c-next 0.1.62 → 0.1.63

package/src/transpiler/output/codegen/resolution/__tests__/EnumTypeResolver.test.ts

@@ -0,0 +1,336 @@
+/**
+ * Tests for EnumTypeResolver - enum type inference from expressions
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import EnumTypeResolver from "../EnumTypeResolver";
+import CodeGenState from "../../CodeGenState";
+import SymbolTable from "../../../../logic/symbols/SymbolTable";
+import ICodeGenSymbols from "../../../../types/ICodeGenSymbols";
+
+describe("EnumTypeResolver", () => {
+  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(() => {
+    CodeGenState.reset();
+  });
+
+  describe("resolve() - function call patterns", () => {
+    it("resolves function call returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves this.method() returning enum type", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "this.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves global.func() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["getGlobalState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "global.getGlobalState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves Scope.method() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownScopes: new Set(["Motor"]),
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "Motor.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves global.Scope.method() returning enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownScopes: new Set(["Motor"]),
+        knownEnums: new Set(["State"]),
+        functionReturnTypes: new Map([["Motor_getState", "State"]]),
+      });
+
+      const mockCtx = { getText: () => "global.Motor.getState()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("returns null for function returning non-enum type", () => {
+      CodeGenState.symbols = createMockSymbols({
+        functionReturnTypes: new Map([["getValue", "u32"]]),
+      });
+
+      const mockCtx = { getText: () => "getValue()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for unknown function", () => {
+      CodeGenState.symbols = createMockSymbols();
+
+      const mockCtx = { getText: () => "unknownFunc()" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+
+  describe("resolve() - simple identifier patterns", () => {
+    it("resolves enum variable by type registry lookup", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+      });
+      CodeGenState.typeRegistry.set("currentState", {
+        baseType: "State",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+        isEnum: true,
+        enumTypeName: "State",
+      });
+
+      const mockCtx = { getText: () => "currentState" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("returns null for non-enum variable", () => {
+      CodeGenState.typeRegistry.set("count", {
+        baseType: "u32",
+        bitWidth: 32,
+        isArray: false,
+        isConst: false,
+      });
+
+      const mockCtx = { getText: () => "count" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+
+  describe("resolve() - member access patterns", () => {
+    it("resolves simple enum member access: State.IDLE", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["State"]),
+      });
+
+      const mockCtx = { getText: () => "State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("State");
+    });
+
+    it("resolves scoped enum: Motor.State.IDLE -> Motor_State", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "Motor.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+
+    it("resolves this.Enum.MEMBER inside scope", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "this.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+
+    it("resolves global.Enum.MEMBER pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["ECategory"]),
+      });
+
+      const mockCtx = { getText: () => "global.ECategory.CAT_A" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("ECategory");
+    });
+
+    it("resolves this.variable pattern for enum-typed scope member", () => {
+      CodeGenState.currentScope = "Motor";
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+      CodeGenState.typeRegistry.set("Motor_current", {
+        baseType: "Motor_State",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+        isEnum: true,
+        enumTypeName: "Motor_State",
+      });
+
+      const mockCtx = { getText: () => "this.current" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBe("Motor_State");
+    });
+  });
+
+  describe("resolve() - TypeResolver fallback for struct member chains", () => {
+    /**
+     * Helper to build a mock ExpressionContext that contains a full postfix
+     * expression tree: global.input.assignedValue
+     */
+    const buildStructChainCtx = (
+      primaryToken: "GLOBAL" | "THIS" | "IDENTIFIER",
+      primaryText: string,
+      suffixes: string[],
+    ) => {
+      const primary = {
+        IDENTIFIER: () =>
+          primaryToken === "IDENTIFIER" ? { getText: () => primaryText } : null,
+        GLOBAL: () =>
+          primaryToken === "GLOBAL" ? { getText: () => "global" } : null,
+        THIS: () =>
+          primaryToken === "THIS" ? { getText: () => "this" } : null,
+        literal: () => null,
+        expression: () => null,
+        castExpression: () => null,
+      };
+      const children = [
+        { getText: () => primaryText },
+        ...suffixes.map((s) => ({ getText: () => s })),
+      ];
+      const postfix = { primaryExpression: () => primary, children };
+
+      // Build the full expression tree wrapping the postfix
+      const unary = {
+        postfixExpression: () => postfix,
+        unaryExpression: () => null,
+      };
+      const mult = { unaryExpression: () => [unary] };
+      const add = { multiplicativeExpression: () => [mult] };
+      const shift = { additiveExpression: () => [add] };
+      const bitAnd = { shiftExpression: () => [shift] };
+      const bitXor = { bitwiseAndExpression: () => [bitAnd] };
+      const bitOr = { bitwiseXorExpression: () => [bitXor] };
+      const rel = { bitwiseOrExpression: () => [bitOr] };
+      const eq = { relationalExpression: () => [rel] };
+      const and = { equalityExpression: () => [eq] };
+      const or = { andExpression: () => [and] };
+      const ternary = { orExpression: () => [or] };
+
+      return {
+        getText: () => primaryText + suffixes.join(""),
+        ternaryExpression: () => ternary,
+      } as never;
+    };
+
+    it("resolves global.struct.enumField via TypeResolver fallback", () => {
+      const symbolTable = new SymbolTable();
+      symbolTable.addStructField("TInput", "assignedValue", "EValueId");
+      CodeGenState.symbolTable = symbolTable;
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["EValueId"]),
+      });
+      CodeGenState.typeRegistry.set("input", {
+        baseType: "TInput",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+      });
+
+      const ctx = buildStructChainCtx("GLOBAL", "global", [
+        ".input",
+        ".assignedValue",
+      ]);
+      expect(EnumTypeResolver.resolve(ctx)).toBe("EValueId");
+    });
+
+    it("returns null when struct field is not an enum type", () => {
+      const symbolTable = new SymbolTable();
+      symbolTable.addStructField("TInput", "count", "u32");
+      CodeGenState.symbolTable = symbolTable;
+      CodeGenState.symbols = createMockSymbols();
+      CodeGenState.typeRegistry.set("input", {
+        baseType: "TInput",
+        bitWidth: 0,
+        isArray: false,
+        isConst: false,
+      });
+
+      const ctx = buildStructChainCtx("GLOBAL", "global", [".input", ".count"]);
+      expect(EnumTypeResolver.resolve(ctx)).toBeNull();
+    });
+
+    it("returns null for RelationalExpressionContext (no ternaryExpression)", () => {
+      CodeGenState.symbols = createMockSymbols();
+      // RelationalExpressionContext doesn't have ternaryExpression
+      const ctx = { getText: () => "something.weird" } as never;
+      expect(EnumTypeResolver.resolve(ctx)).toBeNull();
+    });
+  });
+
+  describe("resolve() - edge cases", () => {
+    it("returns null for this.Enum.MEMBER when not in a scope", () => {
+      CodeGenState.currentScope = null;
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(["Motor_State"]),
+      });
+
+      const mockCtx = { getText: () => "this.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for this.variable when not in a scope", () => {
+      CodeGenState.currentScope = null;
+
+      const mockCtx = { getText: () => "this.current" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for unknown enum in scoped pattern", () => {
+      CodeGenState.symbols = createMockSymbols({
+        knownEnums: new Set(), // No enums
+      });
+
+      const mockCtx = { getText: () => "Motor.State.IDLE" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+
+    it("returns null for single identifier that is not in type registry", () => {
+      CodeGenState.symbols = createMockSymbols();
+
+      const mockCtx = { getText: () => "unknownVar" };
+      expect(EnumTypeResolver.resolve(mockCtx as never)).toBeNull();
+    });
+  });
+});

package/src/transpiler/output/codegen/resolution/__tests__/SizeofResolver.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Tests for SizeofResolver - sizeof expression generation
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import SizeofResolver from "../SizeofResolver";
+import CodeGenState from "../../CodeGenState";
+
+describe("SizeofResolver", () => {
+  beforeEach(() => {
+    CodeGenState.reset();
+  });
+
+  describe("sizeofParameter", () => {
+    it("throws E0601 for array parameter", () => {
+      // Set up parameter info indicating array
+      CodeGenState.currentParameters.set("arr", {
+        name: "arr",
+        baseType: "u32",
+        isArray: true,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      // Create a mock context for sizeof(arr)
+      const mockTypeCtx = {
+        qualifiedType: () => null,
+        userType: () => ({ getText: () => "arr" }),
+        getText: () => "arr",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      expect(() =>
+        SizeofResolver.generate(mockCtx as never, mockCallbacks),
+      ).toThrow("Error[E0601]");
+    });
+
+    it("generates dereference for pass-by-reference parameter", () => {
+      // Non-array, non-callback, non-struct parameter is pass-by-reference
+      CodeGenState.currentParameters.set("value", {
+        name: "value",
+        baseType: "u32",
+        isArray: false,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => null,
+        userType: () => ({ getText: () => "value" }),
+        getText: () => "value",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(*value)");
+    });
+  });
+
+  describe("sizeofQualifiedType", () => {
+    it("handles struct.member access for local variable", () => {
+      CodeGenState.localVariables.add("myStruct");
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "myStruct" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "myStruct.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(myStruct.field)");
+    });
+
+    it("handles struct parameter with arrow notation", () => {
+      CodeGenState.currentParameters.set("param", {
+        name: "param",
+        baseType: "MyStruct",
+        isArray: false,
+        isStruct: true,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "param" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "param.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(param->field)");
+    });
+
+    it("handles non-struct parameter with dot notation", () => {
+      CodeGenState.currentParameters.set("param", {
+        name: "param",
+        baseType: "MyStruct",
+        isArray: false,
+        isStruct: false,
+        isConst: false,
+        isCallback: false,
+        isString: false,
+      });
+
+      const mockCallbacks = {
+        generateType: vi.fn(),
+        generateExpression: vi.fn(),
+        hasSideEffects: vi.fn().mockReturnValue(false),
+      };
+
+      const mockQualifiedCtx = {
+        IDENTIFIER: () => [
+          { getText: () => "param" },
+          { getText: () => "field" },
+        ],
+      };
+
+      const mockTypeCtx = {
+        qualifiedType: () => mockQualifiedCtx,
+        userType: () => null,
+        getText: () => "param.field",
+      };
+
+      const mockCtx = {
+        type: () => mockTypeCtx,
+        expression: () => null,
+      };
+
+      const result = SizeofResolver.generate(mockCtx as never, mockCallbacks);
+
+      expect(result).toBe("sizeof(param.field)");
+    });
+  });
+
+  // Note: sizeofExpression with side effects is tested via integration tests
+  // The mock structure required is too complex for unit testing
+});

package/src/transpiler/output/codegen/types/ITypeResolverDeps.ts

@@ -1,23 +0,0 @@
-/**
- * Dependencies for TypeResolver - allows TypeResolver to be independent of CodeGenerator
- * Issue #61: Extracted dependencies for better separation of concerns
- */
-import ICodeGenSymbols from "../../../types/ICodeGenSymbols";
-import SymbolTable from "../../../logic/symbols/SymbolTable";
-import TTypeInfo from "./TTypeInfo";
-
-interface ITypeResolverDeps {
-  /** Symbol information from C-Next source (ADR-055: ICodeGenSymbols) */
-  symbols: ICodeGenSymbols | null;
-
-  /** Symbol table for C header struct lookups */
-  symbolTable: SymbolTable | null;
-
-  /** Type registry for variable type information */
-  typeRegistry: Map<string, TTypeInfo>;
-
-  /** Callback to resolve identifiers to scoped names */
-  resolveIdentifier: (name: string) => string;
-}
-
-export default ITypeResolverDeps;

package/src/transpiler/output/codegen/types/ITypeValidatorDeps.ts

@@ -1,53 +0,0 @@
-/**
- * Dependencies for TypeValidator - allows TypeValidator to be independent of CodeGenerator
- * Issue #63: Extracted dependencies for better separation of concerns
- */
-import ICodeGenSymbols from "../../../types/ICodeGenSymbols";
-import SymbolTable from "../../../logic/symbols/SymbolTable";
-import TTypeInfo from "./TTypeInfo";
-import TParameterInfo from "./TParameterInfo";
-import ICallbackTypeInfo from "./ICallbackTypeInfo";
-import TypeResolver from "../TypeResolver";
-
-interface ITypeValidatorDeps {
-  /** Symbol information from C-Next source (ADR-055: ICodeGenSymbols) */
-  symbols: ICodeGenSymbols | null;
-
-  /** Symbol table for C header struct lookups */
-  symbolTable: SymbolTable | null;
-
-  /** Type registry for variable type information */
-  typeRegistry: Map<string, TTypeInfo>;
-
-  /** Type resolver for type checking operations (Issue #61) */
-  typeResolver: TypeResolver;
-
-  /** Callback type definitions for signature validation */
-  callbackTypes: Map<string, ICallbackTypeInfo>;
-
-  /** Known function names in the program */
-  knownFunctions: Set<string>;
-
-  /** Known global variable names */
-  knownGlobals: Set<string>;
-
-  /** Callback to get current scope name */
-  getCurrentScope: () => string | null;
-
-  /** Callback to get scope members map */
-  getScopeMembers: () => Map<string, Set<string>>;
-
-  /** Callback to get current function parameters */
-  getCurrentParameters: () => Map<string, TParameterInfo>;
-
-  /** Callback to get local variables in current function */
-  getLocalVariables: () => Set<string>;
-
-  /** Callback to resolve identifiers to scoped names */
-  resolveIdentifier: (name: string) => string;
-
-  /** Callback to get expression type */
-  getExpressionType: (ctx: unknown) => string | null;
-}
-
-export default ITypeValidatorDeps;