c-next 0.2.6 → 0.2.7

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

@@ -6,8 +6,11 @@
  *   "void (*)(Point p)"
  *
  * Used by Issue #895 to determine if callback params should be pointers or values.
+ * Used by Issue #914 to resolve callback pointer/const info onto IParameterSymbol.
  */
 
+import IParameterSymbol from "../../../../utils/types/IParameterSymbol";
+
 /**
  * Parsed parameter info from a typedef.
  */
@@ -215,6 +218,37 @@ class TypedefParamParser {
       TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null
     );
   }
+
+  /**
+   * Resolve callback pointer/const overrides onto an array of IParameterSymbol.
+   *
+   * Issue #914: This is the single point where callback typedef info is applied
+   * to parameters — used by both .c and .h generation paths via IParameterSymbol.
+   *
+   * @param params - The original parameter symbols
+   * @param callbackTypedefType - The typedef type string (e.g., "void (*)(widget_t *, const rect_t *)")
+   * @returns New array with isCallbackPointer/isCallbackConst resolved
+   */
+  static resolveCallbackParams(
+    params: readonly IParameterSymbol[],
+    callbackTypedefType: string,
+  ): IParameterSymbol[] {
+    return params.map((param, index) => {
+      const shouldBePointer = TypedefParamParser.shouldBePointer(
+        callbackTypedefType,
+        index,
+      );
+      const shouldBeConst = TypedefParamParser.shouldBeConst(
+        callbackTypedefType,
+        index,
+      );
+      return {
+        ...param,
+        isCallbackPointer: shouldBePointer ?? undefined,
+        isCallbackConst: shouldBeConst ?? undefined,
+      };
+    });
+  }
 }
 
 export default TypedefParamParser;

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

@@ -285,6 +285,54 @@ describe("ParameterInputAdapter", () => {
 
       expect(result.isAutoConst).toBe(false);
     });
