c-next 0.2.8 → 0.2.10

package/src/transpiler/output/codegen/__tests__/CodeGenerator.test.ts

@@ -2798,7 +2798,8 @@ describe("CodeGenerator", () => {
 
       expect(code).toContain("int8_t a = -128");
       expect(code).toContain("int16_t b = -32768");
-      expect(code).toContain("int32_t c = -2147483648");
+      // MISRA 10.3: -2147483648 is replaced with (int32_t)INT32_MIN
+      expect(code).toContain("int32_t c = (int32_t)INT32_MIN");
     });
   });
 
@@ -3031,7 +3032,8 @@ describe("CodeGenerator", () => {
       });
 
       // Wrap doesn't use clamp helpers
-      expect(code).toContain("counter += 1");
+      // Issue #845: MISRA 10.3 - narrow types expand with cast
+      expect(code).toContain("(uint8_t)(counter + 1");
       expect(code).not.toContain("cnx_clamp");
     });
   });
@@ -4880,7 +4882,9 @@ describe("CodeGenerator", () => {
   });
 
   describe("Compound assignment operators", () => {
-    it("should generate bitwise AND compound assignment", () => {
+    // Issue #845: MISRA 10.3 - narrow type compound assignments expand to explicit cast
+    // u8 val &= 0x0F => val = (uint8_t)(val & 0x0F)
+    it("should generate bitwise AND compound assignment with MISRA cast", () => {
       const source = `
         wrap u8 mask <- 0xFF;
         void main() {
@@ -4897,10 +4901,10 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("&=");
+      expect(code).toContain("(uint8_t)(mask &");
     });
 
-    it("should generate bitwise OR compound assignment", () => {
+    it("should generate bitwise OR compound assignment with MISRA cast", () => {
       const source = `
         wrap u8 flags <- 0x00;
         void main() {
@@ -4917,10 +4921,10 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("|=");
+      expect(code).toContain("(uint8_t)(flags |");
     });
 
-    it("should generate bitwise XOR compound assignment", () => {
+    it("should generate bitwise XOR compound assignment with MISRA cast", () => {
       const source = `
         wrap u8 bits <- 0x55;
         void main() {
@@ -4937,10 +4941,10 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("^=");
+      expect(code).toContain("(uint8_t)(bits ^");
     });
 
-    it("should generate left shift compound assignment", () => {
+    it("should generate left shift compound assignment with MISRA cast", () => {
       const source = `
         wrap u8 val <- 1;
         void main() {
@@ -4957,10 +4961,10 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain("<<=");
+      expect(code).toContain("(uint8_t)(val <<");
     });
 
-    it("should generate right shift compound assignment", () => {
+    it("should generate right shift compound assignment with MISRA cast", () => {
       const source = `
         wrap u8 val <- 0x80;
         void main() {
@@ -4977,7 +4981,7 @@ describe("CodeGenerator", () => {
         sourcePath: "test.cnx",
       });
 
-      expect(code).toContain(">>=");
+      expect(code).toContain("(uint8_t)(val >>");
     });
 
     it("should generate multiply compound assignment", () => {
@@ -7886,7 +7890,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("callee(arr[0])");
+        expect(code).toContain("callee(arr[0U])");
       });
 
       it("should handle scope member as argument", () => {
@@ -8035,7 +8039,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("callee(42)");
+        expect(code).toContain("callee(42U)");
       });
 
       it("should handle nested function call as argument", () => {
@@ -9138,8 +9142,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Bitmap indexing generates bit extraction with U suffix
-        expect(code).toContain("((flags >> 0U) & 1)");
+        // Bitmap indexing generates bit extraction (no shift for position 0)
+        expect(code).toContain("((flags) & 1)");
       });
     });
 
@@ -10707,8 +10711,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Bit access extracts bit 0 with width 1
-        expect(code).toContain("((flags) & ((1U << 1) - 1))");
+        // Bit access extracts bit 0 with width 1 (no shift for position 0)
+        expect(code).toContain("((flags) & ((1U << 1U) - 1))");
       });
 
       it("should not dereference array parameter for index access", () => {
@@ -10728,8 +10732,8 @@ describe("CodeGenerator", () => {
         });
 
         // Array params don't need dereference
-        // Array element access doesn't get U suffix yet
-        expect(code).toContain("arr[5]");
+        // Array index gets U suffix per MISRA 7.2
+        expect(code).toContain("arr[5U]");
         expect(code).not.toContain("(*arr)");
       });
 
@@ -12990,11 +12994,11 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Bit range access generates shift and mask
+        // Bit range access generates mask (no shift for start=0)
         expect(code).toContain("flags");
         expect(code).toContain("& 0xFF");
-        // MISRA Rule 7.2: shift amount gets U suffix
-        expect(code).toContain(">> 0U");
+        // Optimization: no shift when start=0
+        expect(code).not.toContain(">> 0");
       });
 
       it("should generate integer bit range with shift for non-zero start", () => {
@@ -13444,7 +13448,7 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        expect(code).toContain("process(x + 5)");
+        expect(code).toContain("process(x + 5U)");
       });
     });
 
@@ -13691,8 +13695,8 @@ describe("CodeGenerator", () => {
         });
 
         expect(code).toContain("__bits_val");
-        // MISRA Rule 7.2: shift amount gets U suffix
-        expect(code).toContain(">> 0U");
+        // Optimization: no shift when start=0
+        expect(code).not.toContain(">> 0");
       });
 
       it("should handle multiple reads from same float reusing union shadow", () => {
@@ -14673,8 +14677,8 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // MISRA Rule 7.2: shift amount gets U suffix
-        expect(code).toContain(">> 0U");
+        // Optimization: no shift when start=0
+        expect(code).not.toContain(">> 0");
       });
 
       it("should generate 64-bit mask for u64 values", () => {
@@ -15324,8 +15328,9 @@ describe("CodeGenerator", () => {
           sourcePath: "test.cnx",
         });
 
-        // Wrap types just use += without helper
-        expect(code).toContain("+=");
+        // Wrap types don't use cnx_clamp helpers
+        // Issue #845: MISRA 10.3 - narrow types expand with cast
+        expect(code).toContain("(uint8_t)(val + 10");
         expect(code).not.toContain("cnx_");
       });
     });

package/src/transpiler/output/codegen/__tests__/TypeResolver.test.ts

@@ -1130,17 +1130,17 @@ describe("TypeResolver", () => {
       });
     });
 
-    describe("unsuffixed literals", () => {
-      it("should return null for unsuffixed integer", () => {
-        expect(TypeResolver.getLiteralType(mockLiteral("42"))).toBeNull();
+    describe("unsuffixed literals (MISRA 10.3 compliance)", () => {
+      it("should return int for unsuffixed integer", () => {
+        expect(TypeResolver.getLiteralType(mockLiteral("42"))).toBe("int");
       });
 
-      it("should return null for unsuffixed hex", () => {
-        expect(TypeResolver.getLiteralType(mockLiteral("0xFF"))).toBeNull();
+      it("should return int for unsuffixed hex", () => {
+        expect(TypeResolver.getLiteralType(mockLiteral("0xFF"))).toBe("int");
       });
 
-      it("should return null for unsuffixed float", () => {
-        expect(TypeResolver.getLiteralType(mockLiteral("3.14"))).toBeNull();
+      it("should return f64 for unsuffixed float", () => {
+        expect(TypeResolver.getLiteralType(mockLiteral("3.14"))).toBe("f64");
       });
     });
   });

package/src/transpiler/output/codegen/analysis/__tests__/MemberChainAnalyzer.test.ts

@@ -122,6 +122,7 @@ describe("MemberChainAnalyzer", () => {
         scopePrivateConstValues: new Map(),
         functionReturnTypes: new Map(),
         getSingleFunctionForVariable: () => null,
+        opaqueTypes: new Set(),
         hasPublicSymbols: () => false,
       };
     }

package/src/transpiler/output/codegen/assignment/AssignmentClassifier.ts

@@ -460,19 +460,39 @@ class AssignmentClassifier {
   }
 
   /**
-   * Classify this.reg[bit] / this.arr[i] patterns with array access.
+   * Classify this.reg[bit] / this.arr[i] / this.flags[3] patterns with array access.
+   * Issue #954: Uses SubscriptClassifier to distinguish array vs bit access.
    */
   private static classifyThisWithArrayAccess(
     ctx: IAssignmentContext,
     scopedRegName: string,
   ): AssignmentKind {
+    // Check for scoped register first
     if (CodeGenState.symbols!.knownRegisters.has(scopedRegName)) {
       const hasBitRange = ctx.postfixOps.some((op) => op.COMMA() !== null);
       return hasBitRange
         ? AssignmentKind.SCOPED_REGISTER_BIT_RANGE
         : AssignmentKind.SCOPED_REGISTER_BIT;
     }
-    return AssignmentKind.THIS_ARRAY;
+
+    // Get type info using resolved scoped name (e.g., "Sensor_value")
+    const typeInfo = CodeGenState.getVariableTypeInfo(scopedRegName);
+
+    // Use shared classifier to determine array vs bit access
+    const subscriptKind = SubscriptClassifier.classify({
+      typeInfo: typeInfo ?? null,
+      subscriptCount: ctx.lastSubscriptExprCount,
+      isRegisterAccess: false,
+    });
+
+    switch (subscriptKind) {
+      case "bit_single":
+        return AssignmentKind.THIS_BIT;
+      case "bit_range":
+        return AssignmentKind.THIS_BIT_RANGE;
+      default:
+        return AssignmentKind.THIS_ARRAY;
+    }
   }
 
   /**
@@ -586,10 +606,13 @@ class AssignmentClassifier {
     }
 
     // Overflow clamp (integers only, not floats)
-    // Also applies to scoped atomic variables with clamp behavior
+    // Only applies to arithmetic compound ops (+= -= *=) which can overflow
+    // Bitwise ops (&= |= ^= <<= >>=) don't overflow, so they go to SIMPLE
+    const ARITHMETIC_COMPOUND_OPS = new Set(["+=", "-=", "*="]);
     if (
       typeInfo.overflowBehavior === "clamp" &&
-      TypeCheckUtils.isInteger(typeInfo.baseType)
+      TypeCheckUtils.isInteger(typeInfo.baseType) &&
+      ARITHMETIC_COMPOUND_OPS.has(ctx.cOp)
     ) {
       return AssignmentKind.OVERFLOW_CLAMP;
     }

package/src/transpiler/output/codegen/assignment/AssignmentKind.ts

@@ -113,6 +113,12 @@ enum AssignmentKind {
   /** this.arr[i] <- value (scoped array element) */
   THIS_ARRAY,
 
+  /** this.flags[3] <- true (scoped integer bit access) */
+  THIS_BIT,
+
+  /** this.value[0, 8] <- byte (scoped integer bit range) */
+  THIS_BIT_RANGE,
+
   // === Complex access patterns ===
 
   /** struct.field.subfield <- value (member chain) */

package/src/transpiler/output/codegen/assignment/__tests__/AssignmentClassifier.test.ts

@@ -120,6 +120,7 @@ function setupSymbols(
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }
@@ -543,6 +544,78 @@ describe("AssignmentClassifier - Prefix Patterns", () => {
 
     expect(AssignmentClassifier.classify(ctx)).toBe(AssignmentKind.THIS_ARRAY);
   });
+
+  // Issue #954: Scope variable bit access should be classified as THIS_BIT/THIS_BIT_RANGE
+  it("classifies this.flags[3] as THIS_BIT for integer type", () => {
+    setupSymbols();
+    CodeGenState.currentScope = "Sensor";
+    // Register Sensor_flags as a non-array integer type
+    CodeGenState.setVariableTypeInfo(
+      "Sensor_flags",
+      createTypeInfo({ baseType: "u8", isArray: false }),
+    );
+
+    const ctx = createMockContext({
+      identifiers: ["flags"],
+      subscripts: [{} as IAssignmentContext["subscripts"][0]],
+      hasThis: true,
+      hasArrayAccess: true,
+      postfixOpsCount: 1,
+      isSimpleIdentifier: false,
+      lastSubscriptExprCount: 1, // single bit
+    });
+
+    expect(AssignmentClassifier.classify(ctx)).toBe(AssignmentKind.THIS_BIT);
+  });
+
+  it("classifies this.value[0, 8] as THIS_BIT_RANGE for integer type", () => {
+    setupSymbols();
+    CodeGenState.currentScope = "Sensor";
+    // Register Sensor_value as a non-array integer type
+    CodeGenState.setVariableTypeInfo(
+      "Sensor_value",
+      createTypeInfo({ baseType: "u16", isArray: false }),
+    );
+
+    const ctx = createMockContext({
+      identifiers: ["value"],
+      subscripts: [
+        {} as IAssignmentContext["subscripts"][0],
+        {} as IAssignmentContext["subscripts"][0],
+      ],
+      hasThis: true,
+      hasArrayAccess: true,
+      postfixOpsCount: 1,
+      isSimpleIdentifier: false,
+      lastSubscriptExprCount: 2, // bit range
+    });
+
+    expect(AssignmentClassifier.classify(ctx)).toBe(
+      AssignmentKind.THIS_BIT_RANGE,
+    );
+  });
+
+  it("classifies this.data[i] as THIS_ARRAY for array type", () => {
+    setupSymbols();
+    CodeGenState.currentScope = "Buffer";
+    // Register Buffer_data as an array type
+    CodeGenState.setVariableTypeInfo(
+      "Buffer_data",
+      createTypeInfo({ baseType: "u8", isArray: true, arrayDimensions: [10] }),
+    );
+
+    const ctx = createMockContext({
+      identifiers: ["data"],
+      subscripts: [{} as IAssignmentContext["subscripts"][0]],
+      hasThis: true,
+      hasArrayAccess: true,
+      postfixOpsCount: 1,
+      isSimpleIdentifier: false,
+      lastSubscriptExprCount: 1,
+    });
+
+    expect(AssignmentClassifier.classify(ctx)).toBe(AssignmentKind.THIS_ARRAY);
+  });
 });
 
 // ========================================================================

package/src/transpiler/output/codegen/assignment/handlers/BitAccessHandlers.ts

@@ -206,10 +206,14 @@ function handleStructChainBitRange(ctx: IAssignmentContext): string {
 
 /**
  * All bit access handlers for registration.
+ * Issue #954: THIS_BIT and THIS_BIT_RANGE reuse the integer bit handlers
+ * since they use resolvedBaseIdentifier which includes the scope prefix.
  */
 const bitAccessHandlers: ReadonlyArray<[AssignmentKind, TAssignmentHandler]> = [
   [AssignmentKind.INTEGER_BIT, handleIntegerBit],
   [AssignmentKind.INTEGER_BIT_RANGE, handleIntegerBitRange],
+  [AssignmentKind.THIS_BIT, handleIntegerBit],
+  [AssignmentKind.THIS_BIT_RANGE, handleIntegerBitRange],
   [AssignmentKind.STRUCT_MEMBER_BIT, handleStructMemberBit],
   [AssignmentKind.ARRAY_ELEMENT_BIT, handleArrayElementBit],
   [AssignmentKind.STRUCT_CHAIN_BIT_RANGE, handleStructChainBitRange],

package/src/transpiler/output/codegen/assignment/handlers/SimpleHandler.ts

@@ -3,25 +3,117 @@
  *
  * The fallback case: generates `target = value;` or `target op= value;`
  * Used when no special handling is needed.
+ *
+ * Issue #845: MISRA 10.3 - For compound assignments on narrower types (i8, i16,
+ * u8, u16), expands to explicit cast: `target = (type)(target OP value);`
+ * Also handles int-to-float conversions with explicit casts.
  */
 import IAssignmentContext from "../IAssignmentContext";
 import CodeGenState from "../../../../state/CodeGenState";
 import type ICodeGenApi from "../../types/ICodeGenApi";
+import NarrowingCastHelper from "../../helpers/NarrowingCastHelper.js";
+import TypeResolver from "../../TypeResolver.js";
+import TYPE_MAP from "../../types/TYPE_MAP.js";
+import CppModeHelper from "../../helpers/CppModeHelper.js";
+import COMPOUND_TO_BINARY from "../../types/COMPOUND_TO_BINARY.js";
 
 /** Get typed generator reference */
 function gen(): ICodeGenApi {
   return CodeGenState.generator as ICodeGenApi;
 }
 
+/**
+ * Try to handle compound assignment on narrow types (MISRA 10.3).
+ * Returns the generated code if handled, null otherwise.
+ */
+function tryHandleCompoundNarrowingCast(
+  ctx: IAssignmentContext,
+  target: string,
+): string | null {
+  if (!ctx.isCompound || !ctx.firstIdTypeInfo) {
+    return null;
+  }
+
+  const baseType = ctx.firstIdTypeInfo.baseType;
+  const promotedType = NarrowingCastHelper.getPromotedType(baseType);
+
+  if (promotedType !== "int" || baseType === "int") {
+    return null;
+  }
+
+  const binaryOp = COMPOUND_TO_BINARY[ctx.cOp];
+  if (!binaryOp) {
+    return null;
+  }
+
+  const cType = TYPE_MAP[baseType] ?? baseType;
+  const expr = `(${target} ${binaryOp} ${ctx.generatedValue})`;
+  const castExpr = CppModeHelper.cast(cType, expr);
+  return `${target} = ${castExpr};`;
+}
+
+/**
+ * Try to handle cross-type-category conversion (int <-> float).
+ * Returns the generated code if handled, null otherwise.
+ */
+function tryHandleIntToFloatConversion(
+  ctx: IAssignmentContext,
+  target: string,
+): string | null {
+  if (ctx.isCompound || !ctx.firstIdTypeInfo || !ctx.valueCtx) {
+    return null;
+  }
+
+  const targetType = ctx.firstIdTypeInfo.baseType;
+  const valueType = TypeResolver.getExpressionType(ctx.valueCtx);
+
+  if (!valueType) {
+    return null;
+  }
+
+  if (
+    !NarrowingCastHelper.isCrossTypeCategoryConversion(valueType, targetType)
+  ) {
+    return null;
+  }
+
+  if (
+    !NarrowingCastHelper.isIntegerType(valueType) ||
+    !NarrowingCastHelper.isFloatType(targetType)
+  ) {
+    return null;
+  }
+
+  const castedValue = NarrowingCastHelper.wrapIntToFloat(
+    ctx.generatedValue,
+    targetType,
+  );
+  return `${target} ${ctx.cOp} ${castedValue};`;
+}
+
 /**
  * Handle simple variable assignment.
  *
  * @example
  * x <- 5           =>  x = 5;
  * counter +<- 1    =>  counter += 1;
+ * i16_val &<- 0xFF =>  i16_val = (int16_t)(i16_val & 0xFF);  // MISRA 10.3
  */
 function handleSimpleAssignment(ctx: IAssignmentContext): string {
   const target = gen().generateAssignmentTarget(ctx.targetCtx);
+
+  // Try compound assignment narrowing cast (MISRA 10.3)
+  const compoundResult = tryHandleCompoundNarrowingCast(ctx, target);
+  if (compoundResult) {
+    return compoundResult;
+  }
+
+  // Try int-to-float conversion
+  const conversionResult = tryHandleIntToFloatConversion(ctx, target);
+  if (conversionResult) {
+    return conversionResult;
+  }
+
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 

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

@@ -59,13 +59,16 @@ describe("BitAccessHandlers", () => {
 
       expect(kinds).toContain(AssignmentKind.INTEGER_BIT);
       expect(kinds).toContain(AssignmentKind.INTEGER_BIT_RANGE);
+      expect(kinds).toContain(AssignmentKind.THIS_BIT);
+      expect(kinds).toContain(AssignmentKind.THIS_BIT_RANGE);
       expect(kinds).toContain(AssignmentKind.STRUCT_MEMBER_BIT);
       expect(kinds).toContain(AssignmentKind.ARRAY_ELEMENT_BIT);
       expect(kinds).toContain(AssignmentKind.STRUCT_CHAIN_BIT_RANGE);
     });
 
-    it("exports exactly 5 handlers", () => {
-      expect(bitAccessHandlers.length).toBe(5);
+    it("exports exactly 7 handlers", () => {
+      // Issue #954: Added THIS_BIT and THIS_BIT_RANGE for scope variable bit access
+      expect(bitAccessHandlers.length).toBe(7);
     });
   });
 

package/src/transpiler/output/codegen/assignment/handlers/__tests__/handlerTestUtils.ts

@@ -57,6 +57,7 @@ function createDefaultMockSymbols(): ICodeGenSymbols {
 
     // Methods
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

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

@@ -390,6 +390,20 @@ interface IOrchestrator {
 
   /** Check if a float shadow has current value */
   isFloatShadowCurrent(shadowName: string): boolean;
+
+  // === Issue #948: Opaque Type Helpers ===
+
+  /**
+   * Check if a type is an opaque (forward-declared) struct type.
+   * Opaque types can only be used as pointers (cannot be instantiated).
+   */
+  isOpaqueType(typeName: string): boolean;
+
+  /**
+   * Mark a scope variable as having an opaque type.
+   * These variables are generated as pointers with NULL initialization.
+   */
+  markOpaqueScopeVariable(qualifiedName: string): void;
 }
 
 export default IOrchestrator;

package/src/transpiler/output/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -24,9 +24,11 @@ import generateScopedRegister from "./ScopedRegisterGenerator";
 import BitmapCommentUtils from "./BitmapCommentUtils";
 import ArrayDimensionUtils from "./ArrayDimensionUtils";
 import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Generate initializer expression for a variable declaration.
+ * Issue #872: Sets expectedType for MISRA 7.2 U suffix on unsigned literals.
  */
 function generateInitializer(
   varDecl: Parser.VariableDeclarationContext,
@@ -34,7 +36,12 @@ function generateInitializer(
   orchestrator: IOrchestrator,
 ): string {
   if (varDecl.expression()) {
-    return ` = ${orchestrator.generateExpression(varDecl.expression()!)}`;
+    // Issue #872: Set expectedType for MISRA 7.2 U suffix compliance
+    const typeName = orchestrator.generateType(varDecl.type());
+    return CodeGenState.withExpectedType(
+      typeName,
+      () => ` = ${orchestrator.generateExpression(varDecl.expression()!)}`,
+    );
   }
   // ADR-015: Zero initialization for uninitialized scope variables
   return ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
@@ -180,8 +187,17 @@ function generateRegularVariable(
   const isArray = arrayDims.length > 0 || arrayTypeCtx !== null;
 
   // ADR-016: All scope variables are emitted at file scope (static-like persistence)
-  const type = orchestrator.generateType(varDecl.type());
+  let type = orchestrator.generateType(varDecl.type());
   const fullName = QualifiedNameGenerator.forMember(scopeName, varName);
+
+  // Issue #948: Check if this is an opaque (forward-declared) struct type
+  // Opaque types must be declared as pointers with NULL initialization
+  const isOpaque = orchestrator.isOpaqueType(type);
+  if (isOpaque) {
+    type = `${type}*`;
+    orchestrator.markOpaqueScopeVariable(fullName);
+  }
+
   // Issue #282: Add 'const' modifier for const variables
   const constPrefix = isConst ? "const " : "";
   const prefix = isPrivate ? "static " : "";
@@ -200,7 +216,13 @@ function generateRegularVariable(
 
   // ADR-045: Add string capacity dimension for string arrays
   decl += ArrayDimensionUtils.generateStringCapacityDim(varDecl.type());
-  decl += generateInitializer(varDecl, isArray, orchestrator);
+
+  // Issue #948: Opaque types use NULL initialization instead of {0}
+  if (isOpaque) {
+    decl += " = NULL";
+  } else {
+    decl += generateInitializer(varDecl, isArray, orchestrator);
+  }
 
   return decl + ";";
 }