c-next 0.1.69 → 0.1.71

package/src/transpiler/logic/symbols/cnext/__tests__/ScopeCollector.test.ts

@@ -1,11 +1,16 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import parse from "./testHelpers";
 import ScopeCollector from "../collectors/ScopeCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import SymbolGuards from "../../types/typeGuards";
+import SymbolGuards from "../../../../types/symbols/SymbolGuards";
+import SymbolRegistry from "../../../../state/SymbolRegistry";
+import TypeResolver from "../../../../../utils/TypeResolver";
 
 describe("ScopeCollector", () => {
+  beforeEach(() => {
+    SymbolRegistry.reset();
+  });
+
   describe("basic scope extraction", () => {
     it("collects an empty scope", () => {
       const code = `
@@ -16,7 +21,7 @@ describe("ScopeCollector", () => {
       const scopeCtx = tree.declaration(0)!.scopeDeclaration()!;
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", new Set());
 
-      expect(result.scopeSymbol.kind).toBe(ESymbolKind.Namespace);
+      expect(result.scopeSymbol.kind).toBe("scope");
       expect(result.scopeSymbol.name).toBe("Motor");
       expect(result.scopeSymbol.members).toEqual([]);
       expect(result.scopeSymbol.sourceFile).toBe("test.cnx");
@@ -45,24 +50,23 @@ describe("ScopeCollector", () => {
 
       expect(result.memberSymbols.length).toBe(2);
 
-      const initFunc = result.memberSymbols.find(
-        (s) => s.name === "Motor_init",
-      );
+      // Functions now have bare names with scope references
+      const initFunc = result.memberSymbols.find((s) => s.name === "init");
       expect(initFunc).toBeDefined();
       expect(SymbolGuards.isFunction(initFunc!)).toBe(true);
       if (SymbolGuards.isFunction(initFunc!)) {
         expect(initFunc.visibility).toBe("public");
         expect(initFunc.isExported).toBe(true);
+        expect(initFunc.scope.name).toBe("Motor");
       }
 
-      const updateFunc = result.memberSymbols.find(
-        (s) => s.name === "Motor_update",
-      );
+      const updateFunc = result.memberSymbols.find((s) => s.name === "update");
       expect(updateFunc).toBeDefined();
       expect(SymbolGuards.isFunction(updateFunc!)).toBe(true);
       if (SymbolGuards.isFunction(updateFunc!)) {
         expect(updateFunc.visibility).toBe("private");
         expect(updateFunc.isExported).toBe(false);
+        expect(updateFunc.scope.name).toBe("Motor");
       }
     });
 
@@ -85,14 +89,14 @@ describe("ScopeCollector", () => {
 
       expect(result.memberSymbols.length).toBe(2);
 
-      const posVar = result.memberSymbols.find(
-        (s) => s.name === "Motor_position",
-      );
+      // Variables now have bare names with scope references
+      const posVar = result.memberSymbols.find((s) => s.name === "position");
       expect(posVar).toBeDefined();
       expect(SymbolGuards.isVariable(posVar!)).toBe(true);
       if (SymbolGuards.isVariable(posVar!)) {
-        expect(posVar.type).toBe("u32");
+        expect(TypeResolver.getTypeName(posVar.type)).toBe("u32");
         expect(posVar.isExported).toBe(false);
+        expect(posVar.scope.name).toBe("Motor");
       }
     });
   });
@@ -114,15 +118,15 @@ describe("ScopeCollector", () => {
 
       expect(result.scopeSymbol.members).toEqual(["State"]);
 
-      const enumSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_State",
-      );
+      // Enum has bare name with scope reference
+      const enumSymbol = result.memberSymbols.find((s) => s.name === "State");
       expect(enumSymbol).toBeDefined();
       expect(SymbolGuards.isEnum(enumSymbol!)).toBe(true);
       if (SymbolGuards.isEnum(enumSymbol!)) {
         expect(enumSymbol.members.get("Off")).toBe(0);
         expect(enumSymbol.members.get("Running")).toBe(1);
         expect(enumSymbol.members.get("Error")).toBe(2);
+        expect(enumSymbol.scope.name).toBe("Motor");
       }
     });
 
@@ -139,14 +143,16 @@ describe("ScopeCollector", () => {
       const scopeCtx = tree.declaration(0)!.scopeDeclaration()!;
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", new Set());
 
+      // Struct has bare name with scope reference
       const structSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_Config",
+        (s) => s.name === "Config",
       );
       expect(structSymbol).toBeDefined();
       expect(SymbolGuards.isStruct(structSymbol!)).toBe(true);
       if (SymbolGuards.isStruct(structSymbol!)) {
-        expect(structSymbol.fields.get("maxSpeed")?.type).toBe("u32");
-        expect(structSymbol.fields.get("acceleration")?.type).toBe("u32");
+        expect(structSymbol.fields.get("maxSpeed")).toBeDefined();
+        expect(structSymbol.fields.get("acceleration")).toBeDefined();
+        expect(structSymbol.scope.name).toBe("Motor");
       }
     });
 
@@ -166,8 +172,9 @@ describe("ScopeCollector", () => {
       const scopeCtx = tree.declaration(0)!.scopeDeclaration()!;
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", new Set());
 
+      // Bitmap has bare name with scope reference
       const bitmapSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_Status",
+        (s) => s.name === "Status",
       );
       expect(bitmapSymbol).toBeDefined();
       expect(SymbolGuards.isBitmap(bitmapSymbol!)).toBe(true);
@@ -177,6 +184,7 @@ describe("ScopeCollector", () => {
           offset: 0,
           width: 1,
         });
+        expect(bitmapSymbol.scope.name).toBe("Motor");
       }
     });
 
@@ -193,15 +201,15 @@ describe("ScopeCollector", () => {
       const scopeCtx = tree.declaration(0)!.scopeDeclaration()!;
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", new Set());
 
-      const regSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_CTRL",
-      );
+      // Register has bare name with scope reference
+      const regSymbol = result.memberSymbols.find((s) => s.name === "CTRL");
       expect(regSymbol).toBeDefined();
       expect(SymbolGuards.isRegister(regSymbol!)).toBe(true);
       if (SymbolGuards.isRegister(regSymbol!)) {
         expect(regSymbol.baseAddress).toBe("0x40001000");
         expect(regSymbol.members.get("STATUS")?.access).toBe("rw");
         expect(regSymbol.members.get("COMMAND")?.access).toBe("wo");
+        expect(regSymbol.scope.name).toBe("Motor");
       }
     });
   });
@@ -228,21 +236,18 @@ describe("ScopeCollector", () => {
       expect(result.scopeSymbol.members).toEqual(["position", "init", "State"]);
       expect(result.memberSymbols.length).toBe(3);
 
-      // Verify each type was collected correctly
-      const varSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_position",
-      );
+      // Verify each type was collected correctly with bare names
+      const varSymbol = result.memberSymbols.find((s) => s.name === "position");
       expect(SymbolGuards.isVariable(varSymbol!)).toBe(true);
+      expect(varSymbol!.scope.name).toBe("Motor");
 
-      const funcSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_init",
-      );
+      const funcSymbol = result.memberSymbols.find((s) => s.name === "init");
       expect(SymbolGuards.isFunction(funcSymbol!)).toBe(true);
+      expect(funcSymbol!.scope.name).toBe("Motor");
 
-      const enumSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_State",
-      );
+      const enumSymbol = result.memberSymbols.find((s) => s.name === "State");
       expect(SymbolGuards.isEnum(enumSymbol!)).toBe(true);
+      expect(enumSymbol!.scope.name).toBe("Motor");
     });
   });
 
@@ -261,9 +266,7 @@ describe("ScopeCollector", () => {
       const knownBitmaps = new Set(["Motor_MotorFlags"]);
       const result = ScopeCollector.collect(scopeCtx, "test.cnx", knownBitmaps);
 
-      const regSymbol = result.memberSymbols.find(
-        (s) => s.name === "Motor_CTRL",
-      );
+      const regSymbol = result.memberSymbols.find((s) => s.name === "CTRL");
       expect(SymbolGuards.isRegister(regSymbol!)).toBe(true);
       if (SymbolGuards.isRegister(regSymbol!)) {
         expect(regSymbol.members.get("FLAGS")?.bitmapType).toBe(

package/src/transpiler/logic/symbols/cnext/__tests__/StructCollector.test.ts

@@ -1,10 +1,15 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import parse from "./testHelpers";
+import TestScopeUtils from "./testUtils";
 import StructCollector from "../collectors/StructCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import TypeResolver from "../../../../../utils/TypeResolver";
 
 describe("StructCollector", () => {
+  beforeEach(() => {
+    TestScopeUtils.resetGlobalScope();
+  });
+
   describe("basic struct extraction", () => {
     it("collects a simple struct with primitive fields", () => {
       const code = `
@@ -15,25 +20,33 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
-      expect(symbol.kind).toBe(ESymbolKind.Struct);
+      expect(symbol.kind).toBe("struct");
       expect(symbol.name).toBe("Point");
       expect(symbol.sourceFile).toBe("test.cnx");
       expect(symbol.sourceLanguage).toBe(ESourceLanguage.CNext);
       expect(symbol.isExported).toBe(true);
+      expect(symbol.scope).toBe(globalScope);
 
       expect(symbol.fields.size).toBe(2);
-      expect(symbol.fields.get("x")).toEqual({
-        type: "i32",
-        isArray: false,
-        isConst: false,
-      });
-      expect(symbol.fields.get("y")).toEqual({
-        type: "i32",
-        isArray: false,
-        isConst: false,
-      });
+
+      const xField = symbol.fields.get("x");
+      expect(xField).toBeDefined();
+      expect(TypeResolver.getTypeName(xField!.type)).toBe("i32");
+      expect(xField!.isArray).toBe(false);
+      expect(xField!.isConst).toBe(false);
+
+      const yField = symbol.fields.get("y");
+      expect(yField).toBeDefined();
+      expect(TypeResolver.getTypeName(yField!.type)).toBe("i32");
+      expect(yField!.isArray).toBe(false);
+      expect(yField!.isConst).toBe(false);
     });
 
     it("collects a struct with various primitive types", () => {
@@ -49,14 +62,31 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
-
-      expect(symbol.fields.get("version")?.type).toBe("u8");
-      expect(symbol.fields.get("flags")?.type).toBe("u16");
-      expect(symbol.fields.get("size")?.type).toBe("u32");
-      expect(symbol.fields.get("timestamp")?.type).toBe("i64");
-      expect(symbol.fields.get("scale")?.type).toBe("f32");
-      expect(symbol.fields.get("enabled")?.type).toBe("bool");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
+
+      expect(TypeResolver.getTypeName(symbol.fields.get("version")!.type)).toBe(
+        "u8",
+      );
+      expect(TypeResolver.getTypeName(symbol.fields.get("flags")!.type)).toBe(
+        "u16",
+      );
+      expect(TypeResolver.getTypeName(symbol.fields.get("size")!.type)).toBe(
+        "u32",
+      );
+      expect(
+        TypeResolver.getTypeName(symbol.fields.get("timestamp")!.type),
+      ).toBe("i64");
+      expect(TypeResolver.getTypeName(symbol.fields.get("scale")!.type)).toBe(
+        "f32",
+      );
+      expect(TypeResolver.getTypeName(symbol.fields.get("enabled")!.type)).toBe(
+        "bool",
+      );
     });
   });
 
@@ -69,10 +99,15 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       const field = symbol.fields.get("data");
-      expect(field?.type).toBe("u8");
+      expect(TypeResolver.getTypeName(field!.type)).toBe("u8");
       expect(field?.isArray).toBe(true);
       expect(field?.dimensions).toEqual([256]);
     });