+
+    it("forces pointer when isCallbackPointer is set (Issue #914)", () => {
+      const param: IParameterSymbol = {
+        name: "buf",
+        type: "u8",
+        isConst: false,
+        isArray: false,
+        isCallbackPointer: true,
+      };
+
+      // Even though deps says pass-by-value, callback overrides it
+      const deps = { ...defaultDeps, isPassByValue: true };
+      const result = ParameterInputAdapter.fromSymbol(param, deps);
+
+      expect(result.isPassByValue).toBe(false);
+      expect(result.isPassByReference).toBe(true);
+      expect(result.forcePointerSyntax).toBe(true);
+    });
+
+    it("forces const when isCallbackConst is set (Issue #914)", () => {
+      const param: IParameterSymbol = {
+        name: "area",
+        type: "rect_t",
+        isConst: false,
+        isArray: false,
+        isCallbackPointer: true,
+        isCallbackConst: true,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.forceConst).toBe(true);
+      expect(result.forcePointerSyntax).toBe(true);
+    });
+
+    it("does not force pointer when isCallbackPointer is not set", () => {
+      const param: IParameterSymbol = {
+        name: "value",
+        type: "u32",
+        isConst: false,
+        isArray: false,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.forcePointerSyntax).toBeUndefined();
+      expect(result.forceConst).toBeUndefined();
+    });
   });
 
   describe("fromAST", () => {

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

@@ -4,6 +4,7 @@
 
 import { describe, expect, it } from "vitest";
 import TypedefParamParser from "../TypedefParamParser";
+import IParameterSymbol from "../../../../../utils/types/IParameterSymbol";
 
 describe("TypedefParamParser", () => {
   describe("parse", () => {
@@ -206,4 +207,91 @@ describe("TypedefParamParser", () => {
       expect(TypedefParamParser.shouldBeConst(typedef, 2)).toBe(false);
     });
   });
+
+  describe("resolveCallbackParams (Issue #914)", () => {
+    function makeParam(
+      name: string,
+      type: string,
+      overrides?: Partial<IParameterSymbol>,
+    ): IParameterSymbol {
+      return {
+        name,
+        type,
+        isConst: false,
+        isArray: false,
+        ...overrides,
+      };
+    }
+
+    it("should set isCallbackPointer for pointer params", () => {
+      const params = [makeParam("w", "widget_t"), makeParam("buf", "u8")];
+      const typedef = "void (*)(widget_t *, uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackPointer).toBe(true);
+    });
+
+    it("should set isCallbackConst for const pointer params", () => {
+      const params = [
+        makeParam("w", "widget_t"),
+        makeParam("area", "rect_t"),
+        makeParam("buf", "u8"),
+      ];
+      const typedef = "void (*)(widget_t *, const rect_t *, uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[0].isCallbackConst).toBe(false);
+
+      expect(result[1].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackConst).toBe(true);
+
+      expect(result[2].isCallbackPointer).toBe(true);
+      expect(result[2].isCallbackConst).toBe(false);
+    });
+
+    it("should not set callback flags for value params", () => {
+      const params = [makeParam("count", "u32")];
+      const typedef = "void (*)(int count)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(false);
+      expect(result[0].isCallbackConst).toBe(false);
+    });
+
+    it("should preserve existing param fields", () => {
+      const params = [
+        makeParam("data", "u8", {
+          isConst: true,
+          isArray: true,
+          arrayDimensions: ["10"],
+        }),
+      ];
+      const typedef = "void (*)(uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].name).toBe("data");
+      expect(result[0].type).toBe("u8");
+      expect(result[0].isConst).toBe(true);
+      expect(result[0].isArray).toBe(true);
+      expect(result[0].arrayDimensions).toEqual(["10"]);
+      expect(result[0].isCallbackPointer).toBe(true);
+    });
+
+    it("should handle params beyond typedef length gracefully", () => {
+      const params = [makeParam("w", "widget_t"), makeParam("extra", "u32")];
+      const typedef = "void (*)(widget_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackPointer).toBeUndefined();
+      expect(result[1].isCallbackConst).toBeUndefined();
+    });
+  });
 });

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

@@ -278,15 +278,28 @@ class HeaderGeneratorUtils {
     }
 
     // User includes
+    // Issue #933: Transform .h to .hpp in C++ mode so headers include correct files
     if (options.userIncludes && options.userIncludes.length > 0) {
       for (const include of options.userIncludes) {
-        lines.push(include);
+        const transformedInclude = options.cppMode
+          ? include.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
+          : include;
+        lines.push(transformedInclude);
       }
     }
 
     // External type header includes (skip duplicates of user includes)
-    const userIncludeSet = new Set(options.userIncludes ?? []);
+    // Note: External C headers stay as .h - only user includes from .cnx files get
+    // transformed to .hpp in C++ mode (those are C-Next generated headers)
+    const userIncludeSet = new Set(
+      options.userIncludes?.map((inc) =>
+        options.cppMode
+          ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
+          : inc,
+      ) ?? [],
+    );
     for (const directive of headersToInclude) {
+      // Don't transform external C headers - they should stay as .h
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
       }

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

@@ -20,6 +20,8 @@ function createFunctionSymbol(
     isAutoConst?: boolean;
     isArray?: boolean;
     arrayDimensions?: string[];
+    isCallbackPointer?: boolean;
+    isCallbackConst?: boolean;
   }>,
 ): IHeaderSymbol {
   return {
@@ -36,6 +38,8 @@ function createFunctionSymbol(
       isAutoConst: p.isAutoConst ?? false,
       isArray: p.isArray ?? false,
       arrayDimensions: p.arrayDimensions,
+      isCallbackPointer: p.isCallbackPointer,
+      isCallbackConst: p.isCallbackConst,
     })),
   };
 }
@@ -239,4 +243,87 @@ describe("BaseHeaderGenerator", () => {
       expect(result).toContain("void processData(const MyStruct* data);");
     });
   });
