c-next 0.1.70 → 0.1.72

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "vitest";
 import parse from "./testHelpers";
 import BitmapCollector from "../collectors/BitmapCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import TestScopeUtils from "./testUtils";
 
 describe("BitmapCollector", () => {
   describe("basic bitmap extraction", () => {
@@ -18,9 +18,13 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "test.cnx");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
-      expect(symbol.kind).toBe(ESymbolKind.Bitmap);
+      expect(symbol.kind).toBe("bitmap");
       expect(symbol.name).toBe("Status");
       expect(symbol.backingType).toBe("uint8_t");
       expect(symbol.bitWidth).toBe(8);
@@ -47,7 +51,11 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "control.cnx");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "control.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.name).toBe("Control");
       expect(symbol.backingType).toBe("uint16_t");
@@ -68,7 +76,11 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "config.cnx");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "config.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.name).toBe("Config");
       expect(symbol.backingType).toBe("uint32_t");
@@ -85,7 +97,11 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "rgb.cnx");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "rgb.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.name).toBe("RGB");
       expect(symbol.backingType).toBe("uint32_t"); // 24-bit uses 32-bit backing
@@ -106,9 +122,16 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "motor.cnx",
+        motorScope,
+      );
 
-      expect(symbol.name).toBe("Motor_Flags");
+      // With the new IScopeSymbol-based design, name is just "Flags" (not prefixed)
+      // The prefixing happens in TSymbolAdapter for backwards compatibility
+      expect(symbol.name).toBe("Flags");
     });
   });
 
