c-next 0.2.12 → 0.2.13

package/src/transpiler/Transpiler.ts

@@ -45,6 +45,8 @@ import IncludeResolver from "./data/IncludeResolver";
 import IncludeTreeWalker from "./data/IncludeTreeWalker";
 import DependencyGraph from "./data/DependencyGraph";
 import PathResolver from "./data/PathResolver";
+import InputExpansion from "./data/InputExpansion";
+import CppEntryPointScanner from "./data/CppEntryPointScanner";
 
 import ParserUtils from "../utils/ParserUtils";
 import ITranspilerConfig from "./types/ITranspilerConfig";
@@ -92,7 +94,7 @@ class Transpiler {
     this.fs = fs ?? new NodeFileSystem();
     // Apply defaults
     this.config = {
-      inputs: config.inputs,
+      input: config.input,
       includeDirs: config.includeDirs ?? [],
       outDir: config.outDir ?? "",
       headerOutDir: config.headerOutDir ?? "",
@@ -118,7 +120,7 @@ class Transpiler {
     // Issue #586: Initialize path resolver
     this.pathResolver = new PathResolver(
       {
-        inputs: this.config.inputs,
+        inputs: [dirname(resolve(this.config.input))],
         outDir: this.config.outDir,
         headerOutDir: this.config.headerOutDir,
         basePath: this.config.basePath,
@@ -395,12 +397,17 @@ class Transpiler {
       this._setupCrossFileModifications();
 
       // Generate code
+      // Use file's sourceRelativePath (source mode) or compute from PathResolver (files mode)
+      const sourceRelativePath =
+        file.sourceRelativePath ??
+        this.pathResolver.getSourceRelativePath(sourcePath);
       const code = this.codeGenerator.generate(tree, tokenStream, {
         debugMode: this.config.debugMode,
         target: this.config.target,
         sourcePath,
         cppMode: this.cppDetected,
         symbolInfo,
+        sourceRelativePath,
       });
 
       // Collect user includes
@@ -535,6 +542,7 @@ class Transpiler {
     );
 
     // Build the main file (with in-memory source and cnextIncludes for enum resolution)
+    // Source mode uses basename for self-include to match files mode behavior
     const mainFile: IPipelineFile = {
       path: sourcePath,
       source,
@@ -544,6 +552,7 @@ class Transpiler {
         extension: ".cnx",
       },
       cnextIncludes: resolved.cnextIncludes,
+      sourceRelativePath: basename(sourcePath),
     };
 
     // Includes first (symbols must be collected before main file code gen),
@@ -753,41 +762,6 @@ class Transpiler {
   /**
    * Discover C-Next files from a single input (file or directory).
    */
-  private _discoverCNextFromInput(
-    input: string,
-    cnextFiles: IDiscoveredFile[],
-    fileByPath: Map<string, IDiscoveredFile>,
-  ): void {
-    const resolvedInput = resolve(input);
-
-    if (!this.fs.exists(resolvedInput)) {
-      throw new Error(`Input not found: ${input}`);
-    }
-
-    const file = FileDiscovery.discoverFile(resolvedInput, this.fs);
-    if (file?.type === EFileType.CNext) {
-      cnextFiles.push(file);
-      fileByPath.set(resolve(file.path), file);
-      return;
-    }
-
-    if (file?.type !== EFileType.Unknown && file !== null) {
-      // Other supported file type (direct header input) - skip for now
-      return;
-    }
-
-    // It's a directory - scan for C-Next files
-    const discovered = FileDiscovery.discover(
-      [resolvedInput],
-      { recursive: true },
-      this.fs,
-    );
-    for (const f of FileDiscovery.getCNextFiles(discovered)) {
-      cnextFiles.push(f);
-      fileByPath.set(resolve(f.path), f);
-    }
-  }
-
   /**
    * Collect headers from resolved includes, filtering out generated ones.
    */
@@ -935,19 +909,89 @@ class Transpiler {
    * includes, not by blindly scanning include directories.
    */
   private async _discoverFromFiles(): Promise<IPipelineInput> {
-    // Step 1: Discover C-Next files from inputs (files or directories)
+    const entryPath = resolve(this.config.input);
+
+    // Check if this is a C/C++ entry point
+    if (InputExpansion.isCppEntryPoint(entryPath)) {
+      return this._discoverFromCppEntryPoint(entryPath);
+    }
+
+    // Step 1: Discover entry point file (original .cnx entry point logic)
     const cnextFiles: IDiscoveredFile[] = [];
     const fileByPath = new Map<string, IDiscoveredFile>();
 
-    for (const input of this.config.inputs) {
-      this._discoverCNextFromInput(input, cnextFiles, fileByPath);
+    const entryFile = FileDiscovery.discoverFile(entryPath, this.fs);
+    if (entryFile?.type !== EFileType.CNext) {
+      return { cnextFiles: [], headerFiles: [], writeOutputToDisk: true };
     }
+    cnextFiles.push(entryFile);
+    fileByPath.set(resolve(entryFile.path), entryFile);
+
+    // Step 2: Build dependency graph, resolve headers, and return pipeline input
+    return this._buildPipelineInput(cnextFiles, fileByPath);
+  }
 
-    if (cnextFiles.length === 0) {
+  /**
+   * Discover C-Next files from a C/C++ entry point.
+   *
+   * Scans the include tree for headers with C-Next generation markers,
+   * extracts the source .cnx paths, and returns them for transpilation.
+   */
+  private _discoverFromCppEntryPoint(entryPath: string): IPipelineInput {
+    const entryDir = dirname(entryPath);
+    const searchPaths = IncludeResolver.buildSearchPaths(
+      entryDir,
+      this.config.includeDirs,
+      [],
+      undefined,
+      this.fs,
+    );
+
+    const scanner = new CppEntryPointScanner(searchPaths, this.fs);
+    const scanResult = scanner.scan(entryPath);
+
+    // Report errors and warnings
+    // Prefix errors to distinguish from informational warnings
+    for (const error of scanResult.errors) {
+      this.warnings.push(`Error: ${error}`);
+    }
+    this.warnings.push(...scanResult.warnings);
+
+    if (scanResult.noCNextFound) {
       return { cnextFiles: [], headerFiles: [], writeOutputToDisk: true };
     }
 
-    // Step 2: For each C-Next file, resolve its #include directives
+    // Convert discovered .cnx paths to IDiscoveredFile array
+    const cnextFiles: IDiscoveredFile[] = scanResult.cnextSources.map(
+      (path) => ({
+        path,
+        type: EFileType.CNext,
+        extension: ".cnx",
+      }),
+    );
+
+    // Build fileByPath map for dependency resolution
+    const fileByPath = new Map<string, IDiscoveredFile>();
+    for (const cnxFile of cnextFiles) {
+      fileByPath.set(resolve(cnxFile.path), cnxFile);
+    }
+
+    // Scanner discovers .cnx files via header markers in the C/C++ include tree.
+    // _buildPipelineInput then resolves direct .cnx-to-.cnx includes (e.g.,
+    // #include "utils.cnx") which the scanner visits but doesn't add to sources.
+    return this._buildPipelineInput(cnextFiles, fileByPath);
+  }
+
+  /**
+   * Shared helper: Build pipeline input from discovered C-Next files.
+   *
+   * Processes includes, builds dependency graph, resolves headers transitively,
+   * and converts to pipeline files. Used by both .cnx and C/C++ entry point paths.
+   */
+  private _buildPipelineInput(
+    cnextFiles: IDiscoveredFile[],
+    fileByPath: Map<string, IDiscoveredFile>,
+  ): IPipelineInput {
     const headerSet = new Map<string, IDiscoveredFile>();
     const depGraph = new DependencyGraph();
     const cnextBaseNames = new Set(
@@ -1381,6 +1425,7 @@ class Transpiler {
       typeInputWithSymbolTable,
       passByValueParams,
       allKnownEnums,
+      basename(sourcePath),
     );
   }
 
@@ -1595,7 +1640,7 @@ class Transpiler {
    */
   private determineProjectRoot(): string | undefined {
     // Start from first input
-    const firstInput = this.config.inputs[0];
+    const firstInput = this.config.input;
     if (!firstInput) {
       return undefined;
     }

package/src/transpiler/__tests__/DualCodePaths.test.ts

@@ -26,9 +26,9 @@ describe("Dual Code Paths (Issue #634)", () => {
     rmSync(tempDir, { recursive: true, force: true });
   });
 
-  function createTranspiler(inputs: string[]): Transpiler {
+  function createTranspiler(input: string): Transpiler {
     const config: ITranspilerConfig = {
-      inputs,
+      input,
       includeDirs: [tempDir],
       outDir: tempDir,
       headerOutDir: tempDir,
@@ -53,11 +53,11 @@ void main() {
       writeFileSync(filePath, source);
 
       // Path 1: Via run()
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
       // Path 2: Via transpileSource()
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -89,10 +89,10 @@ void main() {
       const filePath = join(tempDir, "structs.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -119,10 +119,10 @@ void main() {
       const filePath = join(tempDir, "const-array.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -155,10 +155,10 @@ void main() {
       const filePath = join(tempDir, "enums.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -195,10 +195,10 @@ void main() {
       const filePath = join(tempDir, "scopes.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -246,7 +246,7 @@ void main() {
       writeFileSync(mainPath, mainSource);
 
       // run() should handle cross-file references
-      const transpiler = createTranspiler([mainPath]);
+      const transpiler = createTranspiler(mainPath);
       const result = await transpiler.transpile({ kind: "files" });
 
       expect(result.success).toBe(true);
@@ -283,7 +283,7 @@ void main() {
       const mainPath = join(tempDir, "main.cnx");
       writeFileSync(mainPath, mainSource);
 
-      const transpiler = createTranspiler([mainPath]);
+      const transpiler = createTranspiler(mainPath);
       const result = await transpiler.transpile({ kind: "files" });
 
       expect(result.success).toBe(true);
@@ -310,7 +310,7 @@ void main() {
       const mainPath = join(tempDir, "main.cnx");
       writeFileSync(mainPath, mainSource);
 
-      const transpiler = createTranspiler([mainPath]);
+      const transpiler = createTranspiler(mainPath);
       const result = await transpiler.transpile({ kind: "files" });
 
       expect(result.success).toBe(true);
@@ -347,7 +347,7 @@ void main() {
       writeFileSync(consumerPath, consumerSource);
 
       // Via run()
-      const transpiler1 = createTranspiler([consumerPath]);
+      const transpiler1 = createTranspiler(consumerPath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
       expect(result1.success).toBe(true);
@@ -362,7 +362,7 @@ void main() {
       expect(consumerFile!.code).toContain("Consumer_fetch()");
 
       // Via transpileSource() with context from run()
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -406,7 +406,7 @@ void main() {
       writeFileSync(writerPath, writerSource);
 
       // Via run()
-      const transpiler1 = createTranspiler([writerPath]);
+      const transpiler1 = createTranspiler(writerPath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
       expect(result1.success).toBe(true);
@@ -419,7 +419,7 @@ void main() {
       expect(writerFile!.code).toContain("Storage_value = data");
 
       // Via transpileSource()
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -447,7 +447,7 @@ void main() {}
 `;
 
       // Two separate standalone transpileSource calls
-      const transpiler = createTranspiler([]);
+      const transpiler = createTranspiler("");
 
       const result1 = (
         await transpiler.transpile({
@@ -482,7 +482,7 @@ void main() {}
       const filePath = join(tempDir, "test.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler = createTranspiler([filePath]);
+      const transpiler = createTranspiler(filePath);
 
       // First run
       const result1 = await transpiler.transpile({ kind: "files" });
@@ -520,10 +520,10 @@ void main() {
       const filePath = join(tempDir, "same-file-struct.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -564,10 +564,10 @@ void main() {
       const filePath = join(tempDir, "same-file-enum.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -607,10 +607,10 @@ void main() {
       const filePath = join(tempDir, "nested-struct.cnx");
       writeFileSync(filePath, source);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = (
         await transpiler2.transpile({
           kind: "source",
@@ -634,10 +634,10 @@ u8 x <- ;  // Parse error: missing expression
       const filePath = join(tempDir, "invalid.cnx");
       writeFileSync(filePath, invalidSource);
 
-      const transpiler1 = createTranspiler([filePath]);
+      const transpiler1 = createTranspiler(filePath);
       const result1 = await transpiler1.transpile({ kind: "files" });
 
-      const transpiler2 = createTranspiler([]);
+      const transpiler2 = createTranspiler("");
       const result2 = await transpiler2.transpile({
         kind: "source",
         source: invalidSource,