+
+  describe("Callback-compatible functions (Issue #914)", () => {
+    it("should use pointer for primitive param when isCallbackPointer is set (C mode)", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain("uint8_t* buf");
+    });
+
+    it("should use pointer for primitive param when isCallbackPointer is set (C++ mode)", () => {
+      const generator = new CppHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      // Must use * not & because headers are wrapped in extern "C"
+      expect(result).toContain("uint8_t* buf");
+    });
+
+    it("should use const pointer for struct param with isCallbackConst (C mode)", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          {
+            name: "area",
+            type: "rect_t",
+            isCallbackPointer: true,
+            isCallbackConst: true,
+          },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain("const rect_t* area");
+    });
+
+    it("should use non-const pointer for struct param without isCallbackConst (C++ mode)", () => {
+      const generator = new CppHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "w", type: "widget_t", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      // Must use * not & for callback params
+      expect(result).toContain("widget_t* w");
+    });
+
+    it("should handle mixed callback and non-callback params", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "w", type: "widget_t", isCallbackPointer: true },
+          {
+            name: "area",
+            type: "rect_t",
+            isCallbackPointer: true,
+            isCallbackConst: true,
+          },
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain(
+        "void Renderer_flush(widget_t* w, const rect_t* area, uint8_t* buf);",
+      );
+    });
+  });
 });

package/src/utils/ExpressionUtils.ts

@@ -140,6 +140,57 @@ class ExpressionUtils {
     return identifier?.getText() ?? null;
   }
 
+  /**
+   * Collect all additive expressions from a ternary expression.
+   *
+   * Uses flatMap chains to traverse the expression grammar efficiently.
+   * Useful for analyzers that need to examine operands at the additive level.
+   *
+   * @param ctx - The ternary expression context
+   * @returns Array of all additive expression contexts in the tree
+   */
+  static collectAdditiveExpressions(
+    ctx: Parser.TernaryExpressionContext,
+  ): Parser.AdditiveExpressionContext[] {
+    return ExpressionUtils.collectAdditiveFromOrExprs(ctx.orExpression());
+  }
+
+  /**
+   * Collect additive expressions from an array of orExpression contexts.
+   *
+   * Internal helper that performs the actual flatMap traversal.
+   */
+  private static collectAdditiveFromOrExprs(
+    orExprs: Parser.OrExpressionContext[],
+  ): Parser.AdditiveExpressionContext[] {
+    return orExprs
+      .flatMap((or) => or.andExpression())
+      .flatMap((and) => and.equalityExpression())
+      .flatMap((eq) => eq.relationalExpression())
+      .flatMap((rel) => rel.bitwiseOrExpression())
+      .flatMap((bor) => bor.bitwiseXorExpression())
+      .flatMap((bxor) => bxor.bitwiseAndExpression())
+      .flatMap((band) => band.shiftExpression())
+      .flatMap((shift) => shift.additiveExpression());
+  }
+
+  /**
+   * Collect all unary expressions from an orExpression context.
+   *
+   * Traverses through the entire expression hierarchy to find all unary expressions.
+   * Useful for analyzers that need to examine leaf operands.
+   *
+   * @param orExpr - The orExpression context
+   * @returns Array of all unary expression contexts in the tree
+   */
+  static collectUnaryFromOrExpr(
+    orExpr: Parser.OrExpressionContext,
+  ): Parser.UnaryExpressionContext[] {
+    return ExpressionUtils.collectAdditiveFromOrExprs([orExpr])
+      .flatMap((add) => add.multiplicativeExpression())
+      .flatMap((mul) => mul.unaryExpression());
+  }
+
   /**
    * ADR-023: Check if an expression contains a function call anywhere in its tree.
    *

package/src/utils/types/IParameterSymbol.ts

@@ -8,6 +8,8 @@ interface IParameterSymbol {
   isArray: boolean;
   arrayDimensions?: string[]; // e.g., ["10", "20"] or ["", ""] for unbounded
   isAutoConst?: boolean; // Issue #268: true if parameter should get auto-const (unmodified pointer)
+  isCallbackPointer?: boolean; // Issue #914: typedef says this param must be a pointer
+  isCallbackConst?: boolean; // Issue #914: typedef says this param must be const
 }
 
 export default IParameterSymbol;