c-next 0.1.64 → 0.1.66

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

@@ -0,0 +1,51 @@
+/**
+ * IVariableFormatInput - Normalized input for variable declaration formatting.
+ *
+ * Phase 2 of unified code generation: Provides a single source of truth for
+ * variable declaration string generation, eliminating sync issues between
+ * .c/.cpp and .h/.hpp files.
+ *
+ * Unlike parameters (which have complex pass-by-value/reference semantics),
+ * variable declarations focus on:
+ * - Modifier ordering (extern, const, volatile)
+ * - Type formatting (including string<N> → char[N+1])
+ * - Array dimension placement
+ */
+
+/**
+ * Modifier flags for variable declarations.
+ * These are resolved before formatting - no CodeGenState access needed.
+ */
+interface IVariableModifiers {
+  /** Explicit const modifier */
+  isConst: boolean;
+  /** atomic modifier (maps to volatile in C) */
+  isAtomic: boolean;
+  /** Explicit volatile modifier */
+  isVolatile: boolean;
+  /** extern linkage (for headers or top-level const in C++) */
+  isExtern: boolean;
+}
+
+/**
+ * Normalized input for variable declaration formatting.
+ * All fields are pre-computed - the formatter is stateless.
+ */
+interface IVariableFormatInput {
+  /** Variable name */
+  name: string;
+
+  /** Original C-Next type (e.g., 'u32', 'string<32>') */
+  cnextType: string;
+
+  /** Mapped C type (e.g., 'uint32_t', 'char[33]') */
+  mappedType: string;
+
+  /** Pre-resolved modifier flags */
+  modifiers: IVariableModifiers;
+
+  /** Array dimensions as strings (e.g., ['10', '20']) */
+  arrayDimensions?: string[];
+}
+
+export default IVariableFormatInput;

package/src/transpiler/output/headers/BaseHeaderGenerator.ts

@@ -12,6 +12,9 @@ import IHeaderOptions from "../codegen/types/IHeaderOptions";
 import IHeaderTypeInput from "./generators/IHeaderTypeInput";
 import typeUtils from "./generators/mapType";
 import HeaderGeneratorUtils from "./HeaderGeneratorUtils";
+// Unified parameter generation (Phase 1)
+import ParameterInputAdapter from "../codegen/helpers/ParameterInputAdapter";
+import ParameterSignatureBuilder from "../codegen/helpers/ParameterSignatureBuilder";
 
 const { mapType } = typeUtils;
 
@@ -184,41 +187,23 @@ abstract class BaseHeaderGenerator {
     passByValueSet?: ReadonlySet<string>,
     allKnownEnums?: ReadonlySet<string>,
   ): string {
-    const baseType = mapType(p.type);
-    const constMod = p.isConst ? "const " : "";
-    const autoConst = p.isAutoConst ? "const " : "";
-
-    // Array parameters - pass naturally as pointers per C semantics
-    if (p.isArray && p.arrayDimensions) {
-      const dims = p.arrayDimensions.map((d) => `[${d}]`).join("");
-      if (p.type === "string") {
-        return `${autoConst}${constMod}char* ${p.name}${dims}`;
-      }
-      return `${autoConst}${constMod}${baseType} ${p.name}${dims}`;
-    }
-
-    // ISR is a function pointer typedef - no pointer needed
-    if (p.type === "ISR") {
-      return `${constMod}${baseType} ${p.name}`;
-    }
-
-    // Float types use standard pass-by-value
-    if (p.type === "f32" || p.type === "f64") {
-      return `${constMod}${baseType} ${p.name}`;
-    }
-
-    // Enum types use pass-by-value (like primitives)
-    if (allKnownEnums?.has(p.type)) {
-      return `${constMod}${baseType} ${p.name}`;
-    }
-
-    // Check if parameter should be passed by value
-    if (passByValueSet?.has(p.name)) {
-      return `${constMod}${baseType} ${p.name}`;
-    }
-
-    // Default: pass by reference using subclass-specific semantics
-    return `${autoConst}${constMod}${baseType}${this.getRefSuffix()} ${p.name}`;
+    // Pre-compute pass-by-value (ISR, float, enum, or explicitly marked)
+    const isPassByValue =
+      p.type === "ISR" ||
+      p.type === "f32" ||
+      p.type === "f64" ||
+      allKnownEnums?.has(p.type) ||
+      passByValueSet?.has(p.name) ||
+      false;
+
+    // Build normalized input using adapter
+    const input = ParameterInputAdapter.fromSymbol(p, {
+      mapType: (t) => mapType(t),
+      isPassByValue,
+    });
+
+    // Use shared builder with subclass-specific ref suffix
+    return ParameterSignatureBuilder.build(input, this.getRefSuffix());
   }
 }
 

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

@@ -16,6 +16,8 @@ import IHeaderTypeInput from "./generators/IHeaderTypeInput";
 import generateEnumHeader from "./generators/generateEnumHeader";
 import generateStructHeader from "./generators/generateStructHeader";
 import generateBitmapHeader from "./generators/generateBitmapHeader";