@@ -85,10 +120,15 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       const field = symbol.fields.get("values");
-      expect(field?.type).toBe("f32");
+      expect(TypeResolver.getTypeName(field!.type)).toBe("f32");
       expect(field?.isArray).toBe(true);
       expect(field?.dimensions).toEqual([4, 4]);
     });
@@ -102,10 +142,11 @@ describe("StructCollector", () => {
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
       const constValues = new Map<string, number>([["BUFFER_SIZE", 256]]);
+      const globalScope = TestScopeUtils.getGlobalScope();
       const symbol = StructCollector.collect(
         structCtx,
         "test.cnx",
-        undefined,
+        globalScope,
         constValues,
       );
 
@@ -126,10 +167,11 @@ describe("StructCollector", () => {
         ["ROWS", 4],
         ["COLS", 3],
       ]);
+      const globalScope = TestScopeUtils.getGlobalScope();
       const symbol = StructCollector.collect(
         structCtx,
         "test.cnx",
-        undefined,
+        globalScope,
         constValues,
       );
 
@@ -147,10 +189,11 @@ describe("StructCollector", () => {
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
       const constValues = new Map<string, number>([["HEX_SIZE", 16]]);
+      const globalScope = TestScopeUtils.getGlobalScope();
       const symbol = StructCollector.collect(
         structCtx,
         "test.cnx",
-        undefined,
+        globalScope,
         constValues,
       );
 
@@ -169,11 +212,16 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       const field = symbol.fields.get("name");
       // Issue #139: Type includes capacity for string validation in CodeGenerator
-      expect(field?.type).toBe("string<32>");
+      expect(TypeResolver.getTypeName(field!.type)).toBe("string<32>");
       expect(field?.isArray).toBe(true);
       expect(field?.dimensions).toEqual([33]); // 32 + 1 for null terminator
     });
@@ -186,11 +234,16 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       const field = symbol.fields.get("items");
       // Issue #139: Type includes capacity for string validation in CodeGenerator
-      expect(field?.type).toBe("string<16>");
+      expect(TypeResolver.getTypeName(field!.type)).toBe("string<16>");
       expect(field?.isArray).toBe(true);
       expect(field?.dimensions).toEqual([5, 17]); // [5] array, then 16+1 for string
     });
