c-next 0.2.16 → 0.2.17

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

@@ -332,6 +332,60 @@ class TypeRegistrationEngine {
     return true;
   }
 
+  /**
+   * Issue #1029: Register type info for string arrays (string<N>[M]).
+   *
+   * String arrays are parsed as arrayType with stringType inside:
+   *   arrayType -> stringType arrayTypeDimension+
+   *
+   * For `string<32>[4] items`:
+   *   - stringType gives capacity 32
+   *   - arrayTypeDimension gives [4]
+   *   - Result: char items[4][33] with dimensions [4, 33]
+   */
+  private static _registerStringArrayType(
+    registryName: string,
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    arrayDim: Parser.ArrayDimensionContext[] | null,
+    isConst: boolean,
+    overflowBehavior: TOverflowBehavior,
+    isAtomic: boolean,
+    callbacks: ITypeRegistrationCallbacks,
+  ): void {
+    const stringCtx = arrayTypeCtx.stringType()!;
+    const intLiteral = stringCtx.INTEGER_LITERAL();
+    if (!intLiteral) {
+      return; // No capacity specified - can't register
+    }
+
+    const capacity = Number.parseInt(intLiteral.getText(), 10);
+    callbacks.requireInclude("string");
+    const stringDim = capacity + 1;
+
+    // Collect dimensions: arrayTypeDimension from arrayType, then string capacity
+    // Build all dimensions at once to avoid multiple push() calls (SonarCloud S7778)
+    const arrayTypeDims = arrayTypeCtx
+      .arrayTypeDimension()
+      .map((dim) => dim.expression())
+      .filter((expr): expr is Parser.ExpressionContext => expr !== null)
+      .map((expr) => Number.parseInt(expr.getText(), 10))
+      .filter((size) => !Number.isNaN(size));
+    const additionalDims = ArrayDimensionParser.parseSimpleDimensions(arrayDim);
+    const dimensions = [...arrayTypeDims, ...additionalDims, stringDim];
+
+    CodeGenState.setVariableTypeInfo(registryName, {
+      baseType: "char",
+      bitWidth: 8,
+      isArray: true,
+      arrayDimensions: dimensions,
+      isConst,
+      isString: true,
+      stringCapacity: capacity,
+      overflowBehavior,
+      isAtomic,
+    });
+  }
+
   // ============================================================================
   // Array and standard type registration
   // ============================================================================
