c-next 0.1.65 → 0.1.67

package/src/transpiler/output/codegen/helpers/ArrayInitHelper.ts

@@ -12,7 +12,7 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 
 /**
  * Result from processing array initialization.

package/src/transpiler/output/codegen/helpers/AssignmentExpectedTypeResolver.ts

@@ -12,7 +12,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import TOverflowBehavior from "../types/TOverflowBehavior.js";
 import analyzePostfixOps from "../../../../utils/PostfixAnalysisUtils.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 
 /**
  * Result of resolving expected type for an assignment target.

package/src/transpiler/output/codegen/helpers/AssignmentValidator.ts

@@ -17,7 +17,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import TypeValidator from "../TypeValidator.js";
 import EnumAssignmentValidator from "./EnumAssignmentValidator.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 import TypeCheckUtils from "../../../../utils/TypeCheckUtils.js";
 
 /**

package/src/transpiler/output/codegen/helpers/CppModeHelper.ts

@@ -9,7 +9,7 @@
  * Migrated to use CodeGenState instead of constructor DI.
  */
 
-import CodeGenState from "../CodeGenState";
+import CodeGenState from "../../../state/CodeGenState";
 
 /**
  * Static helper class for C/C++ mode-specific code generation patterns.

package/src/transpiler/output/codegen/helpers/EnumAssignmentValidator.ts

@@ -12,7 +12,7 @@
  */
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 import EnumTypeResolver from "../resolution/EnumTypeResolver.js";
 import TypeCheckUtils from "../../../../utils/TypeCheckUtils.js";
 

package/src/transpiler/output/codegen/helpers/FloatBitHelper.ts

