@tsonic/frontend 0.0.73 → 0.0.75

package/dist/validator.test.js

@@ -1,1087 +1,5 @@
-/**
- * Tests for validator - now only checks truly unsupported features
- *
- * Most generic constructs are now handled via:
- * - Monomorphisation
- * - CRTP pattern
- * - Tuple specialisations
- * - Structural adapters
- */
-import { describe, it } from "mocha";
-import { expect } from "chai";
-import * as ts from "typescript";
-import { validateProgram } from "./validator.js";
-import { DotnetMetadataRegistry } from "./dotnet-metadata.js";
-import { BindingRegistry } from "./program/bindings.js";
-import { createClrBindingsResolver } from "./resolver/clr-bindings-resolver.js";
-import { createBinding } from "./ir/binding/index.js";
-/**
- * Helper to create a test program from source code
- */
-const createTestProgram = (source, fileName = "test.ts") => {
-    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const compilerOptions = {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.NodeNext,
-        strict: true,
-        noEmit: true,
-    };
-    const host = ts.createCompilerHost(compilerOptions);
-    const originalGetSourceFile = host.getSourceFile;
-    host.getSourceFile = (name, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
-        if (name === fileName) {
-            return sourceFile;
-        }
-        return originalGetSourceFile.call(host, name, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-    };
-    const program = ts.createProgram([fileName], compilerOptions, host);
-    const checker = program.getTypeChecker();
-    return {
-        program,
-        checker,
-        options: {
-            projectRoot: "/test",
-            sourceRoot: "/test",
-            rootNamespace: "Test",
-        },
-        sourceFiles: [sourceFile],
-        declarationSourceFiles: [],
-        metadata: new DotnetMetadataRegistry(),
-        bindings: new BindingRegistry(),
-        clrResolver: createClrBindingsResolver("/test"),
-        binding: createBinding(checker),
-    };
-};
-describe("Generic Validation", () => {
-    describe("TSN7106 - Extension Method Receiver Marker", () => {
-        it("should allow thisarg<T> on first parameter of a top-level function declaration", () => {
-            const source = `
-        import type { thisarg } from "@tsonic/core/lang.js";
-
-        export function where(x: thisarg<number>, y: number): number {
-          return x + y;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7106");
-            expect(diag).to.equal(undefined);
-        });
-        it("should reject thisarg<T> when not the first parameter", () => {
-            const source = `
-        import type { thisarg } from "@tsonic/core/lang.js";
-
-        export function where(y: number, x: thisarg<number>): number {
-          return x + y;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7106");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("must be the first parameter");
-        });
-        it("should reject thisarg<T> on class methods", () => {
-            const source = `
-        import type { thisarg } from "@tsonic/core/lang.js";
-
-        export class Extensions {
-          static where(x: thisarg<number>, y: number): number {
-            return x + y;
-          }
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7106");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("only valid on top-level function declarations");
-        });
-        it("should reject thisarg<T> on arrow functions", () => {
-            const source = `
-        import type { thisarg } from "@tsonic/core/lang.js";
-
-        export const where = (x: thisarg<number>, y: number): number => x + y;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7106");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("only valid on top-level function declarations");
-        });
-        it("should reject out receiver on thisarg<T> parameters", () => {
-            const source = `
-        import type { thisarg } from "@tsonic/core/lang.js";
-        import type { out } from "@tsonic/core/types.js";
-
-        export function tryGetCount(xs: out<thisarg<number>>): number {
-          return xs;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7106");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("cannot be `out`");
-        });
-    });
-    describe("TSN7440 - Core Intrinsic Provenance", () => {
-        it("should reject locally declared core numeric aliases (int)", () => {
-            const source = `
-        type int = number;
-
-        export const x: int = 1 as int;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7440");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("Core intrinsic 'int'");
-        });
-        it("should reject locally declared core lang intrinsics (stackalloc)", () => {
-            const source = `
-        function stackalloc<T>(size: number): T {
-          throw new Error("not implemented");
-        }
-
-        export function main(): void {
-          stackalloc<number>(123);
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7440");
-            expect(diag).not.to.equal(undefined);
-            expect(diag?.message).to.include("Core intrinsic 'stackalloc'");
-        });
-        it("should allow core intrinsics when imported from @tsonic/core", () => {
-            const source = `
-        import type { int } from "@tsonic/core/types.js";
-        import { stackalloc, nameof, sizeof } from "@tsonic/core/lang.js";
-
-        export const x: int = 1 as int;
-        export const fieldName = nameof(x);
-        export const intSize: int = sizeof<int>();
-
-        export function main(): void {
-          stackalloc<int>(10 as int);
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7440");
-            expect(diag).to.equal(undefined);
-        });
-    });
-    describe("TSN7203 retired - Symbol index signatures", () => {
-        it("should allow symbol index signatures", () => {
-            const source = `
-        export interface WithSymbolIndex {
-          [key: symbol]: string;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
-            expect(symbolDiag).to.equal(undefined);
-        });
-        it("should not flag string index signatures", () => {
-            const source = `
-        interface WithStringIndex {
-          [key: string]: number;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
-            expect(symbolDiag).to.equal(undefined);
-        });
-        it("should not flag number index signatures", () => {
-            const source = `
-        interface WithNumberIndex {
-          [key: number]: string;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
-            expect(symbolDiag).to.equal(undefined);
-        });
-        it("should allow Record<symbol, V> without TSN7203", () => {
-            const source = `
-        type SymbolMap = Record<symbol, number>;
-        const table: SymbolMap = {} as SymbolMap;
-        void table;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
-            expect(symbolDiag).to.equal(undefined);
-        });
-        it("should allow mixed PropertyKey unions including symbol", () => {
-            const source = `
-        type Key = string | number | symbol;
-        type Map = Record<Key, number>;
-        const table: Map = {} as Map;
-        void table;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const symbolDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7203");
-            expect(symbolDiag).to.equal(undefined);
-        });
-    });
-    describe("Previously-blocked constructs (now ALLOWED)", () => {
-        it("should allow recursive mapped types (handled via monomorphisation)", () => {
-            const source = `
-        type RecursiveMapped<T> = {
-          [K in keyof T]: RecursiveMapped<T[K]>
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should NOT have TSN7101 error anymore
-            const recursiveDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7101");
-            expect(recursiveDiag).to.equal(undefined);
-        });
-        it("should allow conditional types with infer (handled via monomorphisation)", () => {
-            const source = `
-        type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should NOT have TSN7102 error anymore
-            const inferDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7102");
-            expect(inferDiag).to.equal(undefined);
-        });
-        it("should allow this typing (handled via CRTP pattern)", () => {
-            const source = `
-        interface Chainable {
-          add(value: number): this;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should NOT have TSN7103 error anymore
-            const thisDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7103");
-            expect(thisDiag).to.equal(undefined);
-        });
-        it("should allow variadic type parameters (handled via tuple specialisations)", () => {
-            const source = `
-        type VariadicFunction<T extends unknown[]> = (...args: T) => void;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should NOT have TSN7104 error anymore
-            const variadicDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7104");
-            expect(variadicDiag).to.equal(undefined);
-        });
-        it("should allow recursive structural aliases (emit as C# classes)", () => {
-            const source = `
-        type Node = {
-          name: string;
-          children: Node[];
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should NOT have TSN7201 error anymore
-            const recursiveDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7201");
-            expect(recursiveDiag).to.equal(undefined);
-        });
-        it("should allow complex generic code without errors", () => {
-            const source = `
-        // Conditional type with infer
-        type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-
-        // This typing
-        interface Builder {
-          set(key: string, value: any): this;
-        }
-
-        // Variadic parameters
-        function concat<T extends any[]>(...arrays: T): T {
-          return arrays;
-        }
-
-        // Recursive structural alias
-        type Tree = {
-          value: number;
-          left?: Tree;
-          right?: Tree;
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should have NO generic-specific diagnostics (TSN71xx, TSN72xx)
-            // Note: TSN74xx (static safety) may fire due to 'any' in test code, but that's expected
-            const genericDiags = diagnostics.diagnostics.filter((d) => d.code.startsWith("TSN71") || d.code.startsWith("TSN72"));
-            expect(genericDiags).to.have.lengthOf(0);
-        });
-    });
-});
-describe("Static Safety Validation", () => {
-    describe("TSN7401 - 'any' type banned", () => {
-        it("should reject explicit any type annotation", () => {
-            const source = `
-        export const x: any = 1;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
-            expect(anyDiag).not.to.equal(undefined);
-            expect(anyDiag?.message).to.include("'any' type is not supported");
-        });
-        it("should reject 'as any' type assertion", () => {
-            const source = `
-        export const x = (123 as any);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
-            expect(anyDiag).not.to.equal(undefined);
-            expect(anyDiag?.message).to.include("'as any'");
-        });
-        it("should allow unknown type", () => {
-            const source = `
-        export function process(data: unknown): void {
-          console.log(data);
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const anyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7401");
-            expect(anyDiag).to.equal(undefined);
-        });
-    });
-    describe("TSN7403 - Object literal requires nominal type", () => {
-        it("should allow simple object literal (auto-synthesis)", () => {
-            // Simple object literals with identifier keys are now synthesized automatically
-            const source = `
-        const a = { x: 1 };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with method shorthand", () => {
-            const source = `
-        const a = { foo(x: number): number { return x + 1; } };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with computed string-literal method key", () => {
-            const source = `
-        const a = { ["foo"](x: number): number { return x + 1; } };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with computed const-literal property and accessor keys", () => {
-            const source = `
-        const valueKey = "value";
-        const doubledKey = "doubled";
-        const a = {
-          [valueKey]: 2,
-          get [doubledKey](): number {
-            return this.value * 2;
-          },
-        };
-        void a.doubled;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with computed const-literal numeric property key", () => {
-            const source = `
-        const slot = 1;
-        const a = { [slot]: 7 };
-        void a;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal method shorthand that uses this", () => {
-            const source = `
-        const a = {
-          x: 1,
-          foo(): number {
-            return this.x;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal method shorthand that uses arguments.length with fixed required parameters", () => {
-            const source = `
-        const a = {
-          foo(x: number): number {
-            return arguments.length + x;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal method shorthand that uses arguments[n] with fixed required identifier parameters", () => {
-            const source = `
-        const a = {
-          foo(x: number, y: number): number {
-            return (arguments[0] as number) + y;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should reject object literal method shorthand that uses unsupported arguments patterns", () => {
-            const source = `
-        const a = {
-          foo(x?: number): number {
-            return arguments[0] as number;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).not.to.equal(undefined);
-            expect(objDiag?.message).to.include("arguments");
-        });
-        it("should allow object literal getter shorthand", () => {
-            const source = `
-        const a = {
-          get foo(): number {
-            return 1;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal getter shorthand that returns this-bound property type", () => {
-            const source = `
-        const counter = {
-          x: 1,
-          get value() {
-            return this.x;
-          },
-        };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with interface type", () => {
-            const source = `
-        interface Point { x: number; y: number }
-        const p: Point = { x: 1, y: 2 };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-        it("should allow object literal with Record type", () => {
-            const source = `
-        const d: Record<string, number> = { a: 1, b: 2 };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const objDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7403");
-            expect(objDiag).to.equal(undefined);
-        });
-    });
-    describe("TSN7405 - Untyped function parameters", () => {
-        it("should reject untyped function parameter", () => {
-            const source = `
-        export function greet(name): void {
-          console.log(name);
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).not.to.equal(undefined);
-            expect(paramDiag?.message).to.include("explicit type annotation");
-        });
-        it("should reject untyped arrow function parameter", () => {
-            const source = `
-        const fn = (x) => x + 1;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).not.to.equal(undefined);
-            expect(paramDiag?.message).to.include("explicit type annotation");
-        });
-        it("should reject untyped function expression parameter", () => {
-            const source = `
-        const fn = function(x) { return x + 1; };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).not.to.equal(undefined);
-            expect(paramDiag?.message).to.include("explicit type annotation");
-        });
-        it("should allow typed function parameter", () => {
-            const source = `
-        export function greet(name: string): void {
-          console.log(name);
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow typed arrow function parameter", () => {
-            const source = `
-        const fn = (x: number): number => x + 1;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        // Contextual type inference tests
-        it("should allow lambda with contextually inferred params in array.sort", () => {
-            const source = `
-        const nums: number[] = [3, 1, 2];
-        const sorted = nums.sort((a, b) => a - b);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow lambda with contextually inferred params in array.map", () => {
-            const source = `
-        const nums: number[] = [1, 2, 3];
-        const doubled = nums.map((x) => x * 2);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow lambda with contextually inferred params in array.filter", () => {
-            const source = `
-        const nums: number[] = [1, 2, 3, 4];
-        const evens = nums.filter((x) => x % 2 === 0);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow lambda with contextually inferred params in array.find", () => {
-            const source = `
-        const nums: number[] = [1, 2, 3];
-        const found = nums.find((x) => x > 2);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow lambda assigned to typed function variable", () => {
-            const source = `
-        const fn: (x: number) => number = (x) => x + 1;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow lambda passed to higher-order function", () => {
-            const source = `
-        function apply(fn: (x: number) => number, value: number): number {
-          return fn(value);
-        }
-        const result = apply((x) => x * 2, 5);
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow Promise executor callback without explicit types", () => {
-            const source = `
-        export async function delay(ms: number): Promise<void> {
-          return new Promise((resolve) => {
-            setTimeout(resolve, ms);
-          });
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow Promise executor with both resolve and reject", () => {
-            const source = `
-        export function fetchData(): Promise<string> {
-          return new Promise((resolve, reject) => {
-            resolve("data");
-          });
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const paramDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7405");
-            expect(paramDiag).to.equal(undefined);
-        });
-        it("should allow contextual Promise constructor inference without explicit type arguments", () => {
-            const source = `
-        export function delay(ms: number): Promise<void> {
-          return new Promise((resolve) => {
-            setTimeout(() => resolve(), ms);
-          });
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const typeArgDiag = diagnostics.diagnostics.find((d) => d.code === "TSN5202");
-            expect(typeArgDiag).to.equal(undefined);
-        });
-    });
-    describe("TSN7413 - Dictionary key type validation", () => {
-        it("should allow Record with string key", () => {
-            const source = `
-        const d: Record<string, number> = {};
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow Record with number key", () => {
-            const source = `
-        const d: Record<number, string> = {};
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow index signature with string key", () => {
-            const source = `
-        interface StringIndexed {
-          [key: string]: number;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow index signature with number key", () => {
-            const source = `
-        interface NumIndexed {
-          [key: number]: string;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow Record with symbol key", () => {
-            const source = `
-        const d: Record<symbol, string> = {};
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow index signature with symbol key", () => {
-            const source = `
-        interface SymIndexed {
-          [key: symbol]: string;
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow symbol-typed key values in dictionary access", () => {
-            const source = `
-        function read(table: Record<symbol, number>, key: symbol): number {
-          return table[key];
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            const typeDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7414");
-            expect(keyDiag).to.equal(undefined);
-            expect(typeDiag).to.equal(undefined);
-        });
-        it("should reject Record with object key type", () => {
-            const source = `
-        interface Key { id: string; }
-        const d: Record<Key, string> = {};
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(keyDiag).not.to.equal(undefined);
-        });
-    });
-    describe("Intersection types are supported", () => {
-        it("should allow intersection type", () => {
-            const source = `
-        interface Named { name: string; }
-        interface Aged { age: number; }
-        type Person = Named & Aged;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const intDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7410");
-            expect(intDiag).to.equal(undefined);
-        });
-        it("should allow nested intersection type", () => {
-            const source = `
-        interface A { a: string; }
-        interface B { b: number; }
-        interface C { c: boolean; }
-        type ABC = A & B & C;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const intDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7410");
-            expect(intDiag).to.equal(undefined);
-        });
-    });
-    describe("Mapped utility types now supported", () => {
-        it("should accept Partial<T>", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        type PartialPerson = Partial<Person>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Required<T>", () => {
-            const source = `
-        interface Person { name?: string; }
-        type RequiredPerson = Required<Person>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Readonly<T>", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        type ReadonlyPerson = Readonly<Person>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Pick<T, K>", () => {
-            const source = `
-        interface Person { name: string; age: number; email: string; }
-        type NameOnly = Pick<Person, "name">;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Omit<T, K>", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        type NoAge = Omit<Person, "age">;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept nested utility types (Partial<Readonly<T>>)", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        type PartialReadonlyPerson = Partial<Readonly<Person>>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Pick with multiple keys", () => {
-            const source = `
-        interface Person { name: string; age: number; email: string; phone: string; }
-        type ContactInfo = Pick<Person, "name" | "email" | "phone">;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Omit with multiple keys", () => {
-            const source = `
-        interface Person { name: string; age: number; email: string; phone: string; }
-        type MinimalPerson = Omit<Person, "email" | "phone">;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Required on type with mixed optional properties", () => {
-            const source = `
-        interface MixedPerson { name: string; age?: number; email?: string; }
-        type FullPerson = Required<MixedPerson>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Partial on type with already optional properties", () => {
-            const source = `
-        interface OptionalPerson { name?: string; age?: number; }
-        type StillOptional = Partial<OptionalPerson>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Readonly on type with readonly properties", () => {
-            const source = `
-        interface PartiallyReadonly { readonly id: string; name: string; }
-        type FullyReadonly = Readonly<PartiallyReadonly>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept utility types in variable declarations", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        const update: Partial<Person> = { name: "Alice" };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept utility types in function parameters", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        function updatePerson(person: Person, updates: Partial<Person>): Person {
-          return { ...person, ...updates };
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept utility types in function return type", () => {
-            const source = `
-        interface Person { name: string; age: number; }
-        function getPartialPerson(): Partial<Person> {
-          return { name: "Bob" };
-        }
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-    });
-    describe("Conditional utility types are supported", () => {
-        // Extract, Exclude, NonNullable are now supported and expanded at compile time
-        it("should accept Extract<T, U>", () => {
-            const source = `
-        type StringOrNumber = string | number;
-        type OnlyStrings = Extract<StringOrNumber, string>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Exclude<T, U>", () => {
-            const source = `
-        type StringOrNumber = string | number;
-        type NoStrings = Exclude<StringOrNumber, string>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept NonNullable<T>", () => {
-            const source = `
-        type MaybeString = string | null | undefined;
-        type DefinitelyString = NonNullable<MaybeString>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept ReturnType<T> (now supported)", () => {
-            const source = `
-        function greet(name: string): string { return name; }
-        type GreetReturn = ReturnType<typeof greet>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Parameters<T> (now supported)", () => {
-            const source = `
-        function add(a: number, b: number): number { return a + b; }
-        type AddParams = Parameters<typeof add>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept Awaited<T> (now supported)", () => {
-            const source = `
-        type Result = Awaited<Promise<string>>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept ConstructorParameters<T> (now supported)", () => {
-            const source = `
-        class User {
-          constructor(name: string, active: boolean) {}
-        }
-        type CtorParams = ConstructorParameters<typeof User>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-        it("should accept InstanceType<T> (now supported)", () => {
-            const source = `
-        class Product {
-          constructor(public readonly sku: string) {}
-        }
-        type ProductInstance = InstanceType<typeof Product>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-    });
-    describe("Mapped/conditional syntax is supported", () => {
-        it("should allow direct mapped type aliases", () => {
-            const source = `
-        type Mapper<T> = { [K in keyof T]: T[K] };
-        type X = Mapper<{ a: string; b: number }>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            expect(diagnostics.diagnostics.find((d) => d.code === "TSN7406")).to.equal(undefined);
-        });
-        it("should allow direct conditional type aliases", () => {
-            const source = `
-        type C<T> = T extends string ? number : boolean;
-        type A = C<string>;
-        type B = C<number>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            expect(diagnostics.diagnostics.find((d) => d.code === "TSN7407")).to.equal(undefined);
-        });
-        it("should allow infer clauses in conditional aliases", () => {
-            const source = `
-        type Unwrap<T> = T extends Promise<infer U> ? U : T;
-        type N = Unwrap<Promise<number>>;
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            expect(diagnostics.diagnostics.find((d) => d.code === "TSN7409")).to.equal(undefined);
-        });
-    });
-    describe("No false positives for utility-like names", () => {
-        it("should allow user-defined type named Partial without type args", () => {
-            const source = `
-        interface Partial { x: number; y: number; }
-        const p: Partial = { x: 1, y: 2 };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should allow Record<string, T> (string keys are supported)", () => {
-            const source = `
-        type StringDict = Record<string, number>;
-        const d: StringDict = { a: 1, b: 2 };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            // Should not have TSN7406 (mapped type) or TSN7413 (non-string key)
-            const mappedDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            const keyDiag = diagnostics.diagnostics.find((d) => d.code === "TSN7413");
-            expect(mappedDiag).to.equal(undefined);
-            expect(keyDiag).to.equal(undefined);
-        });
-        it("should allow ReadonlyArray<T> (not a mapped type)", () => {
-            const source = `
-        const arr: ReadonlyArray<number> = [1, 2, 3];
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7406");
-            expect(diag).to.equal(undefined);
-        });
-        it("should allow user-defined Extract without type args", () => {
-            const source = `
-        interface Extract { value: string; }
-        const e: Extract = { value: "test" };
-      `;
-            const program = createTestProgram(source);
-            const diagnostics = validateProgram(program);
-            const diag = diagnostics.diagnostics.find((d) => d.code === "TSN7407");
-            expect(diag).to.equal(undefined);
-        });
-    });
-});
+import "./validator-cases/generic-validation.test.js";
+import "./validator-cases/any-and-object-literals.test.js";
+import "./validator-cases/parameters-and-dict-keys.test.js";
+import "./validator-cases/utility-types.test.js";
 //# sourceMappingURL=validator.test.js.map