c-next 0.1.71 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.71",
+  "version": "0.2.0",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/Transpiler.ts

@@ -271,8 +271,8 @@ class Transpiler {
     // Stage 3b: Resolve external const array dimensions
     CodeGenState.symbolTable.resolveExternalArrayDimensions();
 
-    // Stage 4: Check for symbol conflicts (skipped in standalone mode)
-    if (!input.skipConflictCheck && !this._checkSymbolConflicts(result)) {
+    // Stage 4: Check for symbol conflicts
+    if (!this._checkSymbolConflicts(result)) {
       return;
     }
 
@@ -581,7 +581,6 @@ class Transpiler {
       cnextFiles: [...cnextIncludeFiles, mainFile],
       headerFiles: allHeaders,
       writeOutputToDisk: false,
-      skipConflictCheck: true,
     };
   }
 
@@ -1283,9 +1282,14 @@ class Transpiler {
       ? { ...typeInput, symbolTable: CodeGenState.symbolTable }
       : undefined;
 
-    // ADR-055 Phase 7: Convert TSymbol to IHeaderSymbol
-    // Note: In multi-file run() path, auto-const is already applied during transpilation
-    const headerSymbols = HeaderSymbolAdapter.fromTSymbols(exportedSymbols);
+    // ADR-055 Phase 7: Convert TSymbol to IHeaderSymbol with auto-const info
+    // Issue #817: Apply auto-const info same as generateHeaderContent() does
+    const unmodifiedParams = this.codeGenerator.getFunctionUnmodifiedParams();
+    const headerSymbols = this.convertToHeaderSymbols(
+      exportedSymbols,
+      unmodifiedParams,
+      allKnownEnums,
+    );
 
     const headerContent = this.headerGenerator.generate(
       headerSymbols,

package/src/transpiler/logic/symbols/SymbolTable.ts

@@ -627,14 +627,30 @@ class SymbolTable {
     }
 
     // Multiple definitions in same language (excluding overloads) = ERROR
+    // Issue #817: Group by scope AND kind - symbols in different scopes don't conflict,
+    // and symbols with different kinds (variable vs scope) don't conflict either
     if (cnextDefs.length > 1) {
-      const locations = cnextDefs.map((s) => `${s.sourceFile}:${s.sourceLine}`);
-      return {
-        symbolName: cnextDefs[0].name,
-        definitions: cnextDefs,
-        severity: "error",
-        message: `Symbol conflict: '${cnextDefs[0].name}' is defined multiple times in C-Next:\n  ${locations.join("\n  ")}`,
-      };
+      const byScopeAndKind = this.groupCNextSymbolsByScopeAndKind(cnextDefs);
+
+      // Check each scope+kind group for conflicts (multiple symbols in same scope with same kind)
+      for (const symbols of byScopeAndKind.values()) {
+        if (symbols.length > 1) {
+          const locations = symbols.map(
+            (s) => `${s.sourceFile}:${s.sourceLine}`,
+          );
+          const scopeName = symbols[0].scope.name;
+          const displayName =
+            scopeName === ""
+              ? symbols[0].name
+              : `${scopeName}.${symbols[0].name}`;
+          return {
+            symbolName: displayName,
+            definitions: symbols,
+            severity: "error",
+            message: `Symbol conflict: '${displayName}' is defined multiple times in C-Next:\n  ${locations.join("\n  ")}`,
+          };
+        }
+      }
     }
 
     // Same symbol in C and C++ - typically OK (same symbol)
@@ -645,6 +661,36 @@ class SymbolTable {
     return null;
   }
 
+  /**
+   * Issue #817: Group C-Next symbols by scope name and kind.
+   *
+   * Symbols in different scopes don't conflict (Foo.enabled vs Bar.enabled
+   * generate Foo_enabled and Bar_enabled). Symbols with different kinds also
+   * don't conflict (variable LED vs scope LED are distinct).
+   *
+   * @param symbols C-Next symbols to group (must all be TSymbol)
+   * @returns Map from "scopeName:kind" key to array of symbols
+   */
+  private groupCNextSymbolsByScopeAndKind(
+    symbols: TAnySymbol[],
+  ): Map<string, TSymbol[]> {
+    const byScopeAndKind = new Map<string, TSymbol[]>();
+
+    for (const def of symbols) {
+      const tSymbol = def as TSymbol;
+      const scopeName = tSymbol.scope.name;
+      const key = `${scopeName}:${tSymbol.kind}`;
+      const existing = byScopeAndKind.get(key);
+      if (existing) {
+        existing.push(tSymbol);
+      } else {
+        byScopeAndKind.set(key, [tSymbol]);
+      }
+    }
+
+    return byScopeAndKind;
+  }
+
   // ========================================================================
   // Struct Field Information
   // ========================================================================

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -322,6 +322,162 @@ describe("SymbolTable", () => {
 
       expect(symbolTable.hasConflict("overloaded")).toBe(false);
     });
+
+    // Issue #817: Scope-private members should NOT conflict across scopes
+    it("should NOT detect conflict for same-named members in different scopes", () => {
+      // Create two different named scopes
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
+      const barScope = TestScopeUtils.createMockScope("Bar", globalScope);
+
+      // Add 'enabled' variable in scope Foo
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "enabled",
+        sourceFile: "test.cnx",
+        sourceLine: 2,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
+      });
+
+      // Add 'enabled' variable in scope Bar
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "enabled",
+        sourceFile: "test.cnx",
+        sourceLine: 10,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: barScope,
+      });
+
+      // These are NOT conflicts - they generate Foo_enabled and Bar_enabled
+      expect(symbolTable.hasConflict("enabled")).toBe(false);
+    });
+
+    // Issue #817: Same-named functions in different scopes are not conflicts
+    it("should NOT detect conflict for same-named functions in different scopes", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
+      const barScope = TestScopeUtils.createMockScope("Bar", globalScope);
+
+      // Add 'initialize' function in scope Foo
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "initialize",
+        sourceFile: "test.cnx",
+        sourceLine: 4,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: fooScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // Add 'initialize' function in scope Bar
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "initialize",
+        sourceFile: "test.cnx",
+        sourceLine: 12,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: barScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // These generate Foo_initialize and Bar_initialize - no conflict
+      expect(symbolTable.hasConflict("initialize")).toBe(false);
+    });
+
+    // True conflicts: same name in same scope should still be detected
+    it("should detect conflict for same-named symbols in same scope", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const fooScope = TestScopeUtils.createMockScope("Foo", globalScope);
+
+      // Add 'duplicate' variable in scope Foo twice
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "duplicate",
+        sourceFile: "test.cnx",
+        sourceLine: 2,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
+      });
+
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "duplicate",
+        sourceFile: "test.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: false,
+        type: TTypeUtils.createPrimitive("bool"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: fooScope,
+      });
+
+      // Same name in SAME scope IS a conflict
+      expect(symbolTable.hasConflict("duplicate")).toBe(true);
+    });
+
+    // Global scope conflicts should still be detected
+    it("should detect conflict for same-named globals", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+
+      // Add two global variables with same name
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "globalVar",
+        sourceFile: "first.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: globalScope,
+      });
+
+      symbolTable.addTSymbol({
+        kind: "variable",
+        name: "globalVar",
+        sourceFile: "second.cnx",
+        sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        type: TTypeUtils.createPrimitive("u32"),
+        isArray: false,
+        isConst: false,
+        isAtomic: false,
+        scope: globalScope,
+      });
+
+      // Two globals with same name IS a conflict
+      expect(symbolTable.hasConflict("globalVar")).toBe(true);
+    });
   });
 
   // ========================================================================

package/src/transpiler/types/IPipelineInput.ts

@@ -15,9 +15,6 @@ interface IPipelineInput {
 
   /** Whether to write generated output to disk */
   readonly writeOutputToDisk: boolean;
-
-  /** Skip Stage 4 (symbol conflict check) — standalone mode doesn't need it */
-  readonly skipConflictCheck?: boolean;
 }
 
 export default IPipelineInput;