c-next 0.1.70 → 0.1.72

package/src/utils/TypeResolver.ts

@@ -0,0 +1,132 @@
+/**
+ * TypeResolver - Converts string type representations to TType.
+ *
+ * This utility handles the conversion from the old string-based type system
+ * (e.g., "u32", "string<32>", "u8[10]") to the new TType discriminated union.
+ */
+import type TType from "../transpiler/types/TType";
+import TTypeUtils from "./TTypeUtils";
+import PrimitiveKindUtils from "./PrimitiveKindUtils";
+
+// Regex patterns for type parsing
+const STRING_TYPE_PATTERN = /^string\s*<\s*(\d+)\s*>$/;
+const ARRAY_TYPE_PATTERN = /^(.+?)(\[\s*[^\]]+\s*\])+$/;
+const ARRAY_DIMENSION_PATTERN = /\[\s*([^\]]+)\s*\]/g;
+const EXTERNAL_TYPE_PATTERN = /[:<>]/;
+const ENUM_PREFIX_PATTERN = /^E[A-Z]/;
+
+class TypeResolver {
+  /**
+   * Parse a string type representation and return the corresponding TType.
+   *
+   * @param typeString - String representation of a type (e.g., "u32", "string<32>", "u8[10]")
+   * @returns The corresponding TType object
+   * @throws Error if the type string is empty or invalid
+   */
+  static resolve(typeString: string): TType {
+    const trimmed = typeString.trim();
+
+    if (trimmed === "") {
+      throw new Error("Cannot resolve empty type string");
+    }
+
+    // Check for string type: string<N>
+    const stringMatch = STRING_TYPE_PATTERN.exec(trimmed);
+    if (stringMatch) {
+      const capacity = Number.parseInt(stringMatch[1], 10);
+      return TTypeUtils.createString(capacity);
+    }
+
+    // Check for array type: baseType[dim1][dim2]...
+    const arrayMatch = ARRAY_TYPE_PATTERN.exec(trimmed);
+    if (arrayMatch) {
+      return TypeResolver.parseArrayType(trimmed, arrayMatch[1]);
+    }
+
+    // Check for external type (contains :: or < > for templates)
+    if (EXTERNAL_TYPE_PATTERN.test(trimmed)) {
+      return TTypeUtils.createExternal(trimmed);
+    }
+
+    // Check for primitive type
+    if (PrimitiveKindUtils.isPrimitive(trimmed)) {
+      return TTypeUtils.createPrimitive(trimmed);
+    }
+
+    // Check for enum (E prefix convention)
+    // LIMITATION: This heuristic assumes enums start with 'E' followed by uppercase.
+    // It may misclassify: enums without 'E' prefix, or structs named like 'EFoo'.
+    // For accurate resolution, use SymbolRegistry to check against known types.
+    if (ENUM_PREFIX_PATTERN.test(trimmed)) {
+      return TTypeUtils.createEnum(trimmed);
+    }
+
+    // Default to struct type
+    return TTypeUtils.createStruct(trimmed);
+  }
+
+  /**
+   * Parse an array type and return the TType.
+   */
+  private static parseArrayType(fullType: string, baseTypeStr: string): TType {
+    // Extract all dimensions from the full type string
+    const dimensions: (number | string)[] = [];
+    let match: RegExpExecArray | null = null;
+
+    // Reset lastIndex for global regex
+    ARRAY_DIMENSION_PATTERN.lastIndex = 0;
+
+    while ((match = ARRAY_DIMENSION_PATTERN.exec(fullType)) !== null) {
+      const dimStr = match[1].trim();
+      const dimNum = Number.parseInt(dimStr, 10);
+
+      if (Number.isNaN(dimNum)) {
+        // String dimension (C macro)
+        dimensions.push(dimStr);
+      } else {
+        dimensions.push(dimNum);
+      }
+    }
+
+    // Resolve the base type (recursively handles string<N> as base type)
+    const elementType = TypeResolver.resolve(baseTypeStr.trim());
+
+    return TTypeUtils.createArray(elementType, dimensions);
+  }
+
+  /**
+   * Convert a TType back to its string representation.
+   *
+   * This is useful for round-trip compatibility and debugging.
+   *
+   * @param type - The TType object to convert
+   * @returns String representation of the type
+   */
+  static getTypeName(type: TType): string {
+    switch (type.kind) {
+      case "primitive":
+        return type.primitive;
+      case "string":
+        return `string<${type.capacity}>`;
+      case "struct":
+        return type.name;
+      case "enum":
+        return type.name;
+      case "bitmap":
+        return type.name;
+      case "callback":
+        return type.name;
+      case "register":
+        return type.name;
+      case "external":
+        return type.name;
+      case "array": {
+        const elementName = TypeResolver.getTypeName(type.elementType);
+        const dims = type.dimensions.map((d) => `[${d}]`).join("");
+        return `${elementName}${dims}`;
+      }
+    }
+  }
+}
+
+export default TypeResolver;

