c-next 0.1.65 → 0.1.67

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

@@ -0,0 +1,57 @@
+/**
+ * Interface for CodeGenerator methods accessible via CodeGenState.generator.
+ *
+ * Defines the subset of CodeGenerator methods needed by assignment handlers.
+ * Handlers cast CodeGenState.generator to this interface.
+ */
+import type TTypeInfo from "./TTypeInfo";
+
+interface ICodeGenApi {
+  /** Generate C expression from AST context */
+  generateExpression(ctx: unknown): string;
+
+  /** Generate assignment target (lvalue) from AST context */
+  generateAssignmentTarget(ctx: unknown): string;
+
+  /** Try to evaluate expression as compile-time constant */
+  tryEvaluateConstant(ctx: unknown): number | undefined;
+
+  /** Generate atomic read-modify-write operation */
+  generateAtomicRMW(
+    target: string,
+    op: string,
+    value: string,
+    typeInfo: TTypeInfo,
+  ): string;
+
+  /** Generate float bit write operation (returns null if not applicable) */
+  generateFloatBitWrite(
+    name: string,
+    typeInfo: TTypeInfo,
+    bitIndex: string,
+    width: string | null,
+    value: string,
+  ): string | null;
+
+  /** Validate cross-scope member visibility */
+  validateCrossScopeVisibility(scopeName: string, memberName: string): void;
+
+  /** Analyze member chain for bit access patterns */
+  analyzeMemberChainForBitAccess(ctx: unknown): {
+    isBitAccess: boolean;
+    baseTarget?: string;
+    bitIndex?: string;
+    baseType?: string;
+  };
+
+  /** Get type info for struct member */
+  getMemberTypeInfo(structType: string, fieldName: string): TTypeInfo | null;
+
+  /** Check if name is a known scope */
+  isKnownScope(name: string): boolean;
+
+  /** Check if name is a known struct */
+  isKnownStruct(name: string): boolean;
+}
+
+export default ICodeGenApi;

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;

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 = {

package/src/transpiler/{output/codegen → state}/CodeGenState.ts

@@ -5,26 +5,31 @@
  * Eliminates dependency injection complexity and makes debugging easier.
  *
  * Usage:
- *   import CodeGenState from "./CodeGenState";
+ *   import CodeGenState from "../state/CodeGenState";
  *   const type = CodeGenState.typeRegistry.get(name);
  *   if (CodeGenState.isKnownStruct(name)) { ... }
  *
  * Lifecycle:
  *   1. CodeGenerator.generate() calls CodeGenState.reset()
- *   2. CodeGenerator populates state during initialization
+ *   2. CodeGenerator sets CodeGenState.generator = this
  *   3. All generators/helpers read from CodeGenState directly
  *   4. State persists for the duration of one generate() call
+ *
+ * SymbolTable ownership:
+ *   CodeGenState owns the single SymbolTable instance. It persists across
+ *   reset() calls (which are per-file). The Transpiler clears it via
+ *   CodeGenState.symbolTable.clear() at the start of each run().
  */
 
-import SymbolTable from "../../logic/symbols/SymbolTable";
-import ICodeGenSymbols from "../../types/ICodeGenSymbols";
-import TTypeInfo from "./types/TTypeInfo";
-import TParameterInfo from "./types/TParameterInfo";
-import IFunctionSignature from "./types/IFunctionSignature";
-import ICallbackTypeInfo from "./types/ICallbackTypeInfo";
-import ITargetCapabilities from "./types/ITargetCapabilities";
-import TOverflowBehavior from "./types/TOverflowBehavior";
-import TYPE_WIDTH from "./types/TYPE_WIDTH";
+import SymbolTable from "../logic/symbols/SymbolTable";
+import ICodeGenSymbols from "../types/ICodeGenSymbols";
+import TTypeInfo from "../output/codegen/types/TTypeInfo";
+import TParameterInfo from "../output/codegen/types/TParameterInfo";
+import IFunctionSignature from "../output/codegen/types/IFunctionSignature";
+import ICallbackTypeInfo from "../output/codegen/types/ICallbackTypeInfo";
+import ITargetCapabilities from "../output/codegen/types/ITargetCapabilities";
+import TOverflowBehavior from "../output/codegen/types/TOverflowBehavior";
+import TYPE_WIDTH from "../output/codegen/types/TYPE_WIDTH";
 
 /**
  * Default target capabilities (safe fallback)
@@ -62,6 +67,16 @@ interface ICallGraphEntry {
  * during code generation.
  */
 export default class CodeGenState {
+  // ===========================================================================
+  // GENERATOR REFERENCE (for handler access)
+  // ===========================================================================
+
+  /**
+   * Reference to the CodeGenerator instance for handlers to call methods.
+   * Typed as unknown to avoid circular dependencies - handlers cast as needed.
+   */
+  static generator: unknown = null;
+
   // ===========================================================================
   // SYMBOL DATA (read-only after initialization)
   // ===========================================================================
@@ -69,8 +84,11 @@ export default class CodeGenState {
   /** ADR-055: Pre-collected symbol info from CNextResolver + TSymbolInfoAdapter */
   static symbols: ICodeGenSymbols | null = null;
 
-  /** External symbol table for cross-language interop (C headers) */
-  static symbolTable: SymbolTable | null = null;
+  /** External symbol table for cross-language interop (C headers).
+   * Owned by CodeGenState; persists across per-file reset() calls.
+   * Cleared via symbolTable.clear() at the start of each Transpiler run.
+   */
+  static symbolTable: SymbolTable = new SymbolTable();
 
   // ===========================================================================
   // TYPE TRACKING
@@ -277,9 +295,13 @@ export default class CodeGenState {
    * Called at the start of CodeGenerator.generate()
    */
   static reset(targetCapabilities?: ITargetCapabilities): void {
+    // Generator reference
+    this.generator = null;
+
     // Symbol data
     this.symbols = null;
-    this.symbolTable = null;
+    // Note: symbolTable is NOT reset here — it persists across per-file generates.
+    // It is cleared via symbolTable.clear() at the start of each Transpiler run.
 
     // Type tracking
     this.typeRegistry = new Map();
@@ -388,7 +410,7 @@ export default class CodeGenState {
   static isKnownStruct(name: string): boolean {
     if (this.symbols?.knownStructs.has(name)) return true;
     if (this.symbols?.knownBitmaps.has(name)) return true;
-    if (this.symbolTable?.getStructFields?.(name)) return true;
+    if (this.symbolTable.getStructFields(name)) return true;
     return false;
   }
 
@@ -553,17 +575,15 @@ export default class CodeGenState {
     fieldName: string,
   ): { type: string; dimensions?: (number | string)[] } | null {
     // First check SymbolTable (C header structs)
-    if (this.symbolTable) {
-      const fieldInfo = this.symbolTable.getStructFieldInfo(
-        structType,
-        fieldName,
-      );
-      if (fieldInfo) {
-        return {
-          type: fieldInfo.type,
-          dimensions: fieldInfo.arrayDimensions,
-        };
-      }
+    const fieldInfo = this.symbolTable.getStructFieldInfo(
+      structType,
+      fieldName,
+    );
+    if (fieldInfo) {
+      return {
+        type: fieldInfo.type,
+        dimensions: fieldInfo.arrayDimensions,
+      };
     }
 
     // Fall back to local C-Next struct fields

package/src/transpiler/{output/codegen → state}/__tests__/CodeGenState.test.ts

@@ -4,8 +4,8 @@
 
 import { describe, it, expect, beforeEach } from "vitest";
 import CodeGenState from "../CodeGenState";
-import TTypeInfo from "../types/TTypeInfo";
-import ICodeGenSymbols from "../../../types/ICodeGenSymbols";
+import TTypeInfo from "../../output/codegen/types/TTypeInfo";
+import ICodeGenSymbols from "../../types/ICodeGenSymbols";
 
 /**
  * Create a minimal mock ICodeGenSymbols with default empty collections.
@@ -76,6 +76,16 @@ describe("CodeGenState", () => {
       expect(CodeGenState.indentLevel).toBe(0);
     });
 
+    it("resets generator reference", () => {
+      // Simulate having a generator set
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      CodeGenState.generator = {} as any;
+
+      CodeGenState.reset();
+
+      expect(CodeGenState.generator).toBeNull();
+    });
+
     it("accepts custom target capabilities", () => {
       const customTarget = {
         hasFPU: true,