c-next 0.1.70 → 0.1.72

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

@@ -6,9 +6,8 @@
 
 import { describe, it, expect } from "vitest";
 import CppHeaderGenerator from "../CppHeaderGenerator";
-import ISymbol from "../../../../utils/types/ISymbol";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
+import IHeaderSymbol from "../types/IHeaderSymbol";
+
 import IParameterSymbol from "../../../../utils/types/IParameterSymbol";
 
 // ============================================================================
@@ -20,16 +19,15 @@ function createFunctionSymbol(
   returnType: string,
   parameters: IParameterSymbol[] = [],
   isExported = true,
-): ISymbol {
+): IHeaderSymbol {
   return {
     name,
-    kind: ESymbolKind.Function,
+    kind: "function",
     type: returnType,
     parameters,
     isExported,
     sourceFile: "test.cnx",
     sourceLine: 1,
-    sourceLanguage: ESourceLanguage.CNext,
   };
 }
 
@@ -56,7 +54,7 @@ describe("CppHeaderGenerator", () => {
   describe("generate", () => {
     it("generates header with include guard", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -67,7 +65,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates header with custom guard prefix", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "module.h", {
         guardPrefix: "MY_PROJECT",
@@ -79,7 +77,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates extern C wrapper for C++ compatibility", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -90,7 +88,9 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function prototypes", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [createFunctionSymbol("doSomething", "void")];
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("doSomething", "void"),
+      ];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -99,7 +99,7 @@ describe("CppHeaderGenerator", () => {
 
     it("filters to exported symbols when exportedOnly is true", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("publicFunc", "void", [], true),
         createFunctionSymbol("privateFunc", "void", [], false),
       ];
@@ -114,7 +114,7 @@ describe("CppHeaderGenerator", () => {
 
     it("includes all symbols when exportedOnly is false", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("publicFunc", "void", [], true),
         createFunctionSymbol("privateFunc", "void", [], false),
       ];
@@ -131,7 +131,7 @@ describe("CppHeaderGenerator", () => {
   describe("function prototype generation", () => {
     it("generates void function with no parameters", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [createFunctionSymbol("init", "void")];
+      const symbols: IHeaderSymbol[] = [createFunctionSymbol("init", "void")];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -140,7 +140,9 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function with return type", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [createFunctionSymbol("getValue", "u32")];
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("getValue", "u32"),
+      ];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -149,7 +151,7 @@ describe("CppHeaderGenerator", () => {
 
     it("forces main to return int", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [createFunctionSymbol("main", "u32")];
+      const symbols: IHeaderSymbol[] = [createFunctionSymbol("main", "u32")];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -158,7 +160,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function with single parameter using reference", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("process", "void", [createParam("value", "u32")]),
       ];
 
@@ -169,7 +171,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function with const parameter", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("process", "void", [
           createParam("value", "u32", { isConst: true }),
         ]),
@@ -182,7 +184,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function with auto-const parameter", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("process", "void", [
           createParam("value", "u32", { isAutoConst: true }),
         ]),
@@ -195,7 +197,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates function with multiple parameters", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("add", "u32", [
           createParam("a", "u32"),
           createParam("b", "u32"),
@@ -209,7 +211,7 @@ describe("CppHeaderGenerator", () => {
 
     it("uses pass-by-value for parameters in passByValueParams", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("process", "void", [createParam("value", "u32")]),
       ];
       const passByValueParams = new Map([["process", new Set(["value"])]]);
@@ -227,7 +229,7 @@ describe("CppHeaderGenerator", () => {
 
     it("uses pass-by-value for float types (f32)", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("setFloat", "void", [createParam("value", "f32")]),
       ];
 
@@ -238,7 +240,7 @@ describe("CppHeaderGenerator", () => {
 
     it("uses pass-by-value for float types (f64)", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("setDouble", "void", [
           createParam("value", "f64"),
         ]),
@@ -251,7 +253,7 @@ describe("CppHeaderGenerator", () => {
 
     it("uses pass-by-value for enum types", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("setState", "void", [
           createParam("state", "State"),
         ]),
@@ -272,7 +274,7 @@ describe("CppHeaderGenerator", () => {
 
     it("uses pass-by-value for ISR type (function pointer)", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("setHandler", "void", [
           createParam("handler", "ISR"),
         ]),
@@ -285,7 +287,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates array parameter with pointer syntax", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processArray", "void", [
           createParam("data", "u8", { isArray: true, arrayDimensions: ["10"] }),
         ]),
@@ -298,7 +300,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates const array parameter", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("readArray", "void", [
           createParam("data", "u8", {
             isConst: true,
@@ -315,7 +317,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates string array parameter as char*", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processStrings", "void", [
           createParam("strings", "string", {
             isArray: true,
@@ -331,7 +333,7 @@ describe("CppHeaderGenerator", () => {
 
     it("generates multi-dimensional array parameter", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("processMatrix", "void", [
           createParam("matrix", "u32", {
             isArray: true,
@@ -361,7 +363,7 @@ describe("CppHeaderGenerator", () => {
       ];
 
       for (const { cnx, c } of types) {
-        const symbols: ISymbol[] = [createFunctionSymbol("get", cnx)];
+        const symbols: IHeaderSymbol[] = [createFunctionSymbol("get", cnx)];
         const result = generator.generate(symbols, "test.h");
         expect(result).toContain(`${c} get(void);`);
       }
@@ -369,7 +371,9 @@ describe("CppHeaderGenerator", () => {
 
     it("maps bool type", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [createFunctionSymbol("isReady", "bool")];
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("isReady", "bool"),
+      ];
 
       const result = generator.generate(symbols, "test.h");
 
@@ -378,7 +382,7 @@ describe("CppHeaderGenerator", () => {
 
     it("maps float types", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [
+      const symbols: IHeaderSymbol[] = [
         createFunctionSymbol("getF32", "f32"),
         createFunctionSymbol("getF64", "f64"),
       ];
@@ -393,7 +397,7 @@ describe("CppHeaderGenerator", () => {
   describe("empty inputs", () => {
     it("generates valid header with no functions", () => {
       const generator = new CppHeaderGenerator();
-      const symbols: ISymbol[] = [];
+      const symbols: IHeaderSymbol[] = [];
 
       const result = generator.generate(symbols, "empty.h");
 

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

@@ -4,39 +4,39 @@
 
 import { describe, it, expect } from "vitest";
 import ExternalTypeHeaderBuilder from "../ExternalTypeHeaderBuilder";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
-import ISymbol from "../../../../utils/types/ISymbol";
-import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
+
+import TSymbolKind from "../../../types/symbol-kinds/TSymbolKind";
+import TAnySymbol from "../../../types/symbols/TAnySymbol";
+import TCSymbol from "../../../types/symbols/c/TCSymbol";
 
 /**
- * Create a minimal test symbol
+ * Create a minimal test symbol (using C symbol for simplicity)
  */
 function createSymbol(
   name: string,
-  kind: ESymbolKind,
+  kind: TSymbolKind,
   sourceFile: string,
-): ISymbol {
+): TCSymbol {
   return {
     name,
     kind,
     sourceFile,
     sourceLine: 1,
-    sourceLanguage: ESourceLanguage.C,
     isExported: false,
-  };
+  } as TCSymbol;
 }
 
 /**
  * Mock symbol source for testing
  */
 class MockSymbolSource {
-  private symbolsByFile: Map<string, ISymbol[]> = new Map();
+  private symbolsByFile: Map<string, TAnySymbol[]> = new Map();
 
-  addSymbols(filePath: string, symbols: ISymbol[]): void {
+  addSymbols(filePath: string, symbols: TAnySymbol[]): void {
     this.symbolsByFile.set(filePath, symbols);
   }
 
-  getSymbolsByFile(filePath: string): ISymbol[] {
+  getSymbolsByFile(filePath: string): TAnySymbol[] {
     return this.symbolsByFile.get(filePath) ?? [];
   }
 }
@@ -46,7 +46,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("maps struct types to their include directives", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/types.h", [
-        createSymbol("MyStruct", ESymbolKind.Struct, "/path/to/types.h"),
+        createSymbol("MyStruct", "struct", "/path/to/types.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -61,7 +61,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("maps enum types to their include directives", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/enums.h", [
-        createSymbol("Status", ESymbolKind.Enum, "/path/to/enums.h"),
+        createSymbol("Status", "enum", "/path/to/enums.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -76,7 +76,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("maps typedef types to their include directives", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/types.h", [
-        createSymbol("size_t", ESymbolKind.Type, "/path/to/types.h"),
+        createSymbol("size_t", "type", "/path/to/types.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -91,7 +91,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("maps class types to their include directives", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/serial.hpp", [
-        createSymbol("Serial", ESymbolKind.Class, "/path/to/serial.hpp"),
+        createSymbol("Serial", "class", "/path/to/serial.hpp"),
       ]);
 
       const headerDirectives = new Map([
@@ -106,7 +106,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("ignores function symbols", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/funcs.h", [
-        createSymbol("doSomething", ESymbolKind.Function, "/path/to/funcs.h"),
+        createSymbol("doSomething", "function", "/path/to/funcs.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -121,7 +121,7 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("ignores variable symbols", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/vars.h", [
-        createSymbol("globalVar", ESymbolKind.Variable, "/path/to/vars.h"),
+        createSymbol("globalVar", "variable", "/path/to/vars.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -136,10 +136,10 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("first include wins for duplicate type names", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/first.h", [
-        createSymbol("DuplicateType", ESymbolKind.Struct, "/path/to/first.h"),
+        createSymbol("DuplicateType", "struct", "/path/to/first.h"),
       ]);
       source.addSymbols("/path/to/second.h", [
-        createSymbol("DuplicateType", ESymbolKind.Struct, "/path/to/second.h"),
+        createSymbol("DuplicateType", "struct", "/path/to/second.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -155,9 +155,9 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("handles multiple types from same header", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/types.h", [
-        createSymbol("StructA", ESymbolKind.Struct, "/path/to/types.h"),
-        createSymbol("EnumB", ESymbolKind.Enum, "/path/to/types.h"),
-        createSymbol("TypeC", ESymbolKind.Type, "/path/to/types.h"),
+        createSymbol("StructA", "struct", "/path/to/types.h"),
+        createSymbol("EnumB", "enum", "/path/to/types.h"),
+        createSymbol("TypeC", "type", "/path/to/types.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -174,10 +174,10 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("handles multiple headers", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/a.h", [
-        createSymbol("TypeA", ESymbolKind.Struct, "/path/to/a.h"),
+        createSymbol("TypeA", "struct", "/path/to/a.h"),
       ]);
       source.addSymbols("/path/to/b.h", [
-        createSymbol("TypeB", ESymbolKind.Enum, "/path/to/b.h"),
+        createSymbol("TypeB", "enum", "/path/to/b.h"),
       ]);
 
       const headerDirectives = new Map([
@@ -203,8 +203,8 @@ describe("ExternalTypeHeaderBuilder", () => {
     it("returns empty map when headers have no type symbols", () => {
       const source = new MockSymbolSource();
       source.addSymbols("/path/to/funcs.h", [
-        createSymbol("func1", ESymbolKind.Function, "/path/to/funcs.h"),
-        createSymbol("func2", ESymbolKind.Function, "/path/to/funcs.h"),
+        createSymbol("func1", "function", "/path/to/funcs.h"),
+        createSymbol("func2", "function", "/path/to/funcs.h"),
       ]);
 
       const headerDirectives = new Map([