c-next 0.1.49 → 0.1.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.49",
+  "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

@@ -1178,6 +1178,57 @@ export default class CodeGenerator implements IOrchestrator {
     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.
+   */
+  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 };
+  }
+
   /**
    * Issue #268: Check if a callee function's parameter at given index is modified.
    * Returns true if the callee modifies that parameter (should not have const).
@@ -2473,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

package/src/pipeline/Pipeline.ts

@@ -599,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");
@@ -640,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]);
+        }
+      }
+    }
   }
 
   /**
@@ -1241,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,
@@ -1415,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,