c-next 0.1.64 → 0.1.66

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -134,6 +134,9 @@ import TypeGenerationHelper from "./helpers/TypeGenerationHelper";
 import CastValidator from "./helpers/CastValidator";
 // Global state for code generation (simplifies debugging, eliminates DI complexity)
 import CodeGenState from "./CodeGenState";
+// Unified parameter generation (Phase 1)
+import ParameterInputAdapter from "./helpers/ParameterInputAdapter";
+import ParameterSignatureBuilder from "./helpers/ParameterSignatureBuilder";
 // Extracted resolvers that use CodeGenState
 import SizeofResolver from "./resolution/SizeofResolver";
 import EnumTypeResolver from "./resolution/EnumTypeResolver";
@@ -802,30 +805,54 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Issue #137: Check for array element access (e.g., names[0], arr[i])
+    return this._isArrayAccessStringExpression(text);
+  }
+
+  /**
+   * Check if array access expression evaluates to a string.
+   * Extracted from isStringExpression to reduce cognitive complexity.
+   */
+  private _isArrayAccessStringExpression(text: string): boolean {
     // Pattern: identifier[expression] or identifier[expression][expression]...
     // BUT NOT if accessing .length/.capacity/.size (those return numbers, not strings)
     const arrayAccessMatch = /^([a-zA-Z_]\w*)\[/.exec(text);
-    if (arrayAccessMatch) {
-      // ADR-045: String properties return numeric values, not strings
-      if (
-        text.endsWith(".length") ||
-        text.endsWith(".capacity") ||
-        text.endsWith(".size")
-      ) {
-        return false;
-      }
-      const arrayName = arrayAccessMatch[1];
-      const typeInfo = CodeGenState.typeRegistry.get(arrayName);
-      // Check if base type is a string type
-      if (
-        typeInfo?.isString ||
-        (typeInfo?.baseType && TypeCheckUtils.isString(typeInfo.baseType))
-      ) {
-        return true;
-      }
+    if (!arrayAccessMatch) {
+      return false;
     }
 
-    return false;
+    // ADR-045: String properties return numeric values, not strings
+    if (
+      text.endsWith(".length") ||
+      text.endsWith(".capacity") ||
+      text.endsWith(".size")
+    ) {
+      return false;
+    }
+
+    const arrayName = arrayAccessMatch[1];
+    const typeInfo = CodeGenState.typeRegistry.get(arrayName);
+    if (!typeInfo) {
+      return false;
+    }
+
+    // Check if it's an ARRAY OF STRINGS (not a single string being indexed)
+    // A single string<50> has arrayDimensions=[51] (just the char buffer)
+    // An array of strings string<50>[10] has arrayDimensions=[10, 51]
+    // Single string indexing (e.g., userName[i]) returns a char, not a string
+    // Array of strings indexing (e.g., names[0]) returns a string
+    if (typeInfo.isString) {
+      // For strings, only treat as string expression if it's an array of strings
+      // (arrayDimensions.length > 1 means it's string<N>[M], not just string<N>)
+      const dims = typeInfo.arrayDimensions;
+      return Array.isArray(dims) && dims.length > 1;
+    }
+
+    // Non-string array with string base type
+    return Boolean(
+      typeInfo.isArray &&
+      typeInfo.baseType &&
+      TypeCheckUtils.isString(typeInfo.baseType),
+    );
   }
 
   /**
@@ -1505,7 +1532,9 @@ export default class CodeGenerator implements IOrchestrator {
                 return `${constMod}${p.type} ${p.name}${p.arrayDims}`;
               } else if (p.isPointer) {
                 // ADR-006: Non-array, non-callback parameters become pointers
-                return `${constMod}${p.type}*`;
+                // In C++ mode, use reference (&) instead of pointer (*)
+                const ptrOrRef = this.isCppMode() ? "&" : "*";
+                return `${constMod}${p.type}${ptrOrRef}`;
               } else {
                 // ADR-029: Callback parameters are already function pointers
                 return `${p.type}`;
@@ -2373,9 +2402,13 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private addGeneratedHelpers(output: string[]): void {
     if (CodeGenState.needsFloatStaticAssert) {
+      // Use static_assert for C++ (standard), _Static_assert for C11
+      const assertKeyword = this.isCppMode()
+        ? "static_assert"
+        : "_Static_assert";
       output.push(
-        '_Static_assert(sizeof(float) == 4, "Float bit indexing requires 32-bit float");',
-        '_Static_assert(sizeof(double) == 8, "Float bit indexing requires 64-bit double");',
+        `${assertKeyword}(sizeof(float) == 4, "Float bit indexing requires 32-bit float");`,
+        `${assertKeyword}(sizeof(double) == 8, "Float bit indexing requires 64-bit double");`,
         "",
       );
     }
@@ -3579,7 +3612,12 @@ export default class CodeGenerator implements IOrchestrator {
   private _parseArrayTypeDimensionFromCtx(
     arrayTypeCtx: Parser.ArrayTypeContext,
   ): number | undefined {
-    const sizeExpr = arrayTypeCtx.expression();
+    // Get first dimension for backwards compatibility
+    const dims = arrayTypeCtx.arrayTypeDimension();
+    if (dims.length === 0) {
+      return undefined;
+    }
+    const sizeExpr = dims[0].expression();
     if (!sizeExpr) {
       return undefined;
     }
@@ -3596,12 +3634,14 @@ export default class CodeGenerator implements IOrchestrator {
   ): number[] {
     const arrayDimensions: number[] = [];
 
-    // Get dimension from array type syntax
-    const sizeExpr = arrayTypeCtx.expression();
-    if (sizeExpr) {
-      const size = Number.parseInt(sizeExpr.getText(), 10);
-      if (!Number.isNaN(size)) {
-        arrayDimensions.push(size);
+    // Get all dimensions from array type syntax (supports multi-dimensional)
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const sizeExpr = dim.expression();
+      if (sizeExpr) {
+        const size = Number.parseInt(sizeExpr.getText(), 10);
+        if (!Number.isNaN(size)) {
+          arrayDimensions.push(size);
+        }
       }
     }
 
@@ -3671,7 +3711,9 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private _processParameter(param: Parser.ParameterContext): void {
     const name = param.IDENTIFIER().getText();
-    const isArray = param.arrayDimension().length > 0;
+    // Check both C-Next style (u8[8] param) and legacy style (u8 param[8])
+    const isArray =
+      param.arrayDimension().length > 0 || param.type().arrayType() !== null;
     const isConst = param.constModifier() !== null;
     const typeCtx = param.type();
 
@@ -3768,6 +3810,38 @@ export default class CodeGenerator implements IOrchestrator {
       };
     }
 
+    // Handle C-Next style array type (u8[8] param) - extract base type
+    if (typeCtx.arrayType()) {
+      const arrayTypeCtx = typeCtx.arrayType()!;
+      if (arrayTypeCtx.primitiveType()) {
+        return {
+          typeName: arrayTypeCtx.primitiveType()!.getText(),
+          isStruct: false,
+          isCallback: false,
+          isString: false,
+        };
+      }
+      if (arrayTypeCtx.userType()) {
+        const typeName = arrayTypeCtx.userType()!.getText();
+        return {
+          typeName,
+          isStruct: this.isStructType(typeName),
+          isCallback: CodeGenState.callbackTypes.has(typeName),
+          isString: false,
+        };
+      }
+      // Handle string array type (string<32>[5] param)
+      if (arrayTypeCtx.stringType()) {
+        const stringCtx = arrayTypeCtx.stringType()!;
+        return {
+          typeName: stringCtx.getText(), // "string<32>"
+          isStruct: false,
+          isCallback: false,
+          isString: true,
+        };
+      }
+    }
+
     // Fallback
     return {
       typeName: typeCtx.getText(),
@@ -3777,6 +3851,37 @@ export default class CodeGenerator implements IOrchestrator {
     };
   }
 
+  /**
+   * Extract array dimensions from parameter (C-style or C-Next style).
+   */
+  private _extractParamArrayDimensions(
+    param: Parser.ParameterContext,
+    typeCtx: Parser.TypeContext,
+    isArray: boolean,
+  ): number[] {
+    if (!isArray) return [];
+
+    // Try C-style first (param.arrayDimension())
+    if (param.arrayDimension().length > 0) {
+      return ArrayDimensionParser.parseForParameters(param.arrayDimension());
+    }
+
+    // C-Next style: get dimensions from arrayType
+    const arrayTypeCtx = typeCtx.arrayType();
+    if (!arrayTypeCtx) return [];
+
+    const dimensions: number[] = [];
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const expr = dim.expression();
+      if (!expr) continue;
+      const size = Number.parseInt(expr.getText(), 10);
+      if (!Number.isNaN(size)) {
+        dimensions.push(size);
+      }
+    }
+    return dimensions;
+  }
+
   /**
    * Register a parameter in the type registry
    */
@@ -3794,11 +3899,13 @@ export default class CodeGenerator implements IOrchestrator {
     const isBitmap = CodeGenState.symbols!.knownBitmaps.has(typeName);
 
     // Extract array dimensions
-    const arrayDimensions = isArray
-      ? ArrayDimensionParser.parseForParameters(param.arrayDimension())
-      : [];
+    const arrayDimensions = this._extractParamArrayDimensions(
+      param,
+      typeCtx,
+      isArray,
+    );
 
-    // Get string capacity if applicable
+    // Add string capacity dimension if applicable
     const stringCapacity = this._getStringCapacity(typeCtx, isString);
     if (isArray && stringCapacity !== undefined) {
       arrayDimensions.push(stringCapacity + 1);
@@ -3830,10 +3937,25 @@ export default class CodeGenerator implements IOrchestrator {
     typeCtx: Parser.TypeContext,
     isString: boolean,
   ): number | undefined {
-    if (!isString || !typeCtx.stringType()) return undefined;
-    const intLiteral = typeCtx.stringType()!.INTEGER_LITERAL();
-    if (!intLiteral) return undefined;
-    return Number.parseInt(intLiteral.getText(), 10);
+    if (!isString) return undefined;
+
+    // Check direct stringType (e.g., string<32> param)
+    if (typeCtx.stringType()) {
+      const intLiteral = typeCtx.stringType()!.INTEGER_LITERAL();
+      if (intLiteral) {
+        return Number.parseInt(intLiteral.getText(), 10);
+      }
+    }
+
+    // Check arrayType with stringType (e.g., string<32>[5] param)
+    if (typeCtx.arrayType()?.stringType()) {
+      const intLiteral = typeCtx.arrayType()!.stringType()!.INTEGER_LITERAL();
+      if (intLiteral) {
+        return Number.parseInt(intLiteral.getText(), 10);
+      }
+    }
+
+    return undefined;
   }
 
   /**
@@ -3930,7 +4052,14 @@ export default class CodeGenerator implements IOrchestrator {
         if (dims.length > 0) {
           arrayDims = dims.map((d) => this.generateArrayDimension(d)).join("");
         } else if (arrayTypeCtx) {
-          arrayDims = `[${this.generateExpression(arrayTypeCtx.expression())}]`;
+          // Generate all dimensions from arrayType (supports multi-dimensional)
+          arrayDims = arrayTypeCtx
+            .arrayTypeDimension()
+            .map((d) => {
+              const expr = d.expression();
+              return expr ? `[${this.generateExpression(expr)}]` : "[]";
+            })
+            .join("");
         } else {
           arrayDims = "";
         }
@@ -5177,100 +5306,76 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   private generateParameter(ctx: Parser.ParameterContext): string {
-    const constMod = ctx.constModifier() ? "const " : "";
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
-    const dims = ctx.arrayDimension();
-
-    // ADR-029: Check if this is a callback type parameter
-    if (CodeGenState.callbackTypes.has(typeName)) {
-      const callbackInfo = CodeGenState.callbackTypes.get(typeName)!;
-      return `${callbackInfo.typedefName} ${name}`;
-    }
-
-    const type = this.generateType(ctx.type());
 
-    // Handle C-Next style array type in parameter (e.g., u8[8] param)
-    const arrayTypeCtx = ctx.type().arrayType();
-    if (arrayTypeCtx) {
-      const dimExpr = this.generateExpression(arrayTypeCtx.expression());
-      const wasModified = this._isCurrentParameterModified(name);
-      const autoConst = !wasModified && !constMod ? "const " : "";
-      return `${autoConst}${constMod}${type} ${name}[${dimExpr}]`;
-    }
+    // Validate: Reject C-style array parameters
+    this._validateCStyleArrayParam(ctx, typeName, name);
 
-    // Try special cases first
-    const stringArrayResult = this._tryGenerateStringArrayParam(
-      ctx,
-      constMod,
-      name,
-      dims,
-    );
-    if (stringArrayResult) return stringArrayResult;
+    // Validate: Reject unbounded array dimensions
+    this._validateUnboundedArrayParam(ctx);
 
-    const arrayResult = this._tryGenerateArrayParam(constMod, type, name, dims);
-    if (arrayResult) return arrayResult;
+    // Pre-compute CodeGenState-dependent values
+    const isModified = this._isCurrentParameterModified(name);
+    const isPassByValue = this._isPassByValueType(typeName, name);
 
-    // Pass-by-value types
-    if (this._isPassByValueType(typeName, name)) {
-      return `${constMod}${type} ${name}`;
-    }
-
-    // Non-array string parameters
-    const stringResult = this._tryGenerateStringParam(
-      ctx,
-      constMod,
-      name,
-      dims,
-    );
-    if (stringResult) return stringResult;
-
-    // Pass-by-reference types
-    const refResult = this._tryGenerateRefParam(constMod, type, typeName, name);
-    if (refResult) return refResult;
+    // Build normalized input using adapter
+    const input = ParameterInputAdapter.fromAST(ctx, {
+      getTypeName: (t) => this.getTypeName(t),
+      generateType: (t) => this.generateType(t),
+      generateExpression: (e) => this.generateExpression(e),
+      callbackTypes: CodeGenState.callbackTypes,
+      isKnownStruct: (t) => this.isKnownStruct(t),
+      typeMap: TYPE_MAP,
+      isModified,
+      isPassByValue,
+    });
 
-    // Unknown types use pass-by-value (standard C semantics)
-    return `${constMod}${type} ${name}`;
+    // Use shared builder with C/C++ mode
+    return ParameterSignatureBuilder.build(input, CppModeHelper.refOrPtr());
   }
 
   /**
-   * Try to generate string array parameter: string<N>[] -> char arr[n][N+1]
+   * Validate: Reject C-style array parameters
+   * C-style: u8 data[8], u8 data[4][4], u8 data[]
+   * C-Next:  u8[8] data, u8[4][4] data, u8[] data
    */
-  private _tryGenerateStringArrayParam(
+  private _validateCStyleArrayParam(
     ctx: Parser.ParameterContext,
-    constMod: string,
+    typeName: string,
     name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (!ctx.type().stringType() || dims.length === 0) {
-      return null;
+  ): void {
+    const dims = ctx.arrayDimension();
+    if (dims.length > 0) {
+      const dimensions = dims
+        .map((dim) => `[${dim.expression()?.getText() ?? ""}]`)
+        .join("");
+      const line = ctx.start?.line ?? 0;
+      const col = ctx.start?.column ?? 0;
+      throw new Error(
+        `${line}:${col} C-style array parameter is not allowed. ` +
+          `Use '${typeName}${dimensions} ${name}' instead of '${typeName} ${name}${dimensions}'`,
+      );
     }
-
-    const stringType = ctx.type().stringType()!;
-    const capacity = stringType.INTEGER_LITERAL()
-      ? Number.parseInt(stringType.INTEGER_LITERAL()!.getText(), 10)
-      : 256;
-    const dimStr = dims.map((d) => this.generateArrayDimension(d)).join("");
-    return `${constMod}char ${name}${dimStr}[${capacity + 1}]`;
   }
 
   /**
-   * Try to generate array parameter with auto-const
+   * Validate: Reject unbounded array dimensions for memory safety
    */
-  private _tryGenerateArrayParam(
-    constMod: string,
-    type: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (dims.length === 0) {
-      return null;
-    }
+  private _validateUnboundedArrayParam(ctx: Parser.ParameterContext): void {
+    const arrayTypeCtx = ctx.type().arrayType();
+    if (!arrayTypeCtx) return;
 
-    const dimStr = dims.map((d) => this.generateArrayDimension(d)).join("");
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    return `${autoConst}${constMod}${type} ${name}${dimStr}`;
+    const allDims = arrayTypeCtx.arrayTypeDimension();
+    const hasUnboundedDim = allDims.some((d) => !d.expression());
+    if (hasUnboundedDim) {
+      const line = ctx.start?.line ?? 0;
+      const col = ctx.start?.column ?? 0;
+      throw new Error(
+        `${line}:${col} Unbounded array parameters are not allowed. ` +
+          `All dimensions must have explicit sizes for memory safety.`,
+      );
+    }
   }
 
   /**
@@ -5280,7 +5385,7 @@ export default class CodeGenerator implements IOrchestrator {
     // ISR, float, enum types
     if (typeName === "ISR") return true;
     if (this._isFloatType(typeName)) return true;
-    if (CodeGenState.symbols!.knownEnums.has(typeName)) return true;
+    if (CodeGenState.symbols?.knownEnums.has(typeName)) return true;
 
     // Small unmodified primitives
     if (
@@ -5293,43 +5398,6 @@ export default class CodeGenerator implements IOrchestrator {
     return false;
   }
 
-  /**
-   * Try to generate non-array string parameter: string<N> -> char*
-   */
-  private _tryGenerateStringParam(
-    ctx: Parser.ParameterContext,
-    constMod: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (!ctx.type().stringType() || dims.length !== 0) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    return `${autoConst}${constMod}char* ${name}`;
-  }
-
-  /**
-   * Try to generate pass-by-reference parameter for known types
-   */
-  private _tryGenerateRefParam(
-    constMod: string,
-    type: string,
-    typeName: string,
-    name: string,
-  ): string | null {
-    if (!this.isKnownStruct(typeName) && !this._isKnownPrimitive(typeName)) {
-      return null;
-    }
-
-    const wasModified = this._isCurrentParameterModified(name);
-    const autoConst = !wasModified && !constMod ? "const " : "";
-    const refOrPtr = CppModeHelper.refOrPtr();
-    return `${autoConst}${constMod}${type}${refOrPtr} ${name}`;
-  }
-
   // ========================================================================
   // Variables
   // ========================================================================
@@ -5515,39 +5583,48 @@ export default class CodeGenerator implements IOrchestrator {
   }
 
   /**
-   * Get array dimension string from arrayType syntax (u16[8] -> "[8]").
+   * Get array dimension string from arrayType syntax (u16[8] -> "[8]", u16[4][4] -> "[4][4]").
    * Evaluates const expressions to their numeric values for C compatibility.
    */
   private _getArrayTypeDimension(typeCtx: Parser.TypeContext): string {
     if (!typeCtx.arrayType()) {
       return "";
     }
-    const sizeExpr = typeCtx.arrayType()!.expression();
-    if (!sizeExpr) {
-      return "[]";
-    }
-    // Try to evaluate as constant first (required for C file-scope arrays)
-    const constValue = this.tryEvaluateConstant(sizeExpr);
-    if (constValue !== undefined) {
-      return `[${constValue}]`;
+    const dims = typeCtx.arrayType()!.arrayTypeDimension();
+    let result = "";
+    for (const dim of dims) {
+      const sizeExpr = dim.expression();
+      if (!sizeExpr) {
+        result += "[]";
+        continue;
+      }
+      // Try to evaluate as constant first (required for C file-scope arrays)
+      // Fall back to expression text for macros, enums, etc.
+      const dimValue =
+        this.tryEvaluateConstant(sizeExpr) ?? this.generateExpression(sizeExpr);
+      result += `[${dimValue}]`;
     }
-    // Fall back to expression text (for macros, enums, etc.)
-    return `[${this.generateExpression(sizeExpr)}]`;
+    return result;
   }
 
   /**
-   * Parse array dimension from arrayType syntax for size validation.
+   * Parse first array dimension from arrayType syntax for size validation.
    */
   private _parseArrayTypeDimension(typeCtx: Parser.TypeContext): number | null {
     if (!typeCtx.arrayType()) {
       return null;
     }
-    const sizeExpr = typeCtx.arrayType()!.expression();
+    const dims = typeCtx.arrayType()!.arrayTypeDimension();
+    if (dims.length === 0) {
+      return null;
+    }
+    const sizeExpr = dims[0].expression();
     if (!sizeExpr) {
       return null;
     }
     const sizeText = sizeExpr.getText();
-    if (/^\d+$/.exec(sizeText)) {
+    const digitRegex = /^\d+$/;
+    if (digitRegex.exec(sizeText)) {
       return Number.parseInt(sizeText, 10);
     }
     return null;