c-next 0.1.16 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -681,6 +681,45 @@ export default class CodeGenerator implements IOrchestrator {
     return this.symbols!.knownEnums;
   }
 
+  /**
+   * Issue #304: Check if we're generating C++ output.
+   * Part of IOrchestrator interface.
+   */
+  isCppMode(): boolean {
+    return this.cppMode;
+  }
+
+  /**
+   * Issue #304: Check if a type is a C++ enum class (scoped enum).
+   * These require explicit casts to integer types in C++.
+   * Part of IOrchestrator interface.
+   */
+  isCppEnumClass(typeName: string): boolean {
+    if (!this.symbolTable) {
+      return false;
+    }
+
+    const symbols = this.symbolTable.getOverloads(typeName);
+    for (const sym of symbols) {
+      if (
+        sym.sourceLanguage === ESourceLanguage.Cpp &&
+        sym.kind === ESymbolKind.Enum
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Issue #304: Get the type of an expression.
+   * Part of IOrchestrator interface.
+   */
+  getExpressionType(ctx: Parser.ExpressionContext): string | null {
+    return this.typeResolver!.getExpressionType(ctx);
+  }
+
   /**
    * Generate a block (curly braces with statements).
    * Part of IOrchestrator interface (ADR-053 A3).
@@ -1159,6 +1198,94 @@ export default class CodeGenerator implements IOrchestrator {
     return false;
   }
 
+  /**
+   * Issue #294: Check if an identifier is a known scope
+   * Checks both the local SymbolCollector (current file) and the global SymbolTable
+   * (all files including includes). This ensures cross-file scope references are
+   * properly validated.
+   */
+  private isKnownScope(name: string): boolean {
+    // Check local file's symbol collector first
+    if (this.symbols?.knownScopes.has(name)) {
+      return true;
+    }
+
+    // Check global symbol table for scopes from included files
+    if (this.symbolTable) {
+      const symbols = this.symbolTable.getOverloads(name);
+      if (symbols.some((sym) => sym.kind === ESymbolKind.Namespace)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Issue #304: Check if a name is a C++ scope-like symbol that requires :: syntax
+   * This includes C++ namespaces, classes, and enum classes (scoped enums).
+   * Returns true if the symbol comes from C++ and needs :: for member access.
+   */
+  private isCppScopeSymbol(name: string): boolean {
+    if (!this.symbolTable) {
+      return false;
+    }
+
+    const symbols = this.symbolTable.getOverloads(name);
+    for (const sym of symbols) {
+      // Only consider C++ symbols
+      if (sym.sourceLanguage !== ESourceLanguage.Cpp) {
+        continue;
+      }
+
+      // C++ namespaces, classes, and enums (enum class) need :: syntax
+      if (
+        sym.kind === ESymbolKind.Namespace ||
+        sym.kind === ESymbolKind.Class ||
+        sym.kind === ESymbolKind.Enum
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Issue #304: Get the appropriate scope separator for C++ vs C/C-Next.
+   * C++ uses :: for scope resolution, C/C-Next uses _ (underscore).
+   */
+  private getScopeSeparator(isCppContext: boolean): string {
+    return isCppContext ? "::" : "_";
+  }
+
+  /**
+   * Issue #304: Check if a type name is from a C++ header
+   * Used to determine whether to use {} or {0} for initialization.
+   * C++ types with constructors may fail with {0} but work with {}.
+   */
+  private isCppType(typeName: string): boolean {
+    if (!this.symbolTable) {
+      return false;
+    }
+
+    const symbols = this.symbolTable.getOverloads(typeName);
+    for (const sym of symbols) {
+      if (sym.sourceLanguage === ESourceLanguage.Cpp) {
+        // Any C++ struct, class, or user-defined type
+        if (
+          sym.kind === ESymbolKind.Struct ||
+          sym.kind === ESymbolKind.Class ||
+          sym.kind === ESymbolKind.Type
+        ) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Generate C code from a C-Next program
    * @param tree The parsed C-Next program
@@ -3569,14 +3696,6 @@ export default class CodeGenerator implements IOrchestrator {
     this.typeResolver!.validateLiteralFitsType(literalText, targetType);
   }
 
-  /**
-   * ADR-024: Get the type of an expression for type checking.
-   * Returns the inferred type or null if type cannot be determined.
-   */
-  private getExpressionType(ctx: Parser.ExpressionContext): string | null {
-    return this.typeResolver!.getExpressionType(ctx);
-  }
-
   /**
    * ADR-024: Get the type of a postfix expression.
    */
@@ -5372,9 +5491,22 @@ export default class CodeGenerator implements IOrchestrator {
         return `(${typeName})0`;
       }
 
+      // Issue #304: C++ types with constructors may fail with {0}
+      // Use {} for C++ types, {0} for C types
+      if (this.isCppType(typeName)) {
+        return "{}";
+      }
+
       return "{0}";
     }
 
+    // Issue #295: C++ template types use value initialization {}
+    // Template types like FlexCAN_T4<CAN1, RX_SIZE_256, TX_SIZE_16> are non-trivial
+    // class types that cannot be initialized with = 0
+    if (typeCtx.templateType()) {
+      return "{}";
+    }
+
     // Primitive types
     if (typeCtx.primitiveType()) {
       const primType = typeCtx.primitiveType()!.getText();
@@ -5860,7 +5992,7 @@ export default class CodeGenerator implements IOrchestrator {
         const fieldName = identifiers[3].getText();
 
         // Check if first identifier is a scope
-        if (this.symbols!.knownScopes.has(scopeName)) {
+        if (this.isKnownScope(scopeName)) {
           // ADR-016: Validate visibility before allowing cross-scope access
           this.validateCrossScopeVisibility(scopeName, regName);
           const fullRegName = `${scopeName}_${regName}`;
@@ -5997,7 +6129,7 @@ export default class CodeGenerator implements IOrchestrator {
       const firstId = identifiers[0].getText();
       // Check if this is a scoped register: Scope.Register.Member[bit]
       const scopedRegName =
-        identifiers.length >= 3 && this.symbols!.knownScopes.has(firstId)
+        identifiers.length >= 3 && this.isKnownScope(firstId)
           ? `${firstId}_${identifiers[1].getText()}`
           : null;
       const isScopedRegister =
@@ -6022,7 +6154,7 @@ export default class CodeGenerator implements IOrchestrator {
           let exprIndex = 0;
 
           // Check if first identifier is a scope for special handling
-          const isCrossScope = this.symbols!.knownScopes.has(firstId);
+          const isCrossScope = this.isKnownScope(firstId);
 
           // Bug #8: Track struct types to detect bit access through chains
           // e.g., items[0].byte[7] where byte is u8 - final [7] is bit access
@@ -6238,10 +6370,7 @@ export default class CodeGenerator implements IOrchestrator {
         // Pattern 2: Scope.GPIO7.DR_SET[bit] - 3 identifiers, first is scope
         let fullName: string;
         const leadingId = identifiers[0].getText();
-        if (
-          this.symbols!.knownScopes.has(leadingId) &&
-          identifiers.length >= 3
-        ) {
+        if (this.isKnownScope(leadingId) && identifiers.length >= 3) {
           // Scoped register: Scope.Register.Member
           const scopeName = leadingId;
           const regName = identifiers[1].getText();
@@ -6302,10 +6431,7 @@ export default class CodeGenerator implements IOrchestrator {
               // Issue #187: Generate width-appropriate memory access
               // Determine register name for base address lookup
               let regName: string;
-              if (
-                this.symbols!.knownScopes.has(leadingId) &&
-                identifiers.length >= 3
-              ) {
+              if (this.isKnownScope(leadingId) && identifiers.length >= 3) {
                 regName = `${leadingId}_${identifiers[1].getText()}`;
               } else {
                 regName = leadingId;
@@ -6386,7 +6512,7 @@ export default class CodeGenerator implements IOrchestrator {
           // Read-write: need read-modify-write
           return `${regName} = (${regName} & ~(1 << ${bitIndex})) | (${this.foldBooleanToInt(value)} << ${bitIndex});`;
         }
-      } else if (this.symbols!.knownScopes.has(firstId)) {
+      } else if (this.isKnownScope(firstId)) {
         // ADR-016: Validate visibility before allowing cross-scope access
         const memberName = parts[1];
         this.validateCrossScopeVisibility(firstId, memberName);
@@ -7175,18 +7301,24 @@ export default class CodeGenerator implements IOrchestrator {
     const identifiers = ctx.IDENTIFIER();
     const parts = identifiers.map((id) => id.getText());
     const firstId = parts[0];
+    // Issue #304: Check if first identifier is a C++ scope symbol
+    const isCppAccess = this.isCppScopeSymbol(firstId);
     // Check if first identifier is a register
     if (this.symbols!.knownRegisters.has(firstId)) {
       // Register member access: GPIO7.DR_SET -> GPIO7_DR_SET
       return parts.join("_");
     }
     // Check if first identifier is a scope
-    if (this.symbols!.knownScopes.has(firstId)) {
+    if (this.isKnownScope(firstId)) {
       // ADR-016: Validate visibility before allowing cross-scope access
       const memberName = parts[1];
       this.validateCrossScopeVisibility(firstId, memberName);
-      // Scope member access: global.Counter.value -> Counter_value
-      return parts.join("_");
+      // Issue #304: Use :: for C++ namespaces, _ for C-Next scopes
+      return parts.join(this.getScopeSeparator(isCppAccess));
+    }
+    // Issue #304: C++ class/enum access uses ::
+    if (isCppAccess) {
+      return parts.join("::");
     }
     // Non-register, non-scope member access: obj.field
     return parts.join(".");
@@ -7200,6 +7332,8 @@ export default class CodeGenerator implements IOrchestrator {
     const parts = identifiers.map((id) => id.getText());
     const expressions = ctx.expression();
     const firstId = parts[0];
+    // Issue #304: Check if first identifier is a C++ scope symbol
+    const isCppAccess = this.isCppScopeSymbol(firstId);
 
     // Handle single vs multi-expression (bit range) syntax
     let indexExpr: string;
@@ -7220,15 +7354,21 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Check if first identifier is a scope
-    if (this.symbols!.knownScopes.has(firstId)) {
+    if (this.isKnownScope(firstId)) {
       // ADR-016: Validate visibility before allowing cross-scope access
       const memberName = parts[1];
       this.validateCrossScopeVisibility(firstId, memberName);
-      // Scope array access: global.Counter.data[0] -> Counter_data[0]
-      const scopedName = parts.join("_");
+      // Issue #304: Use :: for C++ namespaces, _ for C-Next scopes
+      const scopedName = parts.join(this.getScopeSeparator(isCppAccess));
       return `${scopedName}[${indexExpr}]`;
     }
 
+    // Issue #304: C++ class/enum access uses ::
+    if (isCppAccess) {
+      const baseName = parts.join("::");
+      return `${baseName}[${indexExpr}]`;
+    }
+
     // Non-register, non-scope array access
     const baseName = parts.join(".");
     return `${baseName}[${indexExpr}]`;
@@ -7757,6 +7897,8 @@ export default class CodeGenerator implements IOrchestrator {
     let subscriptDepth = 0;
     // ADR-016: Track if we're in a global. access chain (skips scope/enum/register validation)
     let isGlobalAccess = false;
+    // Issue #304: Track if we're accessing C++ symbols that need :: syntax
+    let isCppAccessChain = false;
 
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
@@ -7770,6 +7912,10 @@ export default class CodeGenerator implements IOrchestrator {
           result = memberName;
           currentIdentifier = memberName; // Track for .length lookups
           isGlobalAccess = true; // Mark that we're in a global access chain
+          // Issue #304: Check if this is a C++ scope symbol (namespace, class, enum)
+          if (this.isCppScopeSymbol(memberName)) {
+            isCppAccessChain = true;
+          }
           // Check if this first identifier is a register
           if (this.symbols!.knownRegisters.has(memberName)) {
             isRegisterChain = true;
@@ -8046,7 +8192,7 @@ export default class CodeGenerator implements IOrchestrator {
             }
           }
           // Check if this is a scope member access: Scope.member (ADR-016)
-          else if (this.symbols!.knownScopes.has(result)) {
+          else if (this.isKnownScope(result)) {
             // ADR-016: Skip validation if we're already in a global. access chain
             if (!isGlobalAccess) {
               // ADR-016: Prevent self-referential scope access - must use 'this.' inside own scope
@@ -8064,8 +8210,8 @@ export default class CodeGenerator implements IOrchestrator {
             }
             // ADR-016: Validate visibility before allowing cross-scope access
             this.validateCrossScopeVisibility(result, memberName);
-            // Transform Scope.member to Scope_member
-            result = `${result}_${memberName}`;
+            // Issue #304: Use :: for C++ namespaces, _ for C-Next scopes
+            result = `${result}${this.getScopeSeparator(isCppAccessChain)}${memberName}`;
             currentIdentifier = result; // Track for .length lookups
 
             // Check if this resolved identifier is a struct type for chained access
@@ -8093,8 +8239,8 @@ export default class CodeGenerator implements IOrchestrator {
                 );
               }
             }
-            // Transform Enum.member to Enum_member
-            result = `${result}_${memberName}`;
+            // Issue #304: Use :: for C++ enum classes, _ for C-Next enums
+            result = `${result}${this.getScopeSeparator(isCppAccessChain)}${memberName}`;
           }
           // Check if this is a register member access: GPIO7.DR -> GPIO7_DR
           else if (this.symbols!.knownRegisters.has(result)) {
@@ -8276,7 +8422,7 @@ export default class CodeGenerator implements IOrchestrator {
                 }
               }
             }
-          } else if (this.symbols!.knownScopes.has(result)) {
+          } else if (this.isKnownScope(result)) {
             // ADR-016: Skip validation if we're already in a global. access chain
             if (!isGlobalAccess) {
               // ADR-016: Prevent self-referential scope access - must use 'this.' inside own scope
@@ -8294,8 +8440,8 @@ export default class CodeGenerator implements IOrchestrator {
             }
             // ADR-016: Validate visibility before allowing cross-scope access
             this.validateCrossScopeVisibility(result, memberName);
-            // Transform Scope.member to Scope_member
-            result = `${result}_${memberName}`;
+            // Issue #304: Use :: for C++ namespaces, _ for C-Next scopes
+            result = `${result}${this.getScopeSeparator(isCppAccessChain)}${memberName}`;
             currentIdentifier = result; // Track for .length lookups
           } else if (this.symbols!.knownEnums.has(result)) {
             // ADR-016: Inside a scope, accessing global enum requires global. prefix
@@ -8311,8 +8457,8 @@ export default class CodeGenerator implements IOrchestrator {
                 );
               }
             }
-            // Transform Enum.member to Enum_member
-            result = `${result}_${memberName}`;
+            // Issue #304: Use :: for C++ enum classes, _ for C-Next enums
+            result = `${result}${this.getScopeSeparator(isCppAccessChain)}${memberName}`;
           } else if (this.symbols!.knownRegisters.has(result)) {
             // ADR-016: Inside a scope, accessing global register requires global. prefix
             // Exception: if the register belongs to the current scope, access is allowed
@@ -8349,6 +8495,14 @@ export default class CodeGenerator implements IOrchestrator {
                 `Error: Unknown bitmap field '${memberName}' on type '${bitmapType}'`,
               );
             }
+          }
+          // Issue #304: C++ class/namespace static member access uses :: (e.g., CommandHandler::execute)
+          // Also handles nested namespaces (hw::nested::configure) by checking if result already contains ::
+          else if (
+            isCppAccessChain &&
+            (this.isCppScopeSymbol(result) || result.includes("::"))
+          ) {
+            result = `${result}::${memberName}`;
           } else {
             result = `${result}.${memberName}`;
             // Track this member for potential .length access (save BEFORE updating)
@@ -8608,6 +8762,12 @@ export default class CodeGenerator implements IOrchestrator {
         this,
       );
       this.applyEffects(result.effects);
+
+      // Issue #304: Transform NULL → nullptr in C++ mode
+      if (result.code === "NULL" && this.cppMode) {
+        return "nullptr";
+      }
+
       return result.code;
     }
     if (ctx.expression()) {
@@ -8711,7 +8871,7 @@ export default class CodeGenerator implements IOrchestrator {
         // Check if first identifier is a global variable
         // If not a scope or enum, it's likely a global struct variable
         if (
-          !this.symbols!.knownScopes.has(firstName) &&
+          !this.isKnownScope(firstName) &&
           !this.symbols!.knownEnums.has(firstName)
         ) {
           return `sizeof(${firstName}.${memberName})`;
@@ -8941,7 +9101,7 @@ export default class CodeGenerator implements IOrchestrator {
       const isDirectRegister =
         parts.length > 1 && this.symbols!.knownRegisters.has(firstPart);
       const scopedRegisterName =
-        parts.length > 2 && this.symbols!.knownScopes.has(firstPart)
+        parts.length > 2 && this.isKnownScope(firstPart)
           ? `${parts[0]}_${parts[1]}`
           : null;
       const isScopedRegister =
@@ -9018,7 +9178,7 @@ export default class CodeGenerator implements IOrchestrator {
           let exprIndex = 0;
 
           // Check if first identifier is a scope for special handling
-          const isCrossScope = this.symbols!.knownScopes.has(firstPart);
+          const isCrossScope = this.isKnownScope(firstPart);
 
           // ADR-016: Inside a scope, accessing another scope requires global. prefix
           if (isCrossScope && this.context.currentScope) {
@@ -9179,7 +9339,7 @@ export default class CodeGenerator implements IOrchestrator {
     }
 
     // Check if it's a scope member access: Timing.tickCount -> Timing_tickCount (ADR-016)
-    if (this.symbols!.knownScopes.has(firstPart)) {
+    if (this.isKnownScope(firstPart)) {
       // ADR-016: Inside a scope, accessing another scope requires global. prefix
       if (this.context.currentScope) {
         // Self-referential access should use 'this.'

package/src/codegen/HeaderGenerator.ts

@@ -104,12 +104,13 @@ class HeaderGenerator {
     );
 
     // Emit forward declarations for external types
+    // Issue #296: Use typedef forward declaration for compatibility with named structs
     if (externalTypes.size > 0) {
       lines.push(
         "/* External type dependencies - include appropriate headers */",
       );
       for (const typeName of externalTypes) {
-        lines.push(`struct ${typeName};`);
+        lines.push(`typedef struct ${typeName} ${typeName};`);
       }
       lines.push("");
     }

package/src/codegen/TypeResolver.ts

@@ -230,6 +230,7 @@ class TypeResolver {
 
   /**
    * ADR-024: Get the type of a postfix expression.
+   * Issue #304: Enhanced to track type through member access chains (e.g., cfg.mode)
    */
   getPostfixExpressionType(
     ctx: Parser.PostfixExpressionContext,
@@ -238,13 +239,28 @@ class TypeResolver {
     if (!primary) return null;
 
     // Get base type from primary expression
-    const baseType = this.getPrimaryExpressionType(primary);
+    let currentType = this.getPrimaryExpressionType(primary);
+    if (!currentType) return null;
 
-    // Check for postfix operations like bit indexing
+    // Check for postfix operations: member access, array indexing, bit indexing
     const suffixes = ctx.children?.slice(1) || [];
     for (const suffix of suffixes) {
       const text = suffix.getText();
-      // Bit indexing: [start, width] or [index]
+
+      // Member access: .fieldName
+      if (text.startsWith(".")) {
+        const memberName = text.slice(1);
+        const memberInfo = this.getMemberTypeInfo(currentType, memberName);
+        if (memberInfo) {
+          currentType = memberInfo.baseType;
+        } else {
+          // Can't determine member type, return null
+          return null;
+        }
+        continue;
+      }
+
+      // Array or bit indexing: [index] or [start, width]
       if (text.startsWith("[") && text.endsWith("]")) {
         const inner = text.slice(1, -1);
         if (inner.includes(",")) {
@@ -253,13 +269,19 @@ class TypeResolver {
           // Bit indexing is the explicit escape hatch for narrowing/sign conversions
           return null;
         } else {
-          // Single bit indexing: [index] - returns bool
-          return "bool";
+          // Single index: could be array access or bit indexing
+          // For arrays, the type stays the same (element type)
+          // For single bit on integer, returns bool
+          if (this.isIntegerType(currentType)) {
+            return "bool";
+          }
+          // For arrays, currentType is already the element type (from getMemberTypeInfo)
+          continue;
         }
       }
     }
 
-    return baseType;
+    return currentType;
   }
 
   /**

package/src/codegen/generators/IOrchestrator.ts

@@ -149,6 +149,15 @@ interface IOrchestrator {
   /** Get known enums set for pass-by-value detection */
   getKnownEnums(): ReadonlySet<string>;
 
+  /** Issue #304: Check if we're generating C++ output */
+  isCppMode(): boolean;
+
+  /** Issue #304: Check if a type is a C++ enum class (needs :: syntax and explicit casts) */
+  isCppEnumClass(typeName: string): boolean;
+
+  /** Issue #304: Get the expression type */
+  getExpressionType(ctx: Parser.ExpressionContext): string | null;
+
   /** Issue #269: Check if a parameter is pass-by-value (small unmodified primitive) */
   isParameterPassByValue(funcName: string, paramIndex: number): boolean;
 

package/src/codegen/generators/declarationGenerators/StructGenerator.ts

@@ -42,7 +42,8 @@ const generateStruct: TGeneratorFn<Parser.StructDeclarationContext> = (
   const callbackFields: Array<{ fieldName: string; callbackType: string }> = [];
 
   const lines: string[] = [];
-  lines.push(`typedef struct {`);
+  // Issue #296: Use named struct for forward declaration compatibility
+  lines.push(`typedef struct ${name} {`);
 
   for (const member of node.structMember()) {
     const fieldName = member.IDENTIFIER().getText();

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

@@ -17,6 +17,58 @@ import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 
+/**
+ * Issue #304: Map C-Next type to C type for static_cast.
+ */
+const TYPE_MAP: Record<string, string> = {
+  u8: "uint8_t",
+  u16: "uint16_t",
+  u32: "uint32_t",
+  u64: "uint64_t",
+  i8: "int8_t",
+  i16: "int16_t",
+  i32: "int32_t",
+  i64: "int64_t",
+  f32: "float",
+  f64: "double",
+  bool: "bool",
+};
+
+const mapTypeToCType = (cnxType: string): string => {
+  return TYPE_MAP[cnxType] || cnxType;
+};
+
+/**
+ * Issue #304: Wrap argument with static_cast if it's a C++ enum class
+ * being passed to an integer parameter.
+ *
+ * @param argCode - The generated argument code
+ * @param argExpr - The argument expression context (for type lookup)
+ * @param targetParamBaseType - The target parameter's base type (if known)
+ * @param orchestrator - Orchestrator for type checking methods
+ * @returns The argument code, possibly wrapped with static_cast
+ */
+const wrapWithCppEnumCast = (
+  argCode: string,
+  argExpr: ExpressionContext,
+  targetParamBaseType: string | undefined,
+  orchestrator: IOrchestrator,
+): string => {
+  if (!orchestrator.isCppMode() || !targetParamBaseType) {
+    return argCode;
+  }
+
+  const argType = orchestrator.getExpressionType(argExpr);
+  if (argType && orchestrator.isCppEnumClass(argType)) {
+    if (orchestrator.isIntegerType(targetParamBaseType)) {
+      const cType = mapTypeToCType(targetParamBaseType);
+      return `static_cast<${cType}>(${argCode})`;
+    }
+  }
+
+  return argCode;
+};
+
 /**
  * Generate C code for a function call.
  *
@@ -61,14 +113,23 @@ const generateFunctionCall = (
 
   const args = argExprs
     .map((e, idx) => {
+      // Get function signature for parameter type info
+      const sig = input.functionSignatures.get(funcExpr);
+      const targetParam = sig?.parameters[idx];
+
       if (!isCNextFunc) {
         // C function: pass-by-value, just generate the expression
-        return orchestrator.generateExpression(e);
+        const argCode = orchestrator.generateExpression(e);
+        // Issue #304: Wrap with static_cast if C++ enum class → integer
+        return wrapWithCppEnumCast(
+          argCode,
+          e,
+          targetParam?.baseType,
+          orchestrator,
+        );
       }
 
       // C-Next function: check if target parameter is a pass-by-value type
-      const sig = input.functionSignatures.get(funcExpr);
-      const targetParam = sig?.parameters[idx];
       const isFloatParam =
         targetParam && orchestrator.isFloatType(targetParam.baseType);
       const isEnumParam =
@@ -81,7 +142,14 @@ const generateFunctionCall = (
 
       if (isFloatParam || isEnumParam || isPrimitivePassByValue) {
         // Target parameter is pass-by-value: pass value directly
-        return orchestrator.generateExpression(e);
+        const argCode = orchestrator.generateExpression(e);
+        // Issue #304: Wrap with static_cast if C++ enum class → integer
+        return wrapWithCppEnumCast(
+          argCode,
+          e,
+          targetParam?.baseType,
+          orchestrator,
+        );
       } else {
         // Target parameter is pass-by-reference: use & logic
         // Pass the target param type for proper literal handling

package/src/codegen/headerGenerators/generateStructHeader.test.ts

@@ -33,7 +33,8 @@ describe("generateStructHeader", () => {
 
       const result = generateStructHeader("Point3D", input);
 
-      expect(result).toContain("typedef struct {");
+      // Issue #296: Named structs for forward declaration compatibility
+      expect(result).toContain("typedef struct Point3D {");
       expect(result).toContain("uint32_t x;");
       expect(result).toContain("uint32_t y;");
       expect(result).toContain("uint32_t z;");
@@ -158,7 +159,10 @@ describe("generateStructHeader", () => {
 
       const result = generateStructHeader("Wrapper", input);
 
-      expect(result).toBe("typedef struct {\n    int64_t value;\n} Wrapper;");
+      // Issue #296: Named structs for forward declaration compatibility
+      expect(result).toBe(
+        "typedef struct Wrapper {\n    int64_t value;\n} Wrapper;",
+      );
     });
 
     it("should handle struct with pointer field type", () => {

package/src/codegen/headerGenerators/generateStructHeader.ts

@@ -13,9 +13,9 @@ const { mapType } = typeUtils;
 /**
  * Generate a C typedef struct declaration for the given struct name.
  *
- * Output format:
+ * Output format (Issue #296: uses named struct for forward declaration compatibility):
  * ```c
- * typedef struct {
+ * typedef struct StructName {
  *     uint32_t field1;
  *     uint8_t buffer[256];
  * } StructName;
@@ -35,7 +35,8 @@ function generateStructHeader(name: string, input: IHeaderTypeInput): string {
 
   const dimensions = input.structFieldDimensions.get(name);
   const lines: string[] = [];
-  lines.push("typedef struct {");
+  // Issue #296: Use named struct for forward declaration compatibility
+  lines.push(`typedef struct ${name} {`);
 
   // Iterate fields in insertion order (Map preserves order)
   for (const [fieldName, fieldType] of fields) {

package/src/pipeline/Pipeline.ts

@@ -830,8 +830,9 @@ class Pipeline {
         }
       }
 
-      // Step 3: Resolve and collect header files
+      // Step 3: Resolve and collect header files (C/C++ headers and C-Next includes)
       const headerFiles: IDiscoveredFile[] = [];
+      const cnextIncludes: IDiscoveredFile[] = [];
       for (const includePath of includes) {
         const resolved = IncludeDiscovery.resolveInclude(
           includePath,
@@ -839,17 +840,21 @@ class Pipeline {
         );
         if (resolved) {
           const file = FileDiscovery.discoverFile(resolved);
-          if (
-            file &&
-            (file.type === EFileType.CHeader ||
-              file.type === EFileType.CppHeader)
-          ) {
-            headerFiles.push(file);
+          if (file) {
+            if (
+              file.type === EFileType.CHeader ||
+              file.type === EFileType.CppHeader
+            ) {
+              headerFiles.push(file);
+            } else if (file.type === EFileType.CNext) {
+              // Issue #294: Also collect symbols from C-Next include files
+              cnextIncludes.push(file);
+            }
           }
         }
       }
 
-      // Step 4: Parse headers to populate symbol table
+      // Step 4a: Parse C/C++ headers to populate symbol table
       for (const file of headerFiles) {
         try {
           await this.collectHeaderSymbols(file);
@@ -858,6 +863,18 @@ class Pipeline {
         }
       }
 
+      // Step 4b: Issue #294 - Parse C-Next includes to populate symbol table
+      // This enables cross-file scope references (e.g., decoder.getSpn() -> decoder_getSpn())
+      for (const file of cnextIncludes) {
+        try {
+          this.collectCNextSymbols(file);
+        } catch (err) {
+          this.warnings.push(
+            `Failed to process C-Next include ${file.path}: ${err}`,
+          );
+        }
+      }
+
       // Step 5: Parse C-Next source from string
       const charStream = CharStream.fromString(source);
       const lexer = new CNextLexer(charStream);