c-next 0.2.4 → 0.2.5

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

@@ -0,0 +1,209 @@
+/**
+ * Unit tests for TypedefParamParser
+ */
+
+import { describe, expect, it } from "vitest";
+import TypedefParamParser from "../TypedefParamParser";
+
+describe("TypedefParamParser", () => {
+  describe("parse", () => {
+    it("should parse simple callback with pointer params", () => {
+      const result = TypedefParamParser.parse(
+        "void (*)(widget_t *, const rect_t *, uint8_t *)",
+      );
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(3);
+
+      expect(result!.params[0].isPointer).toBe(true);
+      expect(result!.params[0].isConst).toBe(false);
+      expect(result!.params[0].baseType).toBe("widget_t");
+
+      expect(result!.params[1].isPointer).toBe(true);
+      expect(result!.params[1].isConst).toBe(true);
+      expect(result!.params[1].baseType).toBe("rect_t");
+
+      expect(result!.params[2].isPointer).toBe(true);
+      expect(result!.params[2].isConst).toBe(false);
+      expect(result!.params[2].baseType).toBe("uint8_t");
+    });
+
+    it("should parse callback without spaces (C grammar format)", () => {
+      // This is the actual format from CResolver - getText() may strip spaces
+      const result = TypedefParamParser.parse(
+        "void (*)(widget_t*,const rect_t*,uint8_t*)",
+      );
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(3);
+
+      expect(result!.params[0].isPointer).toBe(true);
+      expect(result!.params[0].isConst).toBe(false);
+      expect(result!.params[0].baseType).toBe("widget_t");
+
+      expect(result!.params[1].isPointer).toBe(true);
+      expect(result!.params[1].isConst).toBe(true);
+      expect(result!.params[1].baseType).toBe("rect_t");
+
+      expect(result!.params[2].isPointer).toBe(true);
+      expect(result!.params[2].isConst).toBe(false);
+      expect(result!.params[2].baseType).toBe("uint8_t");
+    });
+
+    it("should parse callback with value params", () => {
+      const result = TypedefParamParser.parse("void (*)(Point p)");
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(1);
+
+      expect(result!.params[0].isPointer).toBe(false);
+      expect(result!.params[0].isConst).toBe(false);
+      expect(result!.params[0].baseType).toBe("Point");
+    });
+
+    it("should parse callback with no params", () => {
+      const result = TypedefParamParser.parse("void (*)(void)");
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(0);
+    });
+
+    it("should parse callback with primitive return type", () => {
+      const result = TypedefParamParser.parse("int (*)(int x, int y)");
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("int");
+      expect(result!.params).toHaveLength(2);
+
+      expect(result!.params[0].isPointer).toBe(false);
+      expect(result!.params[0].baseType).toBe("int");
+
+      expect(result!.params[1].isPointer).toBe(false);
+      expect(result!.params[1].baseType).toBe("int");
+    });
+
+    it("should return null for invalid typedef", () => {
+      expect(TypedefParamParser.parse("not a typedef")).toBeNull();
+      expect(TypedefParamParser.parse("void foo()")).toBeNull();
+      expect(TypedefParamParser.parse("")).toBeNull();
+    });
+
+    it("should handle mixed pointer and value params", () => {
+      const result = TypedefParamParser.parse(
+        "void (*)(Point* p, int count, Rect r)",
+      );
+
+      expect(result).not.toBeNull();
+      expect(result!.params).toHaveLength(3);
+
+      expect(result!.params[0].isPointer).toBe(true);
+      expect(result!.params[0].baseType).toBe("Point");
+
+      expect(result!.params[1].isPointer).toBe(false);
+      expect(result!.params[1].baseType).toBe("int");
+
+      expect(result!.params[2].isPointer).toBe(false);
+      expect(result!.params[2].baseType).toBe("Rect");
+    });
+
+    it("should parse callback with nested function pointer param", () => {
+      // Nested function pointer: void (*)(void (*)(int))
+      const result = TypedefParamParser.parse("void (*)(void (*)(int))");
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(1);
+
+      // The param is itself a function pointer
+      expect(result!.params[0].type).toBe("void (*)(int)");
+      expect(result!.params[0].isPointer).toBe(true); // Function pointers are pointers
+    });
+
+    it("should parse callback with deeply nested function pointer", () => {
+      // Two levels of nesting: void (*)(void (*)(void (*)(int)))
+      const result = TypedefParamParser.parse(
+        "void (*)(void (*)(void (*)(int)))",
+      );
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(1);
+      expect(result!.params[0].type).toBe("void (*)(void (*)(int))");
+    });
+
+    it("should parse callback with mixed nested and regular params", () => {
+      // Mix of nested function pointer and regular params
+      const result = TypedefParamParser.parse(
+        "void (*)(int x, void (*)(int), char* str)",
+      );
+
+      expect(result).not.toBeNull();
+      expect(result!.returnType).toBe("void");
+      expect(result!.params).toHaveLength(3);
+
+      expect(result!.params[0].baseType).toBe("int");
+      expect(result!.params[0].isPointer).toBe(false);
+
+      expect(result!.params[1].type).toBe("void (*)(int)");
+      expect(result!.params[1].isPointer).toBe(true);
+
+      expect(result!.params[2].baseType).toBe("char");
+      expect(result!.params[2].isPointer).toBe(true);
+    });
+  });
+
+  describe("shouldBePointer", () => {
+    it("should return true for pointer params", () => {
+      const typedef = "void (*)(widget_t *, uint8_t *)";
+
+      expect(TypedefParamParser.shouldBePointer(typedef, 0)).toBe(true);
+      expect(TypedefParamParser.shouldBePointer(typedef, 1)).toBe(true);
+    });
+
+    it("should return false for value params", () => {
+      const typedef = "void (*)(Point p, int count)";
+
+      expect(TypedefParamParser.shouldBePointer(typedef, 0)).toBe(false);
+      expect(TypedefParamParser.shouldBePointer(typedef, 1)).toBe(false);
+    });
+
+    it("should return null for out of bounds index", () => {
+      const typedef = "void (*)(Point p)";
+
+      expect(TypedefParamParser.shouldBePointer(typedef, 1)).toBeNull();
+      expect(TypedefParamParser.shouldBePointer(typedef, 99)).toBeNull();
+    });
+
+    it("should return null for invalid typedef", () => {
+      expect(TypedefParamParser.shouldBePointer("invalid", 0)).toBeNull();
+    });
+  });
+
+  describe("shouldBeConst", () => {
+    it("should return true for const params", () => {
+      const typedef = "void (*)(const Point* p, const char* s)";
+
+      expect(TypedefParamParser.shouldBeConst(typedef, 0)).toBe(true);
+      expect(TypedefParamParser.shouldBeConst(typedef, 1)).toBe(true);
+    });
+
+    it("should return false for non-const params", () => {
+      const typedef = "void (*)(Point* p, uint8_t* buf)";
+
+      expect(TypedefParamParser.shouldBeConst(typedef, 0)).toBe(false);
+      expect(TypedefParamParser.shouldBeConst(typedef, 1)).toBe(false);
+    });
+
+    it("should handle mixed const params", () => {
+      const typedef = "void (*)(widget_t* w, const rect_t* area, uint8_t* buf)";
+
+      expect(TypedefParamParser.shouldBeConst(typedef, 0)).toBe(false);
+      expect(TypedefParamParser.shouldBeConst(typedef, 1)).toBe(true);
+      expect(TypedefParamParser.shouldBeConst(typedef, 2)).toBe(false);
+    });
+  });
+});

