c-next 0.1.65 → 0.1.67

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

@@ -3,8 +3,10 @@
  * Tests shared utilities for register assignment handlers.
  */
 
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import RegisterUtils from "../RegisterUtils";
+import CodeGenState from "../../../../../state/CodeGenState";
+import HandlerTestUtils from "./handlerTestUtils";
 
 describe("RegisterUtils", () => {
   describe("isWriteOnlyRegister", () => {
@@ -36,4 +38,215 @@ describe("RegisterUtils", () => {
       expect(RegisterUtils.isWriteOnlyRegister("")).toBe(false);
     });
   });
+
+  describe("extractBitRangeParams", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+      HandlerTestUtils.setupMockGenerator({
+        generateExpression: vi
+          .fn()
+          .mockImplementation((ctx) => ctx?.mockExpr ?? "0"),
+      });
+    });
+
+    it("extracts start, width, and mask from subscripts", () => {
+      const subscripts = [{ mockExpr: "4" }, { mockExpr: "8" }];
+      const result = RegisterUtils.extractBitRangeParams(subscripts);
+
+      expect(result.start).toBe("4");
+      expect(result.width).toBe("8");
+      // BitUtils.generateMask returns optimized hex for common widths
+      expect(result.mask).toBe("0xFFU");
+    });
+
+    it("handles dynamic expressions", () => {
+      const subscripts = [{ mockExpr: "offset" }, { mockExpr: "width_var" }];
+      const result = RegisterUtils.extractBitRangeParams(subscripts);
+
+      expect(result.start).toBe("offset");
+      expect(result.width).toBe("width_var");
+      expect(result.mask).toBe("((1U << width_var) - 1)");
+    });
+  });
+
+  describe("tryGenerateMMIO", () => {
+    beforeEach(() => {
+      CodeGenState.reset();
+      HandlerTestUtils.setupMockSymbols({
+        registerBaseAddresses: new Map([["GPIO7", "0x401B8000"]]),
+        registerMemberOffsets: new Map([["GPIO7_DR", "0x00"]]),
+      });
+    });
+
+    it("returns success:false when start is not constant", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi.fn().mockReturnValue(undefined),
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xFF",
+      );
+
+      expect(result.success).toBe(false);
+    });
+
+    it("returns success:false when start is not byte-aligned", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(3) // start = 3 (not byte-aligned)
+          .mockReturnValueOnce(8), // width = 8
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xFF",
+      );
+
+      expect(result.success).toBe(false);
+    });
+
+    it("returns success:false when width is not standard (8, 16, 32)", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0) // start = 0
+          .mockReturnValueOnce(12), // width = 12 (non-standard)
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xFF",
+      );
+
+      expect(result.success).toBe(false);
+    });
+
+    it("returns success:false when base address not found", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0)
+          .mockReturnValueOnce(8),
+      });
+      HandlerTestUtils.setupMockSymbols({
+        registerBaseAddresses: new Map(), // No base address
+        registerMemberOffsets: new Map([["GPIO7_DR", "0x00"]]),
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xFF",
+      );
+
+      expect(result.success).toBe(false);
+    });
+
+    it("generates MMIO for byte-aligned 8-bit write at offset 0", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0) // start = 0
+          .mockReturnValueOnce(8), // width = 8
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xFF",
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.statement).toBe(
+        "*((volatile uint8_t*)(0x401B8000 + 0x00)) = (0xFF);",
+      );
+    });
+
+    it("generates MMIO for byte-aligned 16-bit write with byte offset", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(8) // start = 8 (1 byte offset)
+          .mockReturnValueOnce(16), // width = 16
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xABCD",
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.statement).toBe(
+        "*((volatile uint16_t*)(0x401B8000 + 0x00 + 1)) = (0xABCD);",
+      );
+    });
+
+    it("generates MMIO for 32-bit write", () => {
+      HandlerTestUtils.setupMockGenerator({
+        tryEvaluateConstant: vi
+          .fn()
+          .mockReturnValueOnce(0) // start = 0
+          .mockReturnValueOnce(32), // width = 32
+      });
+      const subscripts = [{}, {}];
+
+      const result = RegisterUtils.tryGenerateMMIO(
+        "GPIO7_DR",
+        "GPIO7",
+        subscripts,
+        "0xDEADBEEF",
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.statement).toBe(
+        "*((volatile uint32_t*)(0x401B8000 + 0x00)) = (0xDEADBEEF);",
+      );
+    });
+  });
+
+  describe("generateWriteOnlyBitRange", () => {
+    it("generates write-only bit range assignment", () => {
+      const result = RegisterUtils.generateWriteOnlyBitRange(
+        "GPIO7_DR",
+        "value",
+        "((1U << 8) - 1)",
+        "4",
+      );
+
+      expect(result).toBe("GPIO7_DR = ((value & ((1U << 8) - 1)) << 4);");
+    });
+  });
+
+  describe("generateRmwBitRange", () => {
+    it("generates read-modify-write bit range assignment", () => {
+      const result = RegisterUtils.generateRmwBitRange(
+        "GPIO7_DR",
+        "value",
+        "((1U << 8) - 1)",
+        "4",
+      );
+
+      expect(result).toBe(
+        "GPIO7_DR = (GPIO7_DR & ~(((1U << 8) - 1) << 4)) | ((value & ((1U << 8) - 1)) << 4);",
+      );
+    });
+  });
 });

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

