c-next 0.2.16 → 0.2.17

package/src/transpiler/output/headers/__tests__/HeaderGeneratorUtils.test.ts

@@ -804,4 +804,284 @@ describe("HeaderGeneratorUtils", () => {
       expect(lines).toContain("#endif /* MY_FILE_H */");
     });
   });
+
+  describe("generateCallbackStructForwardDecls", () => {
+    it("returns empty array when no callback types provided", () => {
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        [],
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("returns empty array when callback types is undefined", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: undefined,
+      };
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        [],
+        input,
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("generates forward declarations for struct parameters", () => {
+      const structs = [makeSymbol({ name: "DataStruct", kind: "struct" })];
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "processData",
+            {
+              typedefName: "processData_t",
+              returnType: "void",
+              parameters: [
+                { type: "DataStruct", isStruct: true },
+                { type: "uint32_t", isStruct: false },
+              ],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        structs,
+        input,
+      );
+      expect(result).toContain("typedef struct DataStruct DataStruct;");
+    });
+
+    it("deduplicates struct forward declarations", () => {
+      const structs = [makeSymbol({ name: "MyStruct", kind: "struct" })];
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "handler1",
+            {
+              typedefName: "handler1_t",
+              returnType: "void",
+              parameters: [{ type: "MyStruct", isStruct: true }],
+            },
+          ],
+          [
+            "handler2",
+            {
+              typedefName: "handler2_t",
+              returnType: "void",
+              parameters: [{ type: "MyStruct", isStruct: true }],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        structs,
+        input,
+      );
+      const myStructDecls = result.filter((l) => l.includes("MyStruct"));
+      expect(myStructDecls.length).toBe(1);
+    });
+
+    it("ignores non-struct parameters", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "handler",
+            {
+              typedefName: "handler_t",
+              returnType: "uint32_t",
+              parameters: [
+                { type: "uint32_t", isStruct: false },
+                { type: "bool", isStruct: false },
+              ],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        [],
+        input,
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("only includes local structs in forward declarations", () => {
+      // ExternalStruct is not in the local structs list
+      const structs = [makeSymbol({ name: "LocalStruct", kind: "struct" })];
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "handler",
+            {
+              typedefName: "handler_t",
+              returnType: "void",
+              parameters: [
+                { type: "LocalStruct", isStruct: true },
+                { type: "ExternalStruct", isStruct: true },
+              ],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        structs,
+        input,
+      );
+      expect(result).toContain("typedef struct LocalStruct LocalStruct;");
+      expect(result).not.toContain("ExternalStruct");
+    });
+  });
+
+  describe("generateCallbackTypedefSection", () => {
+    it("returns empty array when no callback types provided", () => {
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection();
+      expect(result).toEqual([]);
+    });
+
+    it("returns empty array when callback types is undefined", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: undefined,
+      };
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection(
+        input,
+        false,
+      );
+      expect(result).toEqual([]);
+    });
+
+    it("generates C-style function pointer typedef", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "processU32",
+            {
+              typedefName: "processU32_t",
+              returnType: "uint32_t",
+              parameters: [{ type: "uint32_t", isStruct: false }],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection(
+        input,
+        false,
+      );
+      expect(result.join("\n")).toContain(
+        "typedef uint32_t (*processU32_t)(uint32_t);",
+      );
+    });
+
+    it("generates C++ reference for struct parameters", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "processPoint",
+            {
+              typedefName: "processPoint_t",
+              returnType: "uint32_t",
+              parameters: [{ type: "Point", isStruct: true }],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection(
+        input,
+        true,
+      );
+      expect(result.join("\n")).toContain("Point&");
+    });
+
+    it("generates C pointer for struct parameters", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "processPoint",
+            {
+              typedefName: "processPoint_t",
+              returnType: "uint32_t",
+              parameters: [{ type: "Point", isStruct: true }],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection(
+        input,
+        false,
+      );
+      expect(result.join("\n")).toContain("Point*");
+    });
+
+    it("handles multiple parameters", () => {
+      const input = {
+        structFields: new Map(),
+        structFieldDimensions: new Map(),
+        enumMembers: new Map(),
+        bitmapBackingType: new Map(),
+        bitmapFields: new Map(),
+        callbackTypes: new Map([
+          [
+            "multiParam",
+            {
+              typedefName: "multiParam_t",
+              returnType: "void",
+              parameters: [
+                { type: "uint32_t", isStruct: false },
+                { type: "Point", isStruct: true },
+                { type: "bool", isStruct: false },
+              ],
+            },
+          ],
+        ]),
+      };
+      const result = HeaderGeneratorUtils.generateCallbackTypedefSection(
+        input,
+        false,
+      );
+      const typedef = result.find((l) => l.includes("multiParam_t"));
+      expect(typedef).toContain("uint32_t");
+      expect(typedef).toContain("Point*");
+      expect(typedef).toContain("bool");
+    });
+  });
 });

