c-next 0.2.16 → 0.2.18

package/src/transpiler/output/codegen/subscript/__tests__/SubscriptClassifier.test.ts

@@ -74,8 +74,13 @@ describe("SubscriptClassifier", () => {
       });
     });
 
-    describe("parameter types (Issue #579)", () => {
-      it("returns array_element for non-array parameter with single index", () => {
+    describe("parameter types (Issue #1100)", () => {
+      // A parameter's array-ness is determined solely by its declared type
+      // (isArray, from explicit `T[N]` syntax, ADR-006) — identical to local
+      // variables. `isParameter` alone must NOT force array classification;
+      // that was the Issue #579 heuristic reverted by Issue #1100 because it
+      // broke ADR-007 bit-indexing for scalar parameters.
+      it("returns bit_single for non-array parameter with single index", () => {
         const typeInfo: TTypeInfo = {
           baseType: "u8",
           bitWidth: 8,
@@ -88,10 +93,10 @@ describe("SubscriptClassifier", () => {
           subscriptCount: 1,
           isRegisterAccess: false,
         });
-        expect(result).toBe("array_element");
+        expect(result).toBe("bit_single");
       });
 
-      it("returns array_slice for non-array parameter with two indices", () => {
+      it("returns bit_range for non-array parameter with two indices", () => {
         const typeInfo: TTypeInfo = {
           baseType: "u8",
           bitWidth: 8,
@@ -104,7 +109,23 @@ describe("SubscriptClassifier", () => {
           subscriptCount: 2,
           isRegisterAccess: false,
         });
-        expect(result).toBe("array_slice");
+        expect(result).toBe("bit_range");
+      });
+
+      it("returns array_element for array parameter with single index", () => {
+        const typeInfo: TTypeInfo = {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+          isParameter: true,
+        };
+        const result = SubscriptClassifier.classify({
+          typeInfo,
+          subscriptCount: 1,
+          isRegisterAccess: false,
+        });
+        expect(result).toBe("array_element");
       });
     });
 
@@ -187,7 +208,7 @@ describe("SubscriptClassifier", () => {
       expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(true);
     });
 
-    it("returns true for parameter type", () => {
+    it("returns false for non-array parameter type (Issue #1100)", () => {
       const typeInfo: TTypeInfo = {
         baseType: "u8",
         bitWidth: 8,
@@ -195,6 +216,17 @@ describe("SubscriptClassifier", () => {
         isConst: false,
         isParameter: true,
       };
+      expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(false);
+    });
+
+    it("returns true for array parameter type", () => {
+      const typeInfo: TTypeInfo = {
+        baseType: "u8",
+        bitWidth: 8,
+        isArray: true,
+        isConst: false,
+        isParameter: true,
+      };
       expect(SubscriptClassifier.isArrayAccess(typeInfo)).toBe(true);
     });
 

package/src/transpiler/output/codegen/types/ICallbackTypeInfo.ts

@@ -10,7 +10,8 @@ interface ICallbackTypeInfo {
     name: string;
     type: string; // C type
     isConst: boolean;
-    isPointer: boolean; // Non-array params become pointers
+    isPointer: boolean; // Non-array params become pointers (C mode only for structs)
+    isStruct: boolean; // True if parameter type is a struct (ADR-006 reference semantics)
     isArray: boolean; // Array parameters pass naturally as pointers
     arrayDims: string; // Array dimensions if applicable
   }>;

package/src/transpiler/output/codegen/types/IParameterInput.ts

@@ -66,6 +66,13 @@ interface IParameterInput {
    * When the C typedef has `const T*`, this preserves const on the generated param.
    */
   forceConst?: boolean;
+
+  /**
+   * Issue #995: Whether the parameter type is an opaque handle (incomplete struct typedef).
+   * This is a pass-through flag; the rule (suppress auto-const, force pointer) is applied
+   * in ParameterSignatureBuilder to avoid dual code paths.
+   */
+  isOpaqueHandle?: boolean;
 }
 
 export default IParameterInput;

package/src/transpiler/output/headers/BaseHeaderGenerator.ts

@@ -116,6 +116,14 @@ abstract class BaseHeaderGenerator {
       ...HeaderGeneratorUtils.generateEnumSection(groups.enums, typeInput),
       ...HeaderGeneratorUtils.generateBitmapSection(groups.bitmaps, typeInput),
       ...HeaderGeneratorUtils.generateTypeAliasSection(groups.types),
+      ...HeaderGeneratorUtils.generateCallbackStructForwardDecls(
+        groups.structs,
+        typeInput,
+      ),
+      ...HeaderGeneratorUtils.generateCallbackTypedefSection(
+        typeInput,
+        options.cppMode,
+      ),
       ...HeaderGeneratorUtils.generateStructSection(
         groups.structs,
         groups.classes,

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

@@ -17,6 +17,7 @@ import generateStructHeader from "./generators/generateStructHeader";
 import generateBitmapHeader from "./generators/generateBitmapHeader";
 import VariableDeclarationFormatter from "../codegen/helpers/VariableDeclarationFormatter";
 import type IVariableFormatInput from "../codegen/types/IVariableFormatInput";
+import MisraSuppressionUtils from "../MisraSuppressionUtils";
 
 const { mapType, isBuiltInType } = typeUtils;
 
@@ -267,6 +268,65 @@ class HeaderGeneratorUtils {
     ];
   }
 
+  /**
+   * Extract header file stem from include directive for deduplication.
+   * E.g., '#include <foo/bar.hpp>' -> 'bar'
+   * SonarCloud S8786: Avoid backtracking by using separate patterns.
+   */
+  private static extractIncludeStem(include: string): string {
+    // Try angle brackets first, then quotes - avoids backtracking regex
+    const angleMatch = /<([^<>]+)>/.exec(include);
+    if (angleMatch) {
+      return angleMatch[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    }
+    const quoteMatch = /"([^"]+)"/.exec(include);
+    if (quoteMatch) {
+      return quoteMatch[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    }
+    return include;
+  }
+
+  /**
+   * Add user includes with MISRA suppression comments.
+   * SonarCloud S3776: Extracted from generateIncludes.
+   */
+  private static addUserIncludes(
+    lines: string[],
+    userIncludes: string[] | undefined,
+  ): void {
+    if (!userIncludes || userIncludes.length === 0) return;
+    for (const include of userIncludes) {
+      // Issue #850: Add MISRA suppression for banned headers
+      const suppression =
+        MisraSuppressionUtils.getMisraSuppressionComment(include);
+      if (suppression) {
+        lines.push(suppression);
+      }
+      lines.push(include);
+    }
+  }
+
+  /**
+   * Add external type headers, deduplicating against user includes.
+   * SonarCloud S3776: Extracted from generateIncludes.
+   */
+  private static addExternalTypeHeaders(
+    lines: string[],
+    headersToInclude: Set<string>,
+    userIncludes: string[] | undefined,
+  ): void {
+    const userIncludeSet = new Set(userIncludes ?? []);
+    const userIncludeStems = new Set(
+      (userIncludes ?? []).map(HeaderGeneratorUtils.extractIncludeStem),
+    );
+    for (const directive of headersToInclude) {
+      if (userIncludeSet.has(directive)) continue;
+      const stem = HeaderGeneratorUtils.extractIncludeStem(directive);
+      if (stem && userIncludeStems.has(stem)) continue;
+      lines.push(directive);
+    }
+  }
+
   /**
    * Generate all include directives (system, user, and external type headers)
    */
@@ -282,37 +342,18 @@ class HeaderGeneratorUtils {
     }
 
     // User includes (already have correct extension from IncludeExtractor)
-    if (options.userIncludes && options.userIncludes.length > 0) {
-      for (const include of options.userIncludes) {
-        lines.push(include);
-      }
-    }
+    HeaderGeneratorUtils.addUserIncludes(lines, options.userIncludes);
 
     // External type header includes (skip duplicates of user includes)
     // Dedup by basename stem to handle:
     // - Different path styles (e.g., <AppConfig.hpp> vs "../AppConfig.hpp")
     // - Extension mismatch from timing (.h from IncludeResolver before cppDetected,
     //   .hpp from IncludeExtractor after cppDetected)
-    const userIncludeSet = new Set(options.userIncludes ?? []);
-    const extractStem = (inc: string): string => {
-      const match = /["<]([^">]+)[">]/.exec(inc);
-      if (!match) return inc;
-      return match[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
-    };
-    const userIncludeStems = new Set(
-      (options.userIncludes ?? []).map(extractStem),
+    HeaderGeneratorUtils.addExternalTypeHeaders(
+      lines,
+      headersToInclude,
+      options.userIncludes,
     );
-    for (const directive of headersToInclude) {
-      if (userIncludeSet.has(directive)) {
-        continue;
-      }
-      // Check if a user include already covers the same file
-      const stem = extractStem(directive);
-      if (stem && userIncludeStems.has(stem)) {
-        continue;
-      }
-      lines.push(directive);
-    }
 
     // Add blank line if any includes were added
     const hasIncludes =
@@ -416,6 +457,81 @@ class HeaderGeneratorUtils {
     return lines;
   }
 
+  /**
+   * ADR-029: Generate forward declarations for structs used in callback typedefs.
+   * This ensures struct types can be used in callback parameter types before
+   * the full struct definition.
+   */
+  static generateCallbackStructForwardDecls(
+    structs: IHeaderSymbol[],
+    typeInput?: IHeaderTypeInput,
+  ): string[] {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+
+    // Collect struct types that are used in callback parameters
+    const usedStructTypes = new Set<string>();
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      for (const p of cbInfo.parameters) {
+        if (p.isStruct) {
+          usedStructTypes.add(p.type);
+        }
+      }
+    }
+
+    if (usedStructTypes.size === 0) {
+      return [];
+    }
+
+    // Get local struct names to only forward-declare those
+    const localStructNames = new Set(structs.map((s) => s.name));
+
+    const lines: string[] = [];
+    for (const structType of usedStructTypes) {
+      if (localStructNames.has(structType)) {
+        lines.push(`typedef struct ${structType} ${structType};`);
+      }
+    }
+
+    return lines.length > 0 ? [...lines, ""] : [];
+  }
+
+  /**
+   * ADR-029: Generate callback typedef section
+   * Generates function pointer typedefs for callbacks used as struct field types
+   */
+  static generateCallbackTypedefSection(
+    typeInput?: IHeaderTypeInput,
+    isCppMode?: boolean,
+  ): string[] {
+    if (!typeInput?.callbackTypes || typeInput.callbackTypes.size === 0) {
+      return [];
+    }
+
+    const lines: string[] = ["/* Callback typedefs */"];
+    for (const [, cbInfo] of typeInput.callbackTypes) {
+      const params =
+        cbInfo.parameters.length > 0
+          ? cbInfo.parameters
+              .map((p) => {
+                // ADR-006: Struct parameters become pointers (C) or references (C++)
+                if (p.isStruct) {
+                  const ptrOrRef = isCppMode ? "&" : "*";
+                  return `${p.type}${ptrOrRef}`;
+                }
+                return p.type;
+              })
+              .join(", ")
+          : "void";
+      lines.push(
+        `typedef ${cbInfo.returnType} (*${cbInfo.typedefName})(${params});`,
+      );
+    }
+    lines.push("");
+    return lines;
+  }
+
   /**
    * Generate struct and class definitions section
    */

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;