c-next 0.1.64 → 0.1.65

package/src/transpiler/logic/parser/grammar/CNextVisitor.ts

@@ -89,6 +89,7 @@ import { TemplateArgumentListContext } from "./CNextParser.js";
 import { TemplateArgumentContext } from "./CNextParser.js";
 import { StringTypeContext } from "./CNextParser.js";
 import { ArrayTypeContext } from "./CNextParser.js";
+import { ArrayTypeDimensionContext } from "./CNextParser.js";
 import { LiteralContext } from "./CNextParser.js";
 
 
@@ -616,6 +617,12 @@ export class CNextVisitor<Result> extends AbstractParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitArrayType?: (ctx: ArrayTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by `CNextParser.arrayTypeDimension`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitArrayTypeDimension?: (ctx: ArrayTypeDimensionContext) => Result;
     /**
      * Visit a parse tree produced by `CNextParser.literal`.
      * @param ctx the parse tree

package/src/transpiler/logic/symbols/cnext/__tests__/FunctionCollector.test.ts

@@ -77,9 +77,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].isConst).toBe(true);
     });
 
-    it("handles array parameters", () => {
+    it("handles array parameters (C-Next style)", () => {
       const code = `
-        void processArray(u8 data[]) {
+        void processArray(u8[] data) {
         }
       `;
       const tree = parse(code);
@@ -90,9 +90,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].arrayDimensions).toEqual([""]);
     });
 
-    it("handles sized array parameters", () => {
+    it("handles sized array parameters (C-Next style)", () => {
       const code = `
-        void processBuffer(u8 buffer[256]) {
+        void processBuffer(u8[256] buffer) {
         }
       `;
       const tree = parse(code);
@@ -103,9 +103,9 @@ describe("FunctionCollector", () => {
       expect(symbol.parameters[0].arrayDimensions).toEqual(["256"]);
     });
 
-    it("handles multi-dimensional array parameters", () => {
+    it("handles multi-dimensional array parameters (C-Next style)", () => {
       const code = `
-        void processMatrix(f32 matrix[4][4]) {
+        void processMatrix(f32[4][4] matrix) {
         }
       `;
       const tree = parse(code);

package/src/transpiler/logic/symbols/cnext/__tests__/VariableCollector.test.ts

@@ -156,6 +156,61 @@ describe("VariableCollector", () => {
       expect(symbol.isArray).toBe(true);
       expect(symbol.arrayDimensions).toEqual([10, 20]);
     });
+
+    it("collects C-Next style array with dimensions in type (u8[8] arr)", () => {
+      const code = `
+        u8[8] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([8]);
+    });
+
+    it("collects C-Next style multi-dimensional array (u8[4][4] arr)", () => {
+      const code = `
+        u8[4][4] matrix;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([4, 4]);
+    });
+
+    it("collects C-Next style array with const reference dimension", () => {
+      const code = `
+        u8[SIZE] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const constValues = new Map<string, number>([["SIZE", 16]]);
+      const symbol = VariableCollector.collect(
+        varCtx,
+        "test.cnx",
+        undefined,
+        true,
+        constValues,
+      );
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual([16]);
+    });
+
+    it("preserves unresolved macro as string in C-Next style array", () => {
+      const code = `
+        u8[BUFFER_SIZE] buffer;
+      `;
+      const tree = parse(code);
+      const varCtx = tree.declaration(0)!.variableDeclaration()!;
+      const symbol = VariableCollector.collect(varCtx, "test.cnx");
+
+      expect(symbol.isArray).toBe(true);
+      expect(symbol.arrayDimensions).toEqual(["BUFFER_SIZE"]);
+    });
   });
 
   describe("scoped variables", () => {

package/src/transpiler/logic/symbols/cnext/collectors/FunctionCollector.ts

@@ -70,17 +70,16 @@ class FunctionCollector {
       const type = TypeUtils.getTypeName(typeCtx, scopeName);
       const isConst = p.constModifier() !== null;
 
-      const arrayDims = p.arrayDimension();
-      const isArray = arrayDims.length > 0;
+      // Check for C-Next style array type (u8[8] param, u8[4][4] param, u8[] param)
+      const arrayTypeCtx = typeCtx.arrayType();
+      const hasArrayType = arrayTypeCtx !== null;
 
-      // Extract array dimensions as strings (can contain expressions like SIZE)
+      // Extract array dimensions from arrayType syntax (supports multi-dimensional)
       const arrayDimensions: string[] = [];
-      if (isArray) {
-        for (const dim of arrayDims) {
-          const text = dim.getText();
-          const regex = /\[([^\]]*)\]/;
-          const match = regex.exec(text);
-          arrayDimensions.push(match ? match[1] : ""); // "" means unbounded
+      if (hasArrayType) {
+        for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+          const sizeExpr = dim.expression();
+          arrayDimensions.push(sizeExpr ? sizeExpr.getText() : "");
         }
       }
 
@@ -88,7 +87,7 @@ class FunctionCollector {
         name,
         type,
         isConst,
-        isArray,
+        isArray: hasArrayType,
       };
 
       if (arrayDimensions.length > 0) {

package/src/transpiler/logic/symbols/cnext/collectors/StructCollector.ts

@@ -30,7 +30,13 @@ function processArrayTypeSyntax(
     return { isArray: false, dimension: undefined };
   }
 
-  const sizeExpr = arrayTypeCtx.expression();
+  // Get the first dimension (for backwards compatibility with single-dimension code)
+  const dims = arrayTypeCtx.arrayTypeDimension();
+  if (dims.length === 0) {
+    return { isArray: true, dimension: undefined };
+  }
+
+  const sizeExpr = dims[0].expression();
   if (!sizeExpr) {
     return { isArray: true, dimension: undefined };
   }

package/src/transpiler/logic/symbols/cnext/collectors/VariableCollector.ts

@@ -71,6 +71,32 @@ class VariableCollector {
     return dimensions;
   }
 
+  /**
+   * Collect dimensions from C-Next style arrayType syntax (u16[8] arr, u16[4][4] arr).
+   */
+  private static collectArrayTypeDimensions(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    constValues: Map<string, number> | undefined,
+  ): (number | string)[] {
+    const dimensions: (number | string)[] = [];
+    for (const dim of arrayTypeCtx.arrayTypeDimension()) {
+      const sizeExpr = dim.expression();
+      if (!sizeExpr) continue;
+
+      const dimText = sizeExpr.getText();
+      const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
+      if (literalSize !== undefined) {
+        dimensions.push(literalSize);
+      } else if (constValues?.has(dimText)) {
+        dimensions.push(constValues.get(dimText)!);
+      } else {
+        // Keep as string for macro/enum references
+        dimensions.push(dimText);
+      }
+    }
+    return dimensions;
+  }
+
   /**
    * Collect a variable declaration and return an IVariableSymbol.
    *
@@ -110,21 +136,14 @@ class VariableCollector {
     const initExpr = ctx.expression();
     const arrayDimensions: (number | string)[] = [];
 
-    // Collect dimension from arrayType syntax (u16[8] arr)
+    // Collect dimensions from arrayType syntax (u16[8] arr, u16[4][4] arr, u16[] arr)
     if (hasArrayTypeSyntax) {
-      const sizeExpr = arrayTypeCtx.expression();
-      if (sizeExpr) {
-        const dimText = sizeExpr.getText();
-        const literalSize = LiteralUtils.parseIntegerLiteral(dimText);
-        if (literalSize !== undefined) {
-          arrayDimensions.push(literalSize);
-        } else if (constValues?.has(dimText)) {
-          arrayDimensions.push(constValues.get(dimText)!);
-        } else {
-          // Keep as string for macro/enum references
-          arrayDimensions.push(dimText);
-        }
-      }
+      arrayDimensions.push(
+        ...VariableCollector.collectArrayTypeDimensions(
+          arrayTypeCtx,
+          constValues,
+        ),
+      );
     }
 
     // Collect additional dimensions from arrayDimension syntax

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

@@ -3579,7 +3579,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 +3601,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 +3678,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 +3777,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 +3818,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 +3866,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 +3904,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 +4019,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 = "";
         }
@@ -5182,6 +5278,22 @@ export default class CodeGenerator implements IOrchestrator {
     const name = ctx.IDENTIFIER().getText();
     const dims = ctx.arrayDimension();
 
+    // Reject ALL C-style array parameters - require C-Next style (dimensions in type)
+    // C-style: u8 data[8], u8 data[4][4], u8 data[]
+    // C-Next:  u8[8] data, u8[4][4] data, u8[] data
+    if (dims.length > 0) {
+      const baseType = typeName;
+      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 '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`,
+      );
+    }
+
     // ADR-029: Check if this is a callback type parameter
     if (CodeGenState.callbackTypes.has(typeName)) {
       const callbackInfo = CodeGenState.callbackTypes.get(typeName)!;
@@ -5190,27 +5302,41 @@ export default class CodeGenerator implements IOrchestrator {
 
     const type = this.generateType(ctx.type());
 
-    // Handle C-Next style array type in parameter (e.g., u8[8] param)
+    // Handle C-Next style array type in parameter (e.g., u8[8] param, u8[4][4] param, string<32>[5] param)
     const arrayTypeCtx = ctx.type().arrayType();
     if (arrayTypeCtx) {
-      const dimExpr = this.generateExpression(arrayTypeCtx.expression());
+      // Check for unbounded dimensions - reject for memory safety
+      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.`,
+        );
+      }
+
+      let dims = allDims
+        .map((d) => {
+          const expr = d.expression();
+          return expr ? `[${this.generateExpression(expr)}]` : "[]";
+        })
+        .join("");
+      // For string arrays, add the string capacity dimension (string<32>[5] -> char[5][33])
+      if (arrayTypeCtx.stringType()) {
+        const stringCtx = arrayTypeCtx.stringType()!;
+        const intLiteral = stringCtx.INTEGER_LITERAL();
+        if (intLiteral) {
+          const capacity = Number.parseInt(intLiteral.getText(), 10);
+          dims += `[${capacity + 1}]`;
+        }
+      }
       const wasModified = this._isCurrentParameterModified(name);
       const autoConst = !wasModified && !constMod ? "const " : "";
-      return `${autoConst}${constMod}${type} ${name}[${dimExpr}]`;
+      return `${autoConst}${constMod}${type} ${name}${dims}`;
     }
 
-    // Try special cases first
-    const stringArrayResult = this._tryGenerateStringArrayParam(
-      ctx,
-      constMod,
-      name,
-      dims,
-    );
-    if (stringArrayResult) return stringArrayResult;
-
-    const arrayResult = this._tryGenerateArrayParam(constMod, type, name, dims);
-    if (arrayResult) return arrayResult;
-
     // Pass-by-value types
     if (this._isPassByValueType(typeName, name)) {
       return `${constMod}${type} ${name}`;
@@ -5233,46 +5359,6 @@ export default class CodeGenerator implements IOrchestrator {
     return `${constMod}${type} ${name}`;
   }
 
-  /**
-   * Try to generate string array parameter: string<N>[] -> char arr[n][N+1]
-   */
-  private _tryGenerateStringArrayParam(
-    ctx: Parser.ParameterContext,
-    constMod: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (!ctx.type().stringType() || dims.length === 0) {
-      return null;
-    }
-
-    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
-   */
-  private _tryGenerateArrayParam(
-    constMod: string,
-    type: string,
-    name: string,
-    dims: Parser.ArrayDimensionContext[],
-  ): string | null {
-    if (dims.length === 0) {
-      return null;
-    }
-
-    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}`;
-  }
-
   /**
    * Check if type should use pass-by-value semantics
    */
@@ -5515,39 +5601,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;