c-next 0.1.69 → 0.1.70

package/src/transpiler/output/codegen/generators/expressions/__tests__/CallExprGenerator.test.ts

@@ -1,10 +1,12 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import generateFunctionCall from "../CallExprGenerator";
 import IGeneratorInput from "../../IGeneratorInput";
 import IGeneratorState from "../../IGeneratorState";
 import IOrchestrator from "../../IOrchestrator";
 import * as Parser from "../../../../../logic/parser/grammar/CNextParser";
 import ESymbolKind from "../../../../../../utils/types/ESymbolKind";
+import CodeGenState from "../../../../../state/CodeGenState";
+import TTypeInfo from "../../../types/TTypeInfo";
 
 // ========================================================================
 // Test Helpers
@@ -27,10 +29,18 @@ function createMockArgListContext(
 function createMockInput(
   overrides: Partial<IGeneratorInput> = {},
 ): IGeneratorInput {
+  // Also populate CodeGenState with the type registry entries
+  // This is needed because CallExprGenerator now uses CodeGenState directly
+  const typeRegistry =
+    (overrides.typeRegistry as Map<string, TTypeInfo>) ?? new Map();
+  for (const [name, info] of typeRegistry) {
+    CodeGenState.setVariableTypeInfo(name, info);
+  }
+
   return {
     symbols: null,
     symbolTable: null,
-    typeRegistry: new Map(),
+    typeRegistry,
     functionSignatures: new Map(),
     knownFunctions: new Set(),
     knownStructs: new Set(),
@@ -94,6 +104,11 @@ function createMockOrchestrator(
 // ========================================================================
 
 describe("CallExprGenerator", () => {
+  // Reset CodeGenState before each test to avoid state pollution
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("empty function call", () => {
     it("generates call with no arguments when argCtx is null", () => {
       const input = createMockInput();
@@ -756,7 +771,7 @@ describe("CallExprGenerator", () => {
   });
 
   describe("cross-file function calls (Issue #315)", () => {
-    it("looks up parameter info from SymbolTable when no local signature", () => {
+    it("looks up parameter info from SymbolTable and passes primitives by value (Issue #786)", () => {
       const argExprs = [createMockExpressionContext("myVal")];
       const argCtx = createMockArgListContext(argExprs);
       const symbolTable = {
@@ -777,6 +792,7 @@ describe("CallExprGenerator", () => {
         isCNextFunction: vi.fn(() => true),
         isFloatType: vi.fn(() => false),
         isParameterPassByValue: vi.fn(() => false),
+        isStructType: vi.fn(() => false),
       });
 
       const result = generateFunctionCall(
@@ -788,7 +804,8 @@ describe("CallExprGenerator", () => {
       );
 
       expect(symbolTable.getOverloads).toHaveBeenCalledWith("crossFileFunc");
-      expect(result.code).toBe("crossFileFunc(&myVal)");
+      // Issue #786: Primitive types like u32 are now passed by value for cross-file calls
+      expect(result.code).toBe("crossFileFunc(myVal)");
     });
 
     it("passes small primitive by value for cross-file functions", () => {

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -9,7 +9,7 @@
  * - Property access (.length, .capacity, .size)
  */
 
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import generatePostfixExpression from "../PostfixExpressionGenerator";
 import type IGeneratorInput from "../../IGeneratorInput";
 import type IGeneratorState from "../../IGeneratorState";
@@ -18,6 +18,7 @@ import type ICodeGenSymbols from "../../../../../types/ICodeGenSymbols";
 import type TTypeInfo from "../../../types/TTypeInfo";
 import type TParameterInfo from "../../../types/TParameterInfo";
 import * as Parser from "../../../../../logic/parser/grammar/CNextParser";
+import CodeGenState from "../../../../../state/CodeGenState";
 
 // ========================================================================
 // Test Helpers - Mock Symbols
@@ -64,10 +65,17 @@ function createMockInput(overrides?: {
   symbols?: ICodeGenSymbols;
   typeRegistry?: Map<string, TTypeInfo>;
 }): IGeneratorInput {
+  // Also populate CodeGenState with the type registry entries
+  // This is needed because PostfixExpressionGenerator now uses CodeGenState directly
+  const typeRegistry = overrides?.typeRegistry ?? new Map<string, TTypeInfo>();
+  for (const [name, info] of typeRegistry) {
+    CodeGenState.setVariableTypeInfo(name, info);
+  }
+
   return {
     symbolTable: null,
     symbols: overrides?.symbols ?? createMockSymbols(),
-    typeRegistry: overrides?.typeRegistry ?? new Map(),
+    typeRegistry,
     functionSignatures: new Map(),
     knownFunctions: new Set(),
     knownStructs: new Set(),
@@ -290,6 +298,11 @@ function createMockPostfixExpressionContext(
 // ========================================================================
 
 describe("PostfixExpressionGenerator", () => {
+  // Reset CodeGenState before each test to avoid state pollution
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("basic expression generation", () => {
     it("generates simple identifier", () => {
       const ctx = createMockPostfixExpressionContext("x", []);

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

@@ -134,9 +134,10 @@ class ArrayInitHelper {
     }
 
     // Update type registry with inferred size for .length support
-    const existingType = CodeGenState.typeRegistry.get(name);
+    const existingType = CodeGenState.getVariableTypeInfo(name);
     if (existingType) {
       existingType.arrayDimensions = [CodeGenState.lastArrayInitCount];
+      CodeGenState.setVariableTypeInfo(name, existingType);
     }
 
     return `[${CodeGenState.lastArrayInitCount}]`;

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

@@ -77,7 +77,7 @@ class AssignmentExpectedTypeResolver {
    * Resolve expected type for a simple identifier target.
    */
   private static resolveForSimpleIdentifier(id: string): IExpectedTypeResult {
-    const typeInfo = CodeGenState.typeRegistry.get(id);
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
     if (!typeInfo) {
       return { expectedType: null, assignmentContext: null };
     }
@@ -107,7 +107,7 @@ class AssignmentExpectedTypeResolver {
     }
 
     const rootName = identifiers[0];
-    const rootTypeInfo = CodeGenState.typeRegistry.get(rootName);
+    const rootTypeInfo = CodeGenState.getVariableTypeInfo(rootName);
 
     if (!rootTypeInfo || !CodeGenState.isKnownStruct(rootTypeInfo.baseType)) {
       return { expectedType: null, assignmentContext: null };

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

@@ -120,7 +120,7 @@ class AssignmentValidator {
     const shadowName = `__bits_${id}`;
     CodeGenState.floatShadowCurrent.delete(shadowName);
 
-    const targetTypeInfo = CodeGenState.typeRegistry.get(id);
+    const targetTypeInfo = CodeGenState.getVariableTypeInfo(id);
     if (!targetTypeInfo) {
       return;
     }
@@ -172,7 +172,7 @@ class AssignmentValidator {
     }
 
     // ADR-036: Compile-time bounds checking
-    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(arrayName);
     if (typeInfo?.isArray && typeInfo.arrayDimensions) {
       TypeValidator.checkArrayBounds(
         arrayName,
@@ -217,7 +217,7 @@ class AssignmentValidator {
     }
 
     // ADR-029: Validate callback field assignments with nominal typing
-    const rootTypeInfo = CodeGenState.typeRegistry.get(rootName);
+    const rootTypeInfo = CodeGenState.getVariableTypeInfo(rootName);
     if (rootTypeInfo && CodeGenState.isKnownStruct(rootTypeInfo.baseType)) {
       const structType = rootTypeInfo.baseType;
       const callbackFieldKey = `${structType}.${memberName}`;

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

@@ -78,7 +78,7 @@ class EnumAssignmentValidator {
 
     // Check if it's a variable of primitive integer type
     if (/^[a-zA-Z_]\w*$/.exec(text)) {
-      const typeInfo = CodeGenState.typeRegistry.get(text);
+      const typeInfo = CodeGenState.getVariableTypeInfo(text);
       if (
         typeInfo &&
         !typeInfo.isEnum &&

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

@@ -325,7 +325,7 @@ class StringDeclHelper {
     const arraySize = CodeGenState.lastArrayInitCount;
 
     // Update type registry with inferred size
-    CodeGenState.typeRegistry.set(name, {
+    CodeGenState.setVariableTypeInfo(name, {
       baseType: "char",
       bitWidth: 8,
       isArray: true,
@@ -531,7 +531,7 @@ class StringDeclHelper {
     callbacks.requireStringInclude();
 
     // Register in type registry with inferred capacity
-    CodeGenState.typeRegistry.set(name, {
+    CodeGenState.setVariableTypeInfo(name, {
       baseType: "char",
       bitWidth: 8,
       isArray: true,

package/src/transpiler/output/codegen/helpers/__tests__/ArrayInitHelper.test.ts

@@ -56,7 +56,7 @@ describe("ArrayInitHelper", () => {
 
     it("handles size inference with array initializer", () => {
       // Add existing type to registry
-      CodeGenState.typeRegistry.set("arr", {
+      CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,

package/src/transpiler/output/codegen/helpers/__tests__/AssignmentExpectedTypeResolver.test.ts

@@ -68,7 +68,7 @@ describe("AssignmentExpectedTypeResolver", () => {
   describe("resolve()", () => {
     describe("simple identifier", () => {
       it("should resolve expected type for known variable", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u32",
           bitWidth: 32,
           isArray: false,
@@ -87,7 +87,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should use specified overflow behavior", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u8",
           bitWidth: 8,
           isArray: false,
@@ -113,7 +113,7 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("member access", () => {
       it("should resolve expected type for struct field", () => {
-        CodeGenState.typeRegistry.set("config", {
+        CodeGenState.setVariableTypeInfo("config", {
           baseType: "Config",
           bitWidth: 0,
           isArray: false,
@@ -128,7 +128,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should walk nested struct chain", () => {
-        CodeGenState.typeRegistry.set("app", {
+        CodeGenState.setVariableTypeInfo("app", {
           baseType: "App",
           bitWidth: 0,
           isArray: false,
@@ -144,7 +144,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should return null for non-struct root", () => {
-        CodeGenState.typeRegistry.set("counter", {
+        CodeGenState.setVariableTypeInfo("counter", {
           baseType: "u32",
           bitWidth: 32,
           isArray: false,
@@ -158,7 +158,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should return null for unknown field", () => {
-        CodeGenState.typeRegistry.set("config", {
+        CodeGenState.setVariableTypeInfo("config", {
           baseType: "Config",
           bitWidth: 0,
           isArray: false,
@@ -175,7 +175,7 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("array access", () => {
       it("should return null for array access target", () => {
-        CodeGenState.typeRegistry.set("arr", {
+        CodeGenState.setVariableTypeInfo("arr", {
           baseType: "u32",
           bitWidth: 32,
           isArray: true,

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

@@ -141,7 +141,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate enum assignment for enum-typed variable", () => {
-      CodeGenState.typeRegistry.set("status", {
+      CodeGenState.setVariableTypeInfo("status", {
         baseType: "Status",
         bitWidth: 8,
         isArray: false,
@@ -165,7 +165,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate integer assignment for integer-typed variable", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -190,7 +190,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should pass isCompound flag to integer validation", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -215,7 +215,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should rethrow validation error with line:column prefix", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,
@@ -240,7 +240,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should handle non-Error validation exceptions", () => {
-      CodeGenState.typeRegistry.set("counter", {
+      CodeGenState.setVariableTypeInfo("counter", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,
@@ -298,7 +298,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should check array bounds for array with dimensions", () => {
-      CodeGenState.typeRegistry.set("arr", {
+      CodeGenState.setVariableTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isConst: false,
@@ -374,7 +374,7 @@ describe("AssignmentValidator", () => {
     });
 
     it("should validate callback assignment for callback field", () => {
-      CodeGenState.typeRegistry.set("handler", {
+      CodeGenState.setVariableTypeInfo("handler", {
         baseType: "Handler",
         bitWidth: 0,
         isArray: false,

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

@@ -275,7 +275,7 @@ describe("EnumAssignmentValidator", () => {
     });
 
     it("returns true for integer-typed variable", () => {
-      CodeGenState.typeRegistry.set("count", {
+      CodeGenState.setVariableTypeInfo("count", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -290,7 +290,7 @@ describe("EnumAssignmentValidator", () => {
     });
 
     it("returns false for enum-typed variable", () => {
-      CodeGenState.typeRegistry.set("state", {
+      CodeGenState.setVariableTypeInfo("state", {
         baseType: "State",
         bitWidth: 0,
         isArray: false,

package/src/transpiler/output/codegen/helpers/__tests__/StringDeclHelper.test.ts

@@ -246,7 +246,7 @@ describe("StringDeclHelper", () => {
       expect(result.handled).toBe(true);
       expect(result.code).toBe('const char greeting[6] = "Hello";');
       expect(requireStringInclude).toHaveBeenCalled();
-      expect(CodeGenState.typeRegistry.get("greeting")).toMatchObject({
+      expect(CodeGenState.getVariableTypeInfo("greeting")).toMatchObject({
         baseType: "char",
         isString: true,
         stringCapacity: 5,
@@ -821,9 +821,9 @@ describe("StringDeclHelper", () => {
       expect(result.handled).toBe(true);
       expect(result.code).toContain("[2]"); // Inferred size
       expect(result.code).toContain("[11]"); // capacity + 1
-      expect(CodeGenState.typeRegistry.get("labels")?.arrayDimensions).toEqual([
-        2, 11,
-      ]);
+      expect(
+        CodeGenState.getVariableTypeInfo("labels")?.arrayDimensions,
+      ).toEqual([2, 11]);
     });
 
     it("generates string array without initializer (zero-init)", () => {

package/src/transpiler/output/codegen/resolution/EnumTypeResolver.ts

@@ -41,7 +41,7 @@ export default class EnumTypeResolver {
 
     // Check if it's a simple identifier that's an enum variable
     if (/^[a-zA-Z_]\w*$/.exec(text)) {
-      const typeInfo = CodeGenState.typeRegistry.get(text);
+      const typeInfo = CodeGenState.getVariableTypeInfo(text);
       if (typeInfo?.isEnum && typeInfo.enumTypeName) {
         return typeInfo.enumTypeName;
       }
@@ -146,7 +146,7 @@ export default class EnumTypeResolver {
     }
     const varName = parts[1];
     const scopedVarName = `${CodeGenState.currentScope}_${varName}`;
-    const typeInfo = CodeGenState.typeRegistry.get(scopedVarName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(scopedVarName);
     if (typeInfo?.isEnum && typeInfo.enumTypeName) {
       return typeInfo.enumTypeName;
     }

package/src/transpiler/output/codegen/resolution/__tests__/EnumTypeResolver.test.ts

@@ -121,7 +121,7 @@ describe("EnumTypeResolver", () => {
       CodeGenState.symbols = createMockSymbols({
         knownEnums: new Set(["State"]),
       });
-      CodeGenState.typeRegistry.set("currentState", {
+      CodeGenState.setVariableTypeInfo("currentState", {
         baseType: "State",
         bitWidth: 0,
         isArray: false,
@@ -135,7 +135,7 @@ describe("EnumTypeResolver", () => {
     });
 
     it("returns null for non-enum variable", () => {
-      CodeGenState.typeRegistry.set("count", {
+      CodeGenState.setVariableTypeInfo("count", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -190,7 +190,7 @@ describe("EnumTypeResolver", () => {
       CodeGenState.symbols = createMockSymbols({
         knownEnums: new Set(["Motor_State"]),
       });
-      CodeGenState.typeRegistry.set("Motor_current", {
+      CodeGenState.setVariableTypeInfo("Motor_current", {
         baseType: "Motor_State",
         bitWidth: 0,
         isArray: false,
@@ -261,7 +261,7 @@ describe("EnumTypeResolver", () => {
       CodeGenState.symbols = createMockSymbols({
         knownEnums: new Set(["EValueId"]),
       });
-      CodeGenState.typeRegistry.set("input", {
+      CodeGenState.setVariableTypeInfo("input", {
         baseType: "TInput",
         bitWidth: 0,
         isArray: false,
@@ -280,7 +280,7 @@ describe("EnumTypeResolver", () => {
       symbolTable.addStructField("TInput", "count", "u32");
       CodeGenState.symbolTable = symbolTable;
       CodeGenState.symbols = createMockSymbols();
-      CodeGenState.typeRegistry.set("input", {
+      CodeGenState.setVariableTypeInfo("input", {
         baseType: "TInput",
         bitWidth: 0,
         isArray: false,

package/src/transpiler/state/CodeGenState.ts

@@ -30,6 +30,8 @@ import ICallbackTypeInfo from "../output/codegen/types/ICallbackTypeInfo";
 import ITargetCapabilities from "../output/codegen/types/ITargetCapabilities";
 import TOverflowBehavior from "../output/codegen/types/TOverflowBehavior";
 import TYPE_WIDTH from "../output/codegen/types/TYPE_WIDTH";
+import ESymbolKind from "../../utils/types/ESymbolKind";
+import ESourceLanguage from "../../utils/types/ESourceLanguage";
 
 /**
  * Default target capabilities (safe fallback)
@@ -101,8 +103,12 @@ export default class CodeGenState {
   // TYPE TRACKING
   // ===========================================================================
 
-  /** Track variable types for bit access, .length, and type inference */
-  static typeRegistry: Map<string, TTypeInfo> = new Map();
+  /**
+   * Track variable types for bit access, .length, and type inference.
+   * PRIVATE: Use getVariableTypeInfo()/setVariableTypeInfo() instead.
+   * This ensures cross-file variables from SymbolTable are also found.
+   */
+  private static typeRegistry: Map<string, TTypeInfo> = new Map();
 
   /** Bug #8: Compile-time const values for array size resolution */
   static constValues: Map<string, number> = new Map();
@@ -451,9 +457,121 @@ export default class CodeGenState {
 
   /**
    * Get type info for a variable.
+   * Checks local typeRegistry first, then falls back to SymbolTable
+   * for cross-file variables from included .cnx files.
+   *
+   * Issue #786: This unified lookup ensures cross-file variables
+   * (defined in included files) are found even before code generation
+   * registers them locally.
+   */
+  static getVariableTypeInfo(name: string): TTypeInfo | undefined {
+    // First check the local type registry (current file's variables)
+    const localInfo = this.typeRegistry.get(name);
+    if (localInfo) {
+      return localInfo;
+    }
+
+    // Fall back to SymbolTable for cross-file C-Next variables only.
+    // C/C++ header symbols don't have complete type info (e.g., isArray),
+    // so we only use C-Next symbols from SymbolTable.
+    const symbol = this.symbolTable.getSymbol(name);
+    if (
+      symbol?.kind === ESymbolKind.Variable &&
+      symbol.type &&
+      symbol.sourceLanguage === ESourceLanguage.CNext
+    ) {
+      return this.convertSymbolToTypeInfo(symbol);
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Legacy alias for getVariableTypeInfo.
+   * @deprecated Use getVariableTypeInfo() instead
    */
   static getTypeInfo(name: string): TTypeInfo | undefined {
-    return this.typeRegistry.get(name);
+    return this.getVariableTypeInfo(name);
+  }
+
+  /**
+   * Check if a variable type is registered (locally or in SymbolTable).
+   */
+  static hasVariableTypeInfo(name: string): boolean {
+    if (this.typeRegistry.has(name)) {
+      return true;
+    }
+    const symbol = this.symbolTable.getSymbol(name);
+    return (
+      symbol?.kind === ESymbolKind.Variable &&
+      symbol.type !== undefined &&
+      symbol.sourceLanguage === ESourceLanguage.CNext
+    );
+  }
+
+  /**
+   * Set variable type info in the local registry.
+   */
+  static setVariableTypeInfo(name: string, info: TTypeInfo): void {
+    this.typeRegistry.set(name, info);
+  }
+
+  /**
+   * Delete variable type info from the local registry.
+   */
+  static deleteVariableTypeInfo(name: string): void {
+    this.typeRegistry.delete(name);
+  }
+
+  /**
+   * Get a read-only view of the local type registry.
+   * Used for passing to helper functions that need to iterate over types.
+   * Note: This only returns locally registered types, not cross-file symbols.
+   */
+  static getTypeRegistryView(): ReadonlyMap<string, TTypeInfo> {
+    return this.typeRegistry;
+  }
+
+  /**
+   * Convert an ISymbol to TTypeInfo for unified type lookups.
+   * Used when looking up cross-file variables from SymbolTable.
+   */
+  private static convertSymbolToTypeInfo(symbol: {
+    type?: string;
+    isArray?: boolean;
+    arrayDimensions?: string[];
+    isConst?: boolean;
+    isAtomic?: boolean;
+  }): TTypeInfo {
+    const rawType = symbol.type || "unknown";
+
+    // Parse string<N> type pattern
+    const stringPattern = /^string<(\d+)>$/;
+    const stringMatch = stringPattern.exec(rawType);
+    const isString = stringMatch !== null;
+    const stringCapacity = stringMatch
+      ? Number.parseInt(stringMatch[1], 10)
+      : undefined;
+    // Use "char" for string types to match local convention (StringDeclHelper.ts)
+    const baseType = isString ? "char" : rawType;
+
+    const isEnum = this.isKnownEnum(baseType);
+
+    return {
+      baseType,
+      // Use bitWidth 8 for strings (char), otherwise lookup from TYPE_WIDTH
+      bitWidth: isString ? 8 : TYPE_WIDTH[baseType] || 0,
+      isArray: symbol.isArray || false,
+      arrayDimensions: symbol.arrayDimensions
+        ?.map((d) => Number.parseInt(d, 10))
+        .filter((n) => !Number.isNaN(n)),
+      isConst: symbol.isConst || false,
+      isAtomic: symbol.isAtomic || false,
+      isEnum,
+      enumTypeName: isEnum ? baseType : undefined,
+      isString,
+      stringCapacity,
+    };
   }
 
   /**
@@ -785,7 +903,7 @@ export default class CodeGenState {
    * Register a variable type.
    */
   static registerType(name: string, info: TTypeInfo): void {
-    this.typeRegistry.set(name, info);
+    this.setVariableTypeInfo(name, info);
   }
 
   /**