c-next 0.1.70 → 0.1.72

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

@@ -2,7 +2,7 @@
  * Unit tests for CodeGenerator - the main transpiler component.
  * Tests the IOrchestrator interface and internal methods.
  */
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import CodeGenerator from "../CodeGenerator";
 import CNextSourceParser from "../../../logic/parser/CNextSourceParser";
 import * as Parser from "../../../logic/parser/grammar/CNextParser";
@@ -12,6 +12,7 @@ import TSymbolInfoAdapter from "../../../logic/symbols/cnext/adapters/TSymbolInf
 import ICodeGenSymbols from "../../../types/ICodeGenSymbols";
 import TParameterInfo from "../types/TParameterInfo";
 import CodeGenState from "../../../state/CodeGenState";
+import SymbolRegistry from "../../../state/SymbolRegistry";
 
 /**
  * Helper to parse C-Next source and return tree + generator ready for testing.
@@ -51,6 +52,11 @@ function createMinimalGenerator(source: string): CodeGenerator {
 }
 
 describe("CodeGenerator", () => {
+  // Reset SymbolRegistry before each test to prevent state pollution
+  beforeEach(() => {
+    SymbolRegistry.reset();
+  });
+
   describe("generate()", () => {
     it("should generate basic C code from empty program", () => {
       const source = "";

package/src/transpiler/output/codegen/assignment/AssignmentClassifier.ts

@@ -13,6 +13,7 @@ import CodeGenState from "../../../state/CodeGenState";
 import SubscriptClassifier from "../subscript/SubscriptClassifier";
 import TTypeInfo from "../types/TTypeInfo";
 import TypeCheckUtils from "../../../../utils/TypeCheckUtils";
+import QualifiedNameGenerator from "../utils/QualifiedNameGenerator";
 
 /**
  * Classifies assignment statements by analyzing their structure.
@@ -227,7 +228,7 @@ class AssignmentClassifier {
       return null;
     }
 
-    const fullRegName = `${scopeName}_${ids[1]}`;
+    const fullRegName = QualifiedNameGenerator.forMember(scopeName, ids[1]);
     if (!CodeGenState.symbols!.knownRegisters.has(fullRegName)) {
       return null;
     }

package/src/transpiler/output/codegen/assignment/handlers/AssignmentHandlerUtils.ts

@@ -6,6 +6,7 @@
  */
 
 import IRegisterNameResult from "./IRegisterNameResult";