@@ -123,7 +146,13 @@ describe("BitmapCollector", () => {
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
 
-      expect(() => BitmapCollector.collect(bitmapCtx, "test.cnx")).toThrow(
+      expect(() =>
+        BitmapCollector.collect(
+          bitmapCtx,
+          "test.cnx",
+          TestScopeUtils.getGlobalScope(),
+        ),
+      ).toThrow(
         "Error: Bitmap 'TooMany' has 10 bits but bitmap8 requires exactly 8 bits",
       );
     });
@@ -138,7 +167,13 @@ describe("BitmapCollector", () => {
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
 
-      expect(() => BitmapCollector.collect(bitmapCtx, "test.cnx")).toThrow(
+      expect(() =>
+        BitmapCollector.collect(
+          bitmapCtx,
+          "test.cnx",
+          TestScopeUtils.getGlobalScope(),
+        ),
+      ).toThrow(
         "Error: Bitmap 'TooFew' has 4 bits but bitmap8 requires exactly 8 bits",
       );
     });
@@ -154,7 +189,11 @@ describe("BitmapCollector", () => {
       `;
       const tree = parse(code);
       const bitmapCtx = tree.declaration(0)!.bitmapDeclaration()!;
-      const symbol = BitmapCollector.collect(bitmapCtx, "test.cnx");
+      const symbol = BitmapCollector.collect(
+        bitmapCtx,
+        "test.cnx",
+        TestScopeUtils.getGlobalScope(),
+      );
 
       expect(symbol.sourceLine).toBe(3);
     });

package/src/transpiler/logic/symbols/cnext/__tests__/CNextResolver.integration.test.ts

@@ -1,8 +1,7 @@
 import { describe, expect, it } from "vitest";
 import parse from "./testHelpers";
 import CNextResolver from "../index";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
-import SymbolGuards from "../../types/typeGuards";
+import SymbolGuards from "../../../../types/symbols/SymbolGuards";
 
 describe("CNextResolver Integration", () => {
   describe("single declaration types", () => {
@@ -117,20 +116,24 @@ describe("CNextResolver Integration", () => {
       expect(scope).toBeDefined();
       expect(SymbolGuards.isScope(scope!)).toBe(true);
 
-      const positionVar = symbols.find((s) => s.name === "Motor_position");
+      // Members now have bare names with scope references
+      const positionVar = symbols.find((s) => s.name === "position");
       expect(positionVar).toBeDefined();
       expect(SymbolGuards.isVariable(positionVar!)).toBe(true);
+      expect(positionVar!.scope.name).toBe("Motor");
 
-      const initFunc = symbols.find((s) => s.name === "Motor_init");
+      const initFunc = symbols.find((s) => s.name === "init");
       expect(initFunc).toBeDefined();
       if (SymbolGuards.isFunction(initFunc!)) {
         expect(initFunc.visibility).toBe("public");
+        expect(initFunc.scope.name).toBe("Motor");
       }
 
-      const updateFunc = symbols.find((s) => s.name === "Motor_update");
+      const updateFunc = symbols.find((s) => s.name === "update");
       expect(updateFunc).toBeDefined();
       if (SymbolGuards.isFunction(updateFunc!)) {
         expect(updateFunc.visibility).toBe("private");
+        expect(updateFunc.scope.name).toBe("Motor");
       }
     });
 
@@ -153,13 +156,16 @@ describe("CNextResolver Integration", () => {
       // Scope + enum + struct
       expect(symbols.length).toBe(3);
 
-      const enumSym = symbols.find((s) => s.name === "Motor_State");
+      // Nested types have bare names with scope references
+      const enumSym = symbols.find((s) => s.name === "State");
       expect(enumSym).toBeDefined();
       expect(SymbolGuards.isEnum(enumSym!)).toBe(true);
+      expect(enumSym!.scope.name).toBe("Motor");
 
-      const structSym = symbols.find((s) => s.name === "Motor_Config");
+      const structSym = symbols.find((s) => s.name === "Config");
       expect(structSym).toBeDefined();
       expect(SymbolGuards.isStruct(structSym!)).toBe(true);
+      expect(structSym!.scope.name).toBe("Motor");
     });
   });
 
@@ -210,8 +216,10 @@ describe("CNextResolver Integration", () => {
       // Scope + bitmap + register
       expect(symbols.length).toBe(3);
 
-      const regSymbol = symbols.find((s) => s.name === "Motor_CTRL");
+      // Both bitmap and register have bare names with scope references
+      const regSymbol = symbols.find((s) => s.name === "CTRL");
       expect(regSymbol).toBeDefined();
+      expect(regSymbol!.scope.name).toBe("Motor");
       if (SymbolGuards.isRegister(regSymbol!)) {
         expect(regSymbol.members.get("FLAGS")?.bitmapType).toBe(
           "Motor_CtrlFlags",
@@ -270,44 +278,32 @@ describe("CNextResolver Integration", () => {
       // 1 bitmap (Status)
       // 1 register (GPIO)
       // 1 scope (Motor)
-      // 2 scope variables (Motor_position, Motor_direction)
-      // 2 scope functions (Motor_init, Motor_move)
+      // 2 scope variables (position, direction)
+      // 2 scope functions (init, move)
       // 1 top-level function (main)
       // Total: 10
       expect(symbols.length).toBe(10);
 
       // Verify each type is present
-      const structSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Struct,
-      );
+      const structSymbols = symbols.filter((s) => s.kind === "struct");
       expect(structSymbols.length).toBe(1);
 
-      const enumSymbols = symbols.filter((s) => s.kind === ESymbolKind.Enum);
+      const enumSymbols = symbols.filter((s) => s.kind === "enum");
       expect(enumSymbols.length).toBe(1);
 
-      const bitmapSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Bitmap,
-      );
+      const bitmapSymbols = symbols.filter((s) => s.kind === "bitmap");
       expect(bitmapSymbols.length).toBe(1);
 
-      const registerSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Register,
-      );
+      const registerSymbols = symbols.filter((s) => s.kind === "register");
       expect(registerSymbols.length).toBe(1);
 
-      const scopeSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Namespace,
-      );
+      const scopeSymbols = symbols.filter((s) => s.kind === "scope");
       expect(scopeSymbols.length).toBe(1);
 
-      const functionSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Function,
-      );
+      const functionSymbols = symbols.filter((s) => s.kind === "function");
       expect(functionSymbols.length).toBe(3);
 
-      const variableSymbols = symbols.filter(
-        (s) => s.kind === ESymbolKind.Variable,
-      );
+      const variableSymbols = symbols.filter((s) => s.kind === "variable");
       expect(variableSymbols.length).toBe(2);
     });
 
@@ -340,10 +336,22 @@ describe("CNextResolver Integration", () => {
       expect(ledScope).toBeDefined();
       expect(motorScope).toBeDefined();
 
-      expect(symbols.find((s) => s.name === "LED_on")).toBeDefined();
-      expect(symbols.find((s) => s.name === "LED_off")).toBeDefined();
-      expect(symbols.find((s) => s.name === "Motor_start")).toBeDefined();
-      expect(symbols.find((s) => s.name === "Motor_stop")).toBeDefined();
+      // Functions have bare names with scope references
+      const onFunc = symbols.find((s) => s.name === "on");
+      expect(onFunc).toBeDefined();
+      expect(onFunc!.scope.name).toBe("LED");
+
+      const offFunc = symbols.find((s) => s.name === "off");
+      expect(offFunc).toBeDefined();
+      expect(offFunc!.scope.name).toBe("LED");
+
+      const startFunc = symbols.find((s) => s.name === "start");
+      expect(startFunc).toBeDefined();
+      expect(startFunc!.scope.name).toBe("Motor");
+
+      const stopFunc = symbols.find((s) => s.name === "stop");
+      expect(stopFunc).toBeDefined();
+      expect(stopFunc!.scope.name).toBe("Motor");
     });
   });
 
@@ -386,7 +394,10 @@ describe("CNextResolver Integration", () => {
       const tree = parse(code);
       const symbols = CNextResolver.resolve(tree, "test.cnx");
 
-      const bufferSymbol = symbols.find((s) => s.name === "Device_buffer");
+      // Find buffer by bare name with scope reference
+      const bufferSymbol = symbols.find(
+        (s) => s.name === "buffer" && s.scope?.name === "Device",
+      );
       expect(bufferSymbol).toBeDefined();
       if (SymbolGuards.isVariable(bufferSymbol!)) {
         expect(bufferSymbol.isArray).toBe(true);

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

@@ -1,10 +1,14 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import parse from "./testHelpers";
+import TestScopeUtils from "./testUtils";
 import EnumCollector from "../collectors/EnumCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
 
 describe("EnumCollector", () => {
+  beforeEach(() => {
+    TestScopeUtils.resetGlobalScope();
+  });
+
   describe("basic enum extraction", () => {
     it("collects a simple enum with auto-increment values", () => {
       const code = `
@@ -16,13 +20,15 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
-      expect(symbol.kind).toBe(ESymbolKind.Enum);
+      expect(symbol.kind).toBe("enum");
       expect(symbol.name).toBe("Color");
       expect(symbol.sourceFile).toBe("test.cnx");
       expect(symbol.sourceLanguage).toBe(ESourceLanguage.CNext);
       expect(symbol.isExported).toBe(true);
+      expect(symbol.scope).toBe(globalScope);
 
       // Check members
       expect(symbol.members.size).toBe(3);
@@ -41,7 +47,8 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
       expect(symbol.members.get("Low")).toBe(10);
       expect(symbol.members.get("Medium")).toBe(20);
@@ -60,7 +67,8 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
       expect(symbol.members.get("Idle")).toBe(0);
       expect(symbol.members.get("Running")).toBe(5);
@@ -81,7 +89,8 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
       expect(symbol.members.get("A")).toBe(1);
       expect(symbol.members.get("B")).toBe(2);
@@ -99,7 +108,8 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
       expect(symbol.members.get("Bit0")).toBe(1);
       expect(symbol.members.get("Bit1")).toBe(2);
@@ -109,7 +119,7 @@ describe("EnumCollector", () => {
   });
 
   describe("scoped enums", () => {
-    it("prefixes name with scope when scopeName is provided", () => {
+    it("uses scope reference properly", () => {
       const code = `
         enum State {
           Off,
@@ -118,9 +128,12 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const symbol = EnumCollector.collect(enumCtx, "motor.cnx", motorScope);
 
-      expect(symbol.name).toBe("Motor_State");
+      expect(symbol.name).toBe("State");
+      expect(symbol.scope).toBe(motorScope);
+      expect(symbol.scope.name).toBe("Motor");
     });
   });
 
@@ -133,8 +146,11 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
+      const globalScope = TestScopeUtils.getGlobalScope();
 
-      expect(() => EnumCollector.collect(enumCtx, "test.cnx")).toThrow(
+      expect(() =>
+        EnumCollector.collect(enumCtx, "test.cnx", globalScope),
+      ).toThrow(
         "Error: Negative values not allowed in enum (found -1 in Invalid.Bad)",
       );
     });
@@ -150,7 +166,8 @@ describe("EnumCollector", () => {
       `;
       const tree = parse(code);
       const enumCtx = tree.declaration(0)!.enumDeclaration()!;
-      const symbol = EnumCollector.collect(enumCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = EnumCollector.collect(enumCtx, "test.cnx", globalScope);
 
       expect(symbol.sourceLine).toBe(3);
     });