package/src/transpiler/output/headers/generators/IHeaderTypeInput.ts

@@ -31,6 +31,19 @@ interface IHeaderTypeInput {
     string,
     ReadonlyMap<string, { readonly offset: number; readonly width: number }>
   >;
+
+  /** Callback types: functionName -> typedef info for header generation */
+  readonly callbackTypes?: ReadonlyMap<
+    string,
+    {
+      readonly typedefName: string;
+      readonly returnType: string;
+      readonly parameters: ReadonlyArray<{
+        readonly type: string;
+        readonly isStruct: boolean;
+      }>;
+    }
+  >;
 }
 
 export default IHeaderTypeInput;

package/src/transpiler/output/headers/generators/generateStructHeader.ts

@@ -11,6 +11,52 @@ import CppNamespaceUtils from "../../../../utils/CppNamespaceUtils";
 
 const { mapType } = typeUtils;
 
+/**
+ * Resolve the C type for a struct field, checking for callback types first.
+ */
+function resolveFieldCType(fieldType: string, input: IHeaderTypeInput): string {
+  // ADR-029: Check if field type is a callback type and use typedef name
+  const callbackInfo = input.callbackTypes?.get(fieldType);
+  if (callbackInfo) {
+    return callbackInfo.typedefName;
+  }
+  // Issue #502/#522: Convert C++ namespace types from _ to :: format
+  const convertedType = CppNamespaceUtils.convertToCppNamespace(
+    fieldType,
+    input.symbolTable,
+  );
+  return mapType(convertedType);
+}
+
+/**
+ * Generate the field line for a struct member, handling embedded dimensions.
+ *
+ * Issue #461: Handle string<N> types which map to char[N+1]
+ * The embedded dimension must come after array dimensions in C syntax.
+ * Example: string<64> arr[4] -> char arr[4][65], not char[65] arr[4]
+ */
+function generateFieldLine(
+  fieldName: string,
+  cType: string,
+  dims: readonly number[] | undefined,
+): string {
+  const dimSuffix =
+    dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
+  const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
+
+  if (!embeddedMatch) {
+    return `    ${cType} ${fieldName}${dimSuffix};`;
+  }
+
+  const baseType = embeddedMatch[1];
+  const embeddedDim = embeddedMatch[2];
+  // When dims are provided, they already include string capacity from StructCollector
+  if (dims && dims.length > 0) {
+    return `    ${baseType} ${fieldName}${dimSuffix};`;
+  }
+  return `    ${baseType} ${fieldName}[${embeddedDim}];`;
+}
+
 /**
  * Generate a C typedef struct declaration for the given struct name.
  *
@@ -41,35 +87,9 @@ function generateStructHeader(name: string, input: IHeaderTypeInput): string {
 
   // Iterate fields in insertion order (Map preserves order)
   for (const [fieldName, fieldType] of fields) {
-    // Issue #502/#522: Convert C++ namespace types from _ to :: format using shared utility
-    const convertedType = CppNamespaceUtils.convertToCppNamespace(
-      fieldType,
-      input.symbolTable,
-    );
-    const cType = mapType(convertedType);
+    const cType = resolveFieldCType(fieldType, input);
     const dims = dimensions?.get(fieldName);
-    const dimSuffix =
-      dims && dims.length > 0 ? dims.map((d) => `[${d}]`).join("") : "";
-
-    // Issue #461: Handle string<N> types which map to char[N+1]
-    // The embedded dimension must come after array dimensions in C syntax
-    // Example: string<64> arr[4] -> char arr[4][65], not char[65] arr[4]
-    //
-    // Fix: When dims already include the string capacity (from StructCollector),
-    // use dimSuffix directly. Only extract embedded dim when no dims provided.
-    const embeddedMatch = /^(\w+)\[(\d+)\]$/.exec(cType);
-    if (embeddedMatch) {
-      const baseType = embeddedMatch[1];
-      const embeddedDim = embeddedMatch[2];
-      // dims already includes string capacity, so just use dimSuffix
-      if (dims && dims.length > 0) {
-        lines.push(`    ${baseType} ${fieldName}${dimSuffix};`);
-      } else {
-        lines.push(`    ${baseType} ${fieldName}[${embeddedDim}];`);
-      }
-    } else {
-      lines.push(`    ${cType} ${fieldName}${dimSuffix};`);
-    }
+    lines.push(generateFieldLine(fieldName, cType, dims));
   }
 
   lines.push(`} ${name};`);

package/src/transpiler/state/CodeGenState.ts

@@ -217,6 +217,12 @@ export default class CodeGenState {
   /** Whether we're inside a function body */
   static inFunctionBody: boolean = false;
 
