c-next 0.1.62 → 0.1.64

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -132,6 +132,12 @@ import AssignmentTargetExtractor from "./helpers/AssignmentTargetExtractor";
 import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 // Phase 5: Cast validation helper for improved testability
 import CastValidator from "./helpers/CastValidator";
+// Global state for code generation (simplifies debugging, eliminates DI complexity)
+import CodeGenState from "./CodeGenState";
+// Extracted resolvers that use CodeGenState
+import SizeofResolver from "./resolution/SizeofResolver";
+import EnumTypeResolver from "./resolution/EnumTypeResolver";
+import ScopeResolver from "./resolution/ScopeResolver";
 
 const {
   generateOverflowHelpers: helperGenerateOverflowHelpers,
@@ -179,25 +185,6 @@ interface FunctionSignature {
   }>;
 }
 
-/**
- * ADR-029: Callback type info for Function-as-Type pattern
- * Each function definition creates both a callable function AND a type
- */
-interface CallbackTypeInfo {
-  functionName: string; // The original function name (also the type name)
-  returnType: string; // Return type for typedef (C type)
-  parameters: Array<{
-    // Parameter info for typedef
-    name: string;
-    type: string; // C type
-    isConst: boolean;
-    isPointer: boolean; // ADR-006: Non-array params become pointers
-    isArray: boolean; // Array parameters pass naturally as pointers
-    arrayDims: string; // Array dimensions if applicable
-  }>;
-  typedefName: string; // e.g., "onReceive_fp"
-}
-
 /**
  * ADR-049: Target platform capabilities for code generation
  */
@@ -249,7 +236,7 @@ interface GeneratorContext {
   indentLevel: number;
   scopeMembers: Map<string, Set<string>>; // scope -> member names (ADR-016)
   currentParameters: Map<string, TParameterInfo>; // ADR-006: track params for pointer semantics
-  // Issue #558: modifiedParameters removed - now uses analysis-phase results from this.modifiedParameters
+  // Issue #558: modifiedParameters removed - now uses analysis-phase results from CodeGenState.modifiedParameters
   localArrays: Set<string>; // ADR-006: track local array variables (no & needed)
   localVariables: Set<string>; // ADR-016: track local variables (allowed as bare identifiers)
   floatBitShadows: Set<string>; // Track declared shadow variables for float bit indexing
@@ -279,9 +266,6 @@ export default class CodeGenerator implements IOrchestrator {
       ["f64", "0.0"],
     ]);
 
-  /** ADR-044: Debug mode generates panic-on-overflow helpers */
-  private debugMode: boolean = false;
-
   private context: GeneratorContext =
     CodeGenerator.createDefaultContext(DEFAULT_TARGET);
 
@@ -318,55 +302,6 @@ export default class CodeGenerator implements IOrchestrator {
     };
   }
 
-  // Issue #60: Symbol fields moved to SymbolCollector
-  // Remaining fields not yet extracted:
-
-  private knownFunctions: Set<string> = new Set(); // Track C-Next defined functions
-
-  private functionSignatures: Map<string, FunctionSignature> = new Map(); // ADR-013: Track function parameter const-ness
-
-  // Bug #8: Track compile-time const values for array size resolution at file scope
-  private constValues: Map<string, number> = new Map(); // constName -> numeric value
-
-  // ADR-029: Callback types registry
-  private callbackTypes: Map<string, CallbackTypeInfo> = new Map(); // funcName -> CallbackTypeInfo
-
-  private callbackFieldTypes: Map<string, string> = new Map(); // "Struct.field" -> callbackTypeName
-
-  // ADR-044: Track which overflow helper types and operations are needed
-  private usedClampOps: Set<string> = new Set(); // Format: "add_u8", "sub_u16", "mul_u32"
-
-  private usedSafeDivOps: Set<string> = new Set(); // ADR-051: Format: "div_u32", "mod_i16"
-
-  // Track required standard library includes
-  private needsStdint: boolean = false; // For u8, u16, u32, u64, i8, i16, i32, i64
-
-  private needsStdbool: boolean = false; // For bool type
-
-  private needsString: boolean = false; // ADR-045: For strlen, strncpy, etc.
-
-  private needsFloatStaticAssert: boolean = false; // For float bit indexing size verification
-
-  private needsISR: boolean = false; // ADR-040: For ISR function pointer type
-
-  private needsCMSIS: boolean = false; // ADR-049/050: For atomic intrinsics and critical sections
-
-  private needsLimits: boolean = false; // Issue #632: For float-to-int clamp casts
-
-  private needsIrqWrappers: boolean = false; // Issue #473: IRQ wrappers for critical sections
-
-  /** External symbol table for cross-language interop */
-  private symbolTable: SymbolTable | null = null;
-
-  /** ADR-010: Source file path for validating includes */
-  private sourcePath: string | null = null;
-
-  /** Issue #349: Include directories for resolving angle-bracket .cnx includes */
-  private includeDirs: string[] = [];
-
-  /** Issue #349: Input directories for calculating relative paths */
-  private inputs: string[] = [];
-
   /** Token stream for comment extraction (ADR-043) */
   private tokenStream: CommonTokenStream | null = null;
 
@@ -374,117 +309,18 @@ export default class CodeGenerator implements IOrchestrator {
 
   private readonly commentFormatter: CommentFormatter = new CommentFormatter();
 
-  /** Type resolution and classification */
-  private typeResolver: TypeResolver | null = null;
+  /** Type resolution and classification - now a static class, no instance needed */
 
   /** Symbol collection - ADR-055: Now uses ISymbolInfo from TSymbolInfoAdapter */
   public symbols: ICodeGenSymbols | null = null;
 
-  /** Type validation - Issue #63: Extracted from CodeGenerator */
-  private typeValidator: TypeValidator | null = null;
-
-  /** Issue #644: String length counter for strlen caching optimization */
-  private stringLengthCounter: StringLengthCounter | null = null;
-
-  /** Issue #644: Member chain analyzer for bit access pattern detection */
-  private memberChainAnalyzer: MemberChainAnalyzer | null = null;
-
-  /** Issue #644: Float bit write helper for shadow variable pattern */
-  private floatBitHelper: FloatBitHelper | null = null;
-
   /** Issue #644: String declaration helper for bounded/array/concat strings */
-  private stringDeclHelper: StringDeclHelper | null = null;
-
-  /** Issue #644: Enum assignment validator for type-safe enum assignments */
-  private enumValidator: EnumAssignmentValidator | null = null;
 
   /** Issue #644: Array initialization helper for size inference and fill-all */
-  private arrayInitHelper: ArrayInitHelper | null = null;
-
-  /** Issue #644: Assignment expected type resolution helper */
-  private expectedTypeResolver: AssignmentExpectedTypeResolver | null = null;
-
-  /** Issue #644: Assignment validation coordinator helper */
-  private assignmentValidator: AssignmentValidator | null = null;
 
   /** Generator registry for modular code generation (ADR-053) */
   private readonly registry: GeneratorRegistry = new GeneratorRegistry();
 
-  /** Issue #250: C++ mode - use temp vars instead of compound literals */
-  private cppMode: boolean = false;
-
-  /** Issue #644: C/C++ mode helper for consolidated mode-specific patterns */
-  private cppHelper: CppModeHelper | null = null;
-
-  /** Issue #250: Pending temp variable declarations for C++ mode */
-  private pendingTempDeclarations: string[] = [];
-
-  /** Issue #250: Counter for unique temp variable names */
-  private tempVarCounter: number = 0;
-
-  /** Issue #517: Pending field assignments for C++ class struct init */
-  private pendingCppClassAssignments: string[] = [];
-
-  /**
-   * Issue #269: Tracks which parameters are modified (directly or transitively)
-   * Map of functionName -> Set of modified parameter names
-   */
-  private readonly modifiedParameters: Map<string, Set<string>> = new Map();
-
-  /**
-   * Issue #579: Tracks which parameters have subscript access (read or write)
-   * These parameters must become pointers to support array access semantics
-   * Map of functionName -> Set of parameter names with subscript access
-   */
-  private readonly subscriptAccessedParameters: Map<string, Set<string>> =
-    new Map();
-
-  /**
-   * Issue #558: Pending cross-file modifications to inject after analyzePassByValue clears.
-   * Set by Pipeline before generate() to share modifications from previously processed files.
-   */
-  private pendingCrossFileModifications: ReadonlyMap<
-    string,
-    ReadonlySet<string>
-  > | null = null;
-
-  /**
-   * Issue #558: Pending cross-file parameter lists to inject for transitive propagation.
-   */
-  private pendingCrossFileParamLists: ReadonlyMap<
-    string,
-    readonly string[]
-  > | null = null;
-
-  /**
-   * Issue #269: Tracks which parameters should pass by value
-   * Map of functionName -> Set of passByValue parameter names
-   */
-  private readonly passByValueParams: Map<string, Set<string>> = new Map();
-
-  /**
-   * Issue #269: Tracks function call relationships for transitive modification analysis
-   * Map of functionName -> Array of {callee, paramIndex, argParamName}
-   * where argParamName is the caller's parameter passed as argument
-   */
-  private readonly functionCallGraph: Map<
-    string,
-    Array<{ callee: string; paramIndex: number; argParamName: string }>
-  > = new Map();
-
-  /**
-   * Issue #269: Tracks function parameter lists for call graph analysis
-   * Map of functionName -> Array of parameter names in order
-   */
-  private readonly functionParamLists: Map<string, string[]> = new Map();
-
-  /**
-   * Issue #369: Tracks whether self-include was added.
-   * When true, skip struct/enum/bitmap definitions in .c file because
-   * they'll be defined in the included header.
-   */
-  private selfIncludeAdded: boolean = false;
-
   /**
    * Initialize generator registry with extracted generators.
    * Called once before code generation begins.
@@ -617,17 +453,17 @@ export default class CodeGenerator implements IOrchestrator {
    */
   getInput(): IGeneratorInput {
     return {
-      symbolTable: this.symbolTable,
-      symbols: this.symbols,
-      typeRegistry: this.context.typeRegistry,
-      functionSignatures: this.functionSignatures,
-      knownFunctions: this.knownFunctions,
-      knownStructs: this.symbols?.knownStructs ?? new Set(),
-      constValues: this.constValues,
-      callbackTypes: this.callbackTypes,
-      callbackFieldTypes: this.callbackFieldTypes,
-      targetCapabilities: this.context.targetCapabilities,
-      debugMode: this.debugMode,
+      symbolTable: CodeGenState.symbolTable,
+      symbols: CodeGenState.symbols,
+      typeRegistry: CodeGenState.typeRegistry,
+      functionSignatures: CodeGenState.functionSignatures,
+      knownFunctions: CodeGenState.knownFunctions,
+      knownStructs: CodeGenState.symbols?.knownStructs ?? new Set(),
+      constValues: CodeGenState.constValues,
+      callbackTypes: CodeGenState.callbackTypes,
+      callbackFieldTypes: CodeGenState.callbackFieldTypes,
+      targetCapabilities: CodeGenState.targetCapabilities,
+      debugMode: CodeGenState.debugMode,
     };
   }
 
@@ -637,20 +473,20 @@ export default class CodeGenerator implements IOrchestrator {
    */
   getState(): IGeneratorState {
     return {
-      currentScope: this.context.currentScope,
-      indentLevel: this.context.indentLevel,
-      inFunctionBody: this.context.inFunctionBody,
-      currentParameters: this.context.currentParameters,
-      localVariables: this.context.localVariables,
-      localArrays: this.context.localArrays,
-      expectedType: this.context.expectedType,
-      selfIncludeAdded: this.selfIncludeAdded, // Issue #369
+      currentScope: CodeGenState.currentScope,
+      indentLevel: CodeGenState.indentLevel,
+      inFunctionBody: CodeGenState.inFunctionBody,
+      currentParameters: CodeGenState.currentParameters,
+      localVariables: CodeGenState.localVariables,
+      localArrays: CodeGenState.localArrays,
+      expectedType: CodeGenState.expectedType,
+      selfIncludeAdded: CodeGenState.selfIncludeAdded, // Issue #369
       // Issue #644: Postfix expression state
-      scopeMembers: this.context.scopeMembers,
-      mainArgsName: this.context.mainArgsName,
-      floatBitShadows: this.context.floatBitShadows,
-      floatShadowCurrent: this.context.floatShadowCurrent,
-      lengthCache: this.context.lengthCache,
+      scopeMembers: CodeGenState.scopeMembers,
+      mainArgsName: CodeGenState.mainArgsName,
+      floatBitShadows: CodeGenState.floatBitShadows,
+      floatShadowCurrent: CodeGenState.floatShadowCurrent,
+      lengthCache: CodeGenState.lengthCache,
     };
   }
 
@@ -671,64 +507,68 @@ export default class CodeGenerator implements IOrchestrator {
 
         // Helper function effects
         case "helper":
-          this.usedClampOps.add(`${effect.operation}_${effect.cnxType}`);
+          CodeGenState.usedClampOps.add(
+            `${effect.operation}_${effect.cnxType}`,
+          );
           break;
         case "safe-div":
-          this.usedSafeDivOps.add(`${effect.operation}_${effect.cnxType}`);
+          CodeGenState.usedSafeDivOps.add(
+            `${effect.operation}_${effect.cnxType}`,
+          );
           break;
 
         // Type registration effects
         case "register-type":
-          this.context.typeRegistry.set(effect.name, effect.info);
+          CodeGenState.typeRegistry.set(effect.name, effect.info);
           break;
         case "register-local":
-          this.context.localVariables.add(effect.name);
+          CodeGenState.localVariables.add(effect.name);
           if (effect.isArray) {
-            this.context.localArrays.add(effect.name);
+            CodeGenState.localArrays.add(effect.name);
           }
           break;
         case "register-const-value":
-          this.constValues.set(effect.name, effect.value);
+          CodeGenState.constValues.set(effect.name, effect.value);
           break;
 
         // Scope effects (ADR-016)
         case "set-scope":
-          this.context.currentScope = effect.name;
+          CodeGenState.currentScope = effect.name;
           break;
 
         // Function body effects
         case "enter-function-body":
-          this.context.inFunctionBody = true;
-          this.context.localVariables.clear();
-          this.context.localArrays.clear();
-          this.context.floatBitShadows.clear();
-          this.context.floatShadowCurrent.clear();
+          CodeGenState.inFunctionBody = true;
+          CodeGenState.localVariables.clear();
+          CodeGenState.localArrays.clear();
+          CodeGenState.floatBitShadows.clear();
+          CodeGenState.floatShadowCurrent.clear();
           break;
         case "exit-function-body":
-          this.context.inFunctionBody = false;
-          this.context.localVariables.clear();
-          this.context.localArrays.clear();
-          this.context.floatBitShadows.clear();
-          this.context.floatShadowCurrent.clear();
+          CodeGenState.inFunctionBody = false;
+          CodeGenState.localVariables.clear();
+          CodeGenState.localArrays.clear();
+          CodeGenState.floatBitShadows.clear();
+          CodeGenState.floatShadowCurrent.clear();
           break;
         case "set-parameters":
-          this.context.currentParameters = new Map(effect.params);
+          CodeGenState.currentParameters = new Map(effect.params);
           break;
         case "clear-parameters":
-          this.context.currentParameters.clear();
+          CodeGenState.currentParameters.clear();
           break;
 
         // Callback effects
         case "register-callback-field":
-          this.callbackFieldTypes.set(effect.key, effect.typeName);
+          CodeGenState.callbackFieldTypes.set(effect.key, effect.typeName);
           break;
 
         // Array initializer effects
         case "set-array-init-count":
-          this.context.lastArrayInitCount = effect.count;
+          CodeGenState.lastArrayInitCount = effect.count;
           break;
         case "set-array-fill-value":
-          this.context.lastArrayFillValue = effect.value;
+          CodeGenState.lastArrayFillValue = effect.value;
           break;
       }
     }
@@ -743,28 +583,28 @@ export default class CodeGenerator implements IOrchestrator {
   private requireInclude(header: TIncludeHeader): void {
     switch (header) {
       case "stdint":
-        this.needsStdint = true;
+        CodeGenState.needsStdint = true;
         break;
       case "stdbool":
-        this.needsStdbool = true;
+        CodeGenState.needsStdbool = true;
         break;
       case "string":
-        this.needsString = true;
+        CodeGenState.needsString = true;
         break;
       case "cmsis":
-        this.needsCMSIS = true;
+        CodeGenState.needsCMSIS = true;
         break;
       case "limits":
-        this.needsLimits = true;
+        CodeGenState.needsLimits = true;
         break;
       case "isr":
-        this.needsISR = true;
+        CodeGenState.needsISR = true;
         break;
       case "float_static_assert":
-        this.needsFloatStaticAssert = true;
+        CodeGenState.needsFloatStaticAssert = true;
         break;
       case "irq_wrappers":
-        this.needsIrqWrappers = true;
+        CodeGenState.needsIrqWrappers = true;
         break;
     }
   }
@@ -773,7 +613,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Get the current indentation string.
    */
   getIndent(): string {
-    return FormatUtils.indent(this.context.indentLevel);
+    return FormatUtils.indent(CodeGenState.indentLevel);
   }
 
   /**
@@ -784,10 +624,10 @@ export default class CodeGenerator implements IOrchestrator {
    */
   resolveIdentifier(identifier: string): string {
     // Check current scope first (inner scope shadows outer)
-    if (this.context.currentScope) {
-      const members = this.context.scopeMembers.get(this.context.currentScope);
+    if (CodeGenState.currentScope) {
+      const members = CodeGenState.scopeMembers.get(CodeGenState.currentScope);
       if (members?.has(identifier)) {
-        return `${this.context.currentScope}_${identifier}`;
+        return `${CodeGenState.currentScope}_${identifier}`;
       }
     }
 
@@ -813,10 +653,10 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.ExpressionContext,
     expectedType: string | null,
   ): string {
-    const savedExpectedType = this.context.expectedType;
-    this.context.expectedType = expectedType;
+    const savedExpectedType = CodeGenState.expectedType;
+    CodeGenState.expectedType = expectedType;
     const result = this.generateExpression(ctx);
-    this.context.expectedType = savedExpectedType;
+    CodeGenState.expectedType = savedExpectedType;
     return result;
   }
 
@@ -833,12 +673,12 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Generate the C type using the helper with dependencies
     return TypeGenerationHelper.generate(ctx, {
-      currentScope: this.context.currentScope,
+      currentScope: CodeGenState.currentScope,
       isCppScopeSymbol: (name) => this.isCppScopeSymbol(name),
       checkNeedsStructKeyword: (name) =>
-        this.symbolTable?.checkNeedsStructKeyword(name) ?? false,
+        CodeGenState.symbolTable?.checkNeedsStructKeyword(name) ?? false,
       validateCrossScopeVisibility: (scope, member) =>
-        this._validateCrossScopeVisibility(scope, member),
+        ScopeResolver.validateCrossScopeVisibility(scope, member),
     });
   }
 
@@ -882,9 +722,9 @@ export default class CodeGenerator implements IOrchestrator {
    */
   isKnownStruct(typeName: string): boolean {
     return SymbolLookupHelper.isKnownStruct(
-      this.symbols?.knownStructs,
-      this.symbols?.knownBitmaps,
-      this.symbolTable,
+      CodeGenState.symbols?.knownStructs,
+      CodeGenState.symbols?.knownBitmaps,
+      CodeGenState.symbolTable,
       typeName,
     );
   }
@@ -894,7 +734,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface - delegates to TypeResolver.
    */
   isFloatType(typeName: string): boolean {
-    return this.typeResolver!.isFloatType(typeName);
+    return TypeResolver.isFloatType(typeName);
   }
 
   /**
@@ -902,7 +742,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface - delegates to TypeResolver.
    */
   isIntegerType(typeName: string): boolean {
-    return this.typeResolver!.isIntegerType(typeName);
+    return TypeResolver.isIntegerType(typeName);
   }
 
   /**
@@ -911,8 +751,8 @@ export default class CodeGenerator implements IOrchestrator {
    */
   isCNextFunction(name: string): boolean {
     return SymbolLookupHelper.isCNextFunctionCombined(
-      this.knownFunctions,
-      this.symbolTable,
+      CodeGenState.knownFunctions,
+      CodeGenState.symbolTable,
       name,
     );
   }
@@ -926,7 +766,7 @@ export default class CodeGenerator implements IOrchestrator {
   getExpressionEnumType(
     ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
   ): string | null {
-    return this._getExpressionEnumType(ctx);
+    return EnumTypeResolver.resolve(ctx);
   }
 
   /**
@@ -955,7 +795,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Check if it's a simple variable of string type
     if (/^[a-zA-Z_]\w*$/.exec(text)) {
-      const typeInfo = this.context.typeRegistry.get(text);
+      const typeInfo = CodeGenState.typeRegistry.get(text);
       if (typeInfo?.isString) {
         return true;
       }
@@ -975,7 +815,7 @@ export default class CodeGenerator implements IOrchestrator {
         return false;
       }
       const arrayName = arrayAccessMatch[1];
-      const typeInfo = this.context.typeRegistry.get(arrayName);
+      const typeInfo = CodeGenState.typeRegistry.get(arrayName);
       // Check if base type is a string type
       if (
         typeInfo?.isString ||
@@ -1017,7 +857,11 @@ export default class CodeGenerator implements IOrchestrator {
     memberName: string,
     isGlobalAccess: boolean = false,
   ): void {
-    this._validateCrossScopeVisibility(scopeName, memberName, isGlobalAccess);
+    ScopeResolver.validateCrossScopeVisibility(
+      scopeName,
+      memberName,
+      isGlobalAccess,
+    );
   }
 
   /**
@@ -1030,7 +874,7 @@ export default class CodeGenerator implements IOrchestrator {
     op: string,
     ctx: Parser.ShiftExpressionContext,
   ): void {
-    this.typeValidator!.validateShiftAmount(leftType, rightExpr, op, ctx);
+    TypeValidator.validateShiftAmount(leftType, rightExpr, op, ctx);
   }
 
   /**
@@ -1038,7 +882,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface - delegates to TypeValidator.
    */
   validateTernaryCondition(condition: Parser.OrExpressionContext): void {
-    this.typeValidator!.validateTernaryCondition(condition);
+    TypeValidator.validateTernaryCondition(condition);
   }
 
   /**
@@ -1049,7 +893,7 @@ export default class CodeGenerator implements IOrchestrator {
     expr: Parser.OrExpressionContext,
     branchName: string,
   ): void {
-    this.typeValidator!.validateNoNestedTernary(expr, branchName);
+    TypeValidator.validateNoNestedTernary(expr, branchName);
   }
 
   // === Function Call Helpers (ADR-053 A2 Phase 5) ===
@@ -1078,7 +922,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface - delegates to TypeValidator.
    */
   isConstValue(name: string): boolean {
-    return this.typeValidator!.isConstValue(name);
+    return TypeValidator.isConstValue(name);
   }
 
   /**
@@ -1086,7 +930,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   getKnownEnums(): ReadonlySet<string> {
-    return this.symbols!.knownEnums;
+    return CodeGenState.symbols!.knownEnums;
   }
 
   /**
@@ -1094,7 +938,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   isCppMode(): boolean {
-    return this.cppMode;
+    return CodeGenState.cppMode;
   }
 
   /**
@@ -1103,7 +947,10 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   isCppEnumClass(typeName: string): boolean {
-    return SymbolLookupHelper.isCppEnumClass(this.symbolTable, typeName);
+    return SymbolLookupHelper.isCppEnumClass(
+      CodeGenState.symbolTable,
+      typeName,
+    );
   }
 
   /**
@@ -1111,7 +958,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   getExpressionType(ctx: Parser.ExpressionContext): string | null {
-    return this.typeResolver!.getExpressionType(ctx);
+    return TypeResolver.getExpressionType(ctx);
   }
 
   /**
@@ -1124,9 +971,9 @@ export default class CodeGenerator implements IOrchestrator {
 
     for (const stmt of ctx.statement()) {
       // Temporarily increment for any nested context that needs absolute level
-      this.context.indentLevel++;
+      CodeGenState.indentLevel++;
       const stmtCode = this.generateStatement(stmt);
-      this.context.indentLevel--;
+      CodeGenState.indentLevel--;
 
       if (stmtCode) {
         // Add one level of indent to each line (relative indentation)
@@ -1147,7 +994,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface (ADR-053 A3).
    */
   validateNoEarlyExits(ctx: Parser.BlockContext): void {
-    this.typeValidator!.validateNoEarlyExits(ctx);
+    TypeValidator.validateNoEarlyExits(ctx);
   }
 
   /**
@@ -1184,9 +1031,9 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #250: Prepend any pending temp variable declarations (C++ mode)
-    if (this.pendingTempDeclarations.length > 0) {
-      const tempDecls = this.pendingTempDeclarations.join("\n");
-      this.pendingTempDeclarations = [];
+    if (CodeGenState.pendingTempDeclarations.length > 0) {
+      const tempDecls = CodeGenState.pendingTempDeclarations.join("\n");
+      CodeGenState.pendingTempDeclarations = [];
       return tempDecls + "\n" + result;
     }
 
@@ -1199,11 +1046,11 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   flushPendingTempDeclarations(): string {
-    if (this.pendingTempDeclarations.length === 0) {
+    if (CodeGenState.pendingTempDeclarations.length === 0) {
       return "";
     }
-    const decls = this.pendingTempDeclarations.join("\n");
-    this.pendingTempDeclarations = [];
+    const decls = CodeGenState.pendingTempDeclarations.join("\n");
+    CodeGenState.pendingTempDeclarations = [];
     return decls;
   }
 
@@ -1212,7 +1059,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface (ADR-053 A3).
    */
   indent(text: string): string {
-    return FormatUtils.indentAllLines(text, this.context.indentLevel);
+    return FormatUtils.indentAllLines(text, CodeGenState.indentLevel);
   }
 
   /**
@@ -1223,7 +1070,7 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.SwitchStatementContext,
     switchExpr: Parser.ExpressionContext,
   ): void {
-    this.typeValidator!.validateSwitchStatement(ctx, switchExpr);
+    TypeValidator.validateSwitchStatement(ctx, switchExpr);
   }
 
   /**
@@ -1231,7 +1078,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface (ADR-053 A3).
    */
   validateDoWhileCondition(ctx: Parser.ExpressionContext): void {
-    this.typeValidator!.validateDoWhileCondition(ctx);
+    TypeValidator.validateDoWhileCondition(ctx);
   }
 
   /**
@@ -1242,7 +1089,7 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.ExpressionContext,
     conditionType: string,
   ): void {
-    this.typeValidator!.validateConditionNoFunctionCall(ctx, conditionType);
+    TypeValidator.validateConditionNoFunctionCall(ctx, conditionType);
   }
 
   /**
@@ -1252,7 +1099,7 @@ export default class CodeGenerator implements IOrchestrator {
   validateTernaryConditionNoFunctionCall(
     ctx: Parser.OrExpressionContext,
   ): void {
-    this.typeValidator!.validateTernaryConditionNoFunctionCall(ctx);
+    TypeValidator.validateTernaryConditionNoFunctionCall(ctx);
   }
 
   /**
@@ -1280,7 +1127,7 @@ export default class CodeGenerator implements IOrchestrator {
       safeIdentifier,
       hasGlobal,
       hasThis,
-      this.context.currentScope,
+      CodeGenState.currentScope,
     );
 
     // No postfix operations - return base
@@ -1321,8 +1168,8 @@ export default class CodeGenerator implements IOrchestrator {
   countStringLengthAccesses(
     ctx: Parser.ExpressionContext,
   ): Map<string, number> {
-    // Issue #644: Delegate to extracted StringLengthCounter
-    return this.stringLengthCounter!.countExpression(ctx);
+    // Issue #644: Delegate to extracted StringLengthCounter (now static)
+    return StringLengthCounter.countExpression(ctx);
   }
 
   /**
@@ -1333,8 +1180,8 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.BlockContext,
     counts: Map<string, number>,
   ): void {
-    // Issue #644: Delegate to extracted StringLengthCounter
-    this.stringLengthCounter!.countBlockInto(ctx, counts);
+    // Issue #644: Delegate to extracted StringLengthCounter (now static)
+    StringLengthCounter.countBlockInto(ctx, counts);
   }
 
   /**
@@ -1354,7 +1201,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     if (declarations.length > 0) {
-      this.context.lengthCache = cache;
+      CodeGenState.lengthCache = cache;
       return declarations.join("\n") + "\n";
     }
 
@@ -1366,7 +1213,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface (ADR-053 A3).
    */
   clearLengthCache(): void {
-    this.context.lengthCache = null;
+    CodeGenState.lengthCache = null;
   }
 
   /**
@@ -1374,7 +1221,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface (ADR-053 A3).
    */
   registerLocalVariable(name: string): void {
-    this.context.localVariables.add(name);
+    CodeGenState.localVariables.add(name);
   }
 
   // === Declaration Generation (ADR-053 A4) ===
@@ -1384,7 +1231,7 @@ export default class CodeGenerator implements IOrchestrator {
     if (dim.expression()) {
       // Bug #8: At file scope, resolve const values to numeric literals
       // because C doesn't allow const variables as array sizes at file scope
-      if (!this.context.inFunctionBody) {
+      if (!CodeGenState.inFunctionBody) {
         const constValue = this.tryEvaluateConstant(dim.expression()!);
         if (constValue !== undefined) {
           return `[${constValue}]`;
@@ -1408,8 +1255,8 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-016: Handle this.Type for scoped types (e.g., this.State -> Motor_State)
     if (ctx.scopedType()) {
       const typeName = ctx.scopedType()!.IDENTIFIER().getText();
-      if (this.context.currentScope) {
-        return `${this.context.currentScope}_${typeName}`;
+      if (CodeGenState.currentScope) {
+        return `${CodeGenState.currentScope}_${typeName}`;
       }
       return typeName;
     }
@@ -1424,6 +1271,16 @@ export default class CodeGenerator implements IOrchestrator {
       const identifierNames = identifiers.map((id) => id.getText());
       return this.resolveQualifiedType(identifierNames);
     }
+    // Handle C-Next array type syntax (Type[N]) - return base type without dimension
+    if (ctx.arrayType()) {
+      const arrayTypeCtx = ctx.arrayType()!;
+      if (arrayTypeCtx.primitiveType()) {
+        return arrayTypeCtx.primitiveType()!.getText();
+      }
+      if (arrayTypeCtx.userType()) {
+        return arrayTypeCtx.userType()!.getText();
+      }
+    }
     if (ctx.userType()) {
       return ctx.userType()!.getText();
     }
@@ -1436,7 +1293,7 @@ export default class CodeGenerator implements IOrchestrator {
   /** Try to evaluate a constant expression at compile time */
   tryEvaluateConstant(ctx: Parser.ExpressionContext): number | undefined {
     return ArrayDimensionParser.parseSingleDimension(ctx, {
-      constValues: this.constValues,
+      constValues: CodeGenState.constValues,
       typeWidths: TYPE_WIDTH,
       isKnownStruct: (name) => this.isKnownStruct(name),
     });
@@ -1457,7 +1314,7 @@ export default class CodeGenerator implements IOrchestrator {
     const resolved = this._resolveTypeNameFromContext(typeCtx);
     if (resolved) {
       // Check if enum
-      if (this.symbols!.knownEnums.has(resolved.name)) {
+      if (CodeGenState.symbols!.knownEnums.has(resolved.name)) {
         return this._getEnumZeroValue(resolved.name, resolved.separator);
       }
       // Check if C++ type needing {} (only for userType, not qualified/scoped/global)
@@ -1531,7 +1388,7 @@ export default class CodeGenerator implements IOrchestrator {
     // Variable - check type registry
     const identifierRegex = /^[a-zA-Z_]\w*$/;
     if (identifierRegex.test(exprCode)) {
-      const typeInfo = this.context.typeRegistry.get(exprCode);
+      const typeInfo = CodeGenState.typeRegistry.get(exprCode);
       if (typeInfo?.isString && typeInfo.stringCapacity !== undefined) {
         return typeInfo.stringCapacity;
       }
@@ -1554,7 +1411,7 @@ export default class CodeGenerator implements IOrchestrator {
 
   /** Check if a callback type is used as a struct field type */
   isCallbackTypeUsedAsFieldType(funcName: string): boolean {
-    for (const callbackType of this.callbackFieldTypes.values()) {
+    for (const callbackType of CodeGenState.callbackFieldTypes.values()) {
       if (callbackType === funcName) {
         return true;
       }
@@ -1565,7 +1422,8 @@ export default class CodeGenerator implements IOrchestrator {
   // === Scope Management (A4) ===
 
   setCurrentScope(name: string | null): void {
-    this.context.currentScope = name;
+    CodeGenState.currentScope = name;
+    CodeGenState.currentScope = name;
   }
 
   /**
@@ -1573,7 +1431,8 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   setCurrentFunctionName(name: string | null): void {
-    this.context.currentFunctionName = name;
+    CodeGenState.currentFunctionName = name;
+    CodeGenState.currentFunctionName = name;
   }
 
   /**
@@ -1581,36 +1440,43 @@ export default class CodeGenerator implements IOrchestrator {
    * Used by return statement generation to set expectedType.
    */
   getCurrentFunctionReturnType(): string | null {
-    return this.context.currentFunctionReturnType;
+    return CodeGenState.currentFunctionReturnType;
   }
 
   /**
    * Issue #477: Set the current function's return type for enum inference.
    */
   setCurrentFunctionReturnType(returnType: string | null): void {
-    this.context.currentFunctionReturnType = returnType;
+    CodeGenState.currentFunctionReturnType = returnType;
+    CodeGenState.currentFunctionReturnType = returnType;
   }
 
   // === Function Body Management (A4) ===
 
   enterFunctionBody(): void {
-    this.context.localVariables.clear();
-    this.context.floatBitShadows.clear();
-    this.context.floatShadowCurrent.clear();
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
     // Issue #558: modifiedParameters tracking removed - uses analysis-phase results
-    this.context.inFunctionBody = true;
+    CodeGenState.inFunctionBody = true;
+    // Sync with CodeGenState
+    CodeGenState.enterFunctionBody();
   }
 
   exitFunctionBody(): void {
-    this.context.inFunctionBody = false;
-    this.context.localVariables.clear();
-    this.context.floatBitShadows.clear();
-    this.context.floatShadowCurrent.clear();
-    this.context.mainArgsName = null;
+    CodeGenState.inFunctionBody = false;
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.mainArgsName = null;
+    // Sync with CodeGenState
+    CodeGenState.exitFunctionBody();
+    CodeGenState.mainArgsName = null;
   }
 
   setMainArgsName(name: string | null): void {
-    this.context.mainArgsName = name;
+    CodeGenState.mainArgsName = name;
+    CodeGenState.mainArgsName = name;
   }
 
   isMainFunctionWithArgs(
@@ -1624,7 +1490,7 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-029: Generate typedef for callback type
    */
   generateCallbackTypedef(funcName: string): string | null {
-    const callbackInfo = this.callbackTypes.get(funcName);
+    const callbackInfo = CodeGenState.callbackTypes.get(funcName);
     if (!callbackInfo) {
       return null;
     }
@@ -1674,8 +1540,8 @@ export default class CodeGenerator implements IOrchestrator {
   updateFunctionParamsAutoConst(functionName: string): void {
     // Collect unmodified parameters for this function using analysis results
     const unmodifiedParams = new Set<string>();
-    const modifiedSet = this.modifiedParameters.get(functionName);
-    for (const [paramName] of this.context.currentParameters) {
+    const modifiedSet = CodeGenState.modifiedParameters.get(functionName);
+    for (const [paramName] of CodeGenState.currentParameters) {
       if (!modifiedSet?.has(paramName)) {
         unmodifiedParams.add(paramName);
       }
@@ -1698,9 +1564,11 @@ export default class CodeGenerator implements IOrchestrator {
    * This is the unified source of truth for modification tracking.
    */
   private _isCurrentParameterModified(paramName: string): boolean {
-    const funcName = this.context.currentFunctionName;
+    const funcName = CodeGenState.currentFunctionName;
     if (!funcName) return false;
-    return this.modifiedParameters.get(funcName)?.has(paramName) ?? false;
+    return (
+      CodeGenState.modifiedParameters.get(funcName)?.has(paramName) ?? false
+    );
   }
 
   /**
@@ -1708,7 +1576,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Returns function name -> set of modified parameter names.
    */
   getModifiedParameters(): ReadonlyMap<string, Set<string>> {
-    return this.modifiedParameters;
+    return CodeGenState.modifiedParameters;
   }
 
   /**
@@ -1719,15 +1587,15 @@ export default class CodeGenerator implements IOrchestrator {
     modifications: ReadonlyMap<string, ReadonlySet<string>>,
     paramLists: ReadonlyMap<string, readonly string[]>,
   ): void {
-    this.pendingCrossFileModifications = modifications;
-    this.pendingCrossFileParamLists = paramLists;
+    CodeGenState.pendingCrossFileModifications = modifications;
+    CodeGenState.pendingCrossFileParamLists = paramLists;
   }
 
   /**
    * Issue #558: Get the function parameter lists for cross-file propagation.
    */
   getFunctionParamLists(): ReadonlyMap<string, string[]> {
-    return this.functionParamLists;
+    return CodeGenState.functionParamLists;
   }
 
   /**
@@ -1750,14 +1618,14 @@ export default class CodeGenerator implements IOrchestrator {
     paramLists: Map<string, string[]>;
   } {
     // Save current state
-    const savedModifications = new Map(this.modifiedParameters);
-    const savedParamLists = new Map(this.functionParamLists);
-    const savedCallGraph = new Map(this.functionCallGraph);
+    const savedModifications = new Map(CodeGenState.modifiedParameters);
+    const savedParamLists = new Map(CodeGenState.functionParamLists);
+    const savedCallGraph = new Map(CodeGenState.functionCallGraph);
 
     // Clear for fresh analysis
-    this.modifiedParameters.clear();
-    this.functionParamLists.clear();
-    this.functionCallGraph.clear();
+    CodeGenState.modifiedParameters.clear();
+    CodeGenState.functionParamLists.clear();
+    CodeGenState.functionCallGraph.clear();
 
     // Issue #565: Inject cross-file data BEFORE collecting this file's info
     this.injectCrossFileData(crossFileModifications, crossFileParamLists);
@@ -1770,9 +1638,9 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #565: Run transitive propagation with full context
     TransitiveModificationPropagator.propagate(
-      this.functionCallGraph,
-      this.functionParamLists,
-      this.modifiedParameters,
+      CodeGenState.functionCallGraph,
+      CodeGenState.functionParamLists,
+      CodeGenState.modifiedParameters,
     );
 
     // Capture results - only include functions NOT from cross-file injection
@@ -1783,9 +1651,9 @@ export default class CodeGenerator implements IOrchestrator {
     const paramLists = this.extractThisFileParamLists(crossFileParamLists);
 
     // Restore previous state
-    this.restoreMapState(this.modifiedParameters, savedModifications);
-    this.restoreMapState(this.functionParamLists, savedParamLists);
-    this.restoreMapState(this.functionCallGraph, savedCallGraph);
+    this.restoreMapState(CodeGenState.modifiedParameters, savedModifications);
+    this.restoreMapState(CodeGenState.functionParamLists, savedParamLists);
+    this.restoreMapState(CodeGenState.functionCallGraph, savedCallGraph);
 
     return { modifications, paramLists };
   }
@@ -1799,12 +1667,12 @@ export default class CodeGenerator implements IOrchestrator {
   ): void {
     if (crossFileModifications) {
       for (const [funcName, params] of crossFileModifications) {
-        this.modifiedParameters.set(funcName, new Set(params));
+        CodeGenState.modifiedParameters.set(funcName, new Set(params));
       }
     }
     if (crossFileParamLists) {
       for (const [funcName, params] of crossFileParamLists) {
-        this.functionParamLists.set(funcName, [...params]);
+        CodeGenState.functionParamLists.set(funcName, [...params]);
       }
     }
   }
@@ -1820,7 +1688,7 @@ export default class CodeGenerator implements IOrchestrator {
   ): Map<string, Set<string>> {
     const modifications = new Map<string, Set<string>>();
 
-    for (const [funcName, params] of this.modifiedParameters) {
+    for (const [funcName, params] of CodeGenState.modifiedParameters) {
       if (!injectedFuncs.has(funcName)) {
         // Function defined in this file - include all its modifications
         modifications.set(funcName, new Set(params));
@@ -1857,7 +1725,10 @@ export default class CodeGenerator implements IOrchestrator {
     crossFileParamLists?: ReadonlyMap<string, readonly string[]>,
   ): Map<string, string[]> {
     return SetMapHelper.copyArrayValues(
-      SetMapHelper.filterExclude(this.functionParamLists, crossFileParamLists),
+      SetMapHelper.filterExclude(
+        CodeGenState.functionParamLists,
+        crossFileParamLists,
+      ),
     );
   }
 
@@ -1882,7 +1753,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Get the parameter name at the given index from the function signature
-    const sig = this.functionSignatures.get(funcName);
+    const sig = CodeGenState.functionSignatures.get(funcName);
     if (!sig || paramIndex >= sig.parameters.length) {
       return false;
     }
@@ -1896,7 +1767,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Issue #268: Check if a name is a parameter of the current function.
    */
   isCurrentParameter(name: string): boolean {
-    return this.context.currentParameters.has(name);
+    return CodeGenState.currentParameters.has(name);
   }
 
   // === Postfix Expression Helpers (Issue #644) ===
@@ -1952,8 +1823,8 @@ export default class CodeGenerator implements IOrchestrator {
    */
   isKnownScope(name: string): boolean {
     return SymbolLookupHelper.isKnownScope(
-      this.symbols?.knownScopes,
-      this.symbolTable,
+      CodeGenState.symbols?.knownScopes,
+      CodeGenState.symbolTable,
       name,
     );
   }
@@ -1965,7 +1836,7 @@ export default class CodeGenerator implements IOrchestrator {
   isCppScopeSymbol(name: string): boolean {
     return CppNamespaceUtils.isCppNamespace(
       name,
-      this.symbolTable ?? undefined,
+      CodeGenState.symbolTable ?? undefined,
     );
   }
 
@@ -1986,8 +1857,8 @@ export default class CodeGenerator implements IOrchestrator {
     fieldName: string,
   ): { type: string; dimensions?: (number | string)[] } | null {
     // First check SymbolTable (C header structs)
-    if (this.symbolTable) {
-      const fieldInfo = this.symbolTable.getStructFieldInfo(
+    if (CodeGenState.symbolTable) {
+      const fieldInfo = CodeGenState.symbolTable.getStructFieldInfo(
         structType,
         fieldName,
       );
@@ -2000,12 +1871,12 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Fall back to local C-Next struct fields
-    const localFields = this.symbols!.structFields.get(structType);
+    const localFields = CodeGenState.symbols!.structFields.get(structType);
     if (localFields) {
       const fieldType = localFields.get(fieldName);
       if (fieldType) {
         const fieldDimensions =
-          this.symbols!.structFieldDimensions.get(structType);
+          CodeGenState.symbols!.structFieldDimensions.get(structType);
         const dimensions = fieldDimensions?.get(fieldName);
         return {
           type: fieldType,
@@ -2027,7 +1898,9 @@ export default class CodeGenerator implements IOrchestrator {
 
     const isArray =
       (fieldInfo.dimensions !== undefined && fieldInfo.dimensions.length > 0) ||
-      (this.symbols!.structFieldArrays.get(structType)?.has(memberName) ??
+      (CodeGenState.symbols!.structFieldArrays.get(structType)?.has(
+        memberName,
+      ) ??
         false);
     const dims = fieldInfo.dimensions?.filter(
       (d): d is number => typeof d === "number",
@@ -2057,7 +1930,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   addPendingTempDeclaration(declaration: string): void {
-    this.pendingTempDeclarations.push(declaration);
+    CodeGenState.pendingTempDeclarations.push(declaration);
   }
 
   /**
@@ -2065,7 +1938,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   registerFloatBitShadow(shadowName: string): void {
-    this.context.floatBitShadows.add(shadowName);
+    CodeGenState.floatBitShadows.add(shadowName);
   }
 
   /**
@@ -2073,7 +1946,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   markFloatShadowCurrent(shadowName: string): void {
-    this.context.floatShadowCurrent.add(shadowName);
+    CodeGenState.floatShadowCurrent.add(shadowName);
   }
 
   /**
@@ -2081,7 +1954,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   hasFloatBitShadow(shadowName: string): boolean {
-    return this.context.floatBitShadows.has(shadowName);
+    return CodeGenState.floatBitShadows.has(shadowName);
   }
 
   /**
@@ -2089,7 +1962,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   isFloatShadowCurrent(shadowName: string): boolean {
-    return this.context.floatShadowCurrent.has(shadowName);
+    return CodeGenState.floatShadowCurrent.has(shadowName);
   }
 
   // ===========================================================================
@@ -2113,11 +1986,11 @@ export default class CodeGenerator implements IOrchestrator {
     return {
       isFloatType: (typeName: string) => this._isFloatType(typeName),
       isKnownPrimitive: (typeName: string) => this._isKnownPrimitive(typeName),
-      knownEnums: this.symbols!.knownEnums,
+      knownEnums: CodeGenState.symbols!.knownEnums,
       isParameterPassByValue: (funcName: string, paramName: string) =>
         this._isParameterPassByValueByName(funcName, paramName),
-      currentFunctionName: this.context.currentFunctionName,
-      maybeDereference: (id: string) => this.cppHelper!.maybeDereference(id),
+      currentFunctionName: CodeGenState.currentFunctionName,
+      maybeDereference: (id: string) => CppModeHelper.maybeDereference(id),
     };
   }
 
@@ -2128,7 +2001,8 @@ export default class CodeGenerator implements IOrchestrator {
   private _buildMemberSeparatorDeps(): IMemberSeparatorDeps {
     return {
       isKnownScope: (name: string) => this.isKnownScope(name),
-      isKnownRegister: (name: string) => this.symbols!.knownRegisters.has(name),
+      isKnownRegister: (name: string) =>
+        CodeGenState.symbols!.knownRegisters.has(name),
       validateCrossScopeVisibility: (scopeName: string, memberName: string) =>
         this.validateCrossScopeVisibility(scopeName, memberName),
       validateRegisterAccess: (
@@ -2137,7 +2011,9 @@ export default class CodeGenerator implements IOrchestrator {
         hasGlobal: boolean,
       ) => this._validateRegisterAccess(registerName, memberName, hasGlobal),
       getStructParamSeparator: () =>
-        memberAccessChain.getStructParamSeparator({ cppMode: this.cppMode }),
+        memberAccessChain.getStructParamSeparator({
+          cppMode: CodeGenState.cppMode,
+        }),
     };
   }
 
@@ -2150,10 +2026,10 @@ export default class CodeGenerator implements IOrchestrator {
     hasGlobal: boolean,
   ): void {
     // Only validate when inside a scope and accessing without global. prefix
-    if (this.context.currentScope && !hasGlobal) {
+    if (CodeGenState.currentScope && !hasGlobal) {
       throw new Error(
         `Error: Use 'global.${registerName}.${memberName}' to access register '${registerName}' ` +
-          `from inside scope '${this.context.currentScope}'`,
+          `from inside scope '${CodeGenState.currentScope}'`,
       );
     }
   }
@@ -2165,7 +2041,10 @@ export default class CodeGenerator implements IOrchestrator {
    * We check for the existence of a constructor symbol (TypeName::ClassName).
    */
   private _isCppClassWithConstructor(typeName: string): boolean {
-    return CppConstructorHelper.hasConstructor(typeName, this.symbolTable);
+    return CppConstructorHelper.hasConstructor(
+      typeName,
+      CodeGenState.symbolTable,
+    );
   }
 
   private foldBooleanToInt(expr: string): string {
@@ -2203,7 +2082,7 @@ export default class CodeGenerator implements IOrchestrator {
    * C++ types with constructors may fail with {0} but work with {}.
    */
   private isCppType(typeName: string): boolean {
-    return SymbolLookupHelper.isCppType(this.symbolTable, typeName);
+    return SymbolLookupHelper.isCppType(CodeGenState.symbolTable, typeName);
   }
 
   /**
@@ -2219,12 +2098,6 @@ export default class CodeGenerator implements IOrchestrator {
     tokenStream?: CommonTokenStream,
     options?: ICodeGeneratorOptions,
   ): string {
-    // Store symbol table for function lookup
-    this.symbolTable = symbolTable ?? null;
-
-    // Initialize options and configuration
-    this.initializeGenerateOptions(options, tokenStream);
-
     // ADR-049: Determine target capabilities with priority: CLI > pragma > default
     const targetCapabilities = this.resolveTargetCapabilities(
       tree,
@@ -2237,16 +2110,22 @@ export default class CodeGenerator implements IOrchestrator {
       this.generatorsInitialized = true;
     }
 
-    // Reset state for fresh generation
+    // Reset state for fresh generation (must be before any state assignments)
     this.resetGeneratorState(targetCapabilities);
 
+    // Initialize options and configuration (after reset)
+    this.initializeGenerateOptions(options, tokenStream);
+
+    // Store symbol table for function lookup (after reset)
+    CodeGenState.symbolTable = symbolTable ?? null;
+
     // ADR-055: Use pre-collected symbolInfo from Pipeline (TSymbolInfoAdapter)
     if (!options?.symbolInfo) {
       throw new Error(
         "symbolInfo is required - use CNextResolver + TSymbolInfoAdapter",
       );
     }
-    this.symbols = options.symbolInfo;
+    CodeGenState.symbols = options.symbolInfo;
 
     // Initialize symbol data and const values
     this.initializeSymbolData();
@@ -2268,15 +2147,14 @@ export default class CodeGenerator implements IOrchestrator {
     options: ICodeGeneratorOptions | undefined,
     tokenStream: CommonTokenStream | undefined,
   ): void {
-    this.debugMode = options?.debugMode ?? false;
-    this.sourcePath = options?.sourcePath ?? null;
-    this.includeDirs = options?.includeDirs ?? [];
-    this.inputs = options?.inputs ?? [];
-    this.cppMode = options?.cppMode ?? false;
-    this.cppHelper = new CppModeHelper({ cppMode: this.cppMode });
-    this.pendingTempDeclarations = [];
-    this.tempVarCounter = 0;
-    this.pendingCppClassAssignments = [];
+    CodeGenState.debugMode = options?.debugMode ?? false;
+    CodeGenState.sourcePath = options?.sourcePath ?? null;
+    CodeGenState.includeDirs = options?.includeDirs ?? [];
+    CodeGenState.inputs = options?.inputs ?? [];
+    CodeGenState.cppMode = options?.cppMode ?? false;
+    CodeGenState.pendingTempDeclarations = [];
+    CodeGenState.tempVarCounter = 0;
+    CodeGenState.pendingCppClassAssignments = [];
 
     this.tokenStream = tokenStream ?? null;
     this.commentExtractor = this.tokenStream
@@ -2288,40 +2166,44 @@ export default class CodeGenerator implements IOrchestrator {
    * Reset all generator state for a fresh generation pass.
    */
   private resetGeneratorState(targetCapabilities: TargetCapabilities): void {
+    // Reset global state first
+    CodeGenState.reset(targetCapabilities);
+
+    // Reset local context (will gradually migrate to CodeGenState)
     this.context = CodeGenerator.createDefaultContext(targetCapabilities);
 
-    this.knownFunctions = new Set();
-    this.functionSignatures = new Map();
-    this.callbackTypes = new Map();
-    this.callbackFieldTypes = new Map();
-    this.usedClampOps = new Set();
-    this.usedSafeDivOps = new Set();
-    this.needsStdint = false;
-    this.needsStdbool = false;
-    this.needsString = false;
-    this.needsFloatStaticAssert = false;
-    this.needsISR = false;
-    this.needsCMSIS = false;
-    this.needsLimits = false;
-    this.needsIrqWrappers = false;
-    this.selfIncludeAdded = false;
+    CodeGenState.knownFunctions = new Set();
+    CodeGenState.functionSignatures = new Map();
+    CodeGenState.callbackTypes = new Map();
+    CodeGenState.callbackFieldTypes = new Map();
+    CodeGenState.usedClampOps = new Set();
+    CodeGenState.usedSafeDivOps = new Set();
+    CodeGenState.needsStdint = false;
+    CodeGenState.needsStdbool = false;
+    CodeGenState.needsString = false;
+    CodeGenState.needsFloatStaticAssert = false;
+    CodeGenState.needsISR = false;
+    CodeGenState.needsCMSIS = false;
+    CodeGenState.needsLimits = false;
+    CodeGenState.needsIrqWrappers = false;
+    CodeGenState.selfIncludeAdded = false;
   }
 
   /**
    * Initialize symbol data and const values from symbol table.
    */
   private initializeSymbolData(): void {
-    const symbols = this.symbols!;
+    const symbols = CodeGenState.symbols!;
 
-    // Copy symbol data to context.scopeMembers
+    // Copy symbol data to CodeGenState.scopeMembers
     for (const [scopeName, members] of symbols.scopeMembers) {
-      this.context.scopeMembers.set(scopeName, new Set(members));
+      CodeGenState.scopeMembers.set(scopeName, new Set(members));
     }
 
     // Issue #461: Initialize constValues from symbol table
-    this.constValues = new Map();
-    if (this.symbolTable) {
-      for (const symbol of this.symbolTable.getAllSymbols()) {
+    CodeGenState.constValues = new Map();
+    if (CodeGenState.symbolTable) {
+      for (const symbol of CodeGenState.symbolTable.getAllSymbols()) {
         if (
           symbol.kind === ESymbolKind.Variable &&
           symbol.isConst &&
@@ -2329,7 +2211,9 @@ export default class CodeGenerator implements IOrchestrator {
         ) {
           const value = LiteralUtils.parseIntegerLiteral(symbol.initialValue);
           if (value !== undefined) {
-            this.constValues.set(symbol.name, value);
+            CodeGenState.constValues.set(symbol.name, value);
+            // Also populate CodeGenState
+            CodeGenState.constValues.set(symbol.name, value);
           }
         }
       }
@@ -2340,141 +2224,9 @@ export default class CodeGenerator implements IOrchestrator {
    * Initialize all helper objects needed for code generation.
    */
   private initializeHelperObjects(tree: Parser.ProgramContext): void {
-    const symbols = this.symbols!;
-
-    // Initialize type resolver
-    this.typeResolver = new TypeResolver({
-      symbols: symbols,
-      symbolTable: this.symbolTable,
-      typeRegistry: this.context.typeRegistry,
-      resolveIdentifier: (name: string) => this.resolveIdentifier(name),
-    });
-
     // Collect function/callback information
     this.collectFunctionsAndCallbacks(tree);
     this.analyzePassByValue(tree);
-
-    // Initialize type validator
-    this.typeValidator = new TypeValidator({
-      symbols: symbols,
-      symbolTable: this.symbolTable,
-      typeRegistry: this.context.typeRegistry,
-      typeResolver: this.typeResolver,
-      callbackTypes: this.callbackTypes,
-      knownFunctions: this.knownFunctions,
-      knownGlobals: new Set(),
-      getCurrentScope: () => this.context.currentScope,
-      getScopeMembers: () => this.context.scopeMembers,
-      getCurrentParameters: () => this.context.currentParameters,
-      getLocalVariables: () => this.context.localVariables,
-      resolveIdentifier: (name: string) => this.resolveIdentifier(name),
-      getExpressionType: (ctx: unknown) =>
-        this.getExpressionType(ctx as Parser.ExpressionContext),
-    });
-
-    // Initialize remaining helpers
-    this.initializeAnalysisHelpers(symbols);
-  }
-
-  /**
-   * Initialize analysis and generation helpers.
-   */
-  private initializeAnalysisHelpers(symbols: ICodeGenSymbols): void {
-    this.stringLengthCounter = new StringLengthCounter((name: string) =>
-      this.context.typeRegistry.get(name),
-    );
-
-    this.memberChainAnalyzer = new MemberChainAnalyzer({
-      typeRegistry: this.context.typeRegistry,
-      structFields: symbols.structFields,
-      structFieldArrays: symbols.structFieldArrays,
-      isKnownStruct: (name) => this.isKnownStruct(name),
-      generateExpression: (ctx) => this.generateExpression(ctx),
-    });
-
-    this.floatBitHelper = new FloatBitHelper({
-      cppMode: this.cppMode,
-      state: {
-        floatBitShadows: this.context.floatBitShadows,
-        floatShadowCurrent: this.context.floatShadowCurrent,
-      },
-      generateBitMask: (width, is64Bit) => this.generateBitMask(width, is64Bit),
-      foldBooleanToInt: (expr) => this.foldBooleanToInt(expr),
-      requireInclude: (header) => this.requireInclude(header),
-    });
-
-    // Create arrayInitState proxy
-    const context = this.context;
-    const arrayInitState = {
-      get lastArrayInitCount() {
-        return context.lastArrayInitCount;
-      },
-      set lastArrayInitCount(val: number) {
-        context.lastArrayInitCount = val;
-      },
-      get lastArrayFillValue() {
-        return context.lastArrayFillValue;
-      },
-      set lastArrayFillValue(val: string | undefined) {
-        context.lastArrayFillValue = val;
-      },
-    };
-
-    this.stringDeclHelper = new StringDeclHelper({
-      typeRegistry: this.context.typeRegistry,
-      getInFunctionBody: () => this.context.inFunctionBody,
-      getIndentLevel: () => this.context.indentLevel,
-      arrayInitState,
-      localArrays: this.context.localArrays,
-      generateExpression: (ctx) => this.generateExpression(ctx),
-      generateArrayDimensions: (dims) => this.generateArrayDimensions(dims),
-      getStringConcatOperands: (ctx) => this._getStringConcatOperands(ctx),
-      getSubstringOperands: (ctx) => this._getSubstringOperands(ctx),
-      getStringLiteralLength: (literal) => StringUtils.literalLength(literal),
-      getStringExprCapacity: (exprCode) => this.getStringExprCapacity(exprCode),
-      requireStringInclude: () => this.requireInclude("string"),
-    });
-
-    this.enumValidator = new EnumAssignmentValidator({
-      knownEnums: symbols.knownEnums,
-      getCurrentScope: () => this.context.currentScope,
-      getExpressionEnumType: (ctx) => this.getExpressionEnumType(ctx),
-      isIntegerExpression: (ctx) => this._isIntegerExpression(ctx),
-    });
-
-    this.arrayInitHelper = new ArrayInitHelper({
-      typeRegistry: this.context.typeRegistry,
-      localArrays: this.context.localArrays,
-      arrayInitState: arrayInitState,
-      getExpectedType: () => this.context.expectedType,
-      setExpectedType: (type) => {
-        this.context.expectedType = type;
-      },
-      generateExpression: (ctx) => this.generateExpression(ctx),
-      getTypeName: (ctx) => this.getTypeName(ctx),
-      generateArrayDimensions: (dims) => this.generateArrayDimensions(dims),
-    });
-
-    this.expectedTypeResolver = new AssignmentExpectedTypeResolver({
-      typeRegistry: this.context.typeRegistry,
-      structFields: symbols.structFields,
-      isKnownStruct: (name) => this.isKnownStruct(name),
-    });
-
-    this.assignmentValidator = new AssignmentValidator({
-      typeValidator: this.typeValidator!,
-      enumValidator: this.enumValidator,
-      typeRegistry: this.context.typeRegistry,
-      floatShadowCurrent: this.context.floatShadowCurrent,
-      registerMemberAccess: symbols.registerMemberAccess,
-      callbackFieldTypes: this.callbackFieldTypes,
-      isKnownStruct: (name) => this.isKnownStruct(name),
-      isIntegerType: (name) => this._isIntegerType(name),
-      getExpressionType: (ctx) => this.getExpressionType(ctx),
-      tryEvaluateConstant: (ctx) => this.tryEvaluateConstant(ctx),
-      isCallbackTypeUsedAsFieldType: (name) =>
-        this.isCallbackTypeUsedAsFieldType(name),
-    });
   }
 
   /**
@@ -2485,9 +2237,7 @@ export default class CodeGenerator implements IOrchestrator {
     options: ICodeGeneratorOptions | undefined,
   ): string {
     const output: string[] = [];
-    const symbols = this.symbols!;
-    const typeValidator = this.typeValidator!;
-
+    const symbols = CodeGenState.symbols!;
     // Add header comment
     output.push(
       "/**",
@@ -2498,16 +2248,17 @@ export default class CodeGenerator implements IOrchestrator {
     );
 
     // Self-include for extern "C" linkage
-    if (symbols.hasPublicSymbols() && this.sourcePath) {
+    if (symbols.hasPublicSymbols() && CodeGenState.sourcePath) {
       const pathToUse =
-        options?.sourceRelativePath || this.sourcePath.replace(/^.*[\\/]/, "");
+        options?.sourceRelativePath ||
+        CodeGenState.sourcePath.replace(/^.*[\\/]/, "");
       const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
       output.push(`#include "${headerName}"`, "");
-      this.selfIncludeAdded = true;
+      CodeGenState.selfIncludeAdded = true;
     }
 
     // Process include directives
-    this.processIncludeDirectives(tree, output, typeValidator);
+    this.processIncludeDirectives(tree, output);
 
     // Process preprocessor directives
     this.processPreprocessorDirectives(tree, output);
@@ -2531,10 +2282,9 @@ export default class CodeGenerator implements IOrchestrator {
   private processIncludeDirectives(
     tree: Parser.ProgramContext,
     output: string[],
-    typeValidator: TypeValidator,
   ): void {
-    const includePaths = this.sourcePath
-      ? IncludeDiscovery.discoverIncludePaths(this.sourcePath)
+    const includePaths = CodeGenState.sourcePath
+      ? IncludeDiscovery.discoverIncludePaths(CodeGenState.sourcePath)
       : [];
 
     for (const includeDir of tree.includeDirective()) {
@@ -2542,14 +2292,14 @@ export default class CodeGenerator implements IOrchestrator {
       output.push(...this.formatLeadingComments(leadingComments));
 
       const lineNumber = includeDir.start?.line ?? 0;
-      typeValidator.validateIncludeNotImplementationFile(
+      TypeValidator.validateIncludeNotImplementationFile(
         includeDir.getText(),
         lineNumber,
       );
-      typeValidator.validateIncludeNoCnxAlternative(
+      TypeValidator.validateIncludeNoCnxAlternative(
         includeDir.getText(),
         lineNumber,
-        this.sourcePath,
+        CodeGenState.sourcePath,
         includePaths,
       );
 
@@ -2607,11 +2357,11 @@ export default class CodeGenerator implements IOrchestrator {
   private addAutoIncludes(output: string[]): void {
     const autoIncludes: string[] = [];
 
-    if (this.needsStdint) autoIncludes.push("#include <stdint.h>");
-    if (this.needsStdbool) autoIncludes.push("#include <stdbool.h>");
-    if (this.needsString) autoIncludes.push("#include <string.h>");
-    if (this.needsCMSIS) autoIncludes.push("#include <cmsis_gcc.h>");
-    if (this.needsLimits) autoIncludes.push("#include <limits.h>");
+    if (CodeGenState.needsStdint) autoIncludes.push("#include <stdint.h>");
+    if (CodeGenState.needsStdbool) autoIncludes.push("#include <stdbool.h>");
+    if (CodeGenState.needsString) autoIncludes.push("#include <string.h>");
+    if (CodeGenState.needsCMSIS) autoIncludes.push("#include <cmsis_gcc.h>");
+    if (CodeGenState.needsLimits) autoIncludes.push("#include <limits.h>");
 
     if (autoIncludes.length > 0) {
       output.push(...autoIncludes, "");
@@ -2622,7 +2372,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Add generated helpers (static asserts, IRQ wrappers, typedefs, etc.).
    */
   private addGeneratedHelpers(output: string[]): void {
-    if (this.needsFloatStaticAssert) {
+    if (CodeGenState.needsFloatStaticAssert) {
       output.push(
         '_Static_assert(sizeof(float) == 4, "Float bit indexing requires 32-bit float");',
         '_Static_assert(sizeof(double) == 8, "Float bit indexing requires 64-bit double");',
@@ -2630,7 +2380,7 @@ export default class CodeGenerator implements IOrchestrator {
       );
     }
 
-    if (this.needsIrqWrappers) {
+    if (CodeGenState.needsIrqWrappers) {
       output.push(
         "// ADR-050: IRQ wrappers to avoid macro collisions with platform headers",
         "static inline void __cnx_disable_irq(void) { __disable_irq(); }",
@@ -2640,7 +2390,7 @@ export default class CodeGenerator implements IOrchestrator {
       );
     }
 
-    if (this.needsISR) {
+    if (CodeGenState.needsISR) {
       output.push(
         "/* ADR-040: ISR function pointer type */",
         "typedef void (*ISR)(void);",
@@ -2722,9 +2472,9 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private transformIncludeDirective(includeText: string): string {
     return includeTransformIncludeDirective(includeText, {
-      sourcePath: this.sourcePath,
-      includeDirs: this.includeDirs,
-      inputs: this.inputs,
+      sourcePath: CodeGenState.sourcePath,
+      includeDirs: CodeGenState.includeDirs,
+      inputs: CodeGenState.inputs,
     });
   }
 
@@ -2765,8 +2515,8 @@ export default class CodeGenerator implements IOrchestrator {
     const scopeName = scopeDecl.IDENTIFIER().getText();
 
     // Set scope context for scoped type resolution (this.Type)
-    const savedScope = this.context.currentScope;
-    this.context.currentScope = scopeName;
+    const savedScope = CodeGenState.currentScope;
+    CodeGenState.currentScope = scopeName;
 
     for (const member of scopeDecl.scopeMember()) {
       if (member.functionDeclaration()) {
@@ -2774,20 +2524,20 @@ export default class CodeGenerator implements IOrchestrator {
         const funcName = funcDecl.IDENTIFIER().getText();
         // Track fully qualified function name: Scope_function
         const fullName = `${scopeName}_${funcName}`;
-        this.knownFunctions.add(fullName);
+        CodeGenState.knownFunctions.add(fullName);
         // ADR-013: Track function signature for const checking
         const sig = this.extractFunctionSignature(
           fullName,
           funcDecl.parameterList() ?? null,
         );
-        this.functionSignatures.set(fullName, sig);
+        CodeGenState.functionSignatures.set(fullName, sig);
         // ADR-029: Register scoped function as callback type
         this.registerCallbackType(fullName, funcDecl);
       }
     }
 
     // Restore previous scope context
-    this.context.currentScope = savedScope;
+    CodeGenState.currentScope = savedScope;
   }
 
   /**
@@ -2803,8 +2553,11 @@ export default class CodeGenerator implements IOrchestrator {
       const fieldType = this.getTypeName(member.type());
 
       // Track callback field types (needed for typedef generation)
-      if (this.callbackTypes.has(fieldType)) {
-        this.callbackFieldTypes.set(`${structName}.${fieldName}`, fieldType);
+      if (CodeGenState.callbackTypes.has(fieldType)) {
+        CodeGenState.callbackFieldTypes.set(
+          `${structName}.${fieldName}`,
+          fieldType,
+        );
       }
     }
   }
@@ -2816,13 +2569,13 @@ export default class CodeGenerator implements IOrchestrator {
     funcDecl: Parser.FunctionDeclarationContext,
   ): void {
     const name = funcDecl.IDENTIFIER().getText();
-    this.knownFunctions.add(name);
+    CodeGenState.knownFunctions.add(name);
     // ADR-013: Track function signature for const checking
     const sig = this.extractFunctionSignature(
       name,
       funcDecl.parameterList() ?? null,
     );
-    this.functionSignatures.set(name, sig);
+    CodeGenState.functionSignatures.set(name, sig);
     // ADR-029: Register function as callback type
     this.registerCallbackType(name, funcDecl);
   }
@@ -2865,7 +2618,7 @@ export default class CodeGenerator implements IOrchestrator {
       const constName = varDecl.IDENTIFIER().getText();
       const constValue = this.tryEvaluateConstant(varDecl.expression()!);
       if (constValue !== undefined) {
-        this.constValues.set(constName, constValue);
+        CodeGenState.constValues.set(constName, constValue);
       }
     }
   }
@@ -2880,8 +2633,8 @@ export default class CodeGenerator implements IOrchestrator {
     const scopeName = scopeDecl.IDENTIFIER().getText();
 
     // Set currentScope so that this.Type references resolve correctly
-    const savedScope = this.context.currentScope;
-    this.context.currentScope = scopeName;
+    const savedScope = CodeGenState.currentScope;
+    this.setCurrentScope(scopeName);
 
     for (const member of scopeDecl.scopeMember()) {
       if (member.variableDeclaration()) {
@@ -2894,7 +2647,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Restore previous scope
-    this.context.currentScope = savedScope;
+    this.setCurrentScope(savedScope);
   }
 
   // Issue #60: collectEnum and collectBitmap methods removed - now in SymbolCollector
@@ -2913,10 +2666,10 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private analyzePassByValue(tree: Parser.ProgramContext): void {
     // Reset analysis state
-    this.modifiedParameters.clear();
-    this.passByValueParams.clear();
-    this.functionCallGraph.clear();
-    this.functionParamLists.clear();
+    CodeGenState.modifiedParameters.clear();
+    CodeGenState.passByValueParams.clear();
+    CodeGenState.functionCallGraph.clear();
+    CodeGenState.functionParamLists.clear();
 
     // Phase 1: Collect function parameter lists and direct modifications
     this.collectFunctionParametersAndModifications(tree);
@@ -2927,9 +2680,9 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Phase 2: Fixed-point iteration for transitive modifications
     TransitiveModificationPropagator.propagate(
-      this.functionCallGraph,
-      this.functionParamLists,
-      this.modifiedParameters,
+      CodeGenState.functionCallGraph,
+      CodeGenState.functionParamLists,
+      CodeGenState.modifiedParameters,
     );
 
     // Phase 3: Determine which parameters can pass by value
@@ -2941,19 +2694,22 @@ export default class CodeGenerator implements IOrchestrator {
    * SonarCloud S3776: Extracted from analyzePassByValue().
    */
   private injectCrossFileModifications(): void {
-    if (!this.pendingCrossFileModifications) return;
+    if (!CodeGenState.pendingCrossFileModifications) return;
 
-    for (const [funcName, params] of this.pendingCrossFileModifications) {
-      const existing = this.modifiedParameters.get(funcName);
+    for (const [
+      funcName,
+      params,
+    ] of CodeGenState.pendingCrossFileModifications) {
+      const existing = CodeGenState.modifiedParameters.get(funcName);
       if (existing) {
         for (const param of params) {
           existing.add(param);
         }
       } else {
-        this.modifiedParameters.set(funcName, new Set(params));
+        CodeGenState.modifiedParameters.set(funcName, new Set(params));
       }
     }
-    this.pendingCrossFileModifications = null; // Clear after use
+    CodeGenState.pendingCrossFileModifications = null; // Clear after use
   }
 
   /**
@@ -2961,14 +2717,14 @@ export default class CodeGenerator implements IOrchestrator {
    * SonarCloud S3776: Extracted from analyzePassByValue().
    */
   private injectCrossFileParamLists(): void {
-    if (!this.pendingCrossFileParamLists) return;
+    if (!CodeGenState.pendingCrossFileParamLists) return;
 
-    for (const [funcName, params] of this.pendingCrossFileParamLists) {
-      if (!this.functionParamLists.has(funcName)) {
-        this.functionParamLists.set(funcName, [...params]);
+    for (const [funcName, params] of CodeGenState.pendingCrossFileParamLists) {
+      if (!CodeGenState.functionParamLists.has(funcName)) {
+        CodeGenState.functionParamLists.set(funcName, [...params]);
       }
     }
-    this.pendingCrossFileParamLists = null; // Clear after use
+    CodeGenState.pendingCrossFileParamLists = null; // Clear after use
   }
 
   /**
@@ -3020,13 +2776,13 @@ export default class CodeGenerator implements IOrchestrator {
         paramNames.push(param.IDENTIFIER().getText());
       }
     }
-    this.functionParamLists.set(funcName, paramNames);
+    CodeGenState.functionParamLists.set(funcName, paramNames);
 
     // Initialize modified set
-    this.modifiedParameters.set(funcName, new Set());
+    CodeGenState.modifiedParameters.set(funcName, new Set());
     // Issue #579: Initialize subscript access tracking
-    this.subscriptAccessedParameters.set(funcName, new Set());
-    this.functionCallGraph.set(funcName, []);
+    CodeGenState.subscriptAccessedParameters.set(funcName, new Set());
+    CodeGenState.functionCallGraph.set(funcName, []);
 
     // Walk the function body to find modifications and calls
     const block = funcDecl.block();
@@ -3102,12 +2858,14 @@ export default class CodeGenerator implements IOrchestrator {
       baseIdentifier &&
       paramSet.has(baseIdentifier)
     ) {
-      this.subscriptAccessedParameters.get(funcName)!.add(baseIdentifier);
+      CodeGenState.subscriptAccessedParameters
+        .get(funcName)!
+        .add(baseIdentifier);
     }
 
     // Track as modified parameter
     if (baseIdentifier && paramSet.has(baseIdentifier)) {
-      this.modifiedParameters.get(funcName)!.add(baseIdentifier);
+      CodeGenState.modifiedParameters.get(funcName)!.add(baseIdentifier);
     }
   }
 
@@ -3179,7 +2937,7 @@ export default class CodeGenerator implements IOrchestrator {
       (op) => op.expression().length === 1,
     );
     if (hasSingleIndexSubscript) {
-      this.subscriptAccessedParameters.get(funcName)!.add(primaryId);
+      CodeGenState.subscriptAccessedParameters.get(funcName)!.add(primaryId);
     }
   }
 
@@ -3356,7 +3114,7 @@ export default class CodeGenerator implements IOrchestrator {
       const arg = args[i];
       const argName = ExpressionUtils.extractIdentifier(arg);
       if (argName && paramSet.has(argName)) {
-        this.functionCallGraph.get(funcName)!.push({
+        CodeGenState.functionCallGraph.get(funcName)!.push({
           callee: calleeName,
           paramIndex: i,
           argParamName: argName,
@@ -3406,12 +3164,13 @@ export default class CodeGenerator implements IOrchestrator {
       "bool",
     ]);
 
-    for (const [funcName, paramNames] of this.functionParamLists) {
+    for (const [funcName, paramNames] of CodeGenState.functionParamLists) {
       const passByValue = new Set<string>();
-      const modified = this.modifiedParameters.get(funcName) ?? new Set();
+      const modified =
+        CodeGenState.modifiedParameters.get(funcName) ?? new Set();
 
       // Get function declaration to check parameter types
-      const funcSig = this.functionSignatures.get(funcName);
+      const funcSig = CodeGenState.functionSignatures.get(funcName);
       if (funcSig) {
         for (let i = 0; i < paramNames.length; i++) {
           const paramName = paramNames[i];
@@ -3429,8 +3188,9 @@ export default class CodeGenerator implements IOrchestrator {
           const isModified = modified.has(paramName);
           // Issue #579: Parameters with subscript access must become pointers
           const hasSubscriptAccess =
-            this.subscriptAccessedParameters.get(funcName)?.has(paramName) ??
-            false;
+            CodeGenState.subscriptAccessedParameters
+              .get(funcName)
+              ?.has(paramName) ?? false;
 
           if (
             isSmallPrimitive &&
@@ -3443,7 +3203,7 @@ export default class CodeGenerator implements IOrchestrator {
         }
       }
 
-      this.passByValueParams.set(funcName, passByValue);
+      CodeGenState.passByValueParams.set(funcName, passByValue);
     }
   }
 
@@ -3455,7 +3215,7 @@ export default class CodeGenerator implements IOrchestrator {
     funcName: string,
     paramName: string,
   ): boolean {
-    const passByValue = this.passByValueParams.get(funcName);
+    const passByValue = CodeGenState.passByValueParams.get(funcName);
     return passByValue?.has(paramName) ?? false;
   }
 
@@ -3464,7 +3224,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface - used by CallExprGenerator.
    */
   isParameterPassByValue(funcName: string, paramIndex: number): boolean {
-    const paramList = this.functionParamLists.get(funcName);
+    const paramList = CodeGenState.functionParamLists.get(funcName);
     if (!paramList || paramIndex < 0 || paramIndex >= paramList.length) {
       return false;
     }
@@ -3478,7 +3238,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Used by HeaderGenerator to ensure header and implementation signatures match.
    */
   getPassByValueParams(): ReadonlyMap<string, ReadonlySet<string>> {
-    return this.passByValueParams;
+    return CodeGenState.passByValueParams;
   }
 
   /**
@@ -3498,7 +3258,7 @@ export default class CodeGenerator implements IOrchestrator {
     arrayDim: Parser.ArrayDimensionContext[] | null,
   ): number[] | undefined {
     return ArrayDimensionParser.parseAllDimensions(arrayDim, {
-      constValues: this.constValues,
+      constValues: CodeGenState.constValues,
       typeWidths: TYPE_WIDTH,
       isKnownStruct: (name) => this.isKnownStruct(name),
     });
@@ -3528,8 +3288,8 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-017: Check if this is an enum type
     if (
       TypeRegistrationUtils.tryRegisterEnumType(
-        this.context.typeRegistry,
-        this.symbols!,
+        CodeGenState.typeRegistry,
+        CodeGenState.symbols!,
         registrationOptions,
       )
     ) {
@@ -3540,8 +3300,8 @@ export default class CodeGenerator implements IOrchestrator {
     const bitmapDimensions = this._evaluateArrayDimensions(arrayDim);
     if (
       TypeRegistrationUtils.tryRegisterBitmapType(
-        this.context.typeRegistry,
-        this.symbols!,
+        CodeGenState.typeRegistry,
+        CodeGenState.symbols!,
         registrationOptions,
         bitmapDimensions,
       )
@@ -3607,7 +3367,7 @@ export default class CodeGenerator implements IOrchestrator {
     const allDims =
       additionalDims.length > 0 ? [...additionalDims, stringDim] : [stringDim];
 
-    this.context.typeRegistry.set(registryName, {
+    CodeGenState.typeRegistry.set(registryName, {
       baseType: "char",
       bitWidth: 8,
       isArray: true,
@@ -3635,8 +3395,8 @@ export default class CodeGenerator implements IOrchestrator {
     if (typeCtx.scopedType()) {
       // ADR-016: Handle this.Type for scoped types (e.g., this.State -> Motor_State)
       const typeName = typeCtx.scopedType()!.IDENTIFIER().getText();
-      return this.context.currentScope
-        ? `${this.context.currentScope}_${typeName}`
+      return CodeGenState.currentScope
+        ? `${CodeGenState.currentScope}_${typeName}`
         : typeName;
     }
 
@@ -3755,6 +3515,42 @@ export default class CodeGenerator implements IOrchestrator {
     if (arrayTypeCtx.primitiveType()) {
       baseType = arrayTypeCtx.primitiveType()!.getText();
       bitWidth = TYPE_WIDTH[baseType] || 0;
+    } else if (arrayTypeCtx.userType()) {
+      // Handle user types (structs, enums, bitmaps)
+      baseType = arrayTypeCtx.userType()!.getText();
+
+      const combinedArrayDim = arrayDim ?? [];
+
+      // Check if this is an enum or bitmap type and delegate to proper registration
+      if (
+        this._tryRegisterEnumOrBitmapType(
+          registryName,
+          baseType,
+          isConst,
+          combinedArrayDim,
+          overflowBehavior,
+          isAtomic,
+        )
+      ) {
+        // Enum/bitmap was registered, but we need to update with arrayType dimension
+        const existingInfo = CodeGenState.typeRegistry.get(registryName);
+        if (existingInfo) {
+          const arrayTypeDim =
+            this._parseArrayTypeDimensionFromCtx(arrayTypeCtx);
+          const allDims = arrayTypeDim
+            ? [arrayTypeDim, ...(existingInfo.arrayDimensions ?? [])]
+            : existingInfo.arrayDimensions;
+          CodeGenState.typeRegistry.set(registryName, {
+            ...existingInfo,
+            isArray: true,
+            arrayDimensions: allDims,
+          });
+        }
+        return;
+      }
+
+      // Not an enum/bitmap - register as regular user type (struct)
+      // bitWidth already initialized to 0, no reassignment needed
     }
 
     if (!baseType) {
@@ -3766,7 +3562,7 @@ export default class CodeGenerator implements IOrchestrator {
       arrayDim,
     );
 
-    this.context.typeRegistry.set(registryName, {
+    CodeGenState.typeRegistry.set(registryName, {
       baseType,
       bitWidth,
       isArray: true,
@@ -3777,6 +3573,20 @@ export default class CodeGenerator implements IOrchestrator {
     });
   }
 
+  /**
+   * Parse array dimension from arrayType context.
+   */
+  private _parseArrayTypeDimensionFromCtx(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+  ): number | undefined {
+    const sizeExpr = arrayTypeCtx.expression();
+    if (!sizeExpr) {
+      return undefined;
+    }
+    const size = Number.parseInt(sizeExpr.getText(), 10);
+    return Number.isNaN(size) ? undefined : size;
+  }
+
   /**
    * Collect array dimensions from array type and additional dimensions
    */
@@ -3824,7 +3634,7 @@ export default class CodeGenerator implements IOrchestrator {
       ? this._evaluateArrayDimensions(arrayDim)
       : undefined;
 
-    this.context.typeRegistry.set(registryName, {
+    CodeGenState.typeRegistry.set(registryName, {
       baseType,
       bitWidth,
       isArray,
@@ -3840,14 +3650,15 @@ export default class CodeGenerator implements IOrchestrator {
    * Part of IOrchestrator interface.
    */
   isStructType(typeName: string): boolean {
-    return this.typeResolver!.isStructType(typeName);
+    return TypeResolver.isStructType(typeName);
   }
 
   /**
    * Set up parameter tracking for a function
    */
   private _setParameters(params: Parser.ParameterListContext | null): void {
-    this.context.currentParameters.clear();
+    CodeGenState.currentParameters.clear();
+    CodeGenState.currentParameters.clear();
     if (!params) return;
 
     for (const param of params.parameter()) {
@@ -3868,7 +3679,7 @@ export default class CodeGenerator implements IOrchestrator {
     const typeInfo = this._resolveParameterTypeInfo(typeCtx);
 
     // Register in currentParameters
-    this.context.currentParameters.set(name, {
+    const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
@@ -3876,7 +3687,8 @@ export default class CodeGenerator implements IOrchestrator {
       isConst,
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,
-    });
+    };
+    CodeGenState.currentParameters.set(name, paramInfo);
 
     // Register in typeRegistry
     this._registerParameterType(name, typeInfo, param, isArray, isConst);
@@ -3905,7 +3717,7 @@ export default class CodeGenerator implements IOrchestrator {
       return {
         typeName,
         isStruct: this.isStructType(typeName),
-        isCallback: this.callbackTypes.has(typeName),
+        isCallback: CodeGenState.callbackTypes.has(typeName),
         isString: false,
       };
     }
@@ -3926,8 +3738,8 @@ export default class CodeGenerator implements IOrchestrator {
 
     if (typeCtx.scopedType()) {
       const localTypeName = typeCtx.scopedType()!.IDENTIFIER().getText();
-      const typeName = this.context.currentScope
-        ? `${this.context.currentScope}_${localTypeName}`
+      const typeName = CodeGenState.currentScope
+        ? `${CodeGenState.currentScope}_${localTypeName}`
         : localTypeName;
       return {
         typeName,
@@ -3978,8 +3790,8 @@ export default class CodeGenerator implements IOrchestrator {
     const { typeName, isString } = typeInfo;
     const typeCtx = param.type();
 
-    const isEnum = this.symbols!.knownEnums.has(typeName);
-    const isBitmap = this.symbols!.knownBitmaps.has(typeName);
+    const isEnum = CodeGenState.symbols!.knownEnums.has(typeName);
+    const isBitmap = CodeGenState.symbols!.knownBitmaps.has(typeName);
 
     // Extract array dimensions
     const arrayDimensions = isArray
@@ -3992,10 +3804,10 @@ export default class CodeGenerator implements IOrchestrator {
       arrayDimensions.push(stringCapacity + 1);
     }
 
-    this.context.typeRegistry.set(name, {
+    const registeredType = {
       baseType: typeName,
       bitWidth: isBitmap
-        ? this.symbols!.bitmapBitWidth.get(typeName) || 0
+        ? CodeGenState.symbols!.bitmapBitWidth.get(typeName) || 0
         : TYPE_WIDTH[typeName] || 0,
       isArray,
       arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
@@ -4007,7 +3819,8 @@ export default class CodeGenerator implements IOrchestrator {
       isString,
       stringCapacity,
       isParameter: true,
-    });
+    };
+    CodeGenState.typeRegistry.set(name, registeredType);
   }
 
   /**
@@ -4028,11 +3841,14 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private _clearParameters(): void {
     // ADR-025: Remove parameter types from typeRegistry
-    for (const name of this.context.currentParameters.keys()) {
-      this.context.typeRegistry.delete(name);
+    for (const name of CodeGenState.currentParameters.keys()) {
+      CodeGenState.typeRegistry.delete(name);
+      CodeGenState.typeRegistry.delete(name);
     }
-    this.context.currentParameters.clear();
-    this.context.localArrays.clear();
+    CodeGenState.currentParameters.clear();
+    CodeGenState.localArrays.clear();
+    CodeGenState.currentParameters.clear();
+    CodeGenState.localArrays.clear();
   }
 
   /**
@@ -4054,7 +3870,10 @@ export default class CodeGenerator implements IOrchestrator {
         const paramName = param.IDENTIFIER().getText();
         const isConst = param.constModifier() !== null;
         // arrayDimension() returns an array (due to grammar's *), so check length
-        const isArray = param.arrayDimension().length > 0;
+        // Also check C-Next style array type (e.g., u8[8] param)
+        const isArray =
+          param.arrayDimension().length > 0 ||
+          param.type().arrayType() !== null;
         const baseType = this.getTypeName(param.type());
         parameters.push({ name: paramName, baseType, isConst, isArray });
       }
@@ -4087,17 +3906,18 @@ export default class CodeGenerator implements IOrchestrator {
         const typeName = this.getTypeName(param.type());
         const isConst = param.constModifier() !== null;
         const dims = param.arrayDimension();
-        const isArray = dims.length > 0;
+        const arrayTypeCtx = param.type().arrayType();
+        const isArray = dims.length > 0 || arrayTypeCtx !== null;
 
         // ADR-029: Check if parameter type is itself a callback type
-        const isCallbackParam = this.callbackTypes.has(typeName);
+        const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
 
         let paramType: string;
         let isPointer: boolean;
 
         if (isCallbackParam) {
           // Use the callback typedef name
-          const cbInfo = this.callbackTypes.get(typeName)!;
+          const cbInfo = CodeGenState.callbackTypes.get(typeName)!;
           paramType = cbInfo.typedefName;
           isPointer = false; // Function pointers are already pointers
         } else {
@@ -4106,9 +3926,14 @@ export default class CodeGenerator implements IOrchestrator {
           isPointer = !isArray;
         }
 
-        const arrayDims = isArray
-          ? dims.map((d) => this.generateArrayDimension(d)).join("")
-          : "";
+        let arrayDims: string;
+        if (dims.length > 0) {
+          arrayDims = dims.map((d) => this.generateArrayDimension(d)).join("");
+        } else if (arrayTypeCtx) {
+          arrayDims = `[${this.generateExpression(arrayTypeCtx.expression())}]`;
+        } else {
+          arrayDims = "";
+        }
         parameters.push({
           name: paramName,
           type: paramType,
@@ -4120,7 +3945,7 @@ export default class CodeGenerator implements IOrchestrator {
       }
     }
 
-    this.callbackTypes.set(name, {
+    CodeGenState.callbackTypes.set(name, {
       functionName: name,
       returnType,
       parameters,
@@ -4134,187 +3959,9 @@ export default class CodeGenerator implements IOrchestrator {
   // Issue #63: validateCallbackAssignment, callbackSignaturesMatch, isConstValue,
   //            and validateBareIdentifierInScope moved to TypeValidator
 
-  /**
-   * ADR-016: Check this.State.IDLE pattern (this.Enum.Member inside scope)
-   */
-  private _getEnumTypeFromThisEnum(parts: string[]): string | null {
-    if (parts[0] !== "this" || !this.context.currentScope || parts.length < 3) {
-      return null;
-    }
-    const enumName = parts[1];
-    const scopedEnumName = `${this.context.currentScope}_${enumName}`;
-    return this.symbols!.knownEnums.has(scopedEnumName) ? scopedEnumName : null;
-  }
-
-  /**
-   * Issue #478: Check global.Enum.Member pattern (global.ECategory.CAT_A)
-   */
-  private _getEnumTypeFromGlobalEnum(parts: string[]): string | null {
-    if (parts[0] !== "global" || parts.length < 3) {
-      return null;
-    }
-    const enumName = parts[1];
-    return this.symbols!.knownEnums.has(enumName) ? enumName : null;
-  }
-
-  /**
-   * ADR-016: Check this.variable pattern (this.varName where varName is enum type)
-   */
-  private _getEnumTypeFromThisVariable(parts: string[]): string | null {
-    if (
-      parts[0] !== "this" ||
-      !this.context.currentScope ||
-      parts.length !== 2
-    ) {
-      return null;
-    }
-    const varName = parts[1];
-    const scopedVarName = `${this.context.currentScope}_${varName}`;
-    const typeInfo = this.context.typeRegistry.get(scopedVarName);
-    if (typeInfo?.isEnum && typeInfo.enumTypeName) {
-      return typeInfo.enumTypeName;
-    }
-    return null;
-  }
-
-  /**
-   * Check scoped enum: Motor.State.IDLE -> Motor_State
-   */
-  private _getEnumTypeFromScopedEnum(parts: string[]): string | null {
-    if (parts.length < 3) {
-      return null;
-    }
-    const scopeName = parts[0];
-    const enumName = parts[1];
-    const scopedEnumName = `${scopeName}_${enumName}`;
-    return this.symbols!.knownEnums.has(scopedEnumName) ? scopedEnumName : null;
-  }
-
-  /**
-   * Check if parts represent an enum member access and return the enum type.
-   */
-  private _getEnumTypeFromMemberAccess(parts: string[]): string | null {
-    if (parts.length < 2) {
-      return null;
-    }
-
-    // ADR-016: Check this.State.IDLE pattern
-    const thisEnumType = this._getEnumTypeFromThisEnum(parts);
-    if (thisEnumType) return thisEnumType;
-
-    // Issue #478: Check global.Enum.Member pattern
-    const globalEnumType = this._getEnumTypeFromGlobalEnum(parts);
-    if (globalEnumType) return globalEnumType;
-
-    // ADR-016: Check this.variable pattern
-    const thisVarType = this._getEnumTypeFromThisVariable(parts);
-    if (thisVarType) return thisVarType;
-
-    // Check simple enum: State.IDLE
-    const possibleEnum = parts[0];
-    if (this.symbols!.knownEnums.has(possibleEnum)) {
-      return possibleEnum;
-    }
-
-    // Check scoped enum: Motor.State.IDLE -> Motor_State
-    return this._getEnumTypeFromScopedEnum(parts);
-  }
-
-  /**
-   * ADR-017: Extract enum type from an expression.
-   * Returns the enum type name if the expression is an enum value, null otherwise.
-   *
-   * Handles:
-   * - Variable of enum type: `currentState` -> 'State'
-   * - Enum member access: `State.IDLE` -> 'State'
-   * - Scoped enum member: `Motor.State.IDLE` -> 'Motor_State'
-   * - ADR-016: this.State.IDLE -> 'CurrentScope_State'
-   * - ADR-016: this.variable -> enum type if variable is of enum type
-   */
-  private _getExpressionEnumType(
-    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
-  ): string | null {
-    const text = ctx.getText();
-
-    // Check if it's a function call returning an enum
-    const enumReturnType = this._getFunctionCallEnumType(text);
-    if (enumReturnType) {
-      return enumReturnType;
-    }
-
-    // Check if it's a simple identifier that's an enum variable
-    if (/^[a-zA-Z_]\w*$/.exec(text)) {
-      const typeInfo = this.context.typeRegistry.get(text);
-      if (typeInfo?.isEnum && typeInfo.enumTypeName) {
-        return typeInfo.enumTypeName;
-      }
-    }
-
-    // Check member access patterns: EnumType.MEMBER, Scope.EnumType.MEMBER, etc.
-    return this._getEnumTypeFromMemberAccess(text.split("."));
-  }
-
-  /**
-   * Check if an expression is a function call returning an enum type.
-   * Handles patterns:
-   * - func() or func(args) - global function
-   * - Scope.method() or Scope.method(args) - scope method from outside
-   * - this.method() or this.method(args) - scope method from inside
-   * - global.func() or global.func(args) - global function from inside scope
-   * - global.Scope.method() or global.Scope.method(args) - scope method from inside another scope
-   */
-  private _getFunctionCallEnumType(text: string): string | null {
-    // Check if this looks like a function call (contains parentheses)
-    const parenIndex = text.indexOf("(");
-    if (parenIndex === -1) {
-      return null;
-    }
-
-    // Extract the function reference (everything before the opening paren)
-    const funcRef = text.substring(0, parenIndex);
-    const parts = funcRef.split(".");
-
-    let fullFuncName: string | null = null;
-
-    if (parts.length === 1) {
-      // Simple function call: func()
-      fullFuncName = parts[0];
-    } else if (parts.length === 2) {
-      if (parts[0] === "this" && this.context.currentScope) {
-        // this.method() -> Scope_method
-        fullFuncName = `${this.context.currentScope}_${parts[1]}`;
-      } else if (parts[0] === "global") {
-        // global.func() -> func
-        fullFuncName = parts[1];
-      } else if (this.symbols!.knownScopes.has(parts[0])) {
-        // Scope.method() -> Scope_method
-        fullFuncName = `${parts[0]}_${parts[1]}`;
-      }
-    } else if (parts.length === 3) {
-      if (parts[0] === "global" && this.symbols!.knownScopes.has(parts[1])) {
-        // global.Scope.method() -> Scope_method
-        fullFuncName = `${parts[1]}_${parts[2]}`;
-      }
-    }
-
-    if (!fullFuncName) {
-      return null;
-    }
-
-    // Look up the function's return type
-    const returnType = this.symbols!.functionReturnTypes.get(fullFuncName);
-    if (!returnType) {
-      return null;
-    }
-
-    // Check if the return type is an enum
-    if (this.symbols!.knownEnums.has(returnType)) {
-      return returnType;
-    }
-
-    return null;
-  }
-
+  // EnumTypeResolver now handles: _getEnumTypeFromThisEnum, _getEnumTypeFromGlobalEnum,
+  // _getEnumTypeFromThisVariable, _getEnumTypeFromScopedEnum, _getEnumTypeFromMemberAccess,
+  // _getExpressionEnumType, _getFunctionCallEnumType
   /**
    * ADR-017: Check if an expression represents an integer literal or numeric type.
    * Used to detect comparisons between enums and integers.
@@ -4322,30 +3969,7 @@ export default class CodeGenerator implements IOrchestrator {
   private _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 = this.context.typeRegistry.get(text);
-      if (
-        typeInfo &&
-        !typeInfo.isEnum &&
-        TypeCheckUtils.isInteger(typeInfo.baseType)
-      ) {
-        return true;
-      }
-    }
-
-    return false;
+    return EnumAssignmentValidator.isIntegerExpression(ctx);
   }
 
   /**
@@ -4358,38 +3982,10 @@ export default class CodeGenerator implements IOrchestrator {
     leftCapacity: number;
     rightCapacity: number;
   } | null {
-    // Navigate to the additive expression level
-    const ternary = ctx.ternaryExpression();
-    if (!ternary) return null;
-
-    const orExprs = ternary.orExpression();
-    if (orExprs.length !== 1) return null;
-
-    const or = orExprs[0];
-    if (or.andExpression().length !== 1) return null;
-
-    const and = or.andExpression()[0];
-    if (and.equalityExpression().length !== 1) return null;
-
-    const eq = and.equalityExpression()[0];
-    if (eq.relationalExpression().length !== 1) return null;
-
-    const rel = eq.relationalExpression()[0];
-    if (rel.bitwiseOrExpression().length !== 1) return null;
-
-    const bor = rel.bitwiseOrExpression()[0];
-    if (bor.bitwiseXorExpression().length !== 1) return null;
-
-    const bxor = bor.bitwiseXorExpression()[0];
-    if (bxor.bitwiseAndExpression().length !== 1) return null;
-
-    const band = bxor.bitwiseAndExpression()[0];
-    if (band.shiftExpression().length !== 1) return null;
-
-    const shift = band.shiftExpression()[0];
-    if (shift.additiveExpression().length !== 1) return null;
-
-    const add = shift.additiveExpression()[0];
+    // Navigate to the additive expression level using ExpressionUnwrapper
+    // Issue #707: Deduplicated expression tree navigation
+    const add = ExpressionUnwrapper.getAdditiveExpression(ctx);
+    if (!add) return null;
     const multExprs = add.multiplicativeExpression();
 
     // Need exactly 2 operands for simple concatenation
@@ -4460,7 +4056,7 @@ export default class CodeGenerator implements IOrchestrator {
     const sourceName = sourceId.getText();
 
     // Check if source is a string type
-    const typeInfo = this.context.typeRegistry.get(sourceName);
+    const typeInfo = CodeGenState.typeRegistry.get(sourceName);
     if (!typeInfo?.isString || typeInfo.stringCapacity === undefined) {
       return null;
     }
@@ -4494,11 +4090,11 @@ export default class CodeGenerator implements IOrchestrator {
   // NOTE: Public isIntegerType and isFloatType moved to IOrchestrator interface (ADR-053 A2)
   // Private versions kept for internal use
   private _isIntegerType(typeName: string): boolean {
-    return this.typeResolver!.isIntegerType(typeName);
+    return TypeResolver.isIntegerType(typeName);
   }
 
   private _isFloatType(typeName: string): boolean {
-    return this.typeResolver!.isFloatType(typeName);
+    return TypeResolver.isFloatType(typeName);
   }
 
   /**
@@ -4509,7 +4105,7 @@ export default class CodeGenerator implements IOrchestrator {
     sourceType: string,
     targetType: string,
   ): boolean {
-    return this.typeResolver!.isNarrowingConversion(sourceType, targetType);
+    return TypeResolver.isNarrowingConversion(sourceType, targetType);
   }
 
   /**
@@ -4517,7 +4113,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Sign change occurs when converting between signed and unsigned types
    */
   private isSignConversion(sourceType: string, targetType: string): boolean {
-    return this.typeResolver!.isSignConversion(sourceType, targetType);
+    return TypeResolver.isSignConversion(sourceType, targetType);
   }
 
   /**
@@ -4530,7 +4126,7 @@ export default class CodeGenerator implements IOrchestrator {
     literalText: string,
     targetType: string,
   ): void {
-    this.typeResolver!.validateLiteralFitsType(literalText, targetType);
+    TypeResolver.validateLiteralFitsType(literalText, targetType);
   }
 
   /**
@@ -4539,7 +4135,7 @@ export default class CodeGenerator implements IOrchestrator {
   private getUnaryExpressionType(
     ctx: Parser.UnaryExpressionContext,
   ): string | null {
-    return this.typeResolver!.getUnaryExpressionType(ctx);
+    return TypeResolver.getUnaryExpressionType(ctx);
   }
 
   /**
@@ -4550,7 +4146,7 @@ export default class CodeGenerator implements IOrchestrator {
     targetType: string,
     sourceType: string | null,
   ): void {
-    this.typeResolver!.validateTypeConversion(targetType, sourceType);
+    TypeResolver.validateTypeConversion(targetType, sourceType);
   }
 
   // Issue #63: checkConstAssignment moved to TypeValidator
@@ -4588,7 +4184,7 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.ExpressionContext,
     targetParamBaseType?: string,
   ): boolean {
-    if (!this.cppMode) return false;
+    if (!CodeGenState.cppMode) return false;
     if (!targetParamBaseType) return false;
 
     const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
@@ -4602,7 +4198,7 @@ export default class CodeGenerator implements IOrchestrator {
     const ops = postfix.postfixOp();
 
     // Case 1: Direct parameter member access (cfg.value)
-    const paramInfo = this.context.currentParameters.get(baseId);
+    const paramInfo = CodeGenState.currentParameters.get(baseId);
     if (paramInfo) {
       return this._needsParamMemberConversion(paramInfo, targetParamBaseType);
     }
@@ -4647,7 +4243,7 @@ export default class CodeGenerator implements IOrchestrator {
     baseId: string,
     targetParamBaseType: string,
   ): boolean {
-    const typeInfo = this.context.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.typeRegistry.get(baseId);
     return CppMemberHelper.needsComplexMemberConversion(
       this._toPostfixOps(ops),
       typeInfo,
@@ -4674,8 +4270,8 @@ export default class CodeGenerator implements IOrchestrator {
     const baseId = primary.IDENTIFIER()?.getText();
     if (!baseId) return false;
 
-    const typeInfo = this.context.typeRegistry.get(baseId);
-    const paramInfo = this.context.currentParameters.get(baseId);
+    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const paramInfo = CodeGenState.currentParameters.get(baseId);
 
     return CppMemberHelper.isStringSubscriptPattern(
       hasPostfixOps,
@@ -4728,11 +4324,11 @@ export default class CodeGenerator implements IOrchestrator {
     // 2. Parameter: currentParameters.get(baseId).baseType
     let structType: string | undefined;
 
-    const typeInfo = this.context.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.typeRegistry.get(baseId);
     if (typeInfo) {
       structType = typeInfo.baseType;
     } else {
-      const paramInfo = this.context.currentParameters.get(baseId);
+      const paramInfo = CodeGenState.currentParameters.get(baseId);
       if (paramInfo) {
         structType = paramInfo.baseType;
       }
@@ -4784,26 +4380,33 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private _handleIdentifierArg(id: string): string {
     // Parameters are already pointers
-    if (this.context.currentParameters.get(id)) {
+    if (CodeGenState.currentParameters.get(id)) {
       return id;
     }
 
     // Local arrays decay to pointers
-    if (this.context.localArrays.has(id)) {
+    if (CodeGenState.localArrays.has(id)) {
+      return id;
+    }
+
+    // Global arrays also decay to pointers (check typeRegistry)
+    // But NOT strings - strings need & (they're char arrays but passed by reference)
+    const typeInfo = CodeGenState.typeRegistry.get(id);
+    if (typeInfo?.isArray && !typeInfo.isString) {
       return id;
     }
 
     // Scope member - may need prefixing
-    if (this.context.currentScope) {
-      const members = this.context.scopeMembers.get(this.context.currentScope);
+    if (CodeGenState.currentScope) {
+      const members = CodeGenState.scopeMembers.get(CodeGenState.currentScope);
       if (members?.has(id)) {
-        const scopedName = `${this.context.currentScope}_${id}`;
-        return this.cppHelper!.maybeAddressOf(scopedName);
+        const scopedName = `${CodeGenState.currentScope}_${id}`;
+        return CppModeHelper.maybeAddressOf(scopedName);
       }
     }
 
     // Local variable - add & (except in C++ mode)
-    return this.cppHelper!.maybeAddressOf(id);
+    return CppModeHelper.maybeAddressOf(id);
   }
 
   /**
@@ -4825,7 +4428,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Generate expression with address-of
     const generatedExpr = this.generateExpression(ctx);
-    const expr = this.cppHelper!.maybeAddressOf(generatedExpr);
+    const expr = CppModeHelper.maybeAddressOf(generatedExpr);
 
     // String subscript access may need cast
     if (lvalueType === "array") {
@@ -4869,10 +4472,12 @@ export default class CodeGenerator implements IOrchestrator {
   ): string {
     const cType = TYPE_MAP[targetParamBaseType] || "uint8_t";
     const value = this.generateExpression(ctx);
-    const tempName = `_cnx_tmp_${this.tempVarCounter++}`;
-    const castExpr = this.cppHelper!.cast(cType, value);
-    this.pendingTempDeclarations.push(`${cType} ${tempName} = ${castExpr};`);
-    return this.cppHelper!.maybeAddressOf(tempName);
+    const tempName = `_cnx_tmp_${CodeGenState.tempVarCounter++}`;
+    const castExpr = CppModeHelper.cast(cType, value);
+    CodeGenState.pendingTempDeclarations.push(
+      `${cType} ${tempName} = ${castExpr};`,
+    );
+    return CppModeHelper.maybeAddressOf(tempName);
   }
 
   /**
@@ -4889,7 +4494,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     const cType = TYPE_MAP[targetParamBaseType];
     if (cType && !["float", "double", "bool", "void"].includes(cType)) {
-      return this.cppHelper!.reinterpretCast(`${cType}*`, expr);
+      return CppModeHelper.reinterpretCast(`${cType}*`, expr);
     }
 
     return expr;
@@ -4914,7 +4519,7 @@ export default class CodeGenerator implements IOrchestrator {
     const value = this.generateExpression(ctx);
 
     // C++ mode: rvalues can bind to const T&
-    if (this.cppMode) {
+    if (CodeGenState.cppMode) {
       return value;
     }
 
@@ -4937,21 +4542,21 @@ export default class CodeGenerator implements IOrchestrator {
     // Issue #369: Skip struct/enum/bitmap definitions when self-include is added
     // These types will be defined in the included header file
     if (ctx.structDeclaration()) {
-      if (this.selfIncludeAdded) {
+      if (CodeGenState.selfIncludeAdded) {
         return ""; // Definition will come from header
       }
       return this.generateStruct(ctx.structDeclaration()!);
     }
     // ADR-017: Handle enum declarations
     if (ctx.enumDeclaration()) {
-      if (this.selfIncludeAdded) {
+      if (CodeGenState.selfIncludeAdded) {
         return ""; // Definition will come from header
       }
       return this.generateEnum(ctx.enumDeclaration()!);
     }
     // ADR-034: Handle bitmap declarations
     if (ctx.bitmapDeclaration()) {
-      if (this.selfIncludeAdded) {
+      if (CodeGenState.selfIncludeAdded) {
         return ""; // Definition will come from header
       }
       return this.generateBitmap(ctx.bitmapDeclaration()!);
@@ -4980,7 +4585,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Fallback to inline implementation (will be removed after migration)
     const name = ctx.IDENTIFIER().getText();
-    this.context.currentScope = name;
+    CodeGenState.currentScope = name;
 
     const lines: string[] = [];
     lines.push(`/* Scope: ${name} */`);
@@ -4990,7 +4595,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     lines.push("");
-    this.context.currentScope = null;
+    CodeGenState.currentScope = null;
     return lines.join("\n");
   }
 
@@ -5046,10 +4651,18 @@ export default class CodeGenerator implements IOrchestrator {
     const prefix = isPrivate ? "static " : "";
 
     const arrayDims = varDecl.arrayDimension();
-    const isArray = arrayDims.length > 0;
+    const hasArrayTypeSyntax = varDecl.type().arrayType() !== null;
+    const isArray = arrayDims.length > 0 || hasArrayTypeSyntax;
 
     let decl = `${prefix}${type} ${fullName}`;
-    if (isArray) {
+
+    // Handle arrayType dimension (C-Next style: u8[16] data)
+    if (hasArrayTypeSyntax) {
+      decl += this._getArrayTypeDimension(varDecl.type());
+    }
+
+    // Handle arrayDimension (C-style or additional dimensions)
+    if (arrayDims.length > 0) {
       decl += this.generateArrayDimensions(arrayDims);
     }
 
@@ -5091,9 +4704,9 @@ export default class CodeGenerator implements IOrchestrator {
     const prefix = isPrivate ? "static " : "";
 
     // Issue #269: Set current function name for pass-by-value lookup
-    this.context.currentFunctionName = fullName;
+    CodeGenState.currentFunctionName = fullName;
     // Issue #477: Set return type for enum inference in return statements
-    this.context.currentFunctionReturnType = funcDecl.type().getText();
+    CodeGenState.currentFunctionReturnType = funcDecl.type().getText();
 
     // Track parameters for ADR-006 pointer semantics
     this._setParameters(funcDecl.parameterList() ?? null);
@@ -5114,8 +4727,8 @@ export default class CodeGenerator implements IOrchestrator {
 
     // ADR-016: Exit function body context
     this.exitFunctionBody();
-    this.context.currentFunctionName = null;
-    this.context.currentFunctionReturnType = null;
+    CodeGenState.currentFunctionName = null;
+    CodeGenState.currentFunctionReturnType = null;
     this._clearParameters();
 
     lines.push("", `${prefix}${returnType} ${fullName}(${params}) ${body}`);
@@ -5198,155 +4811,14 @@ export default class CodeGenerator implements IOrchestrator {
   // ========================================================================
 
   private generateStruct(ctx: Parser.StructDeclarationContext): string {
-    // ADR-053: Check registry for extracted generator
+    // ADR-053: Delegates to extracted StructGenerator
     const generator = this.registry.getDeclaration("struct");
-    if (generator) {
-      const result = generator(ctx, this.getInput(), this.getState(), this);
-      this.applyEffects(result.effects);
-      return result.code;
-    }
-
-    // Fallback to inline implementation (will be removed after migration)
-    const name = ctx.IDENTIFIER().getText();
-    const callbackFields: Array<{ fieldName: string; callbackType: string }> =
-      [];
-
-    const lines: string[] = [];
-    lines.push(`typedef struct {`);
-
-    for (const member of ctx.structMember()) {
-      const fieldLine = this.generateStructFieldLine(
-        name,
-        member,
-        callbackFields,
-      );
-      lines.push(fieldLine);
-    }
-
-    lines.push(`} ${name};`, "");
-
-    // ADR-029: Generate init function if struct has callback fields
-    if (callbackFields.length > 0) {
-      lines.push(this.generateStructInitFunction(name, callbackFields));
-    }
-
-    return lines.join("\n");
-  }
-
-  /**
-   * Generate a single struct field line.
-   * SonarCloud S3776: Extracted from generateStruct().
-   */
-  private generateStructFieldLine(
-    structName: string,
-    member: Parser.StructMemberContext,
-    callbackFields: Array<{ fieldName: string; callbackType: string }>,
-  ): string {
-    const fieldName = member.IDENTIFIER().getText();
-    const typeName = this.getTypeName(member.type());
-    const arrayDims = member.arrayDimension();
-    const isArray = arrayDims.length > 0;
-
-    // ADR-029: Check if this is a callback type field
-    if (this.callbackTypes.has(typeName)) {
-      return this.generateCallbackFieldLine(
-        structName,
-        fieldName,
-        typeName,
-        arrayDims,
-        isArray,
-        callbackFields,
-      );
-    }
-
-    return this.generateRegularFieldLine(
-      structName,
-      fieldName,
-      member,
-      arrayDims,
-      isArray,
-    );
-  }
-
-  /**
-   * Generate a callback type field line.
-   * SonarCloud S3776: Extracted from generateStruct().
-   */
-  private generateCallbackFieldLine(
-    structName: string,
-    fieldName: string,
-    typeName: string,
-    arrayDims: Parser.ArrayDimensionContext[],
-    isArray: boolean,
-    callbackFields: Array<{ fieldName: string; callbackType: string }>,
-  ): string {
-    const callbackInfo = this.callbackTypes.get(typeName)!;
-    callbackFields.push({ fieldName, callbackType: typeName });
-
-    // Track callback field for assignment validation
-    this.callbackFieldTypes.set(`${structName}.${fieldName}`, typeName);
-
-    if (isArray) {
-      const dims = this.generateArrayDimensions(arrayDims);
-      return `    ${callbackInfo.typedefName} ${fieldName}${dims};`;
-    }
-    return `    ${callbackInfo.typedefName} ${fieldName};`;
-  }
-
-  /**
-   * Generate a regular (non-callback) field line.
-   * SonarCloud S3776: Extracted from generateStruct().
-   */
-  private generateRegularFieldLine(
-    structName: string,
-    fieldName: string,
-    member: Parser.StructMemberContext,
-    arrayDims: Parser.ArrayDimensionContext[],
-    isArray: boolean,
-  ): string {
-    const type = this.generateType(member.type());
-
-    // Check if we have tracked dimensions for this field
-    const trackedDimensions =
-      this.symbols!.structFieldDimensions.get(structName);
-    const fieldDims = trackedDimensions?.get(fieldName);
-
-    if (fieldDims && fieldDims.length > 0) {
-      const dimsStr = fieldDims.map((d) => `[${d}]`).join("");
-      return `    ${type} ${fieldName}${dimsStr};`;
-    }
-
-    if (isArray) {
-      const dims = this.generateArrayDimensions(arrayDims);
-      return `    ${type} ${fieldName}${dims};`;
-    }
-
-    return `    ${type} ${fieldName};`;
-  }
-
-  /**
-   * ADR-029: Generate init function for structs with callback fields
-   * Sets all callback fields to their default functions
-   */
-  private generateStructInitFunction(
-    structName: string,
-    callbackFields: Array<{ fieldName: string; callbackType: string }>,
-  ): string {
-    const lines: string[] = [];
-    lines.push(
-      `${structName} ${structName}_init(void) {`,
-      `    return (${structName}){`,
-    );
-
-    for (let i = 0; i < callbackFields.length; i++) {
-      const field = callbackFields[i];
-      const comma = i < callbackFields.length - 1 ? "," : "";
-      lines.push(`        .${field.fieldName} = ${field.callbackType}${comma}`);
+    if (!generator) {
+      throw new Error("Error: struct generator not registered");
     }
-
-    lines.push(`    };`, `}`, "");
-
-    return lines.join("\n");
+    const result = generator(ctx, this.getInput(), this.getState(), this);
+    this.applyEffects(result.effects);
+    return result.code;
   }
 
   // ========================================================================
@@ -5358,44 +4830,16 @@ export default class CodeGenerator implements IOrchestrator {
    * enum State { IDLE, RUNNING, ERROR <- 255 }
    * -> typedef enum { State_IDLE = 0, State_RUNNING = 1, State_ERROR = 255 } State;
    *
-   * ADR-053: Delegates to extracted generator if registered.
+   * ADR-053: Delegates to extracted EnumGenerator.
    */
   private generateEnum(ctx: Parser.EnumDeclarationContext): string {
-    // ADR-053: Check registry for extracted generator
     const generator = this.registry.getDeclaration("enum");
-    if (generator) {
-      const result = generator(ctx, this.getInput(), this.getState(), this);
-      this.applyEffects(result.effects);
-      return result.code;
-    }
-
-    // Fallback to inline implementation (will be removed after migration)
-    const name = ctx.IDENTIFIER().getText();
-    const prefix = this.context.currentScope
-      ? `${this.context.currentScope}_`
-      : "";
-    const fullName = `${prefix}${name}`;
-
-    const lines: string[] = [];
-    lines.push(`typedef enum {`);
-
-    const members = this.symbols!.enumMembers.get(fullName);
-    if (!members) {
-      throw new Error(`Error: Enum ${fullName} not found in registry`);
-    }
-
-    const memberEntries = Array.from(members.entries());
-
-    for (let i = 0; i < memberEntries.length; i++) {
-      const [memberName, value] = memberEntries[i];
-      const fullMemberName = `${fullName}_${memberName}`;
-      const comma = i < memberEntries.length - 1 ? "," : "";
-      lines.push(`    ${fullMemberName} = ${value}${comma}`);
+    if (!generator) {
+      throw new Error("Error: enum generator not registered");
     }
-
-    lines.push(`} ${fullName};`, "");
-
-    return lines.join("\n");
+    const result = generator(ctx, this.getInput(), this.getState(), this);
+    this.applyEffects(result.effects);
+    return result.code;
   }
 
   /**
@@ -5416,12 +4860,12 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Fallback to inline implementation (will be removed after migration)
     const name = ctx.IDENTIFIER().getText();
-    const prefix = this.context.currentScope
-      ? `${this.context.currentScope}_`
+    const prefix = CodeGenState.currentScope
+      ? `${CodeGenState.currentScope}_`
       : "";
     const fullName = `${prefix}${name}`;
 
-    const backingType = this.symbols!.bitmapBackingType.get(fullName);
+    const backingType = CodeGenState.symbols!.bitmapBackingType.get(fullName);
     if (!backingType) {
       throw new Error(`Error: Bitmap ${fullName} not found in registry`);
     }
@@ -5433,7 +4877,7 @@ export default class CodeGenerator implements IOrchestrator {
     // Generate comment with field layout
     lines.push(`/* Bitmap: ${fullName} */`);
 
-    const fields = this.symbols!.bitmapFields.get(fullName);
+    const fields = CodeGenState.symbols!.bitmapFields.get(fullName);
     if (fields) {
       lines.push("/* Fields:");
       for (const [fieldName, info] of fields.entries()) {
@@ -5467,7 +4911,7 @@ export default class CodeGenerator implements IOrchestrator {
     // Reject redundant type in struct initializer
     // Wrong: const Point p <- Point { x: 0 };
     // Right: const Point p <- { x: 0 };
-    if (ctx.IDENTIFIER() && this.context.expectedType) {
+    if (ctx.IDENTIFIER() && CodeGenState.expectedType) {
       const explicitType = ctx.IDENTIFIER()!.getText();
       throw new Error(
         `Redundant type '${explicitType}' in struct initializer. ` +
@@ -5479,8 +4923,8 @@ export default class CodeGenerator implements IOrchestrator {
     let typeName: string;
     if (ctx.IDENTIFIER()) {
       typeName = ctx.IDENTIFIER()!.getText();
-    } else if (this.context.expectedType) {
-      typeName = this.context.expectedType;
+    } else if (CodeGenState.expectedType) {
+      typeName = CodeGenState.expectedType;
     } else {
       // This should not happen in valid code
       throw new Error(
@@ -5495,7 +4939,7 @@ export default class CodeGenerator implements IOrchestrator {
     // so designated initializers { .field = value } don't work with them.
     // We check the SymbolTable for a constructor symbol (TypeName::TypeName).
     const isCppClass =
-      this.cppMode && this._isCppClassWithConstructor(typeName);
+      CodeGenState.cppMode && this._isCppClassWithConstructor(typeName);
 
     if (!fieldList) {
       // Empty initializer: Point {} -> (Point){ 0 } or {} for C++ classes
@@ -5504,13 +4948,13 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Get field type info for nested initializers
     // Issue #502: Check both local struct fields and SymbolTable (for C++ header structs)
-    const structFieldTypes = this.symbols!.structFields.get(typeName);
+    const structFieldTypes = CodeGenState.symbols!.structFields.get(typeName);
 
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
 
       // Set expected type for nested initializers
-      const savedExpectedType = this.context.expectedType;
+      const savedExpectedType = CodeGenState.expectedType;
       if (structFieldTypes?.has(fieldName)) {
         // Issue #502: Convert underscore format to correct output format
         // C-Next struct fields may store C++ types with _ separator (e.g., SeaDash_Parse_ParseResult)
@@ -5524,13 +4968,13 @@ export default class CodeGenerator implements IOrchestrator {
             fieldType = parts.join("::");
           }
         }
-        this.context.expectedType = fieldType;
+        CodeGenState.expectedType = fieldType;
       }
 
       const value = this.generateExpression(field.expression());
 
       // Restore expected type
-      this.context.expectedType = savedExpectedType;
+      CodeGenState.expectedType = savedExpectedType;
 
       return { fieldName, value };
     });
@@ -5538,7 +4982,9 @@ export default class CodeGenerator implements IOrchestrator {
     // Issue #517: For C++ classes, store assignments for later and return {}
     if (isCppClass) {
       for (const { fieldName, value } of fields) {
-        this.pendingCppClassAssignments.push(`${fieldName} = ${value};`);
+        CodeGenState.pendingCppClassAssignments.push(
+          `${fieldName} = ${value};`,
+        );
       }
       return "{}";
     }
@@ -5562,8 +5008,8 @@ export default class CodeGenerator implements IOrchestrator {
       // Fill-all: [0*] -> {0}
       const fillValue = this.generateExpression(ctx.expression()!);
       // Store element count as 0 to signal fill-all (size comes from declaration)
-      this.context.lastArrayInitCount = 0;
-      this.context.lastArrayFillValue = fillValue;
+      CodeGenState.lastArrayInitCount = 0;
+      CodeGenState.lastArrayFillValue = fillValue;
       return `{${fillValue}}`;
     }
 
@@ -5587,8 +5033,8 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Store element count for size inference
-    this.context.lastArrayInitCount = generatedElements.length;
-    this.context.lastArrayFillValue = undefined;
+    CodeGenState.lastArrayInitCount = generatedElements.length;
+    CodeGenState.lastArrayFillValue = undefined;
 
     return `{${generatedElements.join(", ")}}`;
   }
@@ -5656,21 +5102,21 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.FunctionDeclarationContext,
   ): void {
     // Issue #269: Set current function name for pass-by-value lookup
-    const fullFuncName = this.context.currentScope
-      ? `${this.context.currentScope}_${name}`
+    const fullFuncName = CodeGenState.currentScope
+      ? `${CodeGenState.currentScope}_${name}`
       : name;
-    this.context.currentFunctionName = fullFuncName;
+    CodeGenState.currentFunctionName = fullFuncName;
     // Issue #477: Set return type for enum inference in return statements
-    this.context.currentFunctionReturnType = ctx.type().getText();
+    CodeGenState.currentFunctionReturnType = ctx.type().getText();
 
     // Track parameters for ADR-006 pointer semantics
     this._setParameters(ctx.parameterList() ?? null);
 
     // ADR-016: Clear local variables and mark that we're in a function body
-    this.context.localVariables.clear();
-    this.context.floatBitShadows.clear();
-    this.context.floatShadowCurrent.clear();
-    this.context.inFunctionBody = true;
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.inFunctionBody = true;
   }
 
   /**
@@ -5685,7 +5131,7 @@ export default class CodeGenerator implements IOrchestrator {
     if (isMainWithArgs) {
       // Special case: main(u8 args[][]) -> int main(int argc, char *argv[])
       const argsParam = ctx.parameterList()!.parameter()[0];
-      this.context.mainArgsName = argsParam.IDENTIFIER().getText();
+      CodeGenState.mainArgsName = argsParam.IDENTIFIER().getText();
       return {
         actualReturnType: "int",
         initialParams: "int argc, char *argv[]",
@@ -5701,13 +5147,13 @@ export default class CodeGenerator implements IOrchestrator {
    * Clean up context after function generation
    */
   private _cleanupFunctionContext(): void {
-    this.context.inFunctionBody = false;
-    this.context.localVariables.clear();
-    this.context.floatBitShadows.clear();
-    this.context.floatShadowCurrent.clear();
-    this.context.mainArgsName = null;
-    this.context.currentFunctionName = null;
-    this.context.currentFunctionReturnType = null;
+    CodeGenState.inFunctionBody = false;
+    CodeGenState.localVariables.clear();
+    CodeGenState.floatBitShadows.clear();
+    CodeGenState.floatShadowCurrent.clear();
+    CodeGenState.mainArgsName = null;
+    CodeGenState.currentFunctionName = null;
+    CodeGenState.currentFunctionReturnType = null;
     this._clearParameters();
   }
 
@@ -5737,13 +5183,22 @@ export default class CodeGenerator implements IOrchestrator {
     const dims = ctx.arrayDimension();
 
     // ADR-029: Check if this is a callback type parameter
-    if (this.callbackTypes.has(typeName)) {
-      const callbackInfo = this.callbackTypes.get(typeName)!;
+    if (CodeGenState.callbackTypes.has(typeName)) {
+      const callbackInfo = CodeGenState.callbackTypes.get(typeName)!;
       return `${callbackInfo.typedefName} ${name}`;
     }
 
     const type = this.generateType(ctx.type());
 
+    // Handle C-Next style array type in parameter (e.g., u8[8] param)
+    const arrayTypeCtx = ctx.type().arrayType();
+    if (arrayTypeCtx) {
+      const dimExpr = this.generateExpression(arrayTypeCtx.expression());
+      const wasModified = this._isCurrentParameterModified(name);
+      const autoConst = !wasModified && !constMod ? "const " : "";
+      return `${autoConst}${constMod}${type} ${name}[${dimExpr}]`;
+    }
+
     // Try special cases first
     const stringArrayResult = this._tryGenerateStringArrayParam(
       ctx,
@@ -5825,12 +5280,12 @@ export default class CodeGenerator implements IOrchestrator {
     // ISR, float, enum types
     if (typeName === "ISR") return true;
     if (this._isFloatType(typeName)) return true;
-    if (this.symbols!.knownEnums.has(typeName)) return true;
+    if (CodeGenState.symbols!.knownEnums.has(typeName)) return true;
 
     // Small unmodified primitives
     if (
-      this.context.currentFunctionName &&
-      this._isParameterPassByValueByName(this.context.currentFunctionName, name)
+      CodeGenState.currentFunctionName &&
+      this._isParameterPassByValueByName(CodeGenState.currentFunctionName, name)
     ) {
       return true;
     }
@@ -5871,7 +5326,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     const wasModified = this._isCurrentParameterModified(name);
     const autoConst = !wasModified && !constMod ? "const " : "";
-    const refOrPtr = this.cppHelper!.refOrPtr();
+    const refOrPtr = CppModeHelper.refOrPtr();
     return `${autoConst}${constMod}${type}${refOrPtr} ${name}`;
   }
 
@@ -5889,24 +5344,39 @@ export default class CodeGenerator implements IOrchestrator {
     // Issue #696: Use helper for modifier extraction and validation
     const modifiers = VariableModifierBuilder.build(
       ctx,
-      this.context.inFunctionBody,
+      CodeGenState.inFunctionBody,
     );
 
     const name = ctx.IDENTIFIER().getText();
     const typeCtx = ctx.type();
+
+    // Reject C-style array declarations (u16 arr[8]) - require C-Next style (u16[8] arr)
+    this._validateArrayDeclarationSyntax(ctx, typeCtx, name);
+
     const type = this._inferVariableType(ctx, name);
 
     // Track local variable metadata
     this._trackLocalVariable(ctx, name);
 
     // ADR-045: Handle bounded string type specially - early return
-    const stringResult = this.stringDeclHelper!.generateStringDecl(
+    const stringResult = StringDeclHelper.generateStringDecl(
       typeCtx,
       name,
       ctx.expression() ?? null,
       ctx.arrayDimension(),
       modifiers,
       ctx.constModifier() !== null,
+      {
+        generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+        generateArrayDimensions: (dims) => this.generateArrayDimensions(dims),
+        getStringConcatOperands: (concatCtx) =>
+          this._getStringConcatOperands(concatCtx),
+        getSubstringOperands: (substrCtx) =>
+          this._getSubstringOperands(substrCtx),
+        getStringExprCapacity: (exprCode) =>
+          this.getStringExprCapacity(exprCode),
+        requireStringInclude: () => this.requireInclude("string"),
+      },
     );
     if (stringResult.handled) {
       return stringResult.code;
@@ -5965,24 +5435,25 @@ export default class CodeGenerator implements IOrchestrator {
     ctx: Parser.VariableDeclarationContext,
     name: string,
   ): void {
-    if (!this.context.inFunctionBody) {
+    if (!CodeGenState.inFunctionBody) {
       return;
     }
 
     this.trackVariableType(ctx);
-    this.context.localVariables.add(name);
+    CodeGenState.localVariables.add(name);
 
     // Bug #8: Track local const values for array size and bit index resolution
     if (ctx.constModifier() && ctx.expression()) {
       const constValue = this.tryEvaluateConstant(ctx.expression()!);
       if (constValue !== undefined) {
-        this.constValues.set(name, constValue);
+        CodeGenState.constValues.set(name, constValue);
       }
     }
   }
 
   /**
    * Issue #696: Handle array declaration with dimension parsing and init.
+   * Bug fix: Also handles C-Next style arrayType syntax (u16[8] myArray).
    */
   private _handleArrayDeclaration(
     ctx: Parser.VariableDeclarationContext,
@@ -5991,42 +5462,97 @@ export default class CodeGenerator implements IOrchestrator {
     decl: string,
   ): { handled: boolean; code: string; decl: string; isArray: boolean } {
     const arrayDims = ctx.arrayDimension();
-    const isArray = arrayDims.length > 0;
+    const hasArrayTypeSyntax = typeCtx.arrayType() !== null;
+    const isArray = arrayDims.length > 0 || hasArrayTypeSyntax;
 
     if (!isArray) {
       return { handled: false, code: "", decl, isArray: false };
     }
 
+    // Generate dimension string from arrayType syntax (u16[8] myArray)
+    const arrayTypeDimStr = this._getArrayTypeDimension(typeCtx);
+
     const hasEmptyArrayDim = arrayDims.some((dim) => !dim.expression());
-    const declaredSize = this._parseFirstArrayDimension(arrayDims);
+    const declaredSize =
+      this._parseArrayTypeDimension(typeCtx) ??
+      this._parseFirstArrayDimension(arrayDims);
 
     // ADR-035: Handle array initializers with size inference
     if (ctx.expression()) {
-      const arrayInitResult = this.arrayInitHelper!.processArrayInit(
+      const arrayInitResult = ArrayInitHelper.processArrayInit(
         name,
         typeCtx,
         ctx.expression()!,
         arrayDims,
         hasEmptyArrayDim,
         declaredSize,
+        {
+          generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+          getTypeName: (typeCtxParam) => this.getTypeName(typeCtxParam),
+          generateArrayDimensions: (dims) => this.generateArrayDimensions(dims),
+        },
       );
       if (arrayInitResult) {
+        // Track as local array for type resolution
+        CodeGenState.localArrays.add(name);
+        // Include arrayType dimension before arrayDimension dimensions
+        const fullDimSuffix = arrayTypeDimStr + arrayInitResult.dimensionSuffix;
         return {
           handled: true,
-          code: `${decl}${arrayInitResult.dimensionSuffix} = ${arrayInitResult.initValue};`,
+          code: `${decl}${fullDimSuffix} = ${arrayInitResult.initValue};`,
           decl,
           isArray: true,
         };
       }
     }
 
-    // Generate dimensions and track as local array
-    const newDecl = decl + this.generateArrayDimensions(arrayDims);
-    this.context.localArrays.add(name);
+    // Generate dimensions: arrayType dimension first, then arrayDimension dimensions
+    const newDecl =
+      decl + arrayTypeDimStr + this.generateArrayDimensions(arrayDims);
+    CodeGenState.localArrays.add(name);
 
     return { handled: false, code: "", decl: newDecl, isArray: true };
   }
 
+  /**
+   * Get array dimension string from arrayType syntax (u16[8] -> "[8]").
+   * Evaluates const expressions to their numeric values for C compatibility.
+   */
+  private _getArrayTypeDimension(typeCtx: Parser.TypeContext): string {
+    if (!typeCtx.arrayType()) {
+      return "";
+    }
+    const sizeExpr = typeCtx.arrayType()!.expression();
+    if (!sizeExpr) {
+      return "[]";
+    }
+    // Try to evaluate as constant first (required for C file-scope arrays)
+    const constValue = this.tryEvaluateConstant(sizeExpr);
+    if (constValue !== undefined) {
+      return `[${constValue}]`;
+    }
+    // Fall back to expression text (for macros, enums, etc.)
+    return `[${this.generateExpression(sizeExpr)}]`;
+  }
+
+  /**
+   * Parse array dimension from arrayType syntax for size validation.
+   */
+  private _parseArrayTypeDimension(typeCtx: Parser.TypeContext): number | null {
+    if (!typeCtx.arrayType()) {
+      return null;
+    }
+    const sizeExpr = typeCtx.arrayType()!.expression();
+    if (!sizeExpr) {
+      return null;
+    }
+    const sizeText = sizeExpr.getText();
+    if (/^\d+$/.exec(sizeText)) {
+      return Number.parseInt(sizeText, 10);
+    }
+    return null;
+  }
+
   /**
    * Issue #696: Parse first array dimension for validation.
    */
@@ -6043,6 +5569,95 @@ export default class CodeGenerator implements IOrchestrator {
     return null;
   }
 
+  /**
+   * Validate array declaration syntax - reject C-style, require C-Next style.
+   * C-style: u16 arr[8] (all dimensions after identifier) - REJECTED
+   * C-Next style: u16[8] arr (first dimension in type) - REQUIRED
+   * Multi-dim C-Next: u16[4] arr[2] (first in type, rest after) - ALLOWED
+   * Exceptions (grammar limitations):
+   *   - Empty dimensions for size inference: u8 arr[] <- [...]
+   *   - Qualified types: SeaDash.Parse.Result arr[3] (no arrayType support)
+   *   - Scoped/global types: this.Type arr[3], global.Type arr[3]
+   *   - String types: string<N> arr[3]
+   */
+  private _validateArrayDeclarationSyntax(
+    ctx: Parser.VariableDeclarationContext,
+    typeCtx: Parser.TypeContext,
+    name: string,
+  ): void {
+    const arrayDims = ctx.arrayDimension();
+    if (arrayDims.length === 0) {
+      return; // Not an array declaration
+    }
+
+    // If type already has arrayType, additional dimensions are allowed (multi-dim)
+    if (typeCtx.arrayType()) {
+      return; // Valid C-Next style: u16[4] arr[2] → uint16_t arr[4][2]
+    }
+
+    // Allow empty first dimension for size inference: u8 arr[] <- [1, 2, 3]
+    // The grammar doesn't support u8[] arr syntax, so this is the only way
+    if (arrayDims.length === 1 && !arrayDims[0].expression()) {
+      return; // Size inference pattern allowed
+    }
+
+    // Allow C-style for multi-dimensional arrays: u8 matrix[4][4]
+    // The arrayType grammar only supports single dimension, so multi-dim needs C-style
+    if (arrayDims.length > 1) {
+      return; // Multi-dimensional arrays need C-style
+    }
+
+    // Allow C-style for types that don't support arrayType syntax:
+    // - Qualified types (Scope.Type, Namespace::Type)
+    // - Scoped types (this.Type)
+    // - Global types (global.Type)
+    // - String types (string<N>)
+    // - Bitmap types (code generator doesn't yet handle arrayType for bitmaps)
+    if (
+      typeCtx.qualifiedType() ||
+      typeCtx.scopedType() ||
+      typeCtx.globalType() ||
+      typeCtx.stringType()
+    ) {
+      return; // Grammar limitation - these can't use arrayType
+    }
+
+    // C-style array declaration detected - reject with helpful error
+    const baseType = this._extractBaseTypeName(typeCtx);
+    const dimensions = arrayDims
+      .map((dim) => `[${dim.expression()?.getText() ?? ""}]`)
+      .join("");
+    const line = ctx.start?.line ?? 0;
+    const col = ctx.start?.column ?? 0;
+
+    throw new Error(
+      `${line}:${col} C-style array declaration is not allowed. ` +
+        `Use '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`,
+    );
+  }
+
+  /**
+   * Extract base type name from type context for error messages.
+   */
+  private _extractBaseTypeName(typeCtx: Parser.TypeContext): string {
+    if (typeCtx.primitiveType()) {
+      return typeCtx.primitiveType()!.getText();
+    }
+    if (typeCtx.userType()) {
+      return typeCtx.userType()!.getText();
+    }
+    if (typeCtx.arrayType()) {
+      const arrCtx = typeCtx.arrayType()!;
+      if (arrCtx.primitiveType()) {
+        return arrCtx.primitiveType()!.getText();
+      }
+      if (arrCtx.userType()) {
+        return arrCtx.userType()!.getText();
+      }
+    }
+    return typeCtx.getText();
+  }
+
   /**
    * Issue #696: Generate variable initializer with validation.
    */
@@ -6058,17 +5673,17 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     const typeName = this.getTypeName(typeCtx);
-    const savedExpectedType = this.context.expectedType;
-    this.context.expectedType = typeName;
+    const savedExpectedType = CodeGenState.expectedType;
+    CodeGenState.expectedType = typeName;
 
     // ADR-017: Validate enum type for initialization
-    this.enumValidator!.validateEnumAssignment(typeName, ctx.expression()!);
+    EnumAssignmentValidator.validateEnumAssignment(typeName, ctx.expression()!);
 
     // ADR-024: Validate integer literals and type conversions
     this._validateIntegerInitializer(ctx, typeName);
 
     const result = `${decl} = ${this.generateExpression(ctx.expression()!)}`;
-    this.context.expectedType = savedExpectedType;
+    CodeGenState.expectedType = savedExpectedType;
 
     return result;
   }
@@ -6116,20 +5731,20 @@ export default class CodeGenerator implements IOrchestrator {
     name: string,
     decl: string,
   ): string {
-    if (this.pendingCppClassAssignments.length === 0) {
+    if (CodeGenState.pendingCppClassAssignments.length === 0) {
       return `${decl};`;
     }
 
-    if (this.context.inFunctionBody) {
-      const assignments = this.pendingCppClassAssignments
+    if (CodeGenState.inFunctionBody) {
+      const assignments = CodeGenState.pendingCppClassAssignments
         .map((a) => `${name}.${a}`)
         .join("\n");
-      this.pendingCppClassAssignments = [];
+      CodeGenState.pendingCppClassAssignments = [];
       return `${decl};\n${assignments}`;
     }
 
     // At global scope, we can't emit assignment statements.
-    this.pendingCppClassAssignments = [];
+    CodeGenState.pendingCppClassAssignments = [];
     throw new Error(
       `Error: C++ class '${this.getTypeName(typeCtx)}' with constructor cannot use struct initializer ` +
         `syntax at global scope. Use constructor syntax or initialize fields separately.`,
@@ -6157,14 +5772,14 @@ export default class CodeGenerator implements IOrchestrator {
       const argName = argNode.getText();
 
       // Check if it exists in type registry
-      const typeInfo = this.context.typeRegistry.get(argName);
+      const typeInfo = CodeGenState.typeRegistry.get(argName);
 
       // Also check scoped variables if inside a scope
       let scopedArgName = argName;
       let scopedTypeInfo = typeInfo;
-      if (!typeInfo && this.context.currentScope) {
-        scopedArgName = `${this.context.currentScope}_${argName}`;
-        scopedTypeInfo = this.context.typeRegistry.get(scopedArgName);
+      if (!typeInfo && CodeGenState.currentScope) {
+        scopedArgName = `${CodeGenState.currentScope}_${argName}`;
+        scopedTypeInfo = CodeGenState.typeRegistry.get(scopedArgName);
       }
 
       if (!typeInfo && !scopedTypeInfo) {
@@ -6188,7 +5803,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Track the variable in type registry (as an external C++ type)
-    this.context.typeRegistry.set(name, {
+    CodeGenState.typeRegistry.set(name, {
       baseType: type,
       bitWidth: 0, // Unknown for C++ types
       isArray: false,
@@ -6198,8 +5813,8 @@ export default class CodeGenerator implements IOrchestrator {
     });
 
     // Track as local variable if inside function body
-    if (this.context.inFunctionBody) {
-      this.context.localVariables.add(name);
+    if (CodeGenState.inFunctionBody) {
+      CodeGenState.localVariables.add(name);
     }
 
     return `${type} ${name}(${resolvedArgs.join(", ")});`;
@@ -6217,6 +5832,14 @@ export default class CodeGenerator implements IOrchestrator {
         return "{}";
       }
     }
+    // Also check C-Next style array type (e.g., CppClass[4]) where
+    // the userType is nested inside arrayType.
+    if (typeCtx.arrayType()?.userType()) {
+      const typeName = typeCtx.arrayType()!.userType()!.getText();
+      if (this._needsEmptyBraceInit(typeName)) {
+        return "{}";
+      }
+    }
     // Template types are always C++ classes
     if (typeCtx.templateType()) {
       return "{}";
@@ -6231,7 +5854,7 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-017: Enums initialize to first member
    */
   private _getEnumZeroValue(enumName: string, separator: string = "_"): string {
-    const members = this.symbols!.enumMembers.get(enumName);
+    const members = CodeGenState.symbols!.enumMembers.get(enumName);
     if (!members) {
       return `(${enumName})0`;
     }
@@ -6264,8 +5887,8 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-016: Check for scoped types (this.Type)
     if (typeCtx.scopedType()) {
       const localName = typeCtx.scopedType()!.IDENTIFIER().getText();
-      const name = this.context.currentScope
-        ? `${this.context.currentScope}_${localName}`
+      const name = CodeGenState.currentScope
+        ? `${CodeGenState.currentScope}_${localName}`
         : localName;
       return { name, separator: "_", checkCppType: false };
     }
@@ -6312,7 +5935,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
     // In C++ mode, unknown user types may have non-trivial constructors
     // Known structs (C-Next or C headers) are POD types where {0} works
-    return this.cppMode && !this.isKnownStruct(typeName);
+    return CodeGenState.cppMode && !this.isKnownStruct(typeName);
   }
 
   /**
@@ -6329,11 +5952,11 @@ export default class CodeGenerator implements IOrchestrator {
   // ADR-109: Build handler dependencies for assignment dispatch
   private buildHandlerDeps(): IHandlerDeps {
     return {
-      symbols: this.symbols!,
-      typeRegistry: this.context.typeRegistry,
-      currentScope: this.context.currentScope,
-      currentParameters: this.context.currentParameters,
-      targetCapabilities: this.context.targetCapabilities,
+      symbols: CodeGenState.symbols!,
+      typeRegistry: CodeGenState.typeRegistry,
+      currentScope: CodeGenState.currentScope,
+      currentParameters: CodeGenState.currentParameters,
+      targetCapabilities: CodeGenState.targetCapabilities,
       generateExpression: (ctx) => this.generateExpression(ctx),
       tryEvaluateConstant: (ctx) => this.tryEvaluateConstant(ctx),
       generateAssignmentTarget: (ctx) => this.generateAssignmentTarget(ctx),
@@ -6342,11 +5965,11 @@ export default class CodeGenerator implements IOrchestrator {
       getMemberTypeInfo: (structType, memberName) =>
         this.getMemberTypeInfo(structType, memberName),
       validateBitmapFieldLiteral: (expr, width, fieldName) =>
-        this.typeValidator!.validateBitmapFieldLiteral(expr, width, fieldName),
+        TypeValidator.validateBitmapFieldLiteral(expr, width, fieldName),
       validateCrossScopeVisibility: (scopeName, memberName) =>
         this.validateCrossScopeVisibility(scopeName, memberName),
       checkArrayBounds: (arrayName, dimensions, indexExprs, line) =>
-        this.typeValidator!.checkArrayBounds(
+        TypeValidator.checkArrayBounds(
           arrayName,
           [...dimensions],
           [...indexExprs],
@@ -6379,7 +6002,10 @@ export default class CodeGenerator implements IOrchestrator {
     bitIndex?: string;
     baseType?: string;
   } {
-    return this.memberChainAnalyzer!.analyze(targetCtx);
+    // Issue #644: MemberChainAnalyzer is now static, pass generateExpression callback
+    return MemberChainAnalyzer.analyze(targetCtx, (ctx) =>
+      this.generateExpression(ctx),
+    );
   }
 
   /**
@@ -6393,12 +6019,18 @@ export default class CodeGenerator implements IOrchestrator {
     width: string | null,
     value: string,
   ): string | null {
-    return this.floatBitHelper!.generateFloatBitWrite(
+    // Issue #644: FloatBitHelper is now static, pass callbacks
+    return FloatBitHelper.generateFloatBitWrite(
       name,
       typeInfo,
       bitIndex,
       width,
       value,
+      {
+        generateBitMask: (w, is64Bit) => this.generateBitMask(w, is64Bit),
+        foldBooleanToInt: (expr) => this.foldBooleanToInt(expr),
+        requireInclude: (header) => this.requireInclude(header),
+      },
     );
   }
 
@@ -6408,22 +6040,23 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #644: Set expected type for inferred struct initializers and overflow behavior
     // Delegated to AssignmentExpectedTypeResolver helper
-    const savedExpectedType = this.context.expectedType;
-    const savedAssignmentContext = { ...this.context.assignmentContext };
+    const savedExpectedType = CodeGenState.expectedType;
+    const savedAssignmentContext = { ...CodeGenState.assignmentContext };
 
-    const resolved = this.expectedTypeResolver!.resolve(targetCtx);
+    // Issue #644: AssignmentExpectedTypeResolver is now static
+    const resolved = AssignmentExpectedTypeResolver.resolve(targetCtx);
     if (resolved.expectedType) {
-      this.context.expectedType = resolved.expectedType;
+      CodeGenState.expectedType = resolved.expectedType;
     }
     if (resolved.assignmentContext) {
-      this.context.assignmentContext = resolved.assignmentContext;
+      CodeGenState.assignmentContext = resolved.assignmentContext;
     }
 
     const value = this.generateExpression(ctx.expression());
 
     // Restore expected type and assignment context
-    this.context.expectedType = savedExpectedType;
-    this.context.assignmentContext = savedAssignmentContext;
+    CodeGenState.expectedType = savedExpectedType;
+    CodeGenState.assignmentContext = savedAssignmentContext;
 
     // Get the assignment operator and map to C equivalent
     const operatorCtx = ctx.assignmentOperator();
@@ -6433,29 +6066,27 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #644: Validate assignment (const, enum, integer, array bounds, callbacks)
     // Delegated to AssignmentValidator helper to reduce cognitive complexity
-    this.assignmentValidator!.validate(
+    AssignmentValidator.validate(
       targetCtx,
       ctx.expression(),
       isCompound,
       ctx.start?.line ?? 0,
+      {
+        getExpressionType: (exprCtx) => this.getExpressionType(exprCtx),
+        tryEvaluateConstant: (exprCtx) => this.tryEvaluateConstant(exprCtx),
+        isCallbackTypeUsedAsFieldType: (name) =>
+          this.isCallbackTypeUsedAsFieldType(name),
+      },
     );
 
     // ADR-109: Dispatch to assignment handlers
     // Build context, classify, and dispatch - all patterns handled by handlers
     const assignCtx = buildAssignmentContext(ctx, {
-      typeRegistry: this.context.typeRegistry,
+      typeRegistry: CodeGenState.typeRegistry,
       generateExpression: () => value,
     });
     const handlerDeps = this.buildHandlerDeps();
-    const classifier = new AssignmentClassifier({
-      symbols: handlerDeps.symbols,
-      typeRegistry: handlerDeps.typeRegistry,
-      currentScope: handlerDeps.currentScope,
-      isKnownStruct: handlerDeps.isKnownStruct,
-      isKnownScope: handlerDeps.isKnownScope,
-      getMemberTypeInfo: handlerDeps.getMemberTypeInfo,
-    });
-    const assignmentKind = classifier.classify(assignCtx);
+    const assignmentKind = AssignmentClassifier.classify(assignCtx);
     const handler = AssignmentHandlerRegistry.getHandler(assignmentKind);
     return handler(assignCtx, handlerDeps);
   }
@@ -6475,7 +6106,7 @@ export default class CodeGenerator implements IOrchestrator {
       cOp,
       value,
       typeInfo,
-      this.context.targetCapabilities,
+      CodeGenState.targetCapabilities,
     );
     this.applyEffects(result.effects);
     return result.code;
@@ -6487,16 +6118,16 @@ export default class CodeGenerator implements IOrchestrator {
   private _buildSimpleIdentifierDeps(): ISimpleIdentifierDeps {
     return {
       getParameterInfo: (name: string) =>
-        this.context.currentParameters.get(name),
+        CodeGenState.currentParameters.get(name),
       resolveParameter: (name: string, paramInfo: TParameterInfo) =>
         ParameterDereferenceResolver.resolve(
           name,
           paramInfo,
           this._buildParameterDereferenceDeps(),
         ),
-      isLocalVariable: (name: string) => this.context.localVariables.has(name),
+      isLocalVariable: (name: string) => CodeGenState.localVariables.has(name),
       resolveBareIdentifier: (name: string, isLocal: boolean) =>
-        this.typeValidator!.resolveBareIdentifier(name, isLocal, (n: string) =>
+        TypeValidator.resolveBareIdentifier(name, isLocal, (n: string) =>
           this.isKnownStruct(n),
         ),
     };
@@ -6522,7 +6153,7 @@ export default class CodeGenerator implements IOrchestrator {
     hasGlobal: boolean,
     hasThis: boolean,
   ): IPostfixChainDeps {
-    const paramInfo = this.context.currentParameters.get(firstId);
+    const paramInfo = CodeGenState.currentParameters.get(firstId);
     const isStructParam = paramInfo?.isStruct ?? false;
     const isCppAccess = hasGlobal && this.isCppScopeSymbol(firstId);
     const separatorDeps = this._buildMemberSeparatorDeps();
@@ -6532,7 +6163,7 @@ export default class CodeGenerator implements IOrchestrator {
         firstId,
         hasGlobal,
         hasThis,
-        this.context.currentScope,
+        CodeGenState.currentScope,
         isStructParam,
         separatorDeps,
         isCppAccess,
@@ -6556,37 +6187,7 @@ export default class CodeGenerator implements IOrchestrator {
     };
   }
 
-  // ADR-016: Validate cross-scope visibility (issue #165)
-  private _validateCrossScopeVisibility(
-    scopeName: string,
-    memberName: string,
-    isGlobalAccess: boolean = false,
-  ): void {
-    // Error if referencing own scope by name (must use this. prefix)
-    // Exception: global.Scope.member is allowed for explicit qualification
-    if (!isGlobalAccess && this.context.currentScope === scopeName) {
-      throw new Error(
-        `Error: Cannot reference own scope '${scopeName}' by name. ` +
-          `Use 'this.${memberName}' instead of '${scopeName}.${memberName}'`,
-      );
-    }
-
-    // Check private member access (skip for own scope - we can access our own privates)
-    const isOwnScope = this.context.currentScope === scopeName;
-    if (!isOwnScope) {
-      const visibility =
-        this.symbols!.scopeMemberVisibility.get(scopeName)?.get(memberName);
-      if (visibility === "private") {
-        const context = this.context.currentScope
-          ? `from scope '${this.context.currentScope}'`
-          : "from outside the scope";
-        throw new Error(
-          `Cannot access private member '${memberName}' of scope '${scopeName}' ${context}. ` +
-            `Only public members are accessible outside their scope.`,
-        );
-      }
-    }
-  }
+  // ADR-016: _validateCrossScopeVisibility moved to ScopeResolver
 
   // Issue #387: Dead methods removed (generateGlobalMemberAccess, generateGlobalArrayAccess,
   // generateThisMemberAccess, generateThisArrayAccess) - now handled by unified doGenerateAssignmentTarget
@@ -6672,7 +6273,7 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-016: 'this' returns a marker that postfixOps will transform to Scope_member
    */
   private _resolveThisKeyword(): string {
-    if (!this.context.currentScope) {
+    if (!CodeGenState.currentScope) {
       throw new Error("Error: 'this' can only be used inside a scope");
     }
     return "__THIS_SCOPE__";
@@ -6684,12 +6285,12 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private _resolveIdentifierExpression(id: string): string {
     // Special case: main function's args parameter -> argv
-    if (this.context.mainArgsName && id === this.context.mainArgsName) {
+    if (CodeGenState.mainArgsName && id === CodeGenState.mainArgsName) {
       return "argv";
     }
 
     // ADR-006: Check if it's a function parameter
-    const paramInfo = this.context.currentParameters.get(id);
+    const paramInfo = CodeGenState.currentParameters.get(id);
     if (paramInfo) {
       return ParameterDereferenceResolver.resolve(
         id,
@@ -6699,15 +6300,16 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // ADR-016: Resolve bare identifier using local -> scope -> global priority
-    const isLocalVariable = this.context.localVariables.has(id);
-    const resolved = this.typeValidator!.resolveBareIdentifier(
+    const isLocalVariable = CodeGenState.localVariables.has(id);
+    const resolved = TypeValidator.resolveBareIdentifier(
       id,
       isLocalVariable,
       (name: string) => this.isKnownStruct(name),
     );
     if (resolved !== null) {
       // Issue #741: Check if this is a private const that should be inlined
-      const constValue = this.symbols!.scopePrivateConstValues.get(resolved);
+      const constValue =
+        CodeGenState.symbols!.scopePrivateConstValues.get(resolved);
       if (constValue !== undefined) {
         return constValue;
       }
@@ -6731,19 +6333,21 @@ export default class CodeGenerator implements IOrchestrator {
   private _resolveUnqualifiedEnumMember(id: string): string | null {
     // Type-aware resolution: check only the expected enum type
     if (
-      this.context.expectedType &&
-      this.symbols!.knownEnums.has(this.context.expectedType)
+      CodeGenState.expectedType &&
+      CodeGenState.symbols!.knownEnums.has(CodeGenState.expectedType)
     ) {
-      const members = this.symbols!.enumMembers.get(this.context.expectedType);
+      const members = CodeGenState.symbols!.enumMembers.get(
+        CodeGenState.expectedType,
+      );
       if (members?.has(id)) {
-        return `${this.context.expectedType}${this.getScopeSeparator(false)}${id}`;
+        return `${CodeGenState.expectedType}${this.getScopeSeparator(false)}${id}`;
       }
       return null;
     }
 
     // No expected enum type - search all enums but error on ambiguity
     const matchingEnums: string[] = [];
-    for (const [enumName, members] of this.symbols!.enumMembers) {
+    for (const [enumName, members] of CodeGenState.symbols!.enumMembers) {
       if (members.has(id)) {
         matchingEnums.push(enumName);
       }
@@ -6771,7 +6375,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Issue #304/#644: Transform NULL → nullptr in C++ mode
     if (result.code === "NULL") {
-      return this.cppHelper!.nullLiteral();
+      return CppModeHelper.nullLiteral();
     }
 
     return result.code;
@@ -6837,7 +6441,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #267/#644: Use C++ casts when cppMode is enabled for MISRA compliance
-    return this.cppHelper!.cast(targetType, expr);
+    return CppModeHelper.cast(targetType, expr);
   }
 
   /**
@@ -6863,7 +6467,7 @@ export default class CodeGenerator implements IOrchestrator {
 
     if (!maxValue) {
       // Unknown type, fall back to raw cast - Issue #644
-      return this.cppHelper!.cast(targetType, expr);
+      return CppModeHelper.cast(targetType, expr);
     }
 
     // Mark that we need limits.h for the type limit macros
@@ -6883,161 +6487,20 @@ export default class CodeGenerator implements IOrchestrator {
     // Generate clamping expression:
     // (expr > MAX) ? MAX : (expr < MIN) ? MIN : (type)(expr)
     // Note: For unsigned targets, MIN is 0 so we check < 0.0
-    const finalCast = this.cppHelper!.cast(targetType, `(${expr})`);
+    const finalCast = CppModeHelper.cast(targetType, `(${expr})`);
     return `((${expr}) > ${maxComparison} ? ${maxValue} : (${expr}) < ${minComparison} ? ${minValue} : ${finalCast})`;
   }
 
   /**
    * ADR-023: Generate sizeof expression
-   * sizeof(type) -> sizeof(c_type)
-   * sizeof(variable) -> sizeof(variable)
-   * With safety checks:
-   * - E0601: sizeof on array parameter is error
-   * - E0602: Side effects in sizeof are error
+   * Delegates to SizeofResolver which uses CodeGenState.
    */
   private generateSizeofExpr(ctx: Parser.SizeofExpressionContext): string {
-    // Check if it's sizeof(type) or sizeof(expression)
-    // Note: Due to grammar ambiguity, sizeof(variable) may parse as sizeof(type)
-    // when the variable name matches userType (just an identifier)
-    if (ctx.type()) {
-      return this._sizeofType(ctx.type()!);
-    }
-    return this._sizeofExpression(ctx.expression()!);
-  }
-
-  /**
-   * Handle sizeof(type) - may actually be sizeof(variable) due to grammar ambiguity
-   */
-  private _sizeofType(typeCtx: Parser.TypeContext): string {
-    // qualifiedType matches IDENTIFIER.IDENTIFIER, could be struct.member
-    if (typeCtx.qualifiedType()) {
-      const result = this._sizeofQualifiedType(typeCtx.qualifiedType()!);
-      if (result) return result;
-      // Fall through to generateType for actual type references (Scope.Type)
-    }
-
-    // userType is just IDENTIFIER, could be a variable reference
-    if (typeCtx.userType()) {
-      return this._sizeofUserType(typeCtx.getText());
-    }
-
-    // It's a primitive or other type - generate normally
-    return `sizeof(${this.generateType(typeCtx)})`;
-  }
-
-  /**
-   * Handle sizeof(qualified.type) - may be struct.member access
-   * Returns null if this is actually a type reference (Scope.Type)
-   */
-  private _sizeofQualifiedType(
-    qualifiedCtx: Parser.QualifiedTypeContext,
-  ): string | null {
-    const identifiers = qualifiedCtx.IDENTIFIER();
-    const firstName = identifiers[0].getText();
-    const memberName = identifiers[1].getText();
-
-    // Check if first identifier is a local variable (struct instance)
-    if (this.context.localVariables.has(firstName)) {
-      return `sizeof(${firstName}.${memberName})`;
-    }
-
-    // Check if first identifier is a parameter (struct parameter)
-    const paramInfo = this.context.currentParameters.get(firstName);
-    if (paramInfo) {
-      const sep = paramInfo.isStruct ? "->" : ".";
-      return `sizeof(${firstName}${sep}${memberName})`;
-    }
-
-    // Check if first identifier is a global variable
-    // If not a scope or enum, it's likely a global struct variable
-    if (
-      !this.isKnownScope(firstName) &&
-      !this.symbols!.knownEnums.has(firstName)
-    ) {
-      return `sizeof(${firstName}.${memberName})`;
-    }
-
-    // It's an actual type reference (Scope.Type), return null to fall through
-    return null;
-  }
-
-  /**
-   * Handle sizeof(identifier) - could be variable or type name
-   */
-  private _sizeofUserType(varName: string): string {
-    // Check if it's a known parameter
-    const paramInfo = this.context.currentParameters.get(varName);
-    if (paramInfo) {
-      return this._sizeofParameter(varName, paramInfo);
-    }
-
-    // Check if it's a known local variable, struct type, or enum type
-    // For all these cases, generate sizeof(name) directly
-    // Unknown identifiers are also treated as variables for safety
-    return `sizeof(${varName})`;
-  }
-
-  /**
-   * Handle sizeof on a parameter - validates and generates appropriate code
-   */
-  private _sizeofParameter(
-    varName: string,
-    paramInfo: { isArray?: boolean; isCallback?: boolean; isStruct?: boolean },
-  ): string {
-    // E0601: Array parameters decay to pointers
-    if (paramInfo.isArray) {
-      this._throwArrayParamSizeofError(varName);
-    }
-    // For pass-by-reference parameters (non-array, non-callback, non-struct),
-    // use pointer dereference
-    if (!paramInfo.isCallback && !paramInfo.isStruct) {
-      return `sizeof(*${varName})`;
-    }
-    return `sizeof(${varName})`;
-  }
-
-  /**
-   * Throw E0601 error for sizeof on array parameter
-   */
-  private _throwArrayParamSizeofError(varName: string): never {
-    throw new Error(
-      `Error[E0601]: sizeof() on array parameter '${varName}' returns pointer size. ` +
-        `Use ${varName}.length for element count or sizeof(elementType) * ${varName}.length for bytes`,
-    );
-  }
-
-  /**
-   * Handle sizeof(expression) with validation
-   */
-  private _sizeofExpression(expr: Parser.ExpressionContext): string {
-    // E0601: Check if expression is an array parameter
-    const varName = this.getSingleIdentifierFromExpr(expr);
-    if (varName) {
-      const paramInfo = this.context.currentParameters.get(varName);
-      if (paramInfo?.isArray) {
-        this._throwArrayParamSizeofError(varName);
-      }
-    }
-
-    // E0602: Check for side effects
-    if (this.hasSideEffects(expr)) {
-      throw new Error(
-        `Error[E0602]: sizeof() operand must not have side effects (MISRA C:2012 Rule 13.6)`,
-      );
-    }
-
-    return `sizeof(${this.generateExpression(expr)})`;
-  }
-
-  /**
-   * ADR-023: Extract simple identifier from expression for parameter checking
-   * Returns the identifier name if expression is a simple variable reference, null otherwise
-   * Issue #707: Delegates to ExpressionUnwrapper utility.
-   */
-  private getSingleIdentifierFromExpr(
-    expr: Parser.ExpressionContext,
-  ): string | null {
-    return ExpressionUnwrapper.getSimpleIdentifier(expr);
+    return SizeofResolver.generate(ctx, {
+      generateType: (typeCtx) => this.generateType(typeCtx),
+      generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+      hasSideEffects: (exprCtx) => this.hasSideEffects(exprCtx),
+    });
   }
 
   /**
@@ -7099,7 +6562,10 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-053 A5: Delegates to HelperGenerator
    */
   private generateOverflowHelpers(): string[] {
-    return helperGenerateOverflowHelpers(this.usedClampOps, this.debugMode);
+    return helperGenerateOverflowHelpers(
+      CodeGenState.usedClampOps,
+      CodeGenState.debugMode,
+    );
   }
 
   /**
@@ -7108,7 +6574,7 @@ export default class CodeGenerator implements IOrchestrator {
   private markClampOpUsed(operation: string, cnxType: string): void {
     // Only generate helpers for integer types (not float/bool)
     if (TYPE_WIDTH[cnxType] && TypeCheckUtils.isInteger(cnxType)) {
-      this.usedClampOps.add(`${operation}_${cnxType}`);
+      CodeGenState.usedClampOps.add(`${operation}_${cnxType}`);
     }
   }
 
@@ -7144,7 +6610,7 @@ export default class CodeGenerator implements IOrchestrator {
    * Format leading comments with current indentation
    */
   private formatLeadingComments(comments: IComment[]): string[] {
-    const indent = FormatUtils.indent(this.context.indentLevel);
+    const indent = FormatUtils.indent(CodeGenState.indentLevel);
     return commentFormatLeadingComments(
       comments,
       this.commentFormatter,
@@ -7157,6 +6623,6 @@ export default class CodeGenerator implements IOrchestrator {
    * ADR-053 A5: Delegates to HelperGenerator
    */
   private generateSafeDivHelpers(): string[] {
-    return helperGenerateSafeDivHelpers(this.usedSafeDivOps);
+    return helperGenerateSafeDivHelpers(CodeGenState.usedSafeDivOps);
   }
 }