feat: user type registry and enumerated types (CIE 4.1/4.2)

- TypeSystem: TypeKinds Enum/Record/Pointer with per-kind payloads and
  checked accessors; two-pass registration (names first, then definitions
  in source order) so pointer TYPEs may forward-reference; enum-constant
  table owned by TypeSystem so constants stay visible inside function
  bodies across the Symbols save/clear/restore. Dead surface removed
  (Custom kind, Printable/Builtin/ReferenceLike, ElementSize, hasType,
  CodeGen::getNamedValue/getLLVMType).
- Enums are i64 with 0-based ordinals (constexpr kEnumOrdinalBase); all
  type identity is by NAME. New emitCoercedExpr is the single admission
  gate, replacing raw coercion at assignments, array stores, BYVAL args,
  RETURN, IF/WHILE/REPEAT/FOR operands, file operands and builtin args;
  coerceValueToType now hard-errors if a user-kind target reaches it.
- Binary ops with user-kind operands are intercepted ahead of
  ArithmeticHandler ('&'-intercept precedent): same-enum comparisons,
  enum +/- INTEGER (with a runtime range check, [Fatal] on overflow, the
  only site that can manufacture an invalid ordinal), same-name pointer
  =/<>; everything else is a compile error naming the operator.
- OUTPUT is an exhaustive switch over TypeKind (enum prints its ordinal;
  record/pointer are compile errors, also covering whole-array OUTPUT);
  INPUT's silent %lld fallback for unknown kinds is now an explicit error.
- Enum value names are globally reserved: collisions with DECLARE,
  array names, parameters and function names are compile errors.
- RuntimeCheck: emitEnumRangeCheck + emitNullDerefCheck (used by the
  pointer phase) following the emitIndexCheck recipe.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

1 files changed, 10 insertions, 0 deletions

diff --git a/lib/CodeGen/FunctionGen.cc b/lib/CodeGen/FunctionGen.cc
index dc238b5..cbaee75 100644
--- a/lib/CodeGen/FunctionGen.cc
+++ b/lib/CodeGen/FunctionGen.cc
@@ -34,6 +34,10 @@ Type *FunctionGen::getLLVMType(const std::string &TypeName) {
 void FunctionGen::createArgumentAllocas(Function *F, const std::vector<ParamDecl> &Params) {
     Function::arg_iterator AI = F->arg_begin();
     for (const ParamDecl &P : Params) {
+        if (Types.lookupEnumConstant(P.Name)) {
+            fprintf(stderr, "Error: parameter '%s' collides with an enum value\n", P.Name.c_str());
+            HadError = true;
+        }
         Value *ArgVal = &(*AI);
         ++AI;
         ArgVal->setName(P.Name);
@@ -70,6 +74,12 @@ Function *FunctionGen::emitPrototype(PrototypeAST *Proto) {
         HadError = true;
         return nullptr;
     }
+    if (Types.lookupEnumConstant(Proto->getName())) {
+        fprintf(stderr, "Error: '%s' is an enum value and cannot be a FUNCTION/PROCEDURE name\n",
+                Proto->getName().c_str());
+        HadError = true;
+        return nullptr;
+    }
 
     FuncSig Sig;
     Sig.ReturnTypeName = Proto->getReturnType();