c-next 0.1.24 → 0.1.25

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -1430,13 +1430,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("");
     }

package/src/codegen/types/ICodeGeneratorOptions.ts

@@ -18,6 +18,12 @@ 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;
 }
 
 export default ICodeGeneratorOptions;

package/src/pipeline/Pipeline.ts

@@ -642,6 +642,7 @@ 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
         },
       );
 
@@ -699,14 +700,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 +716,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 +842,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/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)