c-next 0.1.62 → 0.1.63

package/src/transpiler/output/codegen/helpers/__tests__/ArrayInitHelper.test.ts

@@ -2,50 +2,34 @@
  * Unit tests for ArrayInitHelper
  *
  * Issue #644: Tests for the extracted array initialization helper.
+ * Migrated to use CodeGenState instead of constructor DI.
  */
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import ArrayInitHelper from "../ArrayInitHelper.js";
-import type TTypeInfo from "../../types/TTypeInfo.js";
+import CodeGenState from "../../CodeGenState.js";
 
-describe("ArrayInitHelper", () => {
-  let typeRegistry: Map<string, TTypeInfo>;
-  let localArrays: Set<string>;
-  let arrayInitState: {
-    lastArrayInitCount: number;
-    lastArrayFillValue: string | undefined;
-  };
-  let expectedType: string | null;
-  let helper: ArrayInitHelper;
+/**
+ * Default callbacks for testing.
+ */
+const defaultCallbacks = {
+  generateExpression: vi.fn(() => "{1, 2, 3}"),
+  getTypeName: vi.fn(() => "u8"),
+  generateArrayDimensions: vi.fn(
+    (dims: { expression: () => { getText: () => string } | null }[]) =>
+      dims
+        .map((d) => {
+          const expr = d.expression();
+          return expr ? `[${expr.getText()}]` : "[]";
+        })
+        .join(""),
+  ),
+};
 
+describe("ArrayInitHelper", () => {
   beforeEach(() => {
-    typeRegistry = new Map();
-    localArrays = new Set();
-    arrayInitState = {
-      lastArrayInitCount: 0,
-      lastArrayFillValue: undefined,
-    };
-    expectedType = null;
-
-    helper = new ArrayInitHelper({
-      typeRegistry,
-      localArrays,
-      arrayInitState,
-      getExpectedType: () => expectedType,
-      setExpectedType: (type) => {
-        expectedType = type;
-      },
-      generateExpression: vi.fn(() => "{1, 2, 3}"),
-      getTypeName: vi.fn(() => "u8"),
-      generateArrayDimensions: vi.fn((dims) =>
-        dims
-          .map((d: { expression: () => { getText: () => string } | null }) => {
-            const expr = d.expression();
-            return expr ? `[${expr.getText()}]` : "[]";
-          })
-          .join(""),
-      ),
-    });
+    CodeGenState.reset();
+    vi.clearAllMocks();
   });
 
   describe("processArrayInit", () => {
@@ -56,114 +40,96 @@ describe("ArrayInitHelper", () => {
         { expression: () => ({ getText: () => "3" }) },
       ] as never;
 
-      // arrayInitState not modified by generateExpression mock
-      const result = helper.processArrayInit(
+      // CodeGenState not modified by generateExpression mock (stays at 0)
+      const result = ArrayInitHelper.processArrayInit(
         "arr",
         typeCtx,
         expression,
         arrayDims,
         false,
         3,
+        defaultCallbacks,
       );
 
       expect(result).toBeNull();
     });
 
     it("handles size inference with array initializer", () => {
-      // Simulate generateExpression setting array init state
-      helper = new ArrayInitHelper({
-        typeRegistry,
-        localArrays,
-        arrayInitState,
-        getExpectedType: () => expectedType,
-        setExpectedType: (type) => {
-          expectedType = type;
-        },
-        generateExpression: vi.fn(() => {
-          arrayInitState.lastArrayInitCount = 3;
-          return "{1, 2, 3}";
-        }),
-        getTypeName: vi.fn(() => "u8"),
-        generateArrayDimensions: vi.fn(() => ""),
-      });
-
       // Add existing type to registry
-      typeRegistry.set("arr", {
+      CodeGenState.typeRegistry.set("arr", {
         baseType: "u8",
         bitWidth: 8,
         isArray: true,
         isConst: false,
       });
 
+      const callbacks = {
+        generateExpression: vi.fn(() => {
+          // Simulate generateExpression setting array init state
+          CodeGenState.lastArrayInitCount = 3;
+          return "{1, 2, 3}";
+        }),
+        getTypeName: vi.fn(() => "u8"),
+        generateArrayDimensions: vi.fn(() => ""),
+      };
+
       const typeCtx = {} as never;
       const expression = { getText: () => "[1, 2, 3]" } as never;
       const arrayDims = [{ expression: () => null }] as never; // Empty dimension
 
-      const result = helper.processArrayInit(
+      const result = ArrayInitHelper.processArrayInit(
         "arr",
         typeCtx,
         expression,
         arrayDims,
         true, // hasEmptyArrayDim
         null, // no declared size
+        callbacks,
       );
 
       expect(result).not.toBeNull();
       expect(result!.isArrayInit).toBe(true);
       expect(result!.dimensionSuffix).toBe("[3]");
       expect(result!.initValue).toBe("{1, 2, 3}");
-      expect(localArrays.has("arr")).toBe(true);
+      expect(CodeGenState.localArrays.has("arr")).toBe(true);
     });
 
     it("throws error for fill-all with empty dimension", () => {
-      helper = new ArrayInitHelper({
-        typeRegistry,
-        localArrays,
-        arrayInitState,
-        getExpectedType: () => expectedType,
-        setExpectedType: (type) => {
-          expectedType = type;
-        },
+      const callbacks = {
         generateExpression: vi.fn(() => {
-          arrayInitState.lastArrayFillValue = "0";
+          CodeGenState.lastArrayFillValue = "0";
           return "{0}";
         }),
         getTypeName: vi.fn(() => "u8"),
         generateArrayDimensions: vi.fn(() => ""),
-      });
+      };
 
       const typeCtx = {} as never;
       const expression = { getText: () => "[0*]" } as never;
       const arrayDims = [{ expression: () => null }] as never;
 
       expect(() =>
-        helper.processArrayInit(
+        ArrayInitHelper.processArrayInit(
           "arr",
           typeCtx,
           expression,
           arrayDims,
           true, // hasEmptyArrayDim
           null,
+          callbacks,
         ),
       ).toThrow("Fill-all syntax [0*] requires explicit array size");
     });
 
     it("throws error for array size mismatch", () => {
-      helper = new ArrayInitHelper({
-        typeRegistry,
-        localArrays,
-        arrayInitState,
-        getExpectedType: () => expectedType,
-        setExpectedType: (type) => {
-          expectedType = type;
-        },
+      const callbacks = {
         generateExpression: vi.fn(() => {
-          arrayInitState.lastArrayInitCount = 2; // Only 2 elements
+          CodeGenState.lastArrayInitCount = 2; // Only 2 elements
           return "{1, 2}";
         }),
         getTypeName: vi.fn(() => "u8"),
         generateArrayDimensions: vi.fn(() => "[3]"),
-      });
+      };
 
       const typeCtx = {} as never;
       const expression = { getText: () => "[1, 2]" } as never;
@@ -172,33 +138,27 @@ describe("ArrayInitHelper", () => {
       ] as never;
 
       expect(() =>
-        helper.processArrayInit(
+        ArrayInitHelper.processArrayInit(
           "arr",
           typeCtx,
           expression,
           arrayDims,
           false,
           3, // declared size
+          callbacks,
         ),
       ).toThrow("Array size mismatch - declared [3] but got 2 elements");
     });
 
     it("expands fill-all for non-zero values", () => {
-      helper = new ArrayInitHelper({
-        typeRegistry,
-        localArrays,
-        arrayInitState,
-        getExpectedType: () => expectedType,
-        setExpectedType: (type) => {
-          expectedType = type;
-        },
+      const callbacks = {
         generateExpression: vi.fn(() => {
-          arrayInitState.lastArrayFillValue = "1";
+          CodeGenState.lastArrayFillValue = "1";
           return "{1}";
         }),
         getTypeName: vi.fn(() => "u8"),
         generateArrayDimensions: vi.fn(() => "[3]"),
-      });
+      };
 
       const typeCtx = {} as never;
       const expression = { getText: () => "[1*]" } as never;
@@ -206,13 +166,14 @@ describe("ArrayInitHelper", () => {
         { expression: () => ({ getText: () => "3" }) },
       ] as never;
 
-      const result = helper.processArrayInit(
+      const result = ArrayInitHelper.processArrayInit(
         "arr",
         typeCtx,
         expression,
         arrayDims,
         false,
         3,
+        callbacks,
       );
 
       expect(result).not.toBeNull();
@@ -220,21 +181,14 @@ describe("ArrayInitHelper", () => {
     });
 
     it("does not expand fill-all for zero value", () => {
-      helper = new ArrayInitHelper({
-        typeRegistry,
-        localArrays,
-        arrayInitState,
-        getExpectedType: () => expectedType,
-        setExpectedType: (type) => {
-          expectedType = type;
-        },
+      const callbacks = {
         generateExpression: vi.fn(() => {
-          arrayInitState.lastArrayFillValue = "0";
+          CodeGenState.lastArrayFillValue = "0";
           return "{0}";
         }),
         getTypeName: vi.fn(() => "u8"),
         generateArrayDimensions: vi.fn(() => "[3]"),
-      });
+      };
 
       const typeCtx = {} as never;
       const expression = { getText: () => "[0*]" } as never;
@@ -242,13 +196,14 @@ describe("ArrayInitHelper", () => {
         { expression: () => ({ getText: () => "3" }) },
       ] as never;
 
-      const result = helper.processArrayInit(
+      const result = ArrayInitHelper.processArrayInit(
         "arr",
         typeCtx,
         expression,
         arrayDims,
         false,
         3,
+        callbacks,
       );
 
       expect(result).not.toBeNull();

package/src/transpiler/output/codegen/helpers/__tests__/AssignmentExpectedTypeResolver.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import AssignmentExpectedTypeResolver from "../AssignmentExpectedTypeResolver.js";
 import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
+import CodeGenState from "../../CodeGenState.js";
 
 /**
  * Create a mock assignment target context by parsing a minimal assignment statement.
@@ -16,34 +17,66 @@ function parseAssignmentTarget(target: string) {
   return assignStmt.assignmentTarget();
 }
 
-describe("AssignmentExpectedTypeResolver", () => {
-  let resolver: AssignmentExpectedTypeResolver;
-  let typeRegistry: Map<
-    string,
-    { baseType: string; overflowBehavior?: string }
-  >;
-  let structFields: Map<string, Map<string, string>>;
-  let knownStructs: Set<string>;
+/**
+ * Helper to set up struct fields in CodeGenState.symbols
+ */
+function setupStructFields(
+  structName: string,
+  fields: Map<string, string>,
+): void {
+  if (!CodeGenState.symbols) {
+    CodeGenState.symbols = {
+      knownStructs: new Set(),
+      knownScopes: new Set(),
+      knownEnums: new Set(),
+      knownBitmaps: new Set(),
+      knownRegisters: new Set(),
+      structFields: new Map(),
+      structFieldArrays: new Map(),
+      structFieldDimensions: new Map(),
+      enumMembers: new Map(),
+      bitmapFields: new Map(),
+      bitmapBackingType: new Map(),
+      bitmapBitWidth: new Map(),
+      scopeMembers: new Map(),
+      scopeMemberVisibility: new Map(),
+      scopedRegisters: new Map(),
+      registerMemberAccess: new Map(),
+      registerMemberTypes: new Map(),
+      registerBaseAddresses: new Map(),
+      registerMemberOffsets: new Map(),
+      registerMemberCTypes: new Map(),
+      scopeVariableUsage: new Map(),
+      scopePrivateConstValues: new Map(),
+      functionReturnTypes: new Map(),
+      getSingleFunctionForVariable: () => null,
+      hasPublicSymbols: () => false,
+    };
+  }
+  (CodeGenState.symbols.knownStructs as Set<string>).add(structName);
+  (CodeGenState.symbols.structFields as Map<string, Map<string, string>>).set(
+    structName,
+    fields,
+  );
+}
 
+describe("AssignmentExpectedTypeResolver", () => {
   beforeEach(() => {
-    typeRegistry = new Map();
-    structFields = new Map();
-    knownStructs = new Set();
-
-    resolver = new AssignmentExpectedTypeResolver({
-      typeRegistry: typeRegistry as any,
-      structFields,
-      isKnownStruct: (name) => knownStructs.has(name),
-    });
+    CodeGenState.reset();
   });
 
   describe("resolve()", () => {
     describe("simple identifier", () => {
       it("should resolve expected type for known variable", () => {
-        typeRegistry.set("counter", { baseType: "u32" });
+        CodeGenState.typeRegistry.set("counter", {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        });
         const target = parseAssignmentTarget("counter");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBe("u32");
         expect(result.assignmentContext).toEqual({
@@ -54,13 +87,16 @@ describe("AssignmentExpectedTypeResolver", () => {
       });
 
       it("should use specified overflow behavior", () => {
-        typeRegistry.set("counter", {
+        CodeGenState.typeRegistry.set("counter", {
           baseType: "u8",
+          bitWidth: 8,
+          isArray: false,
+          isConst: false,
           overflowBehavior: "wrap",
         });
         const target = parseAssignmentTarget("counter");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.assignmentContext?.overflowBehavior).toBe("wrap");
       });
@@ -68,7 +104,7 @@ describe("AssignmentExpectedTypeResolver", () => {
       it("should return null for unknown variable", () => {
         const target = parseAssignmentTarget("unknown");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBeNull();
         expect(result.assignmentContext).toBeNull();
@@ -77,45 +113,61 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("member access", () => {
       it("should resolve expected type for struct field", () => {
-        typeRegistry.set("config", { baseType: "Config" });
-        knownStructs.add("Config");
-        structFields.set("Config", new Map([["status", "Status"]]));
+        CodeGenState.typeRegistry.set("config", {
+          baseType: "Config",
+          bitWidth: 0,
+          isArray: false,
+          isConst: false,
+        });
+        setupStructFields("Config", new Map([["status", "Status"]]));
         const target = parseAssignmentTarget("config.status");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBe("Status");
       });
 
       it("should walk nested struct chain", () => {
-        typeRegistry.set("app", { baseType: "App" });
-        knownStructs.add("App");
-        knownStructs.add("Config");
-        structFields.set("App", new Map([["config", "Config"]]));
-        structFields.set("Config", new Map([["mode", "Mode"]]));
+        CodeGenState.typeRegistry.set("app", {
+          baseType: "App",
+          bitWidth: 0,
+          isArray: false,
+          isConst: false,
+        });
+        setupStructFields("App", new Map([["config", "Config"]]));
+        setupStructFields("Config", new Map([["mode", "Mode"]]));
         const target = parseAssignmentTarget("app.config.mode");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBe("Mode");
       });
 
       it("should return null for non-struct root", () => {
-        typeRegistry.set("counter", { baseType: "u32" });
+        CodeGenState.typeRegistry.set("counter", {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: false,
+          isConst: false,
+        });
         const target = parseAssignmentTarget("counter.value");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBeNull();
       });
 
       it("should return null for unknown field", () => {
-        typeRegistry.set("config", { baseType: "Config" });
-        knownStructs.add("Config");
-        structFields.set("Config", new Map([["status", "Status"]]));
+        CodeGenState.typeRegistry.set("config", {
+          baseType: "Config",
+          bitWidth: 0,
+          isArray: false,
+          isConst: false,
+        });
+        setupStructFields("Config", new Map([["status", "Status"]]));
         const target = parseAssignmentTarget("config.unknown");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBeNull();
       });
@@ -123,10 +175,15 @@ describe("AssignmentExpectedTypeResolver", () => {
 
     describe("array access", () => {
       it("should return null for array access target", () => {
-        typeRegistry.set("arr", { baseType: "u32" });
+        CodeGenState.typeRegistry.set("arr", {
+          baseType: "u32",
+          bitWidth: 32,
+          isArray: true,
+          isConst: false,
+        });
         const target = parseAssignmentTarget("arr[0]");
 
-        const result = resolver.resolve(target);
+        const result = AssignmentExpectedTypeResolver.resolve(target);
 
         expect(result.expectedType).toBeNull();
         expect(result.assignmentContext).toBeNull();