c-next 0.1.70 → 0.1.72

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -1,12 +1,20 @@
 /**
  * Unit tests for SymbolTable
  * Issue #221: Function parameters should not cause conflicts
+ * ADR-055 Phase 7: Fully typed symbol storage using TSymbol, TCSymbol, TCppSymbol
  */
 import { describe, it, expect, beforeEach } from "vitest";
 import SymbolTable from "../SymbolTable";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-import ISymbol from "../../../../utils/types/ISymbol";
+import TSymbol from "../../../types/symbols/TSymbol";
+import IVariableSymbol from "../../../types/symbols/IVariableSymbol";
+import IFunctionSymbol from "../../../types/symbols/IFunctionSymbol";
+import IStructSymbol from "../../../types/symbols/IStructSymbol";
+import IEnumSymbol from "../../../types/symbols/IEnumSymbol";
+import TestScopeUtils from "../cnext/__tests__/testUtils";
+import TTypeUtils from "../../../../utils/TTypeUtils";
+import TCSymbol from "../../../types/symbols/c/TCSymbol";
+import TCppSymbol from "../../../types/symbols/cpp/TCppSymbol";
 
 describe("SymbolTable", () => {
   let symbolTable: SymbolTable;
@@ -16,966 +24,622 @@ describe("SymbolTable", () => {
   });
 
   // ========================================================================
-  // Basic Symbol Operations
+  // TSymbol (C-Next) Operations
   // ========================================================================
 
-  describe("addSymbol and getSymbol", () => {
-    it("should add and retrieve a symbol by name", () => {
-      const symbol: ISymbol = {
+  describe("addTSymbol and getTSymbol", () => {
+    it("should add and retrieve a TSymbol by name", () => {
+      const symbol: IVariableSymbol = {
+        kind: "variable",
         name: "myVar",
-        kind: ESymbolKind.Variable,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       };
 
-      symbolTable.addSymbol(symbol);
-      const retrieved = symbolTable.getSymbol("myVar");
+      symbolTable.addTSymbol(symbol);
+      const retrieved = symbolTable.getTSymbol("myVar");
 
       expect(retrieved).toBeDefined();
       expect(retrieved?.name).toBe("myVar");
-      expect(retrieved?.kind).toBe(ESymbolKind.Variable);
+      expect(retrieved?.kind).toBe("variable");
     });
 
     it("should return undefined for non-existent symbol", () => {
-      const retrieved = symbolTable.getSymbol("nonExistent");
+      const retrieved = symbolTable.getTSymbol("nonExistent");
       expect(retrieved).toBeUndefined();
     });
 
     it("should return first symbol when multiple exist with same name", () => {
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "variable",
         name: "duplicate",
-        kind: ESymbolKind.Variable,
         sourceFile: "first.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       });
 
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "variable",
         name: "duplicate",
-        kind: ESymbolKind.Variable,
         sourceFile: "second.cnx",
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       });
 
-      const retrieved = symbolTable.getSymbol("duplicate");
+      const retrieved = symbolTable.getTSymbol("duplicate");
       expect(retrieved?.sourceFile).toBe("first.cnx");
     });
   });
 
-  describe("addSymbols", () => {
-    it("should add multiple symbols at once", () => {
-      const symbols: ISymbol[] = [
+  describe("addTSymbols", () => {
+    it("should add multiple TSymbols at once", () => {
+      const symbols: TSymbol[] = [
         {
+          kind: "variable",
           name: "var1",
-          kind: ESymbolKind.Variable,
           sourceFile: "test.cnx",
           sourceLine: 1,
           sourceLanguage: ESourceLanguage.CNext,
           isExported: true,
+          type: TTypeUtils.createPrimitive("u32"),
+          isArray: false,
+          isConst: false,
+          isAtomic: false,
+          scope: TestScopeUtils.createMockGlobalScope(),
         },
         {
+          kind: "variable",
           name: "var2",
-          kind: ESymbolKind.Variable,
           sourceFile: "test.cnx",
           sourceLine: 2,
           sourceLanguage: ESourceLanguage.CNext,
           isExported: true,
-        },
-        {
-          name: "func1",
-          kind: ESymbolKind.Function,
-          sourceFile: "test.cnx",
-          sourceLine: 3,
-          sourceLanguage: ESourceLanguage.CNext,
-          isExported: true,
+          type: TTypeUtils.createPrimitive("i32"),
+          isArray: false,
+          isConst: false,
+          isAtomic: false,
+          scope: TestScopeUtils.createMockGlobalScope(),
         },
       ];
 
-      symbolTable.addSymbols(symbols);
+      symbolTable.addTSymbols(symbols);
 
-      expect(symbolTable.getSymbol("var1")).toBeDefined();
-      expect(symbolTable.getSymbol("var2")).toBeDefined();
-      expect(symbolTable.getSymbol("func1")).toBeDefined();
-      expect(symbolTable.size).toBe(3);
+      expect(symbolTable.getTSymbol("var1")).toBeDefined();
+      expect(symbolTable.getTSymbol("var2")).toBeDefined();
     });
   });
 
-  describe("hasSymbol", () => {
-    it("should return true for existing symbol", () => {
-      symbolTable.addSymbol({
-        name: "exists",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      expect(symbolTable.hasSymbol("exists")).toBe(true);
-    });
-
-    it("should return false for non-existent symbol", () => {
-      expect(symbolTable.hasSymbol("notHere")).toBe(false);
-    });
-  });
-
-  describe("getOverloads", () => {
-    it("should return all symbols with same name", () => {
-      symbolTable.addSymbol({
-        name: "overloaded",
-        kind: ESymbolKind.Function,
-        signature: "int(int)",
-        sourceFile: "test.cpp",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "overloaded",
-        kind: ESymbolKind.Function,
-        signature: "int(int, int)",
-        sourceFile: "test.cpp",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
-
-      const overloads = symbolTable.getOverloads("overloaded");
-      expect(overloads.length).toBe(2);
-      expect(overloads[0].signature).toBe("int(int)");
-      expect(overloads[1].signature).toBe("int(int, int)");
-    });
-
-    it("should return empty array for non-existent symbol", () => {
-      const overloads = symbolTable.getOverloads("noSuchFunction");
-      expect(overloads).toEqual([]);
-    });
-  });
-
-  describe("getAllSymbols", () => {
-    it("should return all symbols in the table", () => {
-      symbolTable.addSymbol({
-        name: "a",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
+  // ========================================================================
+  // TCSymbol (C) Operations
+  // ========================================================================
 
-      symbolTable.addSymbol({
-        name: "b",
-        kind: ESymbolKind.Function,
-        sourceFile: "test.cnx",
-        sourceLine: 2,
-        sourceLanguage: ESourceLanguage.CNext,
+  describe("addCSymbol and getCSymbol", () => {
+    it("should add and retrieve a C symbol", () => {
+      const symbol: TCSymbol = {
+        kind: "function",
+        name: "c_function",
+        sourceFile: "test.h",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.C,
         isExported: true,
-      });
+        type: "int",
+        parameters: [
+          { name: "x", type: "int", isConst: false, isArray: false },
+        ],
+      };
 
-      const all = symbolTable.getAllSymbols();
-      expect(all.length).toBe(2);
-      expect(all.map((s) => s.name).sort()).toEqual(["a", "b"]);
-    });
+      symbolTable.addCSymbol(symbol);
+      const retrieved = symbolTable.getCSymbol("c_function");
 
-    it("should return empty array for empty table", () => {
-      expect(symbolTable.getAllSymbols()).toEqual([]);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.name).toBe("c_function");
+      expect(retrieved?.kind).toBe("function");
+      expect(retrieved?.sourceLanguage).toBe(ESourceLanguage.C);
     });
   });
 
-  describe("size", () => {
-    it("should return 0 for empty table", () => {
-      expect(symbolTable.size).toBe(0);
-    });
-
-    it("should return correct count including duplicates", () => {
-      symbolTable.addSymbol({
-        name: "sym1",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "sym1",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test2.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
+  // ========================================================================
+  // TCppSymbol (C++) Operations
+  // ========================================================================
 
-      symbolTable.addSymbol({
-        name: "sym2",
-        kind: ESymbolKind.Function,
-        sourceFile: "test.cnx",
+  describe("addCppSymbol and getCppSymbol", () => {
+    it("should add and retrieve a C++ symbol", () => {
+      const symbol: TCppSymbol = {
+        kind: "class",
+        name: "MyClass",
+        sourceFile: "test.hpp",
         sourceLine: 5,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      expect(symbolTable.size).toBe(3);
-    });
-  });
-
-  describe("clear", () => {
-    it("should remove all symbols", () => {
-      symbolTable.addSymbol({
-        name: "toBeCleared",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
+        sourceLanguage: ESourceLanguage.Cpp,
         isExported: true,
-      });
-
-      symbolTable.addStructField("MyStruct", "field1", "uint32_t");
-      symbolTable.markNeedsStructKeyword("CStruct");
-      symbolTable.addEnumBitWidth("MyEnum", 8);
+      };
 
-      symbolTable.clear();
+      symbolTable.addCppSymbol(symbol);
+      const retrieved = symbolTable.getCppSymbol("MyClass");
 
-      expect(symbolTable.size).toBe(0);
-      expect(symbolTable.getSymbol("toBeCleared")).toBeUndefined();
-      expect(
-        symbolTable.getStructFieldType("MyStruct", "field1"),
-      ).toBeUndefined();
-      expect(symbolTable.checkNeedsStructKeyword("CStruct")).toBe(false);
-      expect(symbolTable.getEnumBitWidth("MyEnum")).toBeUndefined();
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.name).toBe("MyClass");
+      expect(retrieved?.kind).toBe("class");
+      expect(retrieved?.sourceLanguage).toBe(ESourceLanguage.Cpp);
     });
   });
 
   // ========================================================================
-  // File-based and Language-based Queries
+  // Cross-Language Operations
   // ========================================================================
 
-  describe("getSymbolsByFile", () => {
-    it("should return symbols from a specific file", () => {
-      symbolTable.addSymbol({
-        name: "inFile1",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "alsoInFile1",
-        kind: ESymbolKind.Function,
-        sourceFile: "file1.cnx",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "inFile2",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file2.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      const file1Symbols = symbolTable.getSymbolsByFile("file1.cnx");
-      expect(file1Symbols.length).toBe(2);
-      expect(file1Symbols.map((s) => s.name).sort()).toEqual([
-        "alsoInFile1",
-        "inFile1",
-      ]);
-    });
-
-    it("should return empty array for unknown file", () => {
-      expect(symbolTable.getSymbolsByFile("unknown.cnx")).toEqual([]);
-    });
-  });
-
-  describe("getSymbolsByLanguage", () => {
-    it("should return symbols from a specific language", () => {
-      symbolTable.addSymbol({
+  describe("getAllSymbols", () => {
+    it("should return symbols from all languages", () => {
+      symbolTable.addTSymbol({
+        kind: "variable",
         name: "cnextVar",
-        kind: ESymbolKind.Variable,
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       });
 
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
+        kind: "variable",
         name: "cVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.c",
+        sourceFile: "test.h",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.C,
         isExported: true,
+        type: "int",
       });
 
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
+        kind: "variable",
         name: "cppVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "test.cpp",
+        sourceFile: "test.hpp",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.Cpp,
         isExported: true,
+        type: "int",
       });
 
-      const cnextSymbols = symbolTable.getSymbolsByLanguage(
-        ESourceLanguage.CNext,
-      );
-      expect(cnextSymbols.length).toBe(1);
-      expect(cnextSymbols[0].name).toBe("cnextVar");
-
-      const cSymbols = symbolTable.getSymbolsByLanguage(ESourceLanguage.C);
-      expect(cSymbols.length).toBe(1);
-      expect(cSymbols[0].name).toBe("cVar");
+      const all = symbolTable.getAllSymbols();
+      expect(all.length).toBe(3);
     });
+  });
 
-    it("should return empty array when no symbols match language", () => {
-      symbolTable.addSymbol({
-        name: "cnextOnly",
-        kind: ESymbolKind.Variable,
+  describe("getOverloads", () => {
+    it("should return overloads from all languages", () => {
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "process",
         sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-
-      expect(symbolTable.getSymbolsByLanguage(ESourceLanguage.C)).toEqual([]);
-    });
-  });
-
-  // ========================================================================
-  // Struct Field Operations
-  // ========================================================================
-
-  describe("struct field operations", () => {
-    it("should add and retrieve struct field type", () => {
-      symbolTable.addStructField("Point", "x", "int32_t");
-      symbolTable.addStructField("Point", "y", "int32_t");
-
-      expect(symbolTable.getStructFieldType("Point", "x")).toBe("int32_t");
-      expect(symbolTable.getStructFieldType("Point", "y")).toBe("int32_t");
-    });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
-    it("should return undefined for unknown struct or field", () => {
-      symbolTable.addStructField("Point", "x", "int32_t");
-
-      expect(symbolTable.getStructFieldType("Unknown", "x")).toBeUndefined();
-      expect(symbolTable.getStructFieldType("Point", "z")).toBeUndefined();
-    });
-
-    it("should add struct field with array dimensions", () => {
-      symbolTable.addStructField("Buffer", "data", "uint8_t", [256]);
-      symbolTable.addStructField("Matrix", "values", "float", [4, 4]);
-
-      const bufferField = symbolTable.getStructFieldInfo("Buffer", "data");
-      expect(bufferField?.type).toBe("uint8_t");
-      expect(bufferField?.arrayDimensions).toEqual([256]);
-
-      const matrixField = symbolTable.getStructFieldInfo("Matrix", "values");
-      expect(matrixField?.type).toBe("float");
-      expect(matrixField?.arrayDimensions).toEqual([4, 4]);
-    });
-
-    it("should get all fields for a struct", () => {
-      symbolTable.addStructField("Person", "name", "char*");
-      symbolTable.addStructField("Person", "age", "uint8_t");
-      symbolTable.addStructField("Person", "id", "uint32_t");
-
-      const fields = symbolTable.getStructFields("Person");
-      expect(fields).toBeDefined();
-      expect(fields?.size).toBe(3);
-      expect(fields?.get("name")?.type).toBe("char*");
-      expect(fields?.get("age")?.type).toBe("uint8_t");
-    });
-
-    it("should return undefined for unknown struct in getStructFields", () => {
-      expect(symbolTable.getStructFields("Unknown")).toBeUndefined();
-    });
-
-    it("should get all struct fields for serialization", () => {
-      symbolTable.addStructField("A", "x", "int");
-      symbolTable.addStructField("B", "y", "float");
-
-      const allFields = symbolTable.getAllStructFields();
-      expect(allFields.size).toBe(2);
-      expect(allFields.has("A")).toBe(true);
-      expect(allFields.has("B")).toBe(true);
-    });
-
-    it("should restore struct fields from cache", () => {
-      const cached = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const pointFields = new Map();
-      pointFields.set("x", { type: "int32_t" });
-      pointFields.set("y", { type: "int32_t" });
-      cached.set("Point", pointFields);
-
-      symbolTable.restoreStructFields(cached);
-
-      expect(symbolTable.getStructFieldType("Point", "x")).toBe("int32_t");
-      expect(symbolTable.getStructFieldType("Point", "y")).toBe("int32_t");
-    });
-
-    it("should merge restored struct fields with existing", () => {
-      symbolTable.addStructField("Point", "x", "int32_t");
-
-      const cached = new Map<
-        string,
-        Map<string, { type: string; arrayDimensions?: number[] }>
-      >();
-      const pointFields = new Map();
-      pointFields.set("z", { type: "int32_t" });
-      cached.set("Point", pointFields);
-
-      symbolTable.restoreStructFields(cached);
-
-      expect(symbolTable.getStructFieldType("Point", "x")).toBe("int32_t");
-      expect(symbolTable.getStructFieldType("Point", "z")).toBe("int32_t");
-    });
-  });
-
-  describe("getStructNamesByFile", () => {
-    it("should return struct names defined in a file", () => {
-      // Add a symbol for the struct
-      symbolTable.addSymbol({
-        name: "Point",
-        kind: ESymbolKind.Struct,
-        sourceFile: "geometry.h",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-      });
-
-      // Register struct fields (which marks it as having struct data)
-      symbolTable.addStructField("Point", "x", "int");
-      symbolTable.addStructField("Point", "y", "int");
-
-      const structNames = symbolTable.getStructNamesByFile("geometry.h");
-      expect(structNames).toContain("Point");
-    });
-
-    it("should return empty array for file with no structs", () => {
-      symbolTable.addSymbol({
-        name: "someVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "vars.cnx",
+      symbolTable.addCppSymbol({
+        kind: "function",
+        name: "process",
+        sourceFile: "test.hpp",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
+        sourceLanguage: ESourceLanguage.Cpp,
         isExported: true,
+        type: "void",
+        parameters: [
+          { name: "x", type: "int", isConst: false, isArray: false },
+        ],
       });
 
-      expect(symbolTable.getStructNamesByFile("vars.cnx")).toEqual([]);
-    });
-
-    it("should return empty array for unknown file", () => {
-      expect(symbolTable.getStructNamesByFile("nonexistent.cnx")).toEqual([]);
-    });
-  });
-
-  // ========================================================================
-  // Struct Keyword Tracking (Issue #196)
-  // ========================================================================
-
-  describe("struct keyword tracking", () => {
-    it("should mark and check if struct needs keyword", () => {
-      symbolTable.markNeedsStructKeyword("NamedPoint");
-
-      expect(symbolTable.checkNeedsStructKeyword("NamedPoint")).toBe(true);
-      expect(symbolTable.checkNeedsStructKeyword("OtherStruct")).toBe(false);
-    });
-
-    it("should get all structs needing keyword", () => {
-      symbolTable.markNeedsStructKeyword("Struct1");
-      symbolTable.markNeedsStructKeyword("Struct2");
-      symbolTable.markNeedsStructKeyword("Struct3");
-
-      const all = symbolTable.getAllNeedsStructKeyword();
-      expect(all.length).toBe(3);
-      expect(all.sort()).toEqual(["Struct1", "Struct2", "Struct3"]);
-    });
-
-    it("should restore struct keyword set from cache", () => {
-      symbolTable.restoreNeedsStructKeyword(["CachedStruct1", "CachedStruct2"]);
-
-      expect(symbolTable.checkNeedsStructKeyword("CachedStruct1")).toBe(true);
-      expect(symbolTable.checkNeedsStructKeyword("CachedStruct2")).toBe(true);
-      expect(symbolTable.checkNeedsStructKeyword("NotCached")).toBe(false);
-    });
-  });
-
-  // ========================================================================
-  // Enum Bit Width Tracking (Issue #208)
-  // ========================================================================
-
-  describe("enum bit width tracking", () => {
-    it("should add and get enum bit width", () => {
-      symbolTable.addEnumBitWidth("EPressureType", 8);
-      symbolTable.addEnumBitWidth("ELargeEnum", 32);
-
-      expect(symbolTable.getEnumBitWidth("EPressureType")).toBe(8);
-      expect(symbolTable.getEnumBitWidth("ELargeEnum")).toBe(32);
-    });
-
-    it("should return undefined for unknown enum", () => {
-      expect(symbolTable.getEnumBitWidth("UnknownEnum")).toBeUndefined();
-    });
-
-    it("should get all enum bit widths for serialization", () => {
-      symbolTable.addEnumBitWidth("Enum8", 8);
-      symbolTable.addEnumBitWidth("Enum16", 16);
-
-      const allWidths = symbolTable.getAllEnumBitWidths();
-      expect(allWidths.size).toBe(2);
-      expect(allWidths.get("Enum8")).toBe(8);
-      expect(allWidths.get("Enum16")).toBe(16);
-    });
-
-    it("should restore enum bit widths from cache", () => {
-      const cached = new Map<string, number>();
-      cached.set("CachedEnum1", 8);
-      cached.set("CachedEnum2", 16);
-
-      symbolTable.restoreEnumBitWidths(cached);
-
-      expect(symbolTable.getEnumBitWidth("CachedEnum1")).toBe(8);
-      expect(symbolTable.getEnumBitWidth("CachedEnum2")).toBe(16);
+      const overloads = symbolTable.getOverloads("process");
+      expect(overloads.length).toBe(2);
     });
   });
 
   // ========================================================================
-  // hasConflict Method
+  // Conflict Detection
   // ========================================================================
 
   describe("hasConflict", () => {
-    it("should return true when symbol has conflicts", () => {
-      symbolTable.addSymbol({
-        name: "conflicted",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.cnx",
+    it("should detect cross-language conflicts between C-Next and C", () => {
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "conflictFunc",
+        sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
-      symbolTable.addSymbol({
-        name: "conflicted",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file2.cnx",
+      symbolTable.addCSymbol({
+        kind: "function",
+        name: "conflictFunc",
+        sourceFile: "test.h",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
+        sourceLanguage: ESourceLanguage.C,
         isExported: true,
+        type: "void",
+        parameters: [],
       });
 
-      expect(symbolTable.hasConflict("conflicted")).toBe(true);
+      expect(symbolTable.hasConflict("conflictFunc")).toBe(true);
     });
 
-    it("should return false when symbol has no conflicts", () => {
-      symbolTable.addSymbol({
-        name: "unique",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.cnx",
+    it("should not detect conflict for C++ function overloads with different signatures", () => {
+      symbolTable.addCppSymbol({
+        kind: "function",
+        name: "overloaded",
+        sourceFile: "test.hpp",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
+        sourceLanguage: ESourceLanguage.Cpp,
         isExported: true,
+        type: "void",
+        parameters: [],
       });
 
-      expect(symbolTable.hasConflict("unique")).toBe(false);
-    });
+      symbolTable.addCppSymbol({
+        kind: "function",
+        name: "overloaded",
+        sourceFile: "test.hpp",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.Cpp,
+        isExported: true,
+        type: "void",
+        parameters: [
+          { name: "x", type: "int", isConst: false, isArray: false },
+        ],
+      });
 
-    it("should return false for non-existent symbol", () => {
-      expect(symbolTable.hasConflict("doesNotExist")).toBe(false);
+      expect(symbolTable.hasConflict("overloaded")).toBe(false);
     });
-  });
 
-  // ========================================================================
-  // Conflict Detection (existing tests)
-  // ========================================================================
+    // Issue #817: Scope-private members should NOT conflict across scopes
+    it("should NOT detect conflict for same-named members in different scopes", () => {
+      // Create two different named scopes
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
+      const barScope = TestScopeUtils.createMockScope("Bar", globalScope);
 
-  describe("conflict detection", () => {
-    it("should detect conflicts between two global variables with same name", () => {
-      // Two global variables with same name = conflict
-      symbolTable.addSymbol({
-        name: "counter",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.cnx",
-        sourceLine: 1,
+      // Add 'enabled' variable in scope Foo
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "enabled",
+        sourceFile: "test.cnx",
+        sourceLine: 2,
         sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
       });
 
-      symbolTable.addSymbol({
-        name: "counter",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file2.cnx",
-        sourceLine: 5,
+      // Add 'enabled' variable in scope Bar
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "enabled",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
         sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: barScope,
       });
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(1);
-      expect(conflicts[0].symbolName).toBe("counter");
+      // These are NOT conflicts - they generate Foo_enabled and Bar_enabled
+      expect(symbolTable.hasConflict("enabled")).toBe(false);
     });
 
-    it("should NOT detect conflicts between function parameters with same name (Issue #221)", () => {
-      // This is the bug: parameters 'x' in different functions should NOT conflict
+    // Issue #817: Same-named functions in different scopes are not conflicts
+    it("should NOT detect conflict for same-named functions in different scopes", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
+      const barScope = TestScopeUtils.createMockScope("Bar", globalScope);
 
-      // Add function Math_add
-      symbolTable.addSymbol({
-        name: "Math_add",
-        kind: ESymbolKind.Function,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 1,
+      // Add 'initialize' function in scope Foo
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "initialize",
+        sourceFile: "test.cnx",
+        sourceLine: 4,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        parent: "Math",
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: fooScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
-      // Add parameter 'x' for Math_add
-      symbolTable.addSymbol({
-        name: "x",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 1,
+      // Add 'initialize' function in scope Bar
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "initialize",
+        sourceFile: "test.cnx",
+        sourceLine: 12,
         sourceLanguage: ESourceLanguage.CNext,
-        parent: "Math_add", // Parent is the function
-        isExported: false,
-      });
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: barScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
-      // Add parameter 'y' for Math_add
-      symbolTable.addSymbol({
-        name: "y",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        parent: "Math_add",
-        isExported: false,
-      });
+      // These generate Foo_initialize and Bar_initialize - no conflict
+      expect(symbolTable.hasConflict("initialize")).toBe(false);
+    });
 
-      // Add function Math_multiply
-      symbolTable.addSymbol({
-        name: "Math_multiply",
-        kind: ESymbolKind.Function,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        parent: "Math",
-      });
+    // True conflicts: same name in same scope should still be detected
+    it("should detect conflict for same-named symbols in same scope", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
 
-      // Add parameter 'x' for Math_multiply - same name as Math_add's x
-      symbolTable.addSymbol({
-        name: "x",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 5,
+      // Add 'duplicate' variable in scope Foo twice
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "duplicate",
+        sourceFile: "test.cnx",
+        sourceLine: 2,
         sourceLanguage: ESourceLanguage.CNext,
-        parent: "Math_multiply", // Different parent function
         isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
       });
 
-      // Add parameter 'y' for Math_multiply
-      symbolTable.addSymbol({
-        name: "y",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "duplicate",
+        sourceFile: "test.cnx",
         sourceLine: 5,
         sourceLanguage: ESourceLanguage.CNext,
-        parent: "Math_multiply",
         isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
       });
 
-      // There should be NO conflicts - parameters are scoped to their functions
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      // Same name in SAME scope IS a conflict
+      expect(symbolTable.hasConflict("duplicate")).toBe(true);
     });
 
-    it("should still detect conflicts for scope-level variables with same qualified name", () => {
-      // Two scope-level variables with same qualified name = conflict
-      symbolTable.addSymbol({
-        name: "Math_counter",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.cnx",
+    // Global scope conflicts should still be detected
+    it("should detect conflict for same-named globals", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+
+      // Add two global variables with same name
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "globalVar",
+        sourceFile: "first.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        parent: "Math",
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: globalScope,
       });
 
-      symbolTable.addSymbol({
-        name: "Math_counter",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file2.cnx",
-        sourceLine: 5,
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "globalVar",
+        sourceFile: "second.cnx",
+        sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        parent: "Math",
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: globalScope,
       });
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(1);
-      expect(conflicts[0].symbolName).toBe("Math_counter");
+      // Two globals with same name IS a conflict
+      expect(symbolTable.hasConflict("globalVar")).toBe(true);
     });
+  });
 
-    it("should not conflict when a global function and scope function have same parameter names", () => {
-      // Global function 'divide' with parameter 'x'
-      symbolTable.addSymbol({
-        name: "divide",
-        kind: ESymbolKind.Function,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 10,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "x",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 10,
-        sourceLanguage: ESourceLanguage.CNext,
-        parent: "divide",
-        isExported: false,
-      });
+  // ========================================================================
+  // Type-Safe Symbol Queries
+  // ========================================================================
 
-      // Scope function 'Math_add' with parameter 'x'
-      symbolTable.addSymbol({
-        name: "Math_add",
-        kind: ESymbolKind.Function,
-        type: "f32",
-        sourceFile: "math.cnx",
+  describe("type-safe queries", () => {
+    it("getStructSymbols should return only struct symbols", () => {
+      symbolTable.addTSymbol({
+        kind: "struct",
+        name: "MyStruct",
+        sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        parent: "Math",
-      });
+        fields: new Map(),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IStructSymbol);
 
-      symbolTable.addSymbol({
-        name: "x",
-        kind: ESymbolKind.Variable,
-        type: "f32",
-        sourceFile: "math.cnx",
-        sourceLine: 1,
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "myVar",
+        sourceFile: "test.cnx",
+        sourceLine: 2,
         sourceLanguage: ESourceLanguage.CNext,
-        parent: "Math_add",
-        isExported: false,
+        isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       });
 
-      // No conflicts - both 'x' are function parameters with different parents
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      const structs = symbolTable.getStructSymbols();
+      expect(structs.length).toBe(1);
+      expect(structs[0].name).toBe("MyStruct");
     });
 
-    it("should detect cross-language conflict between C-Next and C", () => {
-      // Same symbol in C-Next and C = ERROR
-      symbolTable.addSymbol({
-        name: "sharedVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "module.cnx",
+    it("getEnumSymbols should return only enum symbols", () => {
+      symbolTable.addTSymbol({
+        kind: "enum",
+        name: "MyEnum",
+        sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "sharedVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "legacy.c",
-        sourceLine: 10,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-      });
+        members: new Map([["VALUE1", 0]]),
+        scope: TestScopeUtils.createMockGlobalScope(),
+      } as IEnumSymbol);
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(1);
-      expect(conflicts[0].symbolName).toBe("sharedVar");
-      expect(conflicts[0].severity).toBe("error");
-      expect(conflicts[0].message).toContain("defined in multiple languages");
+      const enums = symbolTable.getEnumSymbols();
+      expect(enums.length).toBe(1);
+      expect(enums[0].name).toBe("MyEnum");
     });
 
-    it("should detect cross-language conflict between C-Next and C++", () => {
-      // Same symbol in C-Next and C++ = ERROR
-      symbolTable.addSymbol({
-        name: "sharedFunc",
-        kind: ESymbolKind.Function,
-        sourceFile: "module.cnx",
+    it("getFunctionSymbols should return only function symbols", () => {
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "myFunc",
+        sourceFile: "test.cnx",
         sourceLine: 1,
         sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
-      symbolTable.addSymbol({
-        name: "sharedFunc",
-        kind: ESymbolKind.Function,
-        sourceFile: "driver.cpp",
-        sourceLine: 20,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
-
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(1);
-      expect(conflicts[0].symbolName).toBe("sharedFunc");
-      expect(conflicts[0].severity).toBe("error");
+      const functions = symbolTable.getFunctionSymbols();
+      expect(functions.length).toBe(1);
+      expect(functions[0].name).toBe("myFunc");
     });
+  });
 
-    it("should allow same symbol in C and C++ (common pattern)", () => {
-      // Same symbol in C and C++ is typically OK (e.g., header included by both)
-      symbolTable.addSymbol({
-        name: "commonSymbol",
-        kind: ESymbolKind.Variable,
-        sourceFile: "shared.c",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-      });
+  // ========================================================================
+  // Struct Field Information
+  // ========================================================================
 
-      symbolTable.addSymbol({
-        name: "commonSymbol",
-        kind: ESymbolKind.Variable,
-        sourceFile: "wrapper.cpp",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
+  describe("struct fields", () => {
+    it("should add and retrieve struct field information", () => {
+      symbolTable.addStructField("Point", "x", "int");
+      symbolTable.addStructField("Point", "y", "int");
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      expect(symbolTable.getStructFieldType("Point", "x")).toBe("int");
+      expect(symbolTable.getStructFieldType("Point", "y")).toBe("int");
     });
 
-    it("should allow C++ function overloads with different signatures", () => {
-      symbolTable.addSymbol({
-        name: "process",
-        kind: ESymbolKind.Function,
-        signature: "void(int)",
-        sourceFile: "utils.cpp",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
-
-      symbolTable.addSymbol({
-        name: "process",
-        kind: ESymbolKind.Function,
-        signature: "void(int, int)",
-        sourceFile: "utils.cpp",
-        sourceLine: 10,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
+    it("should return undefined for non-existent struct or field", () => {
+      expect(
+        symbolTable.getStructFieldType("NonExistent", "x"),
+      ).toBeUndefined();
+    });
 
-      symbolTable.addSymbol({
-        name: "process",
-        kind: ESymbolKind.Function,
-        signature: "void(float)",
-        sourceFile: "utils.cpp",
-        sourceLine: 20,
-        sourceLanguage: ESourceLanguage.Cpp,
-        isExported: true,
-      });
+    it("should get all fields for a struct", () => {
+      symbolTable.addStructField("Point", "x", "int");
+      symbolTable.addStructField("Point", "y", "int");
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      const fields = symbolTable.getStructFields("Point");
+      expect(fields?.size).toBe(2);
     });
+  });
 
-    it("should not count extern declarations as conflicts", () => {
-      // extern declarations are not definitions
-      symbolTable.addSymbol({
-        name: "externVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "header.h",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-        isDeclaration: true, // extern declaration
-      });
+  // ========================================================================
+  // Needs Struct Keyword Tracking
+  // ========================================================================
 
-      symbolTable.addSymbol({
-        name: "externVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "impl.c",
-        sourceLine: 10,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-        isDeclaration: false, // actual definition
-      });
+  describe("needsStructKeyword", () => {
+    it("should track structs requiring struct keyword", () => {
+      symbolTable.markNeedsStructKeyword("RawStruct");
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      expect(symbolTable.checkNeedsStructKeyword("RawStruct")).toBe(true);
+      expect(symbolTable.checkNeedsStructKeyword("OtherStruct")).toBe(false);
     });
+  });
 
-    it("should detect conflicts for scope functions with same qualified name", () => {
-      // Two scope functions (non-variable with parent) with same name = conflict
-      symbolTable.addSymbol({
-        name: "Math_calculate",
-        kind: ESymbolKind.Function,
-        type: "i32",
-        sourceFile: "math1.cnx",
-        sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        parent: "Math",
-      });
+  // ========================================================================
+  // Enum Bit Width Tracking
+  // ========================================================================
 
-      symbolTable.addSymbol({
-        name: "Math_calculate",
-        kind: ESymbolKind.Function,
-        type: "i32",
-        sourceFile: "math2.cnx",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.CNext,
-        isExported: true,
-        parent: "Math",
-      });
+  describe("enumBitWidth", () => {
+    it("should track enum bit widths", () => {
+      symbolTable.addEnumBitWidth("SmallEnum", 8);
+      symbolTable.addEnumBitWidth("LargeEnum", 32);
 
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(1);
-      expect(conflicts[0].symbolName).toBe("Math_calculate");
+      expect(symbolTable.getEnumBitWidth("SmallEnum")).toBe(8);
+      expect(symbolTable.getEnumBitWidth("LargeEnum")).toBe(32);
+      expect(symbolTable.getEnumBitWidth("UnknownEnum")).toBeUndefined();
     });
+  });
+
+  // ========================================================================
+  // Clear
+  // ========================================================================
 
-    it("should allow multiple C definitions (fallback case)", () => {
-      // Multiple C definitions - no conflict detection for C-only (handled by C compiler)
-      symbolTable.addSymbol({
-        name: "cOnlyVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file1.c",
+  describe("clear", () => {
+    it("should clear all symbols", () => {
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "test",
+        sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.C,
+        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: TestScopeUtils.createMockGlobalScope(),
       });
 
-      symbolTable.addSymbol({
-        name: "cOnlyVar",
-        kind: ESymbolKind.Variable,
-        sourceFile: "file2.c",
-        sourceLine: 5,
-        sourceLanguage: ESourceLanguage.C,
-        isExported: true,
-      });
+      symbolTable.addStructField("Point", "x", "int");
+      symbolTable.markNeedsStructKeyword("RawStruct");
+      symbolTable.addEnumBitWidth("SmallEnum", 8);
+
+      symbolTable.clear();
 
-      // C-only conflicts are left to the C compiler to detect
-      const conflicts = symbolTable.getConflicts();
-      expect(conflicts.length).toBe(0);
+      expect(symbolTable.getAllSymbols().length).toBe(0);
+      expect(symbolTable.getStructFieldType("Point", "x")).toBeUndefined();
+      expect(symbolTable.checkNeedsStructKeyword("RawStruct")).toBe(false);
+      expect(symbolTable.getEnumBitWidth("SmallEnum")).toBeUndefined();
     });
   });
 });