c-next 0.1.18 → 0.1.20

package/README.md

@@ -663,44 +663,45 @@ Decisions are documented in `/docs/decisions/`:
 
 ### Implemented
 
-| ADR                                                                   | Title                   | Description                                                  |
-| --------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------ |
-| [ADR-001](docs/decisions/adr-001-assignment-operator.md)              | Assignment Operator     | `<-` for assignment, `=` for comparison                      |
-| [ADR-003](docs/decisions/adr-003-static-allocation.md)                | Static Allocation       | No dynamic memory after init                                 |
-| [ADR-004](docs/decisions/adr-004-register-bindings.md)                | Register Bindings       | Type-safe hardware access                                    |
-| [ADR-006](docs/decisions/adr-006-simplified-references.md)            | Simplified References   | Pass by reference, no pointer syntax                         |
-| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)          | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                   |
-| [ADR-010](docs/decisions/adr-010-c-interoperability.md)               | C Interoperability      | Unified ANTLR parser architecture                            |
-| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                 | VS Code Extension       | Live C preview with syntax highlighting                      |
-| [ADR-012](docs/decisions/adr-012-static-analysis.md)                  | Static Analysis         | cppcheck integration for generated C                         |
-| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                  | Const Qualifier         | Compile-time const enforcement                               |
-| [ADR-014](docs/decisions/adr-014-structs.md)                          | Structs                 | Data containers without methods                              |
-| [ADR-015](docs/decisions/adr-015-null-state.md)                       | Null State              | Zero initialization for all variables                        |
-| [ADR-016](docs/decisions/adr-016-scope.md)                            | Scope                   | `this.`/`global.` explicit qualification                     |
-| [ADR-017](docs/decisions/adr-017-enums.md)                            | Enums                   | Type-safe enums with C-style casting                         |
-| [ADR-030](docs/decisions/adr-030-forward-declarations.md)             | Define-Before-Use       | Functions must be defined before called                      |
-| [ADR-037](docs/decisions/adr-037-preprocessor.md)                     | Preprocessor            | Flag-only defines, const for values                          |
-| [ADR-043](docs/decisions/adr-043-comments.md)                         | Comments                | Comment preservation with MISRA compliance                   |
-| [ADR-044](docs/decisions/adr-044-primitive-types.md)                  | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow               |
-| [ADR-024](docs/decisions/adr-024-type-casting.md)                     | Type Casting            | Widening implicit, narrowing uses bit indexing               |
-| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)          | Conditional Expressions | Ternary with required parens, boolean condition, no nesting  |
-| [ADR-025](docs/decisions/adr-025-switch-statements.md)                | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)` |
-| [ADR-029](docs/decisions/adr-029-function-pointers.md)                | Callbacks               | Function-as-Type pattern with nominal typing                 |
-| [ADR-045](docs/decisions/adr-045-string-type.md)                      | Bounded Strings         | `string<N>` with compile-time safety                         |
-| [ADR-023](docs/decisions/adr-023-sizeof.md)                           | Sizeof                  | Type/value size queries with safety checks                   |
-| [ADR-027](docs/decisions/adr-027-do-while.md)                         | Do-While                | `do { } while ()` with boolean condition (E0701)             |
-| [ADR-032](docs/decisions/adr-032-nested-structs.md)                   | Nested Structs          | Named nested structs only (no anonymous)                     |
-| [ADR-035](docs/decisions/adr-035-array-initializers.md)               | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                      |
-| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)          | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement             |
-| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                  | ISR Type                | Built-in `ISR` type for `void(void)` function pointers       |
-| [ADR-034](docs/decisions/adr-034-bit-fields.md)                       | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data |
-| [ADR-048](docs/decisions/adr-048-cli-executable.md)                   | CLI Executable          | `cnext` command with smart defaults                          |
-| [ADR-049](docs/decisions/adr-049-atomic-types.md)                     | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback        |
-| [ADR-050](docs/decisions/adr-050-critical-sections.md)                | Critical Sections       | `critical { }` blocks with PRIMASK save/restore              |
-| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                 | Volatile Variables      | `volatile` keyword prevents compiler optimization            |
-| [ADR-047](docs/decisions/adr-047-nullable-types.md)                   | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
-| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md)  | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion        |
-| [ADR-053](docs/decisions/adr-053-transpiler-pipeline-architecture.md) | Transpiler Pipeline     | Unified multi-pass pipeline with header symbol extraction    |
+| ADR                                                                   | Title                   | Description                                                   |
+| --------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------- |
+| [ADR-001](docs/decisions/adr-001-assignment-operator.md)              | Assignment Operator     | `<-` for assignment, `=` for comparison                       |
+| [ADR-003](docs/decisions/adr-003-static-allocation.md)                | Static Allocation       | No dynamic memory after init                                  |
+| [ADR-004](docs/decisions/adr-004-register-bindings.md)                | Register Bindings       | Type-safe hardware access                                     |
+| [ADR-006](docs/decisions/adr-006-simplified-references.md)            | Simplified References   | Pass by reference, no pointer syntax                          |
+| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)          | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                    |
+| [ADR-010](docs/decisions/adr-010-c-interoperability.md)               | C Interoperability      | Unified ANTLR parser architecture                             |
+| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                 | VS Code Extension       | Live C preview with syntax highlighting                       |
+| [ADR-012](docs/decisions/adr-012-static-analysis.md)                  | Static Analysis         | cppcheck integration for generated C                          |
+| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                  | Const Qualifier         | Compile-time const enforcement                                |
+| [ADR-014](docs/decisions/adr-014-structs.md)                          | Structs                 | Data containers without methods                               |
+| [ADR-015](docs/decisions/adr-015-null-state.md)                       | Null State              | Zero initialization for all variables                         |
+| [ADR-016](docs/decisions/adr-016-scope.md)                            | Scope                   | `this.`/`global.` explicit qualification                      |
+| [ADR-017](docs/decisions/adr-017-enums.md)                            | Enums                   | Type-safe enums with C-style casting                          |
+| [ADR-030](docs/decisions/adr-030-forward-declarations.md)             | Define-Before-Use       | Functions must be defined before called                       |
+| [ADR-037](docs/decisions/adr-037-preprocessor.md)                     | Preprocessor            | Flag-only defines, const for values                           |
+| [ADR-043](docs/decisions/adr-043-comments.md)                         | Comments                | Comment preservation with MISRA compliance                    |
+| [ADR-044](docs/decisions/adr-044-primitive-types.md)                  | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow                |
+| [ADR-024](docs/decisions/adr-024-type-casting.md)                     | Type Casting            | Widening implicit, narrowing uses bit indexing                |
+| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)          | Conditional Expressions | Ternary with required parens, boolean condition, no nesting   |
+| [ADR-025](docs/decisions/adr-025-switch-statements.md)                | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)`  |
+| [ADR-029](docs/decisions/adr-029-function-pointers.md)                | Callbacks               | Function-as-Type pattern with nominal typing                  |
+| [ADR-045](docs/decisions/adr-045-string-type.md)                      | Bounded Strings         | `string<N>` with compile-time safety                          |
+| [ADR-023](docs/decisions/adr-023-sizeof.md)                           | Sizeof                  | Type/value size queries with safety checks                    |
+| [ADR-027](docs/decisions/adr-027-do-while.md)                         | Do-While                | `do { } while ()` with boolean condition (E0701)              |
+| [ADR-032](docs/decisions/adr-032-nested-structs.md)                   | Nested Structs          | Named nested structs only (no anonymous)                      |
+| [ADR-035](docs/decisions/adr-035-array-initializers.md)               | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                       |
+| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)          | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement              |
+| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                  | ISR Type                | Built-in `ISR` type for `void(void)` function pointers        |
+| [ADR-034](docs/decisions/adr-034-bit-fields.md)                       | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data  |
+| [ADR-048](docs/decisions/adr-048-cli-executable.md)                   | CLI Executable          | `cnext` command with smart defaults                           |
+| [ADR-049](docs/decisions/adr-049-atomic-types.md)                     | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback         |
+| [ADR-050](docs/decisions/adr-050-critical-sections.md)                | Critical Sections       | `critical { }` blocks with PRIMASK save/restore               |
+| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                 | Volatile Variables      | `volatile` keyword prevents compiler optimization             |
+| [ADR-046](docs/decisions/adr-046-nullable-c-interop.md)               | Nullable C Interop      | `c_` prefix for nullable C pointer types (supersedes ADR-047) |
+| [ADR-047](docs/decisions/adr-047-nullable-types.md)                   | NULL for C Interop      | `NULL` keyword for C stream functions (superseded by ADR-046) |
+| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md)  | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion         |
+| [ADR-053](docs/decisions/adr-053-transpiler-pipeline-architecture.md) | Transpiler Pipeline     | Unified multi-pass pipeline with header symbol extraction     |
 
 ### Research (v1 Roadmap)
 

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -10,6 +10,7 @@ import ESourceLanguage from "../types/ESourceLanguage";
 import ESymbolKind from "../types/ESymbolKind";
 import CommentExtractor from "./CommentExtractor";
 import CommentFormatter from "./CommentFormatter";