@@ -15,7 +15,7 @@
 
 import TTypeInfo from "../types/TTypeInfo.js";
 import TIncludeHeader from "../generators/TIncludeHeader.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 
 /**
  * Callback types for code generation operations.

package/src/transpiler/output/codegen/helpers/ParameterInputAdapter.ts

@@ -0,0 +1,337 @@
+/**
+ * ParameterInputAdapter - Adapts different input formats to IParameterInput
+ *
+ * Provides two conversion methods:
+ * - fromAST(): For CodeGenerator, converts Parser.ParameterContext + CodeGenState
+ * - fromSymbol(): For HeaderGenerator, converts IParameterSymbol
+ *
+ * Both produce normalized IParameterInput for use with ParameterSignatureBuilder.
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import IParameterInput from "../types/IParameterInput";
+import IParameterSymbol from "../../../../utils/types/IParameterSymbol";
+import ICallbackTypeInfo from "../types/ICallbackTypeInfo";
+
+/**
+ * Dependencies required by fromAST() to resolve types and state.
+ * These are passed in to avoid direct dependency on CodeGenState,
+ * making the adapter more testable.
+ */
+interface IFromASTDeps {
+  /** Get C-Next type name from type context (e.g., 'u32', 'Point') */
+  getTypeName: (type: Parser.TypeContext) => string;
+
+  /** Generate C type from type context (e.g., 'uint32_t', 'Point') */
+  generateType: (type: Parser.TypeContext) => string;
+
+  /** Generate expression string (for array dimension expressions) */
+  generateExpression: (expr: Parser.ExpressionContext) => string;
+
+  /** Map of callback type names to their info */
+  callbackTypes: ReadonlyMap<string, ICallbackTypeInfo>;
+
+  /** Check if type is a known struct (C-Next or C header) */
+  isKnownStruct: (typeName: string) => boolean;
+
+  /** TYPE_MAP for primitive detection */
+  typeMap: Record<string, string>;
+
+  /** Whether the parameter is modified in the current function */
+  isModified: boolean;
+
+  /** Whether the parameter should use pass-by-value (pre-computed) */
+  isPassByValue: boolean;
+}
+
+/**
+ * Dependencies required by fromSymbol() to resolve types.
+ * Simpler than AST deps since IParameterSymbol already contains most info.
+ *
+ * The caller (BaseHeaderGenerator) pre-computes isPassByValue including
+ * ISR/float/enum/passByValueSet checks. The adapter trusts this decision.
+ */
+interface IFromSymbolDeps {
+  /** Map C-Next type to C type */
+  mapType: (type: string) => string;
+
+  /** Whether the parameter should use pass-by-value (pre-computed by caller) */
+  isPassByValue: boolean;
+}
+
+/**
+ * Static adapter class for converting different input formats to IParameterInput.
+ */
+class ParameterInputAdapter {
+  /**
+   * Convert AST ParameterContext to normalized IParameterInput.
+   * Used by CodeGenerator.generateParameter().
+   *
+   * Note: Validation (C-style array rejection, unbounded dimension rejection)
+   * should be done BEFORE calling this method.
+   *
+   * @param ctx - The parser context for the parameter
+   * @param deps - Dependencies for type resolution and state lookup
+   * @returns Normalized IParameterInput
+   */
+  static fromAST(
+    ctx: Parser.ParameterContext,
+    deps: IFromASTDeps,
+  ): IParameterInput {
+    const isConst = ctx.constModifier() !== null;
+    const typeName = deps.getTypeName(ctx.type());
+    const name = ctx.IDENTIFIER().getText();
+    const mappedType = deps.generateType(ctx.type());
+
+    // Check for callback type
+    const callbackInfo = deps.callbackTypes.get(typeName);
+    if (callbackInfo) {
+      return this._buildCallbackInput(
+        name,
+        typeName,
+        mappedType,
+        callbackInfo.typedefName,
+      );
+    }
+
+    // Check for array type
+    const arrayTypeCtx = ctx.type().arrayType();
+    if (arrayTypeCtx) {
+      return this._buildArrayInputFromAST(
+        arrayTypeCtx,
+        name,
+        typeName,
+        mappedType,
+        isConst,
+        deps,
+      );
+    }
+
+    // Check for string type (non-array)
+    const stringTypeCtx = ctx.type().stringType();
+    if (stringTypeCtx) {
+      return this._buildStringInput(
+        name,
+        typeName,
+        isConst,
+        deps,
+        stringTypeCtx,
+      );
+    }
+
+    // Determine classification for non-array, non-string types
+    const isKnownStruct = deps.isKnownStruct(typeName);
+    const isKnownPrimitive = !!deps.typeMap[typeName];
+    const isAutoConst = !deps.isModified && !isConst;
+
+    return {
+      name,
+      baseType: typeName,
+      mappedType,
+      isConst,
+      isAutoConst,
+      isArray: false,
+      isCallback: false,
+      isString: false,
+      isPassByValue: deps.isPassByValue,
+      isPassByReference: isKnownStruct || isKnownPrimitive,
+    };
+  }
+
+  /**
+   * Convert IParameterSymbol to normalized IParameterInput.
+   * Used by BaseHeaderGenerator.generateParameter().
+   *
+   * The caller pre-computes isPassByValue (ISR, float, enum, passByValueSet).
+   * Non-PBV, non-array, non-string types use pass-by-reference.
+   *
+   * @param param - The parameter symbol
+   * @param deps - Dependencies for type mapping
+   * @returns Normalized IParameterInput
+   */
+  static fromSymbol(
+    param: IParameterSymbol,
+    deps: IFromSymbolDeps,
+  ): IParameterInput {
+    const mappedType = deps.mapType(param.type);
+
+    // Array parameters
+    if (
+      param.isArray &&
+      param.arrayDimensions &&
+      param.arrayDimensions.length > 0
+    ) {
+      return this._buildArrayInputFromSymbol(param, mappedType);
+    }
+
+    // String type detection
+    const isString =
+      param.type === "string" || param.type.startsWith("string<");
+
+    // Non-array string
+    if (isString && !param.isArray) {
+      return {
+        name: param.name,
+        baseType: param.type,
+        mappedType: "char",
+        isConst: param.isConst,
+        isAutoConst: param.isAutoConst ?? false,
+        isArray: false,
+        isCallback: false,
+        isString: true,
+        isPassByValue: false,
+        isPassByReference: false,
+      };
+    }
+
+    return {
+      name: param.name,
+      baseType: param.type,
+      mappedType,
+      isConst: param.isConst,
+      isAutoConst: param.isAutoConst ?? false,
+      isArray: false,
+      isCallback: false,
+      isString: false,
+      isPassByValue: deps.isPassByValue,
+      isPassByReference: !deps.isPassByValue,
+    };
+  }
+
+  /**
+   * Build IParameterInput for a callback parameter.
+   */
+  private static _buildCallbackInput(
+    name: string,
+    typeName: string,
+    mappedType: string,
+    typedefName: string,
+  ): IParameterInput {
+    return {
+      name,
+      baseType: typeName,
+      mappedType,
+      isConst: false,
+      isAutoConst: false,
+      isArray: false,
+      isCallback: true,
+      callbackTypedefName: typedefName,
+      isString: false,
+      isPassByValue: true, // Callbacks are function pointers, pass by value
+      isPassByReference: false,
+    };
+  }
+
+  /**
+   * Build IParameterInput for an array parameter from AST.
+   */
+  private static _buildArrayInputFromAST(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    name: string,
+    typeName: string,
+    mappedType: string,
+    isConst: boolean,
+    deps: IFromASTDeps,
+  ): IParameterInput {
+    const allDims = arrayTypeCtx.arrayTypeDimension();
+
+    // Build dimension strings
+    const dims: string[] = allDims.map(
+      (d: Parser.ArrayTypeDimensionContext) => {
+        const expr = d.expression();
+        return expr ? deps.generateExpression(expr) : "";
+      },
+    );
+
+    // Check for string array (string<N>[M])
+    const stringTypeCtx = arrayTypeCtx.stringType();
+    const isString = stringTypeCtx !== null;
+
+    if (isString && stringTypeCtx) {
+      const intLiteral = stringTypeCtx.INTEGER_LITERAL();
+      if (intLiteral) {
+        const capacity = Number.parseInt(intLiteral.getText(), 10);
+        dims.push(String(capacity + 1));
+      }
+    }
+
+    const isAutoConst = !deps.isModified && !isConst;
+
+    return {
+      name,
+      baseType: typeName,
+      mappedType,
+      isConst,
+      isAutoConst,
+      isArray: true,
+      arrayDimensions: dims,
+      isCallback: false,
+      isString,
+      isPassByValue: false, // Arrays are always passed by pointer
+      isPassByReference: false,
+    };
+  }
+
+  /**
+   * Build IParameterInput for an array parameter from symbol.
+   */
+  private static _buildArrayInputFromSymbol(
+    param: IParameterSymbol,
+    mappedType: string,
+  ): IParameterInput {
+    const isString =
+      param.type === "string" || param.type.startsWith("string<");
+    const isUnboundedString = param.type === "string"; // No capacity specified
+
+    // For header generator, we need to use char for string arrays
+    const actualMappedType = isString ? "char" : mappedType;
+
+    return {
+      name: param.name,
+      baseType: param.type,
+      mappedType: actualMappedType,
+      isConst: param.isConst,
+      isAutoConst: param.isAutoConst ?? false,
+      isArray: true,
+      arrayDimensions: param.arrayDimensions,
+      isCallback: false,
+      isString,
+      isUnboundedString,
+      isPassByValue: false,
+      isPassByReference: false,
+    };
+  }
+
+  /**
+   * Build IParameterInput for a non-array string parameter.
+   */
+  private static _buildStringInput(
+    name: string,
+    typeName: string,
+    isConst: boolean,
+    deps: IFromASTDeps,
+    stringTypeCtx: Parser.StringTypeContext,
+  ): IParameterInput {
+    const intLiteral = stringTypeCtx.INTEGER_LITERAL();
+    const capacity = intLiteral
+      ? Number.parseInt(intLiteral.getText(), 10)
+      : undefined;
+    const isAutoConst = !deps.isModified && !isConst;
+
+    return {
+      name,
+      baseType: typeName,
+      mappedType: "char",
+      isConst,
+      isAutoConst,
+      isArray: false,
+      isCallback: false,
+      isString: true,
+      stringCapacity: capacity,
+      isPassByValue: false,
+      isPassByReference: false,
+    };
+  }
+}
+
+export default ParameterInputAdapter;

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

