tstyche 1.0.0-beta.6 → 1.0.0-beta.7

package/build/tstyche.js

@@ -79,18 +79,6 @@ class Environment {
     }
 }
 
-var Color;
-(function (Color) {
-    Color["Reset"] = "0";
-    Color["Red"] = "31";
-    Color["Green"] = "32";
-    Color["Yellow"] = "33";
-    Color["Blue"] = "34";
-    Color["Magenta"] = "35";
-    Color["Cyan"] = "36";
-    Color["Gray"] = "90";
-})(Color || (Color = {}));
-
 class Scribbler {
     #noColor;
     constructor(options) {
@@ -123,7 +111,7 @@ class Scribbler {
             }
             if (element.type === "ansi" && !this.#noColor) {
                 const flags = typeof element.props?.["escapes"] === "string" || Array.isArray(element.props?.["escapes"])
-                    ? element.props?.["escapes"]
+                    ? element.props["escapes"]
                     : undefined;
                 if (flags != null) {
                     return this.#escapeSequence(flags);
@@ -378,6 +366,154 @@ function fileViewText(lines, addEmptyFinalLine) {
         addEmptyFinalLine ? Scribbler.createElement(Line, null) : undefined));
 }
 
+class JsonText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, null, JSON.stringify(this.#sortObject(this.props.input), null, 2));
+    }
+    #sortObject(target) {
+        if (Array.isArray(target)) {
+            return target;
+        }
+        return Object.keys(target)
+            .sort()
+            .reduce((result, key) => {
+            result[key] = target[key];
+            return result;
+        }, {});
+    }
+}
+function formattedText(input) {
+    if (typeof input === "string") {
+        return Scribbler.createElement(Line, null, input);
+    }
+    return Scribbler.createElement(JsonText, { input: input });
+}
+
+const usageExamples = [
+    ["tstyche", "Run all tests."],
+    ["tstyche path/to/first.test.ts second", "Only run the test files with matching path."],
+    ["tstyche --target 4.7,4.8,latest", "Test on all specified versions of TypeScript."],
+];
+class HintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return (Scribbler.createElement(Text, { indent: 1, color: "90" }, this.props.children));
+    }
+}
+class HelpHeaderText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const hint = (Scribbler.createElement(HintText, null,
+            Scribbler.createElement(Text, null, this.props.tstycheVersion)));
+        return (Scribbler.createElement(Line, null,
+            Scribbler.createElement(Text, null, "The TSTyche Type Test Runner"),
+            hint));
+    }
+}
+class CommandText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        let hint = undefined;
+        if (this.props.hint != null) {
+            hint = Scribbler.createElement(HintText, null, this.props.hint);
+        }
+        return (Scribbler.createElement(Line, { indent: 1 },
+            Scribbler.createElement(Text, { color: "34" }, this.props.text),
+            hint));
+    }
+}
+class OptionDescriptionText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
+    }
+}
+class CliUsageText {
+    render() {
+        const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
+            Scribbler.createElement(CommandText, { text: commandText }),
+            Scribbler.createElement(OptionDescriptionText, { text: descriptionText }),
+            Scribbler.createElement(Line, null))));
+        return Scribbler.createElement(Text, null, usageText);
+    }
+}
+class OptionNameText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        return Scribbler.createElement(Text, null,
+            "--",
+            this.props.text);
+    }
+}
+class OptionHintText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        if (this.props.definition.brand === "list") {
+            return (Scribbler.createElement(Text, null,
+                this.props.definition.brand,
+                " of ",
+                this.props.definition.items.brand,
+                "s"));
+        }
+        return Scribbler.createElement(Text, null, this.props.definition.brand);
+    }
+}
+class CliOptionsText {
+    props;
+    constructor(props) {
+        this.props = props;
+    }
+    render() {
+        const definitions = Array.from(this.props.optionDefinitions.values());
+        const optionsText = definitions.map((definition) => (Scribbler.createElement(Text, null,
+            Scribbler.createElement(CommandText, { text: Scribbler.createElement(OptionNameText, { text: definition.name }), hint: Scribbler.createElement(OptionHintText, { definition: definition }) }),
+            Scribbler.createElement(OptionDescriptionText, { text: definition.description }),
+            Scribbler.createElement(Line, null))));
+        return (Scribbler.createElement(Text, null,
+            Scribbler.createElement(Line, null, "CLI Options"),
+            Scribbler.createElement(Line, null),
+            optionsText));
+    }
+}
+class HelpFooterText {
+    render() {
+        return Scribbler.createElement(Line, null, "To learn more, visit https://tstyche.org");
+    }
+}
+function helpText(optionDefinitions, tstycheVersion) {
+    return (Scribbler.createElement(Text, null,
+        Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CliUsageText, null),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(CliOptionsText, { optionDefinitions: optionDefinitions }),
+        Scribbler.createElement(Line, null),
+        Scribbler.createElement(HelpFooterText, null),
+        Scribbler.createElement(Line, null)));
+}
+
 class RowText {
     props;
     constructor(props) {
@@ -651,6 +787,9 @@ class Diagnostic {
         if (options.code != null) {
             this.code = options.code;
         }
+        if (options.origin != null) {
+            this.origin = options.origin;
+        }
         if (options.related != null) {
             this.related = options.related;
         }
@@ -727,10 +866,6 @@ class FileViewService {
         return this.#messages.length > 0;
     }
     addMessage(message) {
-        if (Array.isArray(message)) {
-            this.#messages.push(...message);
-            return;
-        }
         this.#messages.push(message);
     }
     addTest(status, name) {
@@ -1199,14 +1334,12 @@ class TestMember {
     diagnostics;
     members = [];
     name;
-    typeChecker;
     constructor(brand, node, parent, flags) {
         this.brand = brand;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
         this.compiler = parent.compiler;
-        this.typeChecker = parent.typeChecker;
         this.diagnostics = this.#mapDiagnostics(node, this.parent);
         this.name = this.#resolveName(node);
     }
@@ -1304,48 +1437,18 @@ class Assertion extends TestMember {
     get matcherName() {
         return this.matcherNode.expression.name;
     }
-    get sourceArguments() {
+    get source() {
+        if (this.node.typeArguments != null) {
+            return this.node.typeArguments;
+        }
         return this.node.arguments;
     }
-    get sourceType() {
-        if (!this.typeChecker) {
-            return;
-        }
-        if (this.node.typeArguments?.[0]) {
-            return {
-                source: 1,
-                type: this.typeChecker.getTypeFromTypeNode(this.node.typeArguments[0]),
-            };
-        }
-        if (this.node.arguments[0]) {
-            return {
-                source: 0,
-                type: this.typeChecker.getTypeAtLocation(this.node.arguments[0]),
-            };
+    get target() {
+        if (this.matcherNode.typeArguments != null) {
+            return this.matcherNode.typeArguments;
         }
-        return;
-    }
-    get targetArguments() {
         return this.matcherNode.arguments;
     }
-    get targetType() {
-        if (!this.typeChecker) {
-            return;
-        }
-        if (this.matcherNode.typeArguments?.[0]) {
-            return {
-                source: 1,
-                type: this.typeChecker.getTypeFromTypeNode(this.matcherNode.typeArguments[0]),
-            };
-        }
-        if (this.matcherNode.arguments[0]) {
-            return {
-                source: 0,
-                type: this.typeChecker.getTypeAtLocation(this.matcherNode.arguments[0]),
-            };
-        }
-        return;
-    }
     #mapDiagnostics() {
         const mapped = [];
         const unmapped = [];
@@ -1372,12 +1475,6 @@ class Assertion extends TestMember {
     }
 }
 
-var AssertionSource;
-(function (AssertionSource) {
-    AssertionSource[AssertionSource["Argument"] = 0] = "Argument";
-    AssertionSource[AssertionSource["TypeArgument"] = 1] = "TypeArgument";
-})(AssertionSource || (AssertionSource = {}));
-
 class IdentifierLookup {
     compiler;
     #identifiers;
@@ -1478,13 +1575,11 @@ class TestTree {
     compiler;
     diagnostics;
     sourceFile;
-    typeChecker;
     members = [];
-    constructor(compiler, diagnostics, sourceFile, typeChecker) {
+    constructor(compiler, diagnostics, sourceFile) {
         this.compiler = compiler;
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
-        this.typeChecker = typeChecker;
     }
     get hasOnly() {
         function hasOnly(root) {
@@ -1561,8 +1656,8 @@ class CollectService {
             this.#collectTestMembers(node, identifiers, parent);
         });
     }
-    createTestTree(sourceFile, semanticDiagnostics = [], typeChecker) {
-        const testTree = new TestTree(this.compiler, semanticDiagnostics, sourceFile, typeChecker);
+    createTestTree(sourceFile, semanticDiagnostics = []) {
+        const testTree = new TestTree(this.compiler, semanticDiagnostics, sourceFile);
         this.#collectTestMembers(sourceFile, new IdentifierLookup(this.compiler), testTree);
         return testTree;
     }
@@ -1593,408 +1688,551 @@ var TestMemberFlags;
     TestMemberFlags[TestMemberFlags["Todo"] = 8] = "Todo";
 })(TestMemberFlags || (TestMemberFlags = {}));
 
-class ProjectService {
-    compiler;
-    #service;
-    constructor(compiler) {
-        this.compiler = compiler;
-        function doNothing() {
-        }
-        function returnFalse() {
-            return false;
-        }
-        function returnUndefined() {
-            return undefined;
-        }
-        const noopWatcher = { close: doNothing };
-        const noopLogger = {
-            close: doNothing,
-            endGroup: doNothing,
-            getLogFileName: returnUndefined,
-            hasLevel: returnFalse,
-            info: doNothing,
-            loggingEnabled: returnFalse,
-            msg: doNothing,
-            perftrc: doNothing,
-            startGroup: doNothing,
-        };
-        const host = {
-            ...this.compiler.sys,
-            clearImmediate,
-            clearTimeout,
-            setImmediate,
-            setTimeout,
-            watchDirectory: () => noopWatcher,
-            watchFile: () => noopWatcher,
-        };
-        this.#service = new this.compiler.server.ProjectService({
-            cancellationToken: this.compiler.server.nullCancellationToken,
-            host,
-            logger: noopLogger,
-            session: undefined,
-            useInferredProjectPerProjectRoot: true,
-            useSingleInferredProject: false,
-        });
-    }
-    closeFile(filePath) {
-        this.#service.closeClientFile(filePath);
-    }
-    getDefaultProject(filePath) {
-        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
+class PrimitiveTypeMatcher {
+    typeChecker;
+    #targetTypeFlag;
+    #targetTypeText;
+    constructor(typeChecker, targetTypeFlag, targetTypeText) {
+        this.typeChecker = typeChecker;
+        this.#targetTypeFlag = targetTypeFlag;
+        this.#targetTypeText = targetTypeText;
     }
-    getLanguageService(filePath) {
-        const project = this.getDefaultProject(filePath);
-        if (!project) {
-            return;
-        }
-        return project.getLanguageService(true);
+    #explain(sourceType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        return isNot
+            ? [Diagnostic.error(`Type '${this.#targetTypeText}' is identical to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${this.#targetTypeText}' is not identical to type '${sourceTypeText}'.`)];
     }
-    openFile(filePath, sourceText, projectRootPath) {
-        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
-        EventEmitter.dispatch([
-            "project:info",
-            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
-        ]);
-        if (configFileErrors && configFileErrors.length > 0) {
-            EventEmitter.dispatch([
-                "project:error",
-                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
-            ]);
-        }
+    match(sourceType, isNot) {
+        const isMatch = Boolean(sourceType.flags & this.#targetTypeFlag);
+        return {
+            explain: () => this.#explain(sourceType, isNot),
+            isMatch,
+        };
     }
 }
 
-class Checker {
-    compiler;
-    constructor(compiler) {
-        this.compiler = compiler;
-    }
-    #assertNonNullish(value, message) {
-        if (value == null) {
-            throw Error(message);
-        }
+class ToBeAssignable {
+    typeChecker;
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
     }
-    #assertNonNullishSourceType(assertion) {
-        this.#assertNonNullish(assertion.sourceType, "An argument for 'source' was not provided.");
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        const targetTypeText = this.typeChecker.typeToString(targetType);
+        return isNot
+            ? [Diagnostic.error(`Type '${targetTypeText}' is assignable to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not assignable to type '${sourceTypeText}'.`)];
     }
-    #assertNonNullishTargetType(assertion) {
-        this.#assertNonNullish(assertion.targetType, "An argument for 'target' was not provided.");
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeAssignableTo(targetType, sourceType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
     }
-    #assertNonNullishTypeChecker(assertion) {
-        this.#assertNonNullish(assertion.typeChecker, "The 'typeChecker' was not provided.");
+}
+
+class ToEqual {
+    typeChecker;
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
     }
-    #assertStringsOrNumber(expression) {
-        return (expression != null &&
-            (this.compiler.isStringLiteralLike(expression) || this.compiler.isNumericLiteral(expression)));
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        const targetTypeText = this.typeChecker.typeToString(targetType);
+        return isNot
+            ? [Diagnostic.error(`Type '${targetTypeText}' is identical to type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`)];
     }
-    #assertStringsOrNumbers(nodes) {
-        return nodes.every((expression) => this.#assertStringsOrNumber(expression));
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeIdenticalTo(sourceType, targetType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
     }
-    explain(assertion) {
-        this.#assertNonNullishTypeChecker(assertion);
-        const matcher = assertion.matcherName.getText();
-        const origin = {
-            breadcrumbs: assertion.ancestorNames,
-            end: assertion.matcherName.getEnd(),
-            file: assertion.matcherName.getSourceFile(),
-            start: assertion.matcherName.getStart(),
+}
+
+class ToHaveProperty {
+    compiler;
+    typeChecker;
+    constructor(compiler, typeChecker) {
+        this.compiler = compiler;
+        this.typeChecker = typeChecker;
+    }
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        let targetArgumentText;
+        if (this.#isStringOrNumberLiteralType(targetType)) {
+            targetArgumentText = String(targetType.value);
+        }
+        else {
+            targetArgumentText = `[${this.compiler.unescapeLeadingUnderscores(targetType.symbol.escapedName)}]`;
+        }
+        return isNot
+            ? [Diagnostic.error(`Property '${targetArgumentText}' exists on type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Property '${targetArgumentText}' does not exist on type '${sourceTypeText}'.`)];
+    }
+    #isStringOrNumberLiteralType(type) {
+        return Boolean(type.flags & this.compiler.TypeFlags.StringOrNumberLiteral);
+    }
+    match(sourceType, targetType, isNot) {
+        let targetArgumentText;
+        if (this.#isStringOrNumberLiteralType(targetType)) {
+            targetArgumentText = String(targetType.value);
+        }
+        else {
+            targetArgumentText = this.compiler.unescapeLeadingUnderscores(targetType.escapedName);
+        }
+        const isMatch = sourceType.getProperties().some((property) => {
+            return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
+        });
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
         };
-        switch (matcher) {
-            case "toBeAssignable": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is assignable to type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not assignable to type '${sourceTypeText}'.`, origin),
+    }
+}
+
+class ToMatch {
+    typeChecker;
+    constructor(typeChecker) {
+        this.typeChecker = typeChecker;
+    }
+    #explain(sourceType, targetType, isNot) {
+        const sourceTypeText = this.typeChecker.typeToString(sourceType);
+        const targetTypeText = this.typeChecker.typeToString(targetType);
+        return isNot
+            ? [Diagnostic.error(`Type '${targetTypeText}' is a subtype of type '${sourceTypeText}'.`)]
+            : [Diagnostic.error(`Type '${targetTypeText}' is not a subtype of type '${sourceTypeText}'.`)];
+    }
+    match(sourceType, targetType, isNot) {
+        const isMatch = this.typeChecker.isTypeSubtypeOf(sourceType, targetType);
+        return {
+            explain: () => this.#explain(sourceType, targetType, isNot),
+            isMatch,
+        };
+    }
+}
+
+class ToRaiseError {
+    compiler;
+    typeChecker;
+    constructor(compiler, typeChecker) {
+        this.compiler = compiler;
+        this.typeChecker = typeChecker;
+    }
+    #explain(source, targetTypes, isNot) {
+        const sourceText = this.compiler.isTypeNode(source.node) ? "Type expression" : "Expression";
+        if (source.diagnostics.length === 0) {
+            return [Diagnostic.error(`${sourceText} did not raise a type error.`)];
+        }
+        if (isNot && targetTypes.length === 0) {
+            const related = [
+                Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
+                ...Diagnostic.fromDiagnostics(source.diagnostics, this.compiler),
+            ];
+            const text = `${sourceText} raised ${source.diagnostics.length === 1 ? "a" : source.diagnostics.length} type error${source.diagnostics.length === 1 ? "" : "s"}.`;
+            return [Diagnostic.error(text).add({ related })];
+        }
+        if (source.diagnostics.length !== targetTypes.length) {
+            const expectedText = source.diagnostics.length > targetTypes.length
+                ? `only ${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`
+                : `${targetTypes.length} type error${targetTypes.length === 1 ? "" : "s"}`;
+            const foundText = source.diagnostics.length > targetTypes.length
+                ? `${source.diagnostics.length}`
+                : `only ${source.diagnostics.length}`;
+            const related = [
+                Diagnostic.error(`The raised type error${source.diagnostics.length === 1 ? "" : "s"}:`),
+                ...Diagnostic.fromDiagnostics(source.diagnostics, this.compiler),
+            ];
+            const text = `Expected ${expectedText}, but ${foundText} ${source.diagnostics.length === 1 ? "was" : "were"} raised.`;
+            return [Diagnostic.error(text).add({ related })];
+        }
+        const diagnostics = [];
+        targetTypes.forEach((argument, index) => {
+            const diagnostic = source.diagnostics[index];
+            if (!diagnostic) {
+                return;
+            }
+            const isMatch = this.#matchExpectedError(diagnostic, argument);
+            if (!isNot && !isMatch) {
+                const expectedText = this.#isStringLiteralType(argument)
+                    ? `matching substring '${argument.value}'`
+                    : `with code ${argument.value}`;
+                const related = [
+                    Diagnostic.error("The raised type error:"),
+                    ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
+                ];
+                const text = `${sourceText} did not raise a type error ${expectedText}.`;
+                diagnostics.push(Diagnostic.error(text).add({ related }));
+            }
+            if (isNot && isMatch) {
+                const expectedText = this.#isStringLiteralType(argument)
+                    ? `matching substring '${argument.value}'`
+                    : `with code ${argument.value}`;
+                const related = [
+                    Diagnostic.error("The raised type error:"),
+                    ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
                 ];
+                const text = `${sourceText} raised a type error ${expectedText}.`;
+                diagnostics.push(Diagnostic.error(text).add({ related }));
             }
+        });
+        return diagnostics;
+    }
+    #isStringLiteralType(type) {
+        return Boolean(type.flags & this.compiler.TypeFlags.StringLiteral);
+    }
+    match(source, targetTypes, isNot) {
+        const explain = () => this.#explain(source, targetTypes, isNot);
+        if (targetTypes.length === 0) {
+            return {
+                explain,
+                isMatch: source.diagnostics.length > 0,
+            };
+        }
+        if (source.diagnostics.length !== targetTypes.length) {
+            return {
+                explain,
+                isMatch: false,
+            };
+        }
+        return {
+            explain,
+            isMatch: targetTypes.every((type, index) => this.#matchExpectedError(source.diagnostics[index], type)),
+        };
+    }
+    #matchExpectedError(diagnostic, type) {
+        if (this.#isStringLiteralType(type)) {
+            return this.compiler.flattenDiagnosticMessageText(diagnostic?.messageText, " ", 0).includes(type.value);
+        }
+        return type.value === diagnostic?.code;
+    }
+}
+
+class Expect {
+    compiler;
+    typeChecker;
+    toBeAny;
+    toBeAssignable;
+    toBeBigInt;
+    toBeBoolean;
+    toBeNever;
+    toBeNull;
+    toBeNumber;
+    toBeString;
+    toBeSymbol;
+    toBeUndefined;
+    toBeUniqueSymbol;
+    toBeUnknown;
+    toBeVoid;
+    toEqual;
+    toHaveProperty;
+    toMatch;
+    toRaiseError;
+    constructor(compiler, typeChecker) {
+        this.compiler = compiler;
+        this.typeChecker = typeChecker;
+        this.toBeAny = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Any, "any");
+        this.toBeAssignable = new ToBeAssignable(this.typeChecker);
+        this.toBeBigInt = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.BigInt, "bigint");
+        this.toBeBoolean = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Boolean, "boolean");
+        this.toBeNever = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Never, "never");
+        this.toBeNull = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Null, "null");
+        this.toBeNumber = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Number, "number");
+        this.toBeString = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.String, "string");
+        this.toBeSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.ESSymbol, "symbol");
+        this.toBeUndefined = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Undefined, "undefined");
+        this.toBeUniqueSymbol = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.UniqueESSymbol, "unique symbol");
+        this.toBeUnknown = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Unknown, "unknown");
+        this.toBeVoid = new PrimitiveTypeMatcher(this.typeChecker, this.compiler.TypeFlags.Void, "void");
+        this.toEqual = new ToEqual(this.typeChecker);
+        this.toHaveProperty = new ToHaveProperty(this.compiler, this.typeChecker);
+        this.toMatch = new ToMatch(this.typeChecker);
+        this.toRaiseError = new ToRaiseError(this.compiler, this.typeChecker);
+    }
+    static assertTypeChecker(typeChecker) {
+        return ("isTypeAssignableTo" in typeChecker && "isTypeIdenticalTo" in typeChecker && "isTypeSubtypeOf" in typeChecker);
+    }
+    #getType(node) {
+        return this.compiler.isExpression(node)
+            ? this.typeChecker.getTypeAtLocation(node)
+            : this.typeChecker.getTypeFromTypeNode(node);
+    }
+    #getTypes(nodes) {
+        return nodes.map((node) => this.#getType(node));
+    }
+    #isArrayOfStringOrNumberLiteralTypes(types) {
+        return types.every((type) => this.#isStringOrNumberLiteralType(type));
+    }
+    #isStringOrNumberLiteralType(type) {
+        return Boolean(type.flags & this.compiler.TypeFlags.StringOrNumberLiteral);
+    }
+    #isUniqueSymbolType(type) {
+        return Boolean(type.flags & this.compiler.TypeFlags.UniqueESSymbol);
+    }
+    match(assertion, expectResult) {
+        const matcherNameText = assertion.matcherName.getText();
+        switch (matcherNameText) {
+            case "toBeAssignable":
+            case "toEqual":
+            case "toMatch":
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                if (assertion.target[0] == null) {
+                    this.#onTargetArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                return this[matcherNameText].match(this.#getType(assertion.source[0]), this.#getType(assertion.target[0]), assertion.isNot);
             case "toBeAny":
-                return this.#isType(assertion, "any");
             case "toBeBigInt":
-                return this.#isType(assertion, "bigint");
             case "toBeBoolean":
-                return this.#isType(assertion, "boolean");
             case "toBeNever":
-                return this.#isType(assertion, "never");
             case "toBeNull":
-                return this.#isType(assertion, "null");
             case "toBeNumber":
-                return this.#isType(assertion, "number");
             case "toBeString":
-                return this.#isType(assertion, "string");
             case "toBeSymbol":
-                return this.#isType(assertion, "symbol");
             case "toBeUndefined":
-                return this.#isType(assertion, "undefined");
             case "toBeUniqueSymbol":
-                return this.#isType(assertion, "unique symbol");
             case "toBeUnknown":
-                return this.#isType(assertion, "unknown");
             case "toBeVoid":
-                return this.#isType(assertion, "void");
-            case "toEqual": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is identical to type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not identical to type '${sourceTypeText}'.`, origin),
-                ];
-            }
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
+                }
+                return this[matcherNameText].match(this.#getType(assertion.source[0]), assertion.isNot);
             case "toHaveProperty": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                let targetArgumentText;
-                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
-                    targetArgumentText = String(assertion.targetType.type.value);
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
-                    targetArgumentText = `[${this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.symbol.escapedName)}]`;
+                const sourceType = this.#getType(assertion.source[0]);
+                const nonPrimitiveType = { flags: this.compiler.TypeFlags.NonPrimitive };
+                if (sourceType.flags & (this.compiler.TypeFlags.Any | this.compiler.TypeFlags.Never) ||
+                    !this.typeChecker.isTypeAssignableTo(sourceType, nonPrimitiveType)) {
+                    this.#onSourceArgumentMustBeObjectType(assertion.source[0], expectResult);
+                    return;
                 }
-                else {
-                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
+                if (assertion.target[0] == null) {
+                    this.#onKeyArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Property '${targetArgumentText}' exists on type '${sourceText}'.`
-                        : `Property '${targetArgumentText}' does not exist on type '${sourceText}'.`, origin),
-                ];
-            }
-            case "toMatch": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                const sourceTypeText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-                const targetTypeText = assertion.typeChecker.typeToString(assertion.targetType.type);
-                return [
-                    Diagnostic.error(assertion.isNot
-                        ? `Type '${targetTypeText}' is a subtype of type '${sourceTypeText}'.`
-                        : `Type '${targetTypeText}' is not a subtype of type '${sourceTypeText}'.`, origin),
-                ];
+                const targetType = this.#getType(assertion.target[0]);
+                if (!(this.#isStringOrNumberLiteralType(targetType) || this.#isUniqueSymbolType(targetType))) {
+                    this.#onKeyArgumentMustBeOfType(assertion.target[0], expectResult);
+                    return;
+                }
+                return this.toHaveProperty.match(sourceType, targetType, assertion.isNot);
             }
             case "toRaiseError": {
-                this.#assertNonNullishSourceType(assertion);
-                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
-                    throw new Error("An argument for 'target' must be of type 'string | number'.");
-                }
-                const sourceText = assertion.sourceType.source === 0 ? "Expression" : "Type definition";
-                if (assertion.diagnostics.length === 0) {
-                    return [Diagnostic.error(`${sourceText} did not raise a type error.`, origin)];
-                }
-                if (assertion.isNot && assertion.targetArguments.length === 0) {
-                    const related = [
-                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
-                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
-                    ];
-                    return [
-                        Diagnostic.error(`${sourceText} raised ${assertion.diagnostics.length === 1 ? "a" : assertion.diagnostics.length} type error${assertion.diagnostics.length === 1 ? "" : "s"}.`, origin).add({ related }),
-                    ];
-                }
-                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
-                    const expectedText = assertion.diagnostics.length > assertion.targetArguments.length
-                        ? `only ${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`
-                        : `${assertion.targetArguments.length} type error${assertion.targetArguments.length === 1 ? "" : "s"}`;
-                    const foundText = assertion.diagnostics.length > assertion.targetArguments.length
-                        ? `${assertion.diagnostics.length}`
-                        : `only ${assertion.diagnostics.length}`;
-                    const related = [
-                        Diagnostic.error(`The raised type error${assertion.diagnostics.length === 1 ? "" : "s"}:`),
-                        ...Diagnostic.fromDiagnostics(assertion.diagnostics, this.compiler),
-                    ];
-                    const diagnostic = Diagnostic.error(`Expected ${expectedText}, but ${foundText} ${assertion.diagnostics.length === 1 ? "was" : "were"} raised.`, origin).add({
-                        related,
-                    });
-                    return [diagnostic];
+                if (assertion.source[0] == null) {
+                    this.#onSourceArgumentMustBeProvided(assertion, expectResult);
+                    return;
                 }
-                const diagnostics = [];
-                assertion.targetArguments.forEach((argument, index) => {
-                    const diagnostic = assertion.diagnostics[index];
-                    if (!diagnostic) {
-                        return;
-                    }
-                    const isMatch = this.#matchExpectedError(diagnostic, argument);
-                    if (!assertion.isNot && !isMatch) {
-                        const expectedText = this.compiler.isStringLiteralLike(argument)
-                            ? `matching substring '${argument.text}'`
-                            : `with code ${argument.text}`;
-                        const related = [
-                            Diagnostic.error("The raised type error:"),
-                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
-                        ];
-                        diagnostics.push(Diagnostic.error(`${sourceText} did not raise a type error ${expectedText}.`, origin).add({ related }));
-                    }
-                    if (assertion.isNot && isMatch) {
-                        const expectedText = this.compiler.isStringLiteralLike(argument)
-                            ? `matching substring '${argument.text}'`
-                            : `with code ${argument.text}`;
-                        const related = [
-                            Diagnostic.error("The raised type error:"),
-                            ...Diagnostic.fromDiagnostics([diagnostic], this.compiler),
-                        ];
-                        diagnostics.push(Diagnostic.error(`${sourceText} raised a type error ${expectedText}.`, origin).add({ related }));
-                    }
-                });
-                return diagnostics;
+                const targetTypes = this.#getTypes(assertion.target);
+                if (!this.#isArrayOfStringOrNumberLiteralTypes(targetTypes)) {
+                    this.#onTargetArgumentsMustBeStringOrNumberLiteralTypes(assertion.target, expectResult);
+                    return;
+                }
+                return this.toRaiseError.match({ diagnostics: assertion.diagnostics, node: assertion.source[0] }, targetTypes, assertion.isNot);
             }
             default:
-                throw new Error(`The '${matcher}' matcher is not supported.`);
+                this.#onNotSupportedMatcherName(assertion, expectResult);
+                return;
         }
     }
-    #hasTypeFlag(assertion, targetTypeFlag) {
-        this.#assertNonNullishSourceType(assertion);
-        return Boolean(assertion.sourceType.type.flags & targetTypeFlag);
+    #onKeyArgumentMustBeOfType(node, expectResult) {
+        const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
+        const text = `An argument for 'key' must be of type 'string | number | symbol', received: '${receivedTypeText}'.`;
+        const origin = {
+            end: node.getEnd(),
+            file: node.getSourceFile(),
+            start: node.getStart(),
+        };
+        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
+    }
+    #onKeyArgumentMustBeProvided(assertion, expectResult) {
+        const origin = {
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        EventEmitter.dispatch([
+            "expect:error",
+            {
+                diagnostics: [Diagnostic.error("An argument for 'key' must be provided.", origin)],
+                result: expectResult,
+            },
+        ]);
     }
-    #isType(assertion, targetText) {
-        this.#assertNonNullishSourceType(assertion);
-        this.#assertNonNullishTypeChecker(assertion);
+    #onNotSupportedMatcherName(assertion, expectResult) {
+        const matcherNameText = assertion.matcherName.getText();
         const origin = {
-            breadcrumbs: assertion.ancestorNames,
             end: assertion.matcherName.getEnd(),
             file: assertion.matcherName.getSourceFile(),
             start: assertion.matcherName.getStart(),
         };
-        const sourceText = assertion.typeChecker.typeToString(assertion.sourceType.type);
-        return [
-            Diagnostic.error(assertion.isNot
-                ? `Type '${targetText}' is identical to type '${sourceText}'.`
-                : `Type '${targetText}' is not identical to type '${sourceText}'.`, origin),
-        ];
+        EventEmitter.dispatch([
+            "expect:error",
+            {
+                diagnostics: [Diagnostic.error(`The '${matcherNameText}()' matcher is not supported.`, origin)],
+                result: expectResult,
+            },
+        ]);
     }
-    match(assertion) {
-        const matcher = assertion.matcherName.getText();
-        switch (matcher) {
-            case "toBeAssignable":
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeAssignableTo, "The 'isTypeAssignableTo' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeAssignableTo(assertion.targetType.type, assertion.sourceType.type);
-            case "toBeAny": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Any);
-            }
-            case "toBeBigInt": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.BigInt);
-            }
-            case "toBeBoolean": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Boolean);
-            }
-            case "toBeNever": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Never);
-            }
-            case "toBeNull": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Null);
-            }
-            case "toBeNumber": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Number);
-            }
-            case "toBeString": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.String);
-            }
-            case "toBeSymbol": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.ESSymbol);
-            }
-            case "toBeUndefined": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Undefined);
-            }
-            case "toBeUniqueSymbol": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.UniqueESSymbol);
-            }
-            case "toBeUnknown": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Unknown);
-            }
-            case "toBeVoid": {
-                return this.#hasTypeFlag(assertion, this.compiler.TypeFlags.Void);
-            }
-            case "toEqual": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeIdenticalTo, "The 'isTypeIdenticalTo' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeIdenticalTo(assertion.sourceType.type, assertion.targetType.type);
-            }
-            case "toHaveProperty": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                if (!(assertion.sourceType.type.flags & this.compiler.TypeFlags.StructuredType)) {
-                    const receivedText = assertion.typeChecker?.typeToString(assertion.sourceType.type);
-                    throw new Error(`An argument for 'source' must be of object type, received: '${receivedText}'.`);
-                }
-                let targetArgumentText;
-                if (assertion.targetType.type.flags & this.compiler.TypeFlags.StringOrNumberLiteral) {
-                    targetArgumentText = String(assertion.targetType.type.value);
-                }
-                else if (assertion.targetType.type.flags & this.compiler.TypeFlags.UniqueESSymbol) {
-                    targetArgumentText = this.compiler.unescapeLeadingUnderscores(assertion.targetType.type.escapedName);
-                }
-                else {
-                    throw new Error("An argument for 'key' must be of type 'string | number | symbol'.");
-                }
-                return assertion.sourceType.type.getProperties().some((property) => {
-                    return this.compiler.unescapeLeadingUnderscores(property.escapedName) === targetArgumentText;
-                });
-            }
-            case "toMatch": {
-                this.#assertNonNullishSourceType(assertion);
-                this.#assertNonNullishTargetType(assertion);
-                this.#assertNonNullish(assertion.typeChecker?.isTypeSubtypeOf, "The 'isTypeSubtypeOf' method is missing in the provided type checker.");
-                return assertion.typeChecker.isTypeSubtypeOf(assertion.sourceType.type, assertion.targetType.type);
-            }
-            case "toRaiseError": {
-                if (!this.#assertStringsOrNumbers(assertion.targetArguments)) {
-                    throw new Error("An argument for 'target' must be of type 'string | number'.");
-                }
-                if (assertion.targetArguments.length === 0) {
-                    return assertion.diagnostics.length > 0;
-                }
-                if (assertion.diagnostics.length !== assertion.targetArguments.length) {
-                    return false;
-                }
-                return assertion.targetArguments.every((expectedArgument, index) => {
-                    if (this.compiler.isStringLiteralLike(expectedArgument)) {
-                        return this.compiler
-                            .flattenDiagnosticMessageText(assertion.diagnostics[index]?.messageText, " ", 0)
-                            .includes(expectedArgument.text);
-                    }
-                    if (this.compiler.isNumericLiteral(expectedArgument)) {
-                        return Number(expectedArgument.text) === assertion.diagnostics[index]?.code;
-                    }
-                    return false;
-                });
+    #onSourceArgumentMustBeObjectType(node, expectResult) {
+        const sourceText = this.compiler.isTypeNode(node) ? "A type argument for 'Source'" : "An argument for 'source'";
+        const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
+        const text = `${sourceText} must be of an object type, received: '${receivedTypeText}'.`;
+        const origin = {
+            end: node.getEnd(),
+            file: node.getSourceFile(),
+            start: node.getStart(),
+        };
+        EventEmitter.dispatch(["expect:error", { diagnostics: [Diagnostic.error(text, origin)], result: expectResult }]);
+    }
+    #onSourceArgumentMustBeProvided(assertion, expectResult) {
+        const origin = {
+            end: assertion.node.getEnd(),
+            file: assertion.node.getSourceFile(),
+            start: assertion.node.getStart(),
+        };
+        EventEmitter.dispatch([
+            "expect:error",
+            {
+                diagnostics: [
+                    Diagnostic.error("An argument for 'source' or type argument for 'Source' must be provided.", origin),
+                ],
+                result: expectResult,
+            },
+        ]);
+    }
+    #onTargetArgumentMustBeProvided(assertion, expectResult) {
+        const origin = {
+            end: assertion.matcherName.getEnd(),
+            file: assertion.matcherName.getSourceFile(),
+            start: assertion.matcherName.getStart(),
+        };
+        EventEmitter.dispatch([
+            "expect:error",
+            {
+                diagnostics: [
+                    Diagnostic.error("An argument for 'target' or type argument for 'Target' must be provided.", origin),
+                ],
+                result: expectResult,
+            },
+        ]);
+    }
+    #onTargetArgumentsMustBeStringOrNumberLiteralTypes(nodes, expectResult) {
+        const diagnostics = [];
+        for (const node of nodes) {
+            const receivedType = this.#getType(node);
+            if (!this.#isStringOrNumberLiteralType(receivedType)) {
+                const receivedTypeText = this.typeChecker.typeToString(this.#getType(node));
+                const origin = {
+                    end: node.getEnd(),
+                    file: node.getSourceFile(),
+                    start: node.getStart(),
+                };
+                diagnostics.push(Diagnostic.error(`An argument for 'target' must be of type 'string | number', received: '${receivedTypeText}'.`, origin));
             }
-            default:
-                throw new Error(`The '${matcher}' matcher is not supported.`);
         }
+        EventEmitter.dispatch(["expect:error", { diagnostics, result: expectResult }]);
+    }
+}
+
+class ProjectService {
+    compiler;
+    #service;
+    constructor(compiler) {
+        this.compiler = compiler;
+        function doNothing() {
+        }
+        function returnFalse() {
+            return false;
+        }
+        function returnUndefined() {
+            return undefined;
+        }
+        const noopWatcher = { close: doNothing };
+        const noopLogger = {
+            close: doNothing,
+            endGroup: doNothing,
+            getLogFileName: returnUndefined,
+            hasLevel: returnFalse,
+            info: doNothing,
+            loggingEnabled: returnFalse,
+            msg: doNothing,
+            perftrc: doNothing,
+            startGroup: doNothing,
+        };
+        const host = {
+            ...this.compiler.sys,
+            clearImmediate,
+            clearTimeout,
+            setImmediate,
+            setTimeout,
+            watchDirectory: () => noopWatcher,
+            watchFile: () => noopWatcher,
+        };
+        this.#service = new this.compiler.server.ProjectService({
+            allowLocalPluginLoads: true,
+            cancellationToken: this.compiler.server.nullCancellationToken,
+            host,
+            logger: noopLogger,
+            session: undefined,
+            useInferredProjectPerProjectRoot: true,
+            useSingleInferredProject: false,
+        });
+    }
+    closeFile(filePath) {
+        this.#service.closeClientFile(filePath);
     }
-    #matchExpectedError(diagnostic, argument) {
-        if (this.compiler.isStringLiteralLike(argument)) {
-            return this.compiler.flattenDiagnosticMessageText(diagnostic.messageText, " ", 0).includes(argument.text);
+    getDefaultProject(filePath) {
+        return this.#service.getDefaultProjectForFile(this.compiler.server.toNormalizedPath(filePath), true);
+    }
+    getLanguageService(filePath) {
+        const project = this.getDefaultProject(filePath);
+        if (!project) {
+            return;
         }
-        if (this.compiler.isNumericLiteral(argument)) {
-            return Number(argument.text) === diagnostic.code;
+        return project.getLanguageService(true);
+    }
+    openFile(filePath, sourceText, projectRootPath) {
+        const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
+        EventEmitter.dispatch([
+            "project:info",
+            { compilerVersion: this.compiler.version, projectConfigFilePath: configFileName },
+        ]);
+        if (configFileErrors && configFileErrors.length > 0) {
+            EventEmitter.dispatch([
+                "project:error",
+                { diagnostics: Diagnostic.fromDiagnostics(configFileErrors, this.compiler) },
+            ]);
         }
-        throw new Error("An argument for 'target' must be of type 'string | number'.");
     }
 }
 
 class TestTreeWorker {
     resolvedConfig;
     compiler;
-    #checker;
+    #expect;
     #fileResult;
     #hasOnly;
     #position;
     #signal;
-    constructor(resolvedConfig, compiler, options) {
+    constructor(resolvedConfig, compiler, expect, options) {
         this.resolvedConfig = resolvedConfig;
         this.compiler = compiler;
-        this.#checker = new Checker(compiler);
+        this.#expect = expect;
+        this.#fileResult = options.fileResult;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
         this.#signal = options.signal;
-        this.#fileResult = options.fileResult;
     }
     #resolveRunMode(mode, member) {
         if (member.flags & 1) {
@@ -2062,8 +2300,11 @@ class TestTreeWorker {
             ]);
             return;
         }
-        const isPass = this.#checker.match(assertion);
-        if (assertion.isNot ? !isPass : isPass) {
+        const matchResult = this.#expect.match(assertion, expectResult);
+        if (matchResult == null) {
+            return;
+        }
+        if (assertion.isNot ? !matchResult.isMatch : matchResult.isMatch) {
             if (runMode & 1) {
                 const text = ["The assertion was supposed to fail, but it passed.", "Consider removing the '.fail' flag."];
                 const origin = {
@@ -2073,10 +2314,7 @@ class TestTreeWorker {
                 };
                 EventEmitter.dispatch([
                     "expect:error",
-                    {
-                        diagnostics: [Diagnostic.error(text, origin)],
-                        result: expectResult,
-                    },
+                    { diagnostics: [Diagnostic.error(text, origin)], result: expectResult },
                 ]);
             }
             else {
@@ -2088,13 +2326,20 @@ class TestTreeWorker {
                 EventEmitter.dispatch(["expect:pass", { result: expectResult }]);
             }
             else {
-                EventEmitter.dispatch([
-                    "expect:fail",
-                    {
-                        diagnostics: this.#checker.explain(assertion),
-                        result: expectResult,
-                    },
-                ]);
+                const origin = {
+                    breadcrumbs: assertion.ancestorNames,
+                    end: assertion.matcherName.getEnd(),
+                    file: assertion.matcherName.getSourceFile(),
+                    start: assertion.matcherName.getStart(),
+                };
+                const diagnostics = [];
+                for (const diagnostic of matchResult.explain()) {
+                    if (diagnostic.origin == null) {
+                        diagnostic.add({ origin });
+                    }
+                    diagnostics.push(diagnostic);
+                }
+                EventEmitter.dispatch(["expect:fail", { diagnostics, result: expectResult }]);
             }
         }
     }
@@ -2198,8 +2443,7 @@ class TestFileRunner {
         if (!sourceFile) {
             return;
         }
-        const typeChecker = program.getTypeChecker();
-        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics, typeChecker);
+        const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
         if (testTree.diagnostics.length > 0) {
             EventEmitter.dispatch([
                 "file:error",
@@ -2210,7 +2454,14 @@ class TestFileRunner {
             ]);
             return;
         }
-        const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, {
+        const typeChecker = program.getTypeChecker();
+        if (!Expect.assertTypeChecker(typeChecker)) {
+            const text = "The required 'isTypeAssignableTo()', 'isTypeIdenticalTo()' and 'isTypeSubtypeOf()' methods are missing in the provided type checker.";
+            EventEmitter.dispatch(["file:error", { diagnostics: [Diagnostic.error(text)], result: fileResult }]);
+            return;
+        }
+        const expect = new Expect(this.compiler, typeChecker);
+        const testTreeWorker = new TestTreeWorker(this.resolvedConfig, this.compiler, expect, {
             fileResult,
             hasOnly: testTree.hasOnly,
             position,
@@ -3110,11 +3361,13 @@ class ManifestWorker {
     #cachePath;
     #manifestFileName = "store-manifest.json";
     #manifestFilePath;
+    #onDiagnostic;
     #prune;
     #registryUrl = new URL("https://registry.npmjs.org");
     #timeout = Environment.timeout * 1000;
-    constructor(cachePath, prune) {
+    constructor(cachePath, onDiagnostic, prune) {
         this.#cachePath = cachePath;
+        this.#onDiagnostic = onDiagnostic;
         this.#manifestFilePath = path.join(cachePath, this.#manifestFileName);
         this.#prune = prune;
     }
@@ -3202,9 +3455,6 @@ class ManifestWorker {
         }
         return manifest;
     }
-    #onDiagnostic(diagnostic) {
-        EventEmitter.dispatch(["store:error", { diagnostics: [diagnostic] }]);
-    }
     async open(signal) {
         let manifest;
         if (!existsSync(this.#manifestFilePath)) {
@@ -3268,7 +3518,7 @@ class StoreService {
     constructor() {
         this.#cachePath = Environment.storePath;
         this.#compilerModuleWorker = new CompilerModuleWorker(this.#cachePath, this.#onDiagnostic);
-        this.#manifestWorker = new ManifestWorker(this.#cachePath, async () => this.prune());
+        this.#manifestWorker = new ManifestWorker(this.#cachePath, this.#onDiagnostic, this.prune);
     }
     get supportedTags() {
         if (!this.#manifest) {
@@ -3316,9 +3566,9 @@ class StoreService {
         }
         this.#manifest = await this.#manifestWorker.open(signal);
     }
-    async prune() {
+    prune = async () => {
         await fs.rm(this.#cachePath, { force: true, recursive: true });
-    }
+    };
     resolveTag(tag) {
         if (!this.#manifest) {
             this.#onDiagnostic(Diagnostic.error("Store manifest is not open. Call 'StoreService.open()' first."));
@@ -3371,154 +3621,6 @@ class StoreService {
     }
 }
 
-class JsonText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Line, null, JSON.stringify(this.#sortObject(this.props.input), null, 2));
-    }
-    #sortObject(target) {
-        if (Array.isArray(target)) {
-            return target;
-        }
-        return Object.keys(target)
-            .sort()
-            .reduce((result, key) => {
-            result[key] = target[key];
-            return result;
-        }, {});
-    }
-}
-function formattedText(input) {
-    if (typeof input === "string") {
-        return Scribbler.createElement(Line, null, input);
-    }
-    return Scribbler.createElement(JsonText, { input: input });
-}
-
-const usageExamples = [
-    ["tstyche", "Run all tests."],
-    ["tstyche path/to/first.test.ts second", "Only run the test files with matching path."],
-    ["tstyche --target 4.7,4.8,latest", "Test on all specified versions of TypeScript."],
-];
-class HintText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return (Scribbler.createElement(Text, { indent: 1, color: "90" }, this.props.children));
-    }
-}
-class HelpHeaderText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        const hint = (Scribbler.createElement(HintText, null,
-            Scribbler.createElement(Text, null, this.props.tstycheVersion)));
-        return (Scribbler.createElement(Line, null,
-            Scribbler.createElement(Text, null, "The TSTyche Type Test Runner"),
-            hint));
-    }
-}
-class CommandText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        let hint = undefined;
-        if (this.props.hint != null) {
-            hint = Scribbler.createElement(HintText, null, this.props.hint);
-        }
-        return (Scribbler.createElement(Line, { indent: 1 },
-            Scribbler.createElement(Text, { color: "34" }, this.props.text),
-            hint));
-    }
-}
-class OptionDescriptionText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Line, { indent: 1 }, this.props.text);
-    }
-}
-class CliUsageText {
-    render() {
-        const usageText = usageExamples.map(([commandText, descriptionText]) => (Scribbler.createElement(Text, null,
-            Scribbler.createElement(CommandText, { text: commandText }),
-            Scribbler.createElement(OptionDescriptionText, { text: descriptionText }),
-            Scribbler.createElement(Line, null))));
-        return Scribbler.createElement(Text, null, usageText);
-    }
-}
-class OptionNameText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        return Scribbler.createElement(Text, null,
-            "--",
-            this.props.text);
-    }
-}
-class OptionHintText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        if (this.props.definition.brand === "list") {
-            return (Scribbler.createElement(Text, null,
-                this.props.definition.brand,
-                " of ",
-                this.props.definition.items.brand,
-                "s"));
-        }
-        return Scribbler.createElement(Text, null, this.props.definition.brand);
-    }
-}
-class CliOptionsText {
-    props;
-    constructor(props) {
-        this.props = props;
-    }
-    render() {
-        const definitions = Array.from(this.props.optionDefinitions.values());
-        const optionsText = definitions.map((definition) => (Scribbler.createElement(Text, null,
-            Scribbler.createElement(CommandText, { text: Scribbler.createElement(OptionNameText, { text: definition.name }), hint: Scribbler.createElement(OptionHintText, { definition: definition }) }),
-            Scribbler.createElement(OptionDescriptionText, { text: definition.description }),
-            Scribbler.createElement(Line, null))));
-        return (Scribbler.createElement(Text, null,
-            Scribbler.createElement(Line, null, "CLI Options"),
-            Scribbler.createElement(Line, null),
-            optionsText));
-    }
-}
-class HelpFooterText {
-    render() {
-        return Scribbler.createElement(Line, null, "To learn more, visit https://tstyche.org");
-    }
-}
-function helpText(optionDefinitions, tstycheVersion) {
-    return (Scribbler.createElement(Text, null,
-        Scribbler.createElement(HelpHeaderText, { tstycheVersion: tstycheVersion }),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliUsageText, null),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(CliOptionsText, { optionDefinitions: optionDefinitions }),
-        Scribbler.createElement(Line, null),
-        Scribbler.createElement(HelpFooterText, null),
-        Scribbler.createElement(Line, null)));
-}
-
 class Cli {
     #abortController = new AbortController();
     #logger;
@@ -3617,4 +3719,4 @@ class Cli {
     }
 }
 
-export { Assertion, AssertionSource, Checker, Cli, CollectService, Color, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, ExpectResult, FileResult, Line, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, Text, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, summaryText, testNameText, usesCompilerStepText };
+export { Assertion, Cli, CollectService, ConfigService, DescribeResult, Diagnostic, DiagnosticCategory, Environment, EventEmitter, Expect, ExpectResult, FileResult, Logger, OptionBrand, OptionDefinitionsMap, OptionGroup, ProjectResult, ProjectService, Reporter, Result, ResultCount, ResultManager, ResultStatus, ResultTiming, Scribbler, StoreService, SummaryReporter, TSTyche, TargetResult, TaskRunner, TestMember, TestMemberBrand, TestMemberFlags, TestResult, TestTree, ThoroughReporter, addsPackageStepText, describeNameText, diagnosticText, fileStatusText, fileViewText, formattedText, helpText, summaryText, testNameText, usesCompilerStepText };