c-next 0.1.61 → 0.1.63

package/src/transpiler/output/codegen/helpers/AssignmentValidator.ts

@@ -10,33 +10,21 @@
  * - Array bounds checking
  * - Read-only register members
  * - Callback field assignments
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import TypeValidator from "../TypeValidator.js";
 import EnumAssignmentValidator from "./EnumAssignmentValidator.js";
-import TTypeInfo from "../types/TTypeInfo.js";
+import CodeGenState from "../CodeGenState.js";
+import TypeCheckUtils from "../../../../utils/TypeCheckUtils.js";
 
 /**
- * Dependencies required for assignment validation.
+ * Callbacks required for assignment validation.
+ * These need CodeGenerator context and cannot be replaced with static state.
  */
-interface IAssignmentValidatorDeps {
-  /** TypeValidator for const and callback validation */
-  readonly typeValidator: TypeValidator;
-  /** EnumAssignmentValidator for enum type validation */
-  readonly enumValidator: EnumAssignmentValidator;
-  /** Type registry for looking up variable types */
-  readonly typeRegistry: ReadonlyMap<string, TTypeInfo>;
-  /** Float shadow tracking state for invalidation */
-  readonly floatShadowCurrent: Set<string>;
-  /** Register member access modifiers for read-only checks */
-  readonly registerMemberAccess: ReadonlyMap<string, string>;
-  /** Callback field types for nominal typing validation */
-  readonly callbackFieldTypes: ReadonlyMap<string, string>;
-  /** Check if a type is a known struct */
-  isKnownStruct: (typeName: string) => boolean;
-  /** Check if a type is an integer type */
-  isIntegerType: (typeName: string) => boolean;
+interface IAssignmentValidatorCallbacks {
   /** Get the type of an expression */
   getExpressionType: (ctx: Parser.ExpressionContext) => string | null;
   /** Try to evaluate a constant expression */
@@ -49,12 +37,6 @@ interface IAssignmentValidatorDeps {
  * Coordinates all assignment validations.
  */
 class AssignmentValidator {
-  private readonly deps: IAssignmentValidatorDeps;
-
-  constructor(deps: IAssignmentValidatorDeps) {
-    this.deps = deps;
-  }
-
   /**
    * Validate an assignment target.
    *
@@ -62,87 +44,114 @@ class AssignmentValidator {
    * @param expression - The expression being assigned
    * @param isCompound - Whether this is a compound assignment (+<-, -<-, etc.)
    * @param line - Line number for error messages
+   * @param callbacks - Callbacks to CodeGenerator methods
    */
-  validate(
+  static validate(
     targetCtx: Parser.AssignmentTargetContext,
     expression: Parser.ExpressionContext,
     isCompound: boolean,
     line: number,
+    callbacks: IAssignmentValidatorCallbacks,
   ): void {
-    // Case 1: Simple identifier assignment
-    if (
-      targetCtx.IDENTIFIER() &&
-      !targetCtx.memberAccess() &&
-      !targetCtx.arrayAccess()
-    ) {
-      this.validateSimpleIdentifier(
-        targetCtx.IDENTIFIER()!.getText(),
+    const postfixOps = targetCtx.postfixTargetOp();
+    const baseId = targetCtx.IDENTIFIER()?.getText();
+
+    // Case 1: Simple identifier assignment (no postfix ops)
+    if (baseId && postfixOps.length === 0) {
+      AssignmentValidator.validateSimpleIdentifier(
+        baseId,
         expression,
         isCompound,
+        callbacks,
       );
       return;
     }
 
-    // Case 2: Array element assignment
-    if (targetCtx.arrayAccess()) {
-      this.validateArrayElement(targetCtx.arrayAccess()!, line);
-      return;
+    // Analyze postfix ops for member/array patterns
+    const identifiers: string[] = baseId ? [baseId] : [];
+    const subscriptExprs: Parser.ExpressionContext[] = [];
+
+    for (const op of postfixOps) {
+      if (op.IDENTIFIER()) {
+        identifiers.push(op.IDENTIFIER()!.getText());
+      } else {
+        for (const expr of op.expression()) {
+          subscriptExprs.push(expr);
+        }
+      }
     }
 
-    // Case 3: Member access assignment
-    if (targetCtx.memberAccess()) {
-      this.validateMemberAccess(targetCtx.memberAccess()!, expression);
+    // Case 2: Has subscripts - validate array bounds
+    if (subscriptExprs.length > 0 && identifiers.length > 0) {
+      AssignmentValidator.validateArrayElement(
+        identifiers[0],
+        subscriptExprs,
+        line,
+        callbacks,
+      );
+    }
+
+    // Case 3: Has member access - validate member access
+    if (identifiers.length >= 2) {
+      AssignmentValidator.validateMemberAccess(
+        identifiers,
+        expression,
+        callbacks,
+      );
     }
   }
 
   /**
    * Validate simple identifier assignment.
    */
-  private validateSimpleIdentifier(
+  private static validateSimpleIdentifier(
     id: string,
     expression: Parser.ExpressionContext,
     isCompound: boolean,
+    callbacks: IAssignmentValidatorCallbacks,
   ): void {
     // ADR-013: Validate const assignment
-    const constError = this.deps.typeValidator.checkConstAssignment(id);
+    const constError = TypeValidator.checkConstAssignment(id);
     if (constError) {
       throw new Error(constError);
     }
 
     // Invalidate float shadow when variable is assigned directly
     const shadowName = `__bits_${id}`;
-    this.deps.floatShadowCurrent.delete(shadowName);
+    CodeGenState.floatShadowCurrent.delete(shadowName);
 
-    const targetTypeInfo = this.deps.typeRegistry.get(id);
+    const targetTypeInfo = CodeGenState.typeRegistry.get(id);
     if (!targetTypeInfo) {
       return;
     }
 
-    // ADR-017: Validate enum type assignment
+    // ADR-017: Validate enum assignment for enum-typed variable
     if (targetTypeInfo.isEnum && targetTypeInfo.enumTypeName) {
-      this.deps.enumValidator.validateEnumAssignment(
+      EnumAssignmentValidator.validateEnumAssignment(
         targetTypeInfo.enumTypeName,
         expression,
       );
     }
 
     // ADR-024: Validate integer type conversions
-    if (this.deps.isIntegerType(targetTypeInfo.baseType)) {
+    if (TypeCheckUtils.isInteger(targetTypeInfo.baseType)) {
       try {
-        this.deps.typeValidator.validateIntegerAssignment(
+        TypeValidator.validateIntegerAssignment(
           targetTypeInfo.baseType,
           expression.getText(),
-          this.deps.getExpressionType(expression),
+          callbacks.getExpressionType(expression),
           isCompound,
         );
       } catch (validationError) {
-        const line = expression.start?.line ?? 0;
+        const errorLine = expression.start?.line ?? 0;
         const col = expression.start?.column ?? 0;
         const msg =
           validationError instanceof Error
             ? validationError.message
             : String(validationError);
-        throw new Error(`${line}:${col} ${msg}`, { cause: validationError });
+        throw new Error(`${errorLine}:${col} ${msg}`, {
+          cause: validationError,
+        });
       }
     }
   }
@@ -150,27 +159,27 @@ class AssignmentValidator {
   /**
    * Validate array element assignment.
    */
-  private validateArrayElement(
-    arrayAccessCtx: Parser.ArrayAccessContext,
+  private static validateArrayElement(
+    arrayName: string,
+    subscriptExprs: Parser.ExpressionContext[],
     line: number,
+    callbacks: IAssignmentValidatorCallbacks,
   ): void {
-    const arrayName = arrayAccessCtx.IDENTIFIER().getText();
-
     // ADR-013: Validate const assignment on array
-    const constError = this.deps.typeValidator.checkConstAssignment(arrayName);
+    const constError = TypeValidator.checkConstAssignment(arrayName);
     if (constError) {
       throw new Error(`${constError} (array element)`);
     }
 
     // ADR-036: Compile-time bounds checking
-    const typeInfo = this.deps.typeRegistry.get(arrayName);
+    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
     if (typeInfo?.isArray && typeInfo.arrayDimensions) {
-      this.deps.typeValidator.checkArrayBounds(
+      TypeValidator.checkArrayBounds(
         arrayName,
         typeInfo.arrayDimensions,
-        arrayAccessCtx.expression(),
+        subscriptExprs,
         line,
-        this.deps.tryEvaluateConstant,
+        callbacks.tryEvaluateConstant,
       );
     }
   }
@@ -178,32 +187,28 @@ class AssignmentValidator {
   /**
    * Validate member access assignment.
    */
-  private validateMemberAccess(
-    memberAccessCtx: Parser.MemberAccessContext,
+  private static validateMemberAccess(
+    identifiers: string[],
     expression: Parser.ExpressionContext,
+    callbacks: IAssignmentValidatorCallbacks,
   ): void {
-    const identifiers = memberAccessCtx.IDENTIFIER();
-    if (identifiers.length === 0) {
+    if (identifiers.length < 2) {
       return;
     }
 
-    const rootName = identifiers[0].getText();
+    const rootName = identifiers[0];
+    const memberName = identifiers[1];
 
     // ADR-013: Validate const assignment on struct root
-    const constError = this.deps.typeValidator.checkConstAssignment(rootName);
+    const constError = TypeValidator.checkConstAssignment(rootName);
     if (constError) {
       throw new Error(`${constError} (member access)`);
     }
 
-    if (identifiers.length < 2) {
-      return;
-    }
-
-    const memberName = identifiers[1].getText();
     const fullName = `${rootName}_${memberName}`;
 
     // ADR-013: Check for read-only register members
-    const accessMod = this.deps.registerMemberAccess.get(fullName);
+    const accessMod = CodeGenState.symbols?.registerMemberAccess.get(fullName);
     if (accessMod === "ro") {
       throw new Error(
         `cannot assign to read-only register member '${memberName}' ` +
@@ -212,19 +217,19 @@ class AssignmentValidator {
     }
 
     // ADR-029: Validate callback field assignments with nominal typing
-    const rootTypeInfo = this.deps.typeRegistry.get(rootName);
-    if (rootTypeInfo && this.deps.isKnownStruct(rootTypeInfo.baseType)) {
+    const rootTypeInfo = CodeGenState.typeRegistry.get(rootName);
+    if (rootTypeInfo && CodeGenState.isKnownStruct(rootTypeInfo.baseType)) {
       const structType = rootTypeInfo.baseType;
       const callbackFieldKey = `${structType}.${memberName}`;
       const expectedCallbackType =
-        this.deps.callbackFieldTypes.get(callbackFieldKey);
+        CodeGenState.callbackFieldTypes.get(callbackFieldKey);
 
       if (expectedCallbackType) {
-        this.deps.typeValidator.validateCallbackAssignment(
+        TypeValidator.validateCallbackAssignment(
           expectedCallbackType,
           expression,
           memberName,
-          this.deps.isCallbackTypeUsedAsFieldType,
+          callbacks.isCallbackTypeUsedAsFieldType,
         );
       }
     }

package/src/transpiler/output/codegen/helpers/CppModeHelper.ts

@@ -5,26 +5,16 @@
  *
  * In C mode, struct parameters are passed by pointer (need & for address, * for type).
  * In C++ mode, struct parameters are passed by reference (no & needed, & for type).
+ *
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
-/**
- * Options for C/C++ mode helpers.
- */
-interface CppModeOptions {
-  /** Whether we're generating C++ code */
-  cppMode: boolean;
-}
+import CodeGenState from "../CodeGenState";
 
 /**
- * Helper class for C/C++ mode-specific code generation patterns.
+ * Static helper class for C/C++ mode-specific code generation patterns.
  */
 class CppModeHelper {
-  private readonly cppMode: boolean;
-
-  constructor(options: CppModeOptions) {
-    this.cppMode = options.cppMode;
-  }
-
   /**
    * Get address-of expression for struct parameter passing.
    * C mode: `&expr` (pass pointer to struct)
@@ -33,8 +23,8 @@ class CppModeHelper {
    * @param expr - The expression to potentially wrap
    * @returns The expression with address-of operator in C mode
    */
-  maybeAddressOf(expr: string): string {
-    return this.cppMode ? expr : `&${expr}`;
+  static maybeAddressOf(expr: string): string {
+    return CodeGenState.cppMode ? expr : `&${expr}`;
   }
 
   /**
@@ -45,8 +35,8 @@ class CppModeHelper {
    * @param expr - The expression to potentially dereference
    * @returns The expression with dereference in C mode
    */
-  maybeDereference(expr: string): string {
-    return this.cppMode ? expr : `(*${expr})`;
+  static maybeDereference(expr: string): string {
+    return CodeGenState.cppMode ? expr : `(*${expr})`;
   }
 
   /**
@@ -56,8 +46,8 @@ class CppModeHelper {
    *
    * @returns The type modifier character
    */
-  refOrPtr(): string {
-    return this.cppMode ? "&" : "*";
+  static refOrPtr(): string {
+    return CodeGenState.cppMode ? "&" : "*";
   }
 
   /**
@@ -67,8 +57,8 @@ class CppModeHelper {
    *
    * @returns The member access separator
    */
-  memberSeparator(): string {
-    return this.cppMode ? "." : "->";
+  static memberSeparator(): string {
+    return CodeGenState.cppMode ? "." : "->";
   }
 
   /**
@@ -78,8 +68,8 @@ class CppModeHelper {
    *
    * @returns The null pointer literal
    */
-  nullLiteral(): string {
-    return this.cppMode ? "nullptr" : "NULL";
+  static nullLiteral(): string {
+    return CodeGenState.cppMode ? "nullptr" : "NULL";
   }
 
   /**
@@ -91,8 +81,10 @@ class CppModeHelper {
    * @param expr - The expression to cast
    * @returns The cast expression
    */
-  cast(type: string, expr: string): string {
-    return this.cppMode ? `static_cast<${type}>(${expr})` : `(${type})${expr}`;
+  static cast(type: string, expr: string): string {
+    return CodeGenState.cppMode
+      ? `static_cast<${type}>(${expr})`
+      : `(${type})${expr}`;
   }
 
   /**
@@ -104,8 +96,8 @@ class CppModeHelper {
    * @param expr - The expression to cast
    * @returns The cast expression
    */
-  reinterpretCast(type: string, expr: string): string {
-    return this.cppMode
+  static reinterpretCast(type: string, expr: string): string {
+    return CodeGenState.cppMode
       ? `reinterpret_cast<${type}>(${expr})`
       : `(${type})${expr}`;
   }
@@ -115,8 +107,8 @@ class CppModeHelper {
    *
    * @returns True if generating C++ code
    */
-  isCppMode(): boolean {
-    return this.cppMode;
+  static isCppMode(): boolean {
+    return CodeGenState.cppMode;
   }
 }
 

package/src/transpiler/output/codegen/helpers/EnumAssignmentValidator.ts

@@ -2,6 +2,7 @@
  * EnumAssignmentValidator - Validates enum type assignments
  *
  * Issue #644: Extracted from CodeGenerator to reduce file size.
+ * Static class using CodeGenState for all state access.
  *
  * Validates that enum assignments are type-safe:
  * - Cannot assign different enum types to each other
@@ -11,31 +12,15 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-
-/**
- * Dependencies required for enum validation.
- */
-interface IEnumValidatorDeps {
-  /** Set of known enum type names */
-  knownEnums: ReadonlySet<string>;
-  /** Get the current scope name (for this. prefix handling) */
-  getCurrentScope: () => string | null;
-  /** Get the enum type of an expression */
-  getExpressionEnumType: (ctx: Parser.ExpressionContext) => string | null;
-  /** Check if expression is an integer literal or variable */
-  isIntegerExpression: (ctx: Parser.ExpressionContext) => boolean;
-}
+import CodeGenState from "../CodeGenState.js";
+import EnumTypeResolver from "../resolution/EnumTypeResolver.js";
+import TypeCheckUtils from "../../../../utils/TypeCheckUtils.js";
 
 /**
  * Validates enum type assignments.
+ * All methods are static - uses CodeGenState for state access.
  */
 class EnumAssignmentValidator {
-  private readonly deps: IEnumValidatorDeps;
-
-  constructor(deps: IEnumValidatorDeps) {
-    this.deps = deps;
-  }
-
   /**
    * Validate that an expression can be assigned to an enum-typed variable.
    * Throws an error if the assignment is invalid.
@@ -43,16 +28,16 @@ class EnumAssignmentValidator {
    * @param typeName - The target enum type name
    * @param expression - The expression being assigned
    */
-  validateEnumAssignment(
+  static validateEnumAssignment(
     typeName: string,
     expression: Parser.ExpressionContext,
   ): void {
     // Only validate if the target type is a known enum
-    if (!this.deps.knownEnums.has(typeName)) {
+    if (!CodeGenState.isKnownEnum(typeName)) {
       return;
     }
 
-    const valueEnumType = this.deps.getExpressionEnumType(expression);
+    const valueEnumType = EnumTypeResolver.resolve(expression);
 
     // Check if assigning from a different enum type
     if (valueEnumType && valueEnumType !== typeName) {
@@ -62,53 +47,74 @@ class EnumAssignmentValidator {
     }
 
     // Check if assigning integer to enum
-    if (this.deps.isIntegerExpression(expression)) {
+    if (EnumAssignmentValidator.isIntegerExpression(expression)) {
       throw new Error(`Error: Cannot assign integer to ${typeName} enum`);
     }
 
     // Check if assigning a non-enum, non-integer expression
     if (!valueEnumType) {
       const exprText = expression.getText();
-      this.validateNonEnumExpression(exprText, typeName);
+      EnumAssignmentValidator.validateNonEnumExpression(exprText, typeName);
+    }
+  }
+
+  /**
+   * Check if an expression is an integer literal or integer-typed variable.
+   * Used to detect comparisons between enums and integers.
+   */
+  static isIntegerExpression(
+    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
+  ): boolean {
+    const text = ctx.getText();
+
+    // Check for integer literals
+    if (
+      /^-?\d+$/.exec(text) ||
+      /^0[xX][0-9a-fA-F]+$/.exec(text) ||
+      /^0[bB][01]+$/.exec(text)
+    ) {
+      return true;
+    }
+
+    // Check if it's a variable of primitive integer type
+    if (/^[a-zA-Z_]\w*$/.exec(text)) {
+      const typeInfo = CodeGenState.typeRegistry.get(text);
+      if (
+        typeInfo &&
+        !typeInfo.isEnum &&
+        TypeCheckUtils.isInteger(typeInfo.baseType)
+      ) {
+        return true;
+      }
     }
+
+    return false;
   }
 
   /**
    * Validate a non-enum expression being assigned to an enum type.
    * Handles various access patterns like this.Enum.MEMBER, global.Enum.MEMBER, etc.
    */
-  private validateNonEnumExpression(exprText: string, typeName: string): void {
+  private static validateNonEnumExpression(
+    exprText: string,
+    typeName: string,
+  ): void {
     const parts = exprText.split(".");
-    const currentScope = this.deps.getCurrentScope();
 
     // ADR-016: Handle this.State.MEMBER pattern
-    if (parts[0] === "this" && currentScope && parts.length >= 3) {
-      const scopedEnumName = `${currentScope}_${parts[1]}`;
-      if (scopedEnumName === typeName) {
-        // Valid this.Enum.Member access
-        return;
-      }
-      throw new Error(
-        `Error: Cannot assign non-enum value to ${typeName} enum`,
-      );
+    if (parts[0] === "this" && parts.length >= 3) {
+      EnumAssignmentValidator.validateThisEnumPattern(parts, typeName);
+      return;
     }
 
-    // Issue #478: Handle global.Enum.MEMBER pattern
+    // Issue #478: Handle global.Enum.MEMBER or global.struct.field pattern
     if (parts[0] === "global" && parts.length >= 3) {
-      // global.ECategory.CAT_A -> ECategory
-      const globalEnumName = parts[1];
-      if (globalEnumName === typeName) {
-        // Valid global.Enum.Member access
-        return;
-      }
-      throw new Error(
-        `Error: Cannot assign non-enum value to ${typeName} enum`,
-      );
+      EnumAssignmentValidator.validateGlobalEnumPattern(parts, typeName);
+      return;
     }
 
     // Allow if it's an enum member access of the correct type
     if (exprText.startsWith(typeName + ".")) {
-      // Direct enum member access: EnumType.MEMBER
       return;
     }
 
@@ -124,17 +130,69 @@ class EnumAssignmentValidator {
     }
 
     // parts.length === 2: Could be Enum.Member or variable.field
-    // Allow if it's a known enum type (even if different - getExpressionEnumType would catch mismatches)
+    // Allow if it's a known enum type (even if different - resolve would catch mismatches)
     if (
       parts.length === 2 &&
-      parts[0] !== typeName &&
-      !this.deps.knownEnums.has(parts[0])
+      !EnumAssignmentValidator.isMatchingEnum(parts[0], typeName)
     ) {
       throw new Error(
         `Error: Cannot assign non-enum value to ${typeName} enum`,
       );
     }
   }
+
+  /**
+   * ADR-016: Validate this.Enum.MEMBER pattern inside a scope.
+   */
+  private static validateThisEnumPattern(
+    parts: string[],
+    typeName: string,
+  ): void {
+    if (!CodeGenState.currentScope) {
+      throw new Error(
+        `Error: Cannot assign non-enum value to ${typeName} enum`,
+      );
+    }
+    const scopedEnumName = `${CodeGenState.currentScope}_${parts[1]}`;
+    if (scopedEnumName !== typeName) {
+      throw new Error(
+        `Error: Cannot assign non-enum value to ${typeName} enum`,
+      );
+    }
+  }
+
+  /**
+   * Issue #478: Validate global.X.Y pattern.
+   * If X is a known enum, validates it matches the target type.
+   * If X is not an enum (e.g. struct variable), allows through since
+   * EnumTypeResolver.resolve() with TypeResolver fallback handles the chain.
+   */
+  private static validateGlobalEnumPattern(
+    parts: string[],
+    typeName: string,
+  ): void {
+    const name = parts[1];
+
+    // Not an enum (e.g. struct variable like global.input.field) — allow through
+    // since EnumTypeResolver.resolve() with TypeResolver fallback handles the chain
+    if (!CodeGenState.isKnownEnum(name)) {
+      return;
+    }
+
+    // Known enum that doesn't match target type
+    if (name !== typeName) {
+      throw new Error(
+        `Error: Cannot assign non-enum value to ${typeName} enum`,
+      );
+    }
+  }
+
+  /**
+   * Check if an identifier is the target enum type or a known enum type.
+   */
+  private static isMatchingEnum(identifier: string, typeName: string): boolean {
+    return identifier === typeName || CodeGenState.isKnownEnum(identifier);
+  }
 }
 
 export default EnumAssignmentValidator;