@@ -0,0 +1,135 @@
+/**
+ * ParameterSignatureBuilder - Stateless builder for C/C++ parameter signatures
+ *
+ * Takes a normalized IParameterInput and produces the final parameter string.
+ * All decisions (const, pass-by-value, etc.) are pre-computed in the input.
+ *
+ * This is the single source of truth for parameter formatting, used by both:
+ * - CodeGenerator (via ParameterInputAdapter.fromAST)
+ * - BaseHeaderGenerator (via ParameterInputAdapter.fromSymbol)
+ */
+
+import IParameterInput from "../types/IParameterInput";
+
+/**
+ * Static helper class for building C/C++ parameter signature strings.
+ */
+class ParameterSignatureBuilder {
+  /**
+   * Build a parameter signature string from normalized input.
+   *
+   * @param param - Normalized parameter input (all decisions pre-computed)
+   * @param refSuffix - '*' for C mode (pointer), '&' for C++ mode (reference)
+   * @returns The formatted parameter string (e.g., "const uint32_t* value")
+   */
+  static build(param: IParameterInput, refSuffix: string): string {
+    // Callback parameters: just typedef name and param name
+    if (param.isCallback && param.callbackTypedefName) {
+      return `${param.callbackTypedefName} ${param.name}`;
+    }
+
+    // Array parameters with dimensions
+    if (
+      param.isArray &&
+      param.arrayDimensions &&
+      param.arrayDimensions.length > 0
+    ) {
+      return this._buildArrayParam(param);
+    }
+
+    // Pass-by-value parameters (ISR, float, enum, small primitives)
+    if (param.isPassByValue) {
+      return this._buildPassByValueParam(param);
+    }
+
+    // Non-array string: string<N> -> const char* name
+    if (param.isString && !param.isArray) {
+      return this._buildStringParam(param);
+    }
+
+    // Known struct or known primitive: pass by reference
+    if (param.isPassByReference) {
+      return this._buildRefParam(param, refSuffix);
+    }
+
+    // Unknown types: pass by value (standard C semantics)
+    return this._buildUnknownParam(param);
+  }
+
+  /**
+   * Build array parameter signature.
+   * Examples:
+   * - u32[10] arr -> const uint32_t arr[10]
+   * - u8[4][4] matrix -> const uint8_t matrix[4][4]
+   * - string<32>[5] names -> const char names[5][33]
+   * - string[5] names -> char* names[5] (unbounded string array)
+   */
+  private static _buildArrayParam(param: IParameterInput): string {
+    const constPrefix = this._getConstPrefix(param);
+    const dims = param.arrayDimensions!.map((d) => `[${d}]`).join("");
+
+    // Unbounded string arrays use char* (array of char pointers)
+    if (param.isUnboundedString) {
+      return `${constPrefix}char* ${param.name}${dims}`;
+    }
+
+    // Bounded string arrays use char (dimensions include capacity)
+    if (param.isString) {
+      return `${constPrefix}char ${param.name}${dims}`;
+    }
+
+    return `${constPrefix}${param.mappedType} ${param.name}${dims}`;
+  }
+
+  /**
+   * Build pass-by-value parameter signature.
+   * Used for: ISR, f32, f64, enums, small unmodified primitives.
+   * Example: float value, ISR handler, Status s
+   */
+  private static _buildPassByValueParam(param: IParameterInput): string {
+    const constMod = param.isConst ? "const " : "";
+    return `${constMod}${param.mappedType} ${param.name}`;
+  }
+
+  /**
+   * Build non-array string parameter signature.
+   * string<N> -> const char* name (with auto-const if unmodified)
+   */
+  private static _buildStringParam(param: IParameterInput): string {
+    const constPrefix = this._getConstPrefix(param);
+    return `${constPrefix}char* ${param.name}`;
+  }
+
+  /**
+   * Build pass-by-reference parameter signature.
+   * C mode: const Point* p
+   * C++ mode: const Point& p
+   */
+  private static _buildRefParam(
+    param: IParameterInput,
+    refSuffix: string,
+  ): string {
+    const constPrefix = this._getConstPrefix(param);
+    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+  }
+
+  /**
+   * Build unknown type parameter (pass by value, standard C semantics).
+   */
+  private static _buildUnknownParam(param: IParameterInput): string {
+    const constMod = param.isConst ? "const " : "";
+    return `${constMod}${param.mappedType} ${param.name}`;
+  }
+
+  /**
+   * Get const prefix combining explicit const and auto-const.
+   * Auto-const is applied to unmodified parameters.
+   */
+  private static _getConstPrefix(param: IParameterInput): string {
+    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
+    const explicitConst = param.isConst ? "const " : "";
+    return `${autoConst}${explicitConst}`;
+  }
+}
+
+export default ParameterSignatureBuilder;

