c-next 0.1.69 → 0.1.70

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

@@ -6,7 +6,7 @@
  * qualifiedType, userType) that each had identical enum/bitmap handling.
  */
 
-import TTypeInfo from "./types/TTypeInfo";
+import CodeGenState from "../../state/CodeGenState";
 import TOverflowBehavior from "./types/TOverflowBehavior";
 
 /**
@@ -40,7 +40,6 @@ class TypeRegistrationUtils {
    * Returns true if the type was a known enum and was registered.
    */
   static tryRegisterEnumType(
-    typeRegistry: Map<string, TTypeInfo>,
     symbols: ITypeSymbols,
     options: ITypeRegistrationOptions,
   ): boolean {
@@ -48,7 +47,7 @@ class TypeRegistrationUtils {
       return false;
     }
 
-    typeRegistry.set(options.name, {
+    CodeGenState.setVariableTypeInfo(options.name, {
       baseType: options.baseType,
       bitWidth: 0,
       isArray: false,
@@ -69,7 +68,6 @@ class TypeRegistrationUtils {
    * Handles both array and non-array bitmap types.
    */
   static tryRegisterBitmapType(
-    typeRegistry: Map<string, TTypeInfo>,
     symbols: ITypeSymbols,
     options: ITypeRegistrationOptions,
     arrayDimensions: number[] | undefined,
@@ -82,7 +80,7 @@ class TypeRegistrationUtils {
 
     if (arrayDimensions && arrayDimensions.length > 0) {
       // Bitmap array
-      typeRegistry.set(options.name, {
+      CodeGenState.setVariableTypeInfo(options.name, {
         baseType: options.baseType,
         bitWidth,
         isArray: true,
@@ -95,7 +93,7 @@ class TypeRegistrationUtils {
       });
     } else {
       // Non-array bitmap
-      typeRegistry.set(options.name, {
+      CodeGenState.setVariableTypeInfo(options.name, {
         baseType: options.baseType,
         bitWidth,
         isArray: false,

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

@@ -303,7 +303,7 @@ class TypeResolver {
    * Look up a variable name in the type registry and return a SuffixResult.
    */
   private static resolveRegistryLookup(name: string): SuffixResult {
-    const typeInfo = CodeGenState.typeRegistry.get(name);
+    const typeInfo = CodeGenState.getVariableTypeInfo(name);
     if (typeInfo) {
       return {
         stop: false,
@@ -356,7 +356,7 @@ class TypeResolver {
     if (id) {
       const name = id.getText();
       const scopedName = CodeGenState.resolveIdentifier(name);
-      const typeInfo = CodeGenState.typeRegistry.get(scopedName);
+      const typeInfo = CodeGenState.getVariableTypeInfo(scopedName);
       if (typeInfo) {
         return { baseType: typeInfo.baseType, isArray: typeInfo.isArray };
       }

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

@@ -291,7 +291,7 @@ class TypeValidator {
 
     const scopedName = CodeGenState.resolveIdentifier(identifier);
 
-    const typeInfo = CodeGenState.typeRegistry.get(scopedName);
+    const typeInfo = CodeGenState.getVariableTypeInfo(scopedName);
     if (typeInfo?.isConst) {
       return `cannot assign to const variable '${identifier}'`;
     }
@@ -305,7 +305,7 @@ class TypeValidator {
       return true;
     }
 
-    const typeInfo = CodeGenState.typeRegistry.get(identifier);
+    const typeInfo = CodeGenState.getVariableTypeInfo(identifier);
     if (typeInfo?.isConst) {
       return true;
     }
@@ -366,7 +366,7 @@ class TypeValidator {
       );
     }
 
-    const typeInfo = CodeGenState.typeRegistry.get(identifier);
+    const typeInfo = CodeGenState.getVariableTypeInfo(identifier);
     if (typeInfo && !identifier.includes("_")) {
       throw new Error(
         `Error: Use 'global.${identifier}' to access global variable '${identifier}' inside scope '${currentScope}'`,
@@ -428,7 +428,7 @@ class TypeValidator {
     currentScope: string | null,
     isKnownStruct: (name: string) => boolean,
   ): boolean {
-    const typeInfo = CodeGenState.typeRegistry.get(identifier);
+    const typeInfo = CodeGenState.getVariableTypeInfo(identifier);
     if (typeInfo && !identifier.includes("_")) {
       return true;
     }
@@ -790,7 +790,7 @@ class TypeValidator {
       return true;
     }
 
-    const typeInfo = CodeGenState.typeRegistry.get(text);
+    const typeInfo = CodeGenState.getVariableTypeInfo(text);
     if (typeInfo?.baseType === "bool") {
       return true;
     }

package/src/transpiler/output/codegen/__tests__/TypeRegistrationUtils.test.ts

@@ -3,9 +3,9 @@
  * Tests the extracted enum/bitmap type registration helpers.
  */
 
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import TypeRegistrationUtils from "../TypeRegistrationUtils";
-import TTypeInfo from "../types/TTypeInfo";
+import CodeGenState from "../../../state/CodeGenState";
 
 /**
  * Create mock symbols for testing
@@ -20,49 +20,43 @@ function createMockSymbols(overrides: Record<string, unknown> = {}) {
 }
 
 describe("TypeRegistrationUtils", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("tryRegisterEnumType", () => {
     it("returns false if type is not a known enum", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols();
 
-      const result = TypeRegistrationUtils.tryRegisterEnumType(
-        typeRegistry,
-        symbols,
-        {
-          name: "myVar",
-          baseType: "UnknownType",
-          isConst: false,
-          overflowBehavior: "clamp",
-          isAtomic: false,
-        },
-      );
+      const result = TypeRegistrationUtils.tryRegisterEnumType(symbols, {
+        name: "myVar",
+        baseType: "UnknownType",
+        isConst: false,
+        overflowBehavior: "clamp",
+        isAtomic: false,
+      });
 
       expect(result).toBe(false);
-      expect(typeRegistry.size).toBe(0);
+      expect(CodeGenState.getVariableTypeInfo("myVar")).toBeUndefined();
     });
 
     it("registers enum type and returns true", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownEnums: new Set(["MyEnum"]),
       });
 
-      const result = TypeRegistrationUtils.tryRegisterEnumType(
-        typeRegistry,
-        symbols,
-        {
-          name: "myVar",
-          baseType: "MyEnum",
-          isConst: false,
-          overflowBehavior: "clamp",
-          isAtomic: false,
-        },
-      );
+      const result = TypeRegistrationUtils.tryRegisterEnumType(symbols, {
+        name: "myVar",
+        baseType: "MyEnum",
+        isConst: false,
+        overflowBehavior: "clamp",
+        isAtomic: false,
+      });
 
       expect(result).toBe(true);
-      expect(typeRegistry.has("myVar")).toBe(true);
+      expect(CodeGenState.hasVariableTypeInfo("myVar")).toBe(true);
 
-      const info = typeRegistry.get("myVar")!;
+      const info = CodeGenState.getVariableTypeInfo("myVar")!;
       expect(info.baseType).toBe("MyEnum");
       expect(info.isEnum).toBe(true);
       expect(info.enumTypeName).toBe("MyEnum");
@@ -70,12 +64,11 @@ describe("TypeRegistrationUtils", () => {
     });
 
     it("respects isConst flag", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownEnums: new Set(["MyEnum"]),
       });
 
-      TypeRegistrationUtils.tryRegisterEnumType(typeRegistry, symbols, {
+      TypeRegistrationUtils.tryRegisterEnumType(symbols, {
         name: "myVar",
         baseType: "MyEnum",
         isConst: true,
@@ -83,16 +76,15 @@ describe("TypeRegistrationUtils", () => {
         isAtomic: false,
       });
 
-      expect(typeRegistry.get("myVar")!.isConst).toBe(true);
+      expect(CodeGenState.getVariableTypeInfo("myVar")!.isConst).toBe(true);
     });
 
     it("respects overflowBehavior", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownEnums: new Set(["MyEnum"]),
       });
 
-      TypeRegistrationUtils.tryRegisterEnumType(typeRegistry, symbols, {
+      TypeRegistrationUtils.tryRegisterEnumType(symbols, {
         name: "myVar",
         baseType: "MyEnum",
         isConst: false,
@@ -100,16 +92,17 @@ describe("TypeRegistrationUtils", () => {
         isAtomic: false,
       });
 
-      expect(typeRegistry.get("myVar")!.overflowBehavior).toBe("wrap");
+      expect(CodeGenState.getVariableTypeInfo("myVar")!.overflowBehavior).toBe(
+        "wrap",
+      );
     });
 
     it("respects isAtomic flag", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownEnums: new Set(["MyEnum"]),
       });
 
-      TypeRegistrationUtils.tryRegisterEnumType(typeRegistry, symbols, {
+      TypeRegistrationUtils.tryRegisterEnumType(symbols, {
         name: "myVar",
         baseType: "MyEnum",
         isConst: false,
@@ -117,17 +110,15 @@ describe("TypeRegistrationUtils", () => {
         isAtomic: true,
       });
 
-      expect(typeRegistry.get("myVar")!.isAtomic).toBe(true);
+      expect(CodeGenState.getVariableTypeInfo("myVar")!.isAtomic).toBe(true);
     });
   });
 
   describe("tryRegisterBitmapType", () => {
     it("returns false if type is not a known bitmap", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols();
 
       const result = TypeRegistrationUtils.tryRegisterBitmapType(
-        typeRegistry,
         symbols,
         {
           name: "myVar",
@@ -140,18 +131,16 @@ describe("TypeRegistrationUtils", () => {
       );
 
       expect(result).toBe(false);
-      expect(typeRegistry.size).toBe(0);
+      expect(CodeGenState.getVariableTypeInfo("myVar")).toBeUndefined();
     });
 
     it("registers non-array bitmap type", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownBitmaps: new Set(["MyFlags"]),
         bitmapBitWidth: new Map([["MyFlags", 8]]),
       });
 
       const result = TypeRegistrationUtils.tryRegisterBitmapType(
-        typeRegistry,
         symbols,
         {
           name: "flags",
@@ -164,9 +153,9 @@ describe("TypeRegistrationUtils", () => {
       );
 
       expect(result).toBe(true);
-      expect(typeRegistry.has("flags")).toBe(true);
+      expect(CodeGenState.hasVariableTypeInfo("flags")).toBe(true);
 
-      const info = typeRegistry.get("flags")!;
+      const info = CodeGenState.getVariableTypeInfo("flags")!;
       expect(info.baseType).toBe("MyFlags");
       expect(info.isBitmap).toBe(true);
       expect(info.bitmapTypeName).toBe("MyFlags");
@@ -175,14 +164,12 @@ describe("TypeRegistrationUtils", () => {
     });
 
     it("registers bitmap array type with dimensions", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownBitmaps: new Set(["MyFlags"]),
         bitmapBitWidth: new Map([["MyFlags", 16]]),
       });
 
       const result = TypeRegistrationUtils.tryRegisterBitmapType(
-        typeRegistry,
         symbols,
         {
           name: "flagsArray",
@@ -196,21 +183,19 @@ describe("TypeRegistrationUtils", () => {
 
       expect(result).toBe(true);
 
-      const info = typeRegistry.get("flagsArray")!;
+      const info = CodeGenState.getVariableTypeInfo("flagsArray")!;
       expect(info.isArray).toBe(true);
       expect(info.arrayDimensions).toEqual([10, 5]);
       expect(info.bitWidth).toBe(16);
     });
 
     it("defaults bitWidth to 0 if not found", () => {
-      const typeRegistry = new Map<string, TTypeInfo>();
       const symbols = createMockSymbols({
         knownBitmaps: new Set(["MyFlags"]),
         // No bitWidth entry
       });
 
       TypeRegistrationUtils.tryRegisterBitmapType(
-        typeRegistry,
         symbols,
         {
           name: "flags",
@@ -222,7 +207,7 @@ describe("TypeRegistrationUtils", () => {
         undefined,
       );
 
-      expect(typeRegistry.get("flags")!.bitWidth).toBe(0);
+      expect(CodeGenState.getVariableTypeInfo("flags")!.bitWidth).toBe(0);
     });
   });
 });

package/src/transpiler/output/codegen/__tests__/TypeResolver.test.ts

@@ -10,15 +10,18 @@ import TTypeInfo from "../types/TTypeInfo";
 
 describe("TypeResolver", () => {
   let symbolTable: SymbolTable;
-  let typeRegistry: Map<string, TTypeInfo>;
 
   beforeEach(() => {
     CodeGenState.reset();
     symbolTable = new SymbolTable();
-    typeRegistry = CodeGenState.typeRegistry;
     CodeGenState.symbolTable = symbolTable;
   });
 
+  /** Helper function to set type info in the registry */
+  function setTypeInfo(name: string, info: TTypeInfo): void {
+    CodeGenState.setVariableTypeInfo(name, info);
+  }
+
   // ========================================================================
   // Type Classification Methods
   // ========================================================================
@@ -400,7 +403,7 @@ describe("TypeResolver", () => {
     };
 
     it("should return type for identifier in registry", () => {
-      typeRegistry.set("myVar", {
+      setTypeInfo("myVar", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -612,7 +615,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return type from simple identifier", () => {
-      typeRegistry.set("counter", {
+      setTypeInfo("counter", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -651,7 +654,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return member type for struct member access", () => {
-      typeRegistry.set("point", {
+      setTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -675,7 +678,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return null for unknown member", () => {
-      typeRegistry.set("point", {
+      setTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -699,7 +702,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return null for range bit indexing", () => {
-      typeRegistry.set("flags", {
+      setTypeInfo("flags", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -722,7 +725,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return bool for single bit indexing on integer", () => {
-      typeRegistry.set("flags", {
+      setTypeInfo("flags", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -745,7 +748,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return element type for struct array member indexing", () => {
-      typeRegistry.set("data", {
+      setTypeInfo("data", {
         baseType: "Data",
         bitWidth: 0,
         isArray: false,
@@ -774,7 +777,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return element type for direct array variable indexing", () => {
-      typeRegistry.set("arr", {
+      setTypeInfo("arr", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -798,7 +801,7 @@ describe("TypeResolver", () => {
     });
 
     it("should return bool for bit indexing on plain integer variable", () => {
-      typeRegistry.set("val", {
+      setTypeInfo("val", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,
@@ -828,7 +831,7 @@ describe("TypeResolver", () => {
 
   describe("getPostfixExpressionType with global/this", () => {
     it("should resolve global.structVar.field type", () => {
-      typeRegistry.set("config", {
+      setTypeInfo("config", {
         baseType: "TConfig",
         bitWidth: 0,
         isArray: false,
@@ -858,7 +861,7 @@ describe("TypeResolver", () => {
     });
 
     it("should resolve global.arrayVar[0] element type", () => {
-      typeRegistry.set("inputs", {
+      setTypeInfo("inputs", {
         baseType: "TInput",
         bitWidth: 0,
         isArray: true,
@@ -888,7 +891,7 @@ describe("TypeResolver", () => {
 
     it("should resolve this.scopeVar type", () => {
       CodeGenState.currentScope = "Motor";
-      typeRegistry.set("Motor_speed", {
+      setTypeInfo("Motor_speed", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -951,7 +954,7 @@ describe("TypeResolver", () => {
     });
 
     it("should resolve global.struct.enumField for enum type", () => {
-      typeRegistry.set("input", {
+      setTypeInfo("input", {
         baseType: "TInput",
         bitWidth: 0,
         isArray: false,
@@ -987,7 +990,7 @@ describe("TypeResolver", () => {
 
   describe("getUnaryExpressionType", () => {
     it("should return type from postfix expression", () => {
-      typeRegistry.set("value", {
+      setTypeInfo("value", {
         baseType: "i32",
         bitWidth: 32,
         isArray: false,
@@ -1020,7 +1023,7 @@ describe("TypeResolver", () => {
     });
 
     it("should recurse through unary expression chain", () => {
-      typeRegistry.set("x", {
+      setTypeInfo("x", {
         baseType: "i32",
         bitWidth: 32,
         isArray: false,

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

@@ -39,13 +39,13 @@ describe("TypeValidator.resolveBareIdentifier", () => {
   beforeEach(() => {
     CodeGenState.reset();
     CodeGenState.setScopeMembers("Motor", new Set(["speed", "maxSpeed"]));
-    CodeGenState.typeRegistry.set("globalCounter", {
+    CodeGenState.setVariableTypeInfo("globalCounter", {
       baseType: "u32",
       bitWidth: 32,
       isArray: false,
       isConst: false,
     });
-    CodeGenState.typeRegistry.set("Motor_speed", {
+    CodeGenState.setVariableTypeInfo("Motor_speed", {
       baseType: "u32",
       bitWidth: 32,
       isArray: false,
@@ -146,7 +146,7 @@ describe("TypeValidator.resolveBareIdentifier", () => {
   describe("resolveForMemberAccess", () => {
     it("prefers scope name over global variable for member access", () => {
       // Setup: global variable 'LED' exists AND scope 'LED' exists
-      CodeGenState.typeRegistry.set("LED", {
+      CodeGenState.setVariableTypeInfo("LED", {
         baseType: "u8",
         bitWidth: 8,
         isArray: false,

package/src/transpiler/output/codegen/__tests__/TypeValidator.test.ts

@@ -74,7 +74,7 @@ function setupState(options: SetupStateOptions = {}): void {
   }
   if (options.typeRegistry) {
     for (const [k, v] of options.typeRegistry) {
-      CodeGenState.typeRegistry.set(k, v);
+      CodeGenState.setVariableTypeInfo(k, v);
     }
   }
   if (options.callbackTypes) {

package/src/transpiler/output/codegen/analysis/MemberChainAnalyzer.ts

@@ -127,7 +127,7 @@ class MemberChainAnalyzer {
     ops: Parser.PostfixTargetOpContext[],
     _subscriptsSoFar: number,
   ): { type: string; isArray: boolean } | undefined {
-    const baseTypeInfo = CodeGenState.typeRegistry.get(baseId);
+    const baseTypeInfo = CodeGenState.getVariableTypeInfo(baseId);
     if (!baseTypeInfo) {
       return undefined;
     }

package/src/transpiler/output/codegen/analysis/StringLengthCounter.ts

@@ -193,7 +193,7 @@ class StringLengthCounter {
         const memberName = op.IDENTIFIER()?.getText();
         if (memberName === "length") {
           // Check if this is a string type
-          const typeInfo = CodeGenState.typeRegistry.get(primaryId);
+          const typeInfo = CodeGenState.getVariableTypeInfo(primaryId);
           if (typeInfo?.isString) {
             const currentCount = counts.get(primaryId) || 0;
             counts.set(primaryId, currentCount + 1);

package/src/transpiler/output/codegen/analysis/__tests__/MemberChainAnalyzer.test.ts

@@ -139,7 +139,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns isBitAccess false when last op is member access", () => {
       // point.flags (no subscript at end)
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -159,7 +159,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns isBitAccess false when last subscript has 2 expressions (bit range)", () => {
       // flags[0, 8] - bit range, not single bit access
-      CodeGenState.typeRegistry.set("flags", {
+      CodeGenState.setVariableTypeInfo("flags", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,
@@ -180,7 +180,7 @@ describe("MemberChainAnalyzer", () => {
       pointFields.set("flags", "u8");
       setupStructFields("Point", pointFields);
 
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -209,7 +209,7 @@ describe("MemberChainAnalyzer", () => {
       gridFields.set("items", "u8");
       setupStructFields("Grid", gridFields, new Set(["items"]));
 
-      CodeGenState.typeRegistry.set("grid", {
+      CodeGenState.setVariableTypeInfo("grid", {
         baseType: "Grid",
         bitWidth: 0,
         isArray: false,
@@ -236,7 +236,7 @@ describe("MemberChainAnalyzer", () => {
       pointFields.set("name", "string");
       setupStructFields("Point", pointFields);
 
-      CodeGenState.typeRegistry.set("point", {
+      CodeGenState.setVariableTypeInfo("point", {
         baseType: "Point",
         bitWidth: 0,
         isArray: false,
@@ -263,7 +263,7 @@ describe("MemberChainAnalyzer", () => {
       deviceFields.set("flags", "u8");
       setupStructFields("Device", deviceFields);
 
-      CodeGenState.typeRegistry.set("devices", {
+      CodeGenState.setVariableTypeInfo("devices", {
         baseType: "Device",
         bitWidth: 0,
         isArray: true,
@@ -290,7 +290,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns false for 2D array element: matrix[0][1]", () => {
       // matrix[0][1] is array access, not bit access
-      CodeGenState.typeRegistry.set("matrix", {
+      CodeGenState.setVariableTypeInfo("matrix", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -315,7 +315,7 @@ describe("MemberChainAnalyzer", () => {
     it("detects bit access on 2D array element: matrix[0][1][3]", () => {
       // matrix[0][1][3] where matrix is u8[4][4]
       // The third subscript [3] is bit access on the u8 element
-      CodeGenState.typeRegistry.set("matrix", {
+      CodeGenState.setVariableTypeInfo("matrix", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
@@ -357,7 +357,7 @@ describe("MemberChainAnalyzer", () => {
 
     it("returns false for member access on non-struct", () => {
       // x.field[0] where x is a primitive
-      CodeGenState.typeRegistry.set("x", {
+      CodeGenState.setVariableTypeInfo("x", {
         baseType: "u32",
         bitWidth: 32,
         isArray: false,