c-next 0.2.17 → 0.2.18

package/src/transpiler/output/codegen/assignment/handlers/__tests__/ArrayHandlers.test.ts

@@ -16,6 +16,22 @@ vi.mock("../../../TypeValidator", () => ({
   },
 }));
 
+// Slice codegen resolves the source value's type (Issue #1081 review) — mock it
+// so slice tests can control the source type independently of a real parse tree.
+const { mockGetExpressionType, mockGetIntegerExpressionType } = vi.hoisted(
+  () => ({
+    mockGetExpressionType: vi.fn(),
+    mockGetIntegerExpressionType: vi.fn(),
+  }),
+);
+
+vi.mock("../../../TypeResolver", () => ({
+  default: {
+    getExpressionType: mockGetExpressionType,
+    getIntegerExpressionType: mockGetIntegerExpressionType,
+  },
+}));
+
 import arrayHandlers from "../ArrayHandlers";
 import AssignmentKind from "../../AssignmentKind";
 import IAssignmentContext from "../../IAssignmentContext";
@@ -42,6 +58,9 @@ function createMockContext(
     cOp: "=",
     generatedValue: "value",
     targetCtx: {} as never,
+    // Truthy so slice codegen resolves the source type via the mocked
+    // TypeResolver.getExpressionType (Issue #1081 review).
+    valueCtx: {} as never,
     hasThis: false,
     hasGlobal: false,
     hasMemberAccess: false,
@@ -63,6 +82,9 @@ describe("ArrayHandlers", () => {
     CodeGenState.reset();
     HandlerTestUtils.setupMockGenerator();
     HandlerTestUtils.setupMockSymbols();
+    // Default: a source whose direct type is null is also unresolved as a
+    // composite. Tests that exercise composite resolution override this.
+    mockGetIntegerExpressionType.mockReturnValue(null);
   });
 
   describe("handler registration", () => {
@@ -241,32 +263,231 @@ describe("ArrayHandlers", () => {
     const getHandler = () =>
       arrayHandlers.find(([kind]) => kind === AssignmentKind.ARRAY_SLICE)?.[1];
 
-    it("generates memcpy for valid slice assignment", () => {
+    // Every unrolled slice copy is prefixed with a comment naming the MISRA
+    // rule it satisfies and why the codegen looks the way it does (Issue #1081).
+    // Mirror production sliceUnrollComment: the rule is cited ONLY when an
+    // equivalent memcpy would pass incompatible pointer types.
+    const sliceComment = (destCType: string, srcCType: string) =>
+      "/* MISRA C:2012 Rule 21.15: slice copy unrolled to per-element writes " +
+      `(memcpy would pass incompatible pointer types: ${destCType}* vs ${srcCType}*). */`;
+
+    // Default the source type to a wide unsigned; tests override per case.
+    beforeEach(() => mockGetExpressionType.mockReturnValue("u64"));
+
+    // Issue #1081: slice assignment lowers to per-element little-endian writes
+    // (no memcpy), keeping MISRA C:2012 Rule 21.15 (compatible memcpy pointers)
+    // satisfied because no incompatible pointer punning is emitted.
+    it("generates unrolled byte writes for a u8 slice (no memcpy/string.h)", () => {
+      mockGetExpressionType.mockReturnValue("u32");
       HandlerTestUtils.setupMockTypeRegistry([
-        ["buffer", { arrayDimensions: [100], baseType: "u8" }],
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
       ]);
       HandlerTestUtils.setupMockGenerator({
         tryEvaluateConstant: vi
           .fn()
           .mockReturnValueOnce(0)
-          .mockReturnValueOnce(10),
+          .mockReturnValueOnce(4),
       });
       const ctx = createMockContext({
         identifiers: ["buffer"],
         subscripts: [
           { mockValue: "0", start: { line: 1 } } as never,
-          { mockValue: "10", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
         ],
         generatedValue: "source",
       });
 
       const result = getHandler()!(ctx);
 
-      expect(result).toBe("memcpy(&buffer[0], &source, 10);");
-      expect(CodeGenState.needsString).toBe(true);
+      // The source is materialized into a single unsigned temp so it is read
+      // exactly once (Issue #1085 review, Finding 2).
+      expect(result).toBe(
+        `${sliceComment("uint8_t", "uint32_t")}\n` +
+          "const uint32_t _tmp0 = (uint32_t)(source);\n" +
+          "buffer[0] = (uint8_t)(_tmp0);\n" +
+          "buffer[1] = (uint8_t)(_tmp0 >> 8U);\n" +
+          "buffer[2] = (uint8_t)(_tmp0 >> 16U);\n" +
+          "buffer[3] = (uint8_t)(_tmp0 >> 24U);",
+      );
+      // No memcpy means <string.h> is not required.
+      expect(CodeGenState.needsString).toBe(false);
+    });
+
+    it("writes at element granularity for a u16 slice (offset = element index)", () => {
+      mockGetExpressionType.mockReturnValue("u64");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arr16", { arrayDimensions: [16], baseType: "u16", bitWidth: 16 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(8),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arr16"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "8", start: { line: 1 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      const result = getHandler()!(ctx);
+
+      expect(result).toBe(
+        `${sliceComment("uint16_t", "uint64_t")}\n` +
+          "const uint64_t _tmp0 = (uint64_t)(value);\n" +
+          "arr16[0] = (uint16_t)(_tmp0);\n" +
+          "arr16[1] = (uint16_t)(_tmp0 >> 16U);\n" +
+          "arr16[2] = (uint16_t)(_tmp0 >> 32U);\n" +
+          "arr16[3] = (uint16_t)(_tmp0 >> 48U);",
+      );
     });
 
-    it("generates memcpy for string slice", () => {
+    it("omits the rule citation when source and element types match (no 21.15)", () => {
+      mockGetExpressionType.mockReturnValue("u32");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arr32", { arrayDimensions: [16], baseType: "u32", bitWidth: 32 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arr32"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      const result = getHandler()!(ctx);
+
+      // u32[] <- u32: an equivalent memcpy would be compliant, so no comment.
+      expect(result).toBe("arr32[0] = (uint32_t)(value);");
+    });
+
+    it("accepts an in-bounds wide-element slice at a non-zero offset (Finding 1)", () => {
+      mockGetExpressionType.mockReturnValue("u64");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arr64", { arrayDimensions: [8], baseType: "u64", bitWidth: 64 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(4)
+          .mockReturnValueOnce(8),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arr64"],
+        subscripts: [
+          { mockValue: "4", start: { line: 1 } } as never,
+          { mockValue: "8", start: { line: 1 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      const result = getHandler()!(ctx);
+
+      // Element span is offset(4) + 1 element = 5 <= capacity 8. The old check
+      // compared byte length against element capacity (4 + 8 = 12 > 8) and
+      // wrongly rejected this in-bounds slice. Single element → no temp;
+      // same-type u64[] <- u64 → no rule citation.
+      expect(result).toBe("arr64[4] = (uint64_t)(value);");
+    });
+
+    it("reports the element span (not bytes) in the out-of-bounds message", () => {
+      mockGetExpressionType.mockReturnValue("u64");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arr16", { arrayDimensions: [4], baseType: "u16", bitWidth: 16 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(2)
+          .mockReturnValueOnce(8),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arr16"],
+        subscripts: [
+          { mockValue: "2", start: { line: 7 } } as never,
+          { mockValue: "8", start: { line: 7 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      // offset 2 + (8 bytes / 2) = 6 elements > capacity 4.
+      expect(() => getHandler()!(ctx)).toThrow(
+        "offset(2) + 4 element(s) = 6 exceeds buffer capacity(4)",
+      );
+    });
+
+    it("casts a signed source to unsigned once in the temp (MISRA 10.1)", () => {
+      mockGetExpressionType.mockReturnValue("i32");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      const result = getHandler()!(ctx);
+
+      // The signed source is cast to its same-width unsigned type once, in the
+      // temp declaration, so every shift on the temp is MISRA Rule 10.1-clean.
+      expect(result).toBe(
+        `${sliceComment("uint8_t", "int32_t")}\n` +
+          "const uint32_t _tmp0 = (uint32_t)(value);\n" +
+          "buffer[0] = (uint8_t)(_tmp0);\n" +
+          "buffer[1] = (uint8_t)(_tmp0 >> 8U);\n" +
+          "buffer[2] = (uint8_t)(_tmp0 >> 16U);\n" +
+          "buffer[3] = (uint8_t)(_tmp0 >> 24U);",
+      );
+    });
+
+    it("uses the signed-element double-cast for a signed destination (MISRA 10.8)", () => {
+      mockGetExpressionType.mockReturnValue("i32");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arrI", { arrayDimensions: [16], baseType: "i32", bitWidth: 32 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arrI"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      const result = getHandler()!(ctx);
+
+      // i32[] <- i32: same type, so no rule citation; dest cast still applies.
+      expect(result).toBe("arrI[0] = (int32_t)(uint32_t)(value);");
+    });
+
+    it("generates double-cast char writes for a string slice (MISRA 10.8)", () => {
+      mockGetExpressionType.mockReturnValue("u16");
       HandlerTestUtils.setupMockTypeRegistry([
         [
           "str",
@@ -282,20 +503,267 @@ describe("ArrayHandlers", () => {
         tryEvaluateConstant: vi
           .fn()
           .mockReturnValueOnce(5)
-          .mockReturnValueOnce(10),
+          .mockReturnValueOnce(2),
       });
       const ctx = createMockContext({
         identifiers: ["str"],
         subscripts: [
           { mockValue: "5", start: { line: 1 } } as never,
-          { mockValue: "10", start: { line: 1 } } as never,
+          { mockValue: "2", start: { line: 1 } } as never,
         ],
         generatedValue: "data",
       });
 
       const result = getHandler()!(ctx);
 
-      expect(result).toBe("memcpy(&str[5], &data, 10);");
+      expect(result).toBe(
+        `${sliceComment("char", "uint16_t")}\n` +
+          "const uint16_t _tmp0 = (uint16_t)(data);\n" +
+          "str[5] = (char)(uint8_t)(_tmp0);\n" +
+          "str[6] = (char)(uint8_t)(_tmp0 >> 8U);",
+      );
+    });
+
+    it("sizes the temp to the slice length for an unresolved source type", () => {
+      mockGetExpressionType.mockReturnValue(null); // e.g. a computed expression
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "expr",
+      });
+
+      const result = getHandler()!(ctx);
+
+      // Unknown source: NO Rule 21.15 citation — we cannot prove the source type
+      // is incompatible with the destination element, so asserting "incompatible
+      // pointer types" would be false (Issue #1085 review, Finding #1). The temp
+      // is still sized to the 4-byte slice length (uint32_t), not the widest
+      // type — so the cast does not widen a composite expression like `a + b`
+      // (MISRA Rule 10.8), while every shift on the temp stays unsigned (10.1)
+      // and in range (Finding 3).
+      expect(result).toBe(
+        "const uint32_t _tmp0 = (uint32_t)(expr);\n" +
+          "buffer[0] = (uint8_t)(_tmp0);\n" +
+          "buffer[1] = (uint8_t)(_tmp0 >> 8U);\n" +
+          "buffer[2] = (uint8_t)(_tmp0 >> 16U);\n" +
+          "buffer[3] = (uint8_t)(_tmp0 >> 24U);",
+      );
+    });
+
+    it("two-steps a composite signed source so no composite is cast (Rule 10.8)", () => {
+      // Direct type unresolved (composite), but resolvable as a signed i32 via
+      // Rule 10.4's same-category guarantee. The source must be bound to its
+      // own signed type first, then reinterpreted — the unsigned cast lands on
+      // the simple temp, never on the `a + b` composite.
+      mockGetExpressionType.mockReturnValue(null);
+      mockGetIntegerExpressionType.mockReturnValue("i32");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "a + b",
+      });
+
+      const result = getHandler()!(ctx);
+
+      expect(result).toBe(
+        "/* MISRA C:2012 Rule 21.15: slice copy unrolled to per-element writes " +
+          "(memcpy would pass incompatible pointer types: uint8_t* vs int32_t*). */\n" +
+          "const int32_t _tmp0 = a + b;\n" +
+          "const uint32_t _tmp1 = (uint32_t)_tmp0;\n" +
+          "buffer[0] = (uint8_t)(_tmp1);\n" +
+          "buffer[1] = (uint8_t)(_tmp1 >> 8U);\n" +
+          "buffer[2] = (uint8_t)(_tmp1 >> 16U);\n" +
+          "buffer[3] = (uint8_t)(_tmp1 >> 24U);",
+      );
+    });
+
+    it("throws when slice length is not a multiple of the element size", () => {
+      mockGetExpressionType.mockReturnValue("u64");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arr16", { arrayDimensions: [16], baseType: "u16", bitWidth: 16 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(3),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arr16"],
+        subscripts: [
+          { mockValue: "0", start: { line: 7 } } as never,
+          { mockValue: "3", start: { line: 7 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      expect(() => getHandler()!(ctx)).toThrow(
+        "must be a multiple of the element size",
+      );
+    });
+
+    it("throws when slice length exceeds the source value width", () => {
+      mockGetExpressionType.mockReturnValue("u32"); // 4-byte source
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(8), // copying 8 bytes from a 4-byte value
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 8 } } as never,
+          { mockValue: "8", start: { line: 8 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      expect(() => getHandler()!(ctx)).toThrow(
+        "exceeds the source value width",
+      );
+    });
+
+    it("throws on a non-integer (float) slice source", () => {
+      mockGetExpressionType.mockReturnValue("f32");
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 9 } } as never,
+          { mockValue: "4", start: { line: 9 } } as never,
+        ],
+        generatedValue: "fval",
+      });
+
+      expect(() => getHandler()!(ctx)).toThrow(
+        "source must be an integer value",
+      );
+    });
+
+    it("throws on slice assignment into a float array", () => {
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["arrF", { arrayDimensions: [16], baseType: "f32", bitWidth: 32 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(4),
+      });
+      const ctx = createMockContext({
+        identifiers: ["arrF"],
+        subscripts: [
+          { mockValue: "0", start: { line: 9 } } as never,
+          { mockValue: "4", start: { line: 9 } } as never,
+        ],
+        generatedValue: "value",
+      });
+
+      expect(() => getHandler()!(ctx)).toThrow(
+        "Slice assignment is not supported for element type",
+      );
+    });
+
+    it("rejects a negative literal that does not fit the slice (mirror of the positive overflow check)", () => {
+      // A negative literal types as null via getExpressionType (unary minus), but
+      // is still a compile-time constant. It must be fit-checked like a positive
+      // one: buf[0,1] <- -300 cannot fit a 1-byte slice (-300 < -128) and must be
+      // rejected, not silently truncated to (uint8_t)(-300) (Issue #1085 review).
+      mockGetExpressionType.mockReturnValue(null);
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0) // offset
+          .mockReturnValueOnce(1) // length (1-byte slice)
+          .mockReturnValue(-300), // source value (folded; re-read by resolveLiteralSliceSource)
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 7 } } as never,
+          { mockValue: "1", start: { line: 7 } } as never,
+        ],
+        generatedValue: "-300",
+      });
+
+      expect(() => getHandler()!(ctx)).toThrow(
+        "Slice assignment literal value (-300) does not fit in the 1-byte slice",
+      );
+    });
+
+    it("serializes an in-range negative literal as two's-complement little-endian bytes", () => {
+      // -1 fits a 4-byte slice (-2^31 <= -1 < 2^32), so it is accepted and written
+      // as 0xFFFFFFFF little-endian. The literal types to the slice width (u32),
+      // so an equivalent memcpy would be incompatible -> Rule 21.15 is cited.
+      mockGetExpressionType.mockReturnValue(null);
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["buffer", { arrayDimensions: [100], baseType: "u8", bitWidth: 8 }],
+      ]);
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0) // offset
+          .mockReturnValueOnce(4) // length
+          .mockReturnValue(-1), // source value
+      });
+      const ctx = createMockContext({
+        identifiers: ["buffer"],
+        subscripts: [
+          { mockValue: "0", start: { line: 1 } } as never,
+          { mockValue: "4", start: { line: 1 } } as never,
+        ],
+        generatedValue: "-1",
+      });
+
+      const result = getHandler()!(ctx);
+
+      expect(result).toBe(
+        `${sliceComment("uint8_t", "uint32_t")}\n` +
+          "const uint32_t _tmp0 = (uint32_t)(-1);\n" +
+          "buffer[0] = (uint8_t)(_tmp0);\n" +
+          "buffer[1] = (uint8_t)(_tmp0 >> 8U);\n" +
+          "buffer[2] = (uint8_t)(_tmp0 >> 16U);\n" +
+          "buffer[3] = (uint8_t)(_tmp0 >> 24U);",
+      );
     });
 
     it("throws on compound assignment", () => {
@@ -382,7 +850,7 @@ describe("ArrayHandlers", () => {
 
     it("throws on out of bounds access", () => {
       HandlerTestUtils.setupMockTypeRegistry([
-        ["buffer", { arrayDimensions: [50], baseType: "u8" }],
+        ["buffer", { arrayDimensions: [50], baseType: "u8", bitWidth: 8 }],
       ]);
       HandlerTestUtils.setupMockGenerator({
         tryEvaluateConstant: vi

package/src/transpiler/output/codegen/generators/IOrchestrator.ts

@@ -214,6 +214,9 @@ interface IOrchestrator {
     conditionType: string,
   ): void;
 
+  /** Reject an always-true literal loop condition (ADR-113 / #1075, E0707) */
+  validateLoopConditionNotAlwaysTrue(ctx: Parser.ExpressionContext): void;
+
   /** Validate no function calls in condition (Issue #254, E0702) */
   validateConditionNoFunctionCall(
     ctx: Parser.ExpressionContext,

package/src/transpiler/output/codegen/generators/expressions/CallExprGenerator.ts

@@ -104,6 +104,29 @@ const _parameterExpectsAddressOf = (
   return paramBaseType === argType;
 };
 
+/**
+ * Resolve an argument expression's C-Next type for the address-of decision.
+ * Prefers the expression type, then the codegen variable registry, then the C
+ * symbol table — the last covers extern C globals (e.g. an lvgl font
+ * `lv_font_montserrat_32` of type `lv_font_t`, Issue #985) whose type only
+ * header symbol collection knows. Returns null when the type can't be resolved
+ * or the argument is already an address-of expression.
+ */
+const _resolveArgType = (
+  e: ExpressionContext,
+  argCode: string,
+  typeInfoBaseType: string | undefined,
+  orchestrator: IOrchestrator,
+): string | null => {
+  const exprType = orchestrator.getExpressionType(e);
+  if (exprType) return exprType;
+  if (argCode.startsWith("&")) return null;
+  if (typeInfoBaseType) return typeInfoBaseType;
+  const cSymbol = CodeGenState.symbolTable?.getCSymbol(argCode);
+  if (cSymbol?.kind === "variable" && !cSymbol.isArray) return cSymbol.type;
+  return null;
+};
+
 /**
  * Generate argument code for a C/C++ function call.
  * Handles automatic address-of (&) for struct arguments passed to pointer params.
@@ -148,22 +171,12 @@ const _generateCFunctionArg = (
     return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
   }
 
-  // Try getExpressionType first
-  let argType = orchestrator.getExpressionType(e);
-
-  // Issue #322: If getExpressionType returns null (e.g., for this.member),
-  // fall back to looking up the generated code in the type registry
-  let isPointerVariable = false;
+  // Resolve the argument's type (expression type → variable registry → C symbol
+  // table for extern globals) to decide whether it needs address-of.
   const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
-  if (!argType && !argCode.startsWith("&")) {
-    if (typeInfo) {
-      argType = typeInfo.baseType;
-    }
-  }
-  // Issue #895 Bug B: Check if variable was inferred as a pointer
-  if (typeInfo?.isPointer) {
-    isPointerVariable = true;
-  }
+  const argType = _resolveArgType(e, argCode, typeInfo?.baseType, orchestrator);
+  // Issue #895 Bug B: a variable already inferred as a pointer must not get `&`.
+  const isPointerVariable = typeInfo?.isPointer ?? false;
 
   // Issue #948: Check if argument is an opaque scope variable (already a pointer)
   // Issue #996: ...including an element of an opaque-handle array (arr[i])