c-next 0.2.8 → 0.2.10

package/src/transpiler/output/codegen/helpers/__tests__/AssignmentExpectedTypeResolver.test.ts

@@ -63,6 +63,7 @@ function setupStructFields(
       scopePrivateConstValues: new Map(),
       functionReturnTypes: new Map(),
       getSingleFunctionForVariable: () => null,
+      opaqueTypes: new Set(),
       hasPublicSymbols: () => false,
     };
   }
@@ -183,7 +184,8 @@ describe("AssignmentExpectedTypeResolver", () => {
     });
 
     describe("array access", () => {
-      it("should return null for array access target", () => {
+      // Issue #872: Array element assignments need expectedType for MISRA 7.2 U suffix
+      it("should resolve expected type for simple array element access", () => {
         CodeGenState.setVariableTypeInfo("arr", {
           baseType: "u32",
           bitWidth: 32,
@@ -194,8 +196,65 @@ describe("AssignmentExpectedTypeResolver", () => {
 
         const result = AssignmentExpectedTypeResolver.resolve(target);
 
+        expect(result.expectedType).toBe("u32");
+      });
+
+      it("should resolve expected type for u8 array element access", () => {
+        CodeGenState.setVariableTypeInfo("buffer", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          isConst: false,
+        });
+        const target = parseAssignmentTarget("buffer[5]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should resolve expected type for struct member array access", () => {
+        CodeGenState.setVariableTypeInfo("pkt", {
+          baseType: "Packet",
+          bitWidth: 0,
+          isArray: false,
+          isConst: false,
+        });
+        setupStructFields("Packet", new Map([["header", "u8"]]));
+        // Mark header as an array field
+        if (CodeGenState.symbols) {
+          (
+            CodeGenState.symbols.structFieldArrays as Map<string, Set<string>>
+          ).set("Packet", new Set(["header"]));
+        }
+        const target = parseAssignmentTarget("pkt.header[0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should resolve expected type for multi-dimensional array element", () => {
+        CodeGenState.setVariableTypeInfo("matrix", {
+          baseType: "u8",
+          bitWidth: 8,
+          isArray: true,
+          arrayDimensions: [4, 8],
+          isConst: false,
+        });
+        const target = parseAssignmentTarget("matrix[0][0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
+        expect(result.expectedType).toBe("u8");
+      });
+
+      it("should return null for unknown array variable", () => {
+        const target = parseAssignmentTarget("unknown[0]");
+
+        const result = AssignmentExpectedTypeResolver.resolve(target);
+
         expect(result.expectedType).toBeNull();
-        expect(result.assignmentContext).toBeNull();
       });
     });
   });

package/src/transpiler/output/codegen/helpers/__tests__/AssignmentValidator.test.ts

@@ -64,6 +64,7 @@ function setupSymbols(
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

package/src/transpiler/output/codegen/helpers/__tests__/BitRangeHelper.test.ts

@@ -2,8 +2,9 @@
  * Unit tests for BitRangeHelper utility.
  * Tests bit range access code generation patterns.
  */
-import { describe, it, expect } from "vitest";
-import BitRangeHelper from "../BitRangeHelper";
+import { describe, it, expect, beforeEach } from "vitest";
+import BitRangeHelper from "../BitRangeHelper.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
 
 describe("BitRangeHelper", () => {
   describe("buildFloatBitReadExpr", () => {
@@ -114,6 +115,56 @@ describe("BitRangeHelper", () => {
     });
   });
 
+  describe("buildIntegerBitReadExpr with target type", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+      CodeGenState.cppMode = false;
+    });
+
+    it("adds cast when target type is narrower than source", () => {
+      const result = BitRangeHelper.buildIntegerBitReadExpr({
+        varName: "value",
+        start: "0",
+        mask: "0xFFU",
+        sourceType: "u32",
+        targetType: "u8",
+      });
+      expect(result).toBe("(uint8_t)((value) & 0xFFU)");
+    });
+
+    it("returns plain expression when no narrowing", () => {
+      const result = BitRangeHelper.buildIntegerBitReadExpr({
+        varName: "value",
+        start: "8",
+        mask: "0xFFFFU",
+        sourceType: "u32",
+        targetType: "u32",
+      });
+      expect(result).toBe("((value >> 8) & 0xFFFFU)");
+    });
+
+    it("returns plain expression when types not provided (backward compatible)", () => {
+      const result = BitRangeHelper.buildIntegerBitReadExpr({
+        varName: "value",
+        start: "0",
+        mask: "0xFFU",
+      });
+      expect(result).toBe("((value) & 0xFFU)");
+    });
+
+    it("uses static_cast in C++ mode", () => {
+      CodeGenState.cppMode = true;
+      const result = BitRangeHelper.buildIntegerBitReadExpr({
+        varName: "value",
+        start: "0",
+        mask: "0xFFU",
+        sourceType: "u32",
+        targetType: "u8",
+      });
+      expect(result).toBe("static_cast<uint8_t>(((value) & 0xFFU))");
+    });
+  });
+
   describe("getShadowVarName", () => {
     it("should prefix with __bits_", () => {
       expect(BitRangeHelper.getShadowVarName("value")).toBe("__bits_value");

package/src/transpiler/output/codegen/helpers/__tests__/FunctionContextManager.test.ts

@@ -44,6 +44,7 @@ function setupSymbols(
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

package/src/transpiler/output/codegen/helpers/__tests__/NarrowingCastHelper.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Unit tests for NarrowingCastHelper
+ * Issue #845: MISRA C:2012 Rule 10.3 compliance
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import NarrowingCastHelper from "../NarrowingCastHelper.js";
+import CodeGenState from "../../../../state/CodeGenState.js";
+
+describe("NarrowingCastHelper", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("needsCast", () => {
+    it("returns false for same type", () => {
+      expect(NarrowingCastHelper.needsCast("u32", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("u8", "u8")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("bool", "bool")).toBe(false);
+    });
+
+    it("returns false for widening (u8 -> u32)", () => {
+      expect(NarrowingCastHelper.needsCast("u8", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("u16", "u32")).toBe(false);
+      expect(NarrowingCastHelper.needsCast("i8", "i32")).toBe(false);
+    });
+
+    it("returns true for narrowing (u32 -> u8)", () => {
+      expect(NarrowingCastHelper.needsCast("u32", "u8")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("u32", "u16")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("i32", "i8")).toBe(true);
+    });
+
+    it("returns true for int -> smaller unsigned (C promotion result)", () => {
+      expect(NarrowingCastHelper.needsCast("int", "u8")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("int", "u16")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("int", "i8")).toBe(true);
+    });
+
+    it("returns true for int -> bool (different essential type)", () => {
+      expect(NarrowingCastHelper.needsCast("int", "bool")).toBe(true);
+      expect(NarrowingCastHelper.needsCast("u32", "bool")).toBe(true);
+    });
+
+    it("returns true for char literal type -> u8", () => {
+      expect(NarrowingCastHelper.needsCast("int", "u8")).toBe(true);
+    });
+  });
+
+  describe("wrap (C mode)", () => {
+    beforeEach(() => {
+      CodeGenState.cppMode = false;
+    });
+
+    it("returns expression unchanged for same type", () => {
+      expect(NarrowingCastHelper.wrap("x", "u32", "u32")).toBe("x");
+    });
+
+    it("returns expression unchanged for widening", () => {
+      expect(NarrowingCastHelper.wrap("x", "u8", "u32")).toBe("x");
+    });
+
+    it("adds C cast for narrowing u32 -> u8", () => {
+      const expr = "((value >> 0U) & 0xFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u8")).toBe(
+        "(uint8_t)((value >> 0U) & 0xFFU)",
+      );
+    });
+
+    it("adds C cast for narrowing u32 -> u16", () => {
+      const expr = "((value >> 0U) & 0xFFFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u16")).toBe(
+        "(uint16_t)((value >> 0U) & 0xFFFFU)",
+      );
+    });
+
+    it("adds C cast for int -> u8 (C promotion result)", () => {
+      const expr = "((flags >> 3) & 0x7)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "u8")).toBe(
+        "(uint8_t)((flags >> 3) & 0x7)",
+      );
+    });
+
+    it("uses != 0U comparison for bool target (MISRA 10.5)", () => {
+      const expr = "((flags >> 0) & 1)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "bool")).toBe(
+        "((((flags >> 0) & 1)) != 0U)",
+      );
+    });
+
+    it("adds cast for char literal to u8", () => {
+      expect(NarrowingCastHelper.wrap("'A'", "int", "u8")).toBe("(uint8_t)'A'");
+    });
+  });
+
+  describe("wrap (C++ mode)", () => {
+    beforeEach(() => {
+      CodeGenState.cppMode = true;
+    });
+
+    it("uses static_cast for narrowing", () => {
+      const expr = "((value >> 0U) & 0xFFU)";
+      expect(NarrowingCastHelper.wrap(expr, "u32", "u8")).toBe(
+        "static_cast<uint8_t>(((value >> 0U) & 0xFFU))",
+      );
+    });
+
+    it("uses != 0U for bool (same as C mode)", () => {
+      const expr = "((flags >> 0) & 1)";
+      expect(NarrowingCastHelper.wrap(expr, "int", "bool")).toBe(
+        "((((flags >> 0) & 1)) != 0U)",
+      );
+    });
+  });
+
+  describe("getPromotedType", () => {
+    it("returns 'int' for u8 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u8")).toBe("int");
+    });
+
+    it("returns 'int' for i8 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i8")).toBe("int");
+    });
+
+    it("returns 'int' for u16 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u16")).toBe("int");
+    });
+
+    it("returns 'int' for i16 (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i16")).toBe("int");
+    });
+
+    it("returns same type for u32 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u32")).toBe("u32");
+    });
+
+    it("returns same type for i32 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i32")).toBe("i32");
+    });
+
+    it("returns same type for u64 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("u64")).toBe("u64");
+    });
+
+    it("returns same type for i64 (no promotion)", () => {
+      expect(NarrowingCastHelper.getPromotedType("i64")).toBe("i64");
+    });
+
+    it("returns 'int' for bool (promoted)", () => {
+      expect(NarrowingCastHelper.getPromotedType("bool")).toBe("int");
+    });
+
+    it("returns same type for unknown types (conservative)", () => {
+      expect(NarrowingCastHelper.getPromotedType("custom_type")).toBe(
+        "custom_type",
+      );
+    });
+  });
+});