package/src/utils/__tests__/CppNamespaceUtils.test.ts

@@ -6,29 +6,99 @@ import { describe, it, expect, beforeEach } from "vitest";
 import CppNamespaceUtils from "../CppNamespaceUtils";
 import SymbolTable from "../../transpiler/logic/symbols/SymbolTable";
 import ESourceLanguage from "../types/ESourceLanguage";
-import ESymbolKind from "../types/ESymbolKind";
-import ISymbol from "../types/ISymbol";
+import type TCppSymbol from "../../transpiler/types/symbols/cpp/TCppSymbol";
+import type TCSymbol from "../../transpiler/types/symbols/c/TCSymbol";
+import type IScopeSymbol from "../../transpiler/types/symbols/IScopeSymbol";
 
 describe("CppNamespaceUtils", () => {
   let symbolTable: SymbolTable;
 
-  // Helper to create a minimal valid ISymbol
-  function makeSymbol(
-    name: string,
-    kind: ESymbolKind,
-    sourceLanguage: ESourceLanguage,
-    sourceFile: string,
-  ): ISymbol {
+  // Helper to create a C++ namespace symbol
+  function makeCppNamespace(name: string, sourceFile: string): TCppSymbol {
     return {
+      kind: "namespace",
       name,
-      kind,
-      sourceLanguage,
       sourceFile,
       sourceLine: 1,
+      sourceLanguage: ESourceLanguage.Cpp,
       isExported: false,
     };
   }
 
+  // Helper to create a C++ class symbol
+  function makeCppClass(name: string, sourceFile: string): TCppSymbol {
+    return {
+      kind: "class",
+      name,
+      sourceFile,
+      sourceLine: 1,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: false,
+    };
+  }
+
+  // Helper to create a C++ enum symbol
+  function makeCppEnum(name: string, sourceFile: string): TCppSymbol {
+    return {
+      kind: "enum",
+      name,
+      sourceFile,
+      sourceLine: 1,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: false,
+    };
+  }
+
+  // Helper to create a C++ function symbol
+  function makeCppFunction(name: string, sourceFile: string): TCppSymbol {
+    return {
+      kind: "function",
+      name,
+      sourceFile,
+      sourceLine: 1,
+      sourceLanguage: ESourceLanguage.Cpp,
+      isExported: false,
+      type: "void",
+    };
+  }
+
+  // Helper to create a C struct symbol
+  function makeCStruct(name: string, sourceFile: string): TCSymbol {
+    return {
+      kind: "struct",
+      name,
+      sourceFile,
+      sourceLine: 1,
+      sourceLanguage: ESourceLanguage.C,
+      isExported: false,
+      isUnion: false,
+    };
+  }
+
+  // Helper to create a C-Next scope symbol (minimal)
+  function makeCNextScope(name: string, sourceFile: string): IScopeSymbol {
+    const scope: IScopeSymbol = {
+      kind: "scope",
+      name,
+      sourceFile,
+      sourceLine: 1,
+      sourceLanguage: ESourceLanguage.CNext,
+      isExported: false,
+      members: [],
+      functions: [],
+      variables: [],
+      memberVisibility: new Map(),
+      // Self-referencing for global scope
+      get parent(): IScopeSymbol {
+        return scope;
+      },
+      get scope(): IScopeSymbol {
+        return scope;
+      },
+    } as IScopeSymbol;
+    return scope;
+  }
+
   beforeEach(() => {
     symbolTable = new SymbolTable();
   });
@@ -51,84 +121,42 @@ describe("CppNamespaceUtils", () => {
     });
 
     it("should return true for C++ namespace", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "SeaDash",
-          ESymbolKind.Namespace,
-          ESourceLanguage.Cpp,
-          "SeaDash.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppNamespace("SeaDash", "SeaDash.hpp"));
       expect(CppNamespaceUtils.isCppNamespace("SeaDash", symbolTable)).toBe(
         true,
       );
     });
 
     it("should return true for C++ class", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyClass",
-          ESymbolKind.Class,
-          ESourceLanguage.Cpp,
-          "MyClass.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppClass("MyClass", "MyClass.hpp"));
       expect(CppNamespaceUtils.isCppNamespace("MyClass", symbolTable)).toBe(
         true,
       );
     });
 
     it("should return true for C++ enum (scoped enum)", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyEnum",
-          ESymbolKind.Enum,
-          ESourceLanguage.Cpp,
-          "MyEnum.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppEnum("MyEnum", "MyEnum.hpp"));
       expect(CppNamespaceUtils.isCppNamespace("MyEnum", symbolTable)).toBe(
         true,
       );
     });
 
     it("should return false for C-Next namespace (scope)", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyScope",
-          ESymbolKind.Namespace,
-          ESourceLanguage.CNext,
-          "MyScope.cnx",
-        ),
-      );
+      symbolTable.addTSymbol(makeCNextScope("MyScope", "MyScope.cnx"));
       expect(CppNamespaceUtils.isCppNamespace("MyScope", symbolTable)).toBe(
         false,
       );
     });
 
     it("should return false for C struct", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyStruct",
-          ESymbolKind.Struct,
-          ESourceLanguage.C,
-          "MyStruct.h",
-        ),
-      );
+      symbolTable.addCSymbol(makeCStruct("MyStruct", "MyStruct.h"));
       expect(CppNamespaceUtils.isCppNamespace("MyStruct", symbolTable)).toBe(
         false,
       );
     });
 
     it("should return false for C++ function", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "myFunction",
-          ESymbolKind.Function,
-          ESourceLanguage.Cpp,
-          "funcs.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppFunction("myFunction", "funcs.hpp"));
       expect(CppNamespaceUtils.isCppNamespace("myFunction", symbolTable)).toBe(
         false,
       );
@@ -162,14 +190,7 @@ describe("CppNamespaceUtils", () => {
     });
 
     it("should return true for underscore type with C++ namespace prefix", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "SeaDash",
-          ESymbolKind.Namespace,
-          ESourceLanguage.Cpp,
-          "SeaDash.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppNamespace("SeaDash", "SeaDash.hpp"));
       expect(
         CppNamespaceUtils.isCppNamespaceType(
           "SeaDash_Parse_ParseResult",
@@ -186,14 +207,7 @@ describe("CppNamespaceUtils", () => {
     });
 
     it("should return false for C-Next scope underscore type", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyScope",
-          ESymbolKind.Namespace,
-          ESourceLanguage.CNext,
-          "MyScope.cnx",
-        ),
-      );
+      symbolTable.addTSymbol(makeCNextScope("MyScope", "MyScope.cnx"));
       expect(
         CppNamespaceUtils.isCppNamespaceType("MyScope_MyType", symbolTable),
       ).toBe(false);
@@ -230,14 +244,7 @@ describe("CppNamespaceUtils", () => {
     });
 
     it("should convert underscore type with C++ namespace prefix", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "SeaDash",
-          ESymbolKind.Namespace,
-          ESourceLanguage.Cpp,
-          "SeaDash.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppNamespace("SeaDash", "SeaDash.hpp"));
       expect(
         CppNamespaceUtils.convertToCppNamespace(
           "SeaDash_Parse_ParseResult",
@@ -254,28 +261,14 @@ describe("CppNamespaceUtils", () => {
     });
 
     it("should NOT convert C-Next scope underscore type", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "MyScope",
-          ESymbolKind.Namespace,
-          ESourceLanguage.CNext,
-          "MyScope.cnx",
-        ),
-      );
+      symbolTable.addTSymbol(makeCNextScope("MyScope", "MyScope.cnx"));
       expect(
         CppNamespaceUtils.convertToCppNamespace("MyScope_MyType", symbolTable),
       ).toBe("MyScope_MyType");
     });
 
     it("should handle deeply nested namespace", () => {
-      symbolTable.addSymbol(
-        makeSymbol(
-          "Lib",
-          ESymbolKind.Namespace,
-          ESourceLanguage.Cpp,
-          "Lib.hpp",
-        ),
-      );
+      symbolTable.addCppSymbol(makeCppNamespace("Lib", "Lib.hpp"));
       expect(
         CppNamespaceUtils.convertToCppNamespace(
           "Lib_Sub_Deep_Type",

package/src/utils/__tests__/FunctionUtils.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Tests for IFunctionSymbol - C-Next function symbol representation
+ */
+import { describe, it, expect } from "vitest";
+import FunctionUtils from "../FunctionUtils";
+import ScopeUtils from "../ScopeUtils";
+import ParameterUtils from "../ParameterUtils";
+import TTypeUtils from "../TTypeUtils";
+
+describe("IFunctionSymbol", () => {
+  describe("FunctionUtils.create", () => {
+    it("creates function with bare name and scope reference", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const testScope = ScopeUtils.createScope("Test", global);
+
+      const func = FunctionUtils.create({
+        name: "fillData", // Bare name, NOT "Test_fillData"
+        scope: testScope,
+        parameters: [
+          ParameterUtils.create({
+            name: "d",
+            type: TTypeUtils.createPrimitive("u32"),
+            isConst: false,
+            isArray: false,
+          }),
+        ],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+      });
+
+      expect(func.kind).toBe("function");
+      expect(func.name).toBe("fillData");
+      expect(func.scope).toBe(testScope);
+      expect(func.parameters).toHaveLength(1);
+      expect(func.parameters[0].name).toBe("d");
+      expect(func.returnType.kind).toBe("primitive");
+      expect(func.visibility).toBe("private");
+      expect(func.sourceFile).toBe("test.cnx");
+      expect(func.sourceLine).toBe(10);
+    });
+
+    it("creates public function in global scope", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "main",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("i32"),
+        visibility: "public",
+        body: null,
+        sourceFile: "main.cnx",
+        sourceLine: 1,
+      });
+
+      expect(func.scope).toBe(global);
+      expect(func.visibility).toBe("public");
+      expect(func.name).toBe("main");
+      expect(ScopeUtils.isGlobalScope(func.scope)).toBe(true);
+    });
+
+    it("creates function with multiple parameters", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "calculate",
+        scope: global,
+        parameters: [
+          ParameterUtils.create({
+            name: "a",
+            type: TTypeUtils.createPrimitive("i32"),
+            isConst: true,
+            isArray: false,
+          }),
+          ParameterUtils.create({
+            name: "b",
+            type: TTypeUtils.createPrimitive("i32"),
+            isConst: true,
+            isArray: false,
+          }),
+          ParameterUtils.create({
+            name: "result",
+            type: TTypeUtils.createPrimitive("i32"),
+            isConst: false,
+            isArray: false,
+          }),
+        ],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "calc.cnx",
+        sourceLine: 5,
+      });
+
+      expect(func.parameters).toHaveLength(3);
+      expect(func.parameters[0].isConst).toBe(true);
+      expect(func.parameters[1].isConst).toBe(true);
+      expect(func.parameters[2].isConst).toBe(false);
+    });
+
+    it("creates function with struct return type", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "createPoint",
+        scope: global,
+        parameters: [
+          ParameterUtils.create({
+            name: "x",
+            type: TTypeUtils.createPrimitive("i32"),
+            isConst: false,
+            isArray: false,
+          }),
+          ParameterUtils.create({
+            name: "y",
+            type: TTypeUtils.createPrimitive("i32"),
+            isConst: false,
+            isArray: false,
+          }),
+        ],
+        returnType: TTypeUtils.createStruct("Point"),
+        visibility: "public",
+        body: null,
+        sourceFile: "point.cnx",
+        sourceLine: 10,
+      });
+
+      expect(func.returnType.kind).toBe("struct");
+      if (func.returnType.kind === "struct") {
+        expect(func.returnType.name).toBe("Point");
+      }
+    });
+
+    it("creates function with body reference", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const mockBody = { type: "block", statements: [] };
+
+      const func = FunctionUtils.create({
+        name: "doSomething",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: mockBody,
+        sourceFile: "example.cnx",
+        sourceLine: 15,
+      });
+
+      expect(func.body).toBe(mockBody);
+    });
+  });
+
+  describe("FunctionUtils.getCMangledName", () => {
+    it("returns bare name for global scope function", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "main",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("i32"),
+        visibility: "public",
+        body: null,
+        sourceFile: "main.cnx",
+        sourceLine: 1,
+      });
+
+      expect(FunctionUtils.getCMangledName(func)).toBe("main");
+    });
+
+    it("returns scope-prefixed name for scoped function", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const testScope = ScopeUtils.createScope("Test", global);
+
+      const func = FunctionUtils.create({
+        name: "fillData",
+        scope: testScope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+      });
+
+      expect(FunctionUtils.getCMangledName(func)).toBe("Test_fillData");
+    });
+
+    it("returns nested scope-prefixed name for nested scope function", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const outerScope = ScopeUtils.createScope("Outer", global);
+      const innerScope = ScopeUtils.createScope("Inner", outerScope);
+
+      const func = FunctionUtils.create({
+        name: "process",
+        scope: innerScope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "nested.cnx",
+        sourceLine: 20,
+      });
+
+      expect(FunctionUtils.getCMangledName(func)).toBe("Outer_Inner_process");
+    });
+  });
+
+  describe("FunctionUtils.isPublic", () => {
+    it("returns true for public function", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "publicFunc",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "public",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+
+      expect(FunctionUtils.isPublic(func)).toBe(true);
+    });
+
+    it("returns false for private function", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "privateFunc",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 1,
+      });
+
+      expect(FunctionUtils.isPublic(func)).toBe(false);
+    });
+  });
+
+  describe("FunctionUtils.isInGlobalScope", () => {
+    it("returns true for function in global scope", () => {
+      const global = ScopeUtils.createGlobalScope();
+
+      const func = FunctionUtils.create({
+        name: "main",
+        scope: global,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("i32"),
+        visibility: "public",
+        body: null,
+        sourceFile: "main.cnx",
+        sourceLine: 1,
+      });
+
+      expect(FunctionUtils.isInGlobalScope(func)).toBe(true);
+    });
+
+    it("returns false for function in named scope", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const testScope = ScopeUtils.createScope("Test", global);
+
+      const func = FunctionUtils.create({
+        name: "helper",
+        scope: testScope,
+        parameters: [],
+        returnType: TTypeUtils.createPrimitive("void"),
+        visibility: "private",
+        body: null,
+        sourceFile: "test.cnx",
+        sourceLine: 5,
+      });
+
+      expect(FunctionUtils.isInGlobalScope(func)).toBe(false);
+    });
+  });
+});