c-next 0.2.8 → 0.2.9

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.8",
+  version: "0.2.9",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -110828,6 +110828,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 */
@@ -110922,6 +110929,7 @@ var CodeGenState = class {
     this.indentLevel = 0;
     this.inFunctionBody = false;
     this.expectedType = null;
+    this.suppressBareEnumResolution = false;
     this.mainArgsName = null;
     this.assignmentContext = {
       targetName: null,
@@ -110972,6 +110980,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
   // ===========================================================================
@@ -114424,8 +114458,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;
@@ -114471,9 +114511,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";
     }
   }
@@ -115138,7 +115179,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);
   }
@@ -115154,10 +115200,13 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
     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 finalArgCode = needsAddressOf ? `&${argCode}` : argCode;
+  return wrapWithCppEnumCast(
+    finalArgCode,
+    e,
+    targetParam?.baseType,
+    orchestrator
+  );
 };
 var _shouldPassByValue = (funcExpr, idx, targetParam, isCrossFile, orchestrator) => {
   if (!targetParam) return false;
@@ -115204,7 +115253,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,
@@ -116556,12 +116610,15 @@ 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)`;
+    output.result = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
     return output;
   }
   if (ctx.currentMemberIsArray) {
@@ -116575,7 +116632,7 @@ var handleSingleSubscript = (ctx, expr, input, orchestrator, output) => {
   }
   const isPrimitiveIntMember = ctx.currentStructType && TypeCheckUtils_default.isInteger(ctx.currentStructType);
   if (isPrimitiveIntMember) {
-    output.result = `((${ctx.result} >> ${index}) & 1)`;
+    output.result = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
     output.currentStructType = void 0;
     return output;
   }
@@ -116633,12 +116690,18 @@ 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") {
+    output.result = index === "0" || index === "0U" ? `((${ctx.result}) & 1)` : `((${ctx.result} >> ${index}) & 1)`;
+  } 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,7 +116718,7 @@ var handleBitRangeSubscript = (ctx, exprs, input, state, orchestrator, effects,
     );
   } else {
     const mask = orchestrator.generateBitMask(width);
-    if (start === "0") {
+    if (start === "0" || start === "0U") {
       output.result = `((${ctx.result}) & ${mask})`;
     } else {
       output.result = `((${ctx.result} >> ${start}) & ${mask})`;
@@ -116690,7 +116753,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})`;
@@ -117612,7 +117675,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)}`;
 }
@@ -118804,7 +118871,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 +118885,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 +118923,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);
@@ -122618,6 +122694,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 +122702,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 +123133,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 +123167,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 +123746,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 +124442,14 @@ ${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,
+      () => `${decl} = ${callbacks.generateExpression(ctx.expression())}`
+    );
   }
   // ========================================================================
   // Tier 4: Orchestrators (main entry points)
@@ -127245,13 +127370,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).
@@ -128596,15 +128724,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 +129472,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 +130000,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 +130223,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
       );
@@ -130888,15 +131025,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 +131412,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);
       }
     }
@@ -138923,7 +139064,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);