package/src/transpiler/output/codegen/helpers/__tests__/TypeRegistrationEngine.test.ts

@@ -39,6 +39,7 @@ function createMockSymbols(): ICodeGenSymbols {
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }

package/src/transpiler/output/codegen/types/COMPOUND_TO_BINARY.ts

@@ -0,0 +1,21 @@
+/**
+ * Map compound assignment operator to its binary operator equivalent.
+ *
+ * Shared constant used by:
+ * - SimpleHandler.ts: MISRA 10.3 compound assignment expansion
+ * - AtomicGenerator.ts: Atomic compound operation expansion
+ */
+const COMPOUND_TO_BINARY: Record<string, string> = {
+  "+=": "+",
+  "-=": "-",
+  "*=": "*",
+  "/=": "/",
+  "%=": "%",
+  "&=": "&",
+  "|=": "|",
+  "^=": "^",
+  "<<=": "<<",
+  ">>=": ">>",
+};
+
+export default COMPOUND_TO_BINARY;

package/src/transpiler/output/codegen/types/IArrayAccessInfo.ts

@@ -19,6 +19,8 @@ type IArrayAccessInfo = {
   widthExpr?: string;
   /** Type info for the variable being accessed */
   typeInfo?: TTypeInfo;
+  /** Target type for narrowing cast (e.g., "u8" when extracting to uint8_t) */
+  targetType?: string;
   /** Source line for error messages */
   line: number;
 };

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -277,29 +277,27 @@ class HeaderGeneratorUtils {
       lines.push("#include <stdint.h>", "#include <stdbool.h>");
     }
 
