c-next 0.2.3 → 0.2.4

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.3",
+  version: "0.2.4",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -110764,6 +110764,8 @@ var CodeGenState = class {
   static callbackTypes = /* @__PURE__ */ new Map();
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes = /* @__PURE__ */ new Map();
+  /** Functions that need C-callback-compatible (by-value) struct parameters */
+  static callbackCompatibleFunctions = /* @__PURE__ */ new Set();
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
   // ===========================================================================
@@ -114074,14 +114076,14 @@ var TypeValidator = class _TypeValidator {
     }
   }
   // ========================================================================
-  // Do-While Validation (ADR-027)
+  // Condition Boolean Validation (ADR-027, Issue #884)
   // ========================================================================
-  static validateDoWhileCondition(ctx) {
+  static validateConditionIsBoolean(ctx, conditionType) {
     const ternaryExpr = ctx.ternaryExpression();
     const orExprs = ternaryExpr.orExpression();
     if (orExprs.length !== 1) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression, not a ternary (MISRA C:2012 Rule 14.4)`
       );
     }
     const orExpr = orExprs[0];
@@ -114092,7 +114094,7 @@ var TypeValidator = class _TypeValidator {
     const andExpr = orExpr.andExpression(0);
     if (!andExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (andExpr.equalityExpression().length > 1) {
@@ -114101,7 +114103,7 @@ var TypeValidator = class _TypeValidator {
     const equalityExpr = andExpr.equalityExpression(0);
     if (!equalityExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (equalityExpr.relationalExpression().length > 1) {
@@ -114110,7 +114112,7 @@ var TypeValidator = class _TypeValidator {
     const relationalExpr = equalityExpr.relationalExpression(0);
     if (!relationalExpr) {
       throw new Error(
-        `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
+        `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)`
       );
     }
     if (relationalExpr.bitwiseOrExpression().length > 1) {
@@ -114121,7 +114123,7 @@ var TypeValidator = class _TypeValidator {
       return;
     }
     throw new Error(
-      `Error E0701: do-while condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)
+      `Error E0701: ${conditionType} condition must be a boolean expression (comparison or logical operation), not '${text}' (MISRA C:2012 Rule 14.4)
   help: use explicit comparison: ${text} > 0 or ${text} != 0`
     );
   }
@@ -116940,6 +116942,7 @@ var generateIf = (node, _input, _state, orchestrator) => {
   }
   const cacheDecls = orchestrator.setupLengthCache(lengthCounts);
   orchestrator.validateConditionNoFunctionCall(node.expression(), "if");
+  orchestrator.validateConditionIsBoolean(node.expression(), "if");
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
   const thenBranch = orchestrator.generateStatement(thenStmt);
@@ -116960,6 +116963,7 @@ var generateIf = (node, _input, _state, orchestrator) => {
 var generateWhile = (node, _input, _state, orchestrator) => {
   const effects = [];
   orchestrator.validateConditionNoFunctionCall(node.expression(), "while");
+  orchestrator.validateConditionIsBoolean(node.expression(), "while");
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
   const body = orchestrator.generateStatement(node.statement());
@@ -116971,8 +116975,8 @@ var generateWhile = (node, _input, _state, orchestrator) => {
 };
 var generateDoWhile = (node, _input, _state, orchestrator) => {
   const effects = [];
-  orchestrator.validateDoWhileCondition(node.expression());
   orchestrator.validateConditionNoFunctionCall(node.expression(), "do-while");
+  orchestrator.validateConditionIsBoolean(node.expression(), "do-while");
   const body = orchestrator.generateBlock(node.block());
   const condition = orchestrator.generateExpression(node.expression());
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
@@ -117037,6 +117041,7 @@ var generateFor = (node, input, state, orchestrator) => {
   let condition = "";
   if (node.expression()) {
     orchestrator.validateConditionNoFunctionCall(node.expression(), "for");
+    orchestrator.validateConditionIsBoolean(node.expression(), "for");
     condition = orchestrator.generateExpression(node.expression());
   }
   const conditionTemps = orchestrator.flushPendingTempDeclarations();
@@ -125526,11 +125531,14 @@ var FunctionContextManager = class _FunctionContextManager {
       typeCtx,
       callbacks
     );
+    const isCallbackCompat = CodeGenState.currentFunctionName !== null && CodeGenState.callbackCompatibleFunctions.has(
+      CodeGenState.currentFunctionName
+    );
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: typeInfo.isStruct,
+      isStruct: isCallbackCompat ? false : typeInfo.isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString
@@ -127561,11 +127569,11 @@ var CodeGenerator = class _CodeGenerator {
     TypeValidator_default.validateSwitchStatement(ctx, switchExpr);
   }
   /**
-   * Validate do-while condition.
+   * Validate condition is a boolean expression (ADR-027, Issue #884).
    * Part of IOrchestrator interface (ADR-053 A3).
    */
-  validateDoWhileCondition(ctx) {
-    TypeValidator_default.validateDoWhileCondition(ctx);
+  validateConditionIsBoolean(ctx, conditionType) {
+    TypeValidator_default.validateConditionIsBoolean(ctx, conditionType);
   }
   /**
    * Issue #254: Validate no function calls in condition (E0702).
@@ -127951,8 +127959,8 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   }
   /**
    * Issue #561: Analyze modifications in a parse tree without full code generation.
-   * Used by Pipeline.transpileSource() to collect modification info from includes
-   * for cross-file const inference (unified with Pipeline.run() behavior).
+   * Used by the transpile() pipeline to collect modification info from includes
+   * for cross-file const inference.
    *
    * Issue #565: Now accepts optional cross-file data for transitive propagation.
    * When a file calls a function from an included file that modifies its param,
@@ -129333,6 +129341,9 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       return "{}";
     }
     const fieldInits = fields.map((f) => `.${f.fieldName} = ${f.value}`);
+    if (CodeGenState.cppMode && (typeName.startsWith("struct {") || typeName.startsWith("union {"))) {
+      return `{ ${fieldInits.join(", ")} }`;
+    }
     return `(${castType}){ ${fieldInits.join(", ")} }`;
   }
   /**
@@ -129516,6 +129527,11 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     )) {
       return true;
     }
+    if (CodeGenState.currentFunctionName && CodeGenState.callbackCompatibleFunctions.has(
+      CodeGenState.currentFunctionName
+    ) && this.isKnownStruct(typeName)) {
+      return true;
+    }
     return false;
   }
   // ========================================================================
@@ -130728,8 +130744,11 @@ var HeaderGeneratorUtils = class _HeaderGeneratorUtils {
         lines.push(include);
       }
     }
+    const userIncludeSet = new Set(options.userIncludes ?? []);
     for (const directive of headersToInclude) {
-      lines.push(directive);
+      if (!userIncludeSet.has(directive)) {
+        lines.push(directive);
+      }
     }
     const hasIncludes = options.includeSystemHeaders !== false || options.userIncludes && options.userIncludes.length > 0 || headersToInclude.size > 0;
     if (hasIncludes) {
@@ -133342,8 +133361,9 @@ var CResolver = class _CResolver {
       if (!name) continue;
       const isFunction = DeclaratorUtils_default.declaratorIsFunction(declarator);
       if (ctx.isTypedef) {
+        const typedefType = _CResolver.isFunctionPointerDeclarator(declarator) ? `${baseType} (*)(${_CResolver.extractParamText(declarator)})` : baseType;
         ctx.symbols.push(
-          TypedefCollector_default.collect(name, baseType, ctx.sourceFile, ctx.line)
+          TypedefCollector_default.collect(name, typedefType, ctx.sourceFile, ctx.line)
         );
       } else if (isFunction) {
         ctx.symbols.push(
@@ -133446,6 +133466,36 @@ var CResolver = class _CResolver {
     }
     return typeParts.join(" ") || "int";
   }
+  /**
+   * Check if a declarator represents a function pointer.
+   * For `(*PointCallback)(Point p)`, the C grammar parses as:
+   *   declarator -> directDeclarator
+   *   directDeclarator -> directDeclarator '(' parameterTypeList ')'
+   *   inner directDeclarator -> '(' declarator ')'
+   *   inner declarator -> pointer directDeclarator -> * PointCallback
+   */
+  static isFunctionPointerDeclarator(declarator) {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return false;
+    const hasParams = directDecl.parameterTypeList?.() !== null || Boolean(directDecl.LeftParen?.());
+    if (!hasParams) return false;
+    const innerDirectDecl = directDecl.directDeclarator?.();
+    if (!innerDirectDecl) return false;
+    const nestedDecl = innerDirectDecl.declarator?.();
+    if (!nestedDecl) return false;
+    return Boolean(nestedDecl.pointer?.());
+  }
+  /**
+   * Extract parameter text from a function pointer declarator.
+   * Returns the text of the parameters from a function pointer like "(*Callback)(Point p)".
+   */
+  static extractParamText(declarator) {
+    const directDecl = declarator.directDeclarator?.();
+    if (!directDecl) return "";
+    const paramTypeList = directDecl.parameterTypeList?.();
+    if (!paramTypeList) return "";
+    return paramTypeList.getText();
+  }
 };
 var c_default = CResolver;
 
@@ -135075,6 +135125,9 @@ var IncludeResolver = class _IncludeResolver {
     }
     if (file.type === EFileType_default.CNext) {
       result.cnextIncludes.push(file);
+      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ".h");
+      const directive = includeInfo.isLocal ? `#include "${headerPath}"` : `#include <${headerPath}>`;
+      result.headerIncludeDirectives.set(absolutePath, directive);
     }
   }
   /**
@@ -135212,8 +135265,8 @@ var IncludeResolver = class _IncludeResolver {
   /**
    * Build search paths from a source file location
    *
-   * Consolidates the search path building logic used by both `run()` and
-   * `transpileSource()` code paths.
+   * Consolidates the search path building logic used by the unified
+   * transpile() entry point.
    *
    * Search order (highest to lowest priority):
    * 1. Source file's directory (for relative includes)
@@ -136548,16 +136601,20 @@ var FunctionCallListener = class extends CNextListener {
   // ========================================================================
   // ISR/Callback Variable Tracking (ADR-040)
   // ========================================================================
+  /**
+   * Check if a type name represents a callable type (ISR, callback, or C function pointer typedef).
+   */
+  isCallableType(typeName) {
+    return typeName === "ISR" || this.analyzer.isCallbackType(typeName) || this.analyzer.isCFunctionPointerTypedef(typeName);
+  }
   /**
    * Track ISR-typed variables from variable declarations
    * e.g., `ISR handler <- myFunction;`
    */
   enterVariableDeclaration = (ctx) => {
-    const typeCtx = ctx.type();
-    const typeName = typeCtx.getText();
-    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
-      const varName = ctx.IDENTIFIER().getText();
-      this.analyzer.defineCallableVariable(varName);
+    const typeName = ctx.type().getText();
+    if (this.isCallableType(typeName)) {
+      this.analyzer.defineCallableVariable(ctx.IDENTIFIER().getText());
     }
   };
   /**
@@ -136565,11 +136622,9 @@ var FunctionCallListener = class extends CNextListener {
    * e.g., `void execute(ISR handler) { handler(); }`
    */
   enterParameter = (ctx) => {
-    const typeCtx = ctx.type();
-    const typeName = typeCtx.getText();
-    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
-      const paramName = ctx.IDENTIFIER().getText();
-      this.analyzer.defineCallableVariable(paramName);
+    const typeName = ctx.type().getText();
+    if (this.isCallableType(typeName)) {
+      this.analyzer.defineCallableVariable(ctx.IDENTIFIER().getText());
     }
   };
   // ========================================================================
