c-next 0.1.70 → 0.1.72

package/src/utils/cache/__tests__/CacheManager.test.ts

@@ -14,22 +14,28 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import CacheManager from "../CacheManager";
-import ISymbol from "../../types/ISymbol";
-import ESymbolKind from "../../types/ESymbolKind";
+import ISerializedSymbol from "../../../transpiler/types/ISerializedSymbol";
 import ESourceLanguage from "../../types/ESourceLanguage";
-import IStructFieldInfo from "../../../transpiler/logic/symbols/types/IStructFieldInfo";
+import IStructFieldInfo from "../../../transpiler/types/symbols/IStructFieldInfo";
 import SymbolTable from "../../../transpiler/logic/symbols/SymbolTable";
 import MockFileSystem from "../../../transpiler/__tests__/MockFileSystem";
+import TestScopeUtils from "../../../transpiler/logic/symbols/cnext/__tests__/testUtils";
+import TTypeUtils from "../../TTypeUtils";
+import type IFunctionSymbol from "../../../transpiler/types/symbols/IFunctionSymbol";
+import type IStructSymbol from "../../../transpiler/types/symbols/IStructSymbol";
+import type IEnumSymbol from "../../../transpiler/types/symbols/IEnumSymbol";
 
 describe("CacheManager", () => {
   let testDir: string;
   let cacheManager: CacheManager;
 
   // Helper to create a test symbol
-  function createTestSymbol(overrides: Partial<ISymbol> = {}): ISymbol {
+  function createTestSymbol(
+    overrides: Partial<ISerializedSymbol> = {},
+  ): ISerializedSymbol {
     return {
       name: "testFunc",
-      kind: ESymbolKind.Function,
+      kind: "function",
       sourceFile: "/test/file.h",
       sourceLine: 10,
       sourceLanguage: ESourceLanguage.C,
@@ -186,7 +192,7 @@ describe("CacheManager", () => {
       expect(cached!.symbols).toHaveLength(1);
       expect(cached!.symbols[0]).toMatchObject({
         name: "testFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 10,
         sourceLanguage: ESourceLanguage.C,
@@ -239,17 +245,17 @@ describe("CacheManager", () => {
         createTestSymbol({
           sourceFile: testFile,
           name: "func1",
-          kind: ESymbolKind.Function,
+          kind: "function",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "var1",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "MyStruct",
-          kind: ESymbolKind.Struct,
+          kind: "struct",
         }),
       ];
       cacheManager.setSymbols(testFile, symbols, new Map());
@@ -681,70 +687,70 @@ describe("CacheManager", () => {
       await cacheManager.initialize();
     });
 
-    it("should handle all ESymbolKind values", async () => {
+    it("should handle all TSymbolKind values", async () => {
       const testFile = join(testDir, "test.h");
       writeFileSync(testFile, "// test");
 
-      const symbols: ISymbol[] = [
+      const symbols: ISerializedSymbol[] = [
         createTestSymbol({
           sourceFile: testFile,
           name: "func",
-          kind: ESymbolKind.Function,
+          kind: "function",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "var",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "MyType",
-          kind: ESymbolKind.Type,
+          kind: "type",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "ns",
-          kind: ESymbolKind.Namespace,
+          kind: "namespace",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "MyClass",
-          kind: ESymbolKind.Class,
+          kind: "class",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "MyStruct",
-          kind: ESymbolKind.Struct,
+          kind: "struct",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "MyEnum",
-          kind: ESymbolKind.Enum,
+          kind: "enum",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "VALUE",
-          kind: ESymbolKind.EnumMember,
+          kind: "enum_member",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "Flags",
-          kind: ESymbolKind.Bitmap,
+          kind: "bitmap",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "FLAG_A",
-          kind: ESymbolKind.BitmapField,
+          kind: "bitmap_field",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "REG",
-          kind: ESymbolKind.Register,
+          kind: "register",
         }),
         createTestSymbol({
           sourceFile: testFile,
           name: "FIELD",
-          kind: ESymbolKind.RegisterMember,
+          kind: "register_member",
         }),
       ];
 
@@ -758,18 +764,18 @@ describe("CacheManager", () => {
       const cached = newManager.getSymbols(testFile);
       expect(cached!.symbols).toHaveLength(12);
       expect(cached!.symbols.map((s) => s.kind)).toEqual([
-        ESymbolKind.Function,
-        ESymbolKind.Variable,
-        ESymbolKind.Type,
-        ESymbolKind.Namespace,
-        ESymbolKind.Class,
-        ESymbolKind.Struct,
-        ESymbolKind.Enum,
-        ESymbolKind.EnumMember,
-        ESymbolKind.Bitmap,
-        ESymbolKind.BitmapField,
-        ESymbolKind.Register,
-        ESymbolKind.RegisterMember,
+        "function",
+        "variable",
+        "type",
+        "namespace",
+        "class",
+        "struct",
+        "enum",
+        "enum_member",
+        "bitmap",
+        "bitmap_field",
+        "register",
+        "register_member",
       ]);
     });
   });
@@ -783,7 +789,7 @@ describe("CacheManager", () => {
       const testFile = join(testDir, "test.h");
       writeFileSync(testFile, "// test");
 
-      const symbols: ISymbol[] = [
+      const symbols: ISerializedSymbol[] = [
         createTestSymbol({
           sourceFile: testFile,
           name: "cFunc",
@@ -830,16 +836,19 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add symbols to SymbolTable
-      const symbol: ISymbol = {
+      symbolTable.addTSymbol({
         name: "myFunction",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        type: "void",
-      };
-      symbolTable.addSymbol(symbol);
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
       // Cache via setSymbolsFromTable
       cacheManager.setSymbolsFromTable(testFile, symbolTable);
@@ -850,7 +859,7 @@ describe("CacheManager", () => {
       expect(cached!.symbols).toHaveLength(1);
       expect(cached!.symbols[0]).toMatchObject({
         name: "myFunction",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
@@ -864,15 +873,16 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add struct symbol to SymbolTable
-      const structSymbol: ISymbol = {
+      symbolTable.addTSymbol({
         name: "Point",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      };
-      symbolTable.addSymbol(structSymbol);
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
 
       // Add struct fields
       symbolTable.addStructField("Point", "x", "int32_t");
@@ -903,25 +913,29 @@ describe("CacheManager", () => {
       writeFileSync(file2, "// file2");
 
       // Add struct in file1
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "PointA",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: file1,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
       symbolTable.addStructField("PointA", "x", "int32_t");
 
       // Add struct in file2
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "PointB",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: file2,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
       symbolTable.addStructField("PointB", "y", "int32_t");
 
       // Cache file1 only
@@ -939,22 +953,26 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add struct symbols
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "TypedefStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
+      symbolTable.addTSymbol({
         name: "NamedStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
 
       // Add struct fields (required for getStructNamesByFile)
       symbolTable.addStructField("TypedefStruct", "a", "int32_t");
@@ -979,22 +997,26 @@ describe("CacheManager", () => {
       writeFileSync(file2, "// file2");
 
       // Add structs in different files
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "StructA",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: file1,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
+      symbolTable.addTSymbol({
         name: "StructB",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: file2,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
 
       // Add struct fields
       symbolTable.addStructField("StructA", "a", "int32_t");
@@ -1019,22 +1041,26 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add enum symbols
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "Status",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
+      symbolTable.addTSymbol({
         name: "Priority",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
 
       // Add enum bit widths
       symbolTable.addEnumBitWidth("Status", 8);
@@ -1057,22 +1083,26 @@ describe("CacheManager", () => {
       writeFileSync(file2, "// file2");
 
       // Add enums in different files
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "EnumA",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: file1,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
+      symbolTable.addTSymbol({
         name: "EnumB",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: file2,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
 
       // Add bit widths for both
       symbolTable.addEnumBitWidth("EnumA", 8);
@@ -1093,38 +1123,46 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add function symbol
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "processData",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        type: "void",
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
       // Add struct symbol and fields
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "DataPacket",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 10,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
       symbolTable.addStructField("DataPacket", "id", "uint32_t");
       symbolTable.addStructField("DataPacket", "buffer", "uint8_t", [256]);
       symbolTable.markNeedsStructKeyword("DataPacket");
 
       // Add enum symbol and bit width
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "DataType",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: testFile,
         sourceLine: 20,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
       symbolTable.addEnumBitWidth("DataType", 8);
 
       // Cache via setSymbolsFromTable
@@ -1163,25 +1201,29 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add data to SymbolTable
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "MyStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
       symbolTable.addStructField("MyStruct", "value", "int32_t");
       symbolTable.markNeedsStructKeyword("MyStruct");
 
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "MyEnum",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
       symbolTable.addEnumBitWidth("MyEnum", 16);
 
       // Cache and flush
@@ -1207,14 +1249,19 @@ describe("CacheManager", () => {
       const nonExistent = join(testDir, "does-not-exist.cnx");
 
       // Add symbol for non-existent file
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "orphanFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: nonExistent,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
       // Should not throw, but should not cache
       cacheManager.setSymbolsFromTable(nonExistent, symbolTable);
@@ -1243,14 +1290,16 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add struct symbol without adding any fields
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "EmptyStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
       // Note: not adding fields, so getStructNamesByFile won't include it
 
       cacheManager.setSymbolsFromTable(testFile, symbolTable);
@@ -1268,14 +1317,16 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add enum symbol without adding bit width
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "SimpleEnum",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        members: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
 
       cacheManager.setSymbolsFromTable(testFile, symbolTable);
 
@@ -1291,30 +1342,45 @@ describe("CacheManager", () => {
       writeFileSync(testFile, "// test");
 
       // Add multiple functions
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
         name: "func1",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+      symbolTable.addTSymbol({
         name: "func2",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+      symbolTable.addTSymbol({
         name: "func3",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: testFile,
         sourceLine: 10,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: false,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "private",
+        body: null,
+      } as IFunctionSymbol);
 
       cacheManager.setSymbolsFromTable(testFile, symbolTable);
 
@@ -1376,9 +1442,9 @@ describe("CacheManager", () => {
       // Add a virtual test file
       mockFs.addFile("/project/test.h", "// test header");
 
-      const symbol: ISymbol = {
+      const symbol: ISerializedSymbol = {
         name: "testFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceFile: "/project/test.h",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.C,
@@ -1426,7 +1492,7 @@ describe("CacheManager", () => {
       const content = mockFs.getWrittenContent("/project/.cnx/config.json");
       expect(content).toBeDefined();
       const newConfig = JSON.parse(content!);
-      expect(newConfig.version).toBe(3); // Current CACHE_VERSION
+      expect(newConfig.version).toBe(4); // Current CACHE_VERSION (ADR-055 Phase 7)
     });
 
     it("should not cache files that do not exist in IFileSystem", async () => {
@@ -1438,7 +1504,7 @@ describe("CacheManager", () => {
         [
           {
             name: "func",
-            kind: ESymbolKind.Function,
+            kind: "function",
             sourceFile: "/project/nonexistent.h",
             sourceLine: 1,
             sourceLanguage: ESourceLanguage.C,