c-next 0.2.12 → 0.2.13

package/src/transpiler/output/codegen/utils/__tests__/QualifiedNameGenerator.test.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for QualifiedNameGenerator
  *
- * QualifiedNameGenerator is the ONLY place that constructs C-style mangled names
+ * QualifiedNameGenerator is the ONLY place that constructs transpiled C names
  * like "Test_fillData" from function symbols.
  */
 import { describe, it, expect, beforeEach } from "vitest";
@@ -120,7 +120,7 @@ describe("QualifiedNameGenerator", () => {
       );
     });
 
-    it("returns mangled name for simple scope", () => {
+    it("returns transpiled C name for simple scope", () => {
       expect(
         QualifiedNameGenerator.forFunctionStrings("Test", "fillData"),
       ).toBe("Test_fillData");
@@ -168,7 +168,7 @@ describe("QualifiedNameGenerator", () => {
       );
     });
 
-    it("returns mangled name for simple scope", () => {
+    it("returns transpiled C name for simple scope", () => {
       expect(QualifiedNameGenerator.forMember("Test", "counter")).toBe(
         "Test_counter",
       );

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

@@ -38,6 +38,14 @@ abstract class BaseHeaderGenerator {
 
   /**
    * Generate a header file from symbols
+   *
+   * @param symbols - Array of symbols to include in header
+   * @param filename - Output filename (used for include guard)
+   * @param options - Header generation options (includes cppMode)
+   * @param typeInput - Optional type information for full definitions
+   * @param passByValueParams - Map of function names to pass-by-value parameter names
+   * @param allKnownEnums - All known enum names from entire compilation
+   * @param sourcePath - Optional source file path for header comment
    */
   generate(
     symbols: IHeaderSymbol[],
@@ -46,6 +54,7 @@ abstract class BaseHeaderGenerator {
     typeInput?: IHeaderTypeInput,
     passByValueParams?: TPassByValueParams,
     allKnownEnums?: ReadonlySet<string>,
+    sourcePath?: string,
   ): string {
     const guard = HeaderGeneratorUtils.makeGuard(filename, options.guardPrefix);
 
@@ -98,7 +107,7 @@ abstract class BaseHeaderGenerator {
 
     // Build header sections using utility methods
     const lines: string[] = [
-      ...HeaderGeneratorUtils.generateHeaderStart(guard),
+      ...HeaderGeneratorUtils.generateHeaderStart(guard, sourcePath),
       ...HeaderGeneratorUtils.generateIncludes(options, headersToInclude),
       ...HeaderGeneratorUtils.generateCppWrapperStart(),
       ...HeaderGeneratorUtils.generateForwardDeclarations(

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

@@ -37,6 +37,7 @@ class HeaderGenerator {
    * @param typeInput - Optional type information for full definitions
    * @param passByValueParams - Map of function names to pass-by-value parameter names
    * @param allKnownEnums - All known enum names from entire compilation
+   * @param sourcePath - Optional source file path for header comment
    */
   generate(
     symbols: IHeaderSymbol[],
@@ -45,6 +46,7 @@ class HeaderGenerator {
     typeInput?: IHeaderTypeInput,
     passByValueParams?: TPassByValueParams,
     allKnownEnums?: ReadonlySet<string>,
+    sourcePath?: string,
   ): string {
     const generator = options.cppMode ? this.cppGenerator : this.cGenerator;
 
@@ -55,6 +57,7 @@ class HeaderGenerator {
       typeInput,
       passByValueParams,
       allKnownEnums,
+      sourcePath,
     );
   }
 

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

@@ -250,13 +250,17 @@ class HeaderGeneratorUtils {
   /**
    * Generate header guard opening and file comment
    */
-  static generateHeaderStart(guard: string): string[] {
+  static generateHeaderStart(guard: string, sourcePath?: string): string[] {
+    const generatedLine = sourcePath
+      ? ` * Generated by C-Next Transpiler from: ${sourcePath}`
+      : " * Generated by C-Next Transpiler";
+
     return [
       `#ifndef ${guard}`,
       `#define ${guard}`,
       "",
       "/**",
-      " * Generated by C-Next Transpiler",
+      generatedLine,
       " * Header file for cross-language interoperability",
       " */",
       "",

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

@@ -502,6 +502,22 @@ describe("HeaderGeneratorUtils", () => {
       expect(lines).toContain("#define MY_FILE_H");
       expect(lines.some((l) => l.includes("Generated by C-Next"))).toBe(true);
     });
+
+    it("should include source path in generation comment when provided", () => {
+      const lines = HeaderGeneratorUtils.generateHeaderStart(
+        "TEST_H",
+        "led.cnx",
+      );
+      expect(lines.join("\n")).toContain(
+        "Generated by C-Next Transpiler from: led.cnx",
+      );
+    });
+
+    it("should use default comment when no source path provided", () => {
+      const lines = HeaderGeneratorUtils.generateHeaderStart("TEST_H");
+      expect(lines.join("\n")).toContain("Generated by C-Next Transpiler");
+      expect(lines.join("\n")).not.toContain("from:");
+    });
   });
 
   describe("generateIncludes", () => {

package/src/transpiler/output/headers/adapters/HeaderSymbolAdapter.ts

@@ -54,8 +54,8 @@ class HeaderSymbolAdapter {
     // Convert TType return type to string
     const returnTypeStr = TypeResolver.getTypeName(func.returnType);
 
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(func);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(func);
     const isGlobal = func.scope.name === "";
 
     // Convert parameters to IParameterSymbol[]
@@ -74,10 +74,10 @@ class HeaderSymbolAdapter {
     const paramTypes = func.parameters.map((p) =>
       TypeResolver.getTypeName(p.type),
     );
-    const signature = `${returnTypeStr} ${mangledName}(${paramTypes.join(", ")})`;
+    const signature = `${returnTypeStr} ${cName}(${paramTypes.join(", ")})`;
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "function",
       type: returnTypeStr,
       isExported: func.isExported,
@@ -92,8 +92,8 @@ class HeaderSymbolAdapter {
   private static convertVariable(
     variable: import("../../../types/symbols/IVariableSymbol").default,
   ): IHeaderSymbol {
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(variable);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(variable);
     const isGlobal = variable.scope.name === "";
 
     // Convert TType to string
@@ -107,7 +107,7 @@ class HeaderSymbolAdapter {
     );
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "variable",
       type: typeStr,
       isExported: variable.isExported,
@@ -124,12 +124,12 @@ class HeaderSymbolAdapter {
   private static convertStruct(
     struct: import("../../../types/symbols/IStructSymbol").default,
   ): IHeaderSymbol {
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(struct);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(struct);
     const isGlobal = struct.scope.name === "";
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "struct",
       isExported: struct.isExported,
       parent: isGlobal ? undefined : struct.scope.name,
@@ -141,12 +141,12 @@ class HeaderSymbolAdapter {
   private static convertEnum(
     enumSym: import("../../../types/symbols/IEnumSymbol").default,
   ): IHeaderSymbol {
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(enumSym);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(enumSym);
     const isGlobal = enumSym.scope.name === "";
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "enum",
       isExported: enumSym.isExported,
       parent: isGlobal ? undefined : enumSym.scope.name,
@@ -158,12 +158,12 @@ class HeaderSymbolAdapter {
   private static convertBitmap(
     bitmap: import("../../../types/symbols/IBitmapSymbol").default,
   ): IHeaderSymbol {
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(bitmap);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(bitmap);
     const isGlobal = bitmap.scope.name === "";
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "bitmap",
       type: bitmap.backingType,
       isExported: bitmap.isExported,
@@ -176,12 +176,12 @@ class HeaderSymbolAdapter {
   private static convertRegister(
     register: import("../../../types/symbols/IRegisterSymbol").default,
   ): IHeaderSymbol {
-    // Get mangled name (scope-prefixed)
-    const mangledName = SymbolNameUtils.getMangledName(register);
+    // Get transpiled C name (scope-prefixed)
+    const cName = SymbolNameUtils.getTranspiledCName(register);
     const isGlobal = register.scope.name === "";
 
     return {
-      name: mangledName,
+      name: cName,
       kind: "register",
       isExported: register.isExported,
       parent: isGlobal ? undefined : register.scope.name,

package/src/transpiler/output/headers/adapters/__tests__/HeaderSymbolAdapter.test.ts

@@ -48,7 +48,7 @@ describe("HeaderSymbolAdapter", () => {
       expect(result.parent).toBeUndefined();
     });
 
-    it("should convert scoped variable with mangled name", () => {
+    it("should convert scoped variable with transpiled C name", () => {
       const tSymbol: IVariableSymbol = {
         kind: "variable",
         name: "speed",
@@ -235,7 +235,7 @@ describe("HeaderSymbolAdapter", () => {
       expect(result.parent).toBeUndefined();
     });
 
-    it("should convert scoped struct with mangled name", () => {
+    it("should convert scoped struct with transpiled C name", () => {
       const geometryScope = ScopeUtils.createScope("Geometry", globalScope);
       const tSymbol: IStructSymbol = {
         kind: "struct",
@@ -279,7 +279,7 @@ describe("HeaderSymbolAdapter", () => {
       expect(result.isExported).toBe(true);
     });
 
-    it("should convert scoped enum with mangled name", () => {
+    it("should convert scoped enum with transpiled C name", () => {
       const tSymbol: IEnumSymbol = {
         kind: "enum",
         name: "EMode",
@@ -327,7 +327,7 @@ describe("HeaderSymbolAdapter", () => {
       expect(result.isExported).toBe(true);
     });
 
-    it("should convert scoped bitmap with mangled name", () => {
+    it("should convert scoped bitmap with transpiled C name", () => {
       const tSymbol: IBitmapSymbol = {
         kind: "bitmap",
         name: "Status",
@@ -373,7 +373,7 @@ describe("HeaderSymbolAdapter", () => {
       expect(result.isExported).toBe(true);
     });
 
-    it("should convert scoped register with mangled name", () => {
+    it("should convert scoped register with transpiled C name", () => {
       const tSymbol: IRegisterSymbol = {
         kind: "register",
         name: "CTRL",

package/src/transpiler/state/SymbolRegistry.ts

@@ -133,27 +133,27 @@ class SymbolRegistry {
   // ============================================================================
 
   /**
-   * Find a function by its C-mangled name (e.g., "Test_fillData").
+   * Find a function by its transpiled C name (e.g., "Test_fillData").
    *
    * This is a bridge method for gradual migration. New code should use
    * resolveFunction() with bare names and scope references instead.
    *
-   * @param mangledName C-mangled function name (e.g., "Test_fillData", "main")
+   * @param cName Transpiled C function name (e.g., "Test_fillData", "main")
    * @returns The function symbol, or null if not found
    */
-  static findByMangledName(mangledName: string): IFunctionSymbol | null {
+  static findByCName(cName: string): IFunctionSymbol | null {
     // Check global scope first (no underscore = global function)
     for (const func of this.globalScope.functions) {
-      if (func.name === mangledName) {
+      if (func.name === cName) {
         return func;
       }
     }
 
-    // Check all scopes - the mangled name should match scope_name pattern
+    // Check all scopes - the C name should match scope_name pattern
     for (const [scopePath, scope] of this.scopes) {
       const prefix = scopePath.replaceAll(".", "_") + "_";
       for (const func of scope.functions) {
-        if (prefix + func.name === mangledName) {
+        if (prefix + func.name === cName) {
           return func;
         }
       }
@@ -163,17 +163,15 @@ class SymbolRegistry {
   }
 
   /**
-   * Get the scope of a function given its C-mangled name.
+   * Get the scope of a function given its transpiled C name.
    *
    * This is a bridge method for gradual migration.
    *
-   * @param mangledName C-mangled function name
+   * @param cName Transpiled C function name
    * @returns The scope the function belongs to, or null if not found
    */
-  static getScopeByMangledFunctionName(
-    mangledName: string,
-  ): IScopeSymbol | null {
-    const func = this.findByMangledName(mangledName);
+  static getScopeByCFunctionName(cName: string): IScopeSymbol | null {
+    const func = this.findByCName(cName);
     return func?.scope ?? null;
   }
 }

package/src/transpiler/state/__tests__/SymbolRegistry.test.ts

@@ -141,7 +141,7 @@ describe("SymbolRegistry", () => {
     });
   });
 
-  describe("findByMangledName", () => {
+  describe("findByCName", () => {
     it("finds global function by bare name", () => {
       const global = SymbolRegistry.getGlobalScope();
       const func = FunctionUtils.create({
@@ -156,11 +156,11 @@ describe("SymbolRegistry", () => {
       });
       SymbolRegistry.registerFunction(func);
 
-      const found = SymbolRegistry.findByMangledName("main");
+      const found = SymbolRegistry.findByCName("main");
       expect(found).toBe(func);
     });
 
-    it("finds scoped function by mangled name", () => {
+    it("finds scoped function by transpiled C name", () => {
       const scope = SymbolRegistry.getOrCreateScope("Test");
       const func = FunctionUtils.create({
         name: "fillData",
@@ -174,11 +174,11 @@ describe("SymbolRegistry", () => {
       });
       SymbolRegistry.registerFunction(func);
 
-      const found = SymbolRegistry.findByMangledName("Test_fillData");
+      const found = SymbolRegistry.findByCName("Test_fillData");
       expect(found).toBe(func);
     });
 
-    it("finds nested scope function by mangled name", () => {
+    it("finds nested scope function by transpiled C name", () => {
       const scope = SymbolRegistry.getOrCreateScope("Outer.Inner");
       const func = FunctionUtils.create({
         name: "deepFunc",
@@ -192,17 +192,17 @@ describe("SymbolRegistry", () => {
       });
       SymbolRegistry.registerFunction(func);
 
-      const found = SymbolRegistry.findByMangledName("Outer_Inner_deepFunc");
+      const found = SymbolRegistry.findByCName("Outer_Inner_deepFunc");
       expect(found).toBe(func);
     });
 
     it("returns null for unknown function", () => {
-      const found = SymbolRegistry.findByMangledName("Unknown_func");
+      const found = SymbolRegistry.findByCName("Unknown_func");
       expect(found).toBeNull();
     });
   });
 
-  describe("getScopeByMangledFunctionName", () => {
+  describe("getScopeByCFunctionName", () => {
     it("returns scope for scoped function", () => {
       const scope = SymbolRegistry.getOrCreateScope("Motor");
       const func = FunctionUtils.create({
@@ -217,8 +217,7 @@ describe("SymbolRegistry", () => {
       });
       SymbolRegistry.registerFunction(func);
 
-      const foundScope =
-        SymbolRegistry.getScopeByMangledFunctionName("Motor_init");
+      const foundScope = SymbolRegistry.getScopeByCFunctionName("Motor_init");
       expect(foundScope).toBe(scope);
     });
 
@@ -236,13 +235,12 @@ describe("SymbolRegistry", () => {
       });
       SymbolRegistry.registerFunction(func);
 
-      const foundScope = SymbolRegistry.getScopeByMangledFunctionName("helper");
+      const foundScope = SymbolRegistry.getScopeByCFunctionName("helper");
       expect(foundScope).toBe(global);
     });
 
     it("returns null for unknown function", () => {
-      const foundScope =
-        SymbolRegistry.getScopeByMangledFunctionName("Unknown_func");
+      const foundScope = SymbolRegistry.getScopeByCFunctionName("Unknown_func");
       expect(foundScope).toBeNull();
     });
   });

package/src/transpiler/types/IPipelineFile.ts

@@ -22,6 +22,9 @@ interface IPipelineFile {
 
   /** C-Next includes for transitive enum resolution */
   readonly cnextIncludes?: ReadonlyArray<{ path: string }>;
+
+  /** Override for source-relative path (used in source mode) */
+  readonly sourceRelativePath?: string;
 }
 
 export default IPipelineFile;

package/src/transpiler/types/ITranspilerConfig.ts

@@ -5,8 +5,8 @@
  * configuration interface that supports both single-file and multi-file builds.
  */
 interface ITranspilerConfig {
-  /** Input paths - files or directories to transpile */
-  inputs: string[];
+  /** Entry point .cnx file to transpile */
+  input: string;
 
   /** Include directories for C/C++ header discovery */
   includeDirs?: string[];

package/src/transpiler/types/symbols/IScopeSymbol.ts

@@ -16,7 +16,7 @@ interface IScopeSymbol extends IBaseSymbol {
   /** Parent scope (global scope's parent is itself) */
   readonly parent: IScopeSymbol;
 
-  /** List of member names (local names, not mangled) */
+  /** List of member names (local names, not transpiled C names) */
   readonly members: string[];
 
   /** Functions in this scope */

package/src/utils/FunctionUtils.ts

@@ -52,17 +52,17 @@ class FunctionUtils {
   }
 
   // ============================================================================
-  // Name Mangling
+  // Transpiled C Names
   // ============================================================================
 
   /**
-   * Get the C-mangled name for a function.
+   * Get the transpiled C name for a function.
    *
    * For global scope functions, returns the bare name.
    * For scoped functions, returns "Scope_name" (e.g., "Test_fillData").
    * For nested scopes, returns "Outer_Inner_name".
    */
-  static getCMangledName(func: IFunctionSymbol): string {
+  static getTranspiledCName(func: IFunctionSymbol): string {
     const scopePath = ScopeUtils.getScopePath(func.scope);
     if (scopePath.length === 0) {
       return func.name;

package/src/utils/__tests__/FunctionUtils.test.ts

@@ -153,7 +153,7 @@ describe("IFunctionSymbol", () => {
     });
   });
 
-  describe("FunctionUtils.getCMangledName", () => {
+  describe("FunctionUtils.getTranspiledCName", () => {
     it("returns bare name for global scope function", () => {
       const global = ScopeUtils.createGlobalScope();
 
@@ -168,7 +168,7 @@ describe("IFunctionSymbol", () => {
         sourceLine: 1,
       });
 
-      expect(FunctionUtils.getCMangledName(func)).toBe("main");
+      expect(FunctionUtils.getTranspiledCName(func)).toBe("main");
     });
 
     it("returns scope-prefixed name for scoped function", () => {
@@ -186,7 +186,7 @@ describe("IFunctionSymbol", () => {
         sourceLine: 10,
       });
 
-      expect(FunctionUtils.getCMangledName(func)).toBe("Test_fillData");
+      expect(FunctionUtils.getTranspiledCName(func)).toBe("Test_fillData");
     });
 
     it("returns nested scope-prefixed name for nested scope function", () => {
@@ -205,7 +205,9 @@ describe("IFunctionSymbol", () => {
         sourceLine: 20,
       });
 
-      expect(FunctionUtils.getCMangledName(func)).toBe("Outer_Inner_process");
+      expect(FunctionUtils.getTranspiledCName(func)).toBe(
+        "Outer_Inner_process",
+      );
     });
   });
 

package/src/transpiler/data/types/IDiscoveryOptions.ts

@@ -1,15 +0,0 @@
-/**
- * Options for file discovery
- */
-interface IDiscoveryOptions {
-  /** File extensions to include (default: all supported) */
-  extensions?: string[];
-
-  /** Whether to recurse into subdirectories */
-  recursive?: boolean;
-
-  /** Patterns to exclude */
-  excludePatterns?: RegExp[];
-}
-
-export default IDiscoveryOptions;