c-next 0.1.70 → 0.1.72

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

@@ -0,0 +1,174 @@
+import { describe, it, expect } from "vitest";
+import ParameterUtils from "../ParameterUtils";
+import TTypeUtils from "../TTypeUtils";
+
+describe("IParameterInfo", () => {
+  describe("create", () => {
+    it("creates parameter with TType", () => {
+      const param = ParameterUtils.create({
+        name: "count",
+        type: TTypeUtils.createPrimitive("u32"),
+        isConst: false,
+        isArray: false,
+      });
+      expect(param.name).toBe("count");
+      expect(param.type.kind).toBe("primitive");
+      expect(param.isConst).toBe(false);
+      expect(param.isArray).toBe(false);
+    });
+
+    it("creates const parameter", () => {
+      const param = ParameterUtils.create({
+        name: "config",
+        type: TTypeUtils.createPrimitive("u8"),
+        isConst: true,
+        isArray: false,
+      });
+      expect(param.isConst).toBe(true);
+    });
+
+    it("supports array dimensions", () => {
+      const param = ParameterUtils.create({
+        name: "buffer",
+        type: TTypeUtils.createPrimitive("u8"),
+        isConst: false,
+        isArray: true,
+        arrayDimensions: [64],
+      });
+      expect(param.isArray).toBe(true);
+      expect(param.arrayDimensions).toEqual([64]);
+    });
+
+    it("supports string dimensions for C macros", () => {
+      const param = ParameterUtils.create({
+        name: "data",
+        type: TTypeUtils.createPrimitive("u8"),
+        isConst: false,
+        isArray: true,
+        arrayDimensions: ["BUFFER_SIZE"],
+      });
+      expect(param.arrayDimensions).toEqual(["BUFFER_SIZE"]);
+    });
+
+    it("supports multi-dimensional arrays", () => {
+      const param = ParameterUtils.create({
+        name: "matrix",
+        type: TTypeUtils.createPrimitive("f32"),
+        isConst: false,
+        isArray: true,
+        arrayDimensions: [4, 4],
+      });
+      expect(param.arrayDimensions).toEqual([4, 4]);
+    });
+
+    it("defaults arrayDimensions to undefined when not provided", () => {
+      const param = ParameterUtils.create({
+        name: "value",
+        type: TTypeUtils.createPrimitive("i32"),
+        isConst: false,
+        isArray: false,
+      });
+      expect(param.arrayDimensions).toBeUndefined();
+    });
+
+    it("supports isAutoConst field", () => {
+      const param = ParameterUtils.create({
+        name: "ptr",
+        type: TTypeUtils.createPrimitive("u8"),
+        isConst: false,
+        isArray: true,
+        arrayDimensions: [10],
+        isAutoConst: true,
+      });
+      expect(param.isAutoConst).toBe(true);
+    });
+  });
+
+  describe("type support", () => {
+    it("supports struct type parameters", () => {
+      const param = ParameterUtils.create({
+        name: "config",
+        type: TTypeUtils.createStruct("Config"),
+        isConst: true,
+        isArray: false,
+      });
+      expect(param.type.kind).toBe("struct");
+      if (param.type.kind === "struct") {
+        expect(param.type.name).toBe("Config");
+      }
+    });
+
+    it("supports enum type parameters", () => {
+      const param = ParameterUtils.create({
+        name: "mode",
+        type: TTypeUtils.createEnum("Mode"),
+        isConst: false,
+        isArray: false,
+      });
+      expect(param.type.kind).toBe("enum");
+      if (param.type.kind === "enum") {
+        expect(param.type.name).toBe("Mode");
+      }
+    });
+
+    it("supports callback type parameters", () => {
+      const param = ParameterUtils.create({
+        name: "handler",
+        type: TTypeUtils.createCallback("EventHandler"),
+        isConst: false,
+        isArray: false,
+      });
+      expect(param.type.kind).toBe("callback");
+      if (param.type.kind === "callback") {
+        expect(param.type.name).toBe("EventHandler");
+      }
+    });
+
+    it("supports string type parameters", () => {
+      const param = ParameterUtils.create({
+        name: "name",
+        type: TTypeUtils.createString(32),
+        isConst: true,
+        isArray: false,
+      });
+      expect(param.type.kind).toBe("string");
+      if (param.type.kind === "string") {
+        expect(param.type.capacity).toBe(32);
+      }
+    });
+  });
+
+  describe("isArray", () => {
+    it("returns true when arrayDimensions is defined and non-empty", () => {
+      const param = ParameterUtils.create({
+        name: "buffer",
+        type: TTypeUtils.createPrimitive("u8"),
+        isConst: false,
+        isArray: true,
+        arrayDimensions: [64],
+      });
+      expect(ParameterUtils.isArray(param)).toBe(true);
+    });
+
+    it("returns false when arrayDimensions is undefined", () => {
+      const param = ParameterUtils.create({
+        name: "value",
+        type: TTypeUtils.createPrimitive("i32"),
+        isConst: false,
+        isArray: false,
+      });
+      expect(ParameterUtils.isArray(param)).toBe(false);
+    });
+
+    it("returns false when arrayDimensions is empty", () => {
+      const param = ParameterUtils.create({
+        name: "value",
+        type: TTypeUtils.createPrimitive("i32"),
+        isConst: false,
+        isArray: false,
+        arrayDimensions: [],
+      });
+      expect(ParameterUtils.isArray(param)).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import TPrimitiveKind from "../../transpiler/types/TPrimitiveKind";
+import PrimitiveKindUtils from "../PrimitiveKindUtils";
+
+describe("TPrimitiveKind", () => {
+  it("includes all C-Next primitive types", () => {
+    const primitives: TPrimitiveKind[] = [
+      "void",
+      "bool",
+      "u8",
+      "i8",
+      "u16",
+      "i16",
+      "u32",
+      "i32",
+      "u64",
+      "i64",
+      "f32",
+      "f64",
+    ];
+    // Type check passes if all are valid TPrimitiveKind
+    expect(primitives).toHaveLength(12);
+  });
+
+  it("provides bit widths for numeric primitives", () => {
+    expect(PrimitiveKindUtils.BIT_WIDTHS.get("u8")).toBe(8);
+    expect(PrimitiveKindUtils.BIT_WIDTHS.get("i32")).toBe(32);
+    expect(PrimitiveKindUtils.BIT_WIDTHS.get("f64")).toBe(64);
+    expect(PrimitiveKindUtils.BIT_WIDTHS.get("bool")).toBe(1);
+    expect(PrimitiveKindUtils.BIT_WIDTHS.get("void")).toBeUndefined();
+  });
+
+  describe("getBitWidth", () => {
+    it("returns bit width for numeric types", () => {
+      expect(PrimitiveKindUtils.getBitWidth("u8")).toBe(8);
+      expect(PrimitiveKindUtils.getBitWidth("i32")).toBe(32);
+      expect(PrimitiveKindUtils.getBitWidth("f64")).toBe(64);
+    });
+
+    it("returns undefined for void", () => {
+      expect(PrimitiveKindUtils.getBitWidth("void")).toBeUndefined();
+    });
+  });
+
+  describe("isPrimitive", () => {
+    it("returns true for primitive types", () => {
+      expect(PrimitiveKindUtils.isPrimitive("u8")).toBe(true);
+      expect(PrimitiveKindUtils.isPrimitive("i32")).toBe(true);
+      expect(PrimitiveKindUtils.isPrimitive("void")).toBe(true);
+      expect(PrimitiveKindUtils.isPrimitive("bool")).toBe(true);
+    });
+
+    it("returns false for non-primitive types", () => {
+      expect(PrimitiveKindUtils.isPrimitive("MyStruct")).toBe(false);
+      expect(PrimitiveKindUtils.isPrimitive("string")).toBe(false);
+      expect(PrimitiveKindUtils.isPrimitive("array")).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "vitest";
+import ScopeUtils from "../ScopeUtils";
+
+describe("IScopeSymbol", () => {
+  describe("createGlobalScope", () => {
+    it("creates global scope with self-reference parent", () => {
+      const global = ScopeUtils.createGlobalScope();
+      expect(global.kind).toBe("scope");
+      expect(global.name).toBe("");
+      expect(global.parent).toBe(global); // Self-reference
+      expect(global.functions).toEqual([]);
+      expect(global.variables).toEqual([]);
+    });
+  });
+
+  describe("createScope", () => {
+    it("creates named scope with parent reference", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const test = ScopeUtils.createScope("Test", global);
+      expect(test.kind).toBe("scope");
+      expect(test.name).toBe("Test");
+      expect(test.parent).toBe(global);
+    });
+
+    it("supports nested scopes", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const outer = ScopeUtils.createScope("Outer", global);
+      const inner = ScopeUtils.createScope("Inner", outer);
+      expect(inner.parent).toBe(outer);
+      expect(outer.parent).toBe(global);
+    });
+
+    it("initializes empty functions and variables arrays", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const scope = ScopeUtils.createScope("Test", global);
+      expect(scope.functions).toEqual([]);
+      expect(scope.variables).toEqual([]);
+    });
+  });
+
+  describe("isGlobalScope", () => {
+    it("returns true for global scope", () => {
+      const global = ScopeUtils.createGlobalScope();
+      expect(ScopeUtils.isGlobalScope(global)).toBe(true);
+    });
+
+    it("returns false for named scope", () => {
+      const global = ScopeUtils.createGlobalScope();
+      const scope = ScopeUtils.createScope("Test", global);
+      expect(ScopeUtils.isGlobalScope(scope)).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,245 @@
+import { describe, it, expect } from "vitest";
+import TTypeUtils from "../TTypeUtils";
+
+describe("TType", () => {
+  describe("createPrimitive", () => {
+    it("creates a primitive type", () => {
+      const t = TTypeUtils.createPrimitive("u32");
+      expect(t.kind).toBe("primitive");
+      expect(t.primitive).toBe("u32");
+    });
+
+    it("creates all primitive kinds", () => {
+      const kinds = [
+        "void",
+        "bool",
+        "u8",
+        "i8",
+        "u16",
+        "i16",
+        "u32",
+        "i32",
+        "u64",
+        "i64",
+        "f32",
+        "f64",
+      ] as const;
+      for (const kind of kinds) {
+        const t = TTypeUtils.createPrimitive(kind);
+        expect(t.kind).toBe("primitive");
+        expect(t.primitive).toBe(kind);
+      }
+    });
+  });
+
+  describe("createArray", () => {
+    it("creates an array type with dimensions", () => {
+      const elem = TTypeUtils.createPrimitive("u8");
+      const t = TTypeUtils.createArray(elem, [10, 20]);
+      expect(t.kind).toBe("array");
+      expect(t.elementType).toBe(elem);
+      expect(t.dimensions).toEqual([10, 20]);
+    });
+
+    it("creates single-dimension array", () => {
+      const elem = TTypeUtils.createPrimitive("i32");
+      const t = TTypeUtils.createArray(elem, [5]);
+      expect(t.kind).toBe("array");
+      expect(t.dimensions).toEqual([5]);
+    });
+
+    it("supports string dimensions for C macros", () => {
+      const elem = TTypeUtils.createPrimitive("u8");
+      const t = TTypeUtils.createArray(elem, ["BUFFER_SIZE"]);
+      expect(t.dimensions).toEqual(["BUFFER_SIZE"]);
+    });
+  });
+
+  describe("createString", () => {
+    it("creates a string type with capacity", () => {
+      const t = TTypeUtils.createString(32);
+      expect(t.kind).toBe("string");
+      expect(t.capacity).toBe(32);
+    });
+
+    it("creates string with different capacities", () => {
+      const t1 = TTypeUtils.createString(64);
+      const t2 = TTypeUtils.createString(256);
+      expect(t1.capacity).toBe(64);
+      expect(t2.capacity).toBe(256);
+    });
+  });
+
+  describe("createExternal", () => {
+    it("creates an external C++ type", () => {
+      const t = TTypeUtils.createExternal("FlexCAN_T4<CAN1>");
+      expect(t.kind).toBe("external");
+      expect(t.name).toBe("FlexCAN_T4<CAN1>");
+    });
+
+    it("creates external type without template", () => {
+      const t = TTypeUtils.createExternal("SomeExternalClass");
+      expect(t.kind).toBe("external");
+      expect(t.name).toBe("SomeExternalClass");
+    });
+  });
+
+  describe("createStruct", () => {
+    it("creates a struct type reference", () => {
+      const t = TTypeUtils.createStruct("Point");
+      expect(t.kind).toBe("struct");
+      expect(t.name).toBe("Point");
+    });
+  });
+
+  describe("createEnum", () => {
+    it("creates an enum type reference", () => {
+      const t = TTypeUtils.createEnum("Color");
+      expect(t.kind).toBe("enum");
+      expect(t.name).toBe("Color");
+    });
+  });
+
+  describe("createBitmap", () => {
+    it("creates a bitmap type reference", () => {
+      const t = TTypeUtils.createBitmap("StatusFlags", 8);
+      expect(t.kind).toBe("bitmap");
+      expect(t.name).toBe("StatusFlags");
+      expect(t.bitWidth).toBe(8);
+    });
+
+    it("creates bitmap with different widths", () => {
+      const t16 = TTypeUtils.createBitmap("Flags16", 16);
+      const t32 = TTypeUtils.createBitmap("Flags32", 32);
+      expect(t16.bitWidth).toBe(16);
+      expect(t32.bitWidth).toBe(32);
+    });
+  });
+
+  describe("createCallback", () => {
+    it("creates a callback type reference", () => {
+      const t = TTypeUtils.createCallback("onClick");
+      expect(t.kind).toBe("callback");
+      expect(t.name).toBe("onClick");
+    });
+  });
+
+  describe("createRegister", () => {
+    it("creates a register type reference", () => {
+      const t = TTypeUtils.createRegister("PORTA");
+      expect(t.kind).toBe("register");
+      expect(t.name).toBe("PORTA");
+    });
+  });
+
+  describe("type guards", () => {
+    it("isPrimitive returns true for primitives", () => {
+      const t = TTypeUtils.createPrimitive("i64");
+      expect(TTypeUtils.isPrimitive(t)).toBe(true);
+    });
+
+    it("isPrimitive returns false for non-primitives", () => {
+      const t = TTypeUtils.createString(32);
+      expect(TTypeUtils.isPrimitive(t)).toBe(false);
+    });
+
+    it("isArray returns true for arrays", () => {
+      const t = TTypeUtils.createArray(TTypeUtils.createPrimitive("u8"), [5]);
+      expect(TTypeUtils.isArray(t)).toBe(true);
+    });
+
+    it("isArray returns false for non-arrays", () => {
+      const t = TTypeUtils.createPrimitive("u8");
+      expect(TTypeUtils.isArray(t)).toBe(false);
+    });
+
+    it("isStruct returns true for structs", () => {
+      const t = TTypeUtils.createStruct("Point");
+      expect(TTypeUtils.isStruct(t)).toBe(true);
+    });
+
+    it("isStruct returns false for non-structs", () => {
+      const t = TTypeUtils.createPrimitive("u32");
+      expect(TTypeUtils.isStruct(t)).toBe(false);
+    });
+
+    it("isEnum returns true for enums", () => {
+      const t = TTypeUtils.createEnum("Color");
+      expect(TTypeUtils.isEnum(t)).toBe(true);
+    });
+
+    it("isEnum returns false for non-enums", () => {
+      const t = TTypeUtils.createStruct("Point");
+      expect(TTypeUtils.isEnum(t)).toBe(false);
+    });
+
+    it("isString returns true for strings", () => {
+      const t = TTypeUtils.createString(64);
+      expect(TTypeUtils.isString(t)).toBe(true);
+    });
+
+    it("isString returns false for non-strings", () => {
+      const t = TTypeUtils.createPrimitive("u8");
+      expect(TTypeUtils.isString(t)).toBe(false);
+    });
+
+    it("isBitmap returns true for bitmaps", () => {
+      const t = TTypeUtils.createBitmap("Flags", 8);
+      expect(TTypeUtils.isBitmap(t)).toBe(true);
+    });
+
+    it("isBitmap returns false for non-bitmaps", () => {
+      const t = TTypeUtils.createEnum("Color");
+      expect(TTypeUtils.isBitmap(t)).toBe(false);
+    });
+
+    it("isCallback returns true for callbacks", () => {
+      const t = TTypeUtils.createCallback("handler");
+      expect(TTypeUtils.isCallback(t)).toBe(true);
+    });
+
+    it("isCallback returns false for non-callbacks", () => {
+      const t = TTypeUtils.createPrimitive("void");
+      expect(TTypeUtils.isCallback(t)).toBe(false);
+    });
+
+    it("isRegister returns true for registers", () => {
+      const t = TTypeUtils.createRegister("PORTB");
+      expect(TTypeUtils.isRegister(t)).toBe(true);
+    });
+
+    it("isRegister returns false for non-registers", () => {
+      const t = TTypeUtils.createExternal("SomeClass");
+      expect(TTypeUtils.isRegister(t)).toBe(false);
+    });
+
+    it("isExternal returns true for external types", () => {
+      const t = TTypeUtils.createExternal("FlexCAN_T4<CAN1>");
+      expect(TTypeUtils.isExternal(t)).toBe(true);
+    });
+
+    it("isExternal returns false for non-external types", () => {
+      const t = TTypeUtils.createPrimitive("u32");
+      expect(TTypeUtils.isExternal(t)).toBe(false);
+    });
+  });
+
+  describe("nested types", () => {
+    it("creates array of structs", () => {
+      const structType = TTypeUtils.createStruct("Point");
+      const arrayType = TTypeUtils.createArray(structType, [10]);
+      expect(arrayType.kind).toBe("array");
+      expect(arrayType.elementType.kind).toBe("struct");
+      if (arrayType.elementType.kind === "struct") {
+        expect(arrayType.elementType.name).toBe("Point");
+      }
+    });
+
+    it("creates multi-dimensional array of primitives", () => {
+      const elemType = TTypeUtils.createPrimitive("f32");
+      const arrayType = TTypeUtils.createArray(elemType, [3, 3]);
+      expect(arrayType.dimensions).toEqual([3, 3]);
+      expect(arrayType.elementType).toBe(elemType);
+    });
+  });
+});