c-next 0.2.4 → 0.2.6

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/helpers/__tests__/VariableModifierBuilder.test.ts

@@ -54,14 +54,46 @@ describe("VariableModifierBuilder", () => {
       expect(result.volatile).toBe("volatile ");
     });
 
-    it("returns extern for const at file scope", () => {
+    it("returns extern for const at file scope (declaration without initializer, C mode)", () => {
       const ctx = {
         constModifier: () => ({}),
         atomicModifier: () => null,
         volatileModifier: () => null,
       };
 
-      const result = VariableModifierBuilder.build(ctx, false);
+      // Declaration (no initializer) in C mode - should have extern
+      const result = VariableModifierBuilder.build(ctx, false, false, false);
+
+      expect(result.extern).toBe("extern ");
+    });
+
+    it("does not return extern for const at file scope with initializer in C mode (MISRA 8.5)", () => {
+      // MISRA Rule 8.5: External object/function shall be declared once in one file only.
+      // When a variable has an initializer, it's a DEFINITION, not a declaration.
+      // The extern declaration comes from the header; the .c file should not duplicate it.
+      const ctx = {
+        constModifier: () => ({}),
+        atomicModifier: () => null,
+        volatileModifier: () => null,
+      };
+
+      // Definition (has initializer) in C mode - should NOT have extern
+      const result = VariableModifierBuilder.build(ctx, false, true, false);
+
+      expect(result.extern).toBe("");
+    });
+
+    it("returns extern for const at file scope with initializer in C++ mode (Issue #525)", () => {
+      // In C++, const at file scope has internal linkage by default.
+      // extern is needed for cross-file access, even for definitions.
+      const ctx = {
+        constModifier: () => ({}),
+        atomicModifier: () => null,
+        volatileModifier: () => null,
+      };
+
+      // Definition (has initializer) in C++ mode - SHOULD have extern for external linkage
+      const result = VariableModifierBuilder.build(ctx, false, true, true);
 
       expect(result.extern).toBe("extern ");
     });

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/types/TTypeInfo.ts

@@ -19,6 +19,7 @@ type TTypeInfo = {
   isAtomic?: boolean;
   isExternalCppType?: boolean; // Issue #375: C++ types instantiated via constructor
   isParameter?: boolean; // Issue #579: Track if this is a function parameter (becomes pointer in C)
+  isPointer?: boolean; // Issue #895 Bug B: Track if variable is a pointer (inferred from C function return type)
 };
 
 export default TTypeInfo;

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/utils/BitUtils.ts

@@ -6,16 +6,17 @@
  */
 class BitUtils {
   /**
-   * Convert a boolean expression to an integer (0 or 1).
+   * Convert a boolean expression to an unsigned integer (0U or 1U).
    * Handles literal "true"/"false" and generates ternary for expressions.
+   * Uses unsigned literals for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param expr - The expression to convert
-   * @returns C code string representing the integer value
+   * @returns C code string representing the unsigned integer value
    */
   static boolToInt(expr: string): string {
-    if (expr === "true") return "1";
-    if (expr === "false") return "0";
-    return `(${expr} ? 1 : 0)`;
+    if (expr === "true") return "1U";
+    if (expr === "false") return "0U";
+    return `(${expr} ? 1U : 0U)`;
   }
 
   /**
@@ -78,25 +79,27 @@ class BitUtils {
   }
 
   /**
-   * Return the appropriate "1" literal for a given type.
-   * Uses "1ULL" for 64-bit types to avoid undefined behavior on large shifts.
+   * Return the appropriate unsigned "1" literal for a given type.
+   * Uses "1ULL" for 64-bit types, "1U" for others.
+   * MISRA C:2012 Rule 10.1 requires unsigned operands for bitwise operations.
    *
    * @param typeName - The C-Next type name (e.g., "u64", "i32")
-   * @returns "1ULL" for 64-bit types, "1" otherwise
+   * @returns "1ULL" for 64-bit types, "1U" otherwise
    */
   static oneForType(typeName: string): string {
-    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1";
+    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1U";
   }
 
   /**
-   * Format a number as an uppercase hex string (e.g., 255 -> "0xFF").
+   * Format a number as an unsigned uppercase hex string (e.g., 255 -> "0xFFU").
    * Used for generating hex mask literals in generated C code.
+   * Includes U suffix for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param value - The numeric value to format
-   * @returns Hex string like "0xFF" or "0x1F"
+   * @returns Hex string like "0xFFU" or "0x1FU"
    */
   static formatHex(value: number): string {
-    return `0x${value.toString(16).toUpperCase()}`;
+    return `0x${value.toString(16).toUpperCase()}U`;
   }
 
   /**
@@ -154,7 +157,7 @@ class BitUtils {
   ): string {
     const intValue = BitUtils.boolToInt(value);
     const is64Bit = targetType === "u64" || targetType === "i64";
-    const one = is64Bit ? "1ULL" : "1";
+    const one = is64Bit ? "1ULL" : "1U";
     // For 64-bit types, cast the value to ensure shift doesn't overflow
     const valueShift = is64Bit
       ? `((uint64_t)${intValue} << ${offset})`
@@ -203,6 +206,7 @@ class BitUtils {
   ): string {
     const intValue = BitUtils.boolToInt(value);
     // For 64-bit types, cast to ensure correct shift width
+    // boolToInt already returns unsigned values (1U/0U) for MISRA 10.1 compliance
     const castPrefix =
       targetType === "u64" || targetType === "i64" ? "(uint64_t)" : "";
     return `${target} = (${castPrefix}${intValue} << ${offset});`;

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