@@ -204,15 +257,16 @@ describe("StructCollector", () => {
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
       const constValues = new Map<string, number>([["MAX_NAMES", 3]]);
+      const globalScope = TestScopeUtils.getGlobalScope();
       const symbol = StructCollector.collect(
         structCtx,
         "test.cnx",
-        undefined,
+        globalScope,
         constValues,
       );
 
       const field = symbol.fields.get("items");
-      expect(field?.type).toBe("string<16>");
+      expect(TypeResolver.getTypeName(field!.type)).toBe("string<16>");
       expect(field?.isArray).toBe(true);
       expect(field?.dimensions).toEqual([3, 17]); // [3] from const, then 16+1 for string
     });
@@ -230,7 +284,12 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       expect(symbol.fields.get("maxSize")?.isConst).toBe(false);
       expect(symbol.fields.get("currentSize")?.isConst).toBe(false);
@@ -247,15 +306,24 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
-      expect(symbol.fields.get("start")?.type).toBe("Point");
-      expect(symbol.fields.get("end")?.type).toBe("Point");
+      expect(TypeResolver.getTypeName(symbol.fields.get("start")!.type)).toBe(
+        "Point",
+      );
+      expect(TypeResolver.getTypeName(symbol.fields.get("end")!.type)).toBe(
+        "Point",
+      );
     });
   });
 
   describe("scoped structs", () => {
-    it("prefixes name with scope when scopeName is provided", () => {
+    it("uses scope reference properly", () => {
       const code = `
         struct Config {
           u32 value;
@@ -263,9 +331,16 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const symbol = StructCollector.collect(
+        structCtx,
+        "motor.cnx",
+        motorScope,
+      );
 
-      expect(symbol.name).toBe("Motor_Config");
+      expect(symbol.name).toBe("Config");
+      expect(symbol.scope).toBe(motorScope);
+      expect(symbol.scope.name).toBe("Motor");
     });
 
     it("resolves this.Type references within scope", () => {
@@ -278,9 +353,15 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const symbol = StructCollector.collect(
+        structCtx,
+        "motor.cnx",
+        motorScope,
+      );
 
-      expect(symbol.name).toBe("Motor_Container");
+      expect(symbol.name).toBe("Container");
+      expect(symbol.scope.name).toBe("Motor");
     });
   });
 
@@ -294,7 +375,12 @@ describe("StructCollector", () => {
       `;
       const tree = parse(code);
       const structCtx = tree.declaration(0)!.structDeclaration()!;
-      const symbol = StructCollector.collect(structCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = StructCollector.collect(
+        structCtx,
+        "test.cnx",
+        globalScope,
+      );
 
       expect(symbol.sourceLine).toBe(3);
     });