c-next 0.1.70 → 0.1.72

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";
@@ -126,6 +130,9 @@ import TransitiveModificationPropagator from "../../logic/analysis/helpers/Trans
 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
@@ -137,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,
@@ -860,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),
+    });
   }
 
   /**
@@ -1356,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.getVariableTypeInfo(exprCode);
-      if (typeInfo?.isString && typeInfo.stringCapacity !== undefined) {
-        return typeInfo.stringCapacity;
-      }
-    }
-
-    return null;
+    return StringOperationsHelper.getStringExprCapacity(exprCode);
   }
 
   // === Parameter Management (IOrchestrator A4) ===
@@ -1429,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 {
@@ -2167,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);
           }
         }
       }
@@ -2487,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(
@@ -2552,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
@@ -2640,830 +2584,163 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * 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.symbols!,
-        registrationOptions,
-      )
-    ) {
-      return true;
-    }
-
-    // ADR-034: Check if this is a bitmap type
-    const bitmapDimensions = this._evaluateArrayDimensions(arrayDim);
-    if (
-      TypeRegistrationUtils.tryRegisterBitmapType(
-        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.
+   * Issue #322: Check if a type name is a user-defined struct
+   * Part of IOrchestrator interface.
    */
-  private trackVariableType(varDecl: Parser.VariableDeclarationContext): void {
-    const name = varDecl.IDENTIFIER().getText();
-    this.trackVariableTypeWithName(varDecl, name);
+  isStructType(typeName: string): boolean {
+    return TypeResolver.isStructType(typeName);
   }
 
-  // =========================================================================
-  // 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.
+   * Set up parameter tracking for a function.
+   * Issue #793: Delegates to FunctionContextManager.
    */
-  private extractArrayDimensionsSimple(
-    arrayDim: Parser.ArrayDimensionContext[] | null,
-  ): number[] {
-    return ArrayDimensionParser.parseSimpleDimensions(arrayDim);
+  private _setParameters(params: Parser.ParameterListContext | null): void {
+    FunctionContextManager.processParameterList(
+      params,
+      this._getFunctionContextCallbacks(),
+    );
   }
 
   /**
-   * Register a string type in the type registry
-   * Returns true if registration was successful
+   * Clear parameter tracking when leaving a function.
+   * Issue #793: Delegates to FunctionContextManager.
    */
-  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.setVariableTypeInfo(registryName, {
-      baseType: "char",
-      bitWidth: 8,
-      isArray: true,
-      arrayDimensions: allDims,
-      isConst,
-      isString: true,
-      stringCapacity: capacity,
-      overflowBehavior,
-      isAtomic,
-    });
-    return true;
+  private _clearParameters(): void {
+    FunctionContextManager.clearParameters();
   }
 
   /**
-   * Resolve base type name from a type context
-   * Handles scoped, global, qualified, and user types
+   * ADR-013: Extract function signature from parameter list
    */
-  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);
-    }
+  private extractFunctionSignature(
+    name: string,
+    params: Parser.ParameterListContext | null,
+  ): FunctionSignature {
+    const parameters: Array<{
+      name: string;
+      baseType: string;
+      isConst: boolean;
+      isArray: boolean;
+    }> = [];
 
-    if (typeCtx.userType()) {
-      return typeCtx.userType()!.getText();
+    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 null;
+    return { name, parameters };
   }
 
   /**
-   * Track variable type with a specific name (for namespace/class members)
-   * This allows tracking with mangled names for proper scope resolution
+   * ADR-029: Register a function as a callback type
+   * The function name becomes both a callable function and a type for callback fields
    */
-  private trackVariableTypeWithName(
-    varDecl: Parser.VariableDeclarationContext,
-    registryName: string,
+  private registerCallbackType(
+    name: string,
+    funcDecl: Parser.FunctionDeclarationContext,
   ): 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;
-    }
+    const returnType = this.generateType(funcDecl.type());
+    const parameters: Array<{
+      name: string;
+      type: string;
+      isConst: boolean;
+      isPointer: boolean;
+      isArray: boolean;
+      arrayDims: string;
+    }> = [];
 
-    // Handle array type syntax: u8[10]
-    if (typeCtx.arrayType()) {
-      this._registerArrayTypeVariable(
-        registryName,
-        typeCtx.arrayType()!,
-        arrayDim,
-        isConst,
-        overflowBehavior,
-        isAtomic,
-      );
-      return;
-    }
+    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;
 
-    // Resolve base type from context (handles scoped, global, qualified, user types)
-    const baseType = this.resolveBaseTypeFromContext(typeCtx);
-    if (!baseType) {
-      return;
-    }
+        // ADR-029: Check if parameter type is itself a callback type
+        const isCallbackParam = CodeGenState.callbackTypes.has(typeName);
 
-    // ADR-017/ADR-034: Check if enum or bitmap type (reuse existing helper)
-    if (
-      this._tryRegisterEnumOrBitmapType(
-        registryName,
-        baseType,
-        isConst,
-        arrayDim,
-        overflowBehavior,
-        isAtomic,
-      )
-    ) {
-      return;
-    }
+        let paramType: string;
+        let isPointer: boolean;
 
-    // Standard type registration
-    this._registerStandardType(
-      registryName,
-      baseType,
-      arrayDim,
-      isConst,
-      overflowBehavior,
-      isAtomic,
-    );
-  }
+        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;
+        }
 