package/src/transpiler/output/codegen/resolution/EnumTypeResolver.ts

@@ -17,7 +17,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
 import CodeGenState from "../../../state/CodeGenState";
 import TypeResolver from "../TypeResolver";
-import ExpressionUnwrapper from "../utils/ExpressionUnwrapper";
+import ExpressionUnwrapper from "../../../../utils/ExpressionUnwrapper";
 import QualifiedNameGenerator from "../utils/QualifiedNameGenerator";
 
 /**

package/src/transpiler/output/codegen/resolution/SizeofResolver.ts

@@ -11,7 +11,7 @@
 
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
 import CodeGenState from "../../../state/CodeGenState";
-import ExpressionUnwrapper from "../utils/ExpressionUnwrapper";
+import ExpressionUnwrapper from "../../../../utils/ExpressionUnwrapper";
 
 /**
  * Callbacks for operations that require CodeGenerator context.

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

@@ -53,6 +53,19 @@ interface IParameterInput {
 
   /** Whether to use pass-by-reference semantics (known struct or known primitive) */
   isPassByReference: boolean;
+
+  /**
+   * Issue #895: Force pointer syntax even in C++ mode.
+   * Required for callback-compatible functions because C callback typedefs
+   * expect pointers, not C++ references.
+   */
+  forcePointerSyntax?: boolean;
+
+  /**
+   * Issue #895: Force const qualifier from callback typedef signature.
+   * When the C typedef has `const T*`, this preserves const on the generated param.
+   */
+  forceConst?: boolean;
 }
 
 export default IParameterInput;

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

