c-next 0.2.13 → 0.2.14

package/package.json

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

package/src/cli/ArgParser.ts

@@ -42,10 +42,8 @@ function configureYargs(args: string[], argv: string[]) {
       .scriptName("cnext")
       .usage(
         `Usage:
-  cnext <file.cnx>                          Single file (outputs file.c)
+  cnext <file.cnx>                          Entry point file (follows includes)
   cnext <file.cnx> -o <output.c>            Single file with explicit output
-  cnext <files...> -o <dir>                 Multi-file mode
-  cnext <dir>                               Directory mode (recursive)
 
 A safer C for embedded systems development.`,
       )
@@ -156,10 +154,8 @@ A safer C for embedded systems development.`,
       // Config file documentation (shown in help)
       .epilogue(
         `Examples:
-  cnext main.cnx                            # Outputs main.c (same dir)
+  cnext src/main.cnx                        # Entry point (follows includes)
   cnext main.cnx -o build/main.c            # Explicit output path
-  cnext src/*.cnx -o build/                 # Multiple files to directory
-  cnext src/                                # Compile all .cnx files in src/ (recursive)
 
 Target platforms: teensy41, cortex-m7, cortex-m4, cortex-m3, cortex-m0+, cortex-m0, avr
 

package/src/cli/PlatformIOCommand.ts

@@ -46,37 +46,36 @@ class PlatformIOCommand {
     // Create cnext_build.py script
     // Issue #833: Run transpilation at import time (before compilation),
     // not as a pre-action on buildprog (which runs after compilation)
-    const buildScript = `Import("env")
+    const buildScript = String.raw`Import("env")
 import subprocess
 import sys
 from pathlib import Path
 
 def transpile_cnext():
-    """Transpile all .cnx files before build"""
-    # Find all .cnx files in src directory
-    src_dir = Path("src")
-    if not src_dir.exists():
+    """Transpile from main.cnx entry point — cnext follows includes"""
+    entry = Path("src/main.cnx")
+    if not entry.exists():
         return
 
-    cnx_files = list(src_dir.rglob("*.cnx"))
-    if not cnx_files:
-        return
-
-    print(f"Transpiling {len(cnx_files)} c-next files...")
-
-    for cnx_file in cnx_files:
-        try:
-            result = subprocess.run(
-                ["cnext", str(cnx_file)],
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            print(f"  ✓ {cnx_file.name}")
-        except subprocess.CalledProcessError as e:
-            print(f"  ✗ Error: {cnx_file.name}")
-            print(e.stderr)
-            sys.exit(1)
+    print("Transpiling from main.cnx...")
+
+    try:
+        result = subprocess.run(
+            ["cnext", str(entry)],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        if result.stdout:
+            lines = result.stdout.strip().split("\n")
+            for line in lines:
+                if line.startswith(("Compiled", "Collected", "Generated")):
+                    print(f"  {line}")
+        print("  ✓ Transpilation complete")
+    except subprocess.CalledProcessError as e:
+        print(f"  ✗ Transpilation failed")
+        print(e.stderr)
+        sys.exit(1)
 
 # Run transpilation at import time (before compilation starts)
 transpile_cnext()
@@ -119,13 +118,12 @@ transpile_cnext()
     console.log("✓ PlatformIO integration configured!");
     console.log("");
     console.log("Next steps:");
-    console.log(
-      "  1. Create .cnx files in src/ (alongside your .c/.cpp files)",
-    );
-    console.log("  2. Run: pio run");
+    console.log("  1. Create src/main.cnx as your entry point");
+    console.log("  2. Use #include to pull in other .cnx files");
+    console.log("  3. Run: pio run");
     console.log("");
     console.log(
-      "The transpiler will automatically convert .cnx → .c before each build.",
+      "The transpiler will follow includes from main.cnx automatically.",
     );
     console.log("Commit both .cnx and generated .c files to version control.");
   }

package/src/cli/__tests__/PlatformIOCommand.test.ts

@@ -68,6 +68,29 @@ describe("PlatformIOCommand", () => {
       expect(scriptCall?.[1]).toContain("transpile_cnext");
     });
 
+    it("generates script that uses entry point, not per-file loop", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue("[env:esp32]\n");
+
+      PlatformIOCommand.install();
+
+      const writeCalls = vi.mocked(fs.writeFileSync).mock.calls;
+      const scriptCall = writeCalls.find((call) =>
+        (call[0] as string).includes("cnext_build.py"),
+      );
+
+      expect(scriptCall).toBeDefined();
+      const scriptContent = scriptCall?.[1] as string;
+
+      // Should use entry point approach
+      expect(scriptContent).toContain('Path("src/main.cnx")');
+      expect(scriptContent).toContain('["cnext", str(entry)]');
+
+      // Should NOT loop over individual .cnx files
+      expect(scriptContent).not.toContain("for cnx_file");
+      expect(scriptContent).not.toContain("rglob");
+    });
+
     it("generates script that runs at import time, not as buildprog pre-action (issue #833)", () => {
       // Issue #833: buildprog fires AFTER compilation, so transpile runs too late
       // The script should run transpilation at import time (before compilation)

package/src/transpiler/Transpiler.ts

@@ -491,7 +491,11 @@ class Transpiler {
     );
 
     // Resolve includes from source content
-    const resolver = new IncludeResolver(searchPaths, this.fs);
+    const resolver = new IncludeResolver(
+      searchPaths,
+      this.fs,
+      this.cppDetected,
+    );
     const resolved = resolver.resolve(source, sourcePath);
     this.warnings.push(...resolved.warnings);
 
@@ -864,7 +868,11 @@ class Transpiler {
     );
 
     // Resolve includes
-    const resolver = new IncludeResolver(searchPaths, this.fs);
+    const resolver = new IncludeResolver(
+      searchPaths,
+      this.fs,
+      this.cppDetected,
+    );
     const resolved = resolver.resolve(content, cnxFile.path);
 
     this._collectHeaders(resolved, cnextBaseNames, headerSet);

package/src/transpiler/data/IncludeResolver.ts

@@ -60,12 +60,21 @@ class IncludeResolver {
 
   private readonly resolvedPaths: Set<string> = new Set();
   private readonly fs: IFileSystem;
+  private readonly cppMode: boolean;
 
+  /**
+   * @param cppMode Controls .h vs .hpp extension for .cnx include directives.
+   *   Note: In the Transpiler, cppDetected may change after IncludeResolver runs
+   *   (e.g., when a .hpp header is discovered during Stage 2). HeaderGeneratorUtils
+   *   uses stem-based dedup to handle any resulting .h/.hpp mismatch.
+   */
   constructor(
     private readonly searchPaths: string[],
     fs: IFileSystem = defaultFs,
+    cppMode: boolean = false,
   ) {
     this.fs = fs;
+    this.cppMode = cppMode;
   }
 
   /**
@@ -164,7 +173,8 @@ class IncludeResolver {
       // Issue #854: Track header directive for cnext includes so their types
       // can be mapped by ExternalTypeHeaderBuilder, preventing duplicate
       // forward declarations (MISRA Rule 5.6)
-      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ".h");
+      const ext = this.cppMode ? ".hpp" : ".h";
+      const headerPath = includeInfo.path.replace(/\.cnx$|\.cnext$/, ext);
       const directive = includeInfo.isLocal
         ? `#include "${headerPath}"`
         : `#include <${headerPath}>`;

package/src/transpiler/data/__tests__/IncludeResolver.test.ts

@@ -315,6 +315,56 @@ describe("IncludeResolver", () => {
     });
   });
 
+  // ========================================================================
+  // C++ Mode (cppMode) — Issue: .hpp vs .h in headerIncludeDirectives
+  // ========================================================================
+
+  describe("cppMode header directive extension", () => {
+    it("should use .h extension for cnx includes in C mode (default)", () => {
+      const resolver = new IncludeResolver([includeDir]);
+      const content = '#include "shared.cnx"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "shared.h"');
+    });
+
+    it("should use .hpp extension for cnx includes in C++ mode", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = '#include "shared.cnx"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "shared.hpp"');
+    });
+
+    it("should use .hpp for angle-bracket cnx includes in C++ mode", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = "#include <shared.cnx>";
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe("#include <shared.hpp>");
+    });
+
+    it("should not affect C/C++ header directives (only cnx includes)", () => {
+      const resolver = new IncludeResolver([includeDir], undefined, true);
+      const content = '#include "types.h"';
+
+      const result = resolver.resolve(content);
+
+      const directives = [...result.headerIncludeDirectives.values()];
+      expect(directives).toHaveLength(1);
+      expect(directives[0]).toBe('#include "types.h"');
+    });
+  });
+
   // ========================================================================
   // Edge Cases
   // ========================================================================

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -289,22 +289,29 @@ class HeaderGeneratorUtils {
     }
 
     // External type header includes (skip duplicates of user includes)
-    // Note: headersToInclude comes from IncludeResolver which always produces .h
-    // (it runs before cppDetected is set). We need to match against userIncludes
-    // which may have .hpp in C++ mode, so normalize both for deduplication.
+    // Dedup by basename stem to handle:
+    // - Different path styles (e.g., <AppConfig.hpp> vs "../AppConfig.hpp")
+    // - Extension mismatch from timing (.h from IncludeResolver before cppDetected,
+    //   .hpp from IncludeExtractor after cppDetected)
     const userIncludeSet = new Set(options.userIncludes ?? []);
-    // Issue #941: Also add .h variants for dedup since headersToInclude uses .h
-    if (options.cppMode && options.userIncludes) {
-      for (const inc of options.userIncludes) {
-        // Add the .h version so we can match against headersToInclude
-        const hVersion = inc.replace(/\.hpp"/, '.h"').replace(/\.hpp>/, ".h>");
-        userIncludeSet.add(hVersion);
-      }
-    }
+    const extractStem = (inc: string): string => {
+      const match = /["<]([^">]+)[">]/.exec(inc);
+      if (!match) return inc;
+      return match[1].replace(/^.*\//, "").replace(/\.(?:h|hpp)$/, "");
+    };
+    const userIncludeStems = new Set(
+      (options.userIncludes ?? []).map(extractStem),
+    );
     for (const directive of headersToInclude) {
-      if (!userIncludeSet.has(directive)) {
-        lines.push(directive);
+      if (userIncludeSet.has(directive)) {
+        continue;
+      }
+      // Check if a user include already covers the same file
+      const stem = extractStem(directive);
+      if (stem && userIncludeStems.has(stem)) {
+        continue;
       }
+      lines.push(directive);
     }
 
     // Add blank line if any includes were added

package/src/transpiler/output/headers/__tests__/HeaderGeneratorUtils.test.ts

@@ -571,17 +571,31 @@ describe("HeaderGeneratorUtils", () => {
       expect(lines).toContain('#include "types.hpp"');
     });
 
-    it("deduplicates headersToInclude against userIncludes with .h/.hpp normalization in C++ mode", () => {
+    it("deduplicates headersToInclude against userIncludes by basename in C++ mode", () => {
       const result = HeaderGeneratorUtils.generateIncludes(
         {
-          userIncludes: ['#include "types.hpp"'],
+          userIncludes: ["#include <AppConfig.hpp>"],
+          cppMode: true,
+        },
+        new Set(['#include "../AppConfig.hpp"']),
+      );
+      // Should NOT have duplicate - different path styles for same file should dedup
+      const configIncludes = result.filter((l) => l.includes("AppConfig"));
+      expect(configIncludes).toEqual(["#include <AppConfig.hpp>"]);
+    });
+
+    it("deduplicates .h vs .hpp extension mismatch from timing difference", () => {
+      // IncludeExtractor produces .hpp (after cppDetected), IncludeResolver
+      // produces .h (before cppDetected) — stem-based dedup handles this
+      const result = HeaderGeneratorUtils.generateIncludes(
+        {
+          userIncludes: ["#include <Display/AppData.hpp>"],
           cppMode: true,
         },
-        new Set(['#include "types.h"']),
+        new Set(["#include <Display/AppData.h>"]),
       );
-      // Should NOT have duplicate - the .h version should be filtered
-      const typeIncludes = result.filter((l) => l.includes("types"));
-      expect(typeIncludes).toEqual(['#include "types.hpp"']);
+      const appDataIncludes = result.filter((l) => l.includes("AppData"));
+      expect(appDataIncludes).toEqual(["#include <Display/AppData.hpp>"]);
     });
   });