c-next 0.1.70 → 0.1.72

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

@@ -8,29 +8,51 @@
 
 import { describe, expect, it } from "vitest";
 import TSymbolInfoAdapter from "../adapters/TSymbolInfoAdapter";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../../utils/types/ESourceLanguage";
-import IBitmapSymbol from "../../types/IBitmapSymbol";
-import IEnumSymbol from "../../types/IEnumSymbol";
-import IStructSymbol from "../../types/IStructSymbol";
-import IRegisterSymbol from "../../types/IRegisterSymbol";
-import IScopeSymbol from "../../types/IScopeSymbol";
-import IVariableSymbol from "../../types/IVariableSymbol";
-import IFunctionSymbol from "../../types/IFunctionSymbol";
+import IBitmapSymbol from "../../../../types/symbols/IBitmapSymbol";
+import IEnumSymbol from "../../../../types/symbols/IEnumSymbol";
+import IStructSymbol from "../../../../types/symbols/IStructSymbol";
+import IRegisterSymbol from "../../../../types/symbols/IRegisterSymbol";
+import IVariableSymbol from "../../../../types/symbols/IVariableSymbol";
+import IFunctionSymbol from "../../../../types/symbols/IFunctionSymbol";
+import TypeResolver from "../../../../../utils/TypeResolver";
+import TestScopeUtils from "./testUtils";
 
 describe("TSymbolInfoAdapter", () => {
+  // Reset global scope between tests to avoid state pollution
+  const globalScope = TestScopeUtils.getGlobalScope();
+
   describe("convert structs", () => {
     it("should populate knownStructs set", () => {
       const struct: IStructSymbol = {
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         name: "Point",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
         fields: new Map([
-          ["x", { type: "i32", isArray: false, isConst: false }],
-          ["y", { type: "i32", isArray: false, isConst: false }],
+          [
+            "x",
+            {
+              name: "x",
+              type: TypeResolver.resolve("i32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
+          ],
+          [
+            "y",
+            {
+              name: "y",
+              type: TypeResolver.resolve("i32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
+          ],
         ]),
       };
 
@@ -41,15 +63,34 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate structFields map", () => {
       const struct: IStructSymbol = {
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         name: "Point",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
         fields: new Map([
-          ["x", { type: "i32", isArray: false, isConst: false }],
-          ["y", { type: "f32", isArray: false, isConst: false }],
+          [
+            "x",
+            {
+              name: "x",
+              type: TypeResolver.resolve("i32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
+          ],
+          [
+            "y",
+            {
+              name: "y",
+              type: TypeResolver.resolve("f32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
+          ],
         ]),
       };
 
@@ -61,8 +102,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate structFieldArrays for array fields", () => {
       const struct: IStructSymbol = {
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         name: "Buffer",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -70,9 +112,25 @@ describe("TSymbolInfoAdapter", () => {
         fields: new Map([
           [
             "data",
-            { type: "u8", isArray: true, isConst: false, dimensions: [256] },
+            {
+              name: "data",
+              type: TypeResolver.resolve("u8"),
+              isArray: true,
+              isConst: false,
+              isAtomic: false,
+              dimensions: [256],
+            },
+          ],
+          [
+            "size",
+            {
+              name: "size",
+              type: TypeResolver.resolve("u32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
           ],
-          ["size", { type: "u32", isArray: false, isConst: false }],
         ]),
       };
 
@@ -84,8 +142,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate structFieldDimensions for array fields", () => {
       const struct: IStructSymbol = {
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         name: "Matrix",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -93,7 +152,14 @@ describe("TSymbolInfoAdapter", () => {
         fields: new Map([
           [
             "values",
-            { type: "f32", isArray: true, isConst: false, dimensions: [4, 4] },
+            {
+              name: "values",
+              type: TypeResolver.resolve("f32"),
+              isArray: true,
+              isConst: false,
+              isAtomic: false,
+              dimensions: [4, 4],
+            },
           ],
         ]),
       };
@@ -109,8 +175,9 @@ describe("TSymbolInfoAdapter", () => {
   describe("convert enums", () => {
     it("should populate knownEnums set", () => {
       const enumSym: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         name: "Color",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -129,8 +196,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate enumMembers map", () => {
       const enumSym: IEnumSymbol = {
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         name: "Priority",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -153,8 +221,9 @@ describe("TSymbolInfoAdapter", () => {
   describe("convert bitmaps", () => {
     it("should populate knownBitmaps set", () => {
       const bitmap: IBitmapSymbol = {
-        kind: ESymbolKind.Bitmap,
+        kind: "bitmap",
         name: "Status",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -171,8 +240,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate bitmapBackingType and bitmapBitWidth", () => {
       const bitmap: IBitmapSymbol = {
-        kind: ESymbolKind.Bitmap,
+        kind: "bitmap",
         name: "Control",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -194,8 +264,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate bitmapFields with offset and width", () => {
       const bitmap: IBitmapSymbol = {
-        kind: ESymbolKind.Bitmap,
+        kind: "bitmap",
         name: "Flags",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -220,42 +291,33 @@ describe("TSymbolInfoAdapter", () => {
 
   describe("convert scopes", () => {
     it("should populate knownScopes set", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "Motor",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["init", "run"],
-        memberVisibility: new Map([
-          ["init", "public"],
-          ["run", "private"],
-        ]),
-      };
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      (motorScope.members as string[]).push("init", "run");
+      (motorScope.memberVisibility as Map<string, string>).set(
+        "init",
+        "public",
+      );
+      (motorScope.memberVisibility as Map<string, string>).set(
+        "run",
+        "private",
+      );
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([motorScope]);
 
       expect(info.knownScopes.has("Motor")).toBe(true);
     });
 
     it("should populate scopeMembers with member names", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "LED",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["on", "off", "toggle"],
-        memberVisibility: new Map([
-          ["on", "public"],
-          ["off", "public"],
-          ["toggle", "private"],
-        ]),
-      };
+      const ledScope = TestScopeUtils.createMockScope("LED");
+      (ledScope.members as string[]).push("on", "off", "toggle");
+      (ledScope.memberVisibility as Map<string, string>).set("on", "public");
+      (ledScope.memberVisibility as Map<string, string>).set("off", "public");
+      (ledScope.memberVisibility as Map<string, string>).set(
+        "toggle",
+        "private",
+      );
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([ledScope]);
 
       const members = info.scopeMembers.get("LED");
       expect(members?.has("on")).toBe(true);
@@ -264,22 +326,22 @@ describe("TSymbolInfoAdapter", () => {
     });
 
     it("should populate scopeMemberVisibility", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "Timer",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["start", "stop", "reset"],
-        memberVisibility: new Map([
-          ["start", "public"],
-          ["stop", "public"],
-          ["reset", "private"],
-        ]),
-      };
+      const timerScope = TestScopeUtils.createMockScope("Timer");
+      (timerScope.members as string[]).push("start", "stop", "reset");
+      (timerScope.memberVisibility as Map<string, string>).set(
+        "start",
+        "public",
+      );
+      (timerScope.memberVisibility as Map<string, string>).set(
+        "stop",
+        "public",
+      );
+      (timerScope.memberVisibility as Map<string, string>).set(
+        "reset",
+        "private",
+      );
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([timerScope]);
 
       const visibility = info.scopeMemberVisibility.get("Timer");
       expect(visibility?.get("start")).toBe("public");
@@ -291,8 +353,9 @@ describe("TSymbolInfoAdapter", () => {
   describe("convert registers", () => {
     it("should populate knownRegisters set", () => {
       const register: IRegisterSymbol = {
-        kind: ESymbolKind.Register,
+        kind: "register",
         name: "GPIO",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -310,8 +373,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate registerBaseAddresses", () => {
       const register: IRegisterSymbol = {
-        kind: ESymbolKind.Register,
+        kind: "register",
         name: "UART",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -329,8 +393,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should populate register member info maps", () => {
       const register: IRegisterSymbol = {
-        kind: ESymbolKind.Register,
+        kind: "register",
         name: "SPI",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -354,8 +419,9 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should track bitmap types for register members", () => {
       const bitmap: IBitmapSymbol = {
-        kind: ESymbolKind.Bitmap,
+        kind: "bitmap",
         name: "StatusFlags",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -366,8 +432,9 @@ describe("TSymbolInfoAdapter", () => {
       };
 
       const register: IRegisterSymbol = {
-        kind: ESymbolKind.Register,
+        kind: "register",
         name: "CTRL",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
@@ -395,15 +462,17 @@ describe("TSymbolInfoAdapter", () => {
 
   describe("convert variables", () => {
     it("should track private scope const values for inlining", () => {
-      // Variable with scope prefix (scoped variable)
+      // Create a scoped variable with bare name and scope reference
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
-        kind: ESymbolKind.Variable,
-        name: "Motor_MAX_SPEED",
+        kind: "variable",
+        name: "MAX_SPEED", // Bare name - adapter computes mangled name
+        scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: false, // private
-        type: "u32",
+        type: TypeResolver.resolve("u32"),
         isConst: true,
         isAtomic: false,
         isArray: false,
@@ -412,18 +481,21 @@ describe("TSymbolInfoAdapter", () => {
 
       const info = TSymbolInfoAdapter.convert([variable]);
 
+      // Adapter stores using mangled name (scope + bare name)
       expect(info.scopePrivateConstValues.get("Motor_MAX_SPEED")).toBe("255");
     });
 
     it("should not track public const values", () => {
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
-        kind: ESymbolKind.Variable,
-        name: "Motor_PUBLIC_CONST",
+        kind: "variable",
+        name: "PUBLIC_CONST", // Bare name - adapter computes mangled name
+        scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true, // public
-        type: "u32",
+        type: TypeResolver.resolve("u32"),
         isConst: true,
         isAtomic: false,
         isArray: false,
@@ -438,14 +510,16 @@ describe("TSymbolInfoAdapter", () => {
     });
 
     it("should not track non-const private values", () => {
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
-        kind: ESymbolKind.Variable,
-        name: "Motor_counter",
+        kind: "variable",
+        name: "counter", // Bare name - adapter computes mangled name
+        scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: false,
-        type: "u32",
+        type: TypeResolver.resolve("u32"),
         isConst: false, // not const
         isAtomic: false,
         isArray: false,
@@ -458,14 +532,16 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should NOT track private const array values for inlining", () => {
       // Issue #500: Array consts must be emitted, not inlined
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
-        kind: ESymbolKind.Variable,
-        name: "Motor_LOOKUP_TABLE",
+        kind: "variable",
+        name: "LOOKUP_TABLE", // Bare name - adapter computes mangled name
+        scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: false,
-        type: "u16",
+        type: TypeResolver.resolve("u16"),
         isConst: true,
         isAtomic: false,
         isArray: true,
@@ -483,14 +559,16 @@ describe("TSymbolInfoAdapter", () => {
 
     it("should NOT track private const multi-dimensional array values", () => {
       // Issue #500: Multi-dimensional arrays must also be emitted
+      const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
-        kind: ESymbolKind.Variable,
-        name: "Motor_MATRIX",
+        kind: "variable",
+        name: "MATRIX", // Bare name - adapter computes mangled name
+        scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: false,
-        type: "u8",
+        type: TypeResolver.resolve("u8"),
         isConst: true,
         isAtomic: false,
         isArray: true,
@@ -506,49 +584,48 @@ describe("TSymbolInfoAdapter", () => {
 
   describe("hasPublicSymbols", () => {
     it("should return true when scope has public members", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "LED",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["on"],
-        memberVisibility: new Map([["on", "public"]]),
-      };
+      const ledScope = TestScopeUtils.createMockScope("LED");
+      (ledScope.members as string[]).push("on");
+      (ledScope.memberVisibility as Map<string, string>).set("on", "public");
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([ledScope]);
 
       expect(info.hasPublicSymbols()).toBe(true);
     });
 
     it("should return false when all scope members are private", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "Internal",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["helper"],
-        memberVisibility: new Map([["helper", "private"]]),
-      };
+      const internalScope = TestScopeUtils.createMockScope("Internal");
+      (internalScope.members as string[]).push("helper");
+      (internalScope.memberVisibility as Map<string, string>).set(
+        "helper",
+        "private",
+      );
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([internalScope]);
 
       expect(info.hasPublicSymbols()).toBe(false);
     });
 
     it("should return false when there are no scopes", () => {
       const struct: IStructSymbol = {
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         name: "Point",
+        scope: globalScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
         fields: new Map([
-          ["x", { type: "i32", isArray: false, isConst: false }],
+          [
+            "x",
+            {
+              name: "x",
+              type: TypeResolver.resolve("i32"),
+              isArray: false,
+              isConst: false,
+              isAtomic: false,
+            },
+          ],
         ]),
       };
 
@@ -568,18 +645,14 @@ describe("TSymbolInfoAdapter", () => {
     // Note: scopeVariableUsage requires function body analysis
     // which isn't done by the current collectors
     it("should return null for unknown variables", () => {
-      const scope: IScopeSymbol = {
-        kind: ESymbolKind.Namespace,
-        name: "Motor",
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        members: ["counter"],
-        memberVisibility: new Map([["counter", "private"]]),
-      };
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      (motorScope.members as string[]).push("counter");
+      (motorScope.memberVisibility as Map<string, string>).set(
+        "counter",
+        "private",
+      );
 
-      const info = TSymbolInfoAdapter.convert([scope]);
+      const info = TSymbolInfoAdapter.convert([motorScope]);
 
       expect(info.getSingleFunctionForVariable("Motor", "counter")).toBeNull();
     });
@@ -587,21 +660,39 @@ describe("TSymbolInfoAdapter", () => {
 
   describe("mixed symbols", () => {
     it("should handle array of different symbol types", () => {
+      const motorScope = TestScopeUtils.createMockScope("Motor");
+      (motorScope.members as string[]).push("init");
+      (motorScope.memberVisibility as Map<string, string>).set(
+        "init",
+        "public",
+      );
+
       const symbols = [
         {
-          kind: ESymbolKind.Struct,
+          kind: "struct",
           name: "Point",
+          scope: globalScope,
           sourceFile: "test.cnx",
           sourceLine: 1,
           sourceLanguage: ESourceLanguage.CNext,
           isExported: true,
           fields: new Map([
-            ["x", { type: "i32", isArray: false, isConst: false }],
+            [
+              "x",
+              {
+                name: "x",
+                type: TypeResolver.resolve("i32"),
+                isArray: false,
+                isConst: false,
+                isAtomic: false,
+              },
+            ],
           ]),
         } as IStructSymbol,
         {
-          kind: ESymbolKind.Enum,
+          kind: "enum",
           name: "Color",
+          scope: globalScope,
           sourceFile: "test.cnx",
           sourceLine: 5,
           sourceLanguage: ESourceLanguage.CNext,
@@ -611,24 +702,17 @@ describe("TSymbolInfoAdapter", () => {
             ["Green", 1],
           ]),
         } as IEnumSymbol,
+        motorScope,
         {
-          kind: ESymbolKind.Namespace,
-          name: "Motor",
-          sourceFile: "test.cnx",
-          sourceLine: 10,
-          sourceLanguage: ESourceLanguage.CNext,
-          isExported: true,
-          members: ["init"],
-          memberVisibility: new Map([["init", "public"]]),
-        } as IScopeSymbol,
-        {
-          kind: ESymbolKind.Function,
+          kind: "function",
           name: "main",
+          scope: globalScope,
+          body: null,
           sourceFile: "test.cnx",
           sourceLine: 15,
           sourceLanguage: ESourceLanguage.CNext,
           isExported: true,
-          returnType: "void",
+          returnType: TypeResolver.resolve("void"),
           visibility: "public",
           parameters: [],
         } as IFunctionSymbol,