c-next 0.1.48 → 0.1.50

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -189,7 +189,7 @@ interface GeneratorContext {
   indentLevel: number;
   scopeMembers: Map<string, Set<string>>; // scope -> member names (ADR-016)
   currentParameters: Map<string, TParameterInfo>; // ADR-006: track params for pointer semantics
-  modifiedParameters: Set<string>; // Issue #268: track modified params for auto-const inference
+  // Issue #558: modifiedParameters removed - now uses analysis-phase results from this.modifiedParameters
   localArrays: Set<string>; // ADR-006: track local array variables (no & needed)
   localVariables: Set<string>; // ADR-016: track local variables (allowed as bare identifiers)
   floatBitShadows: Set<string>; // Track declared shadow variables for float bit indexing
@@ -221,7 +221,7 @@ export default class CodeGenerator implements IOrchestrator {
     indentLevel: 0,
     scopeMembers: new Map(), // ADR-016: renamed from namespaceMembers
     currentParameters: new Map(),
-    modifiedParameters: new Set(),
+    // Issue #558: modifiedParameters removed - now uses analysis-phase results
     localArrays: new Set(),
     localVariables: new Set(), // ADR-016: track local variables
     floatBitShadows: new Set(), // Track declared shadow variables for float bit indexing
@@ -327,6 +327,17 @@ export default class CodeGenerator implements IOrchestrator {
    */
   private readonly modifiedParameters: Map<string, Set<string>> = new Map();
 
+  /**
+   * Issue #558: Pending cross-file modifications to inject after analyzePassByValue clears.
+   * Set by Pipeline before generate() to share modifications from previously processed files.
+   */
+  private pendingCrossFileModifications: Map<string, Set<string>> | null = null;
+
+  /**
+   * Issue #558: Pending cross-file parameter lists to inject for transitive propagation.
+   */
+  private pendingCrossFileParamLists: Map<string, string[]> | null = null;
+
   /**
    * Issue #269: Tracks which parameters should pass by value
    * Map of functionName -> Set of passByValue parameter names
@@ -1061,7 +1072,7 @@ export default class CodeGenerator implements IOrchestrator {
     this.context.localVariables.clear();
     this.context.floatBitShadows.clear();
     this.context.floatShadowCurrent.clear();
-    this.context.modifiedParameters.clear(); // Issue #268: Clear for new function
+    // Issue #558: modifiedParameters tracking removed - uses analysis-phase results
     this.context.inFunctionBody = true;
   }
 
@@ -1106,13 +1117,14 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Issue #268: Update symbol parameters with auto-const info.
-   * Call after generating function body to track unmodified parameters.
+   * Issue #558: Now uses analysis-phase results for modification tracking.
    */
   updateFunctionParamsAutoConst(functionName: string): void {
-    // Collect unmodified parameters for this function
+    // Collect unmodified parameters for this function using analysis results
     const unmodifiedParams = new Set<string>();
+    const modifiedSet = this.modifiedParameters.get(functionName);
     for (const [paramName] of this.context.currentParameters) {
-      if (!this.context.modifiedParameters.has(paramName)) {
+      if (!modifiedSet?.has(paramName)) {
         unmodifiedParams.add(paramName);
       }
     }
@@ -1121,11 +1133,100 @@ export default class CodeGenerator implements IOrchestrator {
 
   /**
    * Issue #268: Mark a parameter as modified for auto-const tracking.
+   * Issue #558: Now a no-op - analysis phase handles all modification tracking
+   * including transitive propagation across function calls and files.
+   */
+  markParameterModified(_paramName: string): void {
+    // No-op: Analysis phase (analyzePassByValue) now handles all modification
+    // tracking including cross-file and transitive propagation.
+  }
+
+  /**
+   * Issue #558: Check if a parameter is modified using analysis-phase results.
+   * This is the unified source of truth for modification tracking.
+   */
+  private _isCurrentParameterModified(paramName: string): boolean {
+    const funcName = this.context.currentFunctionName;
+    if (!funcName) return false;
+    return this.modifiedParameters.get(funcName)?.has(paramName) ?? false;
+  }
+
+  /**
+   * Issue #558: Get the modified parameters map for cross-file propagation.
+   * Returns function name -> set of modified parameter names.
+   */
+  getModifiedParameters(): ReadonlyMap<string, Set<string>> {
+    return this.modifiedParameters;
+  }
+
+  /**
+   * Issue #558: Set cross-file modification data to inject during analyzePassByValue.
+   * Called by Pipeline before generate() to share modifications from previously processed files.
+   */
+  setCrossFileModifications(
+    modifications: Map<string, Set<string>>,
+    paramLists: Map<string, string[]>,
+  ): void {
+    this.pendingCrossFileModifications = modifications;
+    this.pendingCrossFileParamLists = paramLists;
+  }
+
+  /**
+   * Issue #558: Get the function parameter lists for cross-file propagation.
+   */
+  getFunctionParamLists(): ReadonlyMap<string, string[]> {
+    return this.functionParamLists;
+  }
+
+  /**
+   * 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).
+   *
+   * Returns the modifications and param lists discovered in this tree.
    */
-  markParameterModified(paramName: string): void {
-    if (this.context.currentParameters.has(paramName)) {
-      this.context.modifiedParameters.add(paramName);
+  analyzeModificationsOnly(tree: Parser.ProgramContext): {
+    modifications: Map<string, Set<string>>;
+    paramLists: Map<string, string[]>;
+  } {
+    // Save current state
+    const savedModifications = new Map(this.modifiedParameters);
+    const savedParamLists = new Map(this.functionParamLists);
+    const savedCallGraph = new Map(this.functionCallGraph);
+
+    // Clear for fresh analysis
+    this.modifiedParameters.clear();
+    this.functionParamLists.clear();
+    this.functionCallGraph.clear();
+
+    // Run modification analysis on the tree
+    this.collectFunctionParametersAndModifications(tree);
+
+    // Capture results before restoring state
+    const modifications = new Map<string, Set<string>>();
+    for (const [funcName, params] of this.modifiedParameters) {
+      modifications.set(funcName, new Set(params));
+    }
+    const paramLists = new Map<string, string[]>();
+    for (const [funcName, params] of this.functionParamLists) {
+      paramLists.set(funcName, [...params]);
+    }
+
+    // Restore previous state by clearing and repopulating (readonly maps)
+    this.modifiedParameters.clear();
+    for (const [k, v] of savedModifications) {
+      this.modifiedParameters.set(k, v);
     }
+    this.functionParamLists.clear();
+    for (const [k, v] of savedParamLists) {
+      this.functionParamLists.set(k, v);
+    }
+    this.functionCallGraph.clear();
+    for (const [k, v] of savedCallGraph) {
+      this.functionCallGraph.set(k, v);
+    }
+
+    return { modifications, paramLists };
   }
 
   /**
@@ -1539,7 +1640,7 @@ export default class CodeGenerator implements IOrchestrator {
       indentLevel: 0,
       scopeMembers: new Map(), // ADR-016
       currentParameters: new Map(),
-      modifiedParameters: new Set(),
+      // Issue #558: modifiedParameters removed - uses analysis-phase results
       localArrays: new Set(),
       localVariables: new Set(), // ADR-016
       floatBitShadows: new Set(), // Track declared shadow variables for float bit indexing
@@ -2025,6 +2126,29 @@ export default class CodeGenerator implements IOrchestrator {
     // Phase 1: Collect function parameter lists and direct modifications
     this.collectFunctionParametersAndModifications(tree);
 
+    // Issue #558: Inject cross-file data before transitive propagation
+    if (this.pendingCrossFileModifications) {
+      for (const [funcName, params] of this.pendingCrossFileModifications) {
+        const existing = this.modifiedParameters.get(funcName);
+        if (existing) {
+          for (const param of params) {
+            existing.add(param);
+          }
+        } else {
+          this.modifiedParameters.set(funcName, new Set(params));
+        }
+      }
+      this.pendingCrossFileModifications = null; // Clear after use
+    }
+    if (this.pendingCrossFileParamLists) {
+      for (const [funcName, params] of this.pendingCrossFileParamLists) {
+        if (!this.functionParamLists.has(funcName)) {
+          this.functionParamLists.set(funcName, params);
+        }
+      }
+      this.pendingCrossFileParamLists = null; // Clear after use
+    }
+
     // Phase 2: Fixed-point iteration for transitive modifications
     this.propagateTransitiveModifications();
 
@@ -2120,17 +2244,31 @@ export default class CodeGenerator implements IOrchestrator {
     // Check for assignment statements
     if (stmt.assignmentStatement()) {
       const assign = stmt.assignmentStatement()!;
-      // Get the target - use assignmentTarget() which has IDENTIFIER()
       const target = assign.assignmentTarget();
+
+      // Issue #558: Extract base identifier from assignment target
+      // - Simple identifier: x <- value
+      // - Member access: x.field <- value (first IDENTIFIER is the base)
+      // - Array access: x[i] <- value
+      let baseIdentifier: string | null = null;
+
       if (target?.IDENTIFIER()) {
-        // Simple identifier assignment (not array/member access)
-        if (!target.arrayAccess() && !target.memberAccess()) {
-          const targetName = target.IDENTIFIER()!.getText();
-          if (paramSet.has(targetName)) {
-            // Direct assignment to parameter
-            this.modifiedParameters.get(funcName)!.add(targetName);
-          }
+        // Simple identifier assignment
+        baseIdentifier = target.IDENTIFIER()!.getText();
+      } else if (target?.memberAccess()) {
+        // Member access: first IDENTIFIER is the base (e.g., cfg.value -> cfg)
+        const identifiers = target.memberAccess()!.IDENTIFIER();
+        if (identifiers.length > 0) {
+          baseIdentifier = identifiers[0].getText();
         }
+      } else if (target?.arrayAccess()) {
+        // Array access: IDENTIFIER is the base (e.g., arr[0] -> arr)
+        baseIdentifier = target.arrayAccess()!.IDENTIFIER()?.getText() ?? null;
+      }
+
+      if (baseIdentifier && paramSet.has(baseIdentifier)) {
+        // Direct or member/array assignment modifies the parameter
+        this.modifiedParameters.get(funcName)!.add(baseIdentifier);
       }
     }
 
@@ -2386,9 +2524,17 @@ export default class CodeGenerator implements IOrchestrator {
       const memberNames: string[] = [];
 
       // Start with primary identifier if it's a scope name (not 'global' or 'this')
+      // Issue #561: When 'this' is used, resolve to the current scope name from funcName
       const primaryId = primary.IDENTIFIER()?.getText();
-      if (primaryId && primaryId !== "global" && primaryId !== "this") {
+      if (primaryId && primaryId !== "global") {
         memberNames.push(primaryId);
+      } else if (primary.THIS()) {
+        // Issue #561: 'this' keyword - resolve to current scope name from funcName
+        // funcName format: "ScopeName_methodName" -> extract "ScopeName"
+        const scopeName = funcName.split("_")[0];
+        if (scopeName && scopeName !== funcName) {
+          memberNames.push(scopeName);
+        }
       }
 
       // Collect member access names until we hit a function call
@@ -5358,8 +5504,7 @@ export default class CodeGenerator implements IOrchestrator {
     // Track parameters for ADR-006 pointer semantics
     this._setParameters(ctx.parameterList() ?? null);
 
-    // Issue #268: Clear modified parameters tracking for this function
-    this.context.modifiedParameters.clear();
+    // Issue #558: modifiedParameters tracking removed - uses analysis-phase results
 
     // ADR-016: Clear local variables and mark that we're in a function body
     this.context.localVariables.clear();
@@ -5525,8 +5670,8 @@ export default class CodeGenerator implements IOrchestrator {
     // Arrays pass naturally as pointers
     if (dims.length > 0) {
       const dimStr = dims.map((d) => this._generateArrayDimension(d)).join("");
-      // Issue #268: Add const for unmodified array parameters
-      const wasModified = this.context.modifiedParameters.has(name);
+      // Issue #268/#558: Add const for unmodified array parameters (uses analysis results)
+      const wasModified = this._isCurrentParameterModified(name);
       const autoConst = !wasModified && !constMod ? "const " : "";
       return `${autoConst}${constMod}${type} ${name}${dimStr}`;
     }
@@ -5557,8 +5702,8 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-045: String parameters (non-array) are passed as char*
     // Issue #551: Handle before unknown type check
     if (ctx.type().stringType() && dims.length === 0) {
-      // Issue #268: Add const for unmodified string parameters
-      const wasModified = this.context.modifiedParameters.has(name);
+      // Issue #268/#558: Add const for unmodified string parameters (uses analysis results)
+      const wasModified = this._isCurrentParameterModified(name);
       const autoConst = !wasModified && !constMod ? "const " : "";
       return `${autoConst}${constMod}char* ${name}`;
     }
@@ -5566,8 +5711,8 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-006: Pass by reference for known struct types and known primitives
     // Issue #551: Unknown types (external enums, typedefs) use pass-by-value
     if (this._isKnownStruct(typeName) || this._isKnownPrimitive(typeName)) {
-      // Issue #268: Add const for unmodified pointer parameters
-      const wasModified = this.context.modifiedParameters.has(name);
+      // Issue #268/#558: Add const for unmodified pointer parameters (uses analysis results)
+      const wasModified = this._isCurrentParameterModified(name);
       const autoConst = !wasModified && !constMod ? "const " : "";
       // Issue #409: In C++ mode, use references (&) instead of pointers (*)
       // This allows C-Next callbacks to match C++ function pointer signatures
@@ -6833,10 +6978,7 @@ export default class CodeGenerator implements IOrchestrator {
         throw new Error(constError);
       }
 
-      // Issue #268: Track parameter modification for auto-const inference
-      if (this.context.currentParameters.has(id)) {
-        this.context.modifiedParameters.add(id);
-      }
+      // Issue #558: Parameter modification tracking removed - uses analysis-phase results
 
       // Invalidate float shadow when variable is assigned directly
       const shadowName = `__bits_${id}`;
@@ -6962,10 +7104,7 @@ export default class CodeGenerator implements IOrchestrator {
         );
       }
 
-      // Issue #268: Track parameter modification for auto-const inference (array element)
-      if (this.context.currentParameters.has(arrayName)) {
-        this.context.modifiedParameters.add(arrayName);
-      }
+      // Issue #558: Parameter modification tracking removed - uses analysis-phase results
     }
 
     // Check member access on const struct - validate the root is not const
@@ -6978,10 +7117,7 @@ export default class CodeGenerator implements IOrchestrator {
           throw new Error(`${constError} (member access)`);
         }
 
-        // Issue #268: Track parameter modification for auto-const inference (member access)
-        if (this.context.currentParameters.has(rootName)) {
-          this.context.modifiedParameters.add(rootName);
-        }
+        // Issue #558: Parameter modification tracking removed - uses analysis-phase results
 
         // ADR-013: Check for read-only register members (ro = implicitly const)
         if (identifiers.length >= 2) {
@@ -7124,7 +7260,8 @@ export default class CodeGenerator implements IOrchestrator {
           !paramInfo.isStruct &&
           this._isKnownPrimitive(paramInfo.baseType)
         ) {
-          return `(*${id})`;
+          // Issue #558: In C++ mode, primitives that become references don't need dereferencing
+          return this.cppMode ? id : `(*${id})`;
         }
         return id;
       }
@@ -8657,7 +8794,8 @@ export default class CodeGenerator implements IOrchestrator {
           !paramInfo.isStruct &&
           this._isKnownPrimitive(paramInfo.baseType)
         ) {
-          return `(*${id})`;
+          // Issue #558: In C++ mode, primitives that become references don't need dereferencing
+          return this.cppMode ? id : `(*${id})`;
         }
         return id;
       }

package/src/pipeline/Pipeline.ts

@@ -82,6 +82,17 @@ class Pipeline {
    * Used to include C headers in generated .h files instead of forward-declaring types.
    */
   private readonly headerIncludeDirectives: Map<string, string> = new Map();
+  /**
+   * Issue #558: Accumulated parameter modifications across all processed files.
+   * Used for cross-file const inference in C++ mode.
+   */
+  private readonly accumulatedModifications: Map<string, Set<string>> =
+    new Map();
+  /**
+   * Issue #558: Accumulated function parameter lists across all processed files.
+   * Used for cross-file const inference transitive propagation.
+   */
+  private readonly accumulatedParamLists: Map<string, string[]> = new Map();
 
   constructor(config: IPipelineConfig) {
     // Apply defaults
@@ -137,6 +148,10 @@ class Pipeline {
         await this.cacheManager.initialize();
       }
 
+      // Issue #558: Reset cross-file modification tracking for new run
+      this.accumulatedModifications.clear();
+      this.accumulatedParamLists.clear();
+
       // Stage 1: Discover source files
       const { cnextFiles, headerFiles } = await this.discoverSources();
 
@@ -146,6 +161,15 @@ class Pipeline {
         return result;
       }
 
+      // Issue #558: Sort files by dependency order for correct cross-file const inference.
+      // Files that are included by others should be processed first so their
+      // parameter modifications are available during transitive propagation.
+      // Simple heuristic: reverse the discovery order since includes are added
+      // after the files that include them.
+      if (this.cppDetected) {
+        cnextFiles.reverse();
+      }
+
       // Ensure output directory exists if specified
       if (this.config.outDir && !existsSync(this.config.outDir)) {
         mkdirSync(this.config.outDir, { recursive: true });
@@ -575,6 +599,7 @@ class Pipeline {
 
   /**
    * Stage 3: Collect symbols from a C-Next file
+   * Issue #561: Also collects modification analysis in C++ mode for unified cross-file const inference
    */
   private collectCNextSymbols(file: IDiscoveredFile): void {
     const content = readFileSync(file.path, "utf-8");
@@ -616,6 +641,32 @@ class Pipeline {
     // This ensures enum member info is available for all files before code generation
     const symbolInfo = TSymbolInfoAdapter.convert(tSymbols);
     this.symbolInfoByFile.set(file.path, symbolInfo);
+
+    // Issue #561: Collect modification analysis in C++ mode for cross-file const inference
+    // This unifies behavior between run() and transpileSource() code paths
+    if (this.cppDetected) {
+      const { modifications, paramLists } =
+        this.codeGenerator.analyzeModificationsOnly(tree);
+
+      // Accumulate modifications
+      for (const [funcName, params] of modifications) {
+        const existing = this.accumulatedModifications.get(funcName);
+        if (existing) {
+          for (const param of params) {
+            existing.add(param);
+          }
+        } else {
+          this.accumulatedModifications.set(funcName, new Set(params));
+        }
+      }
+
+      // Accumulate param lists
+      for (const [funcName, params] of paramLists) {
+        if (!this.accumulatedParamLists.has(funcName)) {
+          this.accumulatedParamLists.set(funcName, [...params]);
+        }
+      }
+    }
   }
 
   /**
@@ -788,6 +839,14 @@ class Pipeline {
         );
       }
 
+      // Issue #558: Inject cross-file data for const inference
+      if (this.cppDetected && this.accumulatedModifications.size > 0) {
+        this.codeGenerator.setCrossFileModifications(
+          this.accumulatedModifications,
+          this.accumulatedParamLists,
+        );
+      }
+
       const code = this.codeGenerator.generate(
         tree,
         this.symbolTable,
@@ -822,6 +881,27 @@ class Pipeline {
       }
       this.passByValueParamsCollectors.set(file.path, passByValueCopy);
 
+      // Issue #558: Collect modifications and param lists for cross-file const inference
+      if (this.cppDetected) {
+        const fileModifications = this.codeGenerator.getModifiedParameters();
+        for (const [funcName, params] of fileModifications) {
+          const existing = this.accumulatedModifications.get(funcName);
+          if (existing) {
+            for (const param of params) {
+              existing.add(param);
+            }
+          } else {
+            this.accumulatedModifications.set(funcName, new Set(params));
+          }
+        }
+        const fileParamLists = this.codeGenerator.getFunctionParamLists();
+        for (const [funcName, params] of fileParamLists) {
+          if (!this.accumulatedParamLists.has(funcName)) {
+            this.accumulatedParamLists.set(funcName, [...params]);
+          }
+        }
+      }
+
       // Issue #424: Store user includes for header generation
       // These may define macros used in array dimensions
       // Issue #461: Transform .cnx includes to .h for header generation
@@ -1188,6 +1268,11 @@ class Pipeline {
         await this.cacheManager.initialize();
       }
 
+      // Issue #561: Clear cross-file modification tracking for fresh analysis
+      // This ensures each transpileSource() call starts with a clean slate
+      this.accumulatedModifications.clear();
+      this.accumulatedParamLists.clear();
+
       // Step 1: Build search paths using unified IncludeResolver
       const searchPaths = IncludeResolver.buildSearchPaths(
         workingDir,
@@ -1362,6 +1447,15 @@ class Pipeline {
         );
       }
 
+      // Issue #561: Inject cross-file modification data for const inference
+      // This unifies behavior with run() - both paths now share modifications from includes
+      if (this.cppDetected && this.accumulatedModifications.size > 0) {
+        this.codeGenerator.setCrossFileModifications(
+          this.accumulatedModifications,
+          this.accumulatedParamLists,
+        );
+      }
+
       const code = this.codeGenerator.generate(
         tree,
         this.symbolTable,

package/src/project/Project.ts

@@ -63,6 +63,13 @@ class Project {
    * Compile the project
    */
   async compile(): Promise<IProjectResult> {
+    // Issue #558: For C++ mode, use Pipeline.run() to enable cross-file const inference.
+    // This is needed because struct parameters passed to modifying functions in other
+    // files must not be marked const.
+    if (this.config.cppRequired) {
+      return this.compileWithPipeline();
+    }
+
     // Compile each input file individually to avoid cross‑file symbol leakage.
     const results: any[] = [];
     // Build the full list of .cnx/.cnext files from srcDirs and explicit files
@@ -175,6 +182,30 @@ class Project {
 
     return aggregate;
   }
+
+  /**
+   * Issue #558: Compile using Pipeline.run() for cross-file const inference in C++ mode.
+   */
+  private async compileWithPipeline(): Promise<IProjectResult> {
+    const pipelineResult = await this.pipeline.run();
+
+    // Convert Pipeline result to Project result format
+    return {
+      success: pipelineResult.success,
+      filesProcessed: pipelineResult.filesProcessed,
+      symbolsCollected: pipelineResult.symbolsCollected,
+      conflicts: pipelineResult.conflicts,
+      errors: pipelineResult.errors.map((e) => {
+        if (typeof e === "string") return e;
+        const path = (e as any).sourcePath ?? "";
+        return path
+          ? `${path}:${e.line}:${e.column} ${e.message}`
+          : `${e.line}:${e.column} ${e.message}`;
+      }),
+      warnings: pipelineResult.warnings,
+      outputFiles: pipelineResult.outputFiles,
+    };
+  }
   /**
    * Get the symbol table (for testing/inspection)
    */