-  /**
-   * 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.getVariableTypeInfo(registryName);
-        if (existingInfo) {
-          const arrayTypeDim =
-            this._parseArrayTypeDimensionFromCtx(arrayTypeCtx);
-          const allDims = arrayTypeDim
-            ? [arrayTypeDim, ...(existingInfo.arrayDimensions ?? [])]
-            : existingInfo.arrayDimensions;
-          CodeGenState.setVariableTypeInfo(registryName, {
-            ...existingInfo,
-            isArray: true,
-            arrayDimensions: allDims,
-          });
+        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 = "";
         }
-        return;
+        parameters.push({
+          name: paramName,
+          type: paramType,
+          isConst,
+          isPointer,
+          isArray,
+          arrayDims,
+        });
       }
-
-      // 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.setVariableTypeInfo(registryName, {
-      baseType,
-      bitWidth,
-      isArray: true,
-      arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
-      isConst,
-      overflowBehavior,
-      isAtomic,
+    CodeGenState.callbackTypes.set(name, {
+      functionName: name,
+      returnType,
+      parameters,
+      typedefName: `${name}_fp`,
     });
   }
 
   /**
-   * Parse array dimension from arrayType context.
+   * ADR-029: Check if a function is used as a callback type (field type in a struct)
    */
-  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;
-  }
+  // Issue #63: validateCallbackAssignment, callbackSignaturesMatch, isConstValue,
+  //            and validateBareIdentifierInScope moved to TypeValidator
 
+  // EnumTypeResolver now handles: _getEnumTypeFromThisEnum, _getEnumTypeFromGlobalEnum,
+  // _getEnumTypeFromThisVariable, _getEnumTypeFromScopedEnum, _getEnumTypeFromMemberAccess,
+  // _getExpressionEnumType, _getFunctionCallEnumType
   /**
-   * Collect array dimensions from array type and additional dimensions
+   * ADR-017: Check if an expression represents an integer literal or numeric type.
+   * Used to detect comparisons between enums and integers.
    */
-  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;
+  private _isIntegerExpression(
+    ctx: Parser.ExpressionContext | Parser.RelationalExpressionContext,
+  ): boolean {
+    return EnumAssignmentValidator.isIntegerExpression(ctx);
   }
 
   /**
-   * 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.setVariableTypeInfo(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.setVariableTypeInfo(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.deleteVariableTypeInfo(name);
-    }
-    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.
+   * ADR-045: Check if an expression is a string concatenation.
+   * Delegates to StringOperationsHelper.
    */
   private _getStringConcatOperands(ctx: Parser.ExpressionContext): {
     left: string;
@@ -3471,53 +2748,12 @@ export default class CodeGenerator implements IOrchestrator {
     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,
-    };
+    return StringOperationsHelper.getStringConcatOperands(ctx);
   }
 
   /**
-   * 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.
+   * ADR-045: Check if an expression is a substring extraction.
+   * Delegates to StringOperationsHelper.
    */
   private _getSubstringOperands(ctx: Parser.ExpressionContext): {
     source: string;
@@ -3525,51 +2761,9 @@ export default class CodeGenerator implements IOrchestrator {
     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.getVariableTypeInfo(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;
+    return StringOperationsHelper.getSubstringOperands(ctx, {
+      generateExpression: (exprCtx) => this.generateExpression(exprCtx),
+    });
   }
 
   // ========================================================================
@@ -3794,226 +2988,47 @@ export default class CodeGenerator implements IOrchestrator {
     const postfix = ExpressionUnwrapper.getPostfixExpression(ctx);
     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.getVariableTypeInfo(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.getVariableTypeInfo(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);
-  }
-
-  /**
-   * 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;
-    }
+    const ops = postfix.postfixOp();
+    if (ops.length === 0) return "not-array";
 
-    const cType = TYPE_MAP[targetParamBaseType];
-    if (cType && !["float", "double", "bool", "void"].includes(cType)) {
-      return CppModeHelper.reinterpretCast(`${cType}*`, expr);
-    }
+    // Last operator must be member access (.identifier)
+    const lastOp = ops.at(-1)!;
+    const memberName = lastOp.IDENTIFIER()?.getText();
+    if (!memberName) return "not-array";
 
-    return 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";
 
-  /**
-   * Handle rvalue argument (literals or complex expressions)
-   */
-  private _handleRvalueArg(
-    ctx: Parser.ExpressionContext,
-    targetParamBaseType?: string,
-  ): string {
-    if (!targetParamBaseType) {
-      return this.generateExpression(ctx);
-    }
+    // 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 cType = TYPE_MAP[targetParamBaseType];
-    if (!cType || cType === "void") {
-      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 value = this.generateExpression(ctx);
+    if (!structType) return "not-array";
+
+    // 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";
   }
 
   // ========================================================================
@@ -4136,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();
@@ -4147,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)
@@ -4189,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
@@ -4584,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,
@@ -4617,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();
   }
 
   /**
@@ -4766,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"),
+    });
   }
 
   /**
@@ -4870,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
@@ -4882,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.getVariableTypeInfo(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.getVariableTypeInfo(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.setVariableTypeInfo(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.