c-next 0.2.16 → 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/declarationGenerators/ScopeGenerator.ts

@@ -26,6 +26,7 @@ import ArrayDimensionUtils from "./ArrayDimensionUtils";
 import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 import CodeGenState from "../../../../state/CodeGenState";
 import ScopeUtils from "../../../../../utils/ScopeUtils";
+import VariableModifierBuilder from "../../helpers/VariableModifierBuilder";
 
 /**
  * Generate initializer expression for a variable declaration.
@@ -38,10 +39,12 @@ function generateInitializer(
 ): string {
   if (varDecl.expression()) {
     // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
+    // Issue #992: withDeclarationInit suppresses compound literals at file scope (GCC 9-12 compat)
     const typeName = orchestrator.generateType(varDecl.type());
-    return CodeGenState.withExpectedType(
-      typeName,
-      () => ` = ${orchestrator.generateExpression(varDecl.expression()!)}`,
+    return CodeGenState.withExpectedType(typeName, () =>
+      CodeGenState.withDeclarationInit(
+        () => ` = ${orchestrator.generateExpression(varDecl.expression()!)}`,
+      ),
     );
   }
   // ADR-015: Zero initialization for uninitialized scope variables
@@ -204,12 +207,23 @@ function generateRegularVariable(
     orchestrator.markOpaqueScopeVariable(fullName);
   }
 
-  // Issue #282: Add 'const' modifier for const variables
+  // Issue #998: Use VariableModifierBuilder for consistent modifier handling
+  // This handles const, atomic, volatile, and validates mutual exclusion
+  // Scope variables are always at file scope (not in function body), no initializer for modifier purposes
+  const modifiers = VariableModifierBuilder.build(
+    varDecl,
+    false, // inFunctionBody - scope vars are file scope
+    false, // hasInitializer - doesn't affect volatile/atomic handling
+    false, // cppMode - doesn't affect volatile/atomic handling
+  );
+  // For scope variables: static for private, no modifier for public
+  // Then add volatile (from atomic or volatile keyword), then const
+  const staticPrefix = isPrivate ? "static " : "";
+  const volatilePrefix = modifiers.atomic || modifiers.volatile;
   const constPrefix = isConst ? "const " : "";
-  const prefix = isPrivate ? "static " : "";
 
   // Build declaration with all dimensions
-  let decl = `${prefix}${constPrefix}${type} ${fullName}`;
+  let decl = `${staticPrefix}${volatilePrefix}${constPrefix}${type} ${fullName}`;
   decl += ArrayDimensionUtils.generateArrayTypeDimension(
     arrayTypeCtx,
     orchestrator,
@@ -225,7 +239,12 @@ function generateRegularVariable(
 
   // Issue #948: Opaque types use NULL initialization instead of {0}
   // Issue #958: External typedef struct types also use NULL initialization
-  if (isOpaque || isExternalStruct) {
+  // Issue #996: ...but only for SCALAR handles, which are single pointers. An
+  // *array* of opaque handles needs a brace initializer ({0}), not a scalar
+  // NULL. Route arrays through generateInitializer, which uses
+  // getZeroInitializer(type, isArray) — the single source of truth for
+  // zero-initialization (ADR-015).
+  if ((isOpaque || isExternalStruct) && !isArray) {
     decl += " = NULL";
   } else {
     decl += generateInitializer(varDecl, isArray, orchestrator);