c-next 0.2.6 → 0.2.7

package/src/transpiler/output/codegen/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -583,117 +583,12 @@ describe("PostfixExpressionGenerator", () => {
     });
   });
 
-  describe(".length property", () => {
-    it("returns argc for main args.length", () => {
-      const ctx = createMockPostfixExpressionContext("args", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput();
-      const state = createMockState({ mainArgsName: "args" });
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "argv",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("argc");
-    });
-
-    it("returns comment for unknown type", () => {
-      const ctx = createMockPostfixExpressionContext("unknown", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput();
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "unknown",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toContain("unknown type");
-      expect(result.code).toContain("0");
-    });
-
-    it("returns array dimension for array type", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "arr",
-          {
-            baseType: "u32",
-            bitWidth: 32,
-            isArray: true,
-            arrayDimensions: [10],
-            isConst: false,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("arr", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "arr",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("10");
-    });
-
-    it("returns strlen for string type", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "str",
-          {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("str", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "str",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("strlen(str)");
-    });
-
-    it("uses cached length when available", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "str",
-          {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: false,
-            isConst: false,
-            isString: true,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("str", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState({
-        lengthCache: new Map([["str", "__len_str"]]),
-      });
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "str",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("__len_str");
-    });
+  // Note: .length property tests removed (ADR-058)
+  // .length is deprecated - use explicit properties instead:
+  // .bit_length, .byte_length, .element_count, .char_count
 
-    it("returns bit width for integer type", () => {
+  describe(".length property deprecation", () => {
+    it("throws deprecation error for .length property access", () => {
       const typeRegistry = new Map<string, TTypeInfo>([
         [
           "val",
@@ -714,335 +609,9 @@ describe("PostfixExpressionGenerator", () => {
         generatePrimaryExpr: () => "val",
       });
 
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("32");
-    });
-
-    it("returns 32 for enum type", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "color",
-          {
-            baseType: "Color",
-            bitWidth: 32,
-            isArray: false,
-            isConst: false,
-            isEnum: true,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("color", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "color",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("32");
-    });
-
-    it("returns dimension for 2D array type at depth 0", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "matrix",
-          {
-            baseType: "u32",
-            bitWidth: 32,
-            isArray: true,
-            arrayDimensions: [3, 4],
-            isConst: false,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("matrix", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "matrix",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("3");
-    });
-
-    it("returns dimension for 2D array type at depth 1", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "matrix",
-          {
-            baseType: "u32",
-            bitWidth: 32,
-            isArray: true,
-            arrayDimensions: [3, 4],
-            isConst: false,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("matrix", [
-        createMockPostfixOp({ expressions: [createMockExpression("0")] }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "matrix",
-        generateExpression: () => "0",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("4");
-    });
-
-    it("returns bit width when subscriptDepth exceeds dimensions", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "arr",
-          {
-            baseType: "u32",
-            bitWidth: 32,
-            isArray: true,
-            arrayDimensions: [10],
-            isConst: false,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("arr", [
-        createMockPostfixOp({ expressions: [createMockExpression("0")] }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "arr",
-        generateExpression: () => "0",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("32");
-    });
-
-    it("returns strlen for string array element", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "names",
-          {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: true,
-            arrayDimensions: [5, 32],
-            isConst: false,
-            isString: true,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("names", [
-        createMockPostfixOp({ expressions: [createMockExpression("0")] }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "names",
-        generateExpression: () => "0",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("strlen(names[0])");
-    });
-
-    it("returns dimension for string array at depth 0", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "names",
-          {
-            baseType: "char",
-            bitWidth: 8,
-            isArray: true,
-            arrayDimensions: [5, 32],
-            isConst: false,
-            isString: true,
-          },
-        ],
-      ]);
-      const ctx = createMockPostfixExpressionContext("names", [
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "names",
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("5");
-    });
-
-    it("returns struct field array dimension for struct member access", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "config",
-          {
-            baseType: "Config",
-            bitWidth: 0,
-            isArray: false,
-            isConst: false,
-          },
-        ],
-      ]);
-      const symbols = createMockSymbols({
-        knownStructs: new Set(["Config"]),
-      });
-      const ctx = createMockPostfixExpressionContext("config", [
-        createMockPostfixOp({ identifier: "values" }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ symbols, typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "config",
-        isKnownStruct: (name) => name === "Config",
-        getMemberTypeInfo: () => ({
-          baseType: "u32",
-          isArray: true,
-          bitWidth: 32,
-          isConst: false,
-        }),
-        getStructFieldInfo: () => ({
-          type: "u32",
-          dimensions: [10],
-        }),
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("10");
-    });
-
-    it("returns bit width for scalar struct field", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "point",
-          {
-            baseType: "Point",
-            bitWidth: 0,
-            isArray: false,
-            isConst: false,
-          },
-        ],
-      ]);
-      const symbols = createMockSymbols({
-        knownStructs: new Set(["Point"]),
-      });
-      const ctx = createMockPostfixExpressionContext("point", [
-        createMockPostfixOp({ identifier: "x" }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ symbols, typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "point",
-        isKnownStruct: (name) => name === "Point",
-        getMemberTypeInfo: () => ({
-          baseType: "i32",
-          isArray: false,
-          bitWidth: 32,
-          isConst: false,
-        }),
-        getStructFieldInfo: () => ({
-          type: "i32",
-        }),
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("32");
-    });
-
-    it("returns strlen for string struct field", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "person",
-          {
-            baseType: "Person",
-            bitWidth: 0,
-            isArray: false,
-            isConst: false,
-          },
-        ],
-      ]);
-      const symbols = createMockSymbols({
-        knownStructs: new Set(["Person"]),
-      });
-      const ctx = createMockPostfixExpressionContext("person", [
-        createMockPostfixOp({ identifier: "name" }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ symbols, typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "person",
-        isKnownStruct: (name) => name === "Person",
-        getMemberTypeInfo: () => ({
-          baseType: "string<32>",
-          isArray: false,
-          bitWidth: 32,
-          isConst: false,
-        }),
-        getStructFieldInfo: () => ({
-          type: "string<32>",
-          dimensions: [32],
-        }),
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("strlen(person.name)");
-      expect(result.effects).toContainEqual({
-        type: "include",
-        header: "string",
-      });
-    });
-
-    it("returns first dimension for multi-dimensional string struct field at depth 0", () => {
-      const typeRegistry = new Map<string, TTypeInfo>([
-        [
-          "data",
-          {
-            baseType: "Data",
-            bitWidth: 0,
-            isArray: false,
-            isConst: false,
-          },
-        ],
-      ]);
-      const symbols = createMockSymbols({
-        knownStructs: new Set(["Data"]),
-      });
-      const ctx = createMockPostfixExpressionContext("data", [
-        createMockPostfixOp({ identifier: "names" }),
-        createMockPostfixOp({ identifier: "length" }),
-      ]);
-      const input = createMockInput({ symbols, typeRegistry });
-      const state = createMockState();
-      const orchestrator = createMockOrchestrator({
-        generatePrimaryExpr: () => "data",
-        isKnownStruct: (name) => name === "Data",
-        getMemberTypeInfo: () => ({
-          baseType: "string<32>",
-          isArray: true,
-          bitWidth: 32,
-          isConst: false,
-        }),
-        getStructFieldInfo: () => ({
-          type: "string<32>",
-          dimensions: [5, 32],
-        }),
-      });
-
-      const result = generatePostfixExpression(ctx, input, state, orchestrator);
-      expect(result.code).toBe("5");
+      expect(() =>
+        generatePostfixExpression(ctx, input, state, orchestrator),
+      ).toThrow("'.length' on 'val' is deprecated");
     });
   });
 

package/src/transpiler/output/codegen/generators/expressions/__tests__/UnaryExprGenerator.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Unit tests for UnaryExprGenerator
+ *
+ * Tests bitwise NOT (~) MISRA-compliant cast generation:
+ * - Unsigned types get cast back to original type (MISRA 10.1/10.3)
+ * - Signed types and unresolvable types are unchanged
+ * - C++ mode uses static_cast
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import generateUnaryExpr from "../UnaryExprGenerator";
+import type { UnaryExpressionContext } from "../../../../../logic/parser/grammar/CNextParser";
+import type IGeneratorInput from "../../IGeneratorInput";
+import type IGeneratorState from "../../IGeneratorState";
+import type IOrchestrator from "../../IOrchestrator";
+import CodeGenState from "../../../../../state/CodeGenState";
+
+vi.mock("../../../TypeResolver", () => {
+  return {
+    default: {
+      getUnaryExpressionType: vi.fn(),
+      isUnsignedType: vi.fn(),
+    },
+  };
+});
+
+import TypeResolver from "../../../TypeResolver";
+
+// ========================================================================
+// Test Helpers
+// ========================================================================
+
+/**
+ * Create a mock UnaryExpressionContext for a prefix unary expression.
+ * The node has no postfixExpression (prefix case) and a child unaryExpression.
+ */
+function createMockUnaryNode(fullText: string): UnaryExpressionContext {
+  const innerUnary = {} as UnaryExpressionContext;
+  return {
+    postfixExpression: () => null,
+    unaryExpression: () => innerUnary,
+    getText: () => fullText,
+  } as unknown as UnaryExpressionContext;
+}
+
+const mockInput = {} as IGeneratorInput;
+const mockState = {} as IGeneratorState;
+
+function createMockOrchestrator(innerResult: string): IOrchestrator {
+  return {
+    generateUnaryExpr: () => innerResult,
+    generatePostfixExpr: () => "",
+  } as unknown as IOrchestrator;
+}
+
+// ========================================================================
+// Tests
+// ========================================================================
+
+describe("UnaryExprGenerator", () => {
+  afterEach(() => {
+    vi.mocked(TypeResolver.getUnaryExpressionType).mockReset();
+    vi.mocked(TypeResolver.isUnsignedType).mockReset();
+    CodeGenState.cppMode = false;
+  });
+
+  describe("bitwise NOT on unsigned types", () => {
+    it("should cast ~u8 to (uint8_t)~c in C mode", () => {
+      vi.mocked(TypeResolver.getUnaryExpressionType).mockReturnValue("u8");
+      vi.mocked(TypeResolver.isUnsignedType).mockReturnValue(true);
+
+      const node = createMockUnaryNode("~c");
+      const orchestrator = createMockOrchestrator("c");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("(uint8_t)~c");
+      expect(result.effects).toEqual([]);
+    });
+
+    it("should cast ~u16 to (uint16_t)~c in C mode", () => {
+      vi.mocked(TypeResolver.getUnaryExpressionType).mockReturnValue("u16");
+      vi.mocked(TypeResolver.isUnsignedType).mockReturnValue(true);
+
+      const node = createMockUnaryNode("~c");
+      const orchestrator = createMockOrchestrator("c");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("(uint16_t)~c");
+      expect(result.effects).toEqual([]);
+    });
+
+    it("should use static_cast in C++ mode", () => {
+      CodeGenState.cppMode = true;
+      vi.mocked(TypeResolver.getUnaryExpressionType).mockReturnValue("u8");
+      vi.mocked(TypeResolver.isUnsignedType).mockReturnValue(true);
+
+      const node = createMockUnaryNode("~c");
+      const orchestrator = createMockOrchestrator("c");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("static_cast<uint8_t>(~c)");
+      expect(result.effects).toEqual([]);
+    });
+  });
+
+  describe("bitwise NOT on signed/unresolvable types", () => {
+    it("should not cast ~i8 (signed type)", () => {
+      vi.mocked(TypeResolver.getUnaryExpressionType).mockReturnValue("i8");
+      vi.mocked(TypeResolver.isUnsignedType).mockReturnValue(false);
+
+      const node = createMockUnaryNode("~c");
+      const orchestrator = createMockOrchestrator("c");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("~c");
+      expect(result.effects).toEqual([]);
+    });
+
+    it("should not cast when type is unresolvable", () => {
+      vi.mocked(TypeResolver.getUnaryExpressionType).mockReturnValue(null);
+
+      const node = createMockUnaryNode("~expr");
+      const orchestrator = createMockOrchestrator("expr");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("~expr");
+      expect(result.effects).toEqual([]);
+    });
+  });
+
+  describe("other unary operators", () => {
+    it("should generate logical NOT unchanged", () => {
+      const node = createMockUnaryNode("!flag");
+      const orchestrator = createMockOrchestrator("flag");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("!flag");
+    });
+
+    it("should generate negation unchanged", () => {
+      const node = createMockUnaryNode("-x");
+      const orchestrator = createMockOrchestrator("x");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("-x");
+    });
+
+    it("should generate address-of unchanged", () => {
+      const node = createMockUnaryNode("&x");
+      const orchestrator = createMockOrchestrator("x");
+      const result = generateUnaryExpr(
+        node,
+        mockInput,
+        mockState,
+        orchestrator,
+      );
+
+      expect(result.code).toBe("&x");
+    });
+  });
+});

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

@@ -212,6 +212,9 @@ class ParameterInputAdapter {
       };
     }
 
+    // Issue #914: Callback typedef overrides — param carries resolved pointer/const info
+    const isCallbackPointer = param.isCallbackPointer ?? false;
+
     return {
       name: param.name,
       baseType: param.type,
@@ -221,8 +224,10 @@ class ParameterInputAdapter {
       isArray: false,
       isCallback: false,
       isString: false,
-      isPassByValue: deps.isPassByValue,
-      isPassByReference: !deps.isPassByValue,
+      isPassByValue: isCallbackPointer ? false : deps.isPassByValue,
+      isPassByReference: isCallbackPointer ? true : !deps.isPassByValue,
+      forcePointerSyntax: isCallbackPointer || undefined,
+      forceConst: param.isCallbackConst || undefined,
     };
   }