c-next 0.1.24 → 0.1.26

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -255,6 +255,12 @@ export default class CodeGenerator implements IOrchestrator {
   /** ADR-010: Source file path for validating includes */
   private sourcePath: string | null = null;
 
+  /** Issue #349: Include directories for resolving angle-bracket .cnx includes */
+  private includeDirs: string[] = [];
+
+  /** Issue #349: Input directories for calculating relative paths */
+  private inputs: string[] = [];
+
   /** Token stream for comment extraction (ADR-043) */
   private tokenStream: CommonTokenStream | null = null;
 
@@ -1309,6 +1315,10 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-010: Store source path for include validation
     this.sourcePath = options?.sourcePath ?? null;
 
+    // Issue #349: Store include directories and inputs for angle-bracket include resolution
+    this.includeDirs = options?.includeDirs ?? [];
+    this.inputs = options?.inputs ?? [];
+
     // Issue #250: Store C++ mode for temp variable generation
     this.cppMode = options?.cppMode ?? false;
     // Reset temp var state for each generation
@@ -1430,13 +1440,17 @@ export default class CodeGenerator implements IOrchestrator {
     // Issue #230: Self-include for extern "C" linkage
     // When file has public symbols and headers are being generated,
     // include own header to ensure proper C linkage
+    // Issue #339: Use relative path from source root when available
     if (
       options?.generateHeaders &&
       this.symbols!.hasPublicSymbols() &&
       this.sourcePath
     ) {
-      const basename = this.sourcePath.replace(/^.*[\\/]/, "");
-      const headerName = basename.replace(/\.cnx$|\.cnext$/, ".h");
+      // Issue #339: Prefer sourceRelativePath for correct directory structure
+      // Otherwise fall back to basename for backward compatibility
+      const pathToUse =
+        options.sourceRelativePath || this.sourcePath.replace(/^.*[\\/]/, "");
+      const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
       output.push(`#include "${headerName}"`);
       output.push("");
     }
@@ -1613,9 +1627,14 @@ export default class CodeGenerator implements IOrchestrator {
   /**
    * ADR-010: Transform #include directives, converting .cnx to .h
    * ADR-053 A5: Delegates to IncludeGenerator
+   * Issue #349: Now passes includeDirs and inputs for angle-bracket resolution
    */
   private transformIncludeDirective(includeText: string): string {
-    return includeTransformIncludeDirective(includeText, this.sourcePath);
+    return includeTransformIncludeDirective(includeText, {
+      sourcePath: this.sourcePath,
+      includeDirs: this.includeDirs,
+      inputs: this.inputs,
+    });
   }
 
   // Issue #63: validateIncludeNotImplementationFile moved to TypeValidator

package/src/codegen/HeaderGenerator.ts

@@ -268,7 +268,9 @@ class HeaderGenerator {
     passByValueParams?: TPassByValueParams,
   ): string | null {
     // Map return type from C-Next to C
-    const returnType = sym.type ? mapType(sym.type) : "void";
+    // Special case: main() always returns int for C/C++ compatibility
+    const mappedType = sym.type ? mapType(sym.type) : "void";
+    const returnType = sym.name === "main" ? "int" : mappedType;
 
     // Issue #269: Get pass-by-value parameter names for this function
     const passByValueSet = passByValueParams?.get(sym.name);

package/src/codegen/generators/support/IncludeGenerator.ts

@@ -6,22 +6,98 @@ import * as fs from "fs";
 import * as path from "path";
 import * as Parser from "../../../parser/grammar/CNextParser";
 
+/**
+ * Issue #349: Options for include transformation
+ */
+interface IIncludeTransformOptions {
+  sourcePath: string | null;
+  includeDirs?: string[];
+  inputs?: string[];
+}
+
+/**
+ * Issue #349: Find a .cnx file in the given search paths.
+ * Returns the absolute path if found, null otherwise.
+ */
+const findCnxFile = (
+  filename: string,
+  searchPaths: string[],
+): string | null => {
+  for (const searchPath of searchPaths) {
+    const cnxPath = path.resolve(searchPath, `${filename}.cnx`);
+    if (fs.existsSync(cnxPath)) {
+      return cnxPath;
+    }
+  }
+  return null;
+};
+
+/**
+ * Issue #349: Calculate the relative path from input directories.
+ * Returns the relative path (e.g., "Display/utils.cnx") or null if not found.
+ */
+const getRelativePathFromInputs = (
+  filePath: string,
+  inputs: string[],
+): string | null => {
+  for (const input of inputs) {
+    const resolvedInput = path.resolve(input);
+
+    // Skip if input is a file (not a directory)
+    if (fs.existsSync(resolvedInput) && fs.statSync(resolvedInput).isFile()) {
+      continue;
+    }
+
+    const relativePath = path.relative(resolvedInput, filePath);
+
+    // If relative path doesn't start with '..' it's under this input
+    if (!relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+      return relativePath;
+    }
+  }
+  return null;
+};
+
 /**
  * ADR-010: Transform #include directives, converting .cnx to .h
  * Validates that .cnx files exist if sourcePath is available
  * Supports both <file.cnx> and "file.cnx" forms
+ *
+ * Issue #349: For angle-bracket includes, resolves the correct output path
+ * by finding the .cnx file and calculating its relative path from inputs.
  */
 const transformIncludeDirective = (
   includeText: string,
-  sourcePath: string | null,
+  options: IIncludeTransformOptions,
 ): string => {
+  const { sourcePath, includeDirs = [], inputs = [] } = options;
+
   // Match: #include <file.cnx> or #include "file.cnx"
   const angleMatch = includeText.match(/#\s*include\s*<([^>]+)\.cnx>/);
   const quoteMatch = includeText.match(/#\s*include\s*"([^"]+)\.cnx"/);
 
   if (angleMatch) {
     const filename = angleMatch[1];
-    // Angle brackets: system/library includes - no validation needed
+
+    // Issue #349: Try to resolve the .cnx file to get correct output path
+    if (sourcePath) {
+      const sourceDir = path.dirname(sourcePath);
+      // Build search paths: source directory first, then include directories
+      const searchPaths = [sourceDir, ...includeDirs];
+
+      const foundPath = findCnxFile(filename, searchPaths);
+      if (foundPath && inputs.length > 0) {
+        // Calculate relative path from inputs for correct header path
+        const relativePath = getRelativePathFromInputs(foundPath, inputs);
+        if (relativePath) {
+          // Transform .cnx to .h
+          const headerPath = relativePath.replace(/\.cnx$/, ".h");
+          return includeText.replace(`<${filename}.cnx>`, `<${headerPath}>`);
+        }
+      }
+    }
+
+    // Fallback: simple replacement (for external includes or when resolution fails)
     return includeText.replace(`<${filename}.cnx>`, `<${filename}.h>`);
   } else if (quoteMatch) {
     const filepath = quoteMatch[1];

package/src/codegen/types/ICodeGeneratorOptions.ts

@@ -18,6 +18,22 @@ interface ICodeGeneratorOptions {
    * Uses temporary variables instead of compound literals for rvalue pointer params.
    */
   cppMode?: boolean;
+  /**
+   * Issue #339: Relative path from source root to source file for self-include.
+   * When set, self-includes will use this relative path instead of just the basename.
+   * Example: "Display/Utils.cnx" -> #include "Display/Utils.h"
+   */
+  sourceRelativePath?: string;
+  /**
+   * Issue #349: Include directories for resolving angle-bracket .cnx includes.
+   * Used to search for .cnx files referenced in #include <file.cnx> directives.
+   */
+  includeDirs?: string[];
+  /**
+   * Issue #349: Input directories for calculating relative paths.
+   * Used to determine the correct output path prefix for headers.
+   */
+  inputs?: string[];
 }
 
 export default ICodeGeneratorOptions;

package/src/index.ts

@@ -196,6 +196,7 @@ async function runUnifiedMode(
   verbose: boolean,
   cppRequired: boolean,
   noCache: boolean,
+  parseOnly: boolean,
   headerOutDir?: string,
 ): Promise<void> {
   // Issue #337: Identify which inputs are directories (for structure preservation)
@@ -283,6 +284,7 @@ async function runUnifiedMode(
     defines,
     cppRequired,
     noCache,
+    parseOnly,
   });
 
   // Step 5: Compile
@@ -494,6 +496,7 @@ async function main(): Promise<void> {
   let preprocess = true;
   let verbose = false;
   let noCache = false;
+  let parseOnly = false;
   let headerOutDir: string | undefined;
   let cleanMode = false;
 
@@ -514,6 +517,8 @@ async function main(): Promise<void> {
       preprocess = false;
     } else if (arg === "--no-cache") {
       noCache = true;
+    } else if (arg === "--parse") {
+      parseOnly = true;
     } else if (arg === "--header-out" && i + 1 < args.length) {
       headerOutDir = args[++i];
     } else if (arg === "--clean") {
@@ -526,7 +531,26 @@ async function main(): Promise<void> {
       } else {
         defines[define] = true;
       }
-    } else if (!arg.startsWith("-")) {
+    } else if (arg.startsWith("-I")) {
+      // Common mistake: -I is GCC syntax, we use --include
+      // Catches both "-I path" and "-Ipath" (no space)
+      console.error(`Error: Unknown flag '${arg}'`);
+      console.error("  Did you mean: --include <dir>");
+      console.error("");
+      console.error("Example:");
+      console.error("  cnext src --include path/to/headers");
+      process.exit(1);
+    } else if (arg.startsWith("--")) {
+      // Catch unknown long flags (e.g., --foo)
+      console.error(`Error: Unknown flag '${arg}'`);
+      showHelp();
+      process.exit(1);
+    } else if (arg.startsWith("-")) {
+      // Catch other unknown short flags (e.g., -x)
+      console.error(`Error: Unknown flag '${arg}'`);
+      showHelp();
+      process.exit(1);
+    } else {
       inputFiles.push(arg);
     }
   }
@@ -563,6 +587,7 @@ async function main(): Promise<void> {
     verbose,
     cppRequired,
     noCache,
+    parseOnly,
     headerOutDir,
   );
 }

package/src/pipeline/Pipeline.ts

@@ -642,6 +642,9 @@ class Pipeline {
           sourcePath: file.path, // Issue #230: For self-include header generation
           generateHeaders: this.config.generateHeaders, // Issue #230: Enable self-include when headers are generated
           cppMode: this.cppDetected, // Issue #250: C++ compatible code generation
+          sourceRelativePath: this.getSourceRelativePath(file.path), // Issue #339: For correct self-include paths
+          includeDirs: this.config.includeDirs, // Issue #349: For angle-bracket include resolution
+          inputs: this.config.inputs, // Issue #349: For calculating relative paths
         },
       );
 
@@ -699,14 +702,14 @@ class Pipeline {
   }
 
   /**
-   * Get output path for a file
+   * Get relative path from any input directory for a file.
+   * Returns the relative path (e.g., "Display/Utils.cnx") or null if the file
+   * is not under any input directory.
+   *
+   * This is the shared logic used by getSourceRelativePath, getOutputPath,
+   * and getHeaderOutputPath for directory structure preservation.
    */
-  private getOutputPath(file: IDiscoveredFile): string {
-    // Issue #211: Derive extension from cppDetected flag
-    const ext = this.cppDetected ? ".cpp" : ".c";
-    const outputName = basename(file.path).replace(/\.cnx$|\.cnext$/, ext);
-
-    // Check if file is in any input directory (for preserving structure)
+  private getRelativePathFromInputs(filePath: string): string | null {
     for (const input of this.config.inputs) {
       const resolvedInput = resolve(input);
 
@@ -715,24 +718,49 @@ class Pipeline {
         continue;
       }
 
-      const relativePath = relative(resolvedInput, file.path);
+      const relativePath = relative(resolvedInput, filePath);
 
       // Check if file is under this input directory
       if (relativePath && !relativePath.startsWith("..")) {
-        // File is under this input directory - preserve structure
-        const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ext);
-        const outputPath = join(this.config.outDir, outputRelative);
+        return relativePath;
+      }
+    }
 
-        const outputDir = dirname(outputPath);
-        if (!existsSync(outputDir)) {
-          mkdirSync(outputDir, { recursive: true });
-        }
+    return null;
+  }
+
+  /**
+   * Issue #339: Get relative path from input directory for self-include generation.
+   * Returns the relative path (e.g., "Display/Utils.cnx") or just the basename
+   * if the file is not in any input directory.
+   */
+  private getSourceRelativePath(filePath: string): string {
+    return this.getRelativePathFromInputs(filePath) ?? basename(filePath);
+  }
+
+  /**
+   * Get output path for a file
+   */
+  private getOutputPath(file: IDiscoveredFile): string {
+    // Issue #211: Derive extension from cppDetected flag
+    const ext = this.cppDetected ? ".cpp" : ".c";
+
+    const relativePath = this.getRelativePathFromInputs(file.path);
+    if (relativePath) {
+      // File is under an input directory - preserve structure
+      const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ext);
+      const outputPath = join(this.config.outDir, outputRelative);
 
-        return outputPath;
+      const outputDir = dirname(outputPath);
+      if (!existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
       }
+
+      return outputPath;
     }
 
     // Fallback: flat output in outDir
+    const outputName = basename(file.path).replace(/\.cnx$|\.cnext$/, ext);
     return join(this.config.outDir, outputName);
   }
 
@@ -816,37 +844,25 @@ class Pipeline {
    * 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);
+    const relativePath = this.getRelativePathFromInputs(file.path);
+    if (relativePath) {
+      // File is under an input directory - preserve structure
+      const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ".h");
+      const outputPath = join(headerDir, outputRelative);
 
-      // Skip if input is a file (not a directory) - can't preserve structure
-      if (existsSync(resolvedInput) && statSync(resolvedInput).isFile()) {
-        continue;
+      const outputDir = dirname(outputPath);
+      if (!existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
       }
 
-      const relativePath = relative(resolvedInput, file.path);
-
-      // Check if file is under this input directory
-      if (relativePath && !relativePath.startsWith("..")) {
-        const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ".h");
-        const outputPath = join(headerDir, outputRelative);
-
-        const outputDir = dirname(outputPath);
-        if (!existsSync(outputDir)) {
-          mkdirSync(outputDir, { recursive: true });
-        }
-
-        return outputPath;
-      }
+      return outputPath;
     }
 
     // Fallback: flat output in headerDir
+    const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
     return join(headerDir, headerName);
   }
 

package/src/project/Project.ts

@@ -52,6 +52,7 @@ class Project {
       generateHeaders: this.config.generateHeaders,
       cppRequired: this.config.cppRequired,
       noCache: this.config.noCache,
+      parseOnly: this.config.parseOnly,
     });
   }
 

package/src/project/types/IProjectConfig.ts

@@ -37,6 +37,9 @@ interface IProjectConfig {
 
   /** Issue #183: Disable symbol caching (default: false = cache enabled) */
   noCache?: boolean;
+
+  /** Parse only mode - validate syntax without generating output */
+  parseOnly?: boolean;
 }
 
 export default IProjectConfig;

package/src/symbols/CppSymbolCollector.ts

@@ -5,7 +5,10 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { CPP14Parser } from "../parser/cpp/grammar/CPP14Parser";
+import {
+  CPP14Parser,
+  ClassSpecifierContext,
+} from "../parser/cpp/grammar/CPP14Parser";
 import ISymbol from "../types/ISymbol";
 import ESymbolKind from "../types/ESymbolKind";
 import ESourceLanguage from "../types/ESourceLanguage";
@@ -187,13 +190,28 @@ class CppSymbolCollector {
 
     const baseType = this.extractTypeFromDeclSpecSeq(declSpecSeq);
 
+    // Issue #342: Track anonymous class specifiers for typedef handling
+    let anonymousClassSpec: ClassSpecifierContext | null = null;
+
     // Check for class specifier
     for (const spec of declSpecSeq.declSpecifier?.() ?? []) {
       const typeSpec = spec.typeSpecifier?.();
       if (typeSpec) {
         const classSpec = typeSpec.classSpecifier?.();
         if (classSpec) {
-          this.collectClassSpecifier(classSpec, line);
+          // Check if this is a named struct/class
+          const classHead = classSpec.classHead?.();
+          const classHeadName = classHead?.classHeadName?.();
+          const className = classHeadName?.className?.();
+          const identifier = className?.Identifier?.();
+
+          if (identifier?.getText()) {
+            // Named struct - collect normally
+            this.collectClassSpecifier(classSpec, line);
+          } else {
+            // Issue #342: Anonymous struct - save for typedef handling below
+            anonymousClassSpec = classSpec;
+          }
         }
 
         const enumSpec = typeSpec.enumSpecifier?.();
@@ -218,6 +236,27 @@ class CppSymbolCollector {
           ? `${this.currentNamespace}::${name}`
           : name;
 
+        // Issue #342: If we have an anonymous struct and this is a typedef,
+        // collect struct fields using the typedef name
+        if (anonymousClassSpec && this.symbolTable) {
+          const memberSpec = anonymousClassSpec.memberSpecification?.();
+          if (memberSpec) {
+            // Add the type symbol
+            this.symbols.push({
+              name: fullName,
+              kind: ESymbolKind.Class, // Treat typedef'd structs as classes
+              sourceFile: this.sourceFile,
+              sourceLine: line,
+              sourceLanguage: ESourceLanguage.Cpp,
+              isExported: true,
+              parent: this.currentNamespace,
+            });
+            // Collect members using the typedef name
+            this.collectClassMembers(fullName, memberSpec);
+            continue;
+          }
+        }
+
         // Issue #322: Extract parameters for function declarations
         const params = isFunction
           ? this.extractFunctionParameters(declarator)