c-next 0.1.65 → 0.1.66

package/src/transpiler/output/codegen/helpers/__tests__/ParameterSignatureBuilder.test.ts

@@ -0,0 +1,315 @@
+/**
+ * Unit tests for ParameterSignatureBuilder
+ *
+ * Tests the stateless builder that generates C/C++ parameter signatures
+ * from normalized IParameterInput.
+ */
+
+import { describe, it, expect } from "vitest";
+import ParameterSignatureBuilder from "../ParameterSignatureBuilder";
+import IParameterInput from "../../types/IParameterInput";
+
+/**
+ * Helper to create a minimal IParameterInput with defaults
+ */
+function createInput(overrides: Partial<IParameterInput>): IParameterInput {
+  return {
+    name: "param",
+    baseType: "u32",
+    mappedType: "uint32_t",
+    isConst: false,
+    isAutoConst: false,
+    isArray: false,
+    isCallback: false,
+    isString: false,
+    isPassByValue: false,
+    isPassByReference: true,
+    ...overrides,
+  };
+}
+
+describe("ParameterSignatureBuilder", () => {
+  describe("callback parameters", () => {
+    it("generates callback typedef name", () => {
+      const input = createInput({
+        name: "onClick",
+        baseType: "handleClick",
+        isCallback: true,
+        callbackTypedefName: "HandleClickCallback",
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("HandleClickCallback onClick");
+    });
+  });
+
+  describe("array parameters", () => {
+    it("generates single dimension array", () => {
+      const input = createInput({
+        name: "arr",
+        baseType: "u32",
+        mappedType: "uint32_t",
+        isArray: true,
+        arrayDimensions: ["10"],
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const uint32_t arr[10]");
+    });
+
+    it("generates multi-dimensional array", () => {
+      const input = createInput({
+        name: "matrix",
+        baseType: "u8",
+        mappedType: "uint8_t",
+        isArray: true,
+        arrayDimensions: ["4", "4"],
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const uint8_t matrix[4][4]");
+    });
+
+    it("generates bounded string array with capacity dimension", () => {
+      const input = createInput({
+        name: "names",
+        baseType: "string<32>",
+        mappedType: "char",
+        isArray: true,
+        arrayDimensions: ["5", "33"],
+        isString: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const char names[5][33]");
+    });
+
+    it("generates unbounded string array with char*", () => {
+      const input = createInput({
+        name: "strings",
+        baseType: "string",
+        mappedType: "char",
+        isArray: true,
+        arrayDimensions: ["5"],
+        isString: true,
+        isUnboundedString: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const char* strings[5]");
+    });
+
+    it("omits auto-const for modified array parameter", () => {
+      const input = createInput({
+        name: "arr",
+        baseType: "u32",
+        mappedType: "uint32_t",
+        isArray: true,
+        arrayDimensions: ["10"],
+        isAutoConst: false, // parameter is modified
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("uint32_t arr[10]");
+    });
+  });
+
+  describe("pass-by-value parameters", () => {
+    it("generates ISR parameter", () => {
+      const input = createInput({
+        name: "handler",
+        baseType: "ISR",
+        mappedType: "ISR",
+        isPassByValue: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("ISR handler");
+    });
+
+    it("generates float parameter", () => {
+      const input = createInput({
+        name: "value",
+        baseType: "f32",
+        mappedType: "float",
+        isPassByValue: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("float value");
+    });
+
+    it("generates enum parameter", () => {
+      const input = createInput({
+        name: "status",
+        baseType: "Status",
+        mappedType: "Status",
+        isPassByValue: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("Status status");
+    });
+
+    it("preserves explicit const on pass-by-value", () => {
+      const input = createInput({
+        name: "value",
+        baseType: "f32",
+        mappedType: "float",
+        isConst: true,
+        isPassByValue: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const float value");
+    });
+  });
+
+  describe("non-array string parameters", () => {
+    it("generates string parameter as char*", () => {
+      const input = createInput({
+        name: "name",
+        baseType: "string<32>",
+        mappedType: "char",
+        isString: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const char* name");
+    });
+
+    it("omits auto-const for modified string parameter", () => {
+      const input = createInput({
+        name: "buffer",
+        baseType: "string<64>",
+        mappedType: "char",
+        isString: true,
+        isAutoConst: false, // parameter is modified
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("char* buffer");
+    });
+  });
+
+  describe("pass-by-reference parameters", () => {
+    it("generates struct parameter with pointer in C mode", () => {
+      const input = createInput({
+        name: "point",
+        baseType: "Point",
+        mappedType: "Point",
+        isPassByReference: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const Point* point");
+    });
+
+    it("generates struct parameter with reference in C++ mode", () => {
+      const input = createInput({
+        name: "point",
+        baseType: "Point",
+        mappedType: "Point",
+        isPassByReference: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      expect(result).toBe("const Point& point");
+    });
+
+    it("omits auto-const for modified struct parameter", () => {
+      const input = createInput({
+        name: "point",
+        baseType: "Point",
+        mappedType: "Point",
+        isPassByReference: true,
+        isAutoConst: false, // parameter is modified
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("Point* point");
+    });
+
+    it("generates primitive parameter with pointer", () => {
+      const input = createInput({
+        name: "value",
+        baseType: "u32",
+        mappedType: "uint32_t",
+        isPassByReference: true,
+        isAutoConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const uint32_t* value");
+    });
+
+    it("preserves explicit const with auto-const", () => {
+      const input = createInput({
+        name: "point",
+        baseType: "Point",
+        mappedType: "Point",
+        isConst: true,
+        isAutoConst: false, // explicit const already set
+        isPassByReference: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const Point* point");
+    });
+  });
+
+  describe("unknown type parameters", () => {
+    it("generates unknown type as pass-by-value", () => {
+      const input = createInput({
+        name: "data",
+        baseType: "UnknownType",
+        mappedType: "UnknownType",
+        isPassByReference: false,
+        isPassByValue: false,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("UnknownType data");
+    });
+
+    it("preserves const on unknown type", () => {
+      const input = createInput({
+        name: "data",
+        baseType: "UnknownType",
+        mappedType: "UnknownType",
+        isConst: true,
+        isPassByReference: false,
+        isPassByValue: false,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const UnknownType data");
+    });
+  });
+});

package/src/transpiler/output/codegen/helpers/__tests__/VariableDeclarationFormatter.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Unit tests for VariableDeclarationFormatter.
+ *
+ * Tests the stateless variable declaration formatting used by both
+ * CodeGenerator and HeaderGeneratorUtils.
+ */
+
+import { describe, expect, it } from "vitest";
+import VariableDeclarationFormatter from "../VariableDeclarationFormatter";
+import type IVariableFormatInput from "../../types/IVariableFormatInput";
+
+describe("VariableDeclarationFormatter", () => {
+  describe("format", () => {
+    it("formats simple variable declaration", () => {
+      const input: IVariableFormatInput = {
+        name: "counter",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "uint32_t counter",
+      );
+    });
+
+    it("formats const variable", () => {
+      const input: IVariableFormatInput = {
+        name: "MAX_SIZE",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: true,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "const uint32_t MAX_SIZE",
+      );
+    });
+
+    it("formats extern variable", () => {
+      const input: IVariableFormatInput = {
+        name: "globalCounter",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: true,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "extern uint32_t globalCounter",
+      );
+    });
+
+    it("formats extern const variable with correct ordering", () => {
+      const input: IVariableFormatInput = {
+        name: "MAX_SIZE",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: true,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: true,
+        },
+      };
+
+      // Order should be: extern volatile const (volatile before const)
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "extern const uint32_t MAX_SIZE",
+      );
+    });
+
+    it("formats atomic variable (maps to volatile)", () => {
+      const input: IVariableFormatInput = {
+        name: "sharedCounter",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: true,
+          isVolatile: false,
+          isExtern: false,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "volatile uint32_t sharedCounter",
+      );
+    });
+
+    it("formats volatile variable", () => {
+      const input: IVariableFormatInput = {
+        name: "hwRegister",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: true,
+          isExtern: false,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "volatile uint32_t hwRegister",
+      );
+    });
+
+    it("formats extern volatile const with all modifiers", () => {
+      const input: IVariableFormatInput = {
+        name: "ROM_DATA",
+        cnextType: "u32",
+        mappedType: "uint32_t",
+        modifiers: {
+          isConst: true,
+          isAtomic: false,
+          isVolatile: true,
+          isExtern: true,
+        },
+      };
+
+      // Order: extern volatile const (volatile before const)
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "extern volatile const uint32_t ROM_DATA",
+      );
+    });
+
+    it("formats array variable with single dimension", () => {
+      const input: IVariableFormatInput = {
+        name: "buffer",
+        cnextType: "u8",
+        mappedType: "uint8_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+        arrayDimensions: ["256"],
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "uint8_t buffer[256]",
+      );
+    });
+
+    it("formats array variable with multiple dimensions", () => {
+      const input: IVariableFormatInput = {
+        name: "matrix",
+        cnextType: "u8",
+        mappedType: "uint8_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+        arrayDimensions: ["4", "4"],
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "uint8_t matrix[4][4]",
+      );
+    });
+
+    it("formats string<N> variable with embedded dimension", () => {
+      const input: IVariableFormatInput = {
+        name: "greeting",
+        cnextType: "string<32>",
+        mappedType: "char[33]", // string<32> maps to char[33]
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+      };
+
+      // Embedded dimension should come after variable name
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "char greeting[33]",
+      );
+    });
+
+    it("formats string<N> array with additional dimensions first", () => {
+      const input: IVariableFormatInput = {
+        name: "names",
+        cnextType: "string<32>",
+        mappedType: "char[33]",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+        arrayDimensions: ["5"],
+      };
+
+      // Additional dims first, then embedded dim
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "char names[5][33]",
+      );
+    });
+
+    it("formats const string<N> array for header extern", () => {
+      const input: IVariableFormatInput = {
+        name: "messages",
+        cnextType: "string<64>",
+        mappedType: "char[65]",
+        modifiers: {
+          isConst: true,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: true,
+        },
+        arrayDimensions: ["10"],
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "extern const char messages[10][65]",
+      );
+    });
+
+    it("formats user-defined type variable", () => {
+      const input: IVariableFormatInput = {
+        name: "point",
+        cnextType: "Point",
+        mappedType: "Point",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        },
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe("Point point");
+    });
+
+    it("handles enum dimension identifiers", () => {
+      const input: IVariableFormatInput = {
+        name: "colors",
+        cnextType: "u8",
+        mappedType: "uint8_t",
+        modifiers: {
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: true,
+        },
+        arrayDimensions: ["EColor_COUNT"],
+      };
+
+      expect(VariableDeclarationFormatter.format(input)).toBe(
+        "extern uint8_t colors[EColor_COUNT]",
+      );
+    });
+  });
+
+  describe("buildModifierPrefix", () => {
+    it("returns empty string for no modifiers", () => {
+      expect(
+        VariableDeclarationFormatter.buildModifierPrefix({
+          isConst: false,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        }),
+      ).toBe("");
+    });
+
+    it("builds single modifier", () => {
+      expect(
+        VariableDeclarationFormatter.buildModifierPrefix({
+          isConst: true,
+          isAtomic: false,
+          isVolatile: false,
+          isExtern: false,
+        }),
+      ).toBe("const ");
+    });
+
+    it("builds multiple modifiers in correct order", () => {
+      // Order: extern volatile const (volatile before const)
+      expect(
+        VariableDeclarationFormatter.buildModifierPrefix({
+          isConst: true,
+          isAtomic: true,
+          isVolatile: false,
+          isExtern: true,
+        }),
+      ).toBe("extern volatile const ");
+    });
+  });
+
+  describe("buildArrayDimensions", () => {
+    it("returns empty string for undefined dimensions", () => {
+      expect(VariableDeclarationFormatter.buildArrayDimensions(undefined)).toBe(
+        "",
+      );
+    });
+
+    it("returns empty string for empty array", () => {
+      expect(VariableDeclarationFormatter.buildArrayDimensions([])).toBe("");
+    });
+
+    it("formats single dimension", () => {
+      expect(VariableDeclarationFormatter.buildArrayDimensions(["10"])).toBe(
+        "[10]",
+      );
+    });
+
+    it("formats multiple dimensions", () => {
+      expect(
+        VariableDeclarationFormatter.buildArrayDimensions(["10", "20", "30"]),
+      ).toBe("[10][20][30]");
+    });
+  });
+});

package/src/transpiler/output/codegen/types/IParameterInput.ts

@@ -0,0 +1,58 @@
+/**
+ * Normalized parameter input for signature generation
+ *
+ * This interface serves as the contract between ParameterInputAdapter
+ * (which normalizes AST or symbol data) and ParameterSignatureBuilder
+ * (which generates the final C/C++ parameter string).
+ *
+ * All decisions are pre-computed before reaching the builder:
+ * - Type classification (callback, string, array, etc.)
+ * - Const qualifiers (explicit and auto-inferred)
+ * - Pass-by-value vs pass-by-reference
+ * - Array dimensions
+ */
+interface IParameterInput {
+  /** Parameter name */
+  name: string;
+
+  /** Original C-Next type: 'u32', 'string<32>', 'Point', etc. */
+  baseType: string;
+
+  /** Mapped C type: 'uint32_t', 'char', 'Point', etc. */
+  mappedType: string;
+
+  /** Explicit const modifier from source code */
+  isConst: boolean;
+
+  /** Inferred const for unmodified parameters (computed from CodeGenState.modifiedParameters) */
+  isAutoConst: boolean;
+
+  /** Whether this is an array type */
+  isArray: boolean;
+
+  /** Array dimensions as strings: ['10', '20'] or ['33'] for string capacity */
+  arrayDimensions?: string[];
+
+  /** Whether this is a callback type (from CodeGenState.callbackTypes) */
+  isCallback: boolean;
+
+  /** The typedef name for callback types (e.g., 'HandleClickCallback') */
+  callbackTypedefName?: string;
+
+  /** Whether this is a string type (bounded or unbounded) */
+  isString: boolean;
+
+  /** Whether this is an unbounded string (no capacity) */
+  isUnboundedString?: boolean;
+
+  /** String capacity for non-array strings (used for tracking, not output) */
+  stringCapacity?: number;
+
+  /** Whether to use pass-by-value semantics (ISR, float, enum, small primitive) */
+  isPassByValue: boolean;
+
+  /** Whether to use pass-by-reference semantics (known struct or known primitive) */
+  isPassByReference: boolean;
+}
+
+export default IParameterInput;