c-next 0.1.69 → 0.1.71

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/CallExprGenerator.ts

@@ -17,6 +17,7 @@ import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
 import CallExprUtils from "./CallExprUtils";
+import CodeGenState from "../../../../state/CodeGenState";
 
 /**
  * Issue #304: Wrap argument with static_cast if it's a C++ enum class
@@ -80,7 +81,7 @@ const _generateCFunctionArg = (
   // Issue #322: If getExpressionType returns null (e.g., for this.member),
   // fall back to looking up the generated code in the type registry
   if (!argType && !argCode.startsWith("&")) {
-    const typeInfo = input.typeRegistry.get(argCode);
+    const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
     if (typeInfo) {
       argType = typeInfo.baseType;
     }
@@ -119,8 +120,15 @@ const _shouldPassByValue = (
     funcExpr,
     idx,
   );
-  const isSmallPrimitive =
-    isCrossFile && CallExprUtils.isSmallPrimitiveType(targetParam.baseType);
+
+  // Issue #786: For cross-file calls, check if parameter is a known primitive type.
+  // Known primitives (u8-u64, i8-i64, bool) should always be pass-by-value.
+  // This handles the case where local passByValueParams isn't populated for cross-file functions.
+  const isCrossFilePrimitive =
+    isCrossFile &&
+    CallExprUtils.isKnownPrimitiveType(targetParam.baseType) &&
+    !orchestrator.isStructType(targetParam.baseType) &&
+    !CallExprUtils.isStringType(targetParam.baseType);
 
   // Issue #551: Unknown types (external enums, typedefs) use pass-by-value
   const isUnknownType =
@@ -129,13 +137,13 @@ const _shouldPassByValue = (
     !CallExprUtils.isStringType(targetParam.baseType) &&
     !isFloatParam &&
     !isEnumParam &&
-    !isSmallPrimitive;
+    !isCrossFilePrimitive;
 
   return (
     isFloatParam ||
     isEnumParam ||
     isPrimitivePassByValue ||
-    isSmallPrimitive ||
+    isCrossFilePrimitive ||
     isUnknownType
   );
 };
@@ -259,7 +267,7 @@ const generateSafeDivMod = (
   }
 
   // Look up the type of the output parameter
-  const typeInfo = input.typeRegistry.get(outputArgId);
+  const typeInfo = CodeGenState.getVariableTypeInfo(outputArgId);
   if (!typeInfo) {
     throw new Error(
       `Cannot determine type of output parameter '${outputArgId}' for ${funcName}`,

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/PostfixExpressionGenerator.ts

@@ -27,6 +27,7 @@ import SubscriptClassifier from "../../subscript/SubscriptClassifier";
 import TYPE_WIDTH from "../../types/TYPE_WIDTH";
 import C_TYPE_WIDTH from "../../types/C_TYPE_WIDTH";
 import TTypeInfo from "../../types/TTypeInfo";
+import CodeGenState from "../../../../state/CodeGenState";
 
 // ========================================================================
 // Tracking State
@@ -67,7 +68,7 @@ const initializeTrackingState = (
     : false;
 
   const primaryBaseType = rootIdentifier
-    ? input.typeRegistry.get(rootIdentifier)?.baseType
+    ? CodeGenState.getVariableTypeInfo(rootIdentifier)?.baseType
     : undefined;
   const currentStructType =
     primaryBaseType && orchestrator.isKnownStruct(primaryBaseType)
@@ -162,7 +163,7 @@ const generatePostfixExpression = (
   }
 
   const primaryTypeInfo = rootIdentifier
-    ? input.typeRegistry.get(rootIdentifier)
+    ? CodeGenState.getVariableTypeInfo(rootIdentifier)
     : undefined;
 
   const tracking = initializeTrackingState(
@@ -364,7 +365,7 @@ const handleGlobalPrefix = (
   }
 
   // Issue #612: Set currentStructType for global struct variables
-  const globalTypeInfo = input.typeRegistry.get(memberName);
+  const globalTypeInfo = CodeGenState.getVariableTypeInfo(memberName);
   if (globalTypeInfo && orchestrator.isKnownStruct(globalTypeInfo.baseType)) {
     tracking.currentStructType = globalTypeInfo.baseType;
   }
@@ -396,7 +397,7 @@ const handleThisScopeLength = (
 
   tracking.result = `${state.currentScope}_${memberName}`;
   tracking.resolvedIdentifier = tracking.result;
-  const resolvedTypeInfo = input.typeRegistry.get(tracking.result);
+  const resolvedTypeInfo = CodeGenState.getVariableTypeInfo(tracking.result);
   if (
     resolvedTypeInfo &&
     orchestrator.isKnownStruct(resolvedTypeInfo.baseType)
@@ -422,7 +423,9 @@ const resolveStringTypeInfo = (
   orchestrator: IOrchestrator,
 ): TTypeInfo | undefined => {
   const identifier = tracking.resolvedIdentifier ?? rootIdentifier;
-  const typeInfo = identifier ? input.typeRegistry.get(identifier) : undefined;
+  const typeInfo = identifier
+    ? CodeGenState.getVariableTypeInfo(identifier)
+    : undefined;
   if (typeInfo?.isString) {
     return typeInfo;
   }
@@ -650,7 +653,7 @@ const generateLengthProperty = (
 
   // Fall back to checking the current resolved identifier's type
   const typeInfo = ctx.resolvedIdentifier
-    ? input.typeRegistry.get(ctx.resolvedIdentifier)
+    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
     : undefined;
 
   if (!typeInfo) {
@@ -931,7 +934,7 @@ const generateBitLengthProperty = (
 
   // Get type info for the resolved identifier
   const typeInfo = ctx.resolvedIdentifier
-    ? input.typeRegistry.get(ctx.resolvedIdentifier)
+    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
     : undefined;
 
   if (!typeInfo) {
@@ -1185,7 +1188,7 @@ const generateByteLengthProperty = (
 
   // Get type info for the resolved identifier
   const typeInfo = ctx.resolvedIdentifier
-    ? input.typeRegistry.get(ctx.resolvedIdentifier)
+    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
     : undefined;
 
   if (!typeInfo) {
@@ -1251,10 +1254,10 @@ const generateStructFieldElementCount = (
  */
 const generateTypeInfoElementCount = (
   ctx: IExplicitLengthContext,
-  input: IGeneratorInput,
+  _input: IGeneratorInput,
 ): string => {
   const typeInfo = ctx.resolvedIdentifier
-    ? input.typeRegistry.get(ctx.resolvedIdentifier)
+    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
     : undefined;
 
   if (!typeInfo) {
@@ -1350,7 +1353,7 @@ const generateCharCountProperty = (
 
   // Get type info
   const typeInfo = ctx.resolvedIdentifier
-    ? input.typeRegistry.get(ctx.resolvedIdentifier)
+    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
     : undefined;
 
   if (!typeInfo) {
@@ -1484,7 +1487,7 @@ const tryBitmapFieldAccess = (
   if (!ctx.rootIdentifier) {
     return null;
   }
-  const typeInfo = input.typeRegistry.get(ctx.rootIdentifier);
+  const typeInfo = CodeGenState.getVariableTypeInfo(ctx.rootIdentifier);
   if (!typeInfo?.isBitmap || !typeInfo.bitmapTypeName) {
     return null;
   }
@@ -1525,7 +1528,7 @@ const tryScopeMemberAccess = (
     output.result = fullName;
     output.resolvedIdentifier = fullName;
     if (!input.symbols!.knownEnums.has(fullName)) {
-      const resolvedTypeInfo = input.typeRegistry.get(fullName);
+      const resolvedTypeInfo = CodeGenState.getVariableTypeInfo(fullName);
       if (
         resolvedTypeInfo &&
         orchestrator.isKnownStruct(resolvedTypeInfo.baseType)
@@ -1569,7 +1572,7 @@ const tryKnownScopeAccess = (
   const output = initializeMemberOutput(ctx);
   output.result = `${ctx.result}${orchestrator.getScopeSeparator(ctx.isCppAccessChain)}${ctx.memberName}`;
   output.resolvedIdentifier = output.result;
-  const resolvedTypeInfo = input.typeRegistry.get(output.result);
+  const resolvedTypeInfo = CodeGenState.getVariableTypeInfo(output.result);
   if (
     resolvedTypeInfo &&
     orchestrator.isKnownStruct(resolvedTypeInfo.baseType)
@@ -1920,11 +1923,11 @@ const checkRegisterAccess = (
  */
 const getIdentifierTypeInfo = (
   ctx: ISubscriptAccessContext,
-  input: IGeneratorInput,
+  _input: IGeneratorInput,
 ): TTypeInfo | undefined => {
   const identifierToCheck = ctx.resolvedIdentifier || ctx.rootIdentifier;
   return identifierToCheck
-    ? input.typeRegistry.get(identifierToCheck)
+    ? CodeGenState.getVariableTypeInfo(identifierToCheck)
     : undefined;
 };
 

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

@@ -1,10 +1,11 @@
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import generateFunctionCall from "../CallExprGenerator";
 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";
 
 // ========================================================================
 // Test Helpers
@@ -27,10 +28,18 @@ function createMockArgListContext(
 function createMockInput(
   overrides: Partial<IGeneratorInput> = {},
 ): IGeneratorInput {
+  // Also populate CodeGenState with the type registry entries
+  // This is needed because CallExprGenerator now uses CodeGenState directly
+  const typeRegistry =
+    (overrides.typeRegistry as Map<string, TTypeInfo>) ?? new Map();
+  for (const [name, info] of typeRegistry) {
+    CodeGenState.setVariableTypeInfo(name, info);
+  }
+
   return {
     symbols: null,
     symbolTable: null,
-    typeRegistry: new Map(),
+    typeRegistry,
     functionSignatures: new Map(),
     knownFunctions: new Set(),
     knownStructs: new Set(),
@@ -94,6 +103,11 @@ function createMockOrchestrator(
 // ========================================================================
 
 describe("CallExprGenerator", () => {
+  // Reset CodeGenState before each test to avoid state pollution
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("empty function call", () => {
     it("generates call with no arguments when argCtx is null", () => {
       const input = createMockInput();
@@ -756,13 +770,13 @@ describe("CallExprGenerator", () => {
   });
 
   describe("cross-file function calls (Issue #315)", () => {
-    it("looks up parameter info from SymbolTable when no local signature", () => {
+    it("looks up parameter info from SymbolTable and passes primitives by value (Issue #786)", () => {
       const argExprs = [createMockExpressionContext("myVal")];
       const argCtx = createMockArgListContext(argExprs);
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "val", type: "u32", isConst: false, isArray: false },
             ],
@@ -777,6 +791,7 @@ describe("CallExprGenerator", () => {
         isCNextFunction: vi.fn(() => true),
         isFloatType: vi.fn(() => false),
         isParameterPassByValue: vi.fn(() => false),
+        isStructType: vi.fn(() => false),
       });
 
       const result = generateFunctionCall(
@@ -788,7 +803,8 @@ describe("CallExprGenerator", () => {
       );
 
       expect(symbolTable.getOverloads).toHaveBeenCalledWith("crossFileFunc");
-      expect(result.code).toBe("crossFileFunc(&myVal)");
+      // Issue #786: Primitive types like u32 are now passed by value for cross-file calls
+      expect(result.code).toBe("crossFileFunc(myVal)");
     });
 
     it("passes small primitive by value for cross-file functions", () => {
@@ -797,7 +813,7 @@ describe("CallExprGenerator", () => {
       const symbolTable = {
         getOverloads: vi.fn(() => [
           {
-            kind: ESymbolKind.Function,
+            kind: "function",
             parameters: [
               { name: "f", type: "u8", isConst: false, isArray: false },
             ],
@@ -831,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/generators/expressions/__tests__/PostfixExpressionGenerator.test.ts

@@ -9,7 +9,7 @@
  * - Property access (.length, .capacity, .size)
  */
 
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import generatePostfixExpression from "../PostfixExpressionGenerator";
 import type IGeneratorInput from "../../IGeneratorInput";
 import type IGeneratorState from "../../IGeneratorState";
@@ -18,6 +18,7 @@ import type ICodeGenSymbols from "../../../../../types/ICodeGenSymbols";
 import type TTypeInfo from "../../../types/TTypeInfo";
 import type TParameterInfo from "../../../types/TParameterInfo";
 import * as Parser from "../../../../../logic/parser/grammar/CNextParser";
+import CodeGenState from "../../../../../state/CodeGenState";
 
 // ========================================================================
 // Test Helpers - Mock Symbols
@@ -64,10 +65,17 @@ function createMockInput(overrides?: {
   symbols?: ICodeGenSymbols;
   typeRegistry?: Map<string, TTypeInfo>;
 }): IGeneratorInput {
+  // Also populate CodeGenState with the type registry entries
+  // This is needed because PostfixExpressionGenerator now uses CodeGenState directly
+  const typeRegistry = overrides?.typeRegistry ?? new Map<string, TTypeInfo>();
+  for (const [name, info] of typeRegistry) {
+    CodeGenState.setVariableTypeInfo(name, info);
+  }
+
   return {
     symbolTable: null,
     symbols: overrides?.symbols ?? createMockSymbols(),
-    typeRegistry: overrides?.typeRegistry ?? new Map(),
+    typeRegistry,
     functionSignatures: new Map(),
     knownFunctions: new Set(),
     knownStructs: new Set(),
@@ -290,6 +298,11 @@ function createMockPostfixExpressionContext(
 // ========================================================================
 
 describe("PostfixExpressionGenerator", () => {
+  // Reset CodeGenState before each test to avoid state pollution
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("basic expression generation", () => {
     it("generates simple identifier", () => {
       const ctx = createMockPostfixExpressionContext("x", []);