c-next 0.1.70 → 0.1.72

package/src/transpiler/output/headers/__tests__/HeaderGenerator.test.ts

@@ -4,12 +4,16 @@
  * Issue #522: Tests for C++ namespace type filtering
  */
 
+import { describe, it, expect } from "vitest";
 import HeaderGenerator from "../HeaderGenerator";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-import ISymbol from "../../../../utils/types/ISymbol";
+
+import IHeaderSymbol from "../types/IHeaderSymbol";
 import SymbolTable from "../../../logic/symbols/SymbolTable";
 import IHeaderTypeInput from "../generators/IHeaderTypeInput";
+import TestScopeUtils from "../../../logic/symbols/cnext/__tests__/testUtils";
+import TTypeUtils from "../../../../utils/TTypeUtils";
+import type IFunctionSymbol from "../../../types/symbols/IFunctionSymbol";
+import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
 describe("HeaderGenerator", () => {
   const generator = new HeaderGenerator();
@@ -23,14 +27,13 @@ describe("HeaderGenerator", () => {
       arrayDimensions?: string[];
       isConst?: boolean;
     } = {},
-  ): ISymbol {
+  ): IHeaderSymbol {
     return {
       name,
       type,
-      kind: ESymbolKind.Variable,
+      kind: "variable",
       sourceFile: "test.cnx",
       sourceLine: 1,
-      sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
       isArray: options.isArray,
       arrayDimensions: options.arrayDimensions,
@@ -106,25 +109,23 @@ describe("HeaderGenerator", () => {
 
   describe("Issue #449: declaration ordering", () => {
     // Helper to create an enum symbol
-    function makeEnumSymbol(name: string): ISymbol {
+    function makeEnumSymbol(name: string): IHeaderSymbol {
       return {
         name,
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
       };
     }
 
     // Helper to create a struct symbol
-    function makeStructSymbol(name: string): ISymbol {
+    function makeStructSymbol(name: string): IHeaderSymbol {
       return {
         name,
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
       };
     }
@@ -201,13 +202,13 @@ describe("HeaderGenerator", () => {
       namespaceName: string,
     ): IHeaderTypeInput {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: namespaceName,
-        kind: ESymbolKind.Namespace,
-        sourceLanguage: ESourceLanguage.Cpp,
+        kind: "namespace",
         sourceFile: `${namespaceName}.hpp`,
         sourceLine: 1,
         isExported: false,
+        sourceLanguage: ESourceLanguage.Cpp,
       });
       return {
         symbolTable,
@@ -266,14 +267,13 @@ describe("HeaderGenerator", () => {
 
     describe("forward declaration filtering", () => {
       // Helper to create a function symbol that references an external type
-      function makeFuncSymbol(name: string, paramType: string): ISymbol {
+      function makeFuncSymbol(name: string, paramType: string): IHeaderSymbol {
         return {
           name,
           type: "void",
-          kind: ESymbolKind.Function,
+          kind: "function",
           sourceFile: "test.cnx",
           sourceLine: 1,
-          sourceLanguage: ESourceLanguage.CNext,
           isExported: true,
           parameters: [
             { name: "param", type: paramType, isConst: false, isArray: false },
@@ -357,24 +357,32 @@ describe("HeaderGenerator", () => {
   describe("generateFromSymbolTable", () => {
     it("should generate header from symbols filtered by source file", () => {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "myFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "module.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "otherFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "other.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
 
       const header = generator.generateFromSymbolTable(
         symbolTable,
@@ -389,15 +397,19 @@ describe("HeaderGenerator", () => {
 
     it("should use correct header name from source file", () => {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "testFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "src/utils/helper.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
 
       const header = generator.generateFromSymbolTable(
         symbolTable,
@@ -413,32 +425,36 @@ describe("HeaderGenerator", () => {
   describe("generateCNextHeader", () => {
     it("should generate header only for C-Next language symbols", () => {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "cnextFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "module.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
+      symbolTable.addCppSymbol({
+        kind: "function",
         name: "cppFunc",
-        kind: ESymbolKind.Function,
         type: "void",
         sourceFile: "module.hpp",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.Cpp,
         isExported: true,
+        sourceLanguage: ESourceLanguage.Cpp,
       });
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
+        kind: "function",
         name: "cFunc",
-        kind: ESymbolKind.Function,
         type: "void",
         sourceFile: "module.h",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.C,
         isExported: true,
+        sourceLanguage: ESourceLanguage.C,
       });
 
       const header = generator.generateCNextHeader(symbolTable, "output.h");
@@ -450,15 +466,19 @@ describe("HeaderGenerator", () => {
 
     it("should use the provided filename for include guard", () => {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "testFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
 
       const header = generator.generateCNextHeader(symbolTable, "custom_api.h");
 
@@ -468,24 +488,32 @@ describe("HeaderGenerator", () => {
 
     it("should pass options through to underlying generate method", () => {
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "exportedFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-      });
-      symbolTable.addSymbol({
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "internalFunc",
-        kind: ESymbolKind.Function,
-        type: "void",
         sourceFile: "test.cnx",
         sourceLine: 1,
-        sourceLanguage: ESourceLanguage.CNext,
         isExported: false,
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "private",
+        body: null,
+        sourceLanguage: ESourceLanguage.CNext,
+      } as IFunctionSymbol);
 
       const header = generator.generateCNextHeader(symbolTable, "api.h", {
         exportedOnly: true,

package/src/transpiler/output/headers/__tests__/HeaderGeneratorUtils.test.ts

@@ -4,21 +4,20 @@
 
 import { describe, it, expect } from "vitest";
 import HeaderGeneratorUtils from "../HeaderGeneratorUtils";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-import ISymbol from "../../../../utils/types/ISymbol";
+
+import IHeaderSymbol from "../types/IHeaderSymbol";
 import IParameterSymbol from "../../../../utils/types/IParameterSymbol";
+import TSymbolKind from "../../../types/symbol-kinds/TSymbolKind";
 
 /**
  * Helper to create test symbols with required properties
  */
 function makeSymbol(
-  partial: Partial<ISymbol> & { name: string; kind: ESymbolKind },
-): ISymbol {
+  partial: Partial<IHeaderSymbol> & { name: string; kind: TSymbolKind },
+): IHeaderSymbol {
   return {
     sourceFile: "test.cnx",
     sourceLine: 1,
-    sourceLanguage: ESourceLanguage.CNext,
     isExported: true,
     ...partial,
   };
@@ -68,14 +67,14 @@ describe("HeaderGeneratorUtils", () => {
 
   describe("groupSymbolsByKind", () => {
     it("groups symbols correctly", () => {
-      const symbols: ISymbol[] = [
-        makeSymbol({ name: "MyStruct", kind: ESymbolKind.Struct }),
-        makeSymbol({ name: "MyEnum", kind: ESymbolKind.Enum }),
-        makeSymbol({ name: "myFunc", kind: ESymbolKind.Function }),
-        makeSymbol({ name: "myVar", kind: ESymbolKind.Variable }),
-        makeSymbol({ name: "MyClass", kind: ESymbolKind.Class }),
-        makeSymbol({ name: "MyType", kind: ESymbolKind.Type }),
-        makeSymbol({ name: "MyBitmap", kind: ESymbolKind.Bitmap }),
+      const symbols: IHeaderSymbol[] = [
+        makeSymbol({ name: "MyStruct", kind: "struct" }),
+        makeSymbol({ name: "MyEnum", kind: "enum" }),
+        makeSymbol({ name: "myFunc", kind: "function" }),
+        makeSymbol({ name: "myVar", kind: "variable" }),
+        makeSymbol({ name: "MyClass", kind: "class" }),
+        makeSymbol({ name: "MyType", kind: "type" }),
+        makeSymbol({ name: "MyBitmap", kind: "bitmap" }),
       ];
 
       const groups = HeaderGeneratorUtils.groupSymbolsByKind(symbols);
@@ -185,15 +184,15 @@ describe("HeaderGeneratorUtils", () => {
     it("extracts local type names from grouped symbols", () => {
       const groups = {
         structs: [
-          makeSymbol({ name: "Point", kind: ESymbolKind.Struct }),
-          makeSymbol({ name: "Rect", kind: ESymbolKind.Struct }),
+          makeSymbol({ name: "Point", kind: "struct" }),
+          makeSymbol({ name: "Rect", kind: "struct" }),
         ],
-        classes: [] as ISymbol[],
-        functions: [] as ISymbol[],
-        variables: [] as ISymbol[],
-        enums: [makeSymbol({ name: "Color", kind: ESymbolKind.Enum })],
-        types: [makeSymbol({ name: "Size", kind: ESymbolKind.Type })],
-        bitmaps: [makeSymbol({ name: "Flags", kind: ESymbolKind.Bitmap })],
+        classes: [] as IHeaderSymbol[],
+        functions: [] as IHeaderSymbol[],
+        variables: [] as IHeaderSymbol[],
+        enums: [makeSymbol({ name: "Color", kind: "enum" })],
+        types: [makeSymbol({ name: "Size", kind: "type" })],
+        bitmaps: [makeSymbol({ name: "Flags", kind: "bitmap" })],
       };
 
       const localTypes = HeaderGeneratorUtils.getLocalTypeNames(groups);
@@ -240,10 +239,10 @@ describe("HeaderGeneratorUtils", () => {
 
   describe("collectExternalTypes", () => {
     it("collects types from function return types", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "getConfig",
-          kind: ESymbolKind.Function,
+          kind: "function",
           type: "Config",
         }),
       ];
@@ -261,10 +260,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("collects types from function parameters", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "process",
-          kind: ESymbolKind.Function,
+          kind: "function",
           parameters: [makeParam({ name: "data", type: "DataPacket" })],
         }),
       ];
@@ -282,10 +281,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("collects types from variables", () => {
-      const variables: ISymbol[] = [
+      const variables: IHeaderSymbol[] = [
         makeSymbol({
           name: "state",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "SystemState",
         }),
       ];
@@ -303,10 +302,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("excludes local structs", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "getPoint",
-          kind: ESymbolKind.Function,
+          kind: "function",
           type: "Point",
         }),
       ];
@@ -324,10 +323,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("excludes built-in types", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "getValue",
-          kind: ESymbolKind.Function,
+          kind: "function",
           type: "u32",
         }),
       ];
@@ -345,10 +344,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("excludes C++ namespace types", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "parse",
-          kind: ESymbolKind.Function,
+          kind: "function",
           type: "std::string",
         }),
       ];
@@ -366,10 +365,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("excludes known enums", () => {
-      const functions: ISymbol[] = [
+      const functions: IHeaderSymbol[] = [
         makeSymbol({
           name: "getColor",
-          kind: ESymbolKind.Function,
+          kind: "function",
           type: "Color",
         }),
       ];
@@ -444,13 +443,13 @@ describe("HeaderGeneratorUtils", () => {
 
   describe("filterCCompatibleVariables", () => {
     it("filters out C++ namespace types", () => {
-      const variables: ISymbol[] = [
+      const variables: IHeaderSymbol[] = [
         makeSymbol({
           name: "a",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "std::string",
         }),
-        makeSymbol({ name: "b", kind: ESymbolKind.Variable, type: "int" }),
+        makeSymbol({ name: "b", kind: "variable", type: "int" }),
       ];
 
       const result = HeaderGeneratorUtils.filterCCompatibleVariables(variables);
@@ -460,13 +459,13 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("filters out C++ template types", () => {
-      const variables: ISymbol[] = [
+      const variables: IHeaderSymbol[] = [
         makeSymbol({
           name: "a",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "vector<int>",
         }),
-        makeSymbol({ name: "b", kind: ESymbolKind.Variable, type: "u32" }),
+        makeSymbol({ name: "b", kind: "variable", type: "u32" }),
       ];
 
       const result = HeaderGeneratorUtils.filterCCompatibleVariables(variables);
@@ -476,10 +475,10 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("keeps C-Next string<N> types", () => {
-      const variables: ISymbol[] = [
+      const variables: IHeaderSymbol[] = [
         makeSymbol({
           name: "name",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "string<32>",
         }),
       ];
@@ -589,14 +588,14 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("generates placeholder when no typeInput", () => {
-      const enums = [makeSymbol({ name: "Color", kind: ESymbolKind.Enum })];
+      const enums = [makeSymbol({ name: "Color", kind: "enum" })];
       const lines = HeaderGeneratorUtils.generateEnumSection(enums);
 
       expect(lines.some((l) => l.includes("/* Enum: Color"))).toBe(true);
     });
 
     it("includes section comment", () => {
-      const enums = [makeSymbol({ name: "Color", kind: ESymbolKind.Enum })];
+      const enums = [makeSymbol({ name: "Color", kind: "enum" })];
       const lines = HeaderGeneratorUtils.generateEnumSection(enums);
 
       expect(lines).toContain("/* Enumerations */");
@@ -611,14 +610,14 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("generates placeholder when no typeInput", () => {
-      const bitmaps = [makeSymbol({ name: "Flags", kind: ESymbolKind.Bitmap })];
+      const bitmaps = [makeSymbol({ name: "Flags", kind: "bitmap" })];
       const lines = HeaderGeneratorUtils.generateBitmapSection(bitmaps);
 
       expect(lines.some((l) => l.includes("/* Bitmap: Flags"))).toBe(true);
     });
 
     it("includes section comment", () => {
-      const bitmaps = [makeSymbol({ name: "Flags", kind: ESymbolKind.Bitmap })];
+      const bitmaps = [makeSymbol({ name: "Flags", kind: "bitmap" })];
       const lines = HeaderGeneratorUtils.generateBitmapSection(bitmaps);
 
       expect(lines).toContain("/* Bitmaps */");
@@ -634,8 +633,8 @@ describe("HeaderGeneratorUtils", () => {
 
     it("generates typedef for each type alias", () => {
       const types = [
-        makeSymbol({ name: "Size", kind: ESymbolKind.Type, type: "u32" }),
-        makeSymbol({ name: "Handle", kind: ESymbolKind.Type, type: "u64" }),
+        makeSymbol({ name: "Size", kind: "type", type: "u32" }),
+        makeSymbol({ name: "Handle", kind: "type", type: "u64" }),
       ];
       const lines = HeaderGeneratorUtils.generateTypeAliasSection(types);
 
@@ -645,8 +644,8 @@ describe("HeaderGeneratorUtils", () => {
 
     it("skips types without type property", () => {
       const types = [
-        makeSymbol({ name: "NoType", kind: ESymbolKind.Type }),
-        makeSymbol({ name: "WithType", kind: ESymbolKind.Type, type: "i32" }),
+        makeSymbol({ name: "NoType", kind: "type" }),
+        makeSymbol({ name: "WithType", kind: "type", type: "i32" }),
       ];
       const lines = HeaderGeneratorUtils.generateTypeAliasSection(types);
 
@@ -663,8 +662,8 @@ describe("HeaderGeneratorUtils", () => {
     });
 
     it("generates forward declarations when no typeInput", () => {
-      const structs = [makeSymbol({ name: "Point", kind: ESymbolKind.Struct })];
-      const classes = [makeSymbol({ name: "Shape", kind: ESymbolKind.Class })];
+      const structs = [makeSymbol({ name: "Point", kind: "struct" })];
+      const classes = [makeSymbol({ name: "Shape", kind: "class" })];
       const lines = HeaderGeneratorUtils.generateStructSection(
         structs,
         classes,
@@ -687,7 +686,7 @@ describe("HeaderGeneratorUtils", () => {
       const variables = [
         makeSymbol({
           name: "counter",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "u32",
         }),
       ];
@@ -700,7 +699,7 @@ describe("HeaderGeneratorUtils", () => {
       const variables = [
         makeSymbol({
           name: "VERSION",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "u32",
           isConst: true,
         }),
@@ -714,7 +713,7 @@ describe("HeaderGeneratorUtils", () => {
       const variables = [
         makeSymbol({
           name: "flag",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "bool",
           isAtomic: true,
         }),
@@ -728,7 +727,7 @@ describe("HeaderGeneratorUtils", () => {
       const variables = [
         makeSymbol({
           name: "buffer",
-          kind: ESymbolKind.Variable,
+          kind: "variable",
           type: "u8",
           isArray: true,
           arrayDimensions: ["64"],