c-next 0.1.70 → 0.1.72

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

@@ -1,10 +1,17 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import parse from "./testHelpers";
+import TestScopeUtils from "./testUtils";
 import FunctionCollector from "../collectors/FunctionCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
+import SymbolRegistry from "../../../../state/SymbolRegistry";
+import TypeResolver from "../../../../../utils/TypeResolver";
 
 describe("FunctionCollector", () => {
+  beforeEach(() => {
+    TestScopeUtils.resetGlobalScope();
+    SymbolRegistry.reset();
+  });
+
   describe("basic function extraction", () => {
     it("collects a void function with no parameters", () => {
       const code = `
@@ -13,16 +20,24 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
-      expect(symbol.kind).toBe(ESymbolKind.Function);
+      expect(symbol.kind).toBe("function");
       expect(symbol.name).toBe("doNothing");
-      expect(symbol.returnType).toBe("void");
+      expect(TypeResolver.getTypeName(symbol.returnType)).toBe("void");
       expect(symbol.parameters).toEqual([]);
       expect(symbol.sourceFile).toBe("test.cnx");
       expect(symbol.sourceLanguage).toBe(ESourceLanguage.CNext);
       expect(symbol.visibility).toBe("private");
       expect(symbol.isExported).toBe(false);
+      expect(symbol.scope).toBe(globalScope);
     });
 
     it("collects a function with return type", () => {
@@ -33,9 +48,16 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
-      expect(symbol.returnType).toBe("u32");
+      expect(TypeResolver.getTypeName(symbol.returnType)).toBe("u32");
     });
 
     it("collects a function with primitive parameters", () => {
@@ -46,21 +68,22 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.parameters.length).toBe(2);
-      expect(symbol.parameters[0]).toEqual({
-        name: "a",
-        type: "i32",
-        isConst: false,
-        isArray: false,
-      });
-      expect(symbol.parameters[1]).toEqual({
-        name: "b",
-        type: "i32",
-        isConst: false,
-        isArray: false,
-      });
+      expect(symbol.parameters[0].name).toBe("a");
+      expect(TypeResolver.getTypeName(symbol.parameters[0].type)).toBe("i32");
+      expect(symbol.parameters[0].isConst).toBe(false);
+      expect(symbol.parameters[0].isArray).toBe(false);
+      expect(symbol.parameters[1].name).toBe("b");
+      expect(TypeResolver.getTypeName(symbol.parameters[1].type)).toBe("i32");
     });
   });
 
@@ -72,7 +95,14 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.parameters[0].isConst).toBe(true);
     });
@@ -84,7 +114,14 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.parameters[0].isArray).toBe(true);
       expect(symbol.parameters[0].arrayDimensions).toEqual([""]);
@@ -97,10 +134,17 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.parameters[0].isArray).toBe(true);
-      expect(symbol.parameters[0].arrayDimensions).toEqual(["256"]);
+      expect(symbol.parameters[0].arrayDimensions).toEqual([256]);
     });
 
     it("handles multi-dimensional array parameters (C-Next style)", () => {
@@ -110,51 +154,40 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.parameters[0].isArray).toBe(true);
-      expect(symbol.parameters[0].arrayDimensions).toEqual(["4", "4"]);
-    });
-  });
-
-  describe("signature generation", () => {
-    it("generates signature for overload detection", () => {
-      const code = `
-        i32 calculate(u32 x, f32 y) {
-          return 0;
-        }
-      `;
-      const tree = parse(code);
-      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
-
-      expect(symbol.signature).toBe("i32 calculate(u32, f32)");
-    });
-
-    it("includes scope prefix in signature", () => {
-      const code = `
-        void init() {
-        }
-      `;
-      const tree = parse(code);
-      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx", "Motor");
-
-      expect(symbol.signature).toBe("void Motor_init()");
+      expect(symbol.parameters[0].arrayDimensions).toEqual([4, 4]);
     });
   });
 
   describe("scoped functions", () => {
-    it("prefixes name with scope when scopeName is provided", () => {
+    it("uses scope reference properly", () => {
       const code = `
         void update() {
         }
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "motor.cnx", "Motor");
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "motor.cnx",
+        motorScope,
+        body,
+      );
 
-      expect(symbol.name).toBe("Motor_update");
+      expect(symbol.name).toBe("update");
+      expect(symbol.scope).toBe(motorScope);
+      expect(symbol.scope.name).toBe("Motor");
     });
 
     it("respects visibility parameter", () => {
@@ -164,10 +197,13 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const body = funcCtx.block();
       const symbol = FunctionCollector.collect(
         funcCtx,
         "motor.cnx",
-        "Motor",
+        motorScope,
+        body,
         "public",
       );
 
@@ -182,10 +218,13 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      const body = funcCtx.block();
       const symbol = FunctionCollector.collect(
         funcCtx,
         "motor.cnx",
-        "Motor",
+        motorScope,
+        body,
         "private",
       );
 
@@ -204,9 +243,16 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
-      expect(symbol.returnType).toBe("Point");
+      expect(TypeResolver.getTypeName(symbol.returnType)).toBe("Point");
     });
 
     it("handles user-defined parameter types", () => {
@@ -217,10 +263,17 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
-      expect(symbol.parameters[0].type).toBe("Point");
-      expect(symbol.parameters[1].type).toBe("Point");
+      expect(TypeResolver.getTypeName(symbol.parameters[0].type)).toBe("Point");
+      expect(TypeResolver.getTypeName(symbol.parameters[1].type)).toBe("Point");
     });
   });
 