@@ -23,6 +23,13 @@ interface ISeparatorContext {
 
   /** Whether scopedRegName refers to a known register */
   readonly isScopedRegister: boolean;
+
+  /**
+   * Issue #895: Force pointer semantics even in C++ mode.
+   * When true, struct params use -> instead of . because they're part of
+   * a callback-compatible function that must match C typedef signatures.
+   */
+  readonly forcePointerSemantics?: boolean;
 }
 
 export default ISeparatorContext;

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

@@ -14,6 +14,18 @@ type TParameterInfo = {
   isConst: boolean; // ADR-013
   isCallback: boolean; // ADR-029
   isString: boolean; // ADR-045
+  /**
+   * Issue #895: True when a primitive param becomes a pointer due to callback typedef.
+   * When used as a value in expressions, these params need dereferencing (*param).
+   */
+  isCallbackPointerPrimitive?: boolean;
+
+  /**
+   * Issue #895: True when a param needs pointer semantics due to callback typedef.
+   * In C++ mode, this forces -> member access instead of . (reference access).
+   * Applies to both struct and primitive callback-compatible params.
+   */
+  forcePointerSemantics?: boolean;
 };
 
 export default TParameterInfo;

package/src/transpiler/output/codegen/utils/CodegenParserUtils.ts

@@ -7,7 +7,7 @@
 
 import { ParserRuleContext, TerminalNode } from "antlr4ng";
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
-import ExpressionUnwrapper from "./ExpressionUnwrapper";
+import ExpressionUnwrapper from "../../../../utils/ExpressionUnwrapper";
 
 /**
  * Static utility methods for parser context operations in code generation.

package/src/transpiler/state/CodeGenState.ts

@@ -128,8 +128,12 @@ export default class CodeGenState {
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes: Map<string, string> = new Map();
 
-  /** Functions that need C-callback-compatible (by-value) struct parameters */
-  static callbackCompatibleFunctions: Set<string> = new Set();
+  /**
+   * Functions that are assigned to C callback typedefs.
+   * Maps function name -> typedef name (e.g., "my_flush" -> "flush_cb_t")
+   * Issue #895: We need the typedef name to look up parameter types.
+   */
+  static callbackCompatibleFunctions: Map<string, string> = new Map();
 
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
@@ -624,6 +628,21 @@ export default class CodeGenState {
     return this.callbackTypes.get(name);
   }
 
+  /**
+   * Issue #895: Get the typedef type string for a C typedef by name.
+   * Used to look up function pointer typedef signatures for callback-compatible functions.
+   *
+   * @param typedefName - Name of the typedef (e.g., "flush_cb_t")
+   * @returns The type string (e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)") or undefined
+   */
+  static getTypedefType(typedefName: string): string | undefined {
+    const symbol = this.symbolTable.getCSymbol(typedefName);
+    if (symbol?.kind === "type") {
+      return symbol.type;
+    }
+    return undefined;
+  }
+
   /**
    * Check if a type name is a known C-Next function.
    */

package/src/{transpiler/output/codegen/utils → utils}/ExpressionUnwrapper.ts

@@ -16,7 +16,7 @@
  * eliminate code duplication.
  */
 
-import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import * as Parser from "../transpiler/logic/parser/grammar/CNextParser";
 
 /**
  * Utility class for navigating expression tree hierarchy

package/src/{transpiler/output/codegen/utils → utils}/__tests__/ExpressionUnwrapper.test.ts

@@ -4,8 +4,8 @@
 
 import { describe, it, expect } from "vitest";
 import ExpressionUnwrapper from "../ExpressionUnwrapper";
-import CNextSourceParser from "../../../../logic/parser/CNextSourceParser";
-import * as Parser from "../../../../logic/parser/grammar/CNextParser";
+import CNextSourceParser from "../../transpiler/logic/parser/CNextSourceParser";
+import * as Parser from "../../transpiler/logic/parser/grammar/CNextParser";
 
 /**
  * Helper to parse a simple expression and get its ExpressionContext