+import VariableDeclarationFormatter from "../codegen/helpers/VariableDeclarationFormatter";
+import type IVariableFormatInput from "../codegen/types/IVariableFormatInput";
 
 const { mapType, isBuiltInType } = typeUtils;
 
@@ -202,39 +204,6 @@ class HeaderGeneratorUtils {
     );
   }
 
-  /**
-   * Format a variable declaration with proper C syntax
-   *
-   * In C, array dimensions follow the variable name, not the type:
-   *   char greeting[33];      // Correct
-   *   char[33] greeting;      // Wrong
-   *
-   * Handles types that include embedded dimensions (like char[33] from
-   * mapType("string<32>")) and places them correctly after the variable name.
-   */
-  static formatVariableDeclaration(
-    cnextType: string,
-    name: string,
-    additionalDims: string,
-    constPrefix: string,
-    volatilePrefix: string = "",
-  ): string {
-    const cType = mapType(cnextType);
-
-    // Check if the mapped type has embedded array dimensions (e.g., char[33])
-    // This happens for string<N> types which map to char[N+1]
-    const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
-    if (embeddedMatch) {
-      const baseType = embeddedMatch[1];
-      const embeddedDim = embeddedMatch[2];
-      // Format: volatile const char name[additionalDims][embeddedDim]
-      return `${volatilePrefix}${constPrefix}${baseType} ${name}${additionalDims}[${embeddedDim}]`;
-    }
-
-    // No embedded dimensions - standard format
-    return `${volatilePrefix}${constPrefix}${cType} ${name}${additionalDims}`;
-  }
-
   /**
    * Build headers to include from external type header mappings
    */
@@ -460,6 +429,8 @@ class HeaderGeneratorUtils {
 
   /**
    * Generate extern variable declarations section
+   *
+   * Uses VariableDeclarationFormatter for consistent formatting with CodeGenerator.
    */
   static generateVariableSection(variables: ISymbol[]): string[] {
     if (variables.length === 0) {
@@ -468,21 +439,23 @@ class HeaderGeneratorUtils {
 
     const lines: string[] = ["/* External variables */"];
     for (const sym of variables) {
-      const constPrefix = sym.isConst ? "const " : "";
-      const volatilePrefix = sym.isAtomic ? "volatile " : "";
-      const arrayDims =
-        sym.isArray && sym.arrayDimensions
-          ? sym.arrayDimensions.map((d) => `[${d}]`).join("")
-          : "";
-
-      const declaration = HeaderGeneratorUtils.formatVariableDeclaration(
-        sym.type || "int",
-        sym.name,
-        arrayDims,
-        constPrefix,
-        volatilePrefix,
-      );
-      lines.push(`extern ${declaration};`);
+      // Build normalized input for the unified formatter
+      const input: IVariableFormatInput = {
+        name: sym.name,
+        cnextType: sym.type || "int",
+        mappedType: mapType(sym.type || "int"),
+        modifiers: {
+          isConst: sym.isConst ?? false,
+          isAtomic: sym.isAtomic ?? false,
+          isVolatile: false, // C-Next uses atomic, not volatile directly
+          isExtern: true, // Headers always use extern
+        },
+        arrayDimensions:
+          sym.isArray && sym.arrayDimensions ? sym.arrayDimensions : undefined,
+      };
+
+      const declaration = VariableDeclarationFormatter.format(input);
+      lines.push(`${declaration};`);
     }
     lines.push("");
     return lines;

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

@@ -181,70 +181,6 @@ describe("HeaderGeneratorUtils", () => {
     });
   });
 
-  describe("formatVariableDeclaration", () => {
-    it("formats simple declaration", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration("u32", "count", "", ""),
-      ).toBe("uint32_t count");
-    });
-
-    it("formats declaration with const", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration(
-          "u32",
-          "count",
-          "",
-          "const ",
-        ),
-      ).toBe("const uint32_t count");
-    });
-
-    it("formats declaration with volatile", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration(
-          "u32",
-          "count",
-          "",
-          "",
-          "volatile ",
-        ),
-      ).toBe("volatile uint32_t count");
-    });
-
-    it("formats declaration with array dimensions", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration(
-          "u32",
-          "values",
-          "[10]",
-          "",
-        ),
-      ).toBe("uint32_t values[10]");
-    });
-
-    it("formats string<N> type with embedded dimension", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration(
-          "string<32>",
-          "name",
-          "",
-          "",
-        ),
-      ).toBe("char name[33]");
-    });
-
-    it("formats string<N> array with additional dimensions", () => {
-      expect(
-        HeaderGeneratorUtils.formatVariableDeclaration(
-          "string<16>",
-          "labels",
-          "[3]",
-          "",
-        ),
-      ).toBe("char labels[3][17]");
-    });
-  });
-
   describe("getLocalTypeNames", () => {
     it("extracts local type names from grouped symbols", () => {
       const groups = {