+import IncludeDiscovery from "../lib/IncludeDiscovery";
 import IComment from "./types/IComment";
 import TYPE_WIDTH from "./types/TYPE_WIDTH";
 import C_TYPE_WIDTH from "./types/C_TYPE_WIDTH";
@@ -1444,6 +1445,10 @@ export default class CodeGenerator implements IOrchestrator {
     // C-Next does NOT hardcode any libraries - all includes must be explicit
     // ADR-043: Comments before first include become file-level comments
     // ADR-010: Transform .cnx includes to .h, reject implementation files
+    // E0504: Cache include paths for performance (computed once, used for all includes)
+    const includePaths = this.sourcePath
+      ? IncludeDiscovery.discoverIncludePaths(this.sourcePath)
+      : [];
     for (const includeDir of tree.includeDirective()) {
       const leadingComments = this.getLeadingComments(includeDir);
       output.push(...this.formatLeadingComments(leadingComments));
@@ -1455,6 +1460,14 @@ export default class CodeGenerator implements IOrchestrator {
         lineNumber,
       );
 
+      // E0504: Check if a .cnx alternative exists for .h/.hpp includes
+      this.typeValidator!.validateIncludeNoCnxAlternative(
+        includeDir.getText(),
+        lineNumber,
+        this.sourcePath,
+        includePaths,
+      );
+
       const transformedInclude = this.transformIncludeDirective(
         includeDir.getText(),
       );
@@ -4012,6 +4025,64 @@ export default class CodeGenerator implements IOrchestrator {
     return false;
   }
 
+  /**
+   * Issue #308: Check if a member access expression is accessing an array member.
+   * For example, result.data where data is a u8[6] array member.
+   * When passing such expressions to functions, the array should naturally decay
+   * to a pointer, so we should NOT add & operator.
+   *
+   * Note: Currently handles single-level member access only (e.g., result.data).
+   * Nested access like outer.inner.data would require traversing the postfix chain
+   * to resolve intermediate struct types. This is acceptable since issue #308
+   * involves single-level access patterns.
+   *
+   * @param ctx - The expression context
+   * @returns true if the expression is a member access to an array field
+   */
+  private isMemberAccessToArray(ctx: Parser.ExpressionContext): boolean {
+    const postfix = this.getPostfixExpression(ctx);
+    if (!postfix) return false;
+
+    const ops = postfix.postfixOp();
+    if (ops.length === 0) return false;
+
+    // Last operator must be member access (.identifier)
+    const lastOp = ops[ops.length - 1];
+    const memberName = lastOp.IDENTIFIER()?.getText();
+    if (!memberName) return false;
+
+    // Get the base identifier to find the struct type
+    const primary = postfix.primaryExpression();
+    if (!primary) return false;
+    const baseId = primary.IDENTIFIER()?.getText();
+    if (!baseId) return false;
+
+    // Look up the struct type from either:
+    // 1. Local variable: typeRegistry.get(baseId).baseType
+    // 2. Parameter: currentParameters.get(baseId).baseType
+    let structType: string | undefined;
+
+    const typeInfo = this.context.typeRegistry.get(baseId);
+    if (typeInfo) {
+      structType = typeInfo.baseType;
+    } else {
+      const paramInfo = this.context.currentParameters.get(baseId);
+      if (paramInfo) {
+        structType = paramInfo.baseType;
+      }
+    }
+
+    if (!structType) return false;
+
+    // Check if this struct member is an array
+    const memberInfo = this.getMemberTypeInfo(structType, memberName);
+    if (memberInfo?.isArray) {
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Check if an expression is a simple literal (number, bool, etc.)
    * Navigates: expression -> ternaryExpression -> orExpression -> ... -> primaryExpression -> literal
@@ -4172,6 +4243,13 @@ export default class CodeGenerator implements IOrchestrator {
     // Check if it's a member access or array access (lvalue) - needs &
     const lvalueType = this.getLvalueType(ctx);
     if (lvalueType) {
+      // Issue #308: If member access to an array, don't add & - arrays decay to pointers
+      // For example: result.data where data is u8[6] should pass as result.data (decays to uint8_t*)
+      // NOT &result.data (which gives uint8_t (*)[6] - wrong type)
+      if (lvalueType === "member" && this.isMemberAccessToArray(ctx)) {
+        return this._generateExpression(ctx);
+      }
+
       // Issue #251/#252: In C++ mode, struct member access may need temp variable
       if (
         lvalueType === "member" &&
@@ -5497,6 +5575,14 @@ export default class CodeGenerator implements IOrchestrator {
         return "{}";
       }
 
+      // Issue #309: In C++ mode, unknown user types (external libraries)
+      // should use {} instead of {0} because they may have non-trivial
+      // constructors. Known structs (C-Next or C headers) are POD types
+      // where {0} works fine.
+      if (this.cppMode && !this._isKnownStruct(typeName)) {
+        return "{}";
+      }
+
       return "{0}";
     }
 
@@ -7913,7 +7999,10 @@ export default class CodeGenerator implements IOrchestrator {
           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)) {
+          // Issue #314: In C++ mode, global.X.method() should always use :: syntax
+          // because the programmer is explicitly requesting C++ static method access,
+          // even for undeclared external symbols (e.g., Arduino's Serial class)
+          if (this.isCppScopeSymbol(memberName) || this.cppMode) {
             isCppAccessChain = true;
           }
           // Check if this first identifier is a register
@@ -8498,9 +8587,13 @@ export default class CodeGenerator implements IOrchestrator {
           }
           // 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 ::
+          // Issue #314: Also use :: for global.X.method() in C++ mode with undeclared external classes
+          // (e.g., Arduino's Serial class) - the global. prefix explicitly requests C++ static access
           else if (
             isCppAccessChain &&
-            (this.isCppScopeSymbol(result) || result.includes("::"))
+            (this.isCppScopeSymbol(result) ||
+              result.includes("::") ||
+              isGlobalAccess)
           ) {
             result = `${result}::${memberName}`;
           } else {

package/src/codegen/TypeValidator.ts

@@ -3,6 +3,7 @@
  * Extracted from CodeGenerator for better separation of concerns
  * Issue #63: Validation logic separated for independent testing
  */
+import { dirname, resolve, join } from "path";
 import * as Parser from "../parser/grammar/CNextParser";
 import SymbolCollector from "./SymbolCollector";
 import SymbolTable from "../symbols/SymbolTable";
@@ -85,6 +86,75 @@ class TypeValidator {
     }
   }
 
+  /**
+   * E0504: Validate that a .cnx alternative doesn't exist for a .h/.hpp include
+   * This helps during codebase migration by alerting developers when they should
+   * be using the C-Next version of a file instead of the C header.
+   *
+   * @param includeText - The full #include directive text
+   * @param lineNumber - Line number for error reporting
+   * @param sourcePath - Path to the source file (for resolving relative includes)
+   * @param includePaths - Array of directories to search for includes
+   * @param fileExists - Function to check if a file exists (injectable for testing)
+   */
+  validateIncludeNoCnxAlternative(
+    includeText: string,
+    lineNumber: number,
+    sourcePath: string | null,
+    includePaths: string[],
+    fileExists: (path: string) => boolean = (p) => require("fs").existsSync(p),
+  ): void {
+    // Extract the file path from #include directive
+    const angleMatch = includeText.match(/#\s*include\s*<([^>]+)>/);
+    const quoteMatch = includeText.match(/#\s*include\s*"([^"]+)"/);
+
+    const includePath = angleMatch?.[1] || quoteMatch?.[1];
+    if (!includePath) {
+      return; // Malformed include, let other validation handle it
+    }
+
+    // Skip if already a .cnx include
+    if (includePath.endsWith(".cnx")) {
+      return;
+    }
+
+    // Only check .h and .hpp files
+    const ext = includePath
+      .substring(includePath.lastIndexOf("."))
+      .toLowerCase();
+    if (ext !== ".h" && ext !== ".hpp") {
+      return;
+    }
+
+    // Build the .cnx alternative path
+    const cnxPath = includePath.replace(/\.(h|hpp)$/i, ".cnx");
+
+    if (quoteMatch) {
+      // Quoted include: resolve relative to source file's directory
+      if (sourcePath) {
+        const sourceDir = dirname(sourcePath);
+        const fullCnxPath = resolve(sourceDir, cnxPath);
+        if (fileExists(fullCnxPath)) {
+          throw new Error(
+            `E0504: Found #include "${includePath}" but '${cnxPath}' exists at the same location.\n` +
+              `       Use #include "${cnxPath}" instead to use the C-Next version. Line ${lineNumber}`,
+          );
+        }
+      }
+    } else if (angleMatch) {
+      // Angle bracket include: search through include paths
+      for (const searchDir of includePaths) {
+        const fullCnxPath = join(searchDir, cnxPath);
+        if (fileExists(fullCnxPath)) {
+          throw new Error(
+            `E0504: Found #include <${includePath}> but '${cnxPath}' exists at the same location.\n` +
+              `       Use #include <${cnxPath}> instead to use the C-Next version. Line ${lineNumber}`,
+          );
+        }
+      }
+    }
+  }
+
   // ========================================================================
   // Bitmap Field Validation (ADR-034)
   // ========================================================================

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

@@ -30,15 +30,6 @@ import generateScopedRegister from "./ScopedRegisterGenerator";
  * - Visibility control (private -> static, public -> extern)
  * - Organization without runtime overhead
  */
-/**
- * Issue #232: Information about a single-function variable
- */
-interface ISingleFunctionVar {
-  varDecl: Parser.VariableDeclarationContext;
-  targetFunction: string;
-  isPrivate: boolean;
-}
-
 const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
   node: Parser.ScopeDeclarationContext,
   input: IGeneratorInput,
@@ -53,10 +44,6 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
   const lines: string[] = [];
   lines.push(`/* Scope: ${name} */`);
 
-  // Issue #232: First pass - identify single-function variables
-  // Maps functionName -> list of variable declarations that are local to it
-  const localVarsForFunction = new Map<string, ISingleFunctionVar[]>();
-
   for (const member of node.scopeMember()) {
     const visibility = member.visibilityModifier()?.getText() || "private";
     const isPrivate = visibility === "private";
@@ -66,39 +53,16 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
       const varDecl = member.variableDeclaration()!;
       const varName = varDecl.IDENTIFIER().getText();
 
-      // Issue #282: Check if this is a const variable - const values should be inlined,
-      // not injected as local variables
+      // Issue #282: Check if this is a const variable - const values should be inlined
       const isConst = varDecl.constModifier() !== null;
 
-      // Issue #232: Check if this PRIVATE variable is used in only one function
-      // PUBLIC variables must stay file-scope because they can be accessed from outside
-      // Issue #282: Skip const variables - they should be inlined, not made local
-      const targetFunc =
-        isPrivate && !isConst
-          ? input.symbols?.getSingleFunctionForVariable(name, varName)
-          : null;
-
-      if (targetFunc) {
-        // Single-function private variable - emit as local, not file-scope
-        if (!localVarsForFunction.has(targetFunc)) {
-          localVarsForFunction.set(targetFunc, []);
-        }
-        localVarsForFunction.get(targetFunc)!.push({
-          varDecl,
-          targetFunction: targetFunc,
-          isPrivate,
-        });
-        // Don't emit file-scope declaration
-        continue;
-      }
-
       // Issue #282: Private const variables should be inlined, not emitted at file scope
       // The inlining happens in CodeGenerator when resolving this.CONST_NAME
       if (isPrivate && isConst) {
         continue;
       }
 
-      // Multi-function or unused variable - emit at file scope (original behavior)
+      // ADR-016: All scope variables are emitted at file scope (static-like persistence)
       const type = orchestrator.generateType(varDecl.type());
       const fullName = `${name}_${varName}`;
       // Issue #282: Add 'const' modifier for const variables
@@ -149,7 +113,7 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
 
       // Issue #281: Generate body FIRST to track parameter modifications,
       // then generate parameter list using that tracking info
-      let body = orchestrator.generateBlock(funcDecl.block());
+      const body = orchestrator.generateBlock(funcDecl.block());
 
       // Issue #281: Update symbol's parameter info with auto-const before generating params
       orchestrator.updateFunctionParamsAutoConst(fullName);
@@ -159,52 +123,6 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
         ? orchestrator.generateParameterList(funcDecl.parameterList()!)
         : "void";
 
-      // Issue #232: Inject local variable declarations for single-function vars
-      const localVars = localVarsForFunction.get(funcName);
-      if (localVars && localVars.length > 0) {
-        // Generate local variable declarations
-        const localDecls: string[] = [];
-        for (const { varDecl } of localVars) {
-          const varType = orchestrator.generateType(varDecl.type());
-          const varName = varDecl.IDENTIFIER().getText();
-          const varFullName = `${name}_${varName}`;
-
-          const arrayDims = varDecl.arrayDimension();
-          const isArray = arrayDims.length > 0;
-          let decl = `    ${varType} ${varFullName}`;
-          if (isArray) {
-            decl += orchestrator.generateArrayDimensions(arrayDims);
-          }
-          // ADR-045: Add string capacity dimension for string arrays
-          if (varDecl.type().stringType()) {
-            const stringCtx = varDecl.type().stringType()!;
-            const intLiteral = stringCtx.INTEGER_LITERAL();
-            if (intLiteral) {
-              const capacity = parseInt(intLiteral.getText(), 10);
-              decl += `[${capacity + 1}]`;
-            }
-          }
-          if (varDecl.expression()) {
-            decl += ` = ${orchestrator.generateExpression(varDecl.expression()!)}`;
-          } else {
-            decl += ` = ${orchestrator.getZeroInitializer(varDecl.type(), isArray)}`;
-          }
-          localDecls.push(decl + ";");
-        }
-
-        // Inject after opening brace: { -> {\n    local_var = init;
-        // Body format is typically "{\n    ...statements...\n}"
-        const openBraceIdx = body.indexOf("{");
-        if (openBraceIdx !== -1) {
-          const afterBrace = body.substring(openBraceIdx + 1);
-          body =
-            body.substring(0, openBraceIdx + 1) +
-            "\n" +
-            localDecls.join("\n") +
-            afterBrace;
-        }
-      }
-
       // ADR-016: Exit function body context
       orchestrator.exitFunctionBody();
       orchestrator.setCurrentFunctionName(null); // Issue #269: Clear function name

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

@@ -16,6 +16,7 @@ import TGeneratorEffect from "../TGeneratorEffect";
 import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
+import ESymbolKind from "../../../types/ESymbolKind";
 
 /**
  * Issue #304: Map C-Next type to C type for static_cast.
@@ -38,6 +39,14 @@ const mapTypeToCType = (cnxType: string): string => {
   return TYPE_MAP[cnxType] || cnxType;
 };
 
+/**
+ * Issue #315: Small primitive types that are always passed by value.
+ * These match the types used in Issue #269 for pass-by-value optimization.
+ * For cross-file function calls, we use these types directly since we can't
+ * know if the parameter is modified (that info is only in the source file).
+ */
+const SMALL_PRIMITIVE_TYPES = new Set(["u8", "u16", "i8", "i16", "bool"]);
+
 /**
  * Issue #304: Wrap argument with static_cast if it's a C++ enum class
  * being passed to an integer parameter.
@@ -115,7 +124,27 @@ const generateFunctionCall = (
     .map((e, idx) => {
       // Get function signature for parameter type info
       const sig = input.functionSignatures.get(funcExpr);
-      const targetParam = sig?.parameters[idx];
+      let targetParam = sig?.parameters[idx];
+      // Issue #315: Track if we got param info from SymbolTable (cross-file function)
+      let isCrossFileFunction = false;
+
+      // Issue #315: If no local signature, try SymbolTable for cross-file functions
+      if (!targetParam && input.symbolTable) {
+        const symbols = input.symbolTable.getOverloads(funcExpr);
+        for (const sym of symbols) {
+          if (sym.kind === ESymbolKind.Function && sym.parameters?.[idx]) {
+            // Map symbol parameter to targetParam format (IFunctionSignature.parameters)
+            targetParam = {
+              name: sym.parameters[idx].name,
+              baseType: sym.parameters[idx].type,
+              isConst: sym.parameters[idx].isConst,
+              isArray: sym.parameters[idx].isArray,
+            };
+            isCrossFileFunction = true;
+            break;
+          }
+        }
+      }
 
       if (!isCNextFunc) {
         // C function: pass-by-value, just generate the expression
@@ -134,13 +163,26 @@ const generateFunctionCall = (
         targetParam && orchestrator.isFloatType(targetParam.baseType);
       const isEnumParam =
         targetParam && orchestrator.getKnownEnums().has(targetParam.baseType);
-      // Issue #269: Check if small unmodified primitive
+      // Issue #269: Check if small unmodified primitive (for local functions)
       const isPrimitivePassByValue = orchestrator.isParameterPassByValue(
         funcExpr,
         idx,
       );
+      // Issue #315: For cross-file functions ONLY, check if it's a small primitive type
+      // that should always be passed by value (u8, u16, i8, i16, bool).
+      // We only do this for cross-file functions because for local functions,
+      // isPrimitivePassByValue correctly considers whether the parameter is modified.
+      const isSmallPrimitive =
+        isCrossFileFunction &&
+        targetParam &&
+        SMALL_PRIMITIVE_TYPES.has(targetParam.baseType);
 
-      if (isFloatParam || isEnumParam || isPrimitivePassByValue) {
+      if (
+        isFloatParam ||
+        isEnumParam ||
+        isPrimitivePassByValue ||
+        isSmallPrimitive
+      ) {
         // Target parameter is pass-by-value: pass value directly
         const argCode = orchestrator.generateExpression(e);
         // Issue #304: Wrap with static_cast if C++ enum class → integer