c-next 0.1.21 → 0.1.23

package/README.md

@@ -77,6 +77,12 @@ cnext examples/blink.cnx --cpp
 # Target platform for atomic code generation (ADR-049)
 cnext examples/blink.cnx --target teensy41
 
+# Separate output directories for code and headers
+cnext src/ -o build/src --header-out build/include
+
+# Clean generated files
+cnext src/ -o build/src --header-out build/include --clean
+
 # Show all options
 cnext --help
 ```

package/package.json

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

package/src/commands/CleanCommand.ts

@@ -0,0 +1,148 @@
+/**
+ * CleanCommand
+ * Deletes generated files (.c, .cpp, .h, .hpp) that have matching .cnx sources
+ */
+
+import { basename, join, relative, resolve } from "path";
+import { existsSync, statSync, unlinkSync } from "fs";
+import InputExpansion from "../lib/InputExpansion";
+
+/**
+ * Command to clean generated output files
+ */
+class CleanCommand {
+  /**
+   * Execute the clean command
+   *
+   * @param inputs - Input files or directories (source locations)
+   * @param outDir - Output directory for code files
+   * @param headerOutDir - Optional separate output directory for headers
+   */
+  static execute(
+    inputs: string[],
+    outDir: string,
+    headerOutDir?: string,
+  ): void {
+    // If no outDir specified, we can't determine where to clean
+    if (!outDir) {
+      console.log("No output directory specified. Nothing to clean.");
+      return;
+    }
+
+    // Discover all .cnx files
+    let cnxFiles: string[];
+    try {
+      cnxFiles = InputExpansion.expandInputs(inputs);
+    } catch (error) {
+      console.error(`Error: ${error}`);
+      return;
+    }
+
+    if (cnxFiles.length === 0) {
+      console.log("No .cnx files found. Nothing to clean.");
+      return;
+    }
+
+    const resolvedOutDir = resolve(outDir);
+    const resolvedHeaderDir = headerOutDir
+      ? resolve(headerOutDir)
+      : resolvedOutDir;
+
+    let deletedCount = 0;
+
+    // For each .cnx file, calculate and delete generated files
+    for (const cnxFile of cnxFiles) {
+      const baseName = basename(cnxFile).replace(/\.cnx$|\.cnext$/, "");
+
+      // Calculate relative path from input directories
+      const relativePath = this.getRelativePath(cnxFile, inputs);
+
+      // Code files (.c and .cpp) go to outDir
+      const codeExtensions = [".c", ".cpp"];
+      for (const ext of codeExtensions) {
+        const outputPath = relativePath
+          ? join(resolvedOutDir, relativePath.replace(/\.cnx$|\.cnext$/, ext))
+          : join(resolvedOutDir, baseName + ext);
+
+        if (this.deleteIfExists(outputPath)) {
+          deletedCount++;
+        }
+      }
+
+      // Header files (.h and .hpp) go to headerOutDir
+      const headerExtensions = [".h", ".hpp"];
+      for (const ext of headerExtensions) {
+        const headerPath = relativePath
+          ? join(
+              resolvedHeaderDir,
+              relativePath.replace(/\.cnx$|\.cnext$/, ext),
+            )
+          : join(resolvedHeaderDir, baseName + ext);
+
+        if (this.deleteIfExists(headerPath)) {
+          deletedCount++;
+        }
+      }
+    }
+
+    if (deletedCount === 0) {
+      console.log("No generated files found to delete.");
+    } else {
+      console.log(`Deleted ${deletedCount} generated file(s).`);
+    }
+  }
+
+  /**
+   * Get relative path of a file from input directories.
+   * Returns undefined if file is not under any input directory.
+   *
+   * When undefined is returned (e.g., for single file inputs), the caller
+   * falls back to using just the basename, which is correct behavior since
+   * there's no directory structure to preserve.
+   */
+  private static getRelativePath(
+    filePath: string,
+    inputs: string[],
+  ): string | undefined {
+    for (const input of inputs) {
+      const resolvedInput = resolve(input);
+
+      // Skip file inputs - only directories can establish relative structure.
+      // For single file inputs like "cnext myfile.cnx -o build", we return
+      // undefined and the caller uses baseName, which is the correct behavior.
+      if (existsSync(resolvedInput) && statSync(resolvedInput).isFile()) {
+        continue;
+      }
+
+      const rel = relative(resolvedInput, filePath);
+
+      // Check if file is under this input directory
+      if (rel && !rel.startsWith("..")) {
+        return rel;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Delete a file if it exists
+   * @returns true if file was deleted, false otherwise
+   */
+  private static deleteIfExists(filePath: string): boolean {
+    try {
+      unlinkSync(filePath);
+      console.log(`  Deleted: ${filePath}`);
+      return true;
+    } catch (err: unknown) {
+      // ENOENT means file doesn't exist - not an error for our purposes
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return false;
+      }
+      console.error(`  Failed to delete ${filePath}: ${err}`);
+      return false;
+    }
+  }
+}
+
+export default CleanCommand;

package/src/index.ts

@@ -4,6 +4,7 @@
  * A safer C for embedded systems development
  */
 
+import CleanCommand from "./commands/CleanCommand";
 import IncludeDiscovery from "./lib/IncludeDiscovery";
 import InputExpansion from "./lib/InputExpansion";
 import Project from "./project/Project";
@@ -107,6 +108,10 @@ function showHelp(): void {
   );
   console.log("  --no-preprocess    Don't run C preprocessor on headers");
   console.log("  --no-cache         Disable symbol cache (.cnx/ directory)");
+  console.log("  --header-out <dir> Output directory for header files");
+  console.log(
+    "  --clean            Delete generated files for all .cnx sources",
+  );
   console.log("  -D<name>[=value]   Define preprocessor macro");
   console.log("  --pio-install      Setup PlatformIO integration");
   console.log("  --pio-uninstall    Remove PlatformIO integration");
@@ -191,6 +196,7 @@ async function runUnifiedMode(
   verbose: boolean,
   cppRequired: boolean,
   noCache: boolean,
+  headerOutDir?: string,
 ): Promise<void> {
   // Step 1: Expand directories to .cnx files
   let files: string[];
@@ -255,6 +261,7 @@ async function runUnifiedMode(
     files,
     includeDirs: allIncludePaths,
     outDir,
+    headerOutDir,
     generateHeaders,
     preprocess,
     defines,
@@ -471,6 +478,8 @@ async function main(): Promise<void> {
   let preprocess = true;
   let verbose = false;
   let noCache = false;
+  let headerOutDir: string | undefined;
+  let cleanMode = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -489,6 +498,10 @@ async function main(): Promise<void> {
       preprocess = false;
     } else if (arg === "--no-cache") {
       noCache = true;
+    } else if (arg === "--header-out" && i + 1 < args.length) {
+      headerOutDir = args[++i];
+    } else if (arg === "--clean") {
+      cleanMode = true;
     } else if (arg.startsWith("-D")) {
       const define = arg.slice(2);
       const eqIndex = define.indexOf("=");
@@ -518,6 +531,12 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
+  // Clean mode: delete generated files and exit
+  if (cleanMode) {
+    CleanCommand.execute(inputFiles, outputPath, headerOutDir);
+    process.exit(0);
+  }
+
   await runUnifiedMode(
     inputFiles,
     outputPath,
@@ -528,6 +547,7 @@ async function main(): Promise<void> {
     verbose,
     cppRequired,
     noCache,
+    headerOutDir,
   );
 }
 

package/src/pipeline/Pipeline.ts

@@ -76,6 +76,7 @@ class Pipeline {
       inputs: config.inputs,
       includeDirs: config.includeDirs ?? [],
       outDir: config.outDir ?? "",
+      headerOutDir: config.headerOutDir ?? "",
       defines: config.defines ?? {},
       preprocess: config.preprocess ?? true,
       generateHeaders: config.generateHeaders ?? true,
@@ -137,6 +138,11 @@ class Pipeline {
         mkdirSync(this.config.outDir, { recursive: true });
       }
 
+      // Ensure header output directory exists if specified separately
+      if (this.config.headerOutDir && !existsSync(this.config.headerOutDir)) {
+        mkdirSync(this.config.headerOutDir, { recursive: true });
+      }
+
       // Stage 2: Collect symbols from C/C++ headers
       for (const file of headerFiles) {
         try {
@@ -363,6 +369,17 @@ class Pipeline {
     // The preprocessor expands/removes #include directives, so we need the original
     const originalContent = readFileSync(file.path, "utf-8");
 
+    // Issue #328: Skip headers generated by C-Next Transpiler
+    // During incremental migration, generated .h files may be discovered via #include
+    // recursion from C++ files. These headers contain the same symbols as their .cnx
+    // source files, so including them would cause false symbol conflicts.
+    if (originalContent.includes("Generated by C-Next Transpiler")) {
+      if (this.config.debugMode) {
+        console.log(`[DEBUG]   Skipping C-Next generated header: ${file.path}`);
+      }
+      return;
+    }
+
     // Issue #321: Recursively process #include directives in headers
     // This ensures symbols from nested headers (like Arduino's extern HardwareSerial Serial)
     // are properly collected even when included transitively
@@ -537,7 +554,9 @@ class Pipeline {
       throw new Error(errors.join("\n"));
     }
 
-    const collector = new CNextSymbolCollector(file.path);
+    // Issue #332: Pass symbolTable to collector so struct fields are registered
+    // This enables TypeResolver.isStructType() to identify C-Next structs from included files
+    const collector = new CNextSymbolCollector(file.path, this.symbolTable);
     const symbols = collector.collect(tree);
     this.symbolTable.addSymbols(symbols);
   }
@@ -794,10 +813,14 @@ class Pipeline {
 
   /**
    * Get output path for a header file
+   * Uses headerOutDir if specified, otherwise falls back to outDir
    */
   private getHeaderOutputPath(file: IDiscoveredFile): string {
     const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
 
+    // Use headerOutDir if specified, otherwise fall back to outDir
+    const headerDir = this.config.headerOutDir || this.config.outDir;
+
     // Check if file is in any input directory (for preserving structure)
     for (const input of this.config.inputs) {
       const resolvedInput = resolve(input);
@@ -812,7 +835,7 @@ class Pipeline {
       // Check if file is under this input directory
       if (relativePath && !relativePath.startsWith("..")) {
         const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ".h");
-        const outputPath = join(this.config.outDir, outputRelative);
+        const outputPath = join(headerDir, outputRelative);
 
         const outputDir = dirname(outputPath);
         if (!existsSync(outputDir)) {
@@ -823,8 +846,8 @@ class Pipeline {
       }
     }
 
-    // Fallback: flat output in outDir
-    return join(this.config.outDir, headerName);
+    // Fallback: flat output in headerDir
+    return join(headerDir, headerName);
   }
 
   /**

package/src/pipeline/types/IPipelineConfig.ts

@@ -14,6 +14,9 @@ interface IPipelineConfig {
   /** Output directory for generated files (defaults to same as input) */
   outDir?: string;
 
+  /** Separate output directory for header files (defaults to outDir) */
+  headerOutDir?: string;
+
   /** Preprocessor defines for C/C++ headers */
   defines?: Record<string, string | boolean>;
 

package/src/project/FileDiscovery.ts

@@ -31,6 +31,9 @@ const EXTENSION_MAP: Record<string, EFileType> = {
 class FileDiscovery {
   /**
    * Discover files in the given directories
+   *
+   * Issue #331: Uses a Set to track discovered file paths and avoid duplicates
+   * when overlapping directories are provided (e.g., both src/Display and src).
    */
   static discover(
     directories: string[],
@@ -44,6 +47,8 @@ class FileDiscovery {
       /\.build/,
       /\.pio/,
     ];
+    // Issue #331: Track discovered paths to avoid duplicates from overlapping dirs
+    const discoveredPaths = new Set<string>();
 
     for (const dir of directories) {
       const resolvedDir = resolve(dir);
@@ -59,6 +64,7 @@ class FileDiscovery {
         recursive,
         options.extensions,
         excludePatterns,
+        discoveredPaths,
       );
     }
 
@@ -131,6 +137,9 @@ class FileDiscovery {
 
   /**
    * Scan a directory for source files
+   *
+   * Issue #331: discoveredPaths parameter tracks already-discovered files
+   * to avoid duplicates when scanning overlapping directories.
    */
   private static scanDirectory(
     dir: string,
@@ -138,6 +147,7 @@ class FileDiscovery {
     recursive: boolean,
     extensions: string[] | undefined,
     excludePatterns: RegExp[],
+    discoveredPaths: Set<string>,
   ): void {
     let entries: string[];
 
@@ -171,9 +181,15 @@ class FileDiscovery {
             recursive,
             extensions,
             excludePatterns,
+            discoveredPaths,
           );
         }
       } else if (stats.isFile()) {
+        // Issue #331: Skip already-discovered files (from overlapping directories)
+        if (discoveredPaths.has(fullPath)) {
+          continue;
+        }
+
         const ext = extname(fullPath).toLowerCase();
 
         // Check extension filter
@@ -183,6 +199,7 @@ class FileDiscovery {
 
         const type = EXTENSION_MAP[ext];
         if (type) {
+          discoveredPaths.add(fullPath);
           files.push({
             path: fullPath,
             type,

package/src/project/Project.ts

@@ -46,6 +46,7 @@ class Project {
       inputs,
       includeDirs: this.config.includeDirs,
       outDir: this.config.outDir,
+      headerOutDir: this.config.headerOutDir,
       defines: this.config.defines,
       preprocess: this.config.preprocess,
       generateHeaders: this.config.generateHeaders,

package/src/project/types/IProjectConfig.ts

@@ -14,6 +14,9 @@ interface IProjectConfig {
   /** Output directory for generated files */
   outDir: string;
 
+  /** Separate output directory for header files (defaults to outDir) */
+  headerOutDir?: string;
+
   /** Specific files to compile (overrides srcDirs) */
   files?: string[];
 

package/src/symbols/CNextSymbolCollector.ts

@@ -7,6 +7,7 @@ import * as Parser from "../parser/grammar/CNextParser";
 import ISymbol from "../types/ISymbol";
 import ESymbolKind from "../types/ESymbolKind";
 import ESourceLanguage from "../types/ESourceLanguage";
+import SymbolTable from "./SymbolTable";
 
 /**
  * Collects symbols from a C-Next parse tree
@@ -16,8 +17,12 @@ class CNextSymbolCollector {
 
   private symbols: ISymbol[] = [];
 
-  constructor(sourceFile: string) {
+  // Issue #332: Optional SymbolTable to register struct fields for isStructType() lookup
+  private symbolTable: SymbolTable | null;
+
+  constructor(sourceFile: string, symbolTable?: SymbolTable) {
     this.sourceFile = sourceFile;
+    this.symbolTable = symbolTable ?? null;
   }
 
   /**
@@ -166,6 +171,45 @@ class CNextSymbolCollector {
       sourceLanguage: ESourceLanguage.CNext,
       isExported: true,
     });
+
+    // Issue #332: Register struct fields in SymbolTable for isStructType() lookup
+    // This enables TypeResolver to identify C-Next structs from included files
+    // when determining if & should be added for pointer parameters
+    if (this.symbolTable) {
+      for (const member of struct.structMember()) {
+        const fieldName = member.IDENTIFIER().getText();
+        const fieldType = this.getTypeText(member.type());
+
+        // Check for array dimensions
+        const arrayDims = member.arrayDimension();
+        const dimensions: number[] = [];
+        for (const dim of arrayDims) {
+          const sizeExpr = dim.expression();
+          if (sizeExpr) {
+            const size = parseInt(sizeExpr.getText(), 10);
+            if (!isNaN(size)) {
+              dimensions.push(size);
+            }
+          }
+        }
+
+        this.symbolTable!.addStructField(
+          name,
+          fieldName,
+          fieldType,
+          dimensions.length > 0 ? dimensions : undefined,
+        );
+      }
+    }
+  }
+
+  /**
+   * Issue #332: Extract type text from a type context
+   * Simple extraction for struct field registration
+   */
+  private getTypeText(ctx: Parser.TypeContext | null): string {
+    if (!ctx) return "void";
+    return ctx.getText();
   }
 
   private collectRegister(reg: Parser.RegisterDeclarationContext): void {