-    // User includes
-    // Issue #933: Transform .h to .hpp in C++ mode so headers include correct files
+    // User includes (already have correct extension from IncludeExtractor)
     if (options.userIncludes && options.userIncludes.length > 0) {
       for (const include of options.userIncludes) {
-        const transformedInclude = options.cppMode
-          ? include.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
-          : include;
-        lines.push(transformedInclude);
+        lines.push(include);
       }
     }
 
     // External type header includes (skip duplicates of user includes)
-    // Note: External C headers stay as .h - only user includes from .cnx files get
-    // transformed to .hpp in C++ mode (those are C-Next generated headers)
-    const userIncludeSet = new Set(
-      options.userIncludes?.map((inc) =>
-        options.cppMode
-          ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
-          : inc,
-      ) ?? [],
-    );
+    // Note: headersToInclude comes from IncludeResolver which always produces .h
+    // (it runs before cppDetected is set). We need to match against userIncludes
+    // which may have .hpp in C++ mode, so normalize both for deduplication.
+    const userIncludeSet = new Set(options.userIncludes ?? []);
+    // Issue #941: Also add .h variants for dedup since headersToInclude uses .h
+    if (options.cppMode && options.userIncludes) {
+      for (const inc of options.userIncludes) {
+        // Add the .h version so we can match against headersToInclude
+        const hVersion = inc.replace(/\.hpp"/, '.h"').replace(/\.hpp>/, ".h>");
+        userIncludeSet.add(hVersion);
+      }
+    }
     for (const directive of headersToInclude) {
-      // Don't transform external C headers - they should stay as .h
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
       }

package/src/transpiler/output/headers/__tests__/HeaderGeneratorUtils.test.ts

@@ -542,6 +542,31 @@ describe("HeaderGeneratorUtils", () => {
 
       expect(lines[lines.length - 1]).toBe("");
     });
+
+    it("passes through userIncludes as-is (extension already correct from IncludeExtractor)", () => {
+      const lines = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ['#include "types.hpp"'],
+          cppMode: true,
+        },
+        new Set(),
+      );
+
+      expect(lines).toContain('#include "types.hpp"');
+    });
+
+    it("deduplicates headersToInclude against userIncludes with .h/.hpp normalization in C++ mode", () => {
+      const result = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ['#include "types.hpp"'],
+          cppMode: true,
+        },
+        new Set(['#include "types.h"']),
+      );
+      // Should NOT have duplicate - the .h version should be filtered
+      const typeIncludes = result.filter((l) => l.includes("types"));
+      expect(typeIncludes).toEqual(['#include "types.hpp"']);
+    });
   });
 
   describe("generateCppWrapperStart", () => {

package/src/transpiler/state/CodeGenState.ts

@@ -220,6 +220,14 @@ export default class CodeGenState {
   /** Expected type for struct initializers and enum inference */
   static expectedType: string | null = null;
 
+  /**
+   * Suppress bare enum resolution even when expectedType is set.
+   * Issue #872: MISRA 7.2 requires expectedType for U suffix on function args,
+   * but bare enum resolution in function args was never allowed and changing
+   * that would require ADR approval.
+   */
+  static suppressBareEnumResolution: boolean = false;
+
   /** Track args parameter name for main() translation */
   static mainArgsName: string | null = null;
 
@@ -270,6 +278,18 @@ export default class CodeGenState {
   /** Issue #473: IRQ wrappers for critical sections */
   static needsIrqWrappers: boolean = false;
 
+  // ===========================================================================
+  // OPAQUE TYPE SCOPE VARIABLES (Issue #948)
+  // ===========================================================================
+
+  /**
+   * Tracks scope variables with opaque (forward-declared) struct types.
+   * These are generated as pointers with NULL initialization and should
+   * be passed directly (not with &) since they're already pointers.
+   * Maps qualified name (e.g., "MyScope_widget") to true.
+   */
+  private static opaqueScopeVariables: Set<string> = new Set();
+
   // ===========================================================================
   // C++ MODE STATE (Issue #250)
   // ===========================================================================
@@ -362,6 +382,7 @@ export default class CodeGenState {
     this.indentLevel = 0;
     this.inFunctionBody = false;
     this.expectedType = null;
+    this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
     this.assignmentContext = {
       targetName: null,
@@ -391,6 +412,9 @@ export default class CodeGenState {
     this.pendingCppClassAssignments = [];
     this.selfIncludeAdded = false;
 
+    // Issue #948: Opaque scope variables (reset per-file)
+    this.opaqueScopeVariables = new Set();
+
     // Source paths
     this.sourcePath = null;
     this.includeDirs = [];
@@ -421,6 +445,37 @@ export default class CodeGenState {
     this.floatShadowCurrent.clear();
   }
 
+  /**
+   * Execute a function with a temporary expectedType, restoring on completion.
+   * Issue #872: Extracted to eliminate duplicate save/restore pattern and add exception safety.
+   *
+   * @param type - The expected type to set (if falsy, no change is made)
+   * @param fn - The function to execute
+   * @param suppressEnumResolution - If true, suppress bare enum resolution (for MISRA-only contexts)
+   * @returns The result of the function
+   */
+  static withExpectedType<T>(
+    type: string | undefined | null,
+    fn: () => T,
+    suppressEnumResolution: boolean = false,
+  ): T {
+    if (!type) {
+      return fn();
+    }
+    const savedType = this.expectedType;
+    const savedSuppress = this.suppressBareEnumResolution;
+    this.expectedType = type;
+    if (suppressEnumResolution) {
+      this.suppressBareEnumResolution = true;
+    }
+    try {
+      return fn();
+    } finally {
+      this.expectedType = savedType;
+      this.suppressBareEnumResolution = savedSuppress;
+    }
+  }
+
   // ===========================================================================
   // CONVENIENCE LOOKUP METHODS
   // ===========================================================================
@@ -464,6 +519,15 @@ export default class CodeGenState {
     return this.symbols?.knownRegisters.has(name) ?? false;
   }
 
+  /**
+   * Issue #948: Check if a type name is an opaque (forward-declared) struct type.
+   * Opaque types are incomplete types that can only be used as pointers.
+   * Example: `typedef struct _widget_t widget_t;` without a body makes `widget_t` opaque.
+   */
+  static isOpaqueType(typeName: string): boolean {
+    return this.symbols?.opaqueTypes.has(typeName) ?? false;
+  }
+
   /**
    * Get type info for a variable.
    * Checks local typeRegistry first, then falls back to SymbolTable
@@ -1006,6 +1070,31 @@ export default class CodeGenState {
     return this.floatShadowCurrent.has(name);
   }
 
+  // ===========================================================================
+  // OPAQUE SCOPE VARIABLE HELPERS (Issue #948)
+  // ===========================================================================
+
+  /**
+   * Mark a scope variable as having an opaque (forward-declared) struct type.
+   * These are generated as pointers with NULL initialization.
+   *
+   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
+   */
+  static markOpaqueScopeVariable(qualifiedName: string): void {
+    this.opaqueScopeVariables.add(qualifiedName);
+  }
+
+  /**
+   * Check if a scope variable has an opaque type (and is thus a pointer).
+   * Used during access generation to determine if & prefix is needed.
+   *
+   * @param qualifiedName - The fully qualified variable name (e.g., "MyScope_widget")
+   * @returns true if this is an opaque scope variable (already a pointer)
+   */
+  static isOpaqueScopeVariable(qualifiedName: string): boolean {
+    return this.opaqueScopeVariables.has(qualifiedName);
+  }
+
   // ===========================================================================
   // C++ MODE HELPERS
   // ===========================================================================

package/src/transpiler/state/__tests__/CodeGenState.test.ts

@@ -69,6 +69,7 @@ function createMockSymbols(
     structFieldArrays: Map<string, Set<string>>;
     functionReturnTypes: Map<string, string>;
     scopeMemberVisibility: Map<string, Map<string, "public" | "private">>;
+    opaqueTypes: Set<string>;
   }> = {},
 ): ICodeGenSymbols {
   return {
@@ -95,6 +96,7 @@ function createMockSymbols(
     scopeVariableUsage: new Map(),
     scopePrivateConstValues: new Map(),
     functionReturnTypes: overrides.functionReturnTypes ?? new Map(),
+    opaqueTypes: overrides.opaqueTypes ?? new Set(),
     getSingleFunctionForVariable: () => null,
     hasPublicSymbols: () => false,
   };
@@ -714,6 +716,21 @@ describe("CodeGenState", () => {
       expect(CodeGenState.isKnownScope("MyScope")).toBe(true);
       expect(CodeGenState.isKnownScope("UnknownScope")).toBe(false);
     });
+
+    it("isOpaqueType returns false without symbols", () => {
+      CodeGenState.symbols = null;
+      expect(CodeGenState.isOpaqueType("widget_t")).toBe(false);
+    });
+
+    it("isOpaqueType returns true for opaque type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        opaqueTypes: new Set(["widget_t", "display_t"]),
+      });
+
+      expect(CodeGenState.isOpaqueType("widget_t")).toBe(true);
+      expect(CodeGenState.isOpaqueType("display_t")).toBe(true);
+      expect(CodeGenState.isOpaqueType("Point")).toBe(false);
+    });
   });
 
   describe("Local Variable Helpers", () => {
@@ -848,4 +865,40 @@ describe("CodeGenState", () => {
       expect(result.get("Simple")?.has("value")).toBe(true);
     });
   });
+
+  describe("Opaque Scope Variable Helpers (Issue #948)", () => {
+    it("markOpaqueScopeVariable adds to opaqueScopeVariables", () => {
+      CodeGenState.markOpaqueScopeVariable("MyScope_widget");
+      expect(CodeGenState.isOpaqueScopeVariable("MyScope_widget")).toBe(true);
+    });
+
+    it("isOpaqueScopeVariable returns false for unknown variable", () => {
+      expect(CodeGenState.isOpaqueScopeVariable("Unknown_var")).toBe(false);
+    });
+
+    it("isOpaqueScopeVariable returns true for marked variable", () => {
+      CodeGenState.markOpaqueScopeVariable("Gui_display");
+      expect(CodeGenState.isOpaqueScopeVariable("Gui_display")).toBe(true);
+    });
+
+    it("reset clears opaqueScopeVariables", () => {
+      CodeGenState.markOpaqueScopeVariable("Test_opaque");
+      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(true);
+
+      CodeGenState.reset();
+
+      expect(CodeGenState.isOpaqueScopeVariable("Test_opaque")).toBe(false);
+    });
+
+    it("handles multiple opaque scope variables", () => {
+      CodeGenState.markOpaqueScopeVariable("Scope1_widget");
+      CodeGenState.markOpaqueScopeVariable("Scope1_display");
+      CodeGenState.markOpaqueScopeVariable("Scope2_handle");
+
+      expect(CodeGenState.isOpaqueScopeVariable("Scope1_widget")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariable("Scope1_display")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariable("Scope2_handle")).toBe(true);
+      expect(CodeGenState.isOpaqueScopeVariable("Scope1_other")).toBe(false);
+    });
+  });
 });

package/src/transpiler/state/__tests__/TranspilerState.test.ts

@@ -35,6 +35,7 @@ function createMockSymbolInfo(enumName?: string): ICodeGenSymbols {
     scopePrivateConstValues: new Map(),
     functionReturnTypes: new Map(),
     getSingleFunctionForVariable: () => null,
+    opaqueTypes: new Set(),
     hasPublicSymbols: () => false,
   };
 }