c-next 0.1.62 → 0.1.63

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

@@ -3,123 +3,150 @@
  * Issue #644: C/C++ mode pattern consolidation
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import CppModeHelper from "../CppModeHelper";
+import CodeGenState from "../../CodeGenState";
 
 describe("CppModeHelper", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
   describe("C mode (cppMode: false)", () => {
-    const helper = new CppModeHelper({ cppMode: false });
+    beforeEach(() => {
+      CodeGenState.cppMode = false;
+    });
 
     it("maybeAddressOf adds & prefix", () => {
-      expect(helper.maybeAddressOf("expr")).toBe("&expr");
-      expect(helper.maybeAddressOf("foo.bar")).toBe("&foo.bar");
+      expect(CppModeHelper.maybeAddressOf("expr")).toBe("&expr");
+      expect(CppModeHelper.maybeAddressOf("foo.bar")).toBe("&foo.bar");
     });
 
     it("maybeDereference wraps in (*...)", () => {
-      expect(helper.maybeDereference("ptr")).toBe("(*ptr)");
-      expect(helper.maybeDereference("param")).toBe("(*param)");
+      expect(CppModeHelper.maybeDereference("ptr")).toBe("(*ptr)");
+      expect(CppModeHelper.maybeDereference("param")).toBe("(*param)");
     });
 
     it("refOrPtr returns *", () => {
-      expect(helper.refOrPtr()).toBe("*");
+      expect(CppModeHelper.refOrPtr()).toBe("*");
     });
 
     it("memberSeparator returns ->", () => {
-      expect(helper.memberSeparator()).toBe("->");
+      expect(CppModeHelper.memberSeparator()).toBe("->");
     });
 
     it("nullLiteral returns NULL", () => {
-      expect(helper.nullLiteral()).toBe("NULL");
+      expect(CppModeHelper.nullLiteral()).toBe("NULL");
     });
 
     it("cast returns C-style cast", () => {
-      expect(helper.cast("int", "x")).toBe("(int)x");
-      expect(helper.cast("uint8_t", "value")).toBe("(uint8_t)value");
+      expect(CppModeHelper.cast("int", "x")).toBe("(int)x");
+      expect(CppModeHelper.cast("uint8_t", "value")).toBe("(uint8_t)value");
     });
 
     it("reinterpretCast returns C-style cast", () => {
-      expect(helper.reinterpretCast("char*", "ptr")).toBe("(char*)ptr");
-      expect(helper.reinterpretCast("uint8_t*", "buf")).toBe("(uint8_t*)buf");
+      expect(CppModeHelper.reinterpretCast("char*", "ptr")).toBe("(char*)ptr");
+      expect(CppModeHelper.reinterpretCast("uint8_t*", "buf")).toBe(
+        "(uint8_t*)buf",
+      );
     });
 
     it("isCppMode returns false", () => {
-      expect(helper.isCppMode()).toBe(false);
+      expect(CppModeHelper.isCppMode()).toBe(false);
     });
   });
 
   describe("C++ mode (cppMode: true)", () => {
-    const helper = new CppModeHelper({ cppMode: true });
+    beforeEach(() => {
+      CodeGenState.cppMode = true;
+    });
 
     it("maybeAddressOf returns expr unchanged", () => {
-      expect(helper.maybeAddressOf("expr")).toBe("expr");
-      expect(helper.maybeAddressOf("foo.bar")).toBe("foo.bar");
+      expect(CppModeHelper.maybeAddressOf("expr")).toBe("expr");
+      expect(CppModeHelper.maybeAddressOf("foo.bar")).toBe("foo.bar");
     });
 
     it("maybeDereference returns expr unchanged", () => {
-      expect(helper.maybeDereference("ptr")).toBe("ptr");
-      expect(helper.maybeDereference("param")).toBe("param");
+      expect(CppModeHelper.maybeDereference("ptr")).toBe("ptr");
+      expect(CppModeHelper.maybeDereference("param")).toBe("param");
     });
 
     it("refOrPtr returns &", () => {
-      expect(helper.refOrPtr()).toBe("&");
+      expect(CppModeHelper.refOrPtr()).toBe("&");
     });
 
     it("memberSeparator returns .", () => {
-      expect(helper.memberSeparator()).toBe(".");
+      expect(CppModeHelper.memberSeparator()).toBe(".");
     });
 
     it("nullLiteral returns nullptr", () => {
-      expect(helper.nullLiteral()).toBe("nullptr");
+      expect(CppModeHelper.nullLiteral()).toBe("nullptr");
     });
 
     it("cast returns static_cast", () => {
-      expect(helper.cast("int", "x")).toBe("static_cast<int>(x)");
-      expect(helper.cast("uint8_t", "value")).toBe(
+      expect(CppModeHelper.cast("int", "x")).toBe("static_cast<int>(x)");
+      expect(CppModeHelper.cast("uint8_t", "value")).toBe(
         "static_cast<uint8_t>(value)",
       );
     });
 
     it("reinterpretCast returns reinterpret_cast", () => {
-      expect(helper.reinterpretCast("char*", "ptr")).toBe(
+      expect(CppModeHelper.reinterpretCast("char*", "ptr")).toBe(
         "reinterpret_cast<char*>(ptr)",
       );
-      expect(helper.reinterpretCast("uint8_t*", "buf")).toBe(
+      expect(CppModeHelper.reinterpretCast("uint8_t*", "buf")).toBe(
         "reinterpret_cast<uint8_t*>(buf)",
       );
     });
 
     it("isCppMode returns true", () => {
-      expect(helper.isCppMode()).toBe(true);
+      expect(CppModeHelper.isCppMode()).toBe(true);
     });
   });
 
   describe("edge cases", () => {
-    it("handles expressions with special characters", () => {
-      const cHelper = new CppModeHelper({ cppMode: false });
-      const cppHelper = new CppModeHelper({ cppMode: true });
+    it("handles expressions with special characters in C mode", () => {
+      CodeGenState.cppMode = false;
+
+      // Parenthesized expressions
+      expect(CppModeHelper.maybeAddressOf("(a + b)")).toBe("&(a + b)");
+
+      // Array access
+      expect(CppModeHelper.maybeDereference("arr[0]")).toBe("(*arr[0])");
+    });
+
+    it("handles expressions with special characters in C++ mode", () => {
+      CodeGenState.cppMode = true;
 
       // Parenthesized expressions
-      expect(cHelper.maybeAddressOf("(a + b)")).toBe("&(a + b)");
-      expect(cppHelper.maybeAddressOf("(a + b)")).toBe("(a + b)");
+      expect(CppModeHelper.maybeAddressOf("(a + b)")).toBe("(a + b)");
 
       // Array access
-      expect(cHelper.maybeDereference("arr[0]")).toBe("(*arr[0])");
-      expect(cppHelper.maybeDereference("arr[0]")).toBe("arr[0]");
+      expect(CppModeHelper.maybeDereference("arr[0]")).toBe("arr[0]");
     });
 
-    it("handles complex type casts", () => {
-      const cHelper = new CppModeHelper({ cppMode: false });
-      const cppHelper = new CppModeHelper({ cppMode: true });
+    it("handles complex type casts in C mode", () => {
+      CodeGenState.cppMode = false;
 
       // Pointer to pointer
-      expect(cHelper.cast("int**", "ptr")).toBe("(int**)ptr");
-      expect(cppHelper.cast("int**", "ptr")).toBe("static_cast<int**>(ptr)");
+      expect(CppModeHelper.cast("int**", "ptr")).toBe("(int**)ptr");
 
       // Const types
-      expect(cHelper.reinterpretCast("const char*", "str")).toBe(
+      expect(CppModeHelper.reinterpretCast("const char*", "str")).toBe(
         "(const char*)str",
       );
-      expect(cppHelper.reinterpretCast("const char*", "str")).toBe(
+    });
+
+    it("handles complex type casts in C++ mode", () => {
+      CodeGenState.cppMode = true;
+
+      // Pointer to pointer
+      expect(CppModeHelper.cast("int**", "ptr")).toBe(
+        "static_cast<int**>(ptr)",
+      );
+
+      // Const types
+      expect(CppModeHelper.reinterpretCast("const char*", "str")).toBe(
         "reinterpret_cast<const char*>(str)",
       );
     });

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

@@ -2,165 +2,316 @@
  * Unit tests for EnumAssignmentValidator
  *
  * Issue #644: Tests for the extracted enum assignment validator.
+ * Rewritten for static class pattern using CodeGenState.
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
 import EnumAssignmentValidator from "../EnumAssignmentValidator.js";
+import CodeGenState from "../../CodeGenState.js";
+import EnumTypeResolver from "../../resolution/EnumTypeResolver.js";
+import ICodeGenSymbols from "../../../../types/ICodeGenSymbols.js";
 
 describe("EnumAssignmentValidator", () => {
-  let knownEnums: Set<string>;
-  let validator: EnumAssignmentValidator;
+  const createMockSymbols = (
+    overrides: Partial<ICodeGenSymbols> = {},
+  ): ICodeGenSymbols =>
+    ({
+      knownScopes: new Set(),
+      knownEnums: new Set(),
+      knownBitmaps: new Set(),
+      knownStructs: new Set(),
+      knownRegisters: new Set(),
+      bitmapBitWidth: new Map(),
+      bitmapFields: new Map(),
+      bitmapBackingType: new Map(),
+      enumMembers: new Map(),
+      structFields: new Map(),
+      structFieldArrays: new Map(),
+      structFieldDimensions: new Map(),
+      functionReturnTypes: 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(),
+      getSingleFunctionForVariable: () => null,
+      hasPublicSymbols: () => false,
+      ...overrides,
+    }) as ICodeGenSymbols;
 
   beforeEach(() => {
-    knownEnums = new Set(["Color", "Status", "Scope_State"]);
+    CodeGenState.reset();
+  });
 
-    validator = new EnumAssignmentValidator({
-      knownEnums,
-      getCurrentScope: vi.fn(() => null),
-      getExpressionEnumType: vi.fn(() => null),
-      isIntegerExpression: vi.fn(() => false),
-    });
+  afterEach(() => {
+    vi.restoreAllMocks();
   });
 
   describe("validateEnumAssignment", () => {
     it("does nothing for non-enum types", () => {
+      CodeGenState.symbols = createMockSymbols();
       const expression = { getText: () => "42" } as never;
 
-      // Should not throw for non-enum type
       expect(() =>
-        validator.validateEnumAssignment("u32", expression),
+        EnumAssignmentValidator.validateEnumAssignment("u32", expression),
       ).not.toThrow();
     });
 
     it("throws for assigning different enum type", () => {
-      const validator = new EnumAssignmentValidator({
-        knownEnums,
-        getCurrentScope: () => null,
-        getExpressionEnumType: () => "Status", // Value is Status type
-        isIntegerExpression: () => false,
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color", "Status"]),
       });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue("Status");
 
       const expression = { getText: () => "Status.OK" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).toThrow("Cannot assign Status enum to Color enum");
     });
 
     it("throws for assigning integer to enum", () => {
-      const validator = new EnumAssignmentValidator({
-        knownEnums,
-        getCurrentScope: () => null,
-        getExpressionEnumType: () => null,
-        isIntegerExpression: () => true, // Expression is integer
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
       });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
 
       const expression = { getText: () => "42" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).toThrow("Cannot assign integer to Color enum");
     });
 
     it("allows same enum type assignment", () => {
-      const validator = new EnumAssignmentValidator({
-        knownEnums,
-        getCurrentScope: () => null,
-        getExpressionEnumType: () => "Color", // Value is Color type
-        isIntegerExpression: () => false,
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
       });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue("Color");
 
       const expression = { getText: () => "Color.RED" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).not.toThrow();
     });
 
     it("allows direct enum member access", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "Color.RED" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).not.toThrow();
     });
 
     it("allows this.Enum.MEMBER pattern", () => {
-      const validator = new EnumAssignmentValidator({
+      CodeGenState.currentScope = "MyScope";
+      CodeGenState.symbols = createMockSymbols({
         knownEnums: new Set(["MyScope_State"]),
-        getCurrentScope: () => "MyScope",
-        getExpressionEnumType: () => null,
-        isIntegerExpression: () => false,
       });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
 
       const expression = { getText: () => "this.State.ACTIVE" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("MyScope_State", expression),
+        EnumAssignmentValidator.validateEnumAssignment(
+          "MyScope_State",
+          expression,
+        ),
       ).not.toThrow();
     });
 
     it("allows global.Enum.MEMBER pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "global.Color.RED" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).not.toThrow();
     });
 
     it("throws for global.WrongEnum.MEMBER pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color", "Status"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "global.Status.OK" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).toThrow("Cannot assign non-enum value to Color enum");
     });
 
+    it("allows global.structVar.enumField (non-enum parts[1])", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EValueId"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
+      const expression = {
+        getText: () => "global.input.assignedValue",
+      } as never;
+
+      // Should NOT throw — parts[1] "input" is not a known enum
+      expect(() =>
+        EnumAssignmentValidator.validateEnumAssignment("EValueId", expression),
+      ).not.toThrow();
+    });
+
     it("allows scoped enum pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Scope_State"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "Scope.State.ACTIVE" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Scope_State", expression),
+        EnumAssignmentValidator.validateEnumAssignment(
+          "Scope_State",
+          expression,
+        ),
       ).not.toThrow();
     });
 
     it("throws for wrong scoped enum pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Scope_State"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "Other.State.ACTIVE" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Scope_State", expression),
+        EnumAssignmentValidator.validateEnumAssignment(
+          "Scope_State",
+          expression,
+        ),
       ).toThrow("Cannot assign non-enum value to Scope_State enum");
     });
 
     it("throws for this.WrongEnum.MEMBER with wrong scoped name", () => {
-      const validator = new EnumAssignmentValidator({
+      CodeGenState.currentScope = "MyScope";
+      CodeGenState.symbols = createMockSymbols({
         knownEnums: new Set(["MyScope_State"]),
-        getCurrentScope: () => "MyScope",
-        getExpressionEnumType: () => null,
-        isIntegerExpression: () => false,
       });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
 
       const expression = { getText: () => "this.Wrong.ACTIVE" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("MyScope_State", expression),
+        EnumAssignmentValidator.validateEnumAssignment(
+          "MyScope_State",
+          expression,
+        ),
       ).toThrow("Cannot assign non-enum value to MyScope_State enum");
     });
 
     it("throws for variable.field access on non-enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "someVar.field" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).toThrow("Cannot assign non-enum value to Color enum");
     });
 
     it("allows variable.field when variable is a known enum", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Color", "Status"]),
+      });
+      vi.spyOn(EnumTypeResolver, "resolve").mockReturnValue(null);
+
       const expression = { getText: () => "Status.OK" } as never;
 
       expect(() =>
-        validator.validateEnumAssignment("Color", expression),
+        EnumAssignmentValidator.validateEnumAssignment("Color", expression),
       ).not.toThrow();
     });
   });
+
+  describe("isIntegerExpression", () => {
+    it("returns true for decimal literals", () => {
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "42",
+        } as never),
+      ).toBe(true);
+    });
+
+    it("returns true for hex literals", () => {
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "0xFF",
+        } as never),
+      ).toBe(true);
+    });
+
+    it("returns true for binary literals", () => {
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "0b1010",
+        } as never),
+      ).toBe(true);
+    });
+
+    it("returns true for integer-typed variable", () => {
+      CodeGenState.typeRegistry.set("count", {
+        baseType: "u32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
+      });
+
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "count",
+        } as never),
+      ).toBe(true);
+    });
+
+    it("returns false for enum-typed variable", () => {
+      CodeGenState.typeRegistry.set("state", {
+        baseType: "State",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+        isEnum: true,
+        enumTypeName: "State",
+      });
+
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "state",
+        } as never),
+      ).toBe(false);
+    });
+
+    it("returns false for non-integer expression", () => {
+      expect(
+        EnumAssignmentValidator.isIntegerExpression({
+          getText: () => "foo.bar",
+        } as never),
+      ).toBe(false);
+    });
+  });
 });