+  /** Whether we're generating the RHS of a variable declaration initializer.
+   *  When true, struct literals use { .field = value } instead of (Type){ .field = value }
+   *  because plain designated initializers are valid C99 at any scope, while compound
+   *  literals are not constant expressions and fail at file scope on GCC < 13. */
+  static inDeclarationInit: boolean = false;
+
   /** Expected type for struct initializers and enum inference */
   static expectedType: string | null = null;
 
@@ -381,6 +387,7 @@ export default class CodeGenState {
     // Generation state
     this.indentLevel = 0;
     this.inFunctionBody = false;
+    this.inDeclarationInit = false;
     this.expectedType = null;
     this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
@@ -476,6 +483,49 @@ export default class CodeGenState {
     }
   }
 
+  /** Execute fn with inDeclarationInit=true, restoring prior value on exit. */
+  static withDeclarationInit<T>(fn: () => T): T {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = true;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+
+  /** Execute fn with inDeclarationInit=false, restoring prior value on exit.
+   *  Used in sub-expression contexts (function args, ternary arms) where
+   *  plain designated initializers are not valid C. */
+  static withoutDeclarationInit<T>(fn: () => T): T {
+    const saved = this.inDeclarationInit;
+    this.inDeclarationInit = false;
+    try {
+      return fn();
+    } finally {
+      this.inDeclarationInit = saved;
+    }
+  }
+
+  /**
+   * Execute fn with expectedType=null, restoring prior value on exit.
+   * Issue #1032: Used in comparison contexts (relational/equality expressions)
+   * where MISRA 7.2 U suffix should NOT be applied - comparing `i32 < 0`
+   * should not generate `signedIdx < 0U` which changes comparison semantics.
+   */
+  static withoutExpectedType<T>(fn: () => T): T {
+    const savedType = this.expectedType;
+    const savedSuppress = this.suppressBareEnumResolution;
+    this.expectedType = null;
+    this.suppressBareEnumResolution = false;
+    try {
+      return fn();
+    } finally {
+      this.expectedType = savedType;
+      this.suppressBareEnumResolution = savedSuppress;
+    }
+  }
+
   // ===========================================================================
   // CONVENIENCE LOOKUP METHODS
   // ===========================================================================
@@ -1136,14 +1186,29 @@ export default class CodeGenState {
   }
 
   /**
-   * Check if a scope variable has an opaque type (and is thus a pointer).
-   * Used during access generation to determine if & prefix is needed.
+   * Check if generated code accesses an opaque scope variable (and is thus
+   * already a pointer). Used during argument generation to decide whether an
+   * address-of (&) prefix is needed.
    *
-   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
-   * @returns true if this is an opaque scope variable (already a pointer)
+   * Handles two forms:
+   * - Direct access:        "MyScope_widget"     → the handle itself (pointer)
+   * - Array-element access: "MyScope_widgets[i]" → an element of an opaque
+   *   handle array, which is itself a pointer (Issue #996)
+   *
+   * @param generatedCode - The generated access expression (e.g. "UI_widgets[i]")
+   * @returns true if this resolves to an opaque scope variable (already a pointer)
    */
-  static isOpaqueScopeVariable(qualifiedName: string): boolean {
-    return this.opaqueScopeVariables.has(qualifiedName);
+  static isOpaqueScopeVariableAccess(generatedCode: string): boolean {
+    if (this.opaqueScopeVariables.has(generatedCode)) {
+      return true;
+    }
+    // Issue #996: An element of an opaque-handle array is already a pointer.
+    // Match on the base array name that precedes the subscript.
+    const bracketIndex = generatedCode.indexOf("[");
+    if (bracketIndex === -1) {
+      return false;
+    }
+    return this.opaqueScopeVariables.has(generatedCode.slice(0, bracketIndex));
   }
 
   // ===========================================================================