c-next 0.1.68 → 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;
     }
@@ -332,7 +332,7 @@ class TypeValidator {
       return;
     }
 
-    const scopeMembers = CodeGenState.scopeMembers.get(currentScope);
+    const scopeMembers = CodeGenState.getScopeMembers(currentScope);
     if (scopeMembers?.has(identifier)) {
       throw new Error(
         `Error: Use 'this.${identifier}' to access scope member '${identifier}' inside scope '${currentScope}'`,
@@ -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}'`,
@@ -410,7 +410,7 @@ class TypeValidator {
     identifier: string,
     currentScope: string,
   ): string | null {
-    const scopeMembers = CodeGenState.scopeMembers.get(currentScope);
+    const scopeMembers = CodeGenState.getScopeMembers(currentScope);
     if (scopeMembers?.has(identifier)) {
       return `${currentScope}_${identifier}`;
     }
@@ -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__/CodeGenerator.coverage.test.ts

@@ -242,7 +242,7 @@ describe("CodeGenerator Coverage Tests", () => {
 
       // Manually set up scope context to test the resolution path
       CodeGenState.currentScope = "Motor";
-      CodeGenState.scopeMembers.set("Motor", new Set(["speed", "setSpeed"]));
+      CodeGenState.setScopeMembers("Motor", new Set(["speed", "setSpeed"]));
 
       // Now resolve should return prefixed name (line 633)
       const resolved = generator.resolveIdentifier("speed");
@@ -253,7 +253,7 @@ describe("CodeGenerator Coverage Tests", () => {
       const { generator } = setupGenerator("u32 globalVar; void main() {}");
 
       CodeGenState.currentScope = "Motor";
-      CodeGenState.scopeMembers.set("Motor", new Set(["speed"]));
+      CodeGenState.setScopeMembers("Motor", new Set(["speed"]));
 
       // globalVar is not in Motor scope members
       const resolved = generator.resolveIdentifier("globalVar");

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

@@ -7318,12 +7318,15 @@ describe("CodeGenerator", () => {
         expect(code).toContain("cfg.enabled = true");
       });
 
-      it("should throw when writing register from inside scope without global prefix", () => {
+      it("should throw when writing register from inside scope when SHADOWED without global prefix", () => {
+        // Issue #779: Ambiguity-aware validation - only require global. when shadowed
         const source = `
           register GPIO @ 0x40000000 {
               DR: u32 rw @ 0x00,
           }
           scope Motor {
+              // Shadow the register name with a scope member
+              u32 GPIO <- 0;
               public void init() {
                   GPIO.DR <- 0xFF;
               }
@@ -7342,6 +7345,31 @@ describe("CodeGenerator", () => {
         ).toThrow("Use 'global.GPIO.DR' to access register");
       });
 
+      it("should allow bare register access from inside scope when NOT shadowed", () => {
+        // Issue #779: Ambiguity-aware validation - allow unambiguous access
+        const source = `
+          register GPIO @ 0x40000000 {
+              DR: u32 rw @ 0x00,
+          }
+          scope Motor {
+              public void init() {
+                  GPIO.DR <- 0xFF;
+              }
+          }
+        `;
+        const { tree, tokenStream } = CNextSourceParser.parse(source);
+        const generator = new CodeGenerator();
+        const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+        const symbols = TSymbolInfoAdapter.convert(tSymbols);
+        const code = generator.generate(tree, tokenStream, {
+          symbolInfo: symbols,
+          sourcePath: "test.cnx",
+        });
+
+        // Should generate GPIO_DR without error since GPIO is unambiguous
+        expect(code).toContain("GPIO_DR = 0xFF");
+      });
+
       it("should generate scope member write from outside any scope", () => {
         const source = `
           scope Timer {

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

@@ -38,16 +38,14 @@ describe("TypeValidator.resolveBareIdentifier", () => {
 
   beforeEach(() => {
     CodeGenState.reset();
-    CodeGenState.scopeMembers = new Map([
-      ["Motor", new Set(["speed", "maxSpeed"])],
-    ]);
-    CodeGenState.typeRegistry.set("globalCounter", {
+    CodeGenState.setScopeMembers("Motor", new Set(["speed", "maxSpeed"]));
+    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,
@@ -148,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) {
@@ -89,7 +89,9 @@ function setupState(options: SetupStateOptions = {}): void {
     CodeGenState.currentScope = options.currentScope;
   }
   if (options.scopeMembers) {
-    CodeGenState.scopeMembers = options.scopeMembers;
+    for (const [scope, members] of options.scopeMembers) {
+      CodeGenState.setScopeMembers(scope, members);
+    }
   }
   if (options.currentParameters) {
     CodeGenState.currentParameters = options.currentParameters;

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);