@@ -3,53 +3,12 @@
  * Tests atomic RMW and overflow clamp handler functions.
  */
 
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import specialHandlers from "../SpecialHandlers";
 import AssignmentKind from "../../AssignmentKind";
 import IAssignmentContext from "../../IAssignmentContext";
-import IHandlerDeps from "../IHandlerDeps";
-
-/**
- * Create mock dependencies for testing.
- */
-function createMockDeps(overrides: Record<string, unknown> = {}): IHandlerDeps {
-  const base = {
-    typeRegistry: new Map(),
-    symbols: {
-      structFields: new Map(),
-      structFieldDimensions: new Map(),
-      bitmapFields: new Map(),
-      registerMemberAccess: new Map(),
-      registerBaseAddresses: new Map(),
-      registerMemberOffsets: new Map(),
-      registerMemberTypes: new Map(),
-    },
-    currentScope: null,
-    currentParameters: new Map(),
-    targetCapabilities: { hasLDREX: false },
-    generateAssignmentTarget: vi.fn().mockReturnValue("target"),
-    generateExpression: vi
-      .fn()
-      .mockImplementation((ctx) => ctx?.mockValue ?? "0"),
-    markNeedsString: vi.fn(),
-    markClampOpUsed: vi.fn(),
-    isKnownScope: vi.fn().mockReturnValue(false),
-    isKnownStruct: vi.fn().mockReturnValue(false),
-    validateCrossScopeVisibility: vi.fn(),
-    validateBitmapFieldLiteral: vi.fn(),
-    checkArrayBounds: vi.fn(),
-    analyzeMemberChainForBitAccess: vi
-      .fn()
-      .mockReturnValue({ isBitAccess: false }),
-    tryEvaluateConstant: vi.fn().mockReturnValue(undefined),
-    getMemberTypeInfo: vi.fn().mockReturnValue(null),
-    generateFloatBitWrite: vi.fn().mockReturnValue(null),
-    foldBooleanToInt: vi.fn().mockImplementation((expr) => expr),
-    generateAtomicRMW: vi.fn().mockReturnValue("atomic_rmw_result"),
-    ...overrides,
-  };
-  return base as unknown as IHandlerDeps;
-}
+import CodeGenState from "../../../../../state/CodeGenState";
+import HandlerTestUtils from "./handlerTestUtils";
 
 /**
  * Create mock context for testing.
@@ -80,6 +39,12 @@ function createMockContext(
 }
 
 describe("SpecialHandlers", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+    HandlerTestUtils.setupMockGenerator();
+    HandlerTestUtils.setupMockSymbols();
+  });
+
   describe("handler registration", () => {
     it("registers all expected special assignment kinds", () => {
       const kinds = specialHandlers.map(([kind]) => kind);
@@ -98,19 +63,18 @@ describe("SpecialHandlers", () => {
       specialHandlers.find(([kind]) => kind === AssignmentKind.ATOMIC_RMW)?.[1];
 
     it("delegates to generateAtomicRMW for simple identifier", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["counter", { baseType: "u32", isAtomic: true }],
-      ]);
+      ]) as any;
       const generateAtomicRMW = vi.fn().mockReturnValue("LDREX/STREX pattern");
       const generateAssignmentTarget = vi.fn().mockReturnValue("counter");
-      const deps = createMockDeps({
-        typeRegistry,
+      HandlerTestUtils.setupMockGenerator({
         generateAtomicRMW,
         generateAssignmentTarget,
       });
       const ctx = createMockContext();
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
       expect(generateAtomicRMW).toHaveBeenCalledWith("counter", "+=", "1", {
         baseType: "u32",
@@ -120,16 +84,15 @@ describe("SpecialHandlers", () => {
     });
 
     it("handles this.member atomic variable", () => {
-      const typeRegistry = new Map([
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.typeRegistry = new Map([
         ["Motor_count", { baseType: "u32", isAtomic: true }],
-      ]);
+      ]) as any;
       const generateAtomicRMW = vi.fn().mockReturnValue("atomic result");
       const generateAssignmentTarget = vi.fn().mockReturnValue("Motor_count");
-      const deps = createMockDeps({
-        typeRegistry,
+      HandlerTestUtils.setupMockGenerator({
         generateAtomicRMW,
         generateAssignmentTarget,
-        currentScope: "Motor",
       });
       const ctx = createMockContext({
         identifiers: ["count"],
@@ -137,7 +100,7 @@ describe("SpecialHandlers", () => {
         isSimpleThisAccess: true,
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
       expect(generateAtomicRMW).toHaveBeenCalledWith("Motor_count", "+=", "1", {
         baseType: "u32",
@@ -147,13 +110,12 @@ describe("SpecialHandlers", () => {
     });
 
     it("handles global.member atomic variable", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["globalCounter", { baseType: "u32", isAtomic: true }],
-      ]);
+      ]) as any;
       const generateAtomicRMW = vi.fn().mockReturnValue("global atomic result");
       const generateAssignmentTarget = vi.fn().mockReturnValue("globalCounter");
-      const deps = createMockDeps({
-        typeRegistry,
+      HandlerTestUtils.setupMockGenerator({
         generateAtomicRMW,
         generateAssignmentTarget,
       });
@@ -163,19 +125,18 @@ describe("SpecialHandlers", () => {
         isSimpleGlobalAccess: true,
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
       expect(result).toBe("global atomic result");
     });
 
     it("handles subtract operation", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["counter", { baseType: "u32", isAtomic: true }],
-      ]);
+      ]) as any;
       const generateAtomicRMW = vi.fn().mockReturnValue("atomic sub");
       const generateAssignmentTarget = vi.fn().mockReturnValue("counter");
-      const deps = createMockDeps({
-        typeRegistry,
+      HandlerTestUtils.setupMockGenerator({
         generateAtomicRMW,
         generateAssignmentTarget,
       });
@@ -184,7 +145,7 @@ describe("SpecialHandlers", () => {
         cOp: "-=",
       });
 
-      getHandler()!(ctx, deps);
+      getHandler()!(ctx);
 
       expect(generateAtomicRMW).toHaveBeenCalledWith(
         "counter",
@@ -202,14 +163,11 @@ describe("SpecialHandlers", () => {
       )?.[1];
 
     it("generates clamp add helper for u8", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["saturated", { baseType: "u8", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("saturated");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -217,21 +175,18 @@ describe("SpecialHandlers", () => {
         generatedValue: "200",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).toHaveBeenCalledWith("add", "u8");
+      expect(CodeGenState.usedClampOps.has("add_u8")).toBe(true);
       expect(result).toBe("saturated = cnx_clamp_add_u8(saturated, 200);");
     });
 
     it("generates clamp sub helper for u16", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["value", { baseType: "u16", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("value");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -241,21 +196,18 @@ describe("SpecialHandlers", () => {
         generatedValue: "100",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).toHaveBeenCalledWith("sub", "u16");
+      expect(CodeGenState.usedClampOps.has("sub_u16")).toBe(true);
       expect(result).toBe("value = cnx_clamp_sub_u16(value, 100);");
     });
 
     it("generates clamp mul helper for u32", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["result", { baseType: "u32", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("result");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -265,21 +217,18 @@ describe("SpecialHandlers", () => {
         generatedValue: "2",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).toHaveBeenCalledWith("mul", "u32");
+      expect(CodeGenState.usedClampOps.has("mul_u32")).toBe(true);
       expect(result).toBe("result = cnx_clamp_mul_u32(result, 2);");
     });
 
     it("uses native arithmetic for float types", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["f", { baseType: "f32", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("f");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -287,19 +236,18 @@ describe("SpecialHandlers", () => {
         generatedValue: "1000.0",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).not.toHaveBeenCalled();
+      expect(CodeGenState.usedClampOps.size).toBe(0);
       expect(result).toBe("f += 1000.0;");
     });
 
     it("uses native arithmetic for f64 type", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["d", { baseType: "f64", overflowBehavior: "clamp" }],
-      ]);
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("d");
-      const deps = createMockDeps({
-        typeRegistry,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -308,20 +256,17 @@ describe("SpecialHandlers", () => {
         generatedValue: "0.5",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
       expect(result).toBe("d -= 0.5;");
     });
 
     it("falls back to native for unsupported operators", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["value", { baseType: "u32", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("value");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -331,23 +276,20 @@ describe("SpecialHandlers", () => {
         generatedValue: "2",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).not.toHaveBeenCalled();
+      expect(CodeGenState.usedClampOps.size).toBe(0);
       expect(result).toBe("value /= 2;");
     });
 
     it("handles this.member with clamp", () => {
-      const typeRegistry = new Map([
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.typeRegistry = new Map([
         ["Motor_speed", { baseType: "u8", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("Motor_speed");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
-        currentScope: "Motor",
       });
       const ctx = createMockContext({
         identifiers: ["speed"],
@@ -356,21 +298,18 @@ describe("SpecialHandlers", () => {
         generatedValue: "10",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).toHaveBeenCalledWith("add", "u8");
+      expect(CodeGenState.usedClampOps.has("add_u8")).toBe(true);
       expect(result).toBe("Motor_speed = cnx_clamp_add_u8(Motor_speed, 10);");
     });
 
     it("handles global.member with clamp", () => {
-      const typeRegistry = new Map([
+      CodeGenState.typeRegistry = new Map([
         ["globalValue", { baseType: "i16", overflowBehavior: "clamp" }],
-      ]);
-      const markClampOpUsed = vi.fn();
+      ]) as any;
       const generateAssignmentTarget = vi.fn().mockReturnValue("globalValue");
-      const deps = createMockDeps({
-        typeRegistry,
-        markClampOpUsed,
+      HandlerTestUtils.setupMockGenerator({
         generateAssignmentTarget,
       });
       const ctx = createMockContext({
@@ -380,9 +319,9 @@ describe("SpecialHandlers", () => {
         generatedValue: "50",
       });
 
-      const result = getHandler()!(ctx, deps);
+      const result = getHandler()!(ctx);
 
-      expect(markClampOpUsed).toHaveBeenCalledWith("add", "i16");
+      expect(CodeGenState.usedClampOps.has("add_i16")).toBe(true);
       expect(result).toBe("globalValue = cnx_clamp_add_i16(globalValue, 50);");
     });
   });