c-next 0.1.69 → 0.1.71

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

@@ -6,8 +6,8 @@
 import { CommonTokenStream, ParserRuleContext } from "antlr4ng";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
 
-import ESymbolKind from "../../../utils/types/ESymbolKind";
 import CommentExtractor from "../../logic/analysis/CommentExtractor";
+import TypeRegistrationEngine from "./helpers/TypeRegistrationEngine";
 import CommentFormatter from "./CommentFormatter";
 import IncludeDiscovery from "../../data/IncludeDiscovery";
 import IComment from "../../types/IComment";
@@ -17,12 +17,10 @@ import TYPE_LIMITS from "./types/TYPE_LIMITS";
 // Issue #60: BITMAP_SIZE and BITMAP_BACKING_TYPE moved to SymbolCollector
 import TTypeInfo from "./types/TTypeInfo";
 import TParameterInfo from "./types/TParameterInfo";
-import TOverflowBehavior from "./types/TOverflowBehavior";
 import ICodeGeneratorOptions from "./types/ICodeGeneratorOptions";
 import TypeResolver from "./TypeResolver";
 import ICodeGenSymbols from "../../types/ICodeGenSymbols";
 import TypeValidator from "./TypeValidator";
-import TypeRegistrationUtils from "./TypeRegistrationUtils";
 import IOrchestrator from "./generators/IOrchestrator";
 import IGeneratorInput from "./generators/IGeneratorInput";
 import IGeneratorState from "./generators/IGeneratorState";
@@ -81,11 +79,13 @@ import MemberChainAnalyzer from "./analysis/MemberChainAnalyzer";
 // Issue #644: Float bit write helper for shadow variable pattern
 import FloatBitHelper from "./helpers/FloatBitHelper";
 // Issue #644: String declaration helper for bounded/array/concat strings
-import StringDeclHelper from "./helpers/StringDeclHelper";
+// Note: StringDeclHelper is now used via VariableDeclHelper
+// Issue #794: Argument generation helper for ADR-006 semantics
+import ArgumentGenerator from "./helpers/ArgumentGenerator";
 // Issue #644: Enum assignment validator for type-safe enum assignments
 import EnumAssignmentValidator from "./helpers/EnumAssignmentValidator";
 // Issue #644: Array initialization helper for size inference and fill-all
-import ArrayInitHelper from "./helpers/ArrayInitHelper";
+// Note: ArrayInitHelper is now used via VariableDeclHelper
 // Issue #644: Assignment expected type resolution helper
 import AssignmentExpectedTypeResolver from "./helpers/AssignmentExpectedTypeResolver";
 // PR #715: C++ member conversion helper for improved testability
@@ -102,7 +102,11 @@ import SymbolLookupHelper from "./helpers/SymbolLookupHelper";
 // Issue #644: Assignment validation coordinator helper
 import AssignmentValidator from "./helpers/AssignmentValidator";
 // Issue #696: Variable modifier extraction helper
-import VariableModifierBuilder from "./helpers/VariableModifierBuilder";
+// Note: VariableModifierBuilder is now used via VariableDeclHelper
+// Issue #792: Variable declaration helper
+import VariableDeclHelper from "./helpers/VariableDeclHelper";
+// String operation detection and extraction
+import StringOperationsHelper from "./helpers/StringOperationsHelper";
 // PR #681: Extracted separator and dereference resolution utilities
 import MemberSeparatorResolver from "./helpers/MemberSeparatorResolver";
 import ParameterDereferenceResolver from "./helpers/ParameterDereferenceResolver";
@@ -120,20 +124,19 @@ import CodegenParserUtils from "./utils/CodegenParserUtils";
 import IMemberSeparatorDeps from "./types/IMemberSeparatorDeps";
 import IParameterDereferenceDeps from "./types/IParameterDereferenceDeps";
 import ISeparatorContext from "./types/ISeparatorContext";
-// Issue #566: Statement expression collection for const inference
-import StatementExpressionCollector from "./helpers/StatementExpressionCollector";
-// Issue #269: Transitive modification propagation for const inference
-import TransitiveModificationPropagator from "./helpers/TransitiveModificationPropagator";
-// Issue #566: Child statement/block collection for const inference
-import ChildStatementCollector from "./helpers/ChildStatementCollector";
-// SonarCloud S3776: Assignment target extraction for walkStatementForModifications
-import AssignmentTargetExtractor from "./helpers/AssignmentTargetExtractor";
+// Issue #269: Transitive modification propagation for const inference (used by analyzeModificationsOnly)
+import TransitiveModificationPropagator from "../../logic/analysis/helpers/TransitiveModificationPropagator";
 // Phase 3: Type generation helper for improved testability
 import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 // Phase 5: Cast validation helper for improved testability
 import CastValidator from "./helpers/CastValidator";
+// Issue #793: Function context lifecycle and parameter processing helper
+import FunctionContextManager from "./helpers/FunctionContextManager";
+import IFunctionContextCallbacks from "./types/IFunctionContextCallbacks";
 // Global state for code generation (simplifies debugging, eliminates DI complexity)
 import CodeGenState from "../../state/CodeGenState";
+// Issue #269: Pass-by-value analysis extracted from CodeGenerator
+import PassByValueAnalyzer from "../../logic/analysis/PassByValueAnalyzer";
 // Unified parameter generation (Phase 1)
 import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
 import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
@@ -141,6 +144,8 @@ import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
 import SizeofResolver from "./resolution/SizeofResolver";
 import EnumTypeResolver from "./resolution/EnumTypeResolver";
 import ScopeResolver from "./resolution/ScopeResolver";