@@ -233,9 +286,171 @@ describe("FunctionCollector", () => {
       `;
       const tree = parse(code);
       const funcCtx = tree.declaration(0)!.functionDeclaration()!;
-      const symbol = FunctionCollector.collect(funcCtx, "test.cnx");
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const body = funcCtx.block();
+      const symbol = FunctionCollector.collect(
+        funcCtx,
+        "test.cnx",
+        globalScope,
+        body,
+      );
 
       expect(symbol.sourceLine).toBe(3);
     });
   });
+
+  describe("collectAndRegister", () => {
+    it("returns a valid function symbol", () => {
+      const code = `
+        void doNothing() {
+        }
+      `;
+      const tree = parse(code);
+      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const body = funcCtx.block();
+
+      const symbol = FunctionCollector.collectAndRegister(
+        funcCtx,
+        "test.cnx",
+        undefined,
+        body,
+        "private",
+      );
+
+      expect(symbol.name).toBe("doNothing");
+      expect(TypeResolver.getTypeName(symbol.returnType)).toBe("void");
+      expect(symbol.visibility).toBe("private");
+    });
+
+    it("registers function in SymbolRegistry global scope", () => {
+      const code = `
+        u32 getValue() {
+          return 42;
+        }
+      `;
+      const tree = parse(code);
+      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const body = funcCtx.block();
+
+      FunctionCollector.collectAndRegister(
+        funcCtx,
+        "test.cnx",
+        undefined,
+        body,
+        "private",
+      );
+
+      const globalScope = SymbolRegistry.getGlobalScope();
+      expect(globalScope.functions.length).toBe(1);
+      expect(globalScope.functions[0].name).toBe("getValue");
+    });
+
+    it("creates scope and registers scoped functions", () => {
+      const code = `
+        void init() {
+        }
+      `;
+      const tree = parse(code);
+      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const body = funcCtx.block();
+
+      FunctionCollector.collectAndRegister(
+        funcCtx,
+        "motor.cnx",
+        "Motor",
+        body,
+        "public",
+      );
+
+      const motorScope = SymbolRegistry.getOrCreateScope("Motor");
+      expect(motorScope.functions.length).toBe(1);
+      expect(motorScope.functions[0].name).toBe("init");
+      expect(motorScope.functions[0].visibility).toBe("public");
+    });
+
+    it("reuses existing scope when registering multiple functions", () => {
+      const code = `
+        void funcA() {
+        }
+        void funcB() {
+        }
+      `;
+      const tree = parse(code);
+      const funcACtx = tree.declaration(0)!.functionDeclaration()!;
+      const funcBCtx = tree.declaration(1)!.functionDeclaration()!;
+
+      FunctionCollector.collectAndRegister(
+        funcACtx,
+        "test.cnx",
+        "Test",
+        funcACtx.block(),
+        "public",
+      );
+      FunctionCollector.collectAndRegister(
+        funcBCtx,
+        "test.cnx",
+        "Test",
+        funcBCtx.block(),
+        "private",
+      );
+
+      const testScope = SymbolRegistry.getOrCreateScope("Test");
+      expect(testScope.functions.length).toBe(2);
+      expect(testScope.functions[0].name).toBe("funcA");
+      expect(testScope.functions[1].name).toBe("funcB");
+    });
+
+    it("stores body AST reference in registered function", () => {
+      const code = `
+        void testFunc() {
+          u32 x <- 1;
+        }
+      `;
+      const tree = parse(code);
+      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+      const body = funcCtx.block();
+
+      FunctionCollector.collectAndRegister(
+        funcCtx,
+        "test.cnx",
+        undefined,
+        body,
+        "private",
+      );
+
+      const globalScope = SymbolRegistry.getGlobalScope();
+      const registeredFunc = globalScope.functions[0];
+      expect(registeredFunc.body).toBe(body);
+    });
+
+    it("resolves function via SymbolRegistry.resolveFunction", () => {
+      const code = `
+        i32 calculate(u32 x) {
+          return x * 2;
+        }
+      `;
+      const tree = parse(code);
+      const funcCtx = tree.declaration(0)!.functionDeclaration()!;
+
+      FunctionCollector.collectAndRegister(
+        funcCtx,
+        "test.cnx",
+        undefined,
+        funcCtx.block(),
+        "private",
+      );
+
+      const globalScope = SymbolRegistry.getGlobalScope();
+      const resolved = SymbolRegistry.resolveFunction("calculate", globalScope);
+      expect(resolved).not.toBeNull();
+      expect(resolved!.name).toBe("calculate");
+      expect(resolved!.returnType.kind).toBe("primitive");
+      // Cast to primitive type to access primitive property
+      const returnType = resolved!.returnType as {
+        kind: "primitive";
+        primitive: string;
+      };
+      expect(returnType.primitive).toBe("i32");
+    });
+  });
 });

package/src/transpiler/logic/symbols/cnext/__tests__/RegisterCollector.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 RegisterCollector from "../collectors/RegisterCollector";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
 
 describe("RegisterCollector", () => {
+  beforeEach(() => {
+    TestScopeUtils.resetGlobalScope();
+  });
+
   describe("basic register extraction", () => {
     it("collects a simple register with primitive members", () => {
       const code = `
@@ -15,14 +19,21 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
-      expect(symbol.kind).toBe(ESymbolKind.Register);
+      expect(symbol.kind).toBe("register");
       expect(symbol.name).toBe("GPIO");
       expect(symbol.baseAddress).toBe("0x40000000");
       expect(symbol.sourceFile).toBe("test.cnx");
       expect(symbol.sourceLanguage).toBe(ESourceLanguage.CNext);
       expect(symbol.isExported).toBe(true);
+      expect(symbol.scope).toBe(globalScope);
 
       expect(symbol.members.size).toBe(2);
       expect(symbol.members.get("DATA")).toEqual({
@@ -49,7 +60,13 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
       expect(symbol.members.get("RX")?.access).toBe("ro");
       expect(symbol.members.get("TX")?.access).toBe("wo");
@@ -70,7 +87,13 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
       expect(symbol.members.get("COUNT8")?.cType).toBe("uint8_t");
       expect(symbol.members.get("COUNT16")?.cType).toBe("uint16_t");
@@ -90,10 +113,12 @@ describe("RegisterCollector", () => {
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
       const knownBitmaps = new Set(["StatusFlags"]);
+      const globalScope = TestScopeUtils.getGlobalScope();
       const symbol = RegisterCollector.collect(
         regCtx,
         "test.cnx",
         knownBitmaps,
+        globalScope,
       );
 
       const member = symbol.members.get("FLAGS");
@@ -109,14 +134,20 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
       expect(symbol.members.get("VALUE")?.bitmapType).toBeUndefined();
     });
   });
 
   describe("scoped registers", () => {
-    it("prefixes name with scope when scopeName is provided", () => {
+    it("uses scope reference properly", () => {
       const code = `
         register CTRL @ 0x40005000 {
           STATUS: u32 rw @ 0x00,
@@ -124,14 +155,17 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const symbol = RegisterCollector.collect(
         regCtx,
         "motor.cnx",
         new Set(),
-        "Motor",
+        motorScope,
       );
 
-      expect(symbol.name).toBe("Motor_CTRL");
+      expect(symbol.name).toBe("CTRL");
+      expect(symbol.scope).toBe(motorScope);
+      expect(symbol.scope.name).toBe("Motor");
     });
 
     it("resolves scoped bitmap types", () => {
@@ -144,11 +178,12 @@ describe("RegisterCollector", () => {
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
       // Bitmap would be collected as Motor_MotorFlags in a scope
       const knownBitmaps = new Set(["Motor_MotorFlags"]);
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const symbol = RegisterCollector.collect(
         regCtx,
         "motor.cnx",
         knownBitmaps,
-        "Motor",
+        motorScope,
       );
 
       // The collector checks both scoped and unscoped names
@@ -165,7 +200,13 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
       expect(symbol.baseAddress).toBe("BASE_ADDR");
     });
@@ -181,7 +222,13 @@ describe("RegisterCollector", () => {
       `;
       const tree = parse(code);
       const regCtx = tree.declaration(0)!.registerDeclaration()!;
-      const symbol = RegisterCollector.collect(regCtx, "test.cnx", new Set());
+      const globalScope = TestScopeUtils.getGlobalScope();
+      const symbol = RegisterCollector.collect(
+        regCtx,
+        "test.cnx",
+        new Set(),
+        globalScope,
+      );
 
       expect(symbol.sourceLine).toBe(3);
     });