+import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 
 /**
  * Validate that 'this' is being used within a scope context.
@@ -79,7 +80,12 @@ function buildScopedRegisterName(
   scopeName: string,
   parts: readonly string[],
 ): string {
-  return `${scopeName}_${parts.join("_")}`;
+  // Build the name progressively: Scope_Part1_Part2_...
+  let result = scopeName;
+  for (const part of parts) {
+    result = QualifiedNameGenerator.forMember(result, part);
+  }
+  return result;
 }
 
 /**

package/src/transpiler/output/codegen/assignment/handlers/BitmapHandlers.ts

@@ -16,6 +16,7 @@ import TAssignmentHandler from "./TAssignmentHandler";
 import CodeGenState from "../../../../state/CodeGenState";
 import TypeValidator from "../../TypeValidator";
 import type ICodeGenApi from "../../types/ICodeGenApi";
+import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 
 /** Get typed generator reference */
 function gen(): ICodeGenApi {
@@ -211,8 +212,11 @@ function handleScopedRegisterMemberBitmapField(
     gen().validateCrossScopeVisibility(scopeName, regName);
   }
 
-  const fullRegName = `${scopeName}_${regName}`;
-  const fullRegMember = `${fullRegName}_${memberName}`;
+  const fullRegName = QualifiedNameGenerator.forMember(scopeName, regName);
+  const fullRegMember = QualifiedNameGenerator.forMember(
+    fullRegName,
+    memberName,
+  );
   const bitmapType =
     CodeGenState.symbols!.registerMemberTypes.get(fullRegMember)!;
 

package/src/transpiler/output/codegen/assignment/handlers/RegisterHandlers.ts

@@ -16,6 +16,7 @@ import RegisterUtils from "./RegisterUtils";
 import AssignmentHandlerUtils from "./AssignmentHandlerUtils";
 import CodeGenState from "../../../../state/CodeGenState";
 import type ICodeGenApi from "../../types/ICodeGenApi";
+import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 
 /** Get typed generator reference */
 function gen(): ICodeGenApi {
@@ -166,7 +167,7 @@ function handleScopedRegisterBitRange(ctx: IAssignmentContext): string {
     scopeName,
     parts,
   );
-  const scopedRegName = `${scopeName}_${parts[0]}`;
+  const scopedRegName = QualifiedNameGenerator.forMember(scopeName, parts[0]);
 
   const accessMod = CodeGenState.symbols!.registerMemberAccess.get(regName);
   const isWriteOnly = RegisterUtils.isWriteOnlyRegister(accessMod);

package/src/transpiler/output/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -23,6 +23,7 @@ import TGeneratorFn from "../TGeneratorFn";
 import generateScopedRegister from "./ScopedRegisterGenerator";
 import BitmapCommentUtils from "./BitmapCommentUtils";
 import ArrayDimensionUtils from "./ArrayDimensionUtils";
+import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 
 /**
  * Generate initializer expression for a variable declaration.
@@ -48,7 +49,7 @@ function getScopedName(
   scopeName: string,
 ): { name: string; fullName: string } {
   const name = node.IDENTIFIER().getText();
-  return { name, fullName: `${scopeName}_${name}` };
+  return { name, fullName: QualifiedNameGenerator.forMember(scopeName, name) };
 }
 
 /**
@@ -66,7 +67,7 @@ function resolveConstructorArgs(
   for (const argNode of argIdentifiers) {
     const argName = argNode.getText();
     // Arguments must be resolved with scope prefix
-    const scopedArgName = `${scopeName}_${argName}`;
+    const scopedArgName = QualifiedNameGenerator.forMember(scopeName, argName);
 
     // Check if it's const using orchestrator
     if (!orchestrator.isConstValue(scopedArgName)) {
@@ -146,7 +147,7 @@ function generateConstructorVariable(
 ): string {
   // ADR-016: All scope variables are emitted at file scope
   const type = orchestrator.generateType(varDecl.type());
-  const fullName = `${scopeName}_${varName}`;
+  const fullName = QualifiedNameGenerator.forMember(scopeName, varName);
   const prefix = isPrivate ? "static " : "";
 
   // Validate and resolve constructor arguments
@@ -180,7 +181,7 @@ function generateRegularVariable(
 
   // ADR-016: All scope variables are emitted at file scope (static-like persistence)
   const type = orchestrator.generateType(varDecl.type());
-  const fullName = `${scopeName}_${varName}`;
+  const fullName = QualifiedNameGenerator.forMember(scopeName, varName);
   // Issue #282: Add 'const' modifier for const variables
   const constPrefix = isConst ? "const " : "";
   const prefix = isPrivate ? "static " : "";
@@ -216,7 +217,11 @@ function generateScopeFunction(
 ): string[] {
   const returnType = orchestrator.generateType(funcDecl.type());
   const funcName = funcDecl.IDENTIFIER().getText();
-  const fullName = `${scopeName}_${funcName}`;
+  // Use QualifiedNameGenerator for consistent C-style name generation
+  const fullName = QualifiedNameGenerator.forFunctionStrings(
+    scopeName,
+    funcName,
+  );
   const prefix = isPrivate ? "static " : "";
 
   // Issue #269: Set current function name for pass-by-value lookup
@@ -274,7 +279,11 @@ function generateEnumMembersFromAST(
   for (let i = 0; i < members.length; i++) {
     const member = members[i];
     const memberName = member.IDENTIFIER().getText();
-    const fullMemberName = `${fullName}_${memberName}`;
+    // Enum members use the full enum name as their "scope"
+    const fullMemberName = QualifiedNameGenerator.forMember(
+      fullName,
+      memberName,
+    );
 
     if (member.expression()) {
       const constValue = orchestrator.tryEvaluateConstant(member.expression()!);
@@ -421,7 +430,11 @@ function generateScopedEnumInline(
     const memberEntries = Array.from(symbolMembers.entries());
     for (let i = 0; i < memberEntries.length; i++) {
       const [memberName, value] = memberEntries[i];
-      const fullMemberName = `${fullName}_${memberName}`;
+      // Enum members use the full enum name as their "scope"
+      const fullMemberName = QualifiedNameGenerator.forMember(
+        fullName,
+        memberName,
+      );
       const comma = i < memberEntries.length - 1 ? "," : "";
       lines.push(`    ${fullMemberName} = ${value}${comma}`);
     }
@@ -500,7 +513,7 @@ function generateScopedBitmapInline(
   input: IGeneratorInput,
 ): string {
   const name = node.IDENTIFIER().getText();
-  const fullName = `${scopeName}_${name}`;
+  const fullName = QualifiedNameGenerator.forMember(scopeName, name);
   const backingType = _getBitmapBackingType(fullName, node, input);
 
   const lines: string[] = [];

package/src/transpiler/output/codegen/generators/declarationGenerators/ScopedRegisterGenerator.ts

@@ -14,6 +14,7 @@ import IGeneratorState from "../IGeneratorState";
 import IGeneratorOutput from "../IGeneratorOutput";
 import IOrchestrator from "../IOrchestrator";
 import generateRegisterMacros from "./RegisterMacroGenerator";
+import QualifiedNameGenerator from "../../utils/QualifiedNameGenerator";
 
 /**
  * Generate register macros with scope prefix.
@@ -26,12 +27,12 @@ const generateScopedRegister = (
   orchestrator: IOrchestrator,
 ): IGeneratorOutput => {
   const name = node.IDENTIFIER().getText();
-  const fullName = `${scopeName}_${name}`; // Teensy4_GPIO7
+  const fullName = QualifiedNameGenerator.forMember(scopeName, name); // Teensy4_GPIO7
   const baseAddress = orchestrator.generateExpression(node.expression());
 
   // Type resolver for scoped bitmaps (e.g., GPIO7Pins -> Teensy4_GPIO7Pins)
   const resolveType = (regType: string): string | undefined => {
-    const scopedTypeName = `${scopeName}_${regType}`;
+    const scopedTypeName = QualifiedNameGenerator.forMember(scopeName, regType);
     return input.symbols?.knownBitmaps.has(scopedTypeName)
       ? scopedTypeName
       : undefined;

package/src/transpiler/output/codegen/generators/expressions/CallExprUtils.ts

@@ -5,7 +5,7 @@
 import TYPE_MAP from "../../types/TYPE_MAP";
 import IFunctionSignature from "../../types/IFunctionSignature";
 import SymbolTable from "../../../../logic/symbols/SymbolTable";
-import ESymbolKind from "../../../../../utils/types/ESymbolKind";
+import TypeResolver from "../../../../../utils/TypeResolver";
 
 /**
  * Issue #315: Small primitive types that are always passed by value.
@@ -88,12 +88,18 @@ class CallExprUtils {
     if (symbolTable) {
       const symbols = symbolTable.getOverloads(funcName);
       for (const sym of symbols) {
-        if (sym.kind === ESymbolKind.Function && sym.parameters?.[paramIndex]) {
+        if (sym.kind === "function" && sym.parameters?.[paramIndex]) {
           const p = sym.parameters[paramIndex];
+          // Convert TType to string for C-Next symbols, use string directly for C/C++
+          const paramType = p.type;
+          const baseType =
+            typeof paramType === "string"
+              ? paramType
+              : TypeResolver.getTypeName(paramType);
           return {
             param: {
               name: p.name,
-              baseType: p.type,
+              baseType,
               isConst: p.isConst,
               isArray: p.isArray,
             },

package/src/transpiler/output/codegen/generators/expressions/__tests__/CallExprGenerator.test.ts

@@ -4,7 +4,6 @@ import IGeneratorInput from "../../IGeneratorInput";
 import IGeneratorState from "../../IGeneratorState";
 import IOrchestrator from "../../IOrchestrator";
 import * as Parser from "../../../../../logic/parser/grammar/CNextParser";
-import ESymbolKind from "../../../../../../utils/types/ESymbolKind";
 import CodeGenState from "../../../../../state/CodeGenState";
 import TTypeInfo from "../../../types/TTypeInfo";
 
@@ -777,7 +776,7 @@ describe("CallExprGenerator", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "val", type: "u32", isConst: false, isArray: false },
             ],
@@ -814,7 +813,7 @@ describe("CallExprGenerator", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "f", type: "u8", isConst: false, isArray: false },
             ],
@@ -848,7 +847,7 @@ describe("CallExprGenerator", () => {
       const argCtx = createMockArgListContext(argExprs);
       const symbolTable = {
         getOverloads: vi.fn(() => [
-          { kind: ESymbolKind.Variable, parameters: undefined },
+          { kind: "variable", parameters: undefined },
         ]),
       };
       const input = createMockInput({

package/src/transpiler/output/codegen/generators/expressions/__tests__/CallExprUtils.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect, vi } from "vitest";
 import CallExprUtils from "../CallExprUtils";
-import ESymbolKind from "../../../../../../utils/types/ESymbolKind";
 
 describe("CallExprUtils", () => {
   describe("mapTypeToCType", () => {
@@ -166,7 +165,7 @@ describe("CallExprUtils", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "val", type: "i32", isConst: true, isArray: false },
             ],
@@ -193,10 +192,7 @@ describe("CallExprUtils", () => {
 
     it("skips non-function symbols in SymbolTable", () => {
       const symbolTable = {
-        getOverloads: vi.fn(() => [
-          { kind: ESymbolKind.Variable },
-          { kind: ESymbolKind.Struct },
-        ]),
+        getOverloads: vi.fn(() => [{ kind: "variable" }, { kind: "struct" }]),
       };
 
       const result = CallExprUtils.resolveTargetParam(
@@ -214,7 +210,7 @@ describe("CallExprUtils", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "a", type: "u8", isConst: false, isArray: false },
             ],
@@ -243,7 +239,7 @@ describe("CallExprUtils", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "remote", type: "i64", isConst: true, isArray: false },
             ],

package/src/transpiler/output/codegen/helpers/ArgumentGenerator.ts

@@ -0,0 +1,236 @@
+/**
+ * ArgumentGenerator - Generates function arguments with proper ADR-006 semantics
+ *
+ * Issue #794: Extracted from CodeGenerator to reduce file size.
+ * Uses CodeGenState for state access and callbacks for CodeGenerator methods.
+ *
+ * Handles argument generation patterns:
+ * - Local variables get & (address-of) in C mode
+ * - Member access (cursor.x) gets & (address-of)
+ * - Array access (arr[i]) gets & (address-of)
+ * - Parameters are passed as-is (already pointers)
+ * - Arrays are passed as-is (naturally decay to pointers)
+ * - Literals use compound literals for pointer params: &(type){value}
+ * - Complex expressions are passed as-is
+ */
+
+import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
+import CodeGenState from "../../../state/CodeGenState.js";
+import CppModeHelper from "./CppModeHelper.js";
+import TYPE_MAP from "../types/TYPE_MAP.js";
+import IArgumentGeneratorCallbacks from "./types/IArgumentGeneratorCallbacks.js";
+
+/**
+ * Generates function arguments with proper pass-by-reference semantics.
+ */
+class ArgumentGenerator {
+  /**
+   * Handle simple identifier argument (parameter, local array, scope member, or variable).
+   * This is a pure function that only reads from CodeGenState.
+   */
+  static handleIdentifierArg(id: string): string {
+    // Parameters are already pointers
+    if (CodeGenState.currentParameters.get(id)) {
+      return id;
+    }
+
+    // Local arrays decay to pointers
+    if (CodeGenState.localArrays.has(id)) {
+      return id;
+    }
+
+    // Global arrays also decay to pointers (check typeRegistry)
+    // But NOT strings - strings need & (they're char arrays but passed by reference)
+    const typeInfo = CodeGenState.getVariableTypeInfo(id);
+    if (typeInfo?.isArray && !typeInfo.isString) {
+      return id;
+    }
+
+    // Scope member - may need prefixing
+    if (CodeGenState.currentScope) {
+      const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
+      if (members?.has(id)) {
+        const scopedName = `${CodeGenState.currentScope}_${id}`;
+        return CppModeHelper.maybeAddressOf(scopedName);
+      }
+    }
+
+    // Local variable - add & (except in C++ mode)
+    return CppModeHelper.maybeAddressOf(id);
+  }
+
+  /**
+   * Handle rvalue argument (literals or complex expressions).
+   */
+  static handleRvalueArg(
+    ctx: Parser.ExpressionContext,
+    targetParamBaseType: string | undefined,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string {
+    if (!targetParamBaseType) {
+      return callbacks.generateExpression(ctx);
+    }
+
+    const cType = TYPE_MAP[targetParamBaseType];
+    if (!cType || cType === "void") {
+      return callbacks.generateExpression(ctx);
+    }
+
+    const value = callbacks.generateExpression(ctx);
+
+    // C++ mode: rvalues can bind to const T&
+    if (CodeGenState.cppMode) {
+      return value;
+    }
+
+    // C mode: Use compound literal syntax
+    return `&(${cType}){${value}}`;
+  }
+
+  /**
+   * Create temp variable for C++ member conversion.
+   */
+  static createCppMemberConversionTemp(
+    ctx: Parser.ExpressionContext,
+    targetParamBaseType: string,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string {
+    const cType = TYPE_MAP[targetParamBaseType] || "uint8_t";
+    const value = callbacks.generateExpression(ctx);
+    const tempName = `_cnx_tmp_${CodeGenState.tempVarCounter++}`;
+    const castExpr = CppModeHelper.cast(cType, value);
+    CodeGenState.pendingTempDeclarations.push(
+      `${cType} ${tempName} = ${castExpr};`,
+    );
+    return CppModeHelper.maybeAddressOf(tempName);
+  }
+
+  /**
+   * Maybe cast string subscript access for integer pointer parameters.
+   */
+  static maybeCastStringSubscript(
+    ctx: Parser.ExpressionContext,
+    expr: string,
+    targetParamBaseType: string | undefined,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string {
+    if (!targetParamBaseType || !callbacks.isStringSubscriptAccess(ctx)) {
+      return expr;
+    }
+
+    const cType = TYPE_MAP[targetParamBaseType];
+    if (cType && !["float", "double", "bool", "void"].includes(cType)) {
+      return CppModeHelper.reinterpretCast(`${cType}*`, expr);
+    }
+
+    return expr;
+  }
+
+  /**
+   * Handle member access argument - may need special handling for arrays or C++ conversions.
+   * Returns null if default lvalue handling should be used.
+   */
+  static handleMemberAccessArg(
+    ctx: Parser.ExpressionContext,
+    targetParamBaseType: string | undefined,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string | null {
+    const arrayStatus = callbacks.getMemberAccessArrayStatus(ctx);
+
+    // Array member - no address-of needed
+    if (arrayStatus === "array") {
+      return callbacks.generateExpression(ctx);
+    }
+
+    // C++ mode may need temp variable for type conversion
+    if (
+      arrayStatus === "not-array" &&
+      targetParamBaseType &&
+      callbacks.needsCppMemberConversion(ctx, targetParamBaseType)
+    ) {
+      return ArgumentGenerator.createCppMemberConversionTemp(
+        ctx,
+        targetParamBaseType,
+        callbacks,
+      );
+    }
+
+    return null; // Fall through to default lvalue handling
+  }
+
+  /**
+   * Handle lvalue argument (member access or array access).
+   */
+  static handleLvalueArg(
+    ctx: Parser.ExpressionContext,
+    lvalueType: "member" | "array",
+    targetParamBaseType: string | undefined,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string {
+    // Member access to array field - arrays decay to pointers
+    if (lvalueType === "member") {
+      const memberResult = ArgumentGenerator.handleMemberAccessArg(
+        ctx,
+        targetParamBaseType,
+        callbacks,
+      );
+      if (memberResult) return memberResult;
+    }
+
+    // Generate expression with address-of
+    const generatedExpr = callbacks.generateExpression(ctx);
+    const expr = CppModeHelper.maybeAddressOf(generatedExpr);
+
+    // String subscript access may need cast
+    if (lvalueType === "array") {
+      return ArgumentGenerator.maybeCastStringSubscript(
+        ctx,
+        expr,
+        targetParamBaseType,
+        callbacks,
+      );
+    }
+
+    return expr;
+  }
+
+  /**
+   * Main entry point: Generate a function argument with proper ADR-006 semantics.
+   *
+   * @param ctx - The expression context
+   * @param simpleId - The simple identifier if known (optimization to avoid re-parsing)
+   * @param targetParamBaseType - The target parameter's base type
+   * @param callbacks - Callbacks to CodeGenerator methods
+   */
+  static generateArg(
+    ctx: Parser.ExpressionContext,
+    simpleId: string | null,
+    targetParamBaseType: string | undefined,
+    callbacks: IArgumentGeneratorCallbacks,
+  ): string {
+    // Handle simple identifiers
+    if (simpleId) {
+      return ArgumentGenerator.handleIdentifierArg(simpleId);
+    }
+
+    // Check if expression is an lvalue
+    const lvalueType = callbacks.getLvalueType(ctx);
+    if (lvalueType) {
+      return ArgumentGenerator.handleLvalueArg(
+        ctx,
+        lvalueType,
+        targetParamBaseType,
+        callbacks,
+      );
+    }
+
+    // Handle rvalue (literals or complex expressions)
+    return ArgumentGenerator.handleRvalueArg(
+      ctx,
+      targetParamBaseType,
+      callbacks,
+    );
+  }
+}
+
+export default ArgumentGenerator;

package/src/transpiler/output/codegen/helpers/CppConstructorHelper.ts

@@ -6,13 +6,13 @@
  * so designated initializers { .field = value } don't work with them.
  */
 
-import ESymbolKind from "../../../../utils/types/ESymbolKind.js";
+import TSymbolKind from "../../../types/symbol-kinds/TSymbolKind.js";
 
 /**
  * Symbol lookup interface for constructor detection
  */
 interface ISymbolLookup {
-  getSymbol(name: string): { kind: ESymbolKind } | undefined;
+  getSymbol(name: string): { kind: TSymbolKind } | undefined;
 }
 
 class CppConstructorHelper {
@@ -68,7 +68,7 @@ class CppConstructorHelper {
     );
 
     const constructorSymbol = symbolTable.getSymbol(constructorName);
-    return constructorSymbol?.kind === ESymbolKind.Function;
+    return constructorSymbol?.kind === "function";
   }
 }