@@ -345,45 +399,40 @@ class TypeRegistrationEngine {
     isAtomic: boolean,
     callbacks: ITypeRegistrationCallbacks,
   ): void {
-    let baseType = "";
-    let bitWidth = 0;
+    // Issue #1029: Handle string arrays (string<N>[M]) - must check before primitiveType/userType
+    if (arrayTypeCtx.stringType()) {
+      TypeRegistrationEngine._registerStringArrayType(
+        registryName,
+        arrayTypeCtx,
+        arrayDim,
+        isConst,
+        overflowBehavior,
+        isAtomic,
+        callbacks,
+      );
+      return;
+    }
 
-    if (arrayTypeCtx.primitiveType()) {
-      baseType = arrayTypeCtx.primitiveType()!.getText();
-      bitWidth = TYPE_WIDTH[baseType] || 0;
-    } else if (arrayTypeCtx.userType()) {
-      baseType = arrayTypeCtx.userType()!.getText();
-
-      const combinedArrayDim = arrayDim ?? [];
-      if (
-        TypeRegistrationEngine._tryRegisterEnumOrBitmapType(
-          registryName,
-          baseType,
-          isConst,
-          combinedArrayDim,
-          overflowBehavior,
-          isAtomic,
-          callbacks,
-        )
-      ) {
-        const existingInfo = CodeGenState.getVariableTypeInfo(registryName);
-        if (existingInfo) {
-          const arrayTypeDim =
-            TypeRegistrationEngine.parseArrayTypeDimension(arrayTypeCtx);
-          const allDims = arrayTypeDim
-            ? [arrayTypeDim, ...(existingInfo.arrayDimensions ?? [])]
-            : existingInfo.arrayDimensions;
-          CodeGenState.setVariableTypeInfo(registryName, {
-            ...existingInfo,
-            isArray: true,
-            arrayDimensions: allDims,
-          });
-        }
+    // Try to register enum/bitmap user type arrays separately
+    if (arrayTypeCtx.userType()) {
+      const registered = TypeRegistrationEngine._tryRegisterUserTypeArray(
+        registryName,
+        arrayTypeCtx,
+        arrayDim,
+        isConst,
+        overflowBehavior,
+        isAtomic,
+        callbacks,
+      );
+      if (registered) {
         return;
       }
     }
 
-    if (!baseType) {
+    // Extract base type and bit width from array type
+    const typeInfo =
+      TypeRegistrationEngine._extractArrayBaseTypeInfo(arrayTypeCtx);
+    if (!typeInfo.baseType) {
       return;
     }
 
@@ -394,8 +443,8 @@ class TypeRegistrationEngine {
     );
 
     CodeGenState.setVariableTypeInfo(registryName, {
-      baseType,
-      bitWidth,
+      baseType: typeInfo.baseType,
+      bitWidth: typeInfo.bitWidth,
       isArray: true,
       arrayDimensions: arrayDimensions.length > 0 ? arrayDimensions : undefined,
       isConst,
@@ -404,6 +453,91 @@ class TypeRegistrationEngine {
     });
   }
 
+  /**
+   * Extract base type and bit width from an array type context.
+   * Handles primitive, qualified, scoped, and user types.
+   */
+  private static _extractArrayBaseTypeInfo(
+    arrayTypeCtx: Parser.ArrayTypeContext,
+  ): { baseType: string; bitWidth: number } {
+    if (arrayTypeCtx.primitiveType()) {
+      const baseType = arrayTypeCtx.primitiveType()!.getText();
+      return { baseType, bitWidth: TYPE_WIDTH[baseType] || 0 };
+    }
+
+    if (arrayTypeCtx.qualifiedType()) {
+      const parts = arrayTypeCtx.qualifiedType()!.IDENTIFIER();
+      return { baseType: parts.map((p) => p.getText()).join("_"), bitWidth: 0 };
+    }
+
+    if (arrayTypeCtx.scopedType()) {
+      const typeName = arrayTypeCtx.scopedType()!.IDENTIFIER().getText();
+      const baseType = CodeGenState.currentScope
+        ? `${CodeGenState.currentScope}_${typeName}`
+        : typeName;
+      return { baseType, bitWidth: 0 };
+    }
+
+    if (arrayTypeCtx.globalType()) {
+      const typeName = arrayTypeCtx.globalType()!.IDENTIFIER().getText();
+      return { baseType: typeName, bitWidth: 0 };
+    }
+
+    if (arrayTypeCtx.userType()) {
+      return { baseType: arrayTypeCtx.userType()!.getText(), bitWidth: 0 };
+    }
+
+    return { baseType: "", bitWidth: 0 };
+  }
+
+  /**
+   * Try to register a user type array as enum or bitmap.
+   * Returns true if registration was handled, false if it should fall through.
+   */
+  private static _tryRegisterUserTypeArray(
+    registryName: string,
+    arrayTypeCtx: Parser.ArrayTypeContext,
+    arrayDim: Parser.ArrayDimensionContext[] | null,
+    isConst: boolean,
+    overflowBehavior: TOverflowBehavior,
+    isAtomic: boolean,
+    callbacks: ITypeRegistrationCallbacks,
+  ): boolean {
+    const baseType = arrayTypeCtx.userType()!.getText();
+    const combinedArrayDim = arrayDim ?? [];
+
+    const registered = TypeRegistrationEngine._tryRegisterEnumOrBitmapType(
+      registryName,
+      baseType,
+      isConst,
+      combinedArrayDim,
+      overflowBehavior,
+      isAtomic,
+      callbacks,
+    );
+
+    if (!registered) {
+      return false;
+    }
+
+    // Add arrayType dimensions to existing info
+    const existingInfo = CodeGenState.getVariableTypeInfo(registryName);
+    if (existingInfo) {
+      const arrayTypeDim =
+        TypeRegistrationEngine.parseArrayTypeDimension(arrayTypeCtx);
+      const allDims = arrayTypeDim
+        ? [arrayTypeDim, ...(existingInfo.arrayDimensions ?? [])]
+        : existingInfo.arrayDimensions;
+      CodeGenState.setVariableTypeInfo(registryName, {
+        ...existingInfo,
+        isArray: true,
+        arrayDimensions: allDims,
+      });
+    }
+
+    return true;
+  }
+
   private static _collectArrayDimensions(
     arrayTypeCtx: Parser.ArrayTypeContext,
     arrayDim: Parser.ArrayDimensionContext[] | null,

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

@@ -268,49 +268,27 @@ class VariableDeclHelper {
       return; // Not an array declaration
     }
 
-    // If type already has arrayType, additional dimensions are allowed (multi-dim)
-    if (typeCtx.arrayType()) {
-      return; // Valid C-Next style: u16[4] arr[2] -> uint16_t arr[4][2]
-    }
-
-    // Allow empty first dimension for size inference: u8 arr[] <- [1, 2, 3]
-    // The grammar doesn't support u8[] arr syntax, so this is the only way
-    if (arrayDims.length === 1 && !arrayDims[0].expression()) {
-      return; // Size inference pattern allowed
-    }
-
-    // Allow C-style for multi-dimensional arrays: u8 matrix[4][4]
-    // The arrayType grammar only supports single dimension, so multi-dim needs C-style
-    if (arrayDims.length > 1) {
-      return; // Multi-dimensional arrays need C-style
-    }
-
-    // Allow C-style for types that don't support arrayType syntax:
-    // - Qualified types (Scope.Type, Namespace::Type)
-    // - Scoped types (this.Type)
-    // - Global types (global.Type)
-    // - String types (string<N>)
-    // - Bitmap types (code generator doesn't yet handle arrayType for bitmaps)
-    if (
-      typeCtx.qualifiedType() ||
-      typeCtx.scopedType() ||
-      typeCtx.globalType() ||
-      typeCtx.stringType()
-    ) {
-      return; // Grammar limitation - these can't use arrayType
-    }
-
-    // C-style array declaration detected - reject with helpful error
+    // Issues #1014-#1017: ALL trailing brackets after the variable name are rejected.
+    // The only valid form is dimensions in type position: u8[4][8] matrix, string<32>[5] names
+    // No mixed forms (u8[4] matrix[8]), no C-style (u8 matrix[4][8]), no trailing inference (u8 arr[])
     const baseType = VariableDeclHelper.extractBaseTypeName(typeCtx);
-    const dimensions = arrayDims
+    const existingDims = typeCtx.arrayType()
+      ? typeCtx
+          .arrayType()!
+          .arrayTypeDimension()
+          .map((d) => `[${d.expression()?.getText() ?? ""}]`)
+          .join("")
+      : "";
+    const trailingDims = arrayDims
       .map((dim) => `[${dim.expression()?.getText() ?? ""}]`)
       .join("");
+    const allDims = existingDims + trailingDims;
     const line = ctx.start?.line ?? 0;
     const col = ctx.start?.column ?? 0;
 
     throw new Error(
       `${line}:${col} C-style array declaration is not allowed. ` +
-        `Use '${baseType}${dimensions} ${name}' instead of '${baseType} ${name}${dimensions}'`,
+        `Use '${baseType}${allDims} ${name}' instead of '${baseType}${existingDims} ${name}${trailingDims}'`,
     );
   }
 
@@ -456,7 +434,22 @@ class VariableDeclHelper {
       callbacks,
     );
 
-    const hasEmptyArrayDim = arrayDims.some((dim) => !dim.expression());
+    // Check for empty dimensions in both trailing brackets and arrayType
+    const hasEmptyArrayDim =
+      arrayDims.some((dim) => !dim.expression()) ||
+      (typeCtx
+        .arrayType()
+        ?.arrayTypeDimension()
+        .some((dim) => !dim.expression()) ??
+        false);
+
+    // Check if the empty dimension is specifically in arrayType (vs trailing arrayDims)
+    const hasEmptyArrayTypeDim =
+      typeCtx
+        .arrayType()
+        ?.arrayTypeDimension()
+        .some((dim) => !dim.expression()) ?? false;
+
     const declaredSize =
       VariableDeclHelper.parseArrayTypeDimension(typeCtx) ??
       VariableDeclHelper.parseFirstArrayDimension(arrayDims);
@@ -481,8 +474,11 @@ class VariableDeclHelper {
       if (arrayInitResult) {
         // Track as local array for type resolution
         CodeGenState.localArrays.add(name);
-        // Include arrayType dimension before arrayDimension dimensions
-        const fullDimSuffix = arrayTypeDimStr + arrayInitResult.dimensionSuffix;
+        // When size inference happens and the empty dim is in arrayType,
+        // dimensionSuffix already contains the inferred size - don't duplicate
+        const fullDimSuffix = hasEmptyArrayTypeDim
+          ? arrayInitResult.dimensionSuffix
+          : arrayTypeDimStr + arrayInitResult.dimensionSuffix;
         return {
           handled: true,
           code: `${decl}${fullDimSuffix} = ${arrayInitResult.initValue};`,
@@ -537,7 +533,9 @@ class VariableDeclHelper {
     // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
     // MISRA 10.3: Also check for cross-type-category conversions (int <-> float)
     return CodeGenState.withExpectedType(typeName, () => {
-      let exprCode = callbacks.generateExpression(ctx.expression()!);
+      let exprCode = CodeGenState.withDeclarationInit(() =>
+        callbacks.generateExpression(ctx.expression()!),
+      );
 
       // MISRA 10.3: Check for cross-type-category conversions (int <-> float)
       const exprType = callbacks.getExpressionType(ctx.expression()!);

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

@@ -334,6 +334,55 @@ describe("ParameterInputAdapter", () => {
       expect(result.forcePointerSyntax).toBeUndefined();
       expect(result.forceConst).toBeUndefined();
     });
+
+    // Issue #995: Opaque handle support in fromSymbol
+    it("passes through isOpaqueHandle when set (Issue #995)", () => {
+      // The adapter passes through isOpaqueHandle; ParameterSignatureBuilder
+      // applies the rule (suppress auto-const, force pointer syntax)
+      const param: IParameterSymbol = {
+        name: "widget",
+        type: "widget_t",
+        isConst: false,
+        isArray: false,
+        isOpaqueHandle: true,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.isOpaqueHandle).toBe(true);
+    });
+
+    it("passes through isAutoConst even when isOpaqueHandle is set (builder applies rule)", () => {
+      // The adapter passes through both flags; the builder suppresses auto-const
+      // for opaque handles — this is NOT the adapter's responsibility
+      const param: IParameterSymbol = {
+        name: "widget",
+        type: "widget_t",
+        isConst: false,
+        isArray: false,
+        isOpaqueHandle: true,
+        isAutoConst: true,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      // Adapter passes through isAutoConst as-is; builder will suppress it
+      expect(result.isAutoConst).toBe(true);
+      expect(result.isOpaqueHandle).toBe(true);
+    });
+
+    it("does not force pointer when isOpaqueHandle is not set", () => {
+      const param: IParameterSymbol = {
+        name: "point",
+        type: "Point",
+        isConst: false,
+        isArray: false,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.forcePointerSyntax).toBeUndefined();
+    });
   });
 
   describe("fromAST", () => {
@@ -404,6 +453,18 @@ describe("ParameterInputAdapter", () => {
       expect(result.arrayDimensions).toEqual(["4", "4"]);
     });
 
+    // Issue #986: ADR-006 says arrays are mutable by default.
+    // Arrays should never get auto-const, even when unmodified.
+    it("does not set auto-const for unmodified array parameter", () => {
+      const ctx = getParameterContext("void foo(u8[8] data) {}");
+      const deps = createDefaultASTDeps({ isModified: false });
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.isArray).toBe(true);
+      expect(result.isAutoConst).toBe(false); // Arrays never get auto-const
+    });
+
     it("converts non-array string parameter", () => {
       const ctx = getParameterContext("void foo(string<32> name) {}");
       const deps = createDefaultASTDeps();
@@ -508,5 +569,61 @@ describe("ParameterInputAdapter", () => {
 
       expect(result.forceConst).toBeUndefined();
     });
+
+    // Issue #995: Opaque handles pass through isOpaqueHandle; builder applies rule
+    it("passes through isOpaqueHandle for opaque type parameter", () => {
+      const ctx = getParameterContext("void foo(widget_t w) {}");
+      const deps = {
+        ...createDefaultASTDeps({ isModified: false }),
+        isOpaqueType: (typeName: string) => typeName === "widget_t",
+      };
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      // Adapter passes through detection; builder applies rule
+      expect(result.isOpaqueHandle).toBe(true);
+      // isAutoConst computed normally; builder will suppress it for opaque handles
+      expect(result.isAutoConst).toBe(true);
+    });
+
+    // Issue #995: Opaque handles don't set forcePointerSyntax — builder handles it
+    it("does not set forcePointerSyntax for opaque type (builder handles it)", () => {
+      const ctx = getParameterContext("void foo(widget_t w) {}");
+      const deps = {
+        ...createDefaultASTDeps({ isModified: false }),
+        isOpaqueType: (typeName: string) => typeName === "widget_t",
+        isTypedefStructType: () => false, // Not a typedef struct
+      };
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      // forcePointerSyntax not set by adapter for opaque handles
+      // (builder uses isOpaqueHandle instead)
+      expect(result.forcePointerSyntax).toBeUndefined();
+      expect(result.isOpaqueHandle).toBe(true);
+    });
+
+    // Issue #995: Verify non-opaque types still get auto-const
+    it("sets auto-const for non-opaque type when isOpaqueType returns false", () => {
+      const ctx = getParameterContext("void foo(Point p) {}");
+      const deps = {
+        ...createDefaultASTDeps({ isModified: false }),
+        isOpaqueType: () => false,
+      };
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.isAutoConst).toBe(true);
+    });
+
+    // Issue #995: When isOpaqueType is not provided, auto-const still works
+    it("sets auto-const when isOpaqueType is not provided", () => {
+      const ctx = getParameterContext("void foo(Point p) {}");
+      const deps = createDefaultASTDeps({ isModified: false });
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.isAutoConst).toBe(true);
+    });
   });
 });

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

@@ -44,15 +44,20 @@ describe("ParameterSignatureBuilder", () => {
     });
   });
 
+  // Note: These tests verify the builder respects isAutoConst when explicitly set.
+  // Per ADR-006 and issue #986, ParameterInputAdapter now sets isAutoConst=false
+  // for arrays (arrays are mutable by default). These tests still pass because
+  // they test the builder's behavior when isAutoConst IS requested (e.g., for
+  // explicit const arrays or legacy code paths).
   describe("array parameters", () => {
-    it("generates single dimension array", () => {
+    it("generates const array when isAutoConst is true", () => {
       const input = createInput({
         name: "arr",
         baseType: "u32",
         mappedType: "uint32_t",
         isArray: true,
         arrayDimensions: ["10"],
-        isAutoConst: true,
+        isAutoConst: true, // Explicit request for const
       });
 
       const result = ParameterSignatureBuilder.build(input, "*");
@@ -313,6 +318,93 @@ describe("ParameterSignatureBuilder", () => {
     });
   });
 
+  describe("opaque handle parameters (Issue #995)", () => {
+    it("suppresses auto-const for opaque handles", () => {
+      // Opaque handles should not get const because they must be passed
+      // to C APIs expecting non-const pointers (like LVGL's lv_obj_t)
+      const input = createInput({
+        name: "widget",
+        baseType: "widget_t",
+        mappedType: "widget_t",
+        isPassByReference: true,
+        isAutoConst: true, // Would normally add const
+        isOpaqueHandle: true, // But opaque overrides
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      // auto-const should be suppressed
+      expect(result).toBe("widget_t* widget");
+    });
+
+    it("uses pointer syntax for opaque handles in C++ mode", () => {
+      // Opaque handles must use pointer syntax even in C++ mode
+      // because C APIs expect pointers to incomplete struct types
+      const input = createInput({
+        name: "w",
+        baseType: "widget_t",
+        mappedType: "widget_t",
+        isPassByReference: true,
+        isOpaqueHandle: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      // Should use pointer (not reference) in C++ mode
+      expect(result).toBe("widget_t* w");
+    });
+
+    it("routes opaque handles through pass-by-reference path", () => {
+      // Even if isPassByReference is false, opaque handles should
+      // still generate pointer syntax
+      const input = createInput({
+        name: "ctx",
+        baseType: "context_t",
+        mappedType: "context_t",
+        isPassByReference: false, // Not explicitly set
+        isPassByValue: false, // Not explicitly set
+        isOpaqueHandle: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      // Should still get pointer syntax from opaque handle routing
+      expect(result).toBe("context_t* ctx");
+    });
+
+    it("preserves explicit const on opaque handles", () => {
+      // If the user explicitly marks it const, that should be preserved
+      const input = createInput({
+        name: "widget",
+        baseType: "widget_t",
+        mappedType: "widget_t",
+        isConst: true, // Explicit const
+        isOpaqueHandle: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const widget_t* widget");
+    });
+
+    it("isOpaqueHandle overrides forcePointerSyntax check", () => {
+      // isOpaqueHandle should force pointer even without forcePointerSyntax
+      const input = createInput({
+        name: "widget",
+        baseType: "widget_t",
+        mappedType: "widget_t",
+        isPassByReference: true,
+        forcePointerSyntax: false, // Not set
+        isOpaqueHandle: true, // But opaque overrides
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      // Should use pointer (not reference) due to isOpaqueHandle
+      expect(result).toBe("widget_t* widget");
+    });
+  });
+
   describe("callback-compatible parameters (Issue #895)", () => {
     it("forceConst adds const from typedef signature", () => {
       const input = createInput({