c-next 0.1.65 → 0.1.67

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

@@ -3,40 +3,12 @@
  * Tests the string assignment handler functions.
  */
 
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it } from "vitest";
 import stringHandlers from "../StringHandlers";
 import AssignmentKind from "../../AssignmentKind";
 import IAssignmentContext from "../../IAssignmentContext";
-import IHandlerDeps from "../IHandlerDeps";
-
-/**
- * Create mock dependencies for testing.
- * Uses type casting to allow partial mocks for testing.
- */
-function createMockDeps(overrides: Record<string, unknown> = {}): IHandlerDeps {
-  const base = {
-    typeRegistry: new Map(),
-    symbols: {
-      structFields: new Map(),
-      structFieldDimensions: new Map(),
-      registerMemberAccess: new Map(),
-      registerBaseAddresses: new Map(),
-      registerMemberOffsets: new Map(),
-    },
-    currentScope: undefined,
-    generateAssignmentTarget: vi.fn().mockReturnValue("target"),
-    generateExpression: vi.fn().mockReturnValue("0"),
-    markNeedsString: vi.fn(),
-    isKnownScope: vi.fn().mockReturnValue(false),
-    validateCrossScopeVisibility: vi.fn(),
-    analyzeMemberChainForBitAccess: vi.fn().mockReturnValue({
-      isBitAccess: false,
-    }),
-    tryEvaluateConstant: vi.fn().mockReturnValue(undefined),
-    ...overrides,
-  };
-  return base as unknown as IHandlerDeps;
-}
+import CodeGenState from "../../../../../state/CodeGenState";
+import HandlerTestUtils from "./handlerTestUtils";
 
 /**
  * Create mock context for testing
@@ -57,6 +29,12 @@ function createMockContext(
 }
 
 describe("StringHandlers", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+    HandlerTestUtils.setupMockGenerator();
+    HandlerTestUtils.setupMockSymbols();
+  });
+
   describe("handler registration", () => {
     it("registers all expected string assignment kinds", () => {
       const kinds = stringHandlers.map(([kind]) => kind);
@@ -83,35 +61,33 @@ describe("StringHandlers", () => {
 
   describe("handleSimpleStringAssignment (STRING_SIMPLE)", () => {
     it("generates strncpy with null terminator", () => {
-      const typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["testVar", { stringCapacity: 32, baseType: "string" }],
       ]);
-      const deps = createMockDeps({ typeRegistry });
       const ctx = createMockContext();
 
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_SIMPLE,
       )?.[1];
-      const result = handler!(ctx, deps);
+      const result = handler!(ctx);
 
       expect(result).toContain("strncpy");
       expect(result).toContain("target");
       expect(result).toContain("32");
-      expect(deps.markNeedsString).toHaveBeenCalled();
+      expect(CodeGenState.needsString).toBe(true);
     });
 
     it("throws on compound assignment", () => {
-      const typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["testVar", { stringCapacity: 32, baseType: "string" }],
       ]);
-      const deps = createMockDeps({ typeRegistry });
       const ctx = createMockContext({ isCompound: true, cnextOp: "+<-" });
 
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_SIMPLE,
       )?.[1];
 
-      expect(() => handler!(ctx, deps)).toThrow(
+      expect(() => handler!(ctx)).toThrow(
         "Compound operators not supported for string assignment",
       );
     });
@@ -119,34 +95,31 @@ describe("StringHandlers", () => {
 
   describe("handleStringThisMember (STRING_THIS_MEMBER)", () => {
     it("generates strncpy for scoped member", () => {
-      const typeRegistry = new Map([
+      CodeGenState.currentScope = "TestScope";
+      HandlerTestUtils.setupMockTypeRegistry([
         ["TestScope_memberName", { stringCapacity: 64, baseType: "string" }],
       ]);
-      const deps = createMockDeps({
-        typeRegistry,
-        currentScope: "TestScope",
-      });
       const ctx = createMockContext({ identifiers: ["memberName"] });
 
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_THIS_MEMBER,
       )?.[1];
-      const result = handler!(ctx, deps);
+      const result = handler!(ctx);
 
       expect(result).toContain("strncpy");
       expect(result).toContain("64");
-      expect(deps.markNeedsString).toHaveBeenCalled();
+      expect(CodeGenState.needsString).toBe(true);
     });
 
     it("throws when used outside scope", () => {
-      const deps = createMockDeps({ currentScope: undefined });
+      CodeGenState.currentScope = null;
       const ctx = createMockContext();
 
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_THIS_MEMBER,
       )?.[1];
 
-      expect(() => handler!(ctx, deps)).toThrow(
+      expect(() => handler!(ctx)).toThrow(
         "'this' can only be used inside a scope",
       );
     });
@@ -154,42 +127,31 @@ describe("StringHandlers", () => {
 
   describe("handleStringStructField (STRING_STRUCT_FIELD)", () => {
     it("generates strncpy for struct field", () => {
-      const typeRegistry = new Map([
-        ["person", { baseType: "Person", stringCapacity: undefined }],
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["person", { baseType: "Person" }],
       ]);
-      const structFields = new Map([
-        ["Person", new Map([["name", "string<50>"]])],
-      ]);
-      const deps = createMockDeps({
-        typeRegistry,
-        symbols: {
-          structFields,
-          structFieldDimensions: new Map(),
-          registerMemberAccess: new Map(),
-          registerBaseAddresses: new Map(),
-          registerMemberOffsets: new Map(),
-        },
+      HandlerTestUtils.setupMockSymbols({
+        structFields: new Map([["Person", new Map([["name", "string<50>"]])]]),
       });
       const ctx = createMockContext({ identifiers: ["person", "name"] });
 
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_STRUCT_FIELD,
       )?.[1];
-      const result = handler!(ctx, deps);
+      const result = handler!(ctx);
 
       expect(result).toContain("strncpy");
       expect(result).toContain("person");
       expect(result).toContain("name");
-      expect(deps.markNeedsString).toHaveBeenCalled();
+      expect(CodeGenState.needsString).toBe(true);
     });
   });
 
   describe("handleStringArrayElement (STRING_ARRAY_ELEMENT)", () => {
     it("generates strncpy for array element", () => {
-      const typeRegistry = new Map([
+      HandlerTestUtils.setupMockTypeRegistry([
         ["names", { stringCapacity: 20, baseType: "string" }],
       ]);
-      const deps = createMockDeps({ typeRegistry });
       const ctx = createMockContext({
         identifiers: ["names"],
         subscripts: [{} as never],
@@ -198,32 +160,24 @@ describe("StringHandlers", () => {
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_ARRAY_ELEMENT,
       )?.[1];
-      const result = handler!(ctx, deps);
+      const result = handler!(ctx);
 
       expect(result).toContain("strncpy");
       expect(result).toContain("names");
       expect(result).toContain("20");
-      expect(deps.markNeedsString).toHaveBeenCalled();
+      expect(CodeGenState.needsString).toBe(true);
     });
   });
 
   describe("handleStringStructArrayElement (STRING_STRUCT_ARRAY_ELEMENT)", () => {
     it("generates strncpy for struct field array element", () => {
-      const typeRegistry = new Map([
-        ["config", { baseType: "Config", stringCapacity: undefined }],
-      ]);
-      const structFieldDimensions = new Map([
-        ["Config", new Map([["items", [10, 33]]])], // 10 items, capacity 32+1
+      HandlerTestUtils.setupMockTypeRegistry([
+        ["config", { baseType: "Config" }],
       ]);
-      const deps = createMockDeps({
-        typeRegistry,
-        symbols: {
-          structFields: new Map(),
-          structFieldDimensions,
-          registerMemberAccess: new Map(),
-          registerBaseAddresses: new Map(),
-          registerMemberOffsets: new Map(),
-        },
+      HandlerTestUtils.setupMockSymbols({
+        structFieldDimensions: new Map([
+          ["Config", new Map([["items", [10, 33]]])], // 10 items, capacity 32+1
+        ]),
       });
       const ctx = createMockContext({
         identifiers: ["config", "items"],
@@ -233,14 +187,14 @@ describe("StringHandlers", () => {
       const handler = stringHandlers.find(
         ([kind]) => kind === AssignmentKind.STRING_STRUCT_ARRAY_ELEMENT,
       )?.[1];
-      const result = handler!(ctx, deps);
+      const result = handler!(ctx);
 
       expect(result).toContain("strncpy");
       expect(result).toContain("config");
       expect(result).toContain("items");
       // Capacity should be 33 - 1 = 32
       expect(result).toContain("32");
-      expect(deps.markNeedsString).toHaveBeenCalled();
+      expect(CodeGenState.needsString).toBe(true);
     });
   });
 });

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

@@ -0,0 +1,162 @@
+/**
+ * Shared test utilities for assignment handler tests.
+ * Provides common mock setup functions to reduce duplication.
+ */
+
+import { vi } from "vitest";
+import CodeGenState from "../../../../../state/CodeGenState";
+import type ICodeGenApi from "../../../types/ICodeGenApi";
+import type ICodeGenSymbols from "../../../../../types/ICodeGenSymbols";
+import type TTypeInfo from "../../../types/TTypeInfo";
+
+/**
+ * Default mock symbols with all required ICodeGenSymbols fields.
+ * Override specific fields as needed for individual tests.
+ */
+function createDefaultMockSymbols(): ICodeGenSymbols {
+  return {
+    // Known type names
+    knownScopes: new Set(),
+    knownStructs: new Set(),
+    knownRegisters: new Set(),
+    knownEnums: new Set(),
+    knownBitmaps: new Set(),
+
+    // Scope information
+    scopeMembers: new Map(),
+    scopeMemberVisibility: new Map(),
+
+    // Struct information
+    structFields: new Map(),
+    structFieldArrays: new Map(),
+    structFieldDimensions: new Map(),
+
+    // Enum information
+    enumMembers: new Map(),
+
+    // Bitmap information
+    bitmapFields: new Map(),
+    bitmapBackingType: new Map(),
+    bitmapBitWidth: new Map(),
+
+    // Register information
+    scopedRegisters: new Map(),
+    registerMemberAccess: new Map(),
+    registerMemberTypes: new Map(),
+    registerBaseAddresses: new Map(),
+    registerMemberOffsets: new Map(),
+    registerMemberCTypes: new Map(),
+
+    // Scope variable analysis
+    scopeVariableUsage: new Map(),
+    scopePrivateConstValues: new Map(),
+
+    // Function return types
+    functionReturnTypes: new Map(),
+
+    // Methods
+    getSingleFunctionForVariable: () => null,
+    hasPublicSymbols: () => false,
+  };
+}
+
+/**
+ * Set up mock symbols on CodeGenState.
+ * Provides comprehensive defaults that can be overridden.
+ */
+function setupMockSymbols(overrides: Partial<ICodeGenSymbols> = {}): void {
+  CodeGenState.symbols = {
+    ...createDefaultMockSymbols(),
+    ...overrides,
+  };
+}
+
+/**
+ * Set up mock generator on CodeGenState.
+ * Common generator methods are pre-mocked with sensible defaults.
+ */
+function setupMockGenerator(overrides: Record<string, unknown> = {}): void {
+  CodeGenState.generator = {
+    generateAssignmentTarget: vi.fn().mockReturnValue("target"),
+    generateExpression: vi
+      .fn()
+      .mockImplementation((ctx) => ctx?.mockValue ?? "0"),
+    tryEvaluateConstant: vi.fn().mockReturnValue(undefined),
+    validateBitmapFieldLiteral: vi.fn(),
+    validateCrossScopeVisibility: vi.fn(),
+    getMemberTypeInfo: vi.fn().mockReturnValue(null),
+    checkArrayBounds: vi.fn(),
+    analyzeMemberChainForBitAccess: vi
+      .fn()
+      .mockReturnValue({ isBitAccess: false }),
+    generateFloatBitWrite: vi.fn().mockReturnValue(null),
+    generateAtomicRMW: vi.fn().mockReturnValue("atomic_rmw_result"),
+    isKnownScope: vi.fn().mockReturnValue(false),
+    isKnownStruct: vi.fn().mockReturnValue(false),
+    ...overrides,
+  } as unknown as ICodeGenApi;
+}
+
+/**
+ * Combined setup for both symbols and generator.
+ * Convenience function for tests that need both.
+ */
+function setupMockState(
+  symbolOverrides: Partial<ICodeGenSymbols> = {},
+  generatorOverrides: Record<string, unknown> = {},
+): void {
+  setupMockSymbols(symbolOverrides);
+  setupMockGenerator(generatorOverrides);
+}
+
+/** Common type bit widths for test mocks */
+const TYPE_BIT_WIDTHS: Record<string, number> = {
+  u8: 8,
+  i8: 8,
+  u16: 16,
+  i16: 16,
+  u32: 32,
+  i32: 32,
+  u64: 64,
+  i64: 64,
+  f32: 32,
+  f64: 64,
+  bool: 1,
+  string: 0,
+};
+
+/**
+ * Create a TTypeInfo with sensible defaults.
+ * Only override the fields you care about in tests.
+ */
+function createTypeInfo(overrides: Partial<TTypeInfo> = {}): TTypeInfo {
+  const baseType = overrides.baseType ?? "u32";
+  return {
+    baseType,
+    bitWidth: overrides.bitWidth ?? TYPE_BIT_WIDTHS[baseType] ?? 32,
+    isArray: overrides.isArray ?? false,
+    isConst: overrides.isConst ?? false,
+    ...overrides,
+  };
+}
+
+/**
+ * Set up CodeGenState.typeRegistry with typed entries.
+ * Entries only need to specify the fields relevant to the test.
+ */
+function setupMockTypeRegistry(
+  entries: Array<[string, Partial<TTypeInfo>]>,
+): void {
+  CodeGenState.typeRegistry = new Map(
+    entries.map(([name, partial]) => [name, createTypeInfo(partial)]),
+  );
+}
+
+export default class HandlerTestUtils {
+  static readonly setupMockSymbols = setupMockSymbols;
+  static readonly setupMockGenerator = setupMockGenerator;
+  static readonly setupMockState = setupMockState;
+  static readonly createDefaultMockSymbols = createDefaultMockSymbols;
+  static readonly createTypeInfo = createTypeInfo;
+  static readonly setupMockTypeRegistry = setupMockTypeRegistry;
+}