@@ -136708,6 +136763,7 @@ var FunctionCallAnalyzer = class {
     this.collectIncludes(tree);
     this.collectCallbackTypes(tree);
     this.collectAllLocalFunctions(tree);
+    this.collectCallbackCompatibleFunctions(tree);
     const listener = new FunctionCallListener(this);
     ParseTreeWalker5.DEFAULT.walk(listener, tree);
     return this.errors;
@@ -136791,6 +136847,120 @@ var FunctionCallAnalyzer = class {
   isCallbackType(name) {
     return this.callbackTypes.has(name);
   }
+  /**
+   * Check if a type name is a C function pointer typedef.
+   * Looks up the type in the symbol table and checks if it's a typedef
+   * whose underlying type contains "(*)" indicating a function pointer.
+   */
+  isCFunctionPointerTypedef(typeName) {
+    if (!this.symbolTable) return false;
+    const sym = this.symbolTable.getCSymbol(typeName);
+    if (sym?.kind !== "type") return false;
+    return "type" in sym && typeof sym.type === "string" && sym.type.includes("(*)");
+  }
+  /**
+   * Detect functions assigned to C function pointer typedefs.
+   * When `PointCallback cb <- my_handler;` is found and PointCallback
+   * is a C function pointer typedef, mark my_handler as callback-compatible.
+   */
+  collectCallbackCompatibleFunctions(tree) {
+    for (const decl of tree.declaration()) {
+      const funcDecl = decl.functionDeclaration();
+      if (!funcDecl) continue;
+      const block = funcDecl.block();
+      if (!block) continue;
+      this.scanBlockForCallbackAssignments(block);
+    }
+  }
+  /**
+   * Recursively scan all statements in a block for callback typedef assignments.
+   */
+  scanBlockForCallbackAssignments(block) {
+    for (const stmt of block.statement()) {
+      this.scanStatementForCallbackAssignments(stmt);
+    }
+  }
+  /**
+   * Scan a single statement for callback typedef assignments,
+   * recursing into nested blocks (if/while/for/do-while/switch/critical).
+   */
+  scanStatementForCallbackAssignments(stmt) {
+    const varDecl = stmt.variableDeclaration();
+    if (varDecl) {
+      this.checkVarDeclForCallbackAssignment(varDecl);
+      return;
+    }
+    const ifStmt = stmt.ifStatement();
+    if (ifStmt) {
+      for (const child of ifStmt.statement()) {
+        this.scanStatementForCallbackAssignments(child);
+      }
+      return;
+    }
+    const whileStmt = stmt.whileStatement();
+    if (whileStmt) {
+      this.scanStatementForCallbackAssignments(whileStmt.statement());
+      return;
+    }
+    const forStmt = stmt.forStatement();
+    if (forStmt) {
+      this.scanStatementForCallbackAssignments(forStmt.statement());
+      return;
+    }
+    const doWhileStmt = stmt.doWhileStatement();
+    if (doWhileStmt) {
+      this.scanBlockForCallbackAssignments(doWhileStmt.block());
+      return;
+    }
+    const switchStmt = stmt.switchStatement();
+    if (switchStmt) {
+      for (const caseCtx of switchStmt.switchCase()) {
+        this.scanBlockForCallbackAssignments(caseCtx.block());
+      }
+      const defaultCtx = switchStmt.defaultCase();
+      if (defaultCtx) {
+        this.scanBlockForCallbackAssignments(defaultCtx.block());
+      }
+      return;
+    }
+    const criticalStmt = stmt.criticalStatement();
+    if (criticalStmt) {
+      this.scanBlockForCallbackAssignments(criticalStmt.block());
+      return;
+    }
+    const nestedBlock = stmt.block();
+    if (nestedBlock) {
+      this.scanBlockForCallbackAssignments(nestedBlock);
+    }
+  }
+  /**
+   * Check if a variable declaration assigns a function to a C callback typedef.
+   */
+  checkVarDeclForCallbackAssignment(varDecl) {
+    const typeName = varDecl.type().getText();
+    if (!this.isCFunctionPointerTypedef(typeName)) return;
+    const expr = varDecl.expression();
+    if (!expr) return;
+    const funcRef = this.extractFunctionReference(expr);
+    if (!funcRef) return;
+    const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
+    if (this.allLocalFunctions.has(lookupName)) {
+      CodeGenState.callbackCompatibleFunctions.add(lookupName);
+    }
+  }
+  /**
+   * Extract a function reference from an expression context.
+   * Matches bare identifiers (e.g., "my_handler") and qualified scope
+   * names (e.g., "MyScope.handler").
+   * Returns null if the expression is not a function reference.
+   */
+  extractFunctionReference(expr) {
+    const text = expr.getText();
+    if (/^\w+(\.\w+)?$/.test(text)) {
+      return text;
+    }
+    return null;
+  }
   /**
    * ADR-040: Register a variable that holds a callable (ISR or callback)
    */
@@ -137044,6 +137214,26 @@ var TypeConstants = class {
     "float",
     "double"
   ];
+  /**
+   * Unsigned integer types valid as array/bit subscript indexes.
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: validating subscript index types
+   */
+  static UNSIGNED_INDEX_TYPES = [
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "bool"
+  ];
+  /**
+   * Signed integer types (rejected as subscript indexes).
+   *
+   * Used by:
+   * - ArrayIndexTypeAnalyzer: detecting signed integer subscript indexes
+   */
+  static SIGNED_TYPES = ["i8", "i16", "i32", "i64"];
 };
 var TypeConstants_default = TypeConstants;
 
@@ -137161,6 +137351,212 @@ var FloatModuloAnalyzer = class {
 };
 var FloatModuloAnalyzer_default = FloatModuloAnalyzer;
 
+// src/transpiler/logic/analysis/ArrayIndexTypeAnalyzer.ts
+import { ParseTreeWalker as ParseTreeWalker8 } from "antlr4ng";
+var VariableTypeCollector = class extends CNextListener {
+  varTypes = /* @__PURE__ */ new Map();
+  getVarTypes() {
+    return this.varTypes;
+  }
+  trackType(typeCtx, identifier) {
+    if (!typeCtx || !identifier) return;
+    this.varTypes.set(identifier.getText(), typeCtx.getText());
+  }
+  enterVariableDeclaration = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+  enterParameter = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+  enterForVarDecl = (ctx) => {
+    this.trackType(ctx.type(), ctx.IDENTIFIER());
+  };
+};
+var IndexTypeListener = class extends CNextListener {
+  analyzer;
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  varTypes;
+  constructor(analyzer, varTypes) {
+    super();
+    this.analyzer = analyzer;
+    this.varTypes = varTypes;
+  }
+  /**
+   * Check postfix operations in expressions (RHS: arr[idx], flags[bit])
+   */
+  enterPostfixOp = (ctx) => {
+    if (!ctx.LBRACKET()) return;
+    const expressions = ctx.expression();
+    for (const expr of expressions) {
+      this.validateIndexExpression(expr);
+    }
+  };
+  /**
+   * Check postfix target operations in assignments (LHS: arr[idx] <- val)
+   */
+  enterPostfixTargetOp = (ctx) => {
+    if (!ctx.LBRACKET()) return;
+    const expressions = ctx.expression();
+    for (const expr of expressions) {
+      this.validateIndexExpression(expr);
+    }
+  };
+  /**
+   * Validate that a subscript index expression uses an unsigned integer type.
+   * Collects all leaf operands from the expression and checks each one.
+   */
+  validateIndexExpression(ctx) {
+    const operands = this.collectOperands(ctx);
+    for (const operand of operands) {
+      const resolvedType = this.resolveOperandType(operand);
+      if (!resolvedType) continue;
+      if (TypeConstants_default.SIGNED_TYPES.includes(resolvedType)) {
+        const { line: line2, column: column2 } = ParserUtils_default.getPosition(ctx);
+        this.analyzer.addError(line2, column2, "E0850", resolvedType);
+        return;
+      }
+      if (resolvedType === "float literal" || TypeConstants_default.FLOAT_TYPES.includes(resolvedType)) {
+        const { line: line2, column: column2 } = ParserUtils_default.getPosition(ctx);
+        this.analyzer.addError(line2, column2, "E0851", resolvedType);
+        return;
+      }
+      if (TypeConstants_default.UNSIGNED_INDEX_TYPES.includes(resolvedType)) {
+        continue;
+      }
+      const { line, column } = ParserUtils_default.getPosition(ctx);
+      this.analyzer.addError(line, column, "E0852", resolvedType);
+      return;
+    }
+  }
+  /**
+   * Collect all leaf unary expression operands from an expression tree.
+   * Handles binary operators at any level by flatMapping through the grammar hierarchy.
+   */
+  collectOperands(ctx) {
+    const ternary = ctx.ternaryExpression();
+    if (!ternary) return [];
+    const orExpressions = ternary.orExpression();
+    if (orExpressions.length === 0) return [];
+    const valueExpressions = orExpressions.length === 3 ? orExpressions.slice(1) : orExpressions;
+    return valueExpressions.flatMap((o) => o.andExpression()).flatMap((a) => a.equalityExpression()).flatMap((e) => e.relationalExpression()).flatMap((r) => r.bitwiseOrExpression()).flatMap((bo) => bo.bitwiseXorExpression()).flatMap((bx) => bx.bitwiseAndExpression()).flatMap((ba) => ba.shiftExpression()).flatMap((s) => s.additiveExpression()).flatMap((a) => a.multiplicativeExpression()).flatMap((m) => m.unaryExpression());
+  }
+  /**
+   * Resolve the type of a unary expression operand.
+   * Uses local varTypes first, then falls back to CodeGenState for
+   * struct fields, function return types, and enum detection.
+   *
+   * Returns null if the type cannot be resolved (pass-through).
+   */
+  resolveOperandType(operand) {
+    const postfixExpr = operand.postfixExpression();
+    if (!postfixExpr) return null;
+    const primaryExpr = postfixExpr.primaryExpression();
+    if (!primaryExpr) return null;
+    let currentType = this.resolveBaseType(primaryExpr);
+    const postfixOps = postfixExpr.postfixOp();
+    if (!currentType && postfixOps.length > 0) {
+      const identifier = primaryExpr.IDENTIFIER();
+      if (identifier) {
+        currentType = identifier.getText();
+      }
+    }
+    for (const op of postfixOps) {
+      if (!currentType) return null;
+      currentType = this.resolvePostfixOpType(currentType, op);
+    }
+    return currentType;
+  }
+  /**
+   * Resolve the base type of a primary expression.
+   */
+  resolveBaseType(primaryExpr) {
+    const literal = primaryExpr.literal();
+    if (literal) {
+      if (LiteralUtils_default.isFloat(literal)) return "float literal";
+      return null;
+    }
+    const parenExpr = primaryExpr.expression();
+    if (parenExpr) {
+      const innerOperands = this.collectOperands(parenExpr);
+      for (const innerOp of innerOperands) {
+        const innerType = this.resolveOperandType(innerOp);
+        if (innerType) return innerType;
+      }
+      return null;
+    }
+    const identifier = primaryExpr.IDENTIFIER();
+    if (!identifier) return null;
+    const varName = identifier.getText();
+    const localType = this.varTypes.get(varName);
+    if (localType) return localType;
+    const typeInfo = CodeGenState.getVariableTypeInfo(varName);
+    if (typeInfo) return typeInfo.baseType;
+    return null;
+  }
+  /**
+   * Resolve the resulting type after applying a postfix operator.
+   */
+  resolvePostfixOpType(currentType, op) {
+    if (op.DOT()) {
+      const fieldId = op.IDENTIFIER();
+      if (!fieldId) return null;
+      const fieldName = fieldId.getText();
+      if (CodeGenState.isKnownEnum(currentType)) return null;
+      const fieldType = CodeGenState.getStructFieldType(currentType, fieldName);
+      return fieldType ?? null;
+    }
+    if (op.LBRACKET()) {
+      if (TypeConstants_default.UNSIGNED_INDEX_TYPES.includes(currentType)) {
+        return "bool";
+      }
+      if (TypeConstants_default.SIGNED_TYPES.includes(currentType)) {
+        return "bool";
+      }
+      return currentType;
+    }
+    if (op.LPAREN()) {
+      const returnType = CodeGenState.getFunctionReturnType(currentType);
+      return returnType ?? null;
+    }
+    return null;
+  }
+};
+var ArrayIndexTypeAnalyzer = class {
+  errors = [];
+  /**
+   * Analyze the parse tree for invalid subscript index types
+   */
+  analyze(tree) {
+    this.errors = [];
+    const collector = new VariableTypeCollector();
+    ParseTreeWalker8.DEFAULT.walk(collector, tree);
+    const varTypes = collector.getVarTypes();
+    const listener = new IndexTypeListener(this, varTypes);
+    ParseTreeWalker8.DEFAULT.walk(listener, tree);
+    return this.errors;
+  }
+  /**
+   * Add an index type error
+   */
+  addError(line, column, code, actualType) {
+    this.errors.push({
+      code,
+      line,
+      column,
+      actualType,
+      message: `Subscript index must be an unsigned integer type; got '${actualType}'`,
+      helpText: "Use an unsigned integer type (u8, u16, u32, u64) for array and bit subscript indexes."
+    });
+  }
+  /**
+   * Get all detected errors
+   */
+  getErrors() {
+    return this.errors;
+  }
+};
+var ArrayIndexTypeAnalyzer_default = ArrayIndexTypeAnalyzer;
+
 // src/transpiler/logic/analysis/runAnalyzers.ts
 function collectErrors(analyzerErrors, target, formatMessage) {
   const formatter = formatMessage ?? ((e) => e.message);
@@ -137214,6 +137610,10 @@ function runAnalyzers(tree, tokenStream, options) {
   if (collectErrors(floatModAnalyzer.analyze(tree), errors, formatWithCode)) {
     return errors;
   }
+  const indexTypeAnalyzer = new ArrayIndexTypeAnalyzer_default();
+  if (collectErrors(indexTypeAnalyzer.analyze(tree), errors, formatWithCode)) {
+    return errors;
+  }
   const commentExtractor = new CommentExtractor_default(tokenStream);
   collectErrors(
     commentExtractor.validate(),
@@ -137821,7 +138221,7 @@ var TransitiveEnumCollector = class {
   /**
    * Collect symbol info for standalone mode from resolved includes.
    *
-   * Issue #591: Extracted from Transpiler.transpileSource() to unify enum collection.
+   * Issue #591: Extracted to unify enum collection across transpilation modes.
    * Unlike collect() which starts from a file path and parses it, this method
    * starts from already-resolved includes (from IncludeResolver.resolve()).
    *
@@ -137899,83 +138299,53 @@ var Transpiler = class {
     this.cacheManager = projectRoot ? new CacheManager_default(projectRoot, this.fs) : null;
   }
   // ===========================================================================
-  // Public API: run() and transpileSource()
+  // Public API
   // ===========================================================================
   /**
-   * Execute the unified pipeline from CLI inputs.
+   * Unified entry point for all transpilation.
    *
-   * Stage 1 (file discovery) happens here, then delegates to _executePipeline().
+   * @param input - What to transpile:
+   *   - { kind: 'files' } — discover from config.inputs, write to disk
+   *   - { kind: 'source', source, ... } — transpile in-memory source
+   * @returns ITranspilerResult with per-file results in .files[]
    */
-  async run() {
+  async transpile(input) {
     const result = this._initResult();
     try {
       await this._initializeRun();
-      const { cnextFiles, headerFiles } = await this.discoverSources();
-      if (cnextFiles.length === 0) {
+      const pipelineInput = await this.discoverIncludes(input);
+      if (pipelineInput.cnextFiles.length === 0) {
         return this._finalizeResult(result, "No C-Next source files found");
       }
-      this._ensureOutputDirectories();
-      const pipelineFiles = cnextFiles.map((f) => ({
-        path: f.path,
-        discoveredFile: f
-      }));
-      const input = {
-        cnextFiles: pipelineFiles,
-        headerFiles,
-        writeOutputToDisk: true
-      };
-      await this._executePipeline(input, result);
+      if (input.kind === "files") {
+        this._ensureOutputDirectories();
+      }
+      await this._executePipeline(pipelineInput, result);
       return await this._finalizeResult(result);
     } catch (err) {
       return this._handleRunError(result, err);
     }
   }
   /**
-   * Transpile source code provided as a string.
+   * Stage 1: Discover files and build pipeline input.
    *
-   * Discovers includes from the source, builds an IPipelineInput, and
-   * delegates to the same _executePipeline() as run().
+   * Branches on input kind:
+   * - 'files': filesystem scan, dependency graph, topological sort
+   * - 'source': parse in-memory string, walk include tree
    *
-   * @param source - The C-Next source code as a string
-   * @param options - Options for transpilation
-   * @returns Promise<IFileResult> with generated code or errors
-   */
-  async transpileSource(source, options) {
-    const workingDir = options?.workingDir ?? process.cwd();
-    const additionalIncludeDirs = options?.includeDirs ?? [];
-    const sourcePath = options?.sourcePath ?? "<string>";
-    try {
-      await this._initializeRun();
-      const input = this._discoverFromSource(
-        source,
-        workingDir,
-        additionalIncludeDirs,
-        sourcePath
-      );
-      const result = this._initResult();
-      await this._executePipeline(input, result);
-      const fileResult = result.files.find((f) => f.sourcePath === sourcePath);
-      if (fileResult) {
-        return fileResult;
-      }
-      if (result.errors.length > 0) {
-        return this.buildErrorResult(sourcePath, result.errors, 0);
-      }
-      return this.buildErrorResult(
-        sourcePath,
-        [
-          {
-            line: 1,
-            column: 0,
-            message: "Pipeline produced no result for source file",
-            severity: "error"
-          }
-        ],
-        0
-      );
-    } catch (err) {
-      return this.buildCatchResult(sourcePath, err);
-    }
+   * Header directive storage happens via IncludeResolver.resolve() for both
+   * C headers and cnext includes (Issue #854).
+   */
+  async discoverIncludes(input) {
+    if (input.kind === "files") {
+      return this._discoverFromFiles();
+    }
+    return this._discoverFromSource(
+      input.source,
+      input.workingDir ?? process.cwd(),
+      input.includeDirs ?? [],
+      input.sourcePath ?? "<string>"
+    );
   }
   // ===========================================================================
   // Unified Pipeline
@@ -137983,7 +138353,7 @@ var Transpiler = class {
   /**
    * The single unified pipeline for all transpilation.
    *
-   * Both run() and transpileSource() delegate here after file discovery.
+   * transpile() delegates here after file discovery via discoverIncludes().
    *
    * Stage 2: Collect symbols from C/C++ headers (includes building analyzer context)
    * Stage 3: Collect symbols from C-Next files
@@ -138090,14 +138460,6 @@ var Transpiler = class {
       if (this.config.parseOnly) {
         return this.buildParseOnlyResult(sourcePath, declarationCount);
       }
-      const analyzerErrors = runAnalyzers_default(tree, tokenStream);
-      if (analyzerErrors.length > 0) {
-        return this.buildErrorResult(
-          sourcePath,
-          analyzerErrors,
-          declarationCount
-        );
-      }
       const tSymbols = cnext_default.resolve(tree, sourcePath);
       let symbolInfo = TSymbolInfoAdapter_default.convert(tSymbols);
       const externalEnumSources = this._collectExternalEnumSources(
@@ -138110,6 +138472,15 @@ var Transpiler = class {
           externalEnumSources
         );
       }
+      CodeGenState.symbols = symbolInfo;
+      const analyzerErrors = runAnalyzers_default(tree, tokenStream);
+      if (analyzerErrors.length > 0) {
+        return this.buildErrorResult(
+          sourcePath,
+          analyzerErrors,
+          declarationCount
+        );
+      }
       this._setupCrossFileModifications();
       const code = this.codeGenerator.generate(tree, tokenStream, {
         debugMode: this.config.debugMode,
@@ -138127,15 +138498,7 @@ var Transpiler = class {
       if (this.cppDetected) {
         this._accumulateFileModifications();
       }
-      const fileSymbols = CodeGenState.symbolTable.getTSymbolsByFile(sourcePath);
-      const headerCode = this.generateHeaderContent(
-        fileSymbols,
-        sourcePath,
-        this.cppDetected,
-        userIncludes,
-        passByValueCopy,
-        symbolInfo
-      );
+      const headerCode = this.generateHeaderForFile(file) ?? void 0;
       return this.buildSuccessResult(
         sourcePath,
         code,
@@ -138200,6 +138563,13 @@ var Transpiler = class {
         this.state.setHeaderDirective(header.path, directive);
       }
     }
+    for (const cnxInclude of resolved.cnextIncludes) {
+      const includePath = resolve12(cnxInclude.path);
+      const directive = resolved.headerIncludeDirectives.get(includePath);
+      if (directive) {
+        this.state.setHeaderDirective(includePath, directive);
+      }
+    }
     const cnextIncludeFiles = [];
     IncludeTreeWalker_default.walk(
       resolved.cnextIncludes,
@@ -138257,6 +138627,7 @@ var Transpiler = class {
     this.state.reset();
     CodeGenState.symbolTable.clear();
     SymbolRegistry_default.reset();
+    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Set();
   }
   /**
    * Ensure output directories exist
@@ -138335,8 +138706,12 @@ var Transpiler = class {
       if (file.symbolOnly) {
         continue;
       }
-      const headerPath = this.generateHeader(file.discoveredFile);
-      if (headerPath) {
+      const headerContent = this.generateHeaderForFile(file);
+      if (headerContent) {
+        const headerPath = this.pathResolver.getHeaderOutputPath(
+          file.discoveredFile
+        );
+        this.fs.writeFile(headerPath, headerContent);
         result.outputFiles.push(headerPath);
       }
     }
@@ -138370,7 +138745,7 @@ var Transpiler = class {
     return result;
   }
   // ===========================================================================
-  // Source Discovery (Stage 1 for run())
+  // File Discovery (Stage 1 for files mode)
   // ===========================================================================
   /**
    * Discover C-Next files from a single input (file or directory).
@@ -138431,6 +138806,10 @@ var Transpiler = class {
         ""
       );
       depGraph.addDependency(cnxPath, includePath);
+      const directive = resolved.headerIncludeDirectives.get(includePath);
+      if (directive) {
+        this.state.setHeaderDirective(includePath, directive);
+      }
       const alreadyExists = cnextBaseNames.has(includeBaseName) || cnextFiles.some((f) => resolve12(f.path) === includePath);
       if (!alreadyExists) {
         cnextFiles.push(cnxInclude);
@@ -138494,14 +138873,14 @@ var Transpiler = class {
    * This ensures headers are found based on what the source actually
    * includes, not by blindly scanning include directories.
    */
-  async discoverSources() {
+  async _discoverFromFiles() {
     const cnextFiles = [];
     const fileByPath = /* @__PURE__ */ new Map();
     for (const input of this.config.inputs) {
       this._discoverCNextFromInput(input, cnextFiles, fileByPath);
     }
     if (cnextFiles.length === 0) {
-      return { cnextFiles: [], headerFiles: [] };
+      return { cnextFiles: [], headerFiles: [], writeOutputToDisk: true };
     }
     const headerSet = /* @__PURE__ */ new Map();
     const depGraph = new DependencyGraph_default();
@@ -138529,9 +138908,14 @@ var Transpiler = class {
       }
     );
     this.warnings.push(...headerWarnings);
+    const pipelineFiles = sortedCnextFiles.map((f) => ({
+      path: f.path,
+      discoveredFile: f
+    }));
     return {
-      cnextFiles: sortedCnextFiles,
-      headerFiles: allHeaders
+      cnextFiles: pipelineFiles,
+      headerFiles: allHeaders,
+      writeOutputToDisk: true
     };
   }
   // ===========================================================================
@@ -138716,17 +139100,22 @@ var Transpiler = class {
    * Stage 6: Generate header file for a C-Next file
    * ADR-055 Phase 7: Uses TSymbol directly, converts to IHeaderSymbol for generation.
    */
-  generateHeader(file) {
-    const tSymbols = CodeGenState.symbolTable.getTSymbolsByFile(file.path);
+  /**
+   * Generate header content for a single file's exported symbols.
+   * Unified method replacing both generateHeader() and generateHeaderContent().
+   * Reads all needed data from state (populated during Stage 5).
+   */
+  generateHeaderForFile(file) {
+    const sourcePath = file.path;
+    const tSymbols = CodeGenState.symbolTable.getTSymbolsByFile(sourcePath);
     const exportedSymbols = tSymbols.filter((s) => s.isExported);
     if (exportedSymbols.length === 0) {
       return null;
     }
-    const headerName = basename5(file.path).replace(/\.cnx$|\.cnext$/, ".h");
-    const headerPath = this.pathResolver.getHeaderOutputPath(file);
-    const typeInput = this.state.getSymbolInfo(file.path);
-    const passByValueParams = this.state.getPassByValueParams(file.path) ?? /* @__PURE__ */ new Map();
-    const userIncludes = this.state.getUserIncludes(file.path);
+    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
+    const typeInput = this.state.getSymbolInfo(sourcePath);
+    const passByValueParams = this.state.getPassByValueParams(sourcePath) ?? /* @__PURE__ */ new Map();
+    const userIncludes = this.state.getUserIncludes(sourcePath);
     const allKnownEnums = TransitiveEnumCollector_default.aggregateKnownEnums(
       this.state.getAllSymbolInfo()
     );
@@ -138741,7 +139130,7 @@ var Transpiler = class {
       unmodifiedParams,
       allKnownEnums
     );
-    const headerContent = this.headerGenerator.generate(
+    return this.headerGenerator.generate(
       headerSymbols,
       headerName,
       {
@@ -138754,8 +139143,6 @@ var Transpiler = class {
       passByValueParams,
       allKnownEnums
     );
-    this.fs.writeFile(headerPath, headerContent);
-    return headerPath;
   }
   /**
    * Collect external enum sources from included C-Next files.
@@ -138788,43 +139175,6 @@ var Transpiler = class {
       );
     }
   }
-  /**
-   * Generate header content for exported symbols.
-   * Issue #591: Extracted from transpileSource() for reduced complexity.
-   * ADR-055 Phase 7: Works with TSymbol[], converts to IHeaderSymbol for generation.
-   */
-  generateHeaderContent(tSymbols, sourcePath, cppMode, userIncludes, passByValueParams, symbolInfo) {
-    const exportedSymbols = tSymbols.filter((s) => s.isExported);
-    if (exportedSymbols.length === 0) {
-      return void 0;
-    }
-    const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
-    const headerSymbols = this.convertToHeaderSymbols(
-      exportedSymbols,
-      unmodifiedParams,
-      symbolInfo.knownEnums
-    );
-    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
-    const typeInput = CodeGenState.symbols;
-    const externalTypeHeaders = ExternalTypeHeaderBuilder_default.build(
-      this.state.getAllHeaderDirectives(),
-      CodeGenState.symbolTable
-    );
-    const typeInputWithSymbolTable = typeInput ? { ...typeInput, symbolTable: CodeGenState.symbolTable } : void 0;
-    return this.headerGenerator.generate(
-      headerSymbols,
-      headerName,
-      {
-        exportedOnly: true,
-        userIncludes,
-        externalTypeHeaders,
-        cppMode
-      },
-      typeInputWithSymbolTable,
-      passByValueParams,
-      symbolInfo.knownEnums
-    );
-  }
   /**
    * Convert TSymbols to IHeaderSymbols with auto-const information applied.
    * ADR-055 Phase 7: Replaces mutation-based auto-const updating.
@@ -139032,7 +139382,7 @@ var Runner = class {
       target: config.target,
       debugMode: config.debugMode
     });
-    const result = await pipeline.run();
+    const result = await pipeline.transpile({ kind: "files" });
     this._renameOutputIfNeeded(result, explicitOutputFile);
     ResultPrinter_default.print(result);
     process.exit(result.success ? 0 : 1);
@@ -139742,16 +140092,31 @@ var ServeCommand = class _ServeCommand {
     }
     const { source, filePath } = params;
     const options = filePath ? { workingDir: dirname11(filePath), sourcePath: filePath } : void 0;
-    const result = await _ServeCommand.transpiler.transpileSource(
+    const transpileResult = await _ServeCommand.transpiler.transpile({
+      kind: "source",
       source,
-      options
-    );
+      ...options
+    });
+    const fileResult = transpileResult.files.find(
+      (f) => f.sourcePath === (filePath ?? "<string>")
+    ) ?? transpileResult.files[0];
+    if (!fileResult) {
+      return {
+        success: true,
+        result: {
+          success: false,
+          code: "",
+          errors: transpileResult.errors,
+          cppDetected: _ServeCommand.transpiler.isCppDetected()
+        }
+      };
+    }
     return {
       success: true,
       result: {
-        success: result.success,
-        code: result.code,
-        errors: result.errors,
+        success: fileResult.success,
+        code: fileResult.code,
+        errors: fileResult.errors,
         cppDetected: _ServeCommand.transpiler.isCppDetected()
       }
     };
@@ -139765,7 +140130,9 @@ var ServeCommand = class _ServeCommand {
     const { source, filePath } = params;
     if (_ServeCommand.transpiler && filePath) {
       try {
-        await _ServeCommand.transpiler.transpileSource(source, {
+        await _ServeCommand.transpiler.transpile({
+          kind: "source",
+          source,
           workingDir: dirname11(filePath),
           sourcePath: filePath
         });