c-next 0.1.68 → 0.1.70

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

@@ -25,8 +25,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["flags", "Running"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["flags", "Running"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
@@ -44,6 +50,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }
@@ -81,9 +89,9 @@ describe("BitmapHandlers", () => {
       )?.[1];
 
     it("generates single-bit read-modify-write", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Running", { offset: 0, width: 1 }]])],
@@ -99,9 +107,9 @@ describe("BitmapHandlers", () => {
     });
 
     it("generates single-bit write with correct offset", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Active", { offset: 3, width: 1 }]])],
@@ -117,9 +125,9 @@ describe("BitmapHandlers", () => {
     });
 
     it("throws on unknown bitmap field", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([["StatusFlags", new Map()]]),
       });
@@ -133,9 +141,9 @@ describe("BitmapHandlers", () => {
     });
 
     it("throws on compound assignment", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Running", { offset: 0, width: 1 }]])],
@@ -152,9 +160,9 @@ describe("BitmapHandlers", () => {
     });
 
     it("validates bitmap field literal", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Running", { offset: 0, width: 1 }]])],
@@ -180,9 +188,9 @@ describe("BitmapHandlers", () => {
       )?.[1];
 
     it("generates multi-bit read-modify-write with mask", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flags", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Mode", { offset: 4, width: 3 }]])],
@@ -202,9 +210,9 @@ describe("BitmapHandlers", () => {
     });
 
     it("generates correct mask for 2-bit field", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["config", { bitmapTypeName: "Config", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["Config", new Map([["Priority", { offset: 0, width: 2 }]])],
@@ -228,9 +236,9 @@ describe("BitmapHandlers", () => {
       )?.[1];
 
     it("generates array element bitmap field assignment", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["flagsArray", { bitmapTypeName: "StatusFlags", baseType: "u8" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockGenerator({
         generateExpression: vi.fn().mockReturnValue("i"),
       });
@@ -258,9 +266,9 @@ describe("BitmapHandlers", () => {
       )?.[1];
 
     it("generates struct member bitmap field assignment", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["device", { baseType: "Device" }],
-      ]) as any;
+      ]);
       HandlerTestUtils.setupMockSymbols({
         bitmapFields: new Map([
           ["StatusFlags", new Map([["Active", { offset: 2, width: 1 }]])],

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

@@ -16,8 +16,15 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["GPIO7", "DR_SET"];
+  const resolvedTarget =
+    overrides.resolvedTarget ?? `${identifiers.join("_")}[LED_BIT]`;
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["GPIO7", "DR_SET"],
+    identifiers,
     subscripts: [{ mockValue: "LED_BIT" } as never],
     isCompound: false,
     cnextOp: "<-",
@@ -34,6 +41,8 @@ function createMockContext(
     isSimpleIdentifier: false,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/SpecialHandlers.test.ts

@@ -16,8 +16,14 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["counter"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["counter"],
+    identifiers,
     subscripts: [],
     isCompound: true,
     cnextOp: "+<-",
@@ -34,6 +40,8 @@ function createMockContext(
     isSimpleIdentifier: true,
     isSimpleThisAccess: false,
     isSimpleGlobalAccess: false,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }
@@ -63,9 +71,9 @@ describe("SpecialHandlers", () => {
       specialHandlers.find(([kind]) => kind === AssignmentKind.ATOMIC_RMW)?.[1];
 
     it("delegates to generateAtomicRMW for simple identifier", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["counter", { baseType: "u32", isAtomic: true }],
-      ]) as any;
+      ]);
       const generateAtomicRMW = vi.fn().mockReturnValue("LDREX/STREX pattern");
       const generateAssignmentTarget = vi.fn().mockReturnValue("counter");
       HandlerTestUtils.setupMockGenerator({
@@ -76,18 +84,23 @@ describe("SpecialHandlers", () => {
 
       const result = getHandler()!(ctx);
 
-      expect(generateAtomicRMW).toHaveBeenCalledWith("counter", "+=", "1", {
-        baseType: "u32",
-        isAtomic: true,
-      });
+      expect(generateAtomicRMW).toHaveBeenCalledWith(
+        "counter",
+        "+=",
+        "1",
+        expect.objectContaining({
+          baseType: "u32",
+          isAtomic: true,
+        }),
+      );
       expect(result).toBe("LDREX/STREX pattern");
     });
 
     it("handles this.member atomic variable", () => {
       CodeGenState.currentScope = "Motor";
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["Motor_count", { baseType: "u32", isAtomic: true }],
-      ]) as any;
+      ]);
       const generateAtomicRMW = vi.fn().mockReturnValue("atomic result");
       const generateAssignmentTarget = vi.fn().mockReturnValue("Motor_count");
       HandlerTestUtils.setupMockGenerator({
@@ -102,17 +115,22 @@ describe("SpecialHandlers", () => {
 
       const result = getHandler()!(ctx);
 
-      expect(generateAtomicRMW).toHaveBeenCalledWith("Motor_count", "+=", "1", {
-        baseType: "u32",
-        isAtomic: true,
-      });
+      expect(generateAtomicRMW).toHaveBeenCalledWith(
+        "Motor_count",
+        "+=",
+        "1",
+        expect.objectContaining({
+          baseType: "u32",
+          isAtomic: true,
+        }),
+      );
       expect(result).toBe("atomic result");
     });
 
     it("handles global.member atomic variable", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["globalCounter", { baseType: "u32", isAtomic: true }],
-      ]) as any;
+      ]);
       const generateAtomicRMW = vi.fn().mockReturnValue("global atomic result");
       const generateAssignmentTarget = vi.fn().mockReturnValue("globalCounter");
       HandlerTestUtils.setupMockGenerator({
@@ -131,9 +149,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("handles subtract operation", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["counter", { baseType: "u32", isAtomic: true }],
-      ]) as any;
+      ]);
       const generateAtomicRMW = vi.fn().mockReturnValue("atomic sub");
       const generateAssignmentTarget = vi.fn().mockReturnValue("counter");
       HandlerTestUtils.setupMockGenerator({
@@ -163,9 +181,9 @@ describe("SpecialHandlers", () => {
       )?.[1];
 
     it("generates clamp add helper for u8", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["saturated", { baseType: "u8", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("saturated");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -182,9 +200,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("generates clamp sub helper for u16", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["value", { baseType: "u16", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("value");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -203,9 +221,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("generates clamp mul helper for u32", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["result", { baseType: "u32", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("result");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -224,9 +242,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("uses native arithmetic for float types", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["f", { baseType: "f32", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("f");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -243,9 +261,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("uses native arithmetic for f64 type", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["d", { baseType: "f64", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("d");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -262,9 +280,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("falls back to native for unsupported operators", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["value", { baseType: "u32", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("value");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -284,9 +302,9 @@ describe("SpecialHandlers", () => {
 
     it("handles this.member with clamp", () => {
       CodeGenState.currentScope = "Motor";
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["Motor_speed", { baseType: "u8", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("Motor_speed");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
@@ -305,9 +323,9 @@ describe("SpecialHandlers", () => {
     });
 
     it("handles global.member with clamp", () => {
-      CodeGenState.typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["globalValue", { baseType: "i16", overflowBehavior: "clamp" }],
-      ]) as any;
+      ]);
       const generateAssignmentTarget = vi.fn().mockReturnValue("globalValue");
       HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,

package/src/transpiler/output/codegen/assignment/handlers/__tests__/StringHandlers.test.ts

@@ -16,14 +16,22 @@ import HandlerTestUtils from "./handlerTestUtils";
 function createMockContext(
   overrides: Partial<IAssignmentContext> = {},
 ): IAssignmentContext {
+  // Default resolved values based on first identifier
+  const identifiers = overrides.identifiers ?? ["testVar"];
+  const resolvedTarget = overrides.resolvedTarget ?? identifiers[0];
+  const resolvedBaseIdentifier =
+    overrides.resolvedBaseIdentifier ?? identifiers[0];
+
   return {
-    identifiers: ["testVar"],
+    identifiers,
     subscripts: [],
     isCompound: false,
     cnextOp: "<-",
     cOp: "=",
     generatedValue: '"hello"',
     targetCtx: {} as never,
+    resolvedTarget,
+    resolvedBaseIdentifier,
     ...overrides,
   } as IAssignmentContext;
 }

package/src/transpiler/output/codegen/assignment/handlers/__tests__/handlerTestUtils.ts

@@ -141,15 +141,16 @@ function createTypeInfo(overrides: Partial<TTypeInfo> = {}): TTypeInfo {
 }
 
 /**
- * Set up CodeGenState.typeRegistry with typed entries.
+ * Set up CodeGenState type registry with typed entries.
  * Entries only need to specify the fields relevant to the test.
+ * Uses setVariableTypeInfo to properly populate the registry.
  */
 function setupMockTypeRegistry(
   entries: Array<[string, Partial<TTypeInfo>]>,
 ): void {
-  CodeGenState.typeRegistry = new Map(
-    entries.map(([name, partial]) => [name, createTypeInfo(partial)]),
-  );
+  for (const [name, partial] of entries) {
+    CodeGenState.setVariableTypeInfo(name, createTypeInfo(partial));
+  }
 }
 
 export default class HandlerTestUtils {

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/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,12 @@
-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 +29,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 +104,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,7 +771,7 @@ 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 = {
@@ -777,6 +792,7 @@ describe("CallExprGenerator", () => {
         isCNextFunction: vi.fn(() => true),
         isFloatType: vi.fn(() => false),
         isParameterPassByValue: vi.fn(() => false),
+        isStructType: vi.fn(() => false),
       });
 
       const result = generateFunctionCall(
@@ -788,7 +804,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", () => {