npm - c-next - Versions diffs - 0.2.8 → 0.2.10 - Mend

c-next 0.2.8 → 0.2.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/dist/index.js CHANGED Viewed

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.8",
+  version: "0.2.10",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -109966,6 +109966,18 @@ var SymbolTable = class {
    * In C, they must be referred to as 'struct Name', not just 'Name'
    */
   needsStructKeyword = /* @__PURE__ */ new Set();
+  /**
+   * Issue #948: Track typedef names that alias incomplete (forward-declared) struct types.
+   * These are "opaque" types that can only be used as pointers.
+   */
+  opaqueTypes = /* @__PURE__ */ new Set();
+  /**
+   * Issue #948: Track struct tag -> typedef name relationships.
+   * When a typedef declares an alias for a struct tag (e.g., typedef struct _foo foo_t),
+   * we record structTagAliases["_foo"] = "foo_t". This allows us to unmark the typedef
+   * as opaque when the full struct definition is later found.
+   */
+  structTagAliases = /* @__PURE__ */ new Map();
   /**
    * Issue #208: Track enum backing type bit widths
    * C++14 typed enums: enum Name : uint8_t { ... } have explicit bit widths
@@ -110594,6 +110606,66 @@ Rename the C-Next symbol to resolve.`
     }
   }
   // ========================================================================
+  // Opaque Type Tracking (Issue #948)
+  // ========================================================================
+  /**
+   * Issue #948: Mark a typedef as aliasing an opaque (forward-declared) struct type.
+   * @param typeName Typedef name (e.g., "widget_t")
+   */
+  markOpaqueType(typeName) {
+    this.opaqueTypes.add(typeName);
+  }
+  /**
+   * Issue #948: Unmark a typedef when full struct definition is found.
+   * Handles edge case: typedef before definition.
+   * @param typeName Typedef name
+   */
+  unmarkOpaqueType(typeName) {
+    this.opaqueTypes.delete(typeName);
+  }
+  /**
+   * Issue #948: Check if a typedef aliases an opaque struct type.
+   * @param typeName Typedef name
+   * @returns true if the type is opaque (forward-declared)
+   */
+  isOpaqueType(typeName) {
+    return this.opaqueTypes.has(typeName);
+  }
+  /**
+   * Issue #948: Get all opaque type names for cache serialization.
+   * @returns Array of opaque typedef names
+   */
+  getAllOpaqueTypes() {
+    return Array.from(this.opaqueTypes);
+  }
+  /**
+   * Issue #948: Restore opaque types from cache.
+   * @param typeNames Array of opaque typedef names
+   */
+  restoreOpaqueTypes(typeNames) {
+    for (const name of typeNames) {
+      this.opaqueTypes.add(name);
+    }
+  }
+  /**
+   * Issue #948: Register a struct tag -> typedef name relationship.
+   * Called when processing: typedef struct _foo foo_t;
+   * This allows unmarking foo_t when struct _foo { ... } is later defined.
+   * @param structTag The struct tag name (e.g., "_foo")
+   * @param typedefName The typedef alias name (e.g., "foo_t")
+   */
+  registerStructTagAlias(structTag, typedefName) {
+    this.structTagAliases.set(structTag, typedefName);
+  }
+  /**
+   * Issue #948: Get the typedef alias for a struct tag, if any.
+   * @param structTag The struct tag name
+   * @returns The typedef alias name, or undefined if none registered
+   */
+  getStructTagAlias(structTag) {
+    return this.structTagAliases.get(structTag);
+  }
+  // ========================================================================
   // Enum Bit Width Tracking
   // ========================================================================
   /**
@@ -110710,6 +110782,8 @@ Rename the C-Next symbol to resolve.`
     this.cppSymbolsByFile.clear();
     this.structFields.clear();
     this.needsStructKeyword.clear();
+    this.opaqueTypes.clear();
+    this.structTagAliases.clear();
     this.enumBitWidth.clear();
   }
 };
@@ -110828,6 +110902,13 @@ var CodeGenState = class {
   static inFunctionBody = false;
   /** Expected type for struct initializers and enum inference */
   static expectedType = 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 = false;
   /** Track args parameter name for main() translation */
   static mainArgsName = null;
   /** ADR-044: Current assignment context for overflow behavior */
@@ -110864,6 +110945,16 @@ var CodeGenState = class {
   /** Issue #473: IRQ wrappers for critical sections */
   static needsIrqWrappers = 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.
+   */
+  static opaqueScopeVariables = /* @__PURE__ */ new Set();
+  // ===========================================================================
   // C++ MODE STATE (Issue #250)
   // ===========================================================================
   /** Use temp vars instead of compound literals */
@@ -110922,6 +111013,7 @@ var CodeGenState = class {
     this.indentLevel = 0;
     this.inFunctionBody = false;
     this.expectedType = null;
+    this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
     this.assignmentContext = {
       targetName: null,
@@ -110946,6 +111038,7 @@ var CodeGenState = class {
     this.tempVarCounter = 0;
     this.pendingCppClassAssignments = [];
     this.selfIncludeAdded = false;
+    this.opaqueScopeVariables = /* @__PURE__ */ new Set();
     this.sourcePath = null;
     this.includeDirs = [];
     this.inputs = [];
@@ -110972,6 +111065,32 @@ var CodeGenState = class {
     this.floatBitShadows.clear();
     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(type, fn, suppressEnumResolution = false) {
+    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
   // ===========================================================================
@@ -111009,6 +111128,14 @@ var CodeGenState = class {
   static isKnownRegister(name) {
     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) {
+    return this.symbols?.opaqueTypes.has(typeName) ?? false;
+  }
   /**
    * Get type info for a variable.
    * Checks local typeRegistry first, then falls back to SymbolTable
@@ -111448,6 +111575,28 @@ var CodeGenState = class {
     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) {
+    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) {
+    return this.opaqueScopeVariables.has(qualifiedName);
+  }
+  // ===========================================================================
   // C++ MODE HELPERS
   // ===========================================================================
   /**
@@ -113157,6 +113306,12 @@ var TypeResolver2 = class _TypeResolver {
     if (floatMatch) {
       return "f" + floatMatch[1];
     }
+    if (/^\d+$/.test(text) || /^0[xXbBoO][\da-fA-F]+$/.test(text)) {
+      return "int";
+    }
+    if (/^\d*\.\d+([eE][+-]?\d+)?$/.test(text) || /^\d+[eE][+-]?\d+$/.test(text)) {
+      return "f64";
+    }
     return null;
   }
   /**
@@ -114416,6 +114571,229 @@ var GeneratorRegistry = class {
   }
 };
+// src/transpiler/output/codegen/helpers/CppModeHelper.ts
+var CppModeHelper = class {
+  /**
+   * Get address-of expression for struct parameter passing.
+   * C mode: `&expr` (pass pointer to struct)
+   * C++ mode: `expr` (pass reference directly)
+   *
+   * @param expr - The expression to potentially wrap
+   * @returns The expression with address-of operator in C mode
+   */
+  static maybeAddressOf(expr) {
+    return CodeGenState.cppMode ? expr : `&${expr}`;
+  }
+  /**
+   * Get dereference expression for struct parameter access.
+   * C mode: `(*expr)` (dereference pointer)
+   * C++ mode: `expr` (reference can be used directly)
+   *
+   * @param expr - The expression to potentially dereference
+   * @returns The expression with dereference in C mode
+   */
+  static maybeDereference(expr) {
+    return CodeGenState.cppMode ? expr : `(*${expr})`;
+  }
+  /**
+   * Get the type modifier for struct parameter declarations.
+   * C mode: `*` (pointer type)
+   * C++ mode: `&` (reference type)
+   *
+   * @returns The type modifier character
+   */
+  static refOrPtr() {
+    return CodeGenState.cppMode ? "&" : "*";
+  }
+  /**
+   * Get the member access separator for struct parameters.
+   * C mode: `->` (pointer member access)
+   * C++ mode: `.` (reference member access)
+   *
+   * @returns The member access separator
+   */
+  static memberSeparator() {
+    return CodeGenState.cppMode ? "." : "->";
+  }
+  /**
+   * Get NULL literal for the current mode.
+   * C mode: `NULL`
+   * C++ mode: `nullptr`
+   *
+   * @returns The null pointer literal
+   */
+  static nullLiteral() {
+    return CodeGenState.cppMode ? "nullptr" : "NULL";
+  }
+  /**
+   * Generate a cast expression for the current mode.
+   * C mode: `(type)expr`
+   * C++ mode: `static_cast<type>(expr)`
+   *
+   * @param type - The target type
+   * @param expr - The expression to cast
+   * @returns The cast expression
+   */
+  static cast(type, expr) {
+    return CodeGenState.cppMode ? `static_cast<${type}>(${expr})` : `(${type})${expr}`;
+  }
+  /**
+   * Generate a reinterpret cast expression for the current mode.
+   * C mode: `(type)expr`
+   * C++ mode: `reinterpret_cast<type>(expr)`
+   *
+   * @param type - The target type
+   * @param expr - The expression to cast
+   * @returns The cast expression
+   */
+  static reinterpretCast(type, expr) {
+    return CodeGenState.cppMode ? `reinterpret_cast<${type}>(${expr})` : `(${type})${expr}`;
+  }
+  /**
+   * Check if we're in C++ mode.
+   *
+   * @returns True if generating C++ code
+   */
+  static isCppMode() {
+    return CodeGenState.cppMode;
+  }
+};
+var CppModeHelper_default = CppModeHelper;
+// src/transpiler/output/codegen/helpers/NarrowingCastHelper.ts
+var EXTENDED_TYPE_WIDTH = {
+  ...TYPE_WIDTH_default,
+  int: 32
+  // C's int after promotion
+};
+var PROMOTED_TO_INT = /* @__PURE__ */ new Set(["u8", "i8", "u16", "i16", "bool"]);
+var FLOAT_TYPES2 = /* @__PURE__ */ new Set(["f32", "f64", "float", "double"]);
+var INTEGER_TYPES2 = /* @__PURE__ */ new Set([
+  "u8",
+  "u16",
+  "u32",
+  "u64",
+  "i8",
+  "i16",
+  "i32",
+  "i64",
+  "uint8_t",
+  "uint16_t",
+  "uint32_t",
+  "uint64_t",
+  "int8_t",
+  "int16_t",
+  "int32_t",
+  "int64_t",
+  "int"
+]);
+var NarrowingCastHelper = class _NarrowingCastHelper {
+  /**
+   * Check if a cast is needed for MISRA 10.3 compliance.
+   * Returns true if:
+   * - Source is wider than target (narrowing)
+   * - Source and target are different essential type categories
+   *
+   * @param sourceType - Type of the expression (C-Next type or "int" for promoted)
+   * @param targetType - Type of the target variable (C-Next type)
+   */
+  static needsCast(sourceType, targetType) {
+    if (sourceType === targetType) {
+      return false;
+    }
+    if (targetType === "bool" && sourceType !== "bool") {
+      return true;
+    }
+    const sourceWidth = EXTENDED_TYPE_WIDTH[sourceType];
+    const targetWidth = EXTENDED_TYPE_WIDTH[targetType];
+    if (sourceWidth === void 0 || targetWidth === void 0) {
+      return false;
+    }
+    return sourceWidth > targetWidth;
+  }
+  /**
+   * Wrap expression with cast if needed for MISRA 10.3 compliance.
+   *
+   * @param expr - The generated C expression
+   * @param sourceType - Type of the expression (C-Next type or "int")
+   * @param targetType - Type of the assignment target (C-Next type)
+   * @returns Expression with cast wrapper if needed, or original expression
+   */
+  static wrap(expr, sourceType, targetType) {
+    if (!_NarrowingCastHelper.needsCast(sourceType, targetType)) {
+      return expr;
+    }
+    if (targetType === "bool") {
+      return `((${expr}) != 0U)`;
+    }
+    const cType = TYPE_MAP_default[targetType] ?? targetType;
+    return CppModeHelper_default.cast(cType, expr);
+  }
+  /**
+   * Determine the result type of C integer promotion for a given type.
+   *
+   * In C, operations on types smaller than int are promoted:
+   * - u8, i8, u16, i16, bool -> int (32-bit)
+   * - u32, i32, u64, i64 -> no promotion (already >= int width)
+   *
+   * @param baseType - The C-Next type of the operand
+   * @returns "int" for promoted types, or the original type
+   */
+  static getPromotedType(baseType) {
+    if (PROMOTED_TO_INT.has(baseType)) {
+      return "int";
+    }
+    return baseType;
+  }
+  /**
+   * Check if a type is a floating-point type.
+   */
+  static isFloatType(typeName) {
+    return FLOAT_TYPES2.has(typeName);
+  }
+  /**
+   * Check if a type is an integer type.
+   */
+  static isIntegerType(typeName) {
+    return INTEGER_TYPES2.has(typeName);
+  }
+  /**
+   * Check if conversion between source and target is a cross-type-category conversion.
+   * MISRA 10.3 requires explicit casts for different essential type categories.
+   */
+  static isCrossTypeCategoryConversion(sourceType, targetType) {
+    const sourceIsFloat = _NarrowingCastHelper.isFloatType(sourceType);
+    const targetIsFloat = _NarrowingCastHelper.isFloatType(targetType);
+    const sourceIsInt = _NarrowingCastHelper.isIntegerType(sourceType);
+    const targetIsInt = _NarrowingCastHelper.isIntegerType(targetType);
+    return sourceIsFloat && targetIsInt || sourceIsInt && targetIsFloat;
+  }
+  /**
+   * Get the appropriate C float type for a C-Next type.
+   */
+  static getCFloatType(typeName) {
+    if (typeName === "f32" || typeName === "float") {
+      return "float";
+    }
+    if (typeName === "f64" || typeName === "double") {
+      return "double";
+    }
+    return "double";
+  }
+  /**
+   * Wrap int-to-float conversion with explicit cast for MISRA 10.3.
+   *
+   * @param expr - The integer expression
+   * @param targetType - The float target type (f32/f64)
+   * @returns Expression with cast
+   */
+  static wrapIntToFloat(expr, targetType) {
+    const floatType = _NarrowingCastHelper.getCFloatType(targetType);
+    return CppModeHelper_default.cast(floatType, expr);
+  }
+};
+var NarrowingCastHelper_default = NarrowingCastHelper;
 // src/transpiler/output/codegen/generators/expressions/LiteralGenerator.ts
 var UNSIGNED_64_TYPES = /* @__PURE__ */ new Set(["u64", "uint64_t"]);
 var UNSIGNED_TYPES3 = /* @__PURE__ */ new Set([
@@ -114424,8 +114802,14 @@ var UNSIGNED_TYPES3 = /* @__PURE__ */ new Set([
   "u32",
   "uint8_t",
   "uint16_t",
-  "uint32_t"
+  "uint32_t",
+  "size_t"
+  // Array indices (MISRA 7.2)
 ]);
+function resolveTypedef(typeName) {
+  const underlyingType = CodeGenState.getTypedefType(typeName);
+  return underlyingType ?? typeName;
+}
 function isNumericIntegerLiteral(text) {
   if (text.startsWith('"') || text.startsWith("'")) {
     return false;
@@ -114450,6 +114834,18 @@ var generateLiteral = (node, _input, state, _orchestrator) => {
     effects.push({ type: "include", header: "stdbool" });
     return { code: literalText, effects };
   }
+  if (literalText.startsWith("'")) {
+    const expectedType2 = state?.expectedType;
+    if (expectedType2) {
+      const wrappedCode = NarrowingCastHelper_default.wrap(
+        literalText,
+        "int",
+        expectedType2
+      );
+      return { code: wrappedCode, effects };
+    }
+    return { code: literalText, effects };
+  }
   if (/[fF]32$/.test(literalText)) {
     literalText = literalText.replace(/[fF]32$/, "f");
     return { code: literalText, effects };
@@ -114471,9 +114867,10 @@ var generateLiteral = (node, _input, state, _orchestrator) => {
   }
   const expectedType = state?.expectedType;
   if (expectedType && isNumericIntegerLiteral(literalText) && !hasUnsignedSuffix(literalText)) {
-    if (UNSIGNED_64_TYPES.has(expectedType)) {
+    const resolvedType = resolveTypedef(expectedType);
+    if (UNSIGNED_64_TYPES.has(resolvedType)) {
       literalText = literalText + "ULL";
-    } else if (UNSIGNED_TYPES3.has(expectedType)) {
+    } else if (UNSIGNED_TYPES3.has(resolvedType)) {
       literalText = literalText + "U";
     }
   }
@@ -114810,96 +115207,9 @@ var binaryExprGenerators = {
 };
 var BinaryExprGenerator_default = binaryExprGenerators;
-// src/transpiler/output/codegen/helpers/CppModeHelper.ts
-var CppModeHelper = class {
-  /**
-   * Get address-of expression for struct parameter passing.
-   * C mode: `&expr` (pass pointer to struct)
-   * C++ mode: `expr` (pass reference directly)
-   *
-   * @param expr - The expression to potentially wrap
-   * @returns The expression with address-of operator in C mode
-   */
-  static maybeAddressOf(expr) {
-    return CodeGenState.cppMode ? expr : `&${expr}`;
-  }
-  /**
-   * Get dereference expression for struct parameter access.
-   * C mode: `(*expr)` (dereference pointer)
-   * C++ mode: `expr` (reference can be used directly)
-   *
-   * @param expr - The expression to potentially dereference
-   * @returns The expression with dereference in C mode
-   */
-  static maybeDereference(expr) {
-    return CodeGenState.cppMode ? expr : `(*${expr})`;
-  }
-  /**
-   * Get the type modifier for struct parameter declarations.
-   * C mode: `*` (pointer type)
-   * C++ mode: `&` (reference type)
-   *
-   * @returns The type modifier character
-   */
-  static refOrPtr() {
-    return CodeGenState.cppMode ? "&" : "*";
-  }
-  /**
-   * Get the member access separator for struct parameters.
-   * C mode: `->` (pointer member access)
-   * C++ mode: `.` (reference member access)
-   *
-   * @returns The member access separator
-   */
-  static memberSeparator() {
-    return CodeGenState.cppMode ? "." : "->";
-  }
-  /**
-   * Get NULL literal for the current mode.
-   * C mode: `NULL`
-   * C++ mode: `nullptr`
-   *
-   * @returns The null pointer literal
-   */
-  static nullLiteral() {
-    return CodeGenState.cppMode ? "nullptr" : "NULL";
-  }
-  /**
-   * Generate a cast expression for the current mode.
-   * C mode: `(type)expr`
-   * C++ mode: `static_cast<type>(expr)`
-   *
-   * @param type - The target type
-   * @param expr - The expression to cast
-   * @returns The cast expression
-   */
-  static cast(type, expr) {
-    return CodeGenState.cppMode ? `static_cast<${type}>(${expr})` : `(${type})${expr}`;
-  }
-  /**
-   * Generate a reinterpret cast expression for the current mode.
-   * C mode: `(type)expr`
-   * C++ mode: `reinterpret_cast<type>(expr)`
-   *
-   * @param type - The target type
-   * @param expr - The expression to cast
-   * @returns The cast expression
-   */
-  static reinterpretCast(type, expr) {
-    return CodeGenState.cppMode ? `reinterpret_cast<${type}>(${expr})` : `(${type})${expr}`;
-  }
-  /**
-   * Check if we're in C++ mode.
-   *
-   * @returns True if generating C++ code
-   */
-  static isCppMode() {
-    return CodeGenState.cppMode;
-  }
-};
-var CppModeHelper_default = CppModeHelper;
 // src/transpiler/output/codegen/generators/expressions/UnaryExprGenerator.ts
+var INT32_MIN_LITERAL = "2147483648";
+var INT64_MIN_LITERAL = "9223372036854775808";
 var generateUnaryExpr = (node, _input, _state, orchestrator) => {
   if (node.postfixExpression()) {
     return {
@@ -114910,7 +115220,18 @@ var generateUnaryExpr = (node, _input, _state, orchestrator) => {
   const inner = orchestrator.generateUnaryExpr(node.unaryExpression());
   const text = node.getText();
   if (text.startsWith("!")) return { code: `!${inner}`, effects: [] };
-  if (text.startsWith("-")) return { code: `-${inner}`, effects: [] };
+  if (text.startsWith("-")) {
+    const effects = [];
+    if (inner === INT32_MIN_LITERAL) {
+      effects.push({ type: "include", header: "limits" });
+      return { code: "(int32_t)INT32_MIN", effects };
+    }
+    if (inner === INT64_MIN_LITERAL || inner === INT64_MIN_LITERAL + "LL") {
+      effects.push({ type: "include", header: "limits" });
+      return { code: "(int64_t)INT64_MIN", effects };
+    }
+    return { code: `-${inner}`, effects };
+  }
   if (text.startsWith("~")) {
     const innerType = TypeResolver_default2.getUnaryExpressionType(
       node.unaryExpression()
@@ -114973,15 +115294,18 @@ var generateSizeProperty = (typeInfo) => {
   throw new Error(`Error: .size is only available on string types`);
 };
 var generateBitmapFieldAccess = (result, fieldInfo) => {
+  let expr;
   if (fieldInfo.width === 1) {
-    return { code: `((${result} >> ${fieldInfo.offset}) & 1)`, effects: [] };
+    expr = `((${result} >> ${fieldInfo.offset}) & 1)`;
   } else {
     const mask = (1 << fieldInfo.width) - 1;
-    return {
-      code: `((${result} >> ${fieldInfo.offset}) & 0x${mask.toString(16).toUpperCase()})`,
-      effects: []
-    };
+    expr = `((${result} >> ${fieldInfo.offset}) & 0x${mask.toString(16).toUpperCase()})`;
+  }
+  const targetType = CodeGenState.expectedType;
+  if (targetType) {
+    expr = NarrowingCastHelper_default.wrap(expr, "int", targetType);
   }
+  return { code: expr, effects: [] };
 };
 var accessGenerators = {
   generateCapacityProperty,
@@ -115138,7 +115462,12 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
       orchestrator
     );
   }
-  let argCode = orchestrator.generateExpression(e);
+  const argCode = CodeGenState.withExpectedType(
+    targetParam?.baseType,
+    () => orchestrator.generateExpression(e),
+    true
+    // suppressEnumResolution
+  );
   if (!targetParam?.baseType?.endsWith("*")) {
     return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
   }
@@ -115153,11 +115482,15 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
   if (typeInfo?.isPointer) {
     isPointerVariable = true;
   }
-  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && !isPointerVariable && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
-  if (needsAddressOf) {
-    argCode = `&${argCode}`;
-  }
-  return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
+  const isOpaqueScopeVar = CodeGenState.isOpaqueScopeVariable(argCode);
+  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && !isPointerVariable && !isOpaqueScopeVar && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
+  const finalArgCode = needsAddressOf ? `&${argCode}` : argCode;
+  return wrapWithCppEnumCast(
+    finalArgCode,
+    e,
+    targetParam?.baseType,
+    orchestrator
+  );
 };
 var _shouldPassByValue = (funcExpr, idx, targetParam, isCrossFile, orchestrator) => {
   if (!targetParam) return false;
@@ -115204,7 +115537,12 @@ var generateFunctionCall = (funcExpr, argCtx, input, _state, orchestrator) => {
       resolved.isCrossFile,
       orchestrator
     )) {
-      const argCode = orchestrator.generateExpression(e);
+      const argCode = CodeGenState.withExpectedType(
+        targetParam?.baseType,
+        () => orchestrator.generateExpression(e),
+        true
+        // suppressEnumResolution
+      );
       return wrapWithCppEnumCast(
         argCode,
         e,
@@ -115283,7 +115621,7 @@ var trackPassThroughModifications = (funcName, argExprs, orchestrator) => {
 var CallExprGenerator_default = generateFunctionCall;
 // src/utils/TypeCheckUtils.ts
-var INTEGER_TYPES2 = [
+var INTEGER_TYPES3 = [
   "u8",
   "u16",
   "u32",
@@ -115295,7 +115633,7 @@ var INTEGER_TYPES2 = [
 ];
 var UNSIGNED_TYPES4 = ["u8", "u16", "u32", "u64"];
 var SIGNED_TYPES3 = ["i8", "i16", "i32", "i64"];
-var FLOAT_TYPES2 = ["f32", "f64"];
+var FLOAT_TYPES3 = ["f32", "f64"];
 var STANDARD_WIDTHS = [8, 16, 32];
 var TypeCheckUtils = class {
   /**
@@ -115305,7 +115643,7 @@ var TypeCheckUtils = class {
    * @returns true if it's u8, u16, u32, u64, i8, i16, i32, or i64
    */
   static isInteger(typeName) {
-    return INTEGER_TYPES2.includes(typeName);
+    return INTEGER_TYPES3.includes(typeName);
   }
   /**
    * Check if a type name is an unsigned integer type.
@@ -115332,7 +115670,7 @@ var TypeCheckUtils = class {
    * @returns true if it's f32 or f64
    */
   static isFloat(typeName) {
-    return FLOAT_TYPES2.includes(typeName);
+    return FLOAT_TYPES3.includes(typeName);
   }
   /**
    * Check if a type name is a string type (string<N>).
@@ -116556,12 +116894,20 @@ var generateSubscriptAccess = (ctx, input, state, orchestrator, effects) => {
   return output;
 };
 var handleSingleSubscript = (ctx, expr, input, orchestrator, output) => {
-  const index = orchestrator.generateExpression(expr);
+  const index = CodeGenState.withExpectedType(
+    "size_t",
+    () => orchestrator.generateExpression(expr)
+  );
   validateNotBitmapMember(ctx, input);
   const isRegisterAccess = checkRegisterAccess(ctx, input);
   const identifierTypeInfo = getIdentifierTypeInfo(ctx, input);
   if (isRegisterAccess) {
-    output.result = `((${ctx.result} >> ${index}) & 1)`;
+    let expr2 = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr2 = NarrowingCastHelper_default.wrap(expr2, "int", targetType);
+    }
+    output.result = expr2;
     return output;
   }
   if (ctx.currentMemberIsArray) {
@@ -116575,7 +116921,12 @@ var handleSingleSubscript = (ctx, expr, input, orchestrator, output) => {
   }
   const isPrimitiveIntMember = ctx.currentStructType && TypeCheckUtils_default.isInteger(ctx.currentStructType);
   if (isPrimitiveIntMember) {
-    output.result = `((${ctx.result} >> ${index}) & 1)`;
+    let expr2 = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr2 = NarrowingCastHelper_default.wrap(expr2, "int", targetType);
+    }
+    output.result = expr2;
     output.currentStructType = void 0;
     return output;
   }
@@ -116633,12 +116984,23 @@ var handleDefaultSubscript = (ctx, index, typeInfo, output) => {
     subscriptCount: 1,
     isRegisterAccess: false
   });
-  output.result = subscriptKind === "bit_single" ? `((${ctx.result} >> ${index}) & 1)` : `${ctx.result}[${index}]`;
+  if (subscriptKind === "bit_single") {
+    let expr = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
+    const targetType = CodeGenState.expectedType;
+    if (targetType) {
+      expr = NarrowingCastHelper_default.wrap(expr, "int", targetType);
+    }
+    output.result = expr;
+  } else {
+    output.result = `${ctx.result}[${index}]`;
+  }
   return output;
 };
 var handleBitRangeSubscript = (ctx, exprs, input, state, orchestrator, effects, output) => {
-  const start = orchestrator.generateExpression(exprs[0]);
-  const width = orchestrator.generateExpression(exprs[1]);
+  const [start, width] = CodeGenState.withExpectedType("size_t", () => [
+    orchestrator.generateExpression(exprs[0]),
+    orchestrator.generateExpression(exprs[1])
+  ]);
   const isFloatType = ctx.primaryTypeInfo?.baseType === "f32" || ctx.primaryTypeInfo?.baseType === "f64";
   if (isFloatType && ctx.rootIdentifier) {
     output.result = handleFloatBitRange(
@@ -116655,10 +117017,24 @@ var handleBitRangeSubscript = (ctx, exprs, input, state, orchestrator, effects,
     );
   } else {
     const mask = orchestrator.generateBitMask(width);
-    if (start === "0") {
-      output.result = `((${ctx.result}) & ${mask})`;
+    let expr;
+    if (start === "0" || start === "0U") {
+      expr = `((${ctx.result}) & ${mask})`;
     } else {
-      output.result = `((${ctx.result} >> ${start}) & ${mask})`;
+      expr = `((${ctx.result} >> ${start}) & ${mask})`;
+    }
+    const targetType = CodeGenState.expectedType;
+    if (targetType && ctx.primaryTypeInfo?.baseType) {
+      const promotedSourceType = NarrowingCastHelper_default.getPromotedType(
+        ctx.primaryTypeInfo.baseType
+      );
+      output.result = NarrowingCastHelper_default.wrap(
+        expr,
+        promotedSourceType,
+        targetType
+      );
+    } else {
+      output.result = expr;
     }
   }
   return output;
@@ -116690,7 +117066,7 @@ var handleFloatBitRange = (ctx, state, orchestrator, effects) => {
   if (!shadowIsCurrent) {
     orchestrator.addPendingTempDeclaration(`${shadowName}.f = ${ctx.result};`);
   }
-  if (ctx.start === "0") {
+  if (ctx.start === "0" || ctx.start === "0U") {
     return `(${shadowName}.u & ${mask})`;
   }
   return `((${shadowName}.u >> ${ctx.start}) & ${mask})`;
@@ -116968,6 +117344,21 @@ var generateCriticalStatement = (node, _input, _state, orchestrator) => {
 };
 var CriticalGenerator_default = generateCriticalStatement;
+// src/transpiler/output/codegen/types/COMPOUND_TO_BINARY.ts
+var COMPOUND_TO_BINARY = {
+  "+=": "+",
+  "-=": "-",
+  "*=": "*",
+  "/=": "/",
+  "%=": "%",
+  "&=": "&",
+  "|=": "|",
+  "^=": "^",
+  "<<=": "<<",
+  ">>=": ">>"
+};
+var COMPOUND_TO_BINARY_default = COMPOUND_TO_BINARY;
 // src/transpiler/output/codegen/generators/statements/AtomicGenerator.ts
 var TYPE_MAP2 = {
   u8: "uint8_t",
@@ -116995,18 +117386,6 @@ var STREX_MAP = {
   u32: "__STREXW",
   i32: "__STREXW"
 };
-var SIMPLE_OP_MAP = {
-  "+=": "+",
-  "-=": "-",
-  "*=": "*",
-  "/=": "/",
-  "%=": "%",
-  "&=": "&",
-  "|=": "|",
-  "^=": "^",
-  "<<=": "<<",
-  ">>=": ">>"
-};
 var CLAMP_OP_MAP = {
   "+=": "add",
   "-=": "sub",
@@ -117020,7 +117399,7 @@ function getClampHelperOp(cOp, typeInfo) {
 }
 function generateInnerAtomicOp(cOp, value, typeInfo) {
   const effects = [];
-  const simpleOp = SIMPLE_OP_MAP[cOp] || "+";
+  const simpleOp = COMPOUND_TO_BINARY_default[cOp] || "+";
   const helperOp = getClampHelperOp(cOp, typeInfo);
   if (helperOp) {
     effects.push({
@@ -117612,7 +117991,11 @@ var FunctionGenerator_default = generateFunction;
 // src/transpiler/output/codegen/generators/declarationGenerators/ScopeGenerator.ts
 function generateInitializer(varDecl, isArray, orchestrator) {
   if (varDecl.expression()) {
-    return ` = ${orchestrator.generateExpression(varDecl.expression())}`;
+    const typeName = orchestrator.generateType(varDecl.type());
+    return CodeGenState.withExpectedType(
+      typeName,
+      () => ` = ${orchestrator.generateExpression(varDecl.expression())}`
+    );
   }
   return ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
 }
@@ -117681,8 +118064,13 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
   const arrayDims = varDecl.arrayDimension();
   const arrayTypeCtx = varDecl.type().arrayType?.() ?? null;
   const isArray = arrayDims.length > 0 || arrayTypeCtx !== null;
-  const type = orchestrator.generateType(varDecl.type());
+  let type = orchestrator.generateType(varDecl.type());
   const fullName = QualifiedNameGenerator_default.forMember(scopeName, varName);
+  const isOpaque = orchestrator.isOpaqueType(type);
+  if (isOpaque) {
+    type = `${type}*`;
+    orchestrator.markOpaqueScopeVariable(fullName);
+  }
   const constPrefix = isConst ? "const " : "";
   const prefix = isPrivate ? "static " : "";
   let decl = `${prefix}${constPrefix}${type} ${fullName}`;
@@ -117694,7 +118082,11 @@ function generateRegularVariable(varDecl, varName, scopeName, isPrivate, orchest
     decl += orchestrator.generateArrayDimensions(arrayDims);
   }
   decl += ArrayDimensionUtils_default.generateStringCapacityDim(varDecl.type());
-  decl += generateInitializer(varDecl, isArray, orchestrator);
+  if (isOpaque) {
+    decl += " = NULL";
+  } else {
+    decl += generateInitializer(varDecl, isArray, orchestrator);
+  }
   return decl + ";";
 }
 function generateScopeFunction(funcDecl, scopeName, isPrivate, orchestrator) {
@@ -117906,6 +118298,7 @@ function generateScopedStructInline(node, scopeName, _input, orchestrator) {
 var ScopeGenerator_default = generateScope;
 // src/utils/BitUtils.ts
+var NARROW_TYPES = /* @__PURE__ */ new Set(["u8", "u16", "i8", "i16"]);
 var BitUtils = class _BitUtils {
   /**
    * Convert a boolean expression to an unsigned integer (0U or 1U).
@@ -117996,6 +118389,21 @@ var BitUtils = class _BitUtils {
   static formatHex(value) {
     return `0x${value.toString(16).toUpperCase()}U`;
   }
+  /**
+   * Wrap an expression with a cast for MISRA 10.3 compliance on narrow types.
+   * Bit manipulation operations promote to int; this casts back to the target type.
+   *
+   * @param expr - The expression to potentially wrap
+   * @param targetType - The C-Next type name (e.g., "u8", "u16")
+   * @returns Expression wrapped with cast if narrow, or original expression
+   */
+  static wrapNarrowCast(expr, targetType) {
+    if (!targetType || !NARROW_TYPES.has(targetType)) {
+      return expr;
+    }
+    const cType = TYPE_MAP_default[targetType] ?? targetType;
+    return `(${cType})(${expr})`;
+  }
   /**
    * Generate code to read a single bit from a value.
    * Pattern: ((target >> offset) & 1)
@@ -118042,7 +118450,8 @@ var BitUtils = class _BitUtils {
     const is64Bit = targetType === "u64" || targetType === "i64";
     const one = is64Bit ? "1ULL" : "1U";
     const valueShift = is64Bit ? `((uint64_t)${intValue} << ${offset})` : `(${intValue} << ${offset})`;
-    return `${target} = (${target} & ~(${one} << ${offset})) | ${valueShift};`;
+    const rhs = `(${target} & ~(${one} << ${offset})) | ${valueShift}`;
+    return `${target} = ${_BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
   /**
    * Generate read-modify-write code for multi-bit assignment.
@@ -118057,7 +118466,8 @@ var BitUtils = class _BitUtils {
    */
   static multiBitWrite(target, offset, width, value, targetType) {
     const mask = _BitUtils.generateMask(width, targetType);
-    return `${target} = (${target} & ~(${mask} << ${offset})) | ((${value} & ${mask}) << ${offset});`;
+    const rhs = `(${target} & ~(${mask} << ${offset})) | ((${value} & ${mask}) << ${offset})`;
+    return `${target} = ${_BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
   /**
    * Generate write-only register code for single bit assignment.
@@ -118073,7 +118483,8 @@ var BitUtils = class _BitUtils {
   static writeOnlySingleBit(target, offset, value, targetType) {
     const intValue = _BitUtils.boolToInt(value);
     const castPrefix = targetType === "u64" || targetType === "i64" ? "(uint64_t)" : "";
-    return `${target} = (${castPrefix}${intValue} << ${offset});`;
+    const rhs = `(${castPrefix}${intValue} << ${offset})`;
+    return `${target} = ${_BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
   /**
    * Generate write-only register code for multi-bit assignment.
@@ -118089,7 +118500,8 @@ var BitUtils = class _BitUtils {
    */
   static writeOnlyMultiBit(target, offset, width, value, targetType) {
     const mask = _BitUtils.generateMask(width, targetType);
-    return `${target} = ((${value} & ${mask}) << ${offset});`;
+    const rhs = `((${value} & ${mask}) << ${offset})`;
+    return `${target} = ${_BitUtils.wrapNarrowCast(rhs, targetType)};`;
   }
 };
 var BitUtils_default = BitUtils;
@@ -118804,7 +119216,7 @@ var CnxFileResolver = class {
 var CnxFileResolver_default = CnxFileResolver;
 // src/transpiler/output/codegen/generators/support/IncludeGenerator.ts
-var resolveAngleIncludePath = (filename, sourcePath, includeDirs, inputs) => {
+var resolveAngleIncludePath = (filename, sourcePath, includeDirs, inputs, cppMode) => {
   if (inputs.length === 0) {
     return null;
   }
@@ -118818,25 +119230,33 @@ var resolveAngleIncludePath = (filename, sourcePath, includeDirs, inputs) => {
     foundPath,
     inputs
   );
-  return relativePath ? relativePath.replace(/\.cnx$/, ".h") : null;
+  const ext = cppMode ? ".hpp" : ".h";
+  return relativePath ? relativePath.replace(/\.cnx$/, ext) : null;
 };
 var transformAngleInclude = (includeText, filename, options) => {
-  const { sourcePath, includeDirs = [], inputs = [] } = options;
+  const {
+    sourcePath,
+    includeDirs = [],
+    inputs = [],
+    cppMode = false
+  } = options;
   if (sourcePath) {
     const resolvedPath = resolveAngleIncludePath(
       filename,
       sourcePath,
       includeDirs,
-      inputs
+      inputs,
+      cppMode
     );
     if (resolvedPath) {
       return includeText.replace(`<${filename}.cnx>`, `<${resolvedPath}>`);
     }
   }
-  return includeText.replace(`<${filename}.cnx>`, `<${filename}.h>`);
+  const ext = cppMode ? ".hpp" : ".h";
+  return includeText.replace(`<${filename}.cnx>`, `<${filename}${ext}>`);
 };
 var transformQuoteInclude = (includeText, filepath, options) => {
-  const { sourcePath } = options;
+  const { sourcePath, cppMode = false } = options;
   if (sourcePath) {
     const sourceDir = path.dirname(sourcePath);
     const cnxPath = path.resolve(sourceDir, `${filepath}.cnx`);
@@ -118848,7 +119268,8 @@ var transformQuoteInclude = (includeText, filepath, options) => {
       );
     }
   }
-  return includeText.replace(`"${filepath}.cnx"`, `"${filepath}.h"`);
+  const ext = cppMode ? ".hpp" : ".h";
+  return includeText.replace(`"${filepath}.cnx"`, `"${filepath}${ext}"`);
 };
 var transformIncludeDirective = (includeText, options) => {
   const angleMatch = /#\s*include\s*<([^>]+)\.cnx>/.exec(includeText);
@@ -120641,8 +121062,10 @@ var AssignmentKind = /* @__PURE__ */ ((AssignmentKind2) => {
   AssignmentKind2[AssignmentKind2["GLOBAL_REGISTER_BIT"] = 28] = "GLOBAL_REGISTER_BIT";
   AssignmentKind2[AssignmentKind2["THIS_MEMBER"] = 29] = "THIS_MEMBER";
   AssignmentKind2[AssignmentKind2["THIS_ARRAY"] = 30] = "THIS_ARRAY";
-  AssignmentKind2[AssignmentKind2["MEMBER_CHAIN"] = 31] = "MEMBER_CHAIN";
-  AssignmentKind2[AssignmentKind2["SIMPLE"] = 32] = "SIMPLE";
+  AssignmentKind2[AssignmentKind2["THIS_BIT"] = 31] = "THIS_BIT";
+  AssignmentKind2[AssignmentKind2["THIS_BIT_RANGE"] = 32] = "THIS_BIT_RANGE";
+  AssignmentKind2[AssignmentKind2["MEMBER_CHAIN"] = 33] = "MEMBER_CHAIN";
+  AssignmentKind2[AssignmentKind2["SIMPLE"] = 34] = "SIMPLE";
   return AssignmentKind2;
 })(AssignmentKind || {});
 var AssignmentKind_default = AssignmentKind;
@@ -120684,8 +121107,55 @@ var handlers_default = AssignmentHandlerRegistry;
 function gen() {
   return CodeGenState.generator;
 }
+function tryHandleCompoundNarrowingCast(ctx, target) {
+  if (!ctx.isCompound || !ctx.firstIdTypeInfo) {
+    return null;
+  }
+  const baseType = ctx.firstIdTypeInfo.baseType;
+  const promotedType = NarrowingCastHelper_default.getPromotedType(baseType);
+  if (promotedType !== "int" || baseType === "int") {
+    return null;
+  }
+  const binaryOp = COMPOUND_TO_BINARY_default[ctx.cOp];
+  if (!binaryOp) {
+    return null;
+  }
+  const cType = TYPE_MAP_default[baseType] ?? baseType;
+  const expr = `(${target} ${binaryOp} ${ctx.generatedValue})`;
+  const castExpr = CppModeHelper_default.cast(cType, expr);
+  return `${target} = ${castExpr};`;
+}
+function tryHandleIntToFloatConversion(ctx, target) {
+  if (ctx.isCompound || !ctx.firstIdTypeInfo || !ctx.valueCtx) {
+    return null;
+  }
+  const targetType = ctx.firstIdTypeInfo.baseType;
+  const valueType = TypeResolver_default2.getExpressionType(ctx.valueCtx);
+  if (!valueType) {
+    return null;
+  }
+  if (!NarrowingCastHelper_default.isCrossTypeCategoryConversion(valueType, targetType)) {
+    return null;
+  }
+  if (!NarrowingCastHelper_default.isIntegerType(valueType) || !NarrowingCastHelper_default.isFloatType(targetType)) {
+    return null;
+  }
+  const castedValue = NarrowingCastHelper_default.wrapIntToFloat(
+    ctx.generatedValue,
+    targetType
+  );
+  return `${target} ${ctx.cOp} ${castedValue};`;
+}
 function handleSimpleAssignment(ctx) {
   const target = gen().generateAssignmentTarget(ctx.targetCtx);
+  const compoundResult = tryHandleCompoundNarrowingCast(ctx, target);
+  if (compoundResult) {
+    return compoundResult;
+  }
+  const conversionResult = tryHandleIntToFloatConversion(ctx, target);
+  if (conversionResult) {
+    return conversionResult;
+  }
   return `${target} ${ctx.cOp} ${ctx.generatedValue};`;
 }
 var SimpleHandler_default = handleSimpleAssignment;
@@ -121338,6 +121808,8 @@ function handleStructChainBitRange(ctx) {
 var bitAccessHandlers = [
   [AssignmentKind_default.INTEGER_BIT, handleIntegerBit],
   [AssignmentKind_default.INTEGER_BIT_RANGE, handleIntegerBitRange],
+  [AssignmentKind_default.THIS_BIT, handleIntegerBit],
+  [AssignmentKind_default.THIS_BIT_RANGE, handleIntegerBitRange],
   [AssignmentKind_default.STRUCT_MEMBER_BIT, handleStructMemberBit],
   [AssignmentKind_default.ARRAY_ELEMENT_BIT, handleArrayElementBit],
   [AssignmentKind_default.STRUCT_CHAIN_BIT_RANGE, handleStructChainBitRange]
@@ -121889,14 +122361,28 @@ var AssignmentClassifier = class _AssignmentClassifier {
     return AssignmentKind_default.THIS_MEMBER;
   }
   /**
-   * 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.
    */
   static classifyThisWithArrayAccess(ctx, scopedRegName) {
     if (CodeGenState.symbols.knownRegisters.has(scopedRegName)) {
       const hasBitRange = ctx.postfixOps.some((op) => op.COMMA() !== null);
       return hasBitRange ? AssignmentKind_default.SCOPED_REGISTER_BIT_RANGE : AssignmentKind_default.SCOPED_REGISTER_BIT;
     }
-    return AssignmentKind_default.THIS_ARRAY;
+    const typeInfo = CodeGenState.getVariableTypeInfo(scopedRegName);
+    const subscriptKind = SubscriptClassifier_default.classify({
+      typeInfo: typeInfo ?? null,
+      subscriptCount: ctx.lastSubscriptExprCount,
+      isRegisterAccess: false
+    });
+    switch (subscriptKind) {
+      case "bit_single":
+        return AssignmentKind_default.THIS_BIT;
+      case "bit_range":
+        return AssignmentKind_default.THIS_BIT_RANGE;
+      default:
+        return AssignmentKind_default.THIS_ARRAY;
+    }
   }
   /**
    * Classify simple array/bit access (no prefix, no member access).
@@ -121969,7 +122455,8 @@ var AssignmentClassifier = class _AssignmentClassifier {
     if (isGlobalAtomic) {
       return AssignmentKind_default.ATOMIC_RMW;
     }
-    if (typeInfo.overflowBehavior === "clamp" && TypeCheckUtils_default.isInteger(typeInfo.baseType)) {
+    const ARITHMETIC_COMPOUND_OPS = /* @__PURE__ */ new Set(["+=", "-=", "*="]);
+    if (typeInfo.overflowBehavior === "clamp" && TypeCheckUtils_default.isInteger(typeInfo.baseType) && ARITHMETIC_COMPOUND_OPS.has(ctx.cOp)) {
       return AssignmentKind_default.OVERFLOW_CLAMP;
     }
     return null;
@@ -122618,6 +123105,7 @@ var ArgumentGenerator = class _ArgumentGenerator {
   }
   /**
    * Handle rvalue argument (literals or complex expressions).
+   * Issue #872: Sets expectedType for MISRA 7.2 U suffix on unsigned literals.
    */
   static handleRvalueArg(ctx, targetParamBaseType, callbacks) {
     if (!targetParamBaseType) {
@@ -122625,9 +123113,19 @@ var ArgumentGenerator = class _ArgumentGenerator {
     }
     const cType = TYPE_MAP_default[targetParamBaseType];
     if (!cType || cType === "void") {
-      return callbacks.generateExpression(ctx);
+      return CodeGenState.withExpectedType(
+        targetParamBaseType,
+        () => callbacks.generateExpression(ctx),
+        true
+        // suppressEnumResolution
+      );
     }
-    const value = callbacks.generateExpression(ctx);
+    const value = CodeGenState.withExpectedType(
+      targetParamBaseType,
+      () => callbacks.generateExpression(ctx),
+      true
+      // suppressEnumResolution
+    );
     if (CodeGenState.cppMode) {
       return value;
     }
@@ -123046,6 +123544,14 @@ var AssignmentExpectedTypeResolver = class _AssignmentExpectedTypeResolver {
           identifiers
         );
       }
+      if (identifiers.length === 1 && hasSubscript) {
+        return _AssignmentExpectedTypeResolver.resolveForArrayElement(baseId);
+      }
+      if (identifiers.length >= 2 && hasSubscript) {
+        return _AssignmentExpectedTypeResolver.resolveForMemberArrayElement(
+          identifiers
+        );
+      }
     }
     return { expectedType: null, assignmentContext: null };
   }
@@ -123072,8 +123578,40 @@ var AssignmentExpectedTypeResolver = class _AssignmentExpectedTypeResolver {
    *
    * Issue #452: Enables type-aware resolution of unqualified enum members
    * for nested access (e.g., config.nested.field).
+   *
+   * Delegates to walkMemberChain shared implementation.
    */
   static resolveForMemberChain(identifiers) {
+    return _AssignmentExpectedTypeResolver.walkMemberChain(identifiers);
+  }
+  /**
+   * Resolve expected type for array element access.
+   * Issue #872: arr[i] <- value needs baseType for MISRA 7.2 U suffix.
+   */
+  static resolveForArrayElement(id) {
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
+    if (!typeInfo?.isArray) {
+      return { expectedType: null, assignmentContext: null };
+    }
+    return { expectedType: typeInfo.baseType, assignmentContext: null };
+  }
+  /**
+   * Resolve expected type for member chain ending with array access.
+   * Issue #872: struct.arr[i] <- value needs element type for MISRA 7.2.
+   *
+   * Delegates to walkMemberChain which handles both member chain and
+   * member-array-element patterns identically (both return final field type).
+   */
+  static resolveForMemberArrayElement(identifiers) {
+    return _AssignmentExpectedTypeResolver.walkMemberChain(identifiers);
+  }
+  /**
+   * Walk a struct member chain to find the final field's type.
+   * Shared implementation for both member chain and member-array-element patterns.
+   *
+   * Issue #831: Uses SymbolTable as single source of truth for struct fields.
+   */
+  static walkMemberChain(identifiers) {
     if (identifiers.length < 2) {
       return { expectedType: null, assignmentContext: null };
     }
@@ -123619,11 +124157,10 @@ var ArrayInitHelper = class _ArrayInitHelper {
    */
   static _generateArrayInitValue(typeCtx, expression, callbacks) {
     const typeName = callbacks.getTypeName(typeCtx);
-    const savedExpectedType = CodeGenState.expectedType;
-    CodeGenState.expectedType = typeName;
-    const initValue = callbacks.generateExpression(expression);
-    CodeGenState.expectedType = savedExpectedType;
-    return initValue;
+    return CodeGenState.withExpectedType(
+      typeName,
+      () => callbacks.generateExpression(expression)
+    );
   }
   /**
    * Check if the last expression was an array initializer
@@ -124316,15 +124853,24 @@ ${assignments}`;
       return `${decl} = ${callbacks.getZeroInitializer(typeCtx, isArray)}`;
     }
     const typeName = callbacks.getTypeName(typeCtx);
-    const savedExpectedType = CodeGenState.expectedType;
-    CodeGenState.expectedType = typeName;
     EnumAssignmentValidator_default.validateEnumAssignment(typeName, ctx.expression());
     _VariableDeclHelper.validateIntegerInitializer(ctx, typeName, {
       getExpressionType: callbacks.getExpressionType
     });
-    const result = `${decl} = ${callbacks.generateExpression(ctx.expression())}`;
-    CodeGenState.expectedType = savedExpectedType;
-    return result;
+    return CodeGenState.withExpectedType(typeName, () => {
+      let exprCode = callbacks.generateExpression(ctx.expression());
+      const exprType = callbacks.getExpressionType(ctx.expression());
+      if (exprType && NarrowingCastHelper_default.isCrossTypeCategoryConversion(exprType, typeName)) {
+        if (NarrowingCastHelper_default.isIntegerType(exprType) && NarrowingCastHelper_default.isFloatType(typeName)) {
+          exprCode = NarrowingCastHelper_default.wrapIntToFloat(exprCode, typeName);
+        }
+        if (NarrowingCastHelper_default.isFloatType(exprType) && NarrowingCastHelper_default.isIntegerType(typeName)) {
+          const cType = TYPE_MAP_default[typeName] ?? typeName;
+          exprCode = CppModeHelper_default.cast(cType, exprCode);
+        }
+      }
+      return `${decl} = ${exprCode}`;
+    });
   }
   // ========================================================================
   // Tier 4: Orchestrators (main entry points)
@@ -125185,7 +125731,7 @@ var TypeGenerationHelper_default = TypeGenerationHelper;
 var SIGNED_INTEGERS = /* @__PURE__ */ new Set(["i8", "i16", "i32", "i64"]);
 var UNSIGNED_INTEGERS = /* @__PURE__ */ new Set(["u8", "u16", "u32", "u64"]);
 var ALL_INTEGERS = /* @__PURE__ */ new Set([...SIGNED_INTEGERS, ...UNSIGNED_INTEGERS]);
-var FLOAT_TYPES3 = /* @__PURE__ */ new Set(["f32", "f64"]);
+var FLOAT_TYPES4 = /* @__PURE__ */ new Set(["f32", "f64"]);
 var CastValidator = class _CastValidator {
   /**
    * Check if a type is an integer type.
@@ -125197,7 +125743,7 @@ var CastValidator = class _CastValidator {
    * Check if a type is a floating-point type.
    */
   static isFloatType(typeName) {
-    return FLOAT_TYPES3.has(typeName);
+    return FLOAT_TYPES4.has(typeName);
   }
   /**
    * Check if a type is signed.
@@ -127245,13 +127791,16 @@ var CodeGenerator = class _CodeGenerator {
   /**
    * Issue #477: Generate expression with a specific expected type context.
    * Used by return statements to resolve unqualified enum values.
+   * Note: Uses explicit save/restore (not withExpectedType) to support null values.
    */
   generateExpressionWithExpectedType(ctx, expectedType) {
-    const savedExpectedType = CodeGenState.expectedType;
+    const saved = CodeGenState.expectedType;
     CodeGenState.expectedType = expectedType;
-    const result = this.generateExpression(ctx);
-    CodeGenState.expectedType = savedExpectedType;
-    return result;
+    try {
+      return this.generateExpression(ctx);
+    } finally {
+      CodeGenState.expectedType = saved;
+    }
   }
   /**
    * Generate type translation (C-Next type -> C type).
@@ -128240,6 +128789,22 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   isFloatShadowCurrent(shadowName) {
     return CodeGenState.floatShadowCurrent.has(shadowName);
   }
+  /**
+   * Issue #948: Check if a type is an opaque (forward-declared) struct type.
+   * Opaque types can only be used as pointers (cannot be instantiated).
+   * Part of IOrchestrator interface.
+   */
+  isOpaqueType(typeName) {
+    return CodeGenState.isOpaqueType(typeName);
+  }
+  /**
+   * Issue #948: Mark a scope variable as having an opaque type.
+   * These variables are generated as pointers with NULL initialization.
+   * Part of IOrchestrator interface.
+   */
+  markOpaqueScopeVariable(qualifiedName) {
+    CodeGenState.markOpaqueScopeVariable(qualifiedName);
+  }
   // ===========================================================================
   // End IOrchestrator Implementation
   // ===========================================================================
@@ -128596,15 +129161,17 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     return DEFAULT_TARGET2;
   }
   /**
-   * ADR-010: Transform #include directives, converting .cnx to .h
+   * ADR-010: Transform #include directives, converting .cnx to .h or .hpp
    * ADR-053 A5: Delegates to IncludeGenerator
    * Issue #349: Now passes includeDirs and inputs for angle-bracket resolution
+   * Issue #941: Now passes cppMode for .hpp extension in C++ mode
    */
   transformIncludeDirective(includeText) {
     return includeTransformIncludeDirective(includeText, {
       sourcePath: CodeGenState.sourcePath,
       includeDirs: CodeGenState.includeDirs,
-      inputs: CodeGenState.inputs
+      inputs: CodeGenState.inputs,
+      cppMode: CodeGenState.cppMode
     });
   }
   // Issue #63: validateIncludeNotImplementationFile moved to TypeValidator
@@ -129342,19 +129909,20 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const structFieldTypes = CodeGenState.symbolTable?.getStructFieldTypes(typeName);
     const fields = fieldList.fieldInitializer().map((field) => {
       const fieldName = field.IDENTIFIER().getText();
-      const savedExpectedType = CodeGenState.expectedType;
+      let fieldType;
       if (structFieldTypes?.has(fieldName)) {
-        let fieldType = structFieldTypes.get(fieldName);
+        fieldType = structFieldTypes.get(fieldName);
         if (fieldType.includes("_")) {
           const parts = fieldType.split("_");
           if (parts.length > 1 && this.isCppScopeSymbol(parts[0])) {
             fieldType = parts.join("::");
           }
         }
-        CodeGenState.expectedType = fieldType;
       }
-      const value = this.generateExpression(field.expression());
-      CodeGenState.expectedType = savedExpectedType;
+      const value = CodeGenState.withExpectedType(
+        fieldType,
+        () => this.generateExpression(field.expression())
+      );
       return { fieldName, value };
     });
     if (isCppClass) {
@@ -129869,18 +130437,20 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   // ADR-001: <- becomes = in C, with compound assignment operators
   generateAssignment(ctx) {
     const targetCtx = ctx.assignmentTarget();
-    const savedExpectedType = CodeGenState.expectedType;
     const savedAssignmentContext = { ...CodeGenState.assignmentContext };
     const resolved = AssignmentExpectedTypeResolver_default.resolve(targetCtx);
-    if (resolved.expectedType) {
-      CodeGenState.expectedType = resolved.expectedType;
-    }
     if (resolved.assignmentContext) {
       CodeGenState.assignmentContext = resolved.assignmentContext;
     }
-    const value = this.generateExpression(ctx.expression());
-    CodeGenState.expectedType = savedExpectedType;
-    CodeGenState.assignmentContext = savedAssignmentContext;
+    let value;
+    try {
+      value = CodeGenState.withExpectedType(
+        resolved.expectedType,
+        () => this.generateExpression(ctx.expression())
+      );
+    } finally {
+      CodeGenState.assignmentContext = savedAssignmentContext;
+    }
     const operatorCtx = ctx.assignmentOperator();
     const cnextOp = operatorCtx.getText();
     const cOp = ASSIGNMENT_OPERATOR_MAP2[cnextOp] || "=";
@@ -130090,7 +130660,11 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
    * @returns The qualified enum member access, or null if not an enum member
    */
   _resolveUnqualifiedEnumMember(id) {
-    if (CodeGenState.expectedType && CodeGenState.symbols.knownEnums.has(CodeGenState.expectedType)) {
+    if (CodeGenState.suppressBareEnumResolution) {
+    } else if (
+      // Type-aware resolution: check only the expected enum type
+      CodeGenState.expectedType && CodeGenState.symbols.knownEnums.has(CodeGenState.expectedType)
+    ) {
       const members = CodeGenState.symbols.enumMembers.get(
         CodeGenState.expectedType
       );
@@ -130197,7 +130771,9 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const minComparison = minValue === "0" ? `0.0${floatSuffix}` : `((${floatCastType})${minValue})`;
     const maxComparison = `((${floatCastType})${maxValue})`;
     const finalCast = CppModeHelper_default.cast(targetType, `(${expr})`);
-    return `((${expr}) > ${maxComparison} ? ${maxValue} : (${expr}) < ${minComparison} ? ${minValue} : ${finalCast})`;
+    const castMax = CppModeHelper_default.cast(targetType, maxValue);
+    const castMin = minValue === "0" ? "0" : CppModeHelper_default.cast(targetType, minValue);
+    return `((${expr}) > ${maxComparison} ? ${castMax} : (${expr}) < ${minComparison} ? ${castMin} : ${finalCast})`;
   }
   /**
    * ADR-023: Generate sizeof expression
@@ -130888,15 +131464,16 @@ var HeaderGeneratorUtils = class _HeaderGeneratorUtils {
     }
     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);
+      }
+    }
+    const userIncludeSet = new Set(options.userIncludes ?? []);
+    if (options.cppMode && options.userIncludes) {
+      for (const inc of options.userIncludes) {
+        const hVersion = inc.replace(/\.hpp"/, '.h"').replace(/\.hpp>/, ".h>");
+        userIncludeSet.add(hVersion);
       }
     }
-    const userIncludeSet = new Set(
-      options.userIncludes?.map(
-        (inc) => options.cppMode ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>") : inc
-      ) ?? []
-    );
     for (const directive of headersToInclude) {
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
@@ -131274,18 +131851,21 @@ var IncludeExtractor = class {
   /**
    * Extract user includes from a parsed C-Next program.
    *
-   * Extracts #include directives for .cnx files and transforms them to .h includes.
+   * Extracts #include directives for .cnx files and transforms them to .h or .hpp includes.
+   * Issue #941: Uses .hpp extension when cppMode is true.
    * This enables cross-file type definitions in generated headers.
    *
    * @param tree The parsed C-Next program
-   * @returns Array of transformed include strings (e.g., '#include "types.h"')
+   * @param cppMode Whether to use .hpp extension (C++ mode)
+   * @returns Array of transformed include strings (e.g., '#include "types.h"' or '#include "types.hpp"')
    */
-  static collectUserIncludes(tree) {
+  static collectUserIncludes(tree, cppMode = false) {
     const userIncludes = [];
+    const ext = cppMode ? ".hpp" : ".h";
     for (const includeDir of tree.includeDirective()) {
       const includeText = includeDir.getText();
       if (includeText.includes(".cnx")) {
-        const transformedInclude = includeText.replace(/\.cnx"/, '.h"').replace(/\.cnx>/, ".h>");
+        const transformedInclude = includeText.replace(/\.cnx"/, `${ext}"`).replace(/\.cnx>/, `${ext}>`);
         userIncludes.push(transformedInclude);
       }
     }
@@ -132386,6 +132966,7 @@ var TSymbolInfoAdapter = class _TSymbolInfoAdapter {
     const registerMemberCTypes = /* @__PURE__ */ new Map();
     const scopePrivateConstValues = /* @__PURE__ */ new Map();
     const functionReturnTypes = /* @__PURE__ */ new Map();
+    const opaqueTypes = /* @__PURE__ */ new Set();
     for (const symbol of symbols) {
       switch (symbol.kind) {
         case "struct":
@@ -132473,6 +133054,8 @@ var TSymbolInfoAdapter = class _TSymbolInfoAdapter {
       scopePrivateConstValues,
       // Function return types
       functionReturnTypes,
+      // Issue #948: Opaque types
+      opaqueTypes,
       // Methods
       getSingleFunctionForVariable: (scopeName, varName) => _TSymbolInfoAdapter.getSingleFunctionForVariable(
         scopeVariableUsage,
@@ -132670,42 +133253,35 @@ var TSymbolInfoAdapter = class _TSymbolInfoAdapter {
       );
     }
     return {
-      // Type sets - knownEnums and knownScopes are merged
+      ...base,
       knownScopes: mergedKnownScopes,
-      knownStructs: base.knownStructs,
       knownEnums: mergedKnownEnums,
-      knownBitmaps: base.knownBitmaps,
-      knownRegisters: base.knownRegisters,
-      // Scope info
-      scopeMembers: base.scopeMembers,
-      scopeMemberVisibility: base.scopeMemberVisibility,
-      scopeVariableUsage: base.scopeVariableUsage,
-      // Struct info
-      structFields: base.structFields,
-      structFieldArrays: base.structFieldArrays,
-      structFieldDimensions: base.structFieldDimensions,
-      // Enum info - merged
       enumMembers: mergedEnumMembers,
-      // Bitmap info
-      bitmapFields: base.bitmapFields,
-      bitmapBackingType: base.bitmapBackingType,
-      bitmapBitWidth: base.bitmapBitWidth,
-      // Register info
-      scopedRegisters: base.scopedRegisters,
-      registerMemberAccess: base.registerMemberAccess,
-      registerMemberTypes: base.registerMemberTypes,
-      registerBaseAddresses: base.registerBaseAddresses,
-      registerMemberOffsets: base.registerMemberOffsets,
-      registerMemberCTypes: base.registerMemberCTypes,
-      // Private const values
-      scopePrivateConstValues: base.scopePrivateConstValues,
-      // Function return types - merged
-      functionReturnTypes: mergedFunctionReturnTypes,
-      // Methods - delegate to base's implementation
-      getSingleFunctionForVariable: base.getSingleFunctionForVariable,
-      hasPublicSymbols: base.hasPublicSymbols
+      functionReturnTypes: mergedFunctionReturnTypes
     };
   }
+  /**
+   * Issue #948: Merge opaque types from an external source (e.g., SymbolTable)
+   * into an existing ICodeGenSymbols.
+   *
+   * Opaque types are forward-declared struct types (like `typedef struct _foo foo;`)
+   * that come from C headers and need to be tracked for correct scope variable
+   * generation (as pointers with NULL initialization).
+   *
+   * @param base The ICodeGenSymbols from the current file
+   * @param externalOpaqueTypes Array of opaque type names from external sources
+   * @returns New ICodeGenSymbols with merged opaque types
+   */
+  static mergeOpaqueTypes(base, externalOpaqueTypes) {
+    if (externalOpaqueTypes.length === 0) {
+      return base;
+    }
+    const mergedOpaqueTypes = new Set(base.opaqueTypes);
+    for (const typeName of externalOpaqueTypes) {
+      mergedOpaqueTypes.add(typeName);
+    }
+    return { ...base, opaqueTypes: mergedOpaqueTypes };
+  }
 };
 var TSymbolInfoAdapter_default = TSymbolInfoAdapter;
@@ -133092,6 +133668,18 @@ var DeclaratorUtils = class _DeclaratorUtils {
     }
     return void 0;
   }
+  /**
+   * Extract the first declarator name from an init-declarator-list.
+   * For "typedef struct _widget_t widget_t;", this returns "widget_t".
+   * Used for Issue #948 opaque type detection.
+   */
+  static extractFirstDeclaratorName(initDeclList) {
+    const initDeclarators = initDeclList.initDeclarator?.();
+    if (!initDeclarators || initDeclarators.length === 0) return void 0;
+    const firstDeclarator = initDeclarators[0].declarator?.();
+    if (!firstDeclarator) return void 0;
+    return _DeclaratorUtils.extractDeclaratorName(firstDeclarator) ?? void 0;
+  }
 };
 var DeclaratorUtils_default = DeclaratorUtils;
@@ -133113,6 +133701,7 @@ var StructCollector2 = class _StructCollector {
     const name = identifier?.getText() || typedefName;
     if (!name) return null;
     const isUnion = structSpec.structOrUnion()?.getText() === "union";
+    const hasBody = structSpec.structDeclarationList() !== null;
     const fields = _StructCollector.collectFields(
       structSpec,
       name,
@@ -133120,8 +133709,16 @@ var StructCollector2 = class _StructCollector {
       warnings
     );
     const needsStructKeyword = Boolean(identifier && !isTypedef);
-    if (symbolTable && needsStructKeyword) {
-      symbolTable.markNeedsStructKeyword(name);
+    if (symbolTable) {
+      _StructCollector.updateSymbolTable(
+        symbolTable,
+        name,
+        needsStructKeyword,
+        hasBody,
+        isTypedef,
+        typedefName,
+        identifier?.getText()
+      );
     }
     return {
       kind: "struct",
@@ -133135,6 +133732,44 @@ var StructCollector2 = class _StructCollector {
       fields: fields.size > 0 ? fields : void 0
     };
   }
+  /**
+   * Update symbol table with struct metadata.
+   * Extracted to reduce cognitive complexity of collect().
+   */
+  static updateSymbolTable(symbolTable, name, needsStructKeyword, hasBody, isTypedef, typedefName, structTag) {
+    if (needsStructKeyword) {
+      symbolTable.markNeedsStructKeyword(name);
+    }
+    if (isTypedef && !hasBody && typedefName) {
+      symbolTable.markOpaqueType(typedefName);
+      if (structTag) {
+        symbolTable.registerStructTagAlias(structTag, typedefName);
+      }
+    }
+    if (hasBody) {
+      _StructCollector.unmarkOpaqueTypesOnDefinition(
+        symbolTable,
+        structTag,
+        typedefName
+      );
+    }
+  }
+  /**
+   * Unmark opaque types when a full struct definition is encountered.
+   * Handles: typedef struct _foo foo; struct _foo { ... };
+   */
+  static unmarkOpaqueTypesOnDefinition(symbolTable, structTag, typedefName) {
+    if (structTag) {
+      symbolTable.unmarkOpaqueType(structTag);
+      const typedefAlias = symbolTable.getStructTagAlias(structTag);
+      if (typedefAlias) {
+        symbolTable.unmarkOpaqueType(typedefAlias);
+      }
+    }
+    if (typedefName) {
+      symbolTable.unmarkOpaqueType(typedefName);
+    }
+  }
   /**
    * Collect fields from a struct/union definition.
    */
@@ -133271,6 +133906,15 @@ var FunctionCollector2 = class _FunctionCollector {
       isArray: p.isArray
     }));
   }
+  /**
+   * Resolve return type, appending '*' if declarator has a pointer.
+   * Issue #895 Bug B / Issue #945: C grammar puts pointer before directDeclarator
+   * (e.g., `widget_t *func()` has declarator.pointer() !== null)
+   */
+  static _resolveReturnType(baseType, declarator) {
+    const hasPointer = declarator.pointer() !== null;
+    return hasPointer ? `${baseType}*` : baseType;
+  }
   /**
    * Collect a function symbol from a function definition.
    *
@@ -133284,7 +133928,11 @@ var FunctionCollector2 = class _FunctionCollector {
     if (!name) return null;
     const line = funcDef.start?.line ?? 0;
     const declSpecs = funcDef.declarationSpecifiers();
-    const returnType = declSpecs ? DeclaratorUtils_default.extractTypeFromDeclSpecs(declSpecs) : "int";
+    const baseType = declSpecs ? DeclaratorUtils_default.extractTypeFromDeclSpecs(declSpecs) : "int";
+    const returnType = _FunctionCollector._resolveReturnType(
+      baseType,
+      declarator
+    );
     const parameters = _FunctionCollector._mapParameters(
       DeclaratorUtils_default.extractFunctionParameters(declarator)
     );
@@ -133314,8 +133962,10 @@ var FunctionCollector2 = class _FunctionCollector {
     const parameters = _FunctionCollector._mapParameters(
       DeclaratorUtils_default.extractFunctionParameters(declarator)
     );
-    const hasPointer = declarator.pointer() !== null;
-    const returnType = hasPointer ? `${baseType}*` : baseType;
+    const returnType = _FunctionCollector._resolveReturnType(
+      baseType,
+      declarator
+    );
     return {
       kind: "function",
       name,
@@ -133458,39 +134108,33 @@ var CResolver = class _CResolver {
     const line = decl.start?.line ?? 0;
     const isTypedef = DeclaratorUtils_default.hasStorageClass(declSpecs, "typedef");
     const isExtern = DeclaratorUtils_default.hasStorageClass(declSpecs, "extern");
+    const ctx = {
+      sourceFile,
+      line,
+      isTypedef,
+      isExtern,
+      symbols
+    };
     const structSpec = DeclaratorUtils_default.findStructOrUnionSpecifier(declSpecs);
     if (structSpec) {
-      const typedefName = isTypedef ? DeclaratorUtils_default.extractTypedefNameFromSpecs(declSpecs) : void 0;
-      const structSymbol = StructCollector_default2.collect(
+      _CResolver.collectStructSymbol(
         structSpec,
-        sourceFile,
-        line,
+        decl,
+        declSpecs,
+        ctx,
         symbolTable,
-        typedefName,
-        isTypedef,
         warnings
       );
-      if (structSymbol) {
-        symbols.push(structSymbol);
-      }
     }
     const enumSpec = DeclaratorUtils_default.findEnumSpecifier(declSpecs);
     if (enumSpec) {
-      const enumResult = EnumCollector_default2.collect(enumSpec, sourceFile, line);
-      if (enumResult) {
-        symbols.push(enumResult.enum);
-        for (const member of enumResult.members) {
-          symbols.push(member);
-        }
-      }
+      _CResolver.collectEnumSymbols(
+        enumSpec,
+        ctx.sourceFile,
+        ctx.line,
+        ctx.symbols
+      );
     }
-    const ctx = {
-      sourceFile,
-      line,
-      isTypedef,
-      isExtern,
-      symbols
-    };
     const initDeclList = decl.initDeclaratorList();
     if (initDeclList) {
       const baseType = DeclaratorUtils_default.extractTypeFromDeclSpecs(declSpecs);
@@ -133504,6 +134148,49 @@ var CResolver = class _CResolver {
       );
     }
   }
+  /**
+   * Collect struct symbol from a struct specifier.
+   * Extracted to reduce cognitive complexity of collectDeclaration().
+   */
+  static collectStructSymbol(structSpec, decl, declSpecs, ctx, symbolTable, warnings) {
+    const typedefName = ctx.isTypedef ? _CResolver.extractTypedefName(decl, declSpecs) : void 0;
+    const structSymbol = StructCollector_default2.collect(
+      structSpec,
+      ctx.sourceFile,
+      ctx.line,
+      symbolTable,
+      typedefName,
+      ctx.isTypedef,
+      warnings
+    );
+    if (structSymbol) {
+      ctx.symbols.push(structSymbol);
+    }
+  }
+  /**
+   * Extract typedef name from declaration.
+   * First try from init-declarator-list, then fall back to specifiers.
+   */
+  static extractTypedefName(decl, declSpecs) {
+    const initDeclList = decl.initDeclaratorList();
+    if (initDeclList) {
+      const name = DeclaratorUtils_default.extractFirstDeclaratorName(initDeclList);
+      if (name) return name;
+    }
+    return DeclaratorUtils_default.extractTypedefNameFromSpecs(declSpecs);
+  }
+  /**
+   * Collect enum symbols from an enum specifier.
+   * Extracted to reduce cognitive complexity of collectDeclaration().
+   */
+  static collectEnumSymbols(enumSpec, sourceFile, line, symbols) {
+    const enumResult = EnumCollector_default2.collect(enumSpec, sourceFile, line);
+    if (!enumResult) return;
+    symbols.push(enumResult.enum);
+    for (const member of enumResult.members) {
+      symbols.push(member);
+    }
+  }
   /**
    * Collect symbols from init declarator list.
    */
@@ -137697,6 +138384,9 @@ var IndexTypeListener = class extends CNextListener {
       if (TypeConstants_default.UNSIGNED_INDEX_TYPES.includes(resolvedType)) {
         continue;
       }
+      if (CodeGenState.isKnownEnum(resolvedType)) {
+        continue;
+      }
       const { line, column } = ParserUtils_default.getPosition(ctx);
       this.analyzer.addError(line, column, "E0852", resolvedType);
       return;
@@ -137786,6 +138476,10 @@ var IndexTypeListener = class extends CNextListener {
       if (TypeConstants_default.SIGNED_TYPES.includes(currentType)) {
         return "bool";
       }
+      const strippedType = currentType.replace(/\[[^\]]*\]$/, "");
+      if (strippedType !== currentType) {
+        return strippedType;
+      }
       return currentType;
     }
     if (op.LPAREN()) {
@@ -138186,7 +138880,7 @@ var CacheKeyGenerator_default = CacheKeyGenerator;
 // src/utils/cache/CacheManager.ts
 var defaultFs7 = NodeFileSystem_default.instance;
-var CACHE_VERSION = 4;
+var CACHE_VERSION = 5;
 var TRANSPILER_VERSION = package_default.version;
 var CacheManager = class {
   projectRoot;
@@ -138286,14 +138980,15 @@ var CacheManager = class {
       symbols,
       structFields,
       needsStructKeyword: cachedEntry.needsStructKeyword ?? [],
-      enumBitWidth
+      enumBitWidth,
+      opaqueTypes: cachedEntry.opaqueTypes ?? []
     };
   }
   /**
    * Store symbols and struct fields for a file
    * ADR-055 Phase 7: Takes ISerializedSymbol[] directly
    */
-  setSymbols(filePath, symbols, structFields, needsStructKeyword, enumBitWidth) {
+  setSymbols(filePath, symbols, structFields, needsStructKeyword, enumBitWidth, opaqueTypes) {
     if (!this.cache) return;
     let cacheKey;
     try {
@@ -138321,7 +139016,8 @@ var CacheManager = class {
       symbols: serializedSymbols,
       structFields: serializedFields,
       needsStructKeyword,
-      enumBitWidth: serializedEnumBitWidth
+      enumBitWidth: serializedEnumBitWidth,
+      opaqueTypes
     };
     this.cache.setKey(filePath, entry);
     this.dirty = true;
@@ -138349,12 +139045,14 @@ var CacheManager = class {
       filePath,
       symbolTable
     );
+    const opaqueTypes = symbolTable.getAllOpaqueTypes();
     this.setSymbols(
       filePath,
       symbols,
       structFields,
       needsStructKeyword,
-      enumBitWidth
+      enumBitWidth,
+      opaqueTypes
     );
   }
   /**
@@ -138797,7 +139495,7 @@ var Transpiler = class {
    * Stage 6: Generate headers (per-file)
    */
   async _executePipeline(input, result) {
-    this._collectAllHeaderSymbols(input.headerFiles, result);
+    await this._collectAllHeaderSymbols(input.headerFiles, result);
     CodeGenState.buildExternalStructFields();
     if (!this._collectAllCNextSymbolsFromPipeline(input.cnextFiles, result)) {
       return;
@@ -138906,6 +139604,13 @@ var Transpiler = class {
           externalEnumSources
         );
       }
+      const externalOpaqueTypes = CodeGenState.symbolTable.getAllOpaqueTypes();
+      if (externalOpaqueTypes.length > 0) {
+        symbolInfo = TSymbolInfoAdapter_default.mergeOpaqueTypes(
+          symbolInfo,
+          externalOpaqueTypes
+        );
+      }
       CodeGenState.symbols = symbolInfo;
       const analyzerErrors = runAnalyzers_default(tree, tokenStream);
       if (analyzerErrors.length > 0) {
@@ -138923,7 +139628,10 @@ var Transpiler = class {
         cppMode: this.cppDetected,
         symbolInfo
       });
-      const userIncludes = IncludeExtractor_default.collectUserIncludes(tree);
+      const userIncludes = IncludeExtractor_default.collectUserIncludes(
+        tree,
+        this.cppDetected
+      );
       const passByValue = this.codeGenerator.getPassByValueParams();
       const passByValueCopy = MapUtils_default.deepCopyStringSetMap(passByValue);
       this.state.setSymbolInfo(sourcePath, symbolInfo);
@@ -139076,11 +139784,12 @@ var Transpiler = class {
   }
   /**
    * Stage 2: Collect symbols from all C/C++ headers
+   * Issue #945: Made async for preprocessing support.
    */
-  _collectAllHeaderSymbols(headerFiles, result) {
+  async _collectAllHeaderSymbols(headerFiles, result) {
     for (const file of headerFiles) {
       try {
-        this.doCollectHeaderSymbols(file);
+        await this.doCollectHeaderSymbols(file);
         result.filesProcessed++;
       } catch (err) {
         this.warnings.push(`Failed to process header ${file.path}: ${err}`);
@@ -139359,15 +140068,16 @@ var Transpiler = class {
   /**
    * Stage 2: Collect symbols from a single C/C++ header
    * Issue #592: Recursive include processing moved to IncludeResolver.resolveHeadersTransitively()
+   * Issue #945: Added preprocessing support for conditional compilation
    * SonarCloud S3776: Refactored to use helper methods for reduced complexity.
    */
-  doCollectHeaderSymbols(file) {
+  async doCollectHeaderSymbols(file) {
     const absolutePath = resolve12(file.path);
     this.state.markHeaderProcessed(absolutePath);
     if (this.tryRestoreFromCache(file)) {
       return;
     }
-    const content = this.fs.readFile(file.path);
+    const content = await this.getHeaderContent(file);
     this.parseHeaderFile(file, content);
     if (this.config.debugMode) {
       const symbols = CodeGenState.symbolTable.getSymbolsByFile(file.path);
@@ -139398,9 +140108,51 @@ var Transpiler = class {
       cached.needsStructKeyword
     );
     CodeGenState.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
+    CodeGenState.symbolTable.restoreOpaqueTypes(cached.opaqueTypes);
     this.detectCppFromFileType(file);
     return true;
   }
+  /**
+   * Get header content, optionally preprocessed.
+   * Issue #945: Evaluates #if/#ifdef directives using system preprocessor.
+   *
+   * Only preprocesses when necessary to avoid side effects from full expansion.
+   * Preprocessing is needed when the file has conditional compilation patterns
+   * like #if MACRO != 0 that require expression evaluation.
+   */
+  async getHeaderContent(file) {
+    const rawContent = this.fs.readFile(file.path);
+    if (this.config.preprocess === false) {
+      return rawContent;
+    }
+    if (!this.preprocessor.isAvailable()) {
+      return rawContent;
+    }
+    if (!this.needsConditionalPreprocessing(rawContent)) {
+      return rawContent;
+    }
+    const result = await this.preprocessor.preprocess(file.path, {
+      defines: this.config.defines,
+      includePaths: this.config.includeDirs,
+      keepLineDirectives: false
+      // We don't need line mappings for symbol collection
+    });
+    if (!result.success) {
+      this.warnings.push(
+        `Preprocessing failed for ${file.path}: ${result.error}. Using raw content.`
+      );
+      return rawContent;
+    }
+    return result.content;
+  }
+  /**
+   * Check if a header file needs conditional preprocessing.
+   * Issue #945: Only preprocess files with #if expressions that need evaluation.
+   */
+  needsConditionalPreprocessing(content) {
+    const ifExpressionPattern = /#(?:if|elif)\s+(?!defined\s*\()(?![01]\s*(?:$|\n|\/\*|\/\/))\w+/m;
+    return ifExpressionPattern.test(content);
+  }
   /**
    * Restore cached symbols to the symbol table.
    * ADR-055 Phase 7: Converts ISerializedSymbol[] from cache to typed symbols.