package/src/transpiler/output/codegen/helpers/StringDeclHelper.ts

@@ -15,7 +15,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import FormatUtils from "../../../../utils/FormatUtils.js";
 import StringUtils from "../../../../utils/StringUtils.js";
-import CodeGenState from "../CodeGenState.js";
+import CodeGenState from "../../../state/CodeGenState.js";
 
 /** C null terminator character literal for generated code */
 const C_NULL_CHAR = String.raw`'\0'`;

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

@@ -0,0 +1,118 @@
+/**
+ * VariableDeclarationFormatter - Unified variable declaration string generation.
+ *
+ * Phase 2 of unified code generation: Provides a single source of truth for
+ * variable declaration formatting, eliminating sync issues between
+ * CodeGenerator and HeaderGeneratorUtils.
+ *
+ * Handles:
+ * - Modifier ordering (extern const volatile)
+ * - Type formatting with embedded dimensions (string<N> → char[N+1])
+ * - Array dimension placement after variable name
+ *
+ * This class is STATELESS - all decisions are pre-computed in IVariableFormatInput.
+ */
+
+import type IVariableFormatInput from "../types/IVariableFormatInput";
+
+/** Modifier flags for variable declarations */
+type IVariableModifiers = IVariableFormatInput["modifiers"];
+
+class VariableDeclarationFormatter {
+  /**
+   * Format a variable declaration string.
+   *
+   * @param input - Normalized variable declaration input (all decisions pre-computed)
+   * @returns Formatted declaration string (e.g., "extern const uint32_t count")
+   */
+  static format(input: IVariableFormatInput): string {
+    const modifierPrefix = VariableDeclarationFormatter.buildModifierPrefix(
+      input.modifiers,
+    );
+    const arrayDimsStr = VariableDeclarationFormatter.buildArrayDimensions(
+      input.arrayDimensions,
+    );
+
+    // Handle types with embedded dimensions (e.g., char[33] from string<32>)
+    // In C, array dimensions follow the variable name, not the type
+    return VariableDeclarationFormatter.formatWithEmbeddedDimensions(
+      modifierPrefix,
+      input.mappedType,
+      input.name,
+      arrayDimsStr,
+    );
+  }
+
+  /**
+   * Build the modifier prefix string with consistent ordering.
+   *
+   * Order: extern volatile const
+   * - Matches the established C-Next output format
+   * - atomic maps to volatile, so atomic and volatile are mutually exclusive
+   * - The caller should validate this before calling
+   */
+  static buildModifierPrefix(modifiers: IVariableModifiers): string {
+    const parts: string[] = [];
+
+    if (modifiers.isExtern) {
+      parts.push("extern");
+    }
+    // atomic and volatile both map to volatile in C
+    // volatile comes before const to match established format
+    if (modifiers.isAtomic || modifiers.isVolatile) {
+      parts.push("volatile");
+    }
+    if (modifiers.isConst) {
+      parts.push("const");
+    }
+
+    return parts.length > 0 ? parts.join(" ") + " " : "";
+  }
+
+  /**
+   * Build array dimension string from dimensions array.
+   *
+   * @param dimensions - Array of dimension strings (e.g., ['10', '20'])
+   * @returns Formatted dimensions (e.g., '[10][20]')
+   */
+  static buildArrayDimensions(dimensions?: string[]): string {
+    if (!dimensions || dimensions.length === 0) {
+      return "";
+    }
+    return dimensions.map((d) => `[${d}]`).join("");
+  }
+
+  /**
+   * Format declaration handling types with embedded array dimensions.
+   *
+   * Handles types like char[33] from string<32> where the dimension is
+   * embedded in the mapped type. In C, array dimensions must follow the
+   * variable name:
+   *   char greeting[33];      // Correct
+   *   char[33] greeting;      // Wrong
+   *
+   * For string arrays (string<32>[5] names), produces:
+   *   char names[5][33];      // Additional dims first, embedded dim last
+   */
+  private static formatWithEmbeddedDimensions(
+    modifierPrefix: string,
+    mappedType: string,
+    name: string,
+    additionalDims: string,
+  ): string {
+    // 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(mappedType);
+    if (embeddedMatch) {
+      const baseType = embeddedMatch[1];
+      const embeddedDim = embeddedMatch[2];
+      // Format: modifiers baseType name[additionalDims][embeddedDim]
+      return `${modifierPrefix}${baseType} ${name}${additionalDims}[${embeddedDim}]`;
+    }
+
+    // No embedded dimensions - standard format
+    return `${modifierPrefix}${mappedType} ${name}${additionalDims}`;
+  }
+}
+
+export default VariableDeclarationFormatter;

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

@@ -7,7 +7,7 @@
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import ArrayInitHelper from "../ArrayInitHelper.js";
-import CodeGenState from "../../CodeGenState.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
 
 /**
  * Default callbacks for testing.

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import AssignmentExpectedTypeResolver from "../AssignmentExpectedTypeResolver.js";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
-import CodeGenState from "../../CodeGenState.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
 
 /**
  * Create a mock assignment target context by parsing a minimal assignment statement.

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

@@ -3,7 +3,7 @@ import AssignmentValidator from "../AssignmentValidator.js";
 import TypeValidator from "../../TypeValidator.js";
 import EnumAssignmentValidator from "../EnumAssignmentValidator.js";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
-import CodeGenState from "../../CodeGenState.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
 
 /**
  * Create a mock assignment target context by parsing a minimal assignment statement.