+// Issue #797: Centralized C-style name generation
+import QualifiedNameGenerator from "./utils/QualifiedNameGenerator";
 
 const {
   generateOverflowHelpers: helperGenerateOverflowHelpers,
@@ -387,7 +392,7 @@ export default class CodeGenerator implements IOrchestrator {
     return {
       symbolTable: CodeGenState.symbolTable,
       symbols: CodeGenState.symbols,
-      typeRegistry: CodeGenState.typeRegistry,
+      typeRegistry: CodeGenState.getTypeRegistryView(),
       functionSignatures: CodeGenState.functionSignatures,
       knownFunctions: CodeGenState.knownFunctions,
       knownStructs: CodeGenState.symbols?.knownStructs ?? new Set(),
@@ -451,7 +456,7 @@ export default class CodeGenerator implements IOrchestrator {
 
         // Type registration effects
         case "register-type":
-          CodeGenState.typeRegistry.set(effect.name, effect.info);
+          CodeGenState.setVariableTypeInfo(effect.name, effect.info);
           break;
         case "register-local":
           CodeGenState.localVariables.add(effect.name);
@@ -727,7 +732,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 = CodeGenState.typeRegistry.get(text);
+      const typeInfo = CodeGenState.getVariableTypeInfo(text);
       if (typeInfo?.isString) {
         return true;
       }
@@ -759,7 +764,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     const arrayName = arrayAccessMatch[1];
-    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(arrayName);
     if (!typeInfo) {
       return false;
     }
@@ -864,13 +869,20 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Generate function argument with pass-by-reference handling.
-   * Part of IOrchestrator interface - delegates to private implementation.
+   * Part of IOrchestrator interface - delegates to ArgumentGenerator.
    */
   generateFunctionArg(
     ctx: Parser.ExpressionContext,
     targetParamBaseType?: string,
   ): string {
-    return this._generateFunctionArg(ctx, targetParamBaseType);
+    const simpleId = CodegenParserUtils.getSimpleIdentifier(ctx);
+    return ArgumentGenerator.generateArg(ctx, simpleId, targetParamBaseType, {
+      getLvalueType: (c) => this.getLvalueType(c),
+      getMemberAccessArrayStatus: (c) => this.getMemberAccessArrayStatus(c),
+      needsCppMemberConversion: (c, t) => this.needsCppMemberConversion(c, t),
+      isStringSubscriptAccess: (c) => this.isStringSubscriptAccess(c),
+      generateExpression: (c) => this.generateExpression(c),
+    });
   }
 
   /**
@@ -1360,21 +1372,7 @@ export default class CodeGenerator implements IOrchestrator {
 
   /** Get the capacity of a string expression */
   getStringExprCapacity(exprCode: string): number | null {
-    // String literal - capacity equals content length
-    if (exprCode.startsWith('"') && exprCode.endsWith('"')) {
-      return StringUtils.literalLength(exprCode);
-    }
-
-    // Variable - check type registry
-    const identifierRegex = /^[a-zA-Z_]\w*$/;
-    if (identifierRegex.test(exprCode)) {
-      const typeInfo = CodeGenState.typeRegistry.get(exprCode);
-      if (typeInfo?.isString && typeInfo.stringCapacity !== undefined) {
-        return typeInfo.stringCapacity;
-      }
-    }
-
-    return null;
+    return StringOperationsHelper.getStringExprCapacity(exprCode);
   }
 
   // === Parameter Management (IOrchestrator A4) ===
@@ -1433,25 +1431,20 @@ export default class CodeGenerator implements IOrchestrator {
 
   // === Function Body Management (A4) ===
 
+  /**
+   * Enter function body - clears local variables and sets inFunctionBody flag.
+   * Issue #793: Delegates to FunctionContextManager.
+   */
   enterFunctionBody(): void {
-    CodeGenState.localVariables.clear();
-    CodeGenState.floatBitShadows.clear();
-    CodeGenState.floatShadowCurrent.clear();
-    // Issue #558: modifiedParameters tracking removed - uses analysis-phase results
-    CodeGenState.inFunctionBody = true;
-    // Sync with CodeGenState
-    CodeGenState.enterFunctionBody();
+    FunctionContextManager.enterFunctionBody();
   }
 
+  /**
+   * Exit function body - clears local variables and inFunctionBody flag.
+   * Issue #793: Delegates to FunctionContextManager.
+   */
   exitFunctionBody(): void {
-    CodeGenState.inFunctionBody = false;
-    CodeGenState.localVariables.clear();
-    CodeGenState.floatBitShadows.clear();
-    CodeGenState.floatShadowCurrent.clear();
-    CodeGenState.mainArgsName = null;
-    // Sync with CodeGenState
-    CodeGenState.exitFunctionBody();
-    CodeGenState.mainArgsName = null;
+    FunctionContextManager.exitFunctionBody();
   }
 
   setMainArgsName(name: string | null): void {
@@ -1604,7 +1597,7 @@ export default class CodeGenerator implements IOrchestrator {
     const injectedFuncs = new Set(crossFileModifications?.keys() ?? []);
 
     // Run modification analysis on the tree (adds to what was injected)
-    this.collectFunctionParametersAndModifications(tree);
+    PassByValueAnalyzer.collectFunctionParametersAndModifications(tree);
 
     // Issue #565: Run transitive propagation with full context
     TransitiveModificationPropagator.propagate(
@@ -1951,7 +1944,7 @@ export default class CodeGenerator implements IOrchestrator {
       isKnownPrimitive: (typeName: string) => this._isKnownPrimitive(typeName),
       knownEnums: CodeGenState.symbols!.knownEnums,
       isParameterPassByValue: (funcName: string, paramName: string) =>
-        this._isParameterPassByValueByName(funcName, paramName),
+        PassByValueAnalyzer.isParameterPassByValueByName(funcName, paramName),
       currentFunctionName: CodeGenState.currentFunctionName,
       maybeDereference: (id: string) => CppModeHelper.maybeDereference(id),
     };
@@ -2171,19 +2164,18 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #461: Initialize constValues from symbol table
+    // Only C-Next TSymbols have initialValue property
     CodeGenState.constValues = new Map();
     if (CodeGenState.symbolTable) {
-      for (const symbol of CodeGenState.symbolTable.getAllSymbols()) {
+      for (const symbol of CodeGenState.symbolTable.getAllTSymbols()) {
         if (
-          symbol.kind === ESymbolKind.Variable &&
+          symbol.kind === "variable" &&
           symbol.isConst &&
           symbol.initialValue !== undefined
         ) {
           const value = LiteralUtils.parseIntegerLiteral(symbol.initialValue);
           if (value !== undefined) {
             CodeGenState.constValues.set(symbol.name, value);
-            // Also populate CodeGenState
-            CodeGenState.constValues.set(symbol.name, value);
           }
         }
       }
@@ -2196,7 +2188,7 @@ export default class CodeGenerator implements IOrchestrator {
   private initializeHelperObjects(tree: Parser.ProgramContext): void {
     // Collect function/callback information
     this.collectFunctionsAndCallbacks(tree);
-    this.analyzePassByValue(tree);
+    PassByValueAnalyzer.analyze(tree);
   }
 
   /**
@@ -2491,7 +2483,10 @@ export default class CodeGenerator implements IOrchestrator {
         const funcDecl = member.functionDeclaration()!;
         const funcName = funcDecl.IDENTIFIER().getText();
         // Track fully qualified function name: Scope_function
-        const fullName = `${scopeName}_${funcName}`;
+        const fullName = QualifiedNameGenerator.forFunctionStrings(
+          scopeName,
+          funcName,
+        );
         CodeGenState.knownFunctions.add(fullName);
         // ADR-013: Track function signature for const checking
         const sig = this.extractFunctionSignature(
@@ -2556,66 +2551,11 @@ export default class CodeGenerator implements IOrchestrator {
    * SonarCloud S3776: Refactored to use helper methods.
    */
   private registerAllVariableTypes(tree: Parser.ProgramContext): void {
-    for (const decl of tree.declaration()) {
-      // Register global variable types
-      if (decl.variableDeclaration()) {
-        this.registerGlobalVariableType(decl.variableDeclaration()!);
-      }
-
-      // Register scope member variable types
-      if (decl.scopeDeclaration()) {
-        this.registerScopeMemberTypes(decl.scopeDeclaration()!);
-      }
-
-      // Note: Function parameters are registered per-function during generation
-      // since they're scoped to the function body
-    }
-  }
-
-  /**
-   * Register a global variable type and track const values.
-   * SonarCloud S3776: Extracted from registerAllVariableTypes().
-   */
-  private registerGlobalVariableType(
-    varDecl: Parser.VariableDeclarationContext,
-  ): void {
-    this.trackVariableType(varDecl);
-
-    // Bug #8: Track const values for array size resolution at file scope
-    if (varDecl.constModifier() && varDecl.expression()) {
-      const constName = varDecl.IDENTIFIER().getText();
-      const constValue = this.tryEvaluateConstant(varDecl.expression()!);
-      if (constValue !== undefined) {
-        CodeGenState.constValues.set(constName, constValue);
-      }
-    }
-  }
-
-  /**
-   * Register scope member variable types.
-   * SonarCloud S3776: Extracted from registerAllVariableTypes().
-   */
-  private registerScopeMemberTypes(
-    scopeDecl: Parser.ScopeDeclarationContext,
-  ): void {
-    const scopeName = scopeDecl.IDENTIFIER().getText();
-
-    // Set currentScope so that this.Type references resolve correctly
-    const savedScope = CodeGenState.currentScope;
-    this.setCurrentScope(scopeName);
-
-    for (const member of scopeDecl.scopeMember()) {
-      if (member.variableDeclaration()) {
-        const varDecl = member.variableDeclaration()!;
-        const varName = varDecl.IDENTIFIER().getText();
-        const fullName = `${scopeName}_${varName}`;
-        // Register with mangled name (Scope_variable)
-        this.trackVariableTypeWithName(varDecl, fullName);
-      }
-    }
-
-    // Restore previous scope
-    this.setCurrentScope(savedScope);
+    TypeRegistrationEngine.register(tree, {
+      tryEvaluateConstant: (ctx) => this.tryEvaluateConstant(ctx),
+      requireInclude: (header) => this.requireInclude(header),
+      resolveQualifiedType: (ids) => this.resolveQualifiedType(ids),
+    });
   }
 
   // Issue #60: collectEnum and collectBitmap methods removed - now in SymbolCollector
@@ -2623,1530 +2563,209 @@ export default class CodeGenerator implements IOrchestrator {
   // Issue #63: validateBitmapFieldLiteral moved to TypeValidator
   // Issue #60: evaluateConstantExpression method removed - now in SymbolCollector
 
-  // ========================================================================
-  // Issue #269: Pass-by-value analysis for small unmodified parameters
-  // ========================================================================
+  // Issue #269: Pass-by-value analysis extracted to PassByValueAnalyzer
 
   /**
-   * Analyze all functions to determine which parameters should pass by value.
-   * This runs before code generation and populates passByValueParams.
-   * SonarCloud S3776: Refactored to use helper methods.
+   * Issue #269: Check if a parameter should be passed by value (by index).
+   * Part of IOrchestrator interface - used by CallExprGenerator.
+   * Delegates to PassByValueAnalyzer.
    */
-  private analyzePassByValue(tree: Parser.ProgramContext): void {
-    // Reset analysis state
-    CodeGenState.modifiedParameters.clear();
-    CodeGenState.passByValueParams.clear();
-    CodeGenState.functionCallGraph.clear();
-    CodeGenState.functionParamLists.clear();
-
-    // Phase 1: Collect function parameter lists and direct modifications
-    this.collectFunctionParametersAndModifications(tree);
-
-    // Issue #558: Inject cross-file data before transitive propagation
-    this.injectCrossFileModifications();
-    this.injectCrossFileParamLists();
-
-    // Phase 2: Fixed-point iteration for transitive modifications
-    TransitiveModificationPropagator.propagate(
-      CodeGenState.functionCallGraph,
-      CodeGenState.functionParamLists,
-      CodeGenState.modifiedParameters,
-    );
-
-    // Phase 3: Determine which parameters can pass by value
-    this.computePassByValueParams();
+  isParameterPassByValue(funcName: string, paramIndex: number): boolean {
+    return PassByValueAnalyzer.isParameterPassByValue(funcName, paramIndex);
   }
 
   /**
-   * Inject cross-file modification data into modifiedParameters.
-   * SonarCloud S3776: Extracted from analyzePassByValue().
+   * Issue #269: Get all pass-by-value parameters.
+   * Returns a Map from function name to Set of parameter names that should be pass-by-value.
+   * Used by HeaderGenerator to ensure header and implementation signatures match.
    */
-  private injectCrossFileModifications(): void {
-    if (!CodeGenState.pendingCrossFileModifications) return;
-
-    for (const [
-      funcName,
-      params,
-    ] of CodeGenState.pendingCrossFileModifications) {
-      const existing = CodeGenState.modifiedParameters.get(funcName);
-      if (existing) {
-        for (const param of params) {
-          existing.add(param);
-        }
-      } else {
-        CodeGenState.modifiedParameters.set(funcName, new Set(params));
-      }
-    }
-    CodeGenState.pendingCrossFileModifications = null; // Clear after use
+  getPassByValueParams(): ReadonlyMap<string, ReadonlySet<string>> {
+    return CodeGenState.passByValueParams;
   }
 
   /**
-   * Inject cross-file parameter lists into functionParamLists.
-   * SonarCloud S3776: Extracted from analyzePassByValue().
+   * Issue #322: Check if a type name is a user-defined struct
+   * Part of IOrchestrator interface.
    */
-  private injectCrossFileParamLists(): void {
-    if (!CodeGenState.pendingCrossFileParamLists) return;
-
-    for (const [funcName, params] of CodeGenState.pendingCrossFileParamLists) {
-      if (!CodeGenState.functionParamLists.has(funcName)) {
-        CodeGenState.functionParamLists.set(funcName, [...params]);
-      }
-    }
-    CodeGenState.pendingCrossFileParamLists = null; // Clear after use
+  isStructType(typeName: string): boolean {
+    return TypeResolver.isStructType(typeName);
   }
 
   /**
-   * Phase 1: Walk all functions to collect:
-   * - Parameter lists (for call graph resolution)
-   * - Direct modifications (param <- value)
-   * - Function calls where params are passed as arguments
+   * Set up parameter tracking for a function.
+   * Issue #793: Delegates to FunctionContextManager.
    */
-  private collectFunctionParametersAndModifications(
-    tree: Parser.ProgramContext,
-  ): void {
-    for (const decl of tree.declaration()) {
-      // Handle scope-level functions
-      if (decl.scopeDeclaration()) {
-        const scopeDecl = decl.scopeDeclaration()!;
-        const scopeName = scopeDecl.IDENTIFIER().getText();
-
-        for (const member of scopeDecl.scopeMember()) {
-          if (member.functionDeclaration()) {
-            const funcDecl = member.functionDeclaration()!;
-            const funcName = funcDecl.IDENTIFIER().getText();
-            const fullName = `${scopeName}_${funcName}`;
-            this.analyzeFunctionForModifications(fullName, funcDecl);
-          }
-        }
-      }
-
-      // Handle top-level functions
-      if (decl.functionDeclaration()) {
-        const funcDecl = decl.functionDeclaration()!;
-        const name = funcDecl.IDENTIFIER().getText();
-        this.analyzeFunctionForModifications(name, funcDecl);
-      }
-    }
+  private _setParameters(params: Parser.ParameterListContext | null): void {
+    FunctionContextManager.processParameterList(
+      params,
+      this._getFunctionContextCallbacks(),
+    );
   }
 
   /**
-   * Analyze a single function for parameter modifications and call graph edges.
+   * Clear parameter tracking when leaving a function.
+   * Issue #793: Delegates to FunctionContextManager.
    */
-  private analyzeFunctionForModifications(
-    funcName: string,
-    funcDecl: Parser.FunctionDeclarationContext,
-  ): void {
-    // Collect parameter names
-    const paramNames: string[] = [];
-    const paramList = funcDecl.parameterList();
-    if (paramList) {
-      for (const param of paramList.parameter()) {
-        paramNames.push(param.IDENTIFIER().getText());
-      }
-    }
-    CodeGenState.functionParamLists.set(funcName, paramNames);
-
-    // Initialize modified set
-    CodeGenState.modifiedParameters.set(funcName, new Set());
-    // Issue #579: Initialize subscript access tracking
-    CodeGenState.subscriptAccessedParameters.set(funcName, new Set());
-    CodeGenState.functionCallGraph.set(funcName, []);
-
-    // Walk the function body to find modifications and calls
-    const block = funcDecl.block();
-    if (block) {
-      this.walkBlockForModifications(funcName, paramNames, block);
-    }
+  private _clearParameters(): void {
+    FunctionContextManager.clearParameters();
   }
 
   /**
-   * Walk a block to find parameter modifications and function calls.
+   * ADR-013: Extract function signature from parameter list
    */
-  private walkBlockForModifications(
-    funcName: string,
-    paramNames: string[],
-    block: Parser.BlockContext,
-  ): void {
-    const paramSet = new Set(paramNames);
+  private extractFunctionSignature(
+    name: string,
+    params: Parser.ParameterListContext | null,
+  ): FunctionSignature {
+    const parameters: Array<{
+      name: string;
+      baseType: string;
+      isConst: boolean;
+      isArray: boolean;
+    }> = [];
 
-    for (const stmt of block.statement()) {
-      this.walkStatementForModifications(funcName, paramSet, stmt);
+    if (params) {
+      for (const param of params.parameter()) {
+        const paramName = param.IDENTIFIER().getText();
+        const isConst = param.constModifier() !== null;
+        // arrayDimension() returns an array (due to grammar's *), so check length
+        // 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 });
+      }
     }
+
+    return { name, parameters };
   }
 
   /**
-   * Walk a statement recursively looking for modifications and calls.
-   * Issue #566: Refactored to use helper methods for expression and child collection.
+   * ADR-029: Register a function as a callback type
+   * The function name becomes both a callable function and a type for callback fields
    */
-  private walkStatementForModifications(
-    funcName: string,
-    paramSet: Set<string>,
-    stmt: Parser.StatementContext,
+  private registerCallbackType(
+    name: string,
+    funcDecl: Parser.FunctionDeclarationContext,
   ): void {
-    // 1. Check for parameter modifications via assignment targets
-    if (stmt.assignmentStatement()) {
-      this.trackAssignmentModifications(funcName, paramSet, stmt);
-    }
+    const returnType = this.generateType(funcDecl.type());
+    const parameters: Array<{
+      name: string;
+      type: string;
+      isConst: boolean;
+      isPointer: boolean;
+      isArray: boolean;
+      arrayDims: string;
+    }> = [];
 
-    // 2. Walk all expressions in this statement for function calls and subscript access
-    for (const expr of StatementExpressionCollector.collectAll(stmt)) {
-      this.walkExpressionForCalls(funcName, paramSet, expr);
-      // Issue #579: Also track subscript read access on parameters
-      this.walkExpressionForSubscriptAccess(funcName, paramSet, expr);
-    }
+    if (funcDecl.parameterList()) {
+      for (const param of funcDecl.parameterList()!.parameter()) {
+        const paramName = param.IDENTIFIER().getText();
+        const typeName = this.getTypeName(param.type());
+        const isConst = param.constModifier() !== null;
+        const dims = param.arrayDimension();
+        const arrayTypeCtx = param.type().arrayType();
+        const isArray = dims.length > 0 || arrayTypeCtx !== null;
 
-    // 3. Recurse into child statements and blocks
-    const { statements, blocks } = ChildStatementCollector.collectAll(stmt);
-    for (const childStmt of statements) {
-      this.walkStatementForModifications(funcName, paramSet, childStmt);
-    }
-    for (const block of blocks) {
-      this.walkBlockForModifications(funcName, [...paramSet], block);
-    }
-  }
+        // ADR-029: Check if parameter type is itself a callback type
+        const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
 
-  /**
-   * Track assignment modifications for parameter const inference.
-   * SonarCloud S3776: Extracted from walkStatementForModifications().
-   */
-  private trackAssignmentModifications(
-    funcName: string,
-    paramSet: Set<string>,
-    stmt: Parser.StatementContext,
-  ): void {
-    const assign = stmt.assignmentStatement()!;
-    const target = assign.assignmentTarget();
+        let paramType: string;
+        let isPointer: boolean;
 
-    const { baseIdentifier, hasSingleIndexSubscript } =
-      AssignmentTargetExtractor.extract(target);
+        if (isCallbackParam) {
+          // Use the callback typedef name
+          const cbInfo = CodeGenState.callbackTypes.get(typeName)!;
+          paramType = cbInfo.typedefName;
+          isPointer = false; // Function pointers are already pointers
+        } else {
+          paramType = this.generateType(param.type());
+          // ADR-006: Non-array parameters become pointers
+          isPointer = !isArray;
+        }
 
-    // Issue #579: Track subscript access on parameters (for write path)
-    if (
-      hasSingleIndexSubscript &&
-      baseIdentifier &&
-      paramSet.has(baseIdentifier)
-    ) {
-      CodeGenState.subscriptAccessedParameters
-        .get(funcName)!
-        .add(baseIdentifier);
+        let arrayDims: string;
+        if (dims.length > 0) {
+          arrayDims = dims.map((d) => this.generateArrayDimension(d)).join("");
+        } else if (arrayTypeCtx) {
+          // Generate all dimensions from arrayType (supports multi-dimensional)
+          arrayDims = arrayTypeCtx
+            .arrayTypeDimension()
+            .map((d) => {
+              const expr = d.expression();
+              return expr ? `[${this.generateExpression(expr)}]` : "[]";
+            })
+            .join("");
+        } else {
+          arrayDims = "";
+        }
+        parameters.push({
+          name: paramName,
+          type: paramType,
+          isConst,
+          isPointer,
+          isArray,
+          arrayDims,
+        });
+      }
     }
 
-    // Track as modified parameter
-    if (baseIdentifier && paramSet.has(baseIdentifier)) {
-      CodeGenState.modifiedParameters.get(funcName)!.add(baseIdentifier);
-    }
+    CodeGenState.callbackTypes.set(name, {
+      functionName: name,
+      returnType,
+      parameters,
+      typedefName: `${name}_fp`,
+    });
   }
 
   /**
-   * Walk an expression tree to find function calls where parameters are passed.
-   * Uses recursive descent through the expression hierarchy.
+   * ADR-029: Check if a function is used as a callback type (field type in a struct)
    */
-  private walkExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    expr: Parser.ExpressionContext,
-  ): void {
-    // Expression -> TernaryExpression -> OrExpression -> ... -> PostfixExpression
-    const ternary = expr.ternaryExpression();
-    if (ternary) {
-      // Walk all orExpression children
-      for (const orExpr of ternary.orExpression()) {
-        this.walkOrExpressionForCalls(funcName, paramSet, orExpr);
-      }
-    }
-  }
+  // Issue #63: validateCallbackAssignment, callbackSignaturesMatch, isConstValue,
+  //            and validateBareIdentifierInScope moved to TypeValidator
 
+  // EnumTypeResolver now handles: _getEnumTypeFromThisEnum, _getEnumTypeFromGlobalEnum,
+  // _getEnumTypeFromThisVariable, _getEnumTypeFromScopedEnum, _getEnumTypeFromMemberAccess,
+  // _getExpressionEnumType, _getFunctionCallEnumType
   /**
-   * Issue #579: Walk an expression tree to find subscript access on parameters.
-   * This tracks read access like `buf[i]` where buf is a parameter.
-   * Parameters with subscript access must become pointers.
+   * ADR-017: Check if an expression represents an integer literal or numeric type.
+   * Used to detect comparisons between enums and integers.
    */
-  private walkExpressionForSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    expr: Parser.ExpressionContext,
-  ): void {
-    const ternary = expr.ternaryExpression();
-    if (ternary) {
-      for (const orExpr of ternary.orExpression()) {
-        this.walkOrExpression(orExpr, (unaryExpr) => {
-          this.handleSubscriptAccess(funcName, paramSet, unaryExpr);
-        });
-      }
-    }
+  private _isIntegerExpression(
+    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
+  ): boolean {
+    return EnumAssignmentValidator.isIntegerExpression(ctx);
   }
 
   /**
-   * Issue #579: Handle subscript access on a unary expression.
-   * Only tracks single-index subscript access (which could be array access).
-   * Two-index subscript (e.g., value[start, width]) is always bit extraction,
-   * so it doesn't require the parameter to become a pointer.
+   * ADR-045: Check if an expression is a string concatenation.
+   * Delegates to StringOperationsHelper.
    */
-  private handleSubscriptAccess(
-    funcName: string,
-    paramSet: Set<string>,
-    unaryExpr: Parser.UnaryExpressionContext,
-  ): void {
-    const postfixExpr = unaryExpr.postfixExpression();
-    if (!postfixExpr) return;
-
-    const primary = postfixExpr.primaryExpression();
-    const ops = postfixExpr.postfixOp();
-
-    // Check if primary is a parameter and there's subscript access
-    const primaryId = primary.IDENTIFIER()?.getText();
-    if (!primaryId || !paramSet.has(primaryId)) {
-      return;
-    }
-
-    // Only track SINGLE-index subscript access (potential array access)
-    // Two-index subscript like value[0, 8] is bit extraction, not array access
-    const hasSingleIndexSubscript = ops.some(
-      (op) => op.expression().length === 1,
-    );
-    if (hasSingleIndexSubscript) {
-      CodeGenState.subscriptAccessedParameters.get(funcName)!.add(primaryId);
-    }
+  private _getStringConcatOperands(ctx: Parser.ExpressionContext): {
+    left: string;
+    right: string;
+    leftCapacity: number;
+    rightCapacity: number;
+  } | null {
+    return StringOperationsHelper.getStringConcatOperands(ctx);
   }
 
   /**
-   * Generic walker for orExpression trees.
-   * Walks through the expression hierarchy and calls the handler for each unaryExpression.
-   * Used by both function call tracking and subscript access tracking.
+   * ADR-045: Check if an expression is a substring extraction.
+   * Delegates to StringOperationsHelper.
    */
-  private walkOrExpression(
-    orExpr: Parser.OrExpressionContext,
-    handler: (unaryExpr: Parser.UnaryExpressionContext) => void,
-  ): void {
-    orExpr
-      .andExpression()
-      .flatMap((and) => and.equalityExpression())
-      .flatMap((eq) => eq.relationalExpression())
-      .flatMap((rel) => rel.bitwiseOrExpression())
-      .flatMap((bor) => bor.bitwiseXorExpression())
-      .flatMap((bxor) => bxor.bitwiseAndExpression())
-      .flatMap((band) => band.shiftExpression())
-      .flatMap((shift) => shift.additiveExpression())
-      .flatMap((add) => add.multiplicativeExpression())
-      .flatMap((mul) => mul.unaryExpression())
-      .forEach(handler);
-  }
-
-  /**
-   * Walk an orExpression tree for function calls.
-   */
-  private walkOrExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    orExpr: Parser.OrExpressionContext,
-  ): void {
-    this.walkOrExpression(orExpr, (unaryExpr) => {
-      this.walkUnaryExpressionForCalls(funcName, paramSet, unaryExpr);
+  private _getSubstringOperands(ctx: Parser.ExpressionContext): {
+    source: string;
+    start: string;
+    length: string;
+    sourceCapacity: number;
+  } | null {
+    return StringOperationsHelper.getSubstringOperands(ctx, {
+      generateExpression: (exprCtx) => this.generateExpression(exprCtx),
     });
   }
 
-  /**
-   * Walk a unaryExpression tree for function calls.
-   */
-  private walkUnaryExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    unaryExpr: Parser.UnaryExpressionContext,
-  ): void {
-    // Recurse into nested unary
-    if (unaryExpr.unaryExpression()) {
-      this.walkUnaryExpressionForCalls(
-        funcName,
-        paramSet,
-        unaryExpr.unaryExpression()!,
-      );
-      return;
-    }
-
-    // Check postfix expression
-    const postfix = unaryExpr.postfixExpression();
-    if (postfix) {
-      this.walkPostfixExpressionForCalls(funcName, paramSet, postfix);
-    }
-  }
-
-  /**
-   * Walk a postfixExpression for function calls.
-   * This is where function calls are found: primaryExpr followed by '(' args ')'
-   */
-  private walkPostfixExpressionForCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    postfix: Parser.PostfixExpressionContext,
-  ): void {
-    const primary = postfix.primaryExpression();
-    const postfixOps = postfix.postfixOp();
-
-    // Handle simple function calls: IDENTIFIER followed by '(' ... ')'
-    this.handleSimpleFunctionCall(funcName, paramSet, primary, postfixOps);
-
-    // Issue #365: Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
-    this.handleScopeQualifiedCalls(funcName, paramSet, primary, postfixOps);
-
-    // Recurse into primary expression if it's a parenthesized expression
-    if (primary.expression()) {
-      this.walkExpressionForCalls(funcName, paramSet, primary.expression()!);
-    }
-
-    // Walk arguments in any postfix function call ops (for nested calls)
-    this.walkPostfixOpsRecursively(funcName, paramSet, postfixOps);
-  }
-
-  /**
-   * Handle simple function calls: IDENTIFIER followed by '(' ... ')'
-   */
-  private handleSimpleFunctionCall(
-    funcName: string,
-    paramSet: Set<string>,
-    primary: Parser.PrimaryExpressionContext,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    if (!primary.IDENTIFIER() || postfixOps.length === 0) return;
-
-    const firstOp = postfixOps[0];
-    if (!firstOp.LPAREN()) return;
-
-    const calleeName = primary.IDENTIFIER()!.getText();
-    this.recordCallsFromArgList(funcName, paramSet, calleeName, firstOp);
-  }
-
-  /**
-   * Handle scope-qualified calls: Scope.method(...) or global.Scope.method(...)
-   * Track member accesses to build the mangled callee name (e.g., Storage_load)
-   */
-  private handleScopeQualifiedCalls(
-    funcName: string,
-    paramSet: Set<string>,
-    primary: Parser.PrimaryExpressionContext,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    if (postfixOps.length === 0) return;
-
-    const memberNames = this.collectInitialMemberNames(funcName, primary);
-
-    for (const op of postfixOps) {
-      if (op.IDENTIFIER()) {
-        memberNames.push(op.IDENTIFIER()!.getText());
-      } else if (op.LPAREN() && memberNames.length >= 1) {
-        const calleeName = memberNames.join("_");
-        this.recordCallsFromArgList(funcName, paramSet, calleeName, op);
-        memberNames.length = 0; // Reset for potential chained calls
-      } else if (op.expression().length > 0) {
-        memberNames.length = 0; // Array subscript breaks scope chain
-      }
-    }
-  }
-
-  /**
-   * Collect initial member names from primary expression for scope resolution.
-   * Issue #561: When 'this' is used, resolve to the current scope name from funcName.
-   */
-  private collectInitialMemberNames(
-    funcName: string,
-    primary: Parser.PrimaryExpressionContext,
-  ): string[] {
-    const memberNames: string[] = [];
-    const primaryId = primary.IDENTIFIER()?.getText();
-
-    if (primaryId && primaryId !== "global") {
-      memberNames.push(primaryId);
-    } else if (primary.THIS()) {
-      const scopeName = funcName.split("_")[0];
-      if (scopeName && scopeName !== funcName) {
-        memberNames.push(scopeName);
-      }
-    }
-    return memberNames;
-  }
-
-  /**
-   * Record function calls to the call graph from an argument list.
-   * Also recurses into argument expressions.
-   */
-  private recordCallsFromArgList(
-    funcName: string,
-    paramSet: Set<string>,
-    calleeName: string,
-    op: Parser.PostfixOpContext,
-  ): void {
-    const argList = op.argumentList();
-    if (!argList) return;
-
-    const args = argList.expression();
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      const argName = ExpressionUtils.extractIdentifier(arg);
-      if (argName && paramSet.has(argName)) {
-        CodeGenState.functionCallGraph.get(funcName)!.push({
-          callee: calleeName,
-          paramIndex: i,
-          argParamName: argName,
-        });
-      }
-      this.walkExpressionForCalls(funcName, paramSet, arg);
-    }
-  }
-
-  /**
-   * Walk postfix ops recursively for nested calls and array subscripts.
-   */
-  private walkPostfixOpsRecursively(
-    funcName: string,
-    paramSet: Set<string>,
-    postfixOps: Parser.PostfixOpContext[],
-  ): void {
-    for (const op of postfixOps) {
-      if (op.argumentList()) {
-        for (const argExpr of op.argumentList()!.expression()) {
-          this.walkExpressionForCalls(funcName, paramSet, argExpr);
-        }
-      }
-      for (const expr of op.expression()) {
-        this.walkExpressionForCalls(funcName, paramSet, expr);
-      }
-    }
-  }
-
-  /**
-   * Phase 3: Determine which parameters can pass by value.
-   * A parameter passes by value if:
-   * 1. It's a small primitive type (u8, i8, u16, i16, u32, i32, u64, i64, bool)
-   * 2. It's not modified (directly or transitively)
-   * 3. It's not an array, struct, string, or callback
-   */
-  private computePassByValueParams(): void {
-    const smallPrimitives = new Set([
-      "u8",
-      "i8",
-      "u16",
-      "i16",
-      "u32",
-      "i32",
-      "u64",
-      "i64",
-      "bool",
-    ]);
-
-    for (const [funcName, paramNames] of CodeGenState.functionParamLists) {
-      const passByValue = new Set<string>();
-      const modified =
-        CodeGenState.modifiedParameters.get(funcName) ?? new Set();
-
-      // Get function declaration to check parameter types
-      const funcSig = CodeGenState.functionSignatures.get(funcName);
-      if (funcSig) {
-        for (let i = 0; i < paramNames.length; i++) {
-          const paramName = paramNames[i];
-          const paramSig = funcSig.parameters[i];
-
-          if (!paramSig) continue;
-
-          // Check if eligible for pass-by-value:
-          // - Is a small primitive type
-          // - Not an array
-          // - Not modified
-          // - Not accessed via subscript (Issue #579)
-          const isSmallPrimitive = smallPrimitives.has(paramSig.baseType);
-          const isArray = paramSig.isArray ?? false;
-          const isModified = modified.has(paramName);
-          // Issue #579: Parameters with subscript access must become pointers
-          const hasSubscriptAccess =
-            CodeGenState.subscriptAccessedParameters
-              .get(funcName)
-              ?.has(paramName) ?? false;
-
-          if (
-            isSmallPrimitive &&
-            !isArray &&
-            !isModified &&
-            !hasSubscriptAccess
-          ) {
-            passByValue.add(paramName);
-          }
-        }
-      }
-
-      CodeGenState.passByValueParams.set(funcName, passByValue);
-    }
-  }
-
-  /**
-   * Check if a parameter should be passed by value (by name).
-   * Used internally during code generation.
-   */
-  private _isParameterPassByValueByName(
-    funcName: string,
-    paramName: string,
-  ): boolean {
-    const passByValue = CodeGenState.passByValueParams.get(funcName);
-    return passByValue?.has(paramName) ?? false;
-  }
-
-  /**
-   * Issue #269: Check if a parameter should be passed by value (by index).
-   * Part of IOrchestrator interface - used by CallExprGenerator.
-   */
-  isParameterPassByValue(funcName: string, paramIndex: number): boolean {
-    const paramList = CodeGenState.functionParamLists.get(funcName);
-    if (!paramList || paramIndex < 0 || paramIndex >= paramList.length) {
-      return false;
-    }
-    const paramName = paramList[paramIndex];
-    return this._isParameterPassByValueByName(funcName, paramName);
-  }
-
-  /**
-   * Issue #269: Get all pass-by-value parameters.
-   * Returns a Map from function name to Set of parameter names that should be pass-by-value.
-   * Used by HeaderGenerator to ensure header and implementation signatures match.
-   */
-  getPassByValueParams(): ReadonlyMap<string, ReadonlySet<string>> {
-    return CodeGenState.passByValueParams;
-  }
-
-  /**
-   * ADR-036: Try to evaluate an expression as a compile-time constant.
-   * Returns the numeric value if constant, undefined if not evaluable.
-   * Bug #8: Extended to resolve const variable references for file-scope array sizes.
-   * Issue #644: Delegates to ArrayDimensionParser for consolidated implementation.
-   */
-  // Issue #63: checkArrayBounds moved to TypeValidator
-
-  /**
-   * Evaluate array dimensions from ArrayDimensionContext[] to number[].
-   * Used for bitmap array registration.
-   * Issue #644: Delegates to ArrayDimensionParser for consolidated implementation.
-   */
-  private _evaluateArrayDimensions(
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-  ): number[] | undefined {
-    return ArrayDimensionParser.parseAllDimensions(arrayDim, {
-      constValues: CodeGenState.constValues,
-      typeWidths: TYPE_WIDTH,
-      isKnownStruct: (name) => this.isKnownStruct(name),
-    });
-  }
-
-  /**
-   * Try to register a type as enum or bitmap. Returns true if handled.
-   * Extracted to reduce duplication across type contexts (ADR-017, ADR-034).
-   */
-  private _tryRegisterEnumOrBitmapType(
-    name: string,
-    baseType: string,
-    isConst: boolean,
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-    overflowBehavior: TOverflowBehavior,
-    isAtomic: boolean,
-  ): boolean {
-    // Common options for type registration
-    const registrationOptions = {
-      name,
-      baseType,
-      isConst,
-      overflowBehavior,
-      isAtomic,
-    };
-
-    // ADR-017: Check if this is an enum type
-    if (
-      TypeRegistrationUtils.tryRegisterEnumType(
-        CodeGenState.typeRegistry,
-        CodeGenState.symbols!,
-        registrationOptions,
-      )
-    ) {
-      return true;
-    }
-
-    // ADR-034: Check if this is a bitmap type
-    const bitmapDimensions = this._evaluateArrayDimensions(arrayDim);
-    if (
-      TypeRegistrationUtils.tryRegisterBitmapType(
-        CodeGenState.typeRegistry,
-        CodeGenState.symbols!,
-        registrationOptions,
-        bitmapDimensions,
-      )
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Extract type info from a variable declaration and register it.
-   * Delegates to trackVariableTypeWithName using the variable's identifier.
-   */
-  private trackVariableType(varDecl: Parser.VariableDeclarationContext): void {
-    const name = varDecl.IDENTIFIER().getText();
-    this.trackVariableTypeWithName(varDecl, name);
-  }
-
-  // =========================================================================
-  // Type Registration Helpers - Extracted to reduce cognitive complexity
-  // =========================================================================
-
-  /**
-   * Extract array dimensions from ArrayDimensionContext array (simple parseInt version)
-   * Used for string array dimensions where const evaluation is not needed.
-   * Issue #644: Delegates to ArrayDimensionParser for consolidated implementation.
-   */
-  private extractArrayDimensionsSimple(
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-  ): number[] {
-    return ArrayDimensionParser.parseSimpleDimensions(arrayDim);
-  }
-
-  /**
-   * Register a string type in the type registry
-   * Returns true if registration was successful
-   */
-  private tryRegisterStringType(
-    registryName: string,
-    typeCtx: Parser.TypeContext,
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-    isConst: boolean,
-    overflowBehavior: TOverflowBehavior,
-    isAtomic: boolean,
-  ): boolean {
-    const stringCtx = typeCtx.stringType();
-    if (!stringCtx) {
-      return false;
-    }
-
-    const intLiteral = stringCtx.INTEGER_LITERAL();
-    if (!intLiteral) {
-      return false;
-    }
-
-    const capacity = Number.parseInt(intLiteral.getText(), 10);
-    this.requireInclude("string");
-    const stringDim = capacity + 1;
-
-    // Check if there are additional array dimensions (e.g., [4] in string<64> arr[4])
-    const additionalDims = this.extractArrayDimensionsSimple(arrayDim);
-    const allDims =
-      additionalDims.length > 0 ? [...additionalDims, stringDim] : [stringDim];
-
-    CodeGenState.typeRegistry.set(registryName, {
-      baseType: "char",
-      bitWidth: 8,
-      isArray: true,
-      arrayDimensions: allDims,
-      isConst,
-      isString: true,
-      stringCapacity: capacity,
-      overflowBehavior,
-      isAtomic,
-    });
-    return true;
-  }
-
-  /**
-   * Resolve base type name from a type context
-   * Handles scoped, global, qualified, and user types
-   */
-  private resolveBaseTypeFromContext(
-    typeCtx: Parser.TypeContext,
-  ): string | null {
-    if (typeCtx.primitiveType()) {
-      return typeCtx.primitiveType()!.getText();
-    }
-
-    if (typeCtx.scopedType()) {
-      // ADR-016: Handle this.Type for scoped types (e.g., this.State -> Motor_State)
-      const typeName = typeCtx.scopedType()!.IDENTIFIER().getText();
-      return CodeGenState.currentScope
-        ? `${CodeGenState.currentScope}_${typeName}`
-        : typeName;
-    }
-
-    if (typeCtx.globalType()) {
-      // Issue #478: Handle global.Type for global types inside scope
-      return typeCtx.globalType()!.IDENTIFIER().getText();
-    }
-
-    if (typeCtx.qualifiedType()) {
-      // ADR-016: Handle Scope.Type from outside scope
-      // Issue #388: Also handles C++ namespace types
-      const identifiers = typeCtx.qualifiedType()!.IDENTIFIER();
-      const identifierNames = identifiers.map((id) => id.getText());
-      return this.resolveQualifiedType(identifierNames);
-    }
-
-    if (typeCtx.userType()) {
-      return typeCtx.userType()!.getText();
-    }
-
-    return null;
-  }
-
-  /**
-   * Track variable type with a specific name (for namespace/class members)
-   * This allows tracking with mangled names for proper scope resolution
-   */
-  private trackVariableTypeWithName(
-    varDecl: Parser.VariableDeclarationContext,
-    registryName: string,
-  ): void {
-    const typeCtx = varDecl.type();
-    const arrayDim = varDecl.arrayDimension();
-    const isConst = varDecl.constModifier() !== null;
-
-    // ADR-044: Extract overflow modifier (clamp is default)
-    const overflowMod = varDecl.overflowModifier();
-    const overflowBehavior: TOverflowBehavior =
-      overflowMod?.getText() === "wrap" ? "wrap" : "clamp";
-
-    // ADR-049: Extract atomic modifier
-    const isAtomic = varDecl.atomicModifier() !== null;
-
-    // ADR-045: Handle bounded string type first (special case)
-    if (
-      this.tryRegisterStringType(
-        registryName,
-        typeCtx,
-        arrayDim,
-        isConst,
-        overflowBehavior,
-        isAtomic,
-      )
-    ) {
-      return;
-    }
-
-    // Handle array type syntax: u8[10]
-    if (typeCtx.arrayType()) {
-      this._registerArrayTypeVariable(
-        registryName,
-        typeCtx.arrayType()!,
-        arrayDim,
-        isConst,
-        overflowBehavior,
-        isAtomic,
-      );
-      return;
-    }
-
-    // Resolve base type from context (handles scoped, global, qualified, user types)
-    const baseType = this.resolveBaseTypeFromContext(typeCtx);
-    if (!baseType) {
-      return;
-    }
-
-    // ADR-017/ADR-034: Check if enum or bitmap type (reuse existing helper)
-    if (
-      this._tryRegisterEnumOrBitmapType(
-        registryName,
-        baseType,
-        isConst,
-        arrayDim,
-        overflowBehavior,
-        isAtomic,
-      )
-    ) {
-      return;
-    }
-
-    // Standard type registration
-    this._registerStandardType(
-      registryName,
-      baseType,
-      arrayDim,
-      isConst,
-      overflowBehavior,
-      isAtomic,
-    );
-  }
-
-  /**
-   * Register an array type variable (u8[10] syntax)
-   */
-  private _registerArrayTypeVariable(
-    registryName: string,
-    arrayTypeCtx: Parser.ArrayTypeContext,
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-    isConst: boolean,
-    overflowBehavior: TOverflowBehavior,
-    isAtomic: boolean,
-  ): void {
-    let baseType = "";
-    let bitWidth = 0;
-
-    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) {
-      return;
-    }
-
-    const arrayDimensions = this._collectArrayDimensions(
-      arrayTypeCtx,
-      arrayDim,
-    );
-
-    CodeGenState.typeRegistry.set(registryName, {
-      baseType,
-      bitWidth,
-      isArray: true,
-      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
-      isConst,
-      overflowBehavior,
-      isAtomic,
-    });
-  }
-
-  /**
-   * Parse array dimension from arrayType context.
-   */
-  private _parseArrayTypeDimensionFromCtx(
-    arrayTypeCtx: Parser.ArrayTypeContext,
-  ): number | undefined {
-    // Get first dimension for backwards compatibility
-    const dims = arrayTypeCtx.arrayTypeDimension();
-    if (dims.length === 0) {
-      return undefined;
-    }
-    const sizeExpr = dims[0].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
-   */
-  private _collectArrayDimensions(
-    arrayTypeCtx: Parser.ArrayTypeContext,
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-  ): number[] {
-    const arrayDimensions: number[] = [];
-
-    // Get all dimensions from array type syntax (supports multi-dimensional)
-    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
-      const sizeExpr = dim.expression();
-      if (sizeExpr) {
-        const size = Number.parseInt(sizeExpr.getText(), 10);
-        if (!Number.isNaN(size)) {
-          arrayDimensions.push(size);
-        }
-      }
-    }
-
-    // Add additional dimensions using const evaluation
-    const additionalDims = this._evaluateArrayDimensions(arrayDim);
-    if (additionalDims) {
-      arrayDimensions.push(...additionalDims);
-    }
-
-    return arrayDimensions;
-  }
-
-  /**
-   * Register a standard (non-array-syntax, non-special) type
-   */
-  private _registerStandardType(
-    registryName: string,
-    baseType: string,
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-    isConst: boolean,
-    overflowBehavior: TOverflowBehavior,
-    isAtomic: boolean,
-  ): void {
-    const bitWidth = TYPE_WIDTH[baseType] || 0;
-    // Issue #665: Check array syntax presence first, then try to resolve dimensions
-    // This matches the pattern in trackVariableType() - unresolved dimensions (e.g., enum
-    // members like EIndex.COUNT) should still mark the variable as an array
-    const isArray = arrayDim !== null && arrayDim.length > 0;
-    const arrayDimensions = isArray
-      ? this._evaluateArrayDimensions(arrayDim)
-      : undefined;
-
-    CodeGenState.typeRegistry.set(registryName, {
-      baseType,
-      bitWidth,
-      isArray,
-      arrayDimensions: isArray ? arrayDimensions : undefined,
-      isConst,
-      overflowBehavior,
-      isAtomic,
-    });
-  }
-
-  /**
-   * Issue #322: Check if a type name is a user-defined struct
-   * Part of IOrchestrator interface.
-   */
-  isStructType(typeName: string): boolean {
-    return TypeResolver.isStructType(typeName);
-  }
-
-  /**
-   * Set up parameter tracking for a function
-   */
-  private _setParameters(params: Parser.ParameterListContext | null): void {
-    CodeGenState.currentParameters.clear();
-    CodeGenState.currentParameters.clear();
-    if (!params) return;
-
-    for (const param of params.parameter()) {
-      this._processParameter(param);
-    }
-  }
-
-  /**
-   * Process a single parameter declaration
-   */
-  private _processParameter(param: Parser.ParameterContext): void {
-    const name = param.IDENTIFIER().getText();
-    // Check both C-Next style (u8[8] param) and legacy style (u8 param[8])
-    const isArray =
-      param.arrayDimension().length > 0 || param.type().arrayType() !== null;
-    const isConst = param.constModifier() !== null;
-    const typeCtx = param.type();
-
-    // Resolve type information
-    const typeInfo = this._resolveParameterTypeInfo(typeCtx);
-
-    // Register in currentParameters
-    const paramInfo = {
-      name,
-      baseType: typeInfo.typeName,
-      isArray,
-      isStruct: typeInfo.isStruct,
-      isConst,
-      isCallback: typeInfo.isCallback,
-      isString: typeInfo.isString,
-    };
-    CodeGenState.currentParameters.set(name, paramInfo);
-
-    // Register in typeRegistry
-    this._registerParameterType(name, typeInfo, param, isArray, isConst);
-  }
-
-  /**
-   * Resolve type name and flags from a type context
-   */
-  private _resolveParameterTypeInfo(typeCtx: Parser.TypeContext): {
-    typeName: string;
-    isStruct: boolean;
-    isCallback: boolean;
-    isString: boolean;
-  } {
-    if (typeCtx.primitiveType()) {
-      return {
-        typeName: typeCtx.primitiveType()!.getText(),
-        isStruct: false,
-        isCallback: false,
-        isString: false,
-      };
-    }
-
-    if (typeCtx.userType()) {
-      const typeName = typeCtx.userType()!.getText();
-      return {
-        typeName,
-        isStruct: this.isStructType(typeName),
-        isCallback: CodeGenState.callbackTypes.has(typeName),
-        isString: false,
-      };
-    }
-
-    if (typeCtx.qualifiedType()) {
-      const identifierNames = typeCtx
-        .qualifiedType()!
-        .IDENTIFIER()
-        .map((id) => id.getText());
-      const typeName = this.resolveQualifiedType(identifierNames);
-      return {
-        typeName,
-        isStruct: this.isStructType(typeName),
-        isCallback: false,
-        isString: false,
-      };
-    }
-
-    if (typeCtx.scopedType()) {
-      const localTypeName = typeCtx.scopedType()!.IDENTIFIER().getText();
-      const typeName = CodeGenState.currentScope
-        ? `${CodeGenState.currentScope}_${localTypeName}`
-        : localTypeName;
-      return {
-        typeName,
-        isStruct: this.isStructType(typeName),
-        isCallback: false,
-        isString: false,
-      };
-    }
-
-    if (typeCtx.globalType()) {
-      const typeName = typeCtx.globalType()!.IDENTIFIER().getText();
-      return {
-        typeName,
-        isStruct: this.isStructType(typeName),
-        isCallback: false,
-        isString: false,
-      };
-    }
-
-    if (typeCtx.stringType()) {
-      return {
-        typeName: "string",
-        isStruct: false,
-        isCallback: false,
-        isString: true,
-      };
-    }
-
-    // Handle C-Next style array type (u8[8] param) - extract base type
-    if (typeCtx.arrayType()) {
-      const arrayTypeCtx = typeCtx.arrayType()!;
-      if (arrayTypeCtx.primitiveType()) {
-        return {
-          typeName: arrayTypeCtx.primitiveType()!.getText(),
-          isStruct: false,
-          isCallback: false,
-          isString: false,
-        };
-      }
-      if (arrayTypeCtx.userType()) {
-        const typeName = arrayTypeCtx.userType()!.getText();
-        return {
-          typeName,
-          isStruct: this.isStructType(typeName),
-          isCallback: CodeGenState.callbackTypes.has(typeName),
-          isString: false,
-        };
-      }
-      // Handle string array type (string<32>[5] param)
-      if (arrayTypeCtx.stringType()) {
-        const stringCtx = arrayTypeCtx.stringType()!;
-        return {
-          typeName: stringCtx.getText(), // "string<32>"
-          isStruct: false,
-          isCallback: false,
-          isString: true,
-        };
-      }
-    }
-
-    // Fallback
-    return {
-      typeName: typeCtx.getText(),
-      isStruct: false,
-      isCallback: false,
-      isString: false,
-    };
-  }
-
-  /**
-   * Extract array dimensions from parameter (C-style or C-Next style).
-   */
-  private _extractParamArrayDimensions(
-    param: Parser.ParameterContext,
-    typeCtx: Parser.TypeContext,
-    isArray: boolean,
-  ): number[] {
-    if (!isArray) return [];
-
-    // Try C-style first (param.arrayDimension())
-    if (param.arrayDimension().length > 0) {
-      return ArrayDimensionParser.parseForParameters(param.arrayDimension());
-    }
-
-    // C-Next style: get dimensions from arrayType
-    const arrayTypeCtx = typeCtx.arrayType();
-    if (!arrayTypeCtx) return [];
-
-    const dimensions: number[] = [];
-    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
-      const expr = dim.expression();
-      if (!expr) continue;
-      const size = Number.parseInt(expr.getText(), 10);
-      if (!Number.isNaN(size)) {
-        dimensions.push(size);
-      }
-    }
-    return dimensions;
-  }
-
-  /**
-   * Register a parameter in the type registry
-   */
-  private _registerParameterType(
-    name: string,
-    typeInfo: { typeName: string; isString: boolean },
-    param: Parser.ParameterContext,
-    isArray: boolean,
-    isConst: boolean,
-  ): void {
-    const { typeName, isString } = typeInfo;
-    const typeCtx = param.type();
-
-    const isEnum = CodeGenState.symbols!.knownEnums.has(typeName);
-    const isBitmap = CodeGenState.symbols!.knownBitmaps.has(typeName);
-
-    // Extract array dimensions
-    const arrayDimensions = this._extractParamArrayDimensions(
-      param,
-      typeCtx,
-      isArray,
-    );
-
-    // Add string capacity dimension if applicable
-    const stringCapacity = this._getStringCapacity(typeCtx, isString);
-    if (isArray && stringCapacity !== undefined) {
-      arrayDimensions.push(stringCapacity + 1);
-    }
-
-    const registeredType = {
-      baseType: typeName,
-      bitWidth: isBitmap
-        ? CodeGenState.symbols!.bitmapBitWidth.get(typeName) || 0
-        : TYPE_WIDTH[typeName] || 0,
-      isArray,
-      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
-      isConst,
-      isEnum,
-      enumTypeName: isEnum ? typeName : undefined,
-      isBitmap,
-      bitmapTypeName: isBitmap ? typeName : undefined,
-      isString,
-      stringCapacity,
-      isParameter: true,
-    };
-    CodeGenState.typeRegistry.set(name, registeredType);
-  }
-
-  /**
-   * Extract string capacity from a string type context
-   */
-  private _getStringCapacity(
-    typeCtx: Parser.TypeContext,
-    isString: boolean,
-  ): number | undefined {
-    if (!isString) return undefined;
-
-    // Check direct stringType (e.g., string<32> param)
-    if (typeCtx.stringType()) {
-      const intLiteral = typeCtx.stringType()!.INTEGER_LITERAL();
-      if (intLiteral) {
-        return Number.parseInt(intLiteral.getText(), 10);
-      }
-    }
-
-    // Check arrayType with stringType (e.g., string<32>[5] param)
-    if (typeCtx.arrayType()?.stringType()) {
-      const intLiteral = typeCtx.arrayType()!.stringType()!.INTEGER_LITERAL();
-      if (intLiteral) {
-        return Number.parseInt(intLiteral.getText(), 10);
-      }
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Clear parameter tracking when leaving a function
-   */
-  private _clearParameters(): void {
-    // ADR-025: Remove parameter types from typeRegistry
-    for (const name of CodeGenState.currentParameters.keys()) {
-      CodeGenState.typeRegistry.delete(name);
-      CodeGenState.typeRegistry.delete(name);
-    }
-    CodeGenState.currentParameters.clear();
-    CodeGenState.localArrays.clear();
-    CodeGenState.currentParameters.clear();
-    CodeGenState.localArrays.clear();
-  }
-
-  /**
-   * ADR-013: Extract function signature from parameter list
-   */
-  private extractFunctionSignature(
-    name: string,
-    params: Parser.ParameterListContext | null,
-  ): FunctionSignature {
-    const parameters: Array<{
-      name: string;
-      baseType: string;
-      isConst: boolean;
-      isArray: boolean;
-    }> = [];
-
-    if (params) {
-      for (const param of params.parameter()) {
-        const paramName = param.IDENTIFIER().getText();
-        const isConst = param.constModifier() !== null;
-        // arrayDimension() returns an array (due to grammar's *), so check length
-        // 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 });
-      }
-    }
-
-    return { name, parameters };
-  }
-
-  /**
-   * ADR-029: Register a function as a callback type
-   * The function name becomes both a callable function and a type for callback fields
-   */
-  private registerCallbackType(
-    name: string,
-    funcDecl: Parser.FunctionDeclarationContext,
-  ): void {
-    const returnType = this.generateType(funcDecl.type());
-    const parameters: Array<{
-      name: string;
-      type: string;
-      isConst: boolean;
-      isPointer: boolean;
-      isArray: boolean;
-      arrayDims: string;
-    }> = [];
-
-    if (funcDecl.parameterList()) {
-      for (const param of funcDecl.parameterList()!.parameter()) {
-        const paramName = param.IDENTIFIER().getText();
-        const typeName = this.getTypeName(param.type());
-        const isConst = param.constModifier() !== null;
-        const dims = param.arrayDimension();
-        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 = CodeGenState.callbackTypes.has(typeName);
-
-        let paramType: string;
-        let isPointer: boolean;
-
-        if (isCallbackParam) {
-          // Use the callback typedef name
-          const cbInfo = CodeGenState.callbackTypes.get(typeName)!;
-          paramType = cbInfo.typedefName;
-          isPointer = false; // Function pointers are already pointers
-        } else {
-          paramType = this.generateType(param.type());
-          // ADR-006: Non-array parameters become pointers
-          isPointer = !isArray;
-        }
-
-        let arrayDims: string;
-        if (dims.length > 0) {
-          arrayDims = dims.map((d) => this.generateArrayDimension(d)).join("");
-        } else if (arrayTypeCtx) {
-          // Generate all dimensions from arrayType (supports multi-dimensional)
-          arrayDims = arrayTypeCtx
-            .arrayTypeDimension()
-            .map((d) => {
-              const expr = d.expression();
-              return expr ? `[${this.generateExpression(expr)}]` : "[]";
-            })
-            .join("");
-        } else {
-          arrayDims = "";
-        }
-        parameters.push({
-          name: paramName,
-          type: paramType,
-          isConst,
-          isPointer,
-          isArray,
-          arrayDims,
-        });
-      }
-    }
-
-    CodeGenState.callbackTypes.set(name, {
-      functionName: name,
-      returnType,
-      parameters,
-      typedefName: `${name}_fp`,
-    });
-  }
-
-  /**
-   * ADR-029: Check if a function is used as a callback type (field type in a struct)
-   */
-  // Issue #63: validateCallbackAssignment, callbackSignaturesMatch, isConstValue,
-  //            and validateBareIdentifierInScope moved to TypeValidator
-
-  // 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.
-   */
-  private _isIntegerExpression(
-    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
-  ): boolean {
-    return EnumAssignmentValidator.isIntegerExpression(ctx);
-  }
-
-  /**
-   * ADR-045: Check if an expression is a string concatenation (contains + with string operands).
-   * Returns the operand expressions if it is, null otherwise.
-   */
-  private _getStringConcatOperands(ctx: Parser.ExpressionContext): {
-    left: string;
-    right: string;
-    leftCapacity: number;
-    rightCapacity: number;
-  } | null {
-    // 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
-    if (multExprs.length !== 2) return null;
-
-    // Check if this is addition (not subtraction)
-    const text = add.getText();
-    if (text.includes("-")) return null;
-
-    // Get the operand texts
-    const leftText = multExprs[0].getText();
-    const rightText = multExprs[1].getText();
-
-    // Check if at least one operand is a string
-    const leftCapacity = this.getStringExprCapacity(leftText);
-    const rightCapacity = this.getStringExprCapacity(rightText);
-
-    if (leftCapacity === null && rightCapacity === null) {
-      return null; // Neither is a string
-    }
-
-    // If one is null, it's not a valid string concatenation
-    if (leftCapacity === null || rightCapacity === null) {
-      return null;
-    }
-
-    return {
-      left: leftText,
-      right: rightText,
-      leftCapacity,
-      rightCapacity,
-    };
-  }
-
-  /**
-   * ADR-045: Get the capacity of a string expression.
-   * For string literals, capacity is the literal length.
-   * For string variables, capacity is from the type registry.
-   */
-  /**
-   * ADR-045: Check if an expression is a substring extraction (string[start, length]).
-   * Returns the source string, start, length, and source capacity if it is.
-   * Issue #707: Uses ExpressionUnwrapper for tree navigation.
-   */
-  private _getSubstringOperands(ctx: Parser.ExpressionContext): {
-    source: string;
-    start: string;
-    length: string;
-    sourceCapacity: number;
-  } | null {
-    // Navigate to the postfix expression level using shared utility
-    const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
-    if (!postfix) return null;
-
-    const primary = postfix.primaryExpression();
-    const ops = postfix.postfixOp();
-
-    // Need exactly one postfix operation (the [start, length])
-    if (ops.length !== 1) return null;
-
-    const op = ops[0];
-    const exprs = op.expression();
-
-    // Get the source variable name first
-    const sourceId = primary.IDENTIFIER();
-    if (!sourceId) return null;
-
-    const sourceName = sourceId.getText();
-
-    // Check if source is a string type
-    const typeInfo = CodeGenState.typeRegistry.get(sourceName);
-    if (!typeInfo?.isString || typeInfo.stringCapacity === undefined) {
-      return null;
-    }
-
-    // Issue #140: Handle both [start, length] pattern (2 expressions)
-    // and single-character access [index] pattern (1 expression, treated as [index, 1])
-    if (exprs.length === 2) {
-      return {
-        source: sourceName,
-        start: this.generateExpression(exprs[0]),
-        length: this.generateExpression(exprs[1]),
-        sourceCapacity: typeInfo.stringCapacity,
-      };
-    } else if (exprs.length === 1) {
-      // Single-character access: source[i] is sugar for source[i, 1]
-      return {
-        source: sourceName,
-        start: this.generateExpression(exprs[0]),
-        length: "1",
-        sourceCapacity: typeInfo.stringCapacity,
-      };
-    }
-
-    return null;
-  }
-
   // ========================================================================
   // ADR-024: Type Classification and Validation Helpers
   // ========================================================================
@@ -4307,7 +2926,7 @@ export default class CodeGenerator implements IOrchestrator {
     baseId: string,
     targetParamBaseType: string,
   ): boolean {
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
     return CppMemberHelper.needsComplexMemberConversion(
       this._toPostfixOps(ops),
       typeInfo,
@@ -4334,7 +2953,7 @@ export default class CodeGenerator implements IOrchestrator {
     const baseId = primary.IDENTIFIER()?.getText();
     if (!baseId) return false;
 
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
     const paramInfo = CodeGenState.currentParameters.get(baseId);
 
     return CppMemberHelper.isStringSubscriptPattern(
@@ -4370,225 +2989,46 @@ export default class CodeGenerator implements IOrchestrator {
     if (!postfix) return "not-array";
 
     const ops = postfix.postfixOp();
-    if (ops.length === 0) return "not-array";
-
-    // Last operator must be member access (.identifier)
-    const lastOp = ops.at(-1)!;
-    const memberName = lastOp.IDENTIFIER()?.getText();
-    if (!memberName) return "not-array";
-
-    // Get the base identifier to find the struct type
-    const primary = postfix.primaryExpression();
-    if (!primary) return "not-array";
-    const baseId = primary.IDENTIFIER()?.getText();
-    if (!baseId) return "not-array";
-
-    // Look up the struct type from either:
-    // 1. Local variable: typeRegistry.get(baseId).baseType
-    // 2. Parameter: currentParameters.get(baseId).baseType
-    let structType: string | undefined;
-
-    const typeInfo = CodeGenState.typeRegistry.get(baseId);
-    if (typeInfo) {
-      structType = typeInfo.baseType;
-    } else {
-      const paramInfo = CodeGenState.currentParameters.get(baseId);
-      if (paramInfo) {
-        structType = paramInfo.baseType;
-      }
-    }
-
-    if (!structType) return "not-array";
-
-    // Check if this struct member is an array
-    const memberInfo = this.getMemberTypeInfo(structType, memberName);
-
-    // Issue #355: If memberInfo is undefined, we don't have struct field info
-    // This could mean the header wasn't parsed - return "unknown" for defensive generation
-    if (!memberInfo) {
-      return "unknown";
-    }
-
-    return memberInfo.isArray ? "array" : "not-array";
-  }
-
-  /**
-   * Generate a function argument with proper ADR-006 semantics.
-   * - Local variables get & (address-of)
-   * - Member access (cursor.x) gets & (address-of)
-   * - Array access (arr[i]) gets & (address-of)
-   * - Parameters are passed as-is (already pointers)
-   * - Arrays are passed as-is (naturally decay to pointers)
-   * - Literals use compound literals for pointer params: &(type){value}
-   * - Complex expressions are passed as-is
-   */
-  private _generateFunctionArg(
-    ctx: Parser.ExpressionContext,
-    targetParamBaseType?: string,
-  ): string {
-    const id = CodegenParserUtils.getSimpleIdentifier(ctx);
-    if (id) {
-      return this._handleIdentifierArg(id);
-    }
-
-    const lvalueType = this.getLvalueType(ctx);
-    if (lvalueType) {
-      return this._handleLvalueArg(ctx, lvalueType, targetParamBaseType);
-    }
-
-    return this._handleRvalueArg(ctx, targetParamBaseType);
-  }
-
-  /**
-   * Handle simple identifier argument (parameter, local array, scope member, or variable)
-   */
-  private _handleIdentifierArg(id: string): string {
-    // Parameters are already pointers
-    if (CodeGenState.currentParameters.get(id)) {
-      return id;
-    }
-
-    // Local arrays decay to pointers
-    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 (CodeGenState.currentScope) {
-      const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
-      if (members?.has(id)) {
-        const scopedName = `${CodeGenState.currentScope}_${id}`;
-        return CppModeHelper.maybeAddressOf(scopedName);
-      }
-    }
-
-    // Local variable - add & (except in C++ mode)
-    return CppModeHelper.maybeAddressOf(id);
-  }
-
-  /**
-   * Handle lvalue argument (member access or array access)
-   */
-  private _handleLvalueArg(
-    ctx: Parser.ExpressionContext,
-    lvalueType: string,
-    targetParamBaseType?: string,
-  ): string {
-    // Member access to array field - arrays decay to pointers
-    if (lvalueType === "member") {
-      const memberResult = this._handleMemberAccessArg(
-        ctx,
-        targetParamBaseType,
-      );
-      if (memberResult) return memberResult;
-    }
-
-    // Generate expression with address-of
-    const generatedExpr = this.generateExpression(ctx);
-    const expr = CppModeHelper.maybeAddressOf(generatedExpr);
-
-    // String subscript access may need cast
-    if (lvalueType === "array") {
-      return this._maybeCastStringSubscript(ctx, expr, targetParamBaseType);
-    }
-
-    return expr;
-  }
-
-  /**
-   * Handle member access argument - may need special handling for arrays or C++ conversions
-   */
-  private _handleMemberAccessArg(
-    ctx: Parser.ExpressionContext,
-    targetParamBaseType?: string,
-  ): string | null {
-    const arrayStatus = this.getMemberAccessArrayStatus(ctx);
-
-    // Array member - no address-of needed
-    if (arrayStatus === "array") {
-      return this.generateExpression(ctx);
-    }
-
-    // C++ mode may need temp variable for type conversion
-    if (
-      arrayStatus === "not-array" &&
-      this.needsCppMemberConversion(ctx, targetParamBaseType)
-    ) {
-      return this._createCppMemberConversionTemp(ctx, targetParamBaseType!);
-    }
-
-    return null; // Fall through to default lvalue handling
-  }
-
-  /**
-   * Create temp variable for C++ member conversion
-   */
-  private _createCppMemberConversionTemp(
-    ctx: Parser.ExpressionContext,
-    targetParamBaseType: string,
-  ): string {
-    const cType = TYPE_MAP[targetParamBaseType] || "uint8_t";
-    const value = this.generateExpression(ctx);
-    const tempName = `_cnx_tmp_${CodeGenState.tempVarCounter++}`;
-    const castExpr = CppModeHelper.cast(cType, value);
-    CodeGenState.pendingTempDeclarations.push(
-      `${cType} ${tempName} = ${castExpr};`,
-    );
-    return CppModeHelper.maybeAddressOf(tempName);
-  }
+    if (ops.length === 0) return "not-array";
 
-  /**
-   * Maybe cast string subscript access for integer pointer parameters
-   */
-  private _maybeCastStringSubscript(
-    ctx: Parser.ExpressionContext,
-    expr: string,
-    targetParamBaseType?: string,
-  ): string {
-    if (!targetParamBaseType || !this.isStringSubscriptAccess(ctx)) {
-      return expr;
-    }
+    // Last operator must be member access (.identifier)
+    const lastOp = ops.at(-1)!;
+    const memberName = lastOp.IDENTIFIER()?.getText();
+    if (!memberName) return "not-array";
 
-    const cType = TYPE_MAP[targetParamBaseType];
-    if (cType && !["float", "double", "bool", "void"].includes(cType)) {
-      return CppModeHelper.reinterpretCast(`${cType}*`, expr);
-    }
+    // Get the base identifier to find the struct type
+    const primary = postfix.primaryExpression();
+    if (!primary) return "not-array";
+    const baseId = primary.IDENTIFIER()?.getText();
+    if (!baseId) return "not-array";
 
-    return expr;
-  }
+    // Look up the struct type from either:
+    // 1. Local variable: typeRegistry.get(baseId).baseType
+    // 2. Parameter: currentParameters.get(baseId).baseType
+    let structType: string | undefined;
 
-  /**
-   * Handle rvalue argument (literals or complex expressions)
-   */
-  private _handleRvalueArg(
-    ctx: Parser.ExpressionContext,
-    targetParamBaseType?: string,
-  ): string {
-    if (!targetParamBaseType) {
-      return this.generateExpression(ctx);
+    const typeInfo = CodeGenState.getVariableTypeInfo(baseId);
+    if (typeInfo) {
+      structType = typeInfo.baseType;
+    } else {
+      const paramInfo = CodeGenState.currentParameters.get(baseId);
+      if (paramInfo) {
+        structType = paramInfo.baseType;
+      }
     }
 
-    const cType = TYPE_MAP[targetParamBaseType];
-    if (!cType || cType === "void") {
-      return this.generateExpression(ctx);
-    }
+    if (!structType) return "not-array";
 
-    const value = this.generateExpression(ctx);
+    // Check if this struct member is an array
+    const memberInfo = this.getMemberTypeInfo(structType, memberName);
 
-    // C++ mode: rvalues can bind to const T&
-    if (CodeGenState.cppMode) {
-      return value;
+    // Issue #355: If memberInfo is undefined, we don't have struct field info
+    // This could mean the header wasn't parsed - return "unknown" for defensive generation
+    if (!memberInfo) {
+      return "unknown";
     }
 
-    // C mode: Use compound literal syntax
-    return `&(${cType}){${value}}`;
+    return memberInfo.isArray ? "array" : "not-array";
   }
 
   // ========================================================================
@@ -4711,7 +3151,7 @@ export default class CodeGenerator implements IOrchestrator {
   ): void {
     const type = this.generateType(varDecl.type());
     const varName = varDecl.IDENTIFIER().getText();
-    const fullName = `${scopeName}_${varName}`;
+    const fullName = QualifiedNameGenerator.forMember(scopeName, varName);
     const prefix = isPrivate ? "static " : "";
 
     const arrayDims = varDecl.arrayDimension();
@@ -4722,7 +3162,10 @@ export default class CodeGenerator implements IOrchestrator {
 
     // Handle arrayType dimension (C-Next style: u8[16] data)
     if (hasArrayTypeSyntax) {
-      decl += this._getArrayTypeDimension(varDecl.type());
+      decl += VariableDeclHelper.getArrayTypeDimension(varDecl.type(), {
+        tryEvaluateConstant: (exprCtx) => this.tryEvaluateConstant(exprCtx),
+        generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+      });
     }
 
     // Handle arrayDimension (C-style or additional dimensions)
@@ -4764,7 +3207,10 @@ export default class CodeGenerator implements IOrchestrator {
   ): void {
     const returnType = this.generateType(funcDecl.type());
     const funcName = funcDecl.IDENTIFIER().getText();
-    const fullName = `${scopeName}_${funcName}`;
+    const fullName = QualifiedNameGenerator.forFunctionStrings(
+      scopeName,
+      funcName,
+    );
     const prefix = isPrivate ? "static " : "";
 
     // Issue #269: Set current function name for pass-by-value lookup
@@ -5159,32 +3605,34 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * Set up context for function generation
+   * Set up context for function generation.
+   * Issue #793: Delegates to FunctionContextManager.
    */
   private _setupFunctionContext(
     name: string,
     ctx: Parser.FunctionDeclarationContext,
   ): void {
-    // Issue #269: Set current function name for pass-by-value lookup
-    const fullFuncName = CodeGenState.currentScope
-      ? `${CodeGenState.currentScope}_${name}`
-      : name;
-    CodeGenState.currentFunctionName = fullFuncName;
-    // Issue #477: Set return type for enum inference in return statements
-    CodeGenState.currentFunctionReturnType = ctx.type().getText();
-
-    // Track parameters for ADR-006 pointer semantics
-    this._setParameters(ctx.parameterList() ?? null);
+    FunctionContextManager.setupFunctionContext(
+      name,
+      ctx,
+      this._getFunctionContextCallbacks(),
+    );
+  }
 
-    // ADR-016: Clear local variables and mark that we're in a function body
-    CodeGenState.localVariables.clear();
-    CodeGenState.floatBitShadows.clear();
-    CodeGenState.floatShadowCurrent.clear();
-    CodeGenState.inFunctionBody = true;
+  /**
+   * Issue #793: Create callbacks for FunctionContextManager.
+   */
+  private _getFunctionContextCallbacks(): IFunctionContextCallbacks {
+    return {
+      isStructType: (typeName: string) => this.isStructType(typeName),
+      resolveQualifiedType: (identifiers: string[]) =>
+        this.resolveQualifiedType(identifiers),
+    };
   }
 
   /**
-   * Resolve return type and initial params for function
+   * Resolve return type and initial params for function.
+   * Issue #793: Delegates to FunctionContextManager.
    */
   private _resolveReturnTypeAndParams(
     name: string,
@@ -5192,33 +3640,20 @@ export default class CodeGenerator implements IOrchestrator {
     isMainWithArgs: boolean,
     ctx: Parser.FunctionDeclarationContext,
   ): { actualReturnType: string; initialParams: string } {
-    if (isMainWithArgs) {
-      // Special case: main(u8 args[][]) -> int main(int argc, char *argv[])
-      const argsParam = ctx.parameterList()!.parameter()[0];
-      CodeGenState.mainArgsName = argsParam.IDENTIFIER().getText();
-      return {
-        actualReturnType: "int",
-        initialParams: "int argc, char *argv[]",
-      };
-    }
-
-    // For main() without args, always use int return type for C++ compatibility
-    const actualReturnType = name === "main" ? "int" : returnType;
-    return { actualReturnType, initialParams: "" };
+    return FunctionContextManager.resolveReturnTypeAndParams(
+      name,
+      returnType,
+      isMainWithArgs,
+      ctx,
+    );
   }
 
   /**
-   * Clean up context after function generation
+   * Clean up context after function generation.
+   * Issue #793: Delegates to FunctionContextManager.
    */
   private _cleanupFunctionContext(): void {
-    CodeGenState.inFunctionBody = false;
-    CodeGenState.localVariables.clear();
-    CodeGenState.floatBitShadows.clear();
-    CodeGenState.floatShadowCurrent.clear();
-    CodeGenState.mainArgsName = null;
-    CodeGenState.currentFunctionName = null;
-    CodeGenState.currentFunctionReturnType = null;
-    this._clearParameters();
+    FunctionContextManager.cleanupFunctionContext();
   }
 
   /**
@@ -5325,7 +3760,10 @@ export default class CodeGenerator implements IOrchestrator {
     // Small unmodified primitives
     if (
       CodeGenState.currentFunctionName &&
-      this._isParameterPassByValueByName(CodeGenState.currentFunctionName, name)
+      PassByValueAnalyzer.isParameterPassByValueByName(
+        CodeGenState.currentFunctionName,
+        name,
+      )
     ) {
       return true;
     }
@@ -5338,74 +3776,27 @@ export default class CodeGenerator implements IOrchestrator {
   // ========================================================================
 
   private generateVariableDecl(ctx: Parser.VariableDeclarationContext): string {
-    // Issue #375: Check for C++ constructor syntax - early return
-    const constructorArgList = ctx.constructorArgumentList();
-    if (constructorArgList) {
-      return this._generateConstructorDecl(ctx, constructorArgList);
-    }
-
-    // Issue #696: Use helper for modifier extraction and validation
-    const modifiers = VariableModifierBuilder.build(
-      ctx,
-      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 = 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;
-    }
-
-    // Build base declaration
-    const modifierPrefix = VariableModifierBuilder.toPrefix(modifiers);
-    let decl = `${modifierPrefix}${type} ${name}`;
-
-    // Handle array declarations - early return if array init handled
-    const arrayResult = this._handleArrayDeclaration(ctx, typeCtx, name, decl);
-    if (arrayResult.handled) {
-      return arrayResult.code;
-    }
-    decl = arrayResult.decl;
-
-    // Handle initialization
-    decl = this._generateVariableInitializer(
-      ctx,
-      typeCtx,
-      decl,
-      arrayResult.isArray,
-    );
-
-    // Handle pending C++ class field assignments
-    return this._finalizeCppClassAssignments(ctx, typeCtx, name, decl);
+    // Issue #792: Delegate to VariableDeclHelper
+    return VariableDeclHelper.generateVariableDecl(ctx, {
+      generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+      generateType: (typeCtx) => this.generateType(typeCtx),
+      getTypeName: (typeCtx) => this.getTypeName(typeCtx),
+      generateArrayDimensions: (dims) => this.generateArrayDimensions(dims),
+      tryEvaluateConstant: (exprCtx) => this.tryEvaluateConstant(exprCtx),
+      getZeroInitializer: (typeCtx, isArray) =>
+        this.getZeroInitializer(typeCtx, isArray),
+      getExpressionType: (exprCtx) => this.getExpressionType(exprCtx),
+      inferVariableType: (varCtx, name) =>
+        this._inferVariableType(varCtx, name),
+      trackLocalVariable: (varCtx, name) =>
+        this._trackLocalVariable(varCtx, name),
+      getStringConcatOperands: (concatCtx) =>
+        this._getStringConcatOperands(concatCtx),
+      getSubstringOperands: (substrCtx) =>
+        this._getSubstringOperands(substrCtx),
+      getStringExprCapacity: (exprCode) => this.getStringExprCapacity(exprCode),
+      requireStringInclude: () => this.requireInclude("string"),
+    });
   }
 
   /**
@@ -5442,7 +3833,11 @@ export default class CodeGenerator implements IOrchestrator {
       return;
     }
 
-    this.trackVariableType(ctx);
+    TypeRegistrationEngine.trackVariable(ctx, {
+      tryEvaluateConstant: (expr) => this.tryEvaluateConstant(expr),
+      requireInclude: (header) => this.requireInclude(header),
+      resolveQualifiedType: (ids) => this.resolveQualifiedType(ids),
+    });
     CodeGenState.localVariables.add(name);
 
     // Bug #8: Track local const values for array size and bit index resolution
@@ -5454,383 +3849,10 @@ export default class CodeGenerator implements IOrchestrator {
     }
   }
 
-  /**
-   * 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,
-    typeCtx: Parser.TypeContext,
-    name: string,
-    decl: string,
-  ): { handled: boolean; code: string; decl: string; isArray: boolean } {
-    const arrayDims = ctx.arrayDimension();
-    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._parseArrayTypeDimension(typeCtx) ??
-      this._parseFirstArrayDimension(arrayDims);
-
-    // ADR-035: Handle array initializers with size inference
-    if (ctx.expression()) {
-      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}${fullDimSuffix} = ${arrayInitResult.initValue};`,
-          decl,
-          isArray: true,
-        };
-      }
-    }
-
-    // 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]", u16[4][4] -> "[4][4]").
-   * Evaluates const expressions to their numeric values for C compatibility.
-   */
-  private _getArrayTypeDimension(typeCtx: Parser.TypeContext): string {
-    if (!typeCtx.arrayType()) {
-      return "";
-    }
-    const dims = typeCtx.arrayType()!.arrayTypeDimension();
-    let result = "";
-    for (const dim of dims) {
-      const sizeExpr = dim.expression();
-      if (!sizeExpr) {
-        result += "[]";
-        continue;
-      }
-      // Try to evaluate as constant first (required for C file-scope arrays)
-      // Fall back to expression text for macros, enums, etc.
-      const dimValue =
-        this.tryEvaluateConstant(sizeExpr) ?? this.generateExpression(sizeExpr);
-      result += `[${dimValue}]`;
-    }
-    return result;
-  }
-
-  /**
-   * Parse first array dimension from arrayType syntax for size validation.
-   */
-  private _parseArrayTypeDimension(typeCtx: Parser.TypeContext): number | null {
-    if (!typeCtx.arrayType()) {
-      return null;
-    }
-    const dims = typeCtx.arrayType()!.arrayTypeDimension();
-    if (dims.length === 0) {
-      return null;
-    }
-    const sizeExpr = dims[0].expression();
-    if (!sizeExpr) {
-      return null;
-    }
-    const sizeText = sizeExpr.getText();
-    const digitRegex = /^\d+$/;
-    if (digitRegex.exec(sizeText)) {
-      return Number.parseInt(sizeText, 10);
-    }
-    return null;
-  }
-
-  /**
-   * Issue #696: Parse first array dimension for validation.
-   */
-  private _parseFirstArrayDimension(
-    arrayDims: Parser.ArrayDimensionContext[],
-  ): number | null {
-    if (arrayDims.length === 0 || !arrayDims[0].expression()) {
-      return null;
-    }
-    const sizeText = arrayDims[0].expression()!.getText();
-    if (/^\d+$/.exec(sizeText)) {
-      return Number.parseInt(sizeText, 10);
-    }
-    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.
-   */
-  private _generateVariableInitializer(
-    ctx: Parser.VariableDeclarationContext,
-    typeCtx: Parser.TypeContext,
-    decl: string,
-    isArray: boolean,
-  ): string {
-    if (!ctx.expression()) {
-      // ADR-015: Zero initialization for uninitialized variables
-      return `${decl} = ${this.getZeroInitializer(typeCtx, isArray)}`;
-    }
-
-    const typeName = this.getTypeName(typeCtx);
-    const savedExpectedType = CodeGenState.expectedType;
-    CodeGenState.expectedType = typeName;
-
-    // ADR-017: Validate enum type for initialization
-    EnumAssignmentValidator.validateEnumAssignment(typeName, ctx.expression()!);
-
-    // ADR-024: Validate integer literals and type conversions
-    this._validateIntegerInitializer(ctx, typeName);
-
-    const result = `${decl} = ${this.generateExpression(ctx.expression()!)}`;
-    CodeGenState.expectedType = savedExpectedType;
-
-    return result;
-  }
-
-  /**
-   * Issue #696: Validate integer initializer using helper.
-   */
-  private _validateIntegerInitializer(
-    ctx: Parser.VariableDeclarationContext,
-    typeName: string,
-  ): void {
-    if (!this._isIntegerType(typeName)) {
-      return;
-    }
-
-    const exprText = ctx.expression()!.getText().trim();
-    const line = ctx.start?.line ?? 0;
-    const col = ctx.start?.column ?? 0;
-    const isLiteral = LiteralUtils.parseIntegerLiteral(exprText) !== undefined;
-
-    try {
-      if (isLiteral) {
-        // Direct literal - validate it fits in the target type
-        this._validateLiteralFitsType(exprText, typeName);
-      } else {
-        // Not a literal - check for narrowing/sign conversions
-        const sourceType = this.getExpressionType(ctx.expression()!);
-        this._validateTypeConversion(typeName, sourceType);
-      }
-    } catch (validationError) {
-      const msg =
-        validationError instanceof Error
-          ? validationError.message
-          : String(validationError);
-      throw new Error(`${line}:${col} ${msg}`, { cause: validationError });
-    }
-  }
-
-  /**
-   * Issue #696: Handle pending C++ class field assignments.
-   */
-  private _finalizeCppClassAssignments(
-    _ctx: Parser.VariableDeclarationContext,
-    typeCtx: Parser.TypeContext,
-    name: string,
-    decl: string,
-  ): string {
-    if (CodeGenState.pendingCppClassAssignments.length === 0) {
-      return `${decl};`;
-    }
-
-    if (CodeGenState.inFunctionBody) {
-      const assignments = CodeGenState.pendingCppClassAssignments
-        .map((a) => `${name}.${a}`)
-        .join("\n");
-      CodeGenState.pendingCppClassAssignments = [];
-      return `${decl};\n${assignments}`;
-    }
-
-    // At global scope, we can't emit assignment statements.
-    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.`,
-    );
-  }
-
-  /**
-   * Issue #375: Generate C++ constructor-style declaration
-   * Validates that all arguments are const variables.
-   * Example: `Adafruit_MAX31856 thermocouple(pinConst);` -> `Adafruit_MAX31856 thermocouple(pinConst);`
-   */
-  private _generateConstructorDecl(
-    ctx: Parser.VariableDeclarationContext,
-    argListCtx: Parser.ConstructorArgumentListContext,
-  ): string {
-    const type = this.generateType(ctx.type());
-    const name = ctx.IDENTIFIER().getText();
-    const line = ctx.start?.line ?? 0;
-
-    // Collect and validate all arguments
-    const argIdentifiers = argListCtx.IDENTIFIER();
-    const resolvedArgs: string[] = [];
-
-    for (const argNode of argIdentifiers) {
-      const argName = argNode.getText();
-
-      // Check if it exists in type registry
-      const typeInfo = CodeGenState.typeRegistry.get(argName);
-
-      // Also check scoped variables if inside a scope
-      let scopedArgName = argName;
-      let scopedTypeInfo = typeInfo;
-      if (!typeInfo && CodeGenState.currentScope) {
-        scopedArgName = `${CodeGenState.currentScope}_${argName}`;
-        scopedTypeInfo = CodeGenState.typeRegistry.get(scopedArgName);
-      }
-
-      if (!typeInfo && !scopedTypeInfo) {
-        throw new Error(
-          `Error at line ${line}: Constructor argument '${argName}' is not declared`,
-        );
-      }
-
-      const finalTypeInfo = typeInfo ?? scopedTypeInfo!;
-      const finalArgName = typeInfo ? argName : scopedArgName;
-
-      // Check if it's const
-      if (!finalTypeInfo.isConst) {
-        throw new Error(
-          `Error at line ${line}: Constructor argument '${argName}' must be const. ` +
-            `C++ constructors in C-Next only accept const variables.`,
-        );
-      }
-
-      resolvedArgs.push(finalArgName);
-    }
-
-    // Track the variable in type registry (as an external C++ type)
-    CodeGenState.typeRegistry.set(name, {
-      baseType: type,
-      bitWidth: 0, // Unknown for C++ types
-      isArray: false,
-      arrayDimensions: [],
-      isConst: false,
-      isExternalCppType: true,
-    });
-
-    // Track as local variable if inside function body
-    if (CodeGenState.inFunctionBody) {
-      CodeGenState.localVariables.add(name);
-    }
-
-    return `${type} ${name}(${resolvedArgs.join(", ")});`;
-  }
+  // Issue #792: Methods _handleArrayDeclaration, _getArrayTypeDimension, _parseArrayTypeDimension,
+  // _parseFirstArrayDimension, _validateArrayDeclarationSyntax, _extractBaseTypeName,
+  // _generateVariableInitializer, _validateIntegerInitializer, _finalizeCppClassAssignments,
+  // and _generateConstructorDecl have been extracted to VariableDeclHelper.ts
 
   /**
    * Get zero initializer for array types.
@@ -6055,7 +4077,7 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-109: Dispatch to assignment handlers
     // Build context, classify, and dispatch - all patterns handled by handlers
     const assignCtx = buildAssignmentContext(ctx, {
-      typeRegistry: CodeGenState.typeRegistry,
+      typeRegistry: CodeGenState.getTypeRegistryView(),
       generateExpression: () => value,
       generateAssignmentTarget: (targetCtx) =>
         this.generateAssignmentTarget(targetCtx),