c-next 0.2.12 → 0.2.13

package/src/transpiler/logic/symbols/SymbolTable.ts

@@ -157,7 +157,7 @@ class SymbolTable {
    * Called automatically when adding struct symbols.
    */
   private registerStructFields(struct: IStructSymbol): void {
-    const mangledName = SymbolNameUtils.getMangledName(struct);
+    const cName = SymbolNameUtils.getTranspiledCName(struct);
 
     for (const [fieldName, fieldInfo] of struct.fields) {
       // Convert TType to string for structFields map
@@ -169,7 +169,7 @@ class SymbolTable {
       );
 
       this.addStructField(
-        mangledName,
+        cName,
         fieldName,
         typeString,
         numericDims && numericDims.length > 0 ? numericDims : undefined,
@@ -651,17 +651,29 @@ class SymbolTable {
       (s) => s.sourceLanguage === ESourceLanguage.Cpp,
     );
 
-    if (cnextDefs.length > 0 && (cDefs.length > 0 || cppDefs.length > 0)) {
-      const locations = globalDefinitions.map(
+    // Issue #967: Only global-scope C-Next symbols can conflict with C/C++ symbols.
+    // Scoped symbols (e.g., Touch.read) live in a namespace and don't compete
+    // with C's global symbols (e.g., POSIX read()).
+    const conflictingCnextDefs = cnextDefs.filter((s) => {
+      const tSymbol = s as TSymbol;
+      return tSymbol.scope.name === "";
+    });
+
+    if (
+      conflictingCnextDefs.length > 0 &&
+      (cDefs.length > 0 || cppDefs.length > 0)
+    ) {
+      const conflictingDefs = [...conflictingCnextDefs, ...cDefs, ...cppDefs];
+      const locations = conflictingDefs.map(
         (s) =>
           `${s.sourceLanguage.toUpperCase()} (${s.sourceFile}:${s.sourceLine})`,
       );
 
       return {
-        symbolName: globalDefinitions[0].name,
-        definitions: globalDefinitions,
+        symbolName: conflictingDefs[0].name,
+        definitions: conflictingDefs,
         severity: "error",
-        message: `Symbol conflict: '${globalDefinitions[0].name}' is defined in multiple languages:\n  ${locations.join("\n  ")}\nRename the C-Next symbol to resolve.`,
+        message: `Symbol conflict: '${conflictingDefs[0].name}' is defined in multiple languages:\n  ${locations.join("\n  ")}\nRename the C-Next symbol to resolve.`,
       };
     }
 

package/src/transpiler/logic/symbols/__tests__/SymbolTable.test.ts

@@ -478,6 +478,84 @@ describe("SymbolTable", () => {
       // Two globals with same name IS a conflict
       expect(symbolTable.hasConflict("globalVar")).toBe(true);
     });
+
+    // Issue #967: Scoped C-Next symbols live in a namespace and don't conflict
+    // with C's global symbols. Only global-scope C-Next symbols can conflict.
+    it("should NOT detect conflict for scoped C-Next method vs C function with same bare name", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+      const touchScope = TestScopeUtils.createMockScope("Touch", globalScope);
+
+      // Add C-Next scoped function 'read' in scope 'Touch'
+      // This transpiles to Touch_read()
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "touch.cnx",
+        sourceLine: 28,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("u8"),
+        parameters: [],
+        scope: touchScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // Add C function 'read' from POSIX headers
+      // This stays as read()
+      symbolTable.addCSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "lv_pthread.h",
+        sourceLine: 80,
+        sourceLanguage: ESourceLanguage.C,
+        isExported: true,
+        type: "ssize_t",
+        parameters: [
+          { name: "fd", type: "int", isConst: false, isArray: false },
+          { name: "buf", type: "void*", isConst: false, isArray: false },
+          { name: "count", type: "size_t", isConst: false, isArray: false },
+        ],
+      });
+
+      // Touch.read() is in a namespace — does NOT conflict with C's global read()
+      expect(symbolTable.hasConflict("read")).toBe(false);
+    });
+
+    // Issue #967: Global C-Next functions SHOULD still conflict with C functions
+    it("should detect conflict for global C-Next function vs C function", () => {
+      const globalScope = TestScopeUtils.createMockGlobalScope();
+
+      // Add global C-Next function 'read'
+      symbolTable.addTSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "utils.cnx",
+        sourceLine: 5,
+        sourceLanguage: ESourceLanguage.CNext,
+        isExported: true,
+        returnType: TTypeUtils.createPrimitive("u8"),
+        parameters: [],
+        scope: globalScope,
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
+
+      // Add C function 'read'
+      symbolTable.addCSymbol({
+        kind: "function",
+        name: "read",
+        sourceFile: "unistd.h",
+        sourceLine: 100,
+        sourceLanguage: ESourceLanguage.C,
+        isExported: true,
+        type: "ssize_t",
+        parameters: [],
+      });
+
+      // Global C-Next read() DOES conflict with C's read()
+      expect(symbolTable.hasConflict("read")).toBe(true);
+    });
   });
 
   // ========================================================================

package/src/transpiler/logic/symbols/cnext/__tests__/TSymbolInfoAdapter.test.ts

@@ -466,7 +466,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "MAX_SPEED", // Bare name - adapter computes mangled name
+        name: "MAX_SPEED", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -481,7 +481,7 @@ describe("TSymbolInfoAdapter", () => {
 
       const info = TSymbolInfoAdapter.convert([variable]);
 
-      // Adapter stores using mangled name (scope + bare name)
+      // Adapter stores using transpiled C name (scope + bare name)
       expect(info.scopePrivateConstValues.get("Motor_MAX_SPEED")).toBe("255");
     });
 
@@ -489,7 +489,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "PUBLIC_CONST", // Bare name - adapter computes mangled name
+        name: "PUBLIC_CONST", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -513,7 +513,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "counter", // Bare name - adapter computes mangled name
+        name: "counter", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -535,7 +535,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "LOOKUP_TABLE", // Bare name - adapter computes mangled name
+        name: "LOOKUP_TABLE", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,
@@ -562,7 +562,7 @@ describe("TSymbolInfoAdapter", () => {
       const motorScope = TestScopeUtils.createMockScope("Motor");
       const variable: IVariableSymbol = {
         kind: "variable",
-        name: "MATRIX", // Bare name - adapter computes mangled name
+        name: "MATRIX", // Bare name - adapter computes transpiled C name
         scope: motorScope,
         sourceFile: "test.cnx",
         sourceLine: 1,

package/src/transpiler/logic/symbols/cnext/adapters/TSymbolInfoAdapter.ts

@@ -239,8 +239,9 @@ class TSymbolInfoAdapter {
 
   // === Private Processing Methods ===
 
-  // Use shared utility for name mangling
-  private static readonly getMangledName = SymbolNameUtils.getMangledName;
+  // Use shared utility for transpiled C names
+  private static readonly getTranspiledCName =
+    SymbolNameUtils.getTranspiledCName;
 
   private static processStruct(
     struct: IStructSymbol,
@@ -249,9 +250,9 @@ class TSymbolInfoAdapter {
     structFieldArrays: Map<string, Set<string>>,
     structFieldDimensions: Map<string, Map<string, number[]>>,
   ): void {
-    // Use mangled name for lookups (e.g., "Geometry_Point")
-    const mangledName = TSymbolInfoAdapter.getMangledName(struct);
-    knownStructs.add(mangledName);
+    // Use transpiled C name for lookups (e.g., "Geometry_Point")
+    const cName = TSymbolInfoAdapter.getTranspiledCName(struct);
+    knownStructs.add(cName);
 
     const fields = new Map<string, string>();
     const arrayFields = new Set<string>();
@@ -277,10 +278,10 @@ class TSymbolInfoAdapter {
       }
     }
 
-    structFields.set(mangledName, fields);
-    structFieldArrays.set(mangledName, arrayFields);
+    structFields.set(cName, fields);
+    structFieldArrays.set(cName, arrayFields);
     if (dimensions.size > 0) {
-      structFieldDimensions.set(mangledName, dimensions);
+      structFieldDimensions.set(cName, dimensions);
     }
   }
 
@@ -289,9 +290,9 @@ class TSymbolInfoAdapter {
     knownEnums: Set<string>,
     enumMembers: Map<string, Map<string, number>>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(enumSym);
-    knownEnums.add(mangledName);
-    enumMembers.set(mangledName, new Map(enumSym.members));
+    const cName = TSymbolInfoAdapter.getTranspiledCName(enumSym);
+    knownEnums.add(cName);
+    enumMembers.set(cName, new Map(enumSym.members));
   }
 
   private static processBitmap(
@@ -301,10 +302,10 @@ class TSymbolInfoAdapter {
     bitmapBackingType: Map<string, string>,
     bitmapBitWidth: Map<string, number>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(bitmap);
-    knownBitmaps.add(mangledName);
-    bitmapBackingType.set(mangledName, bitmap.backingType);
-    bitmapBitWidth.set(mangledName, bitmap.bitWidth);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(bitmap);
+    knownBitmaps.add(cName);
+    bitmapBackingType.set(cName, bitmap.backingType);
+    bitmapBitWidth.set(cName, bitmap.bitWidth);
 
     const fields = new Map<string, { offset: number; width: number }>();
     for (const [fieldName, fieldInfo] of bitmap.fields) {
@@ -313,7 +314,7 @@ class TSymbolInfoAdapter {
         width: fieldInfo.width,
       });
     }
-    bitmapFields.set(mangledName, fields);
+    bitmapFields.set(cName, fields);
   }
 
   private static processScope(
@@ -338,18 +339,18 @@ class TSymbolInfoAdapter {
     knownBitmaps: Set<string>,
     maps: IRegisterMaps,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(register);
-    maps.knownRegisters.add(mangledName);
-    maps.registerBaseAddresses.set(mangledName, register.baseAddress);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(register);
+    maps.knownRegisters.add(cName);
+    maps.registerBaseAddresses.set(cName, register.baseAddress);
 
     // Check if this is a scoped register (has non-global scope)
     const isScoped = register.scope.name !== "";
     if (isScoped) {
-      maps.scopedRegisters.set(mangledName, register.baseAddress);
+      maps.scopedRegisters.set(cName, register.baseAddress);
     }
 
     for (const [memberName, memberInfo] of register.members) {
-      const fullName = `${mangledName}_${memberName}`;
+      const fullName = `${cName}_${memberName}`;
 
       maps.registerMemberAccess.set(fullName, memberInfo.access);
       maps.registerMemberOffsets.set(fullName, memberInfo.offset);
@@ -370,7 +371,7 @@ class TSymbolInfoAdapter {
     scopeMembers: Map<string, Set<string>>,
     scopePrivateConstValues: Map<string, string>,
   ): void {
-    const mangledName = TSymbolInfoAdapter.getMangledName(variable);
+    const cName = TSymbolInfoAdapter.getTranspiledCName(variable);
     const scopeName = variable.scope.name;
     const isScoped = scopeName !== "";
 
@@ -381,7 +382,7 @@ class TSymbolInfoAdapter {
         members = new Set<string>();
         scopeMembers.set(scopeName, members);
       }
-      members.add(variable.name); // Add local name (e.g., "value"), not mangled
+      members.add(variable.name); // Add local name (e.g., "value"), not transpiled C name
     }
 
     // Issue #282: Track private const values for inlining
@@ -395,7 +396,7 @@ class TSymbolInfoAdapter {
       variable.initialValue &&
       !variable.isArray
     ) {
-      scopePrivateConstValues.set(mangledName, variable.initialValue);
+      scopePrivateConstValues.set(cName, variable.initialValue);
     }
   }
 
@@ -405,10 +406,10 @@ class TSymbolInfoAdapter {
   ): void {
     // Track function return types for enum validation in assignments
     // This enables recognizing that Motor.getMode() returns Motor_EMode
-    // Use mangled name (e.g., "Motor_getMode") for lookup consistency
-    const mangledName = TSymbolInfoAdapter.getMangledName(func);
+    // Use transpiled C name (e.g., "Motor_getMode") for lookup consistency
+    const cName = TSymbolInfoAdapter.getTranspiledCName(func);
     const returnTypeStr = TypeResolver.getTypeName(func.returnType);
-    functionReturnTypes.set(mangledName, returnTypeStr);
+    functionReturnTypes.set(cName, returnTypeStr);
   }
 
   private static cnextTypeToCType(typeName: string): string {

package/src/transpiler/logic/symbols/cnext/index.ts

@@ -164,7 +164,7 @@ class CNextResolver {
           globalScope,
         );
         symbols.push(symbol);
-        // Use mangled name (global bitmaps have no scope prefix)
+        // Use transpiled C name (global bitmaps have no scope prefix)
         knownBitmaps.add(symbol.name);
       }
 
@@ -200,9 +200,9 @@ class CNextResolver {
         const bitmapCtx = member.bitmapDeclaration()!;
         const symbol = BitmapCollector.collect(bitmapCtx, sourceFile, scope);
         symbols.push(symbol);
-        // Use mangled name (e.g., "Timer_ControlBits") for scoped bitmaps
-        const mangledName = `${scopeName}_${symbol.name}`;
-        knownBitmaps.add(mangledName);
+        // Use transpiled C name (e.g., "Timer_ControlBits") for scoped bitmaps
+        const cName = `${scopeName}_${symbol.name}`;
+        knownBitmaps.add(cName);
       }
 
       // Collect structs early so they're available as types

package/src/transpiler/logic/symbols/cnext/utils/SymbolNameUtils.ts

@@ -3,13 +3,13 @@
  */
 
 /**
- * Get the C-mangled name for a symbol (e.g., "Geometry_Point" for Point in Geometry scope).
- * Works with any symbol that has a name and scope reference.
+ * Get the transpiled C name for a symbol (e.g., "Geometry_Point" for Point in Geometry scope).
+ * Use only at the output layer for C code generation, not for input-side logic.
  *
  * @param symbol Object with name and scope.name properties
- * @returns The mangled name (e.g., "Motor_init") or bare name if global scope
+ * @returns The C output name (e.g., "Motor_init") or bare name if global scope
  */
-function getMangledName(symbol: {
+function getTranspiledCName(symbol: {
   name: string;
   scope: { name: string };
 }): string {
@@ -21,7 +21,7 @@ function getMangledName(symbol: {
 }
 
 class SymbolNameUtils {
-  static readonly getMangledName = getMangledName;
+  static readonly getTranspiledCName = getTranspiledCName;
 }
 
 export default SymbolNameUtils;

package/src/transpiler/output/codegen/CodeGenerator.ts

@@ -3,6 +3,7 @@
  * Transforms C-Next AST to clean, readable C code
  */
 
+import { basename } from "node:path";
 import { CommonTokenStream, ParserRuleContext } from "antlr4ng";
 import * as Parser from "../../logic/parser/grammar/CNextParser";
 
@@ -2225,9 +2226,14 @@ export default class CodeGenerator implements IOrchestrator {
     const output: string[] = [];
     const symbols = CodeGenState.symbols!;
     // Add header comment
+    const sourcePath = CodeGenState.sourcePath;
+    const generatedLine = sourcePath
+      ? ` * Generated by C-Next Transpiler from: ${basename(sourcePath)}`
+      : " * Generated by C-Next Transpiler";
+
     output.push(
       "/**",
-      " * Generated by C-Next Transpiler",
+      generatedLine,
       " * A safer C for embedded systems",
       " */",
       "",

package/src/transpiler/output/codegen/__tests__/CodeGenerator.test.ts

@@ -164,6 +164,21 @@ describe("CodeGenerator", () => {
 
       expect(code).toContain("void foo");
     });
+
+    it("should include source path in generation comment", () => {
+      const source = `void test() { }`;
+      const { tree, tokenStream } = CNextSourceParser.parse(source);
+      const generator = new CodeGenerator();
+      const tSymbols = CNextResolver.resolve(tree, "test.cnx");
+      const symbols = TSymbolInfoAdapter.convert(tSymbols);
+
+      const code = generator.generate(tree, tokenStream, {
+        symbolInfo: symbols,
+        sourcePath: "led.cnx",
+      });
+
+      expect(code).toContain("Generated by C-Next Transpiler from: led.cnx");
+    });
   });
 
   describe("IOrchestrator interface", () => {

package/src/transpiler/output/codegen/__tests__/ExpressionWalker.test.ts

@@ -311,7 +311,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];
@@ -341,7 +341,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];
@@ -370,7 +370,7 @@ describe("ExpressionWalker - const inference integration", () => {
         caller(val);
       }
     `;
-    const transpiler = new Transpiler({ inputs: [] });
+    const transpiler = new Transpiler({ input: "" });
     const transpileResult = (
       await transpiler.transpile({ kind: "source", source: source })
     ).files[0];

package/src/transpiler/output/codegen/__tests__/RequireInclude.test.ts

@@ -18,7 +18,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("stdint includes", () => {
     it("includes stdint.h for u8 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({ kind: "source", source: "u8 value <- 0;" })
@@ -29,7 +29,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for u16 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -43,7 +43,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for u32 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -57,7 +57,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for i32 type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -71,7 +71,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes stdint.h for bitmap types", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -94,7 +94,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("stdbool includes", () => {
     it("includes stdbool.h for bool type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -110,7 +110,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("string includes", () => {
     it("includes string.h for bounded string type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -124,7 +124,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("includes string.h for const string inference", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -140,7 +140,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("isr includes", () => {
     it("generates ISR typedef for ISR type", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -156,7 +156,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("float static assert includes", () => {
     it("generates static assert for float bit indexing write", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -177,7 +177,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("generates static assert for float bit indexing read (no string.h)", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -201,7 +201,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("limits includes", () => {
     it("includes limits.h for float-to-int clamp cast", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -221,7 +221,7 @@ describe("CodeGenerator requireInclude", () => {
 
   describe("multiple includes", () => {
     it("includes multiple headers when needed", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({
@@ -241,7 +241,7 @@ describe("CodeGenerator requireInclude", () => {
     });
 
     it("does not include unused headers", async () => {
-      const transpiler = new Transpiler({ inputs: [], noCache: true }, mockFs);
+      const transpiler = new Transpiler({ input: "", noCache: true }, mockFs);
 
       const result = (
         await transpiler.transpile({

package/src/transpiler/output/codegen/__tests__/TrackVariableTypeHelpers.test.ts

@@ -11,7 +11,7 @@ import Transpiler from "../../../Transpiler";
  * Helper to transpile C-Next source and return the C output
  */
 async function transpileSource(source: string): Promise<string> {
-  const transpiler = new Transpiler({ inputs: [] });
+  const transpiler = new Transpiler({ input: "" });
   const result = (
     await transpiler.transpile({ kind: "source", source: source })
   ).files[0];
@@ -130,7 +130,7 @@ describe("trackVariableTypeWithName helpers", () => {
         }
       `;
       const code = await transpileSource(source);
-      // Scoped type should be mangled to Motor_State
+      // Scoped type should be transpiled to Motor_State
       expect(code).toContain("Motor_State");
     });
 

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

@@ -1,8 +1,8 @@
 /**
  * QualifiedNameGenerator - C-style name generation for C-Next symbols
  *
- * Provides C-style mangled name generation for use in the output layer.
- * Delegates to FunctionUtils.getCMangledName() for the actual implementation
+ * Provides transpiled C name generation for use in the output layer.
+ * Delegates to FunctionUtils.getTranspiledCName() for the actual implementation
  * to avoid duplication with the types layer.
  *
  * Design decisions:
@@ -24,16 +24,16 @@ class QualifiedNameGenerator {
   // ============================================================================
 
   /**
-   * Generate the C-style mangled name for a function.
+   * Generate the transpiled C name for a function.
    *
    * For global scope functions, returns the bare name (e.g., "main").
    * For scoped functions, returns "Scope_name" (e.g., "Test_fillData").
    * For nested scopes, returns "Outer_Inner_name" (e.g., "Outer_Inner_deepFunc").
    *
-   * Delegates to FunctionUtils.getCMangledName() to avoid duplication.
+   * Delegates to FunctionUtils.getTranspiledCName() to avoid duplication.
    */
   static forFunction(func: IFunctionSymbol): string {
-    return FunctionUtils.getCMangledName(func);
+    return FunctionUtils.getTranspiledCName(func);
   }
 
   /**
@@ -61,7 +61,7 @@ class QualifiedNameGenerator {
    *
    * @param scopeName Scope name (e.g., "Test", "Outer.Inner") or undefined for global
    * @param funcName Bare function name (e.g., "fillData")
-   * @returns C-mangled name (e.g., "Test_fillData")
+   * @returns Transpiled C name (e.g., "Test_fillData")
    */
   static forFunctionStrings(
     scopeName: string | undefined,
@@ -100,7 +100,7 @@ class QualifiedNameGenerator {
    *
    * @param scopeName Scope name or undefined for global
    * @param memberName Member name
-   * @returns C-mangled name
+   * @returns Transpiled C name
    */
   static forMember(scopeName: string | undefined, memberName: string): string {
     if (!scopeName) {