tstyche 4.0.0-beta.0 → 4.0.0-beta.10

package/build/tstyche.js

@@ -93,12 +93,39 @@ class DiagnosticOrigin {
         this.assertion = assertion;
     }
     static fromAssertion(assertion) {
-        const node = assertion.matcherName;
+        const node = assertion.matcherNameNode.name;
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
     static fromNode(node, assertion) {
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
+    static fromNodes(nodes, assertion) {
+        return new DiagnosticOrigin(nodes.pos, nodes.end, nodes[0].getSourceFile(), assertion);
+    }
+}
+
+function diagnosticBelongsToNode(diagnostic, node) {
+    return diagnostic.start != null && diagnostic.start >= node.pos && diagnostic.start <= node.end;
+}
+function diagnosticMessageChainToText(chain) {
+    const result = [chain.messageText];
+    if (chain.next != null) {
+        for (const nextChain of chain.next) {
+            result.push(...diagnosticMessageChainToText(nextChain));
+        }
+    }
+    return result;
+}
+function getDiagnosticMessageText(diagnostic) {
+    return typeof diagnostic.messageText === "string"
+        ? diagnostic.messageText
+        : diagnosticMessageChainToText(diagnostic.messageText);
+}
+function getTextSpanEnd(span) {
+    return span.start + span.length;
+}
+function isDiagnosticWithLocation(diagnostic) {
+    return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
 }
 
 class Diagnostic {
@@ -138,21 +165,10 @@ class Diagnostic {
             if (diagnostic.relatedInformation != null) {
                 related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
             }
-            const text = typeof diagnostic.messageText === "string"
-                ? diagnostic.messageText
-                : Diagnostic.toMessageText(diagnostic.messageText);
+            const text = getDiagnosticMessageText(diagnostic);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
         });
     }
-    static toMessageText(chain) {
-        const result = [chain.messageText];
-        if (chain.next != null) {
-            for (const nextChain of chain.next) {
-                result.push(...Diagnostic.toMessageText(nextChain));
-            }
-        }
-        return result;
-    }
     static warning(text, origin) {
         return new Diagnostic(text, DiagnosticCategory.Warning, origin);
     }
@@ -556,7 +572,6 @@ class ManifestService {
     #manifestFilePath;
     #npmRegistry;
     #storePath;
-    #supportedVersionRegex = /^(5)\.\d\.\d$/;
     constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
         this.#npmRegistry = npmRegistry;
@@ -586,7 +601,7 @@ class ManifestService {
         const versions = [];
         const packageMetadata = (await response.json());
         for (const [tag, meta] of Object.entries(packageMetadata.versions)) {
-            if (this.#supportedVersionRegex.test(tag)) {
+            if (!tag.includes("-") && Version.isSatisfiedWith(tag, "4.7.2")) {
                 versions.push(tag);
                 packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
@@ -685,6 +700,9 @@ class PackageService {
         if (response?.body != null) {
             const targetPath = `${packagePath}-${Math.random().toString(32).slice(2)}`;
             for await (const file of TarReader.extract(response.body)) {
+                if (!file.name.startsWith("package/")) {
+                    continue;
+                }
                 const filePath = Path.join(targetPath, file.name.replace("package/", ""));
                 const directoryPath = Path.dirname(filePath);
                 if (!existsSync(directoryPath)) {
@@ -792,11 +810,7 @@ class Store {
             modulePath = Path.resolve(modulePath, "../tsserverlibrary.js");
         }
         const sourceText = await fs.readFile(modulePath, { encoding: "utf8" });
-        const toExpose = [
-            "isApplicableIndexType",
-            "isTypeRelatedTo",
-            "relation: { assignable: assignableRelation, identity: identityRelation }",
-        ];
+        const toExpose = ["isApplicableIndexType", "isTypeIdenticalTo"];
         const modifiedSourceText = sourceText.replace("return checker;", `return { ...checker, ${toExpose.join(", ")} };`);
         const compiledWrapper = vm.compileFunction(modifiedSourceText, ["exports", "require", "module", "__filename", "__dirname"], { filename: modulePath });
         compiledWrapper(exports, createRequire(modulePath), module, modulePath, Path.dirname(modulePath));
@@ -903,7 +917,7 @@ class Options {
         },
         {
             brand: OptionBrand.BareTrue,
-            description: "Fetch specified versions of the 'typescript' package and exit.",
+            description: "Fetch the specified versions of the 'typescript' package and exit.",
             group: OptionGroup.CommandLine,
             name: "fetch",
         },
@@ -1656,14 +1670,12 @@ class ResultCount {
 class Result {
     expectCount = new ResultCount();
     fileCount = new ResultCount();
-    resolvedConfig;
     results = [];
     targetCount = new ResultCount();
     tasks;
     testCount = new ResultCount();
     timing = new ResultTiming();
-    constructor(resolvedConfig, tasks) {
-        this.resolvedConfig = resolvedConfig;
+    constructor(tasks) {
         this.tasks = tasks;
     }
 }
@@ -1765,6 +1777,7 @@ class ResultHandler {
                 this.#taskResult.timing.start = Date.now();
                 break;
             case "task:error":
+            case "collect:error":
                 this.#targetResult.status = ResultStatus.Failed;
                 this.#taskResult.status = ResultStatus.Failed;
                 this.#taskResult.diagnostics.push(...payload.diagnostics);
@@ -1899,293 +1912,6 @@ class ResultHandler {
     }
 }
 
-var TestTreeNodeBrand;
-(function (TestTreeNodeBrand) {
-    TestTreeNodeBrand["Describe"] = "describe";
-    TestTreeNodeBrand["Test"] = "test";
-    TestTreeNodeBrand["Expect"] = "expect";
-})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
-
-class TestTreeNode {
-    brand;
-    children = [];
-    #compiler;
-    diagnostics = new Set();
-    flags;
-    name = "";
-    node;
-    parent;
-    constructor(compiler, brand, node, parent, flags) {
-        this.brand = brand;
-        this.#compiler = compiler;
-        this.node = node;
-        this.parent = parent;
-        this.flags = flags;
-        if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
-            this.name = node.arguments[0].text;
-        }
-        if (node.arguments[1] != null &&
-            compiler.isFunctionLike(node.arguments[1]) &&
-            compiler.isBlock(node.arguments[1].body)) {
-            const blockStart = node.arguments[1].body.getStart();
-            const blockEnd = node.arguments[1].body.getEnd();
-            for (const diagnostic of parent.diagnostics) {
-                if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
-                    this.diagnostics.add(diagnostic);
-                    parent.diagnostics.delete(diagnostic);
-                }
-            }
-        }
-    }
-    validate() {
-        const diagnostics = [];
-        const getText = (node) => `'${node.expression.getText()}()' cannot be nested within '${this.node.expression.getText()}()'.`;
-        const getParentCallExpression = (node) => {
-            while (!this.#compiler.isCallExpression(node.parent)) {
-                node = node.parent;
-            }
-            return node.parent;
-        };
-        switch (this.brand) {
-            case TestTreeNodeBrand.Describe:
-                for (const member of this.children) {
-                    if (member.brand === TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(getParentCallExpression(member.node))));
-                    }
-                }
-                break;
-            case TestTreeNodeBrand.Test:
-            case TestTreeNodeBrand.Expect:
-                for (const member of this.children) {
-                    if (member.brand !== TestTreeNodeBrand.Expect) {
-                        diagnostics.push(Diagnostic.error(getText(member.node), DiagnosticOrigin.fromNode(member.node)));
-                    }
-                }
-                break;
-        }
-        return diagnostics;
-    }
-}
-
-class AssertionNode extends TestTreeNode {
-    isNot;
-    matcherName;
-    matcherNode;
-    modifierNode;
-    notNode;
-    source;
-    target;
-    constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
-        super(compiler, brand, node, parent, flags);
-        this.isNot = notNode != null;
-        this.matcherName = matcherNode.expression.name;
-        this.matcherNode = matcherNode;
-        this.modifierNode = modifierNode;
-        this.source = this.node.typeArguments ?? this.node.arguments;
-        this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
-        for (const diagnostic of parent.diagnostics) {
-            if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
-                this.diagnostics.add(diagnostic);
-                parent.diagnostics.delete(diagnostic);
-            }
-        }
-    }
-}
-
-var TestTreeNodeFlags;
-(function (TestTreeNodeFlags) {
-    TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
-    TestTreeNodeFlags[TestTreeNodeFlags["Fail"] = 1] = "Fail";
-    TestTreeNodeFlags[TestTreeNodeFlags["Only"] = 2] = "Only";
-    TestTreeNodeFlags[TestTreeNodeFlags["Skip"] = 4] = "Skip";
-    TestTreeNodeFlags[TestTreeNodeFlags["Todo"] = 8] = "Todo";
-})(TestTreeNodeFlags || (TestTreeNodeFlags = {}));
-
-class IdentifierLookup {
-    #compiler;
-    #identifiers;
-    #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
-    constructor(compiler, identifiers) {
-        this.#compiler = compiler;
-        this.#identifiers = identifiers ?? {
-            namedImports: {
-                describe: undefined,
-                expect: undefined,
-                it: undefined,
-                namespace: undefined,
-                test: undefined,
-            },
-            namespace: undefined,
-        };
-    }
-    handleImportDeclaration(node) {
-        if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
-            node.importClause?.isTypeOnly !== true &&
-            node.importClause?.namedBindings != null) {
-            if (this.#compiler.isNamedImports(node.importClause.namedBindings)) {
-                for (const element of node.importClause.namedBindings.elements) {
-                    if (element.isTypeOnly) {
-                        continue;
-                    }
-                    let identifierKey;
-                    if (element.propertyName) {
-                        identifierKey = element.propertyName.getText();
-                    }
-                    else {
-                        identifierKey = element.name.getText();
-                    }
-                    if (identifierKey in this.#identifiers.namedImports) {
-                        this.#identifiers.namedImports[identifierKey] = element.name.getText();
-                    }
-                }
-            }
-            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
-                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
-            }
-        }
-    }
-    resolveTestMemberMeta(node) {
-        let flags = TestTreeNodeFlags.None;
-        let expression = node.expression;
-        while (this.#compiler.isPropertyAccessExpression(expression)) {
-            if (expression.expression.getText() === this.#identifiers.namespace) {
-                break;
-            }
-            switch (expression.name.getText()) {
-                case "fail":
-                    flags |= TestTreeNodeFlags.Fail;
-                    break;
-                case "only":
-                    flags |= TestTreeNodeFlags.Only;
-                    break;
-                case "skip":
-                    flags |= TestTreeNodeFlags.Skip;
-                    break;
-                case "todo":
-                    flags |= TestTreeNodeFlags.Todo;
-                    break;
-            }
-            expression = expression.expression;
-        }
-        let identifierName;
-        if (this.#compiler.isPropertyAccessExpression(expression) &&
-            expression.expression.getText() === this.#identifiers.namespace) {
-            identifierName = expression.name.getText();
-        }
-        else {
-            identifierName = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
-        }
-        if (!identifierName) {
-            return;
-        }
-        switch (identifierName) {
-            case "describe":
-                return { brand: TestTreeNodeBrand.Describe, flags };
-            case "it":
-            case "test":
-                return { brand: TestTreeNodeBrand.Test, flags };
-            case "expect":
-                return { brand: TestTreeNodeBrand.Expect, flags };
-        }
-        return;
-    }
-}
-
-class TestTree {
-    children = [];
-    diagnostics;
-    hasOnly = false;
-    sourceFile;
-    constructor(diagnostics, sourceFile) {
-        this.diagnostics = diagnostics;
-        this.sourceFile = sourceFile;
-    }
-}
-
-class CollectService {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
-    }
-    #collectTestTreeNodes(node, identifiers, parent) {
-        if (this.#compiler.isCallExpression(node)) {
-            const meta = identifiers.resolveTestMemberMeta(node);
-            if (meta != null && (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test)) {
-                const testTreeNode = new TestTreeNode(this.#compiler, meta.brand, node, parent, meta.flags);
-                parent.children.push(testTreeNode);
-                EventEmitter.dispatch(["collect:node", { testNode: testTreeNode }]);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestTreeNodes(node, identifiers, testTreeNode);
-                });
-                return;
-            }
-            if (meta != null && meta.brand === TestTreeNodeBrand.Expect) {
-                const modifierNode = this.#getChainedNode(node, "type");
-                if (!modifierNode) {
-                    return;
-                }
-                const notNode = this.#getChainedNode(modifierNode, "not");
-                const matcherNode = this.#getChainedNode(notNode ?? modifierNode)?.parent;
-                if (!matcherNode || !this.#isMatcherNode(matcherNode)) {
-                    return;
-                }
-                const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, modifierNode, notNode);
-                parent.children.push(assertionNode);
-                EventEmitter.dispatch(["collect:node", { testNode: assertionNode }]);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestTreeNodes(node, identifiers, assertionNode);
-                });
-                return;
-            }
-        }
-        if (this.#compiler.isImportDeclaration(node)) {
-            identifiers.handleImportDeclaration(node);
-            return;
-        }
-        this.#compiler.forEachChild(node, (node) => {
-            this.#collectTestTreeNodes(node, identifiers, parent);
-        });
-    }
-    createTestTree(sourceFile, semanticDiagnostics = []) {
-        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
-        EventEmitter.dispatch(["collect:start", { testTree }]);
-        this.#collectTestTreeNodes(sourceFile, new IdentifierLookup(this.#compiler), testTree);
-        EventEmitter.dispatch(["collect:end", { testTree }]);
-        return testTree;
-    }
-    #getChainedNode({ parent }, name) {
-        if (!this.#compiler.isPropertyAccessExpression(parent)) {
-            return;
-        }
-        if (name != null && name !== parent.name.getText()) {
-            return;
-        }
-        return parent;
-    }
-    #isMatcherNode(node) {
-        return this.#compiler.isCallExpression(node) && this.#compiler.isPropertyAccessExpression(node.expression);
-    }
-}
-
-class TestTreeHandler {
-    testTree;
-    on([event, payload]) {
-        switch (event) {
-            case "collect:start":
-                this.testTree = payload.testTree;
-                break;
-            case "collect:end":
-                this.testTree = undefined;
-                break;
-            case "collect:node":
-                if (payload.testNode.flags & TestTreeNodeFlags.Only) {
-                    this.testTree.hasOnly = true;
-                }
-                break;
-        }
-    }
-}
-
 function jsx(type, props) {
     return { props, type };
 }
@@ -2500,39 +2226,12 @@ function CountText({ failed, passed, skipped, todo, total }) {
 function DurationText({ seconds }) {
     return jsx(Text, { children: `${Math.round(seconds * 10) / 10}s` });
 }
-function MatchText({ text }) {
-    if (typeof text === "string") {
-        return jsx(Text, { children: ["'", text, "'"] });
-    }
-    if (text.length === 1) {
-        return jsx(Text, { children: ["'", ...text, "'"] });
-    }
-    const lastItem = text.pop();
-    return (jsx(Text, { children: [text.map((match, index, list) => (jsx(Text, { children: ["'", match, "'", index === list.length - 1 ? jsx(Text, { children: " " }) : jsx(Text, { color: Color.Gray, children: ", " })] }))), jsx(Text, { color: Color.Gray, children: "or" }), " '", lastItem, "'"] }));
-}
-function RanFilesText({ onlyMatch, pathMatch, skipMatch }) {
-    const testNameMatchText = [];
-    if (onlyMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: "matching " }), jsx(MatchText, { text: onlyMatch })] }));
-    }
-    if (skipMatch != null) {
-        testNameMatchText.push(jsx(Text, { children: [onlyMatch && jsx(Text, { color: Color.Gray, children: " and " }), jsx(Text, { color: Color.Gray, children: "not matching " }), jsx(MatchText, { text: skipMatch })] }));
-    }
-    let pathMatchText;
-    if (pathMatch.length > 0) {
-        pathMatchText = (jsx(Text, { children: [jsx(Text, { color: Color.Gray, children: "test files matching " }), jsx(MatchText, { text: pathMatch }), jsx(Text, { color: Color.Gray, children: "." })] }));
-    }
-    else {
-        pathMatchText = jsx(Text, { color: Color.Gray, children: "all test files." });
-    }
-    return (jsx(Line, { children: [jsx(Text, { color: Color.Gray, children: "Ran " }), testNameMatchText.length > 0 ? jsx(Text, { color: Color.Gray, children: "tests " }) : undefined, testNameMatchText, testNameMatchText.length > 0 ? jsx(Text, { color: Color.Gray, children: " in " }) : undefined, pathMatchText] }));
-}
-function summaryText({ duration, expectCount, fileCount, onlyMatch, pathMatch, skipMatch, targetCount, testCount, }) {
+function summaryText({ duration, expectCount, fileCount, targetCount, testCount, }) {
     const targetCountText = (jsx(RowText, { label: "Targets", text: jsx(CountText, { failed: targetCount.failed, passed: targetCount.passed, skipped: targetCount.skipped, todo: targetCount.todo, total: targetCount.total }) }));
     const fileCountText = (jsx(RowText, { label: "Test files", text: jsx(CountText, { failed: fileCount.failed, passed: fileCount.passed, skipped: fileCount.skipped, todo: fileCount.todo, total: fileCount.total }) }));
     const testCountText = (jsx(RowText, { label: "Tests", text: jsx(CountText, { failed: testCount.failed, passed: testCount.passed, skipped: testCount.skipped, todo: testCount.todo, total: testCount.total }) }));
     const assertionCountText = (jsx(RowText, { label: "Assertions", text: jsx(CountText, { failed: expectCount.failed, passed: expectCount.passed, skipped: expectCount.skipped, todo: expectCount.todo, total: expectCount.total }) }));
-    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) }), jsx(Line, {}), jsx(RanFilesText, { onlyMatch: onlyMatch, pathMatch: pathMatch, skipMatch: skipMatch })] }));
+    return (jsx(Text, { children: [targetCountText, fileCountText, testCount.total > 0 ? testCountText : undefined, expectCount.total > 0 ? assertionCountText : undefined, jsx(RowText, { label: "Duration", text: jsx(DurationText, { seconds: duration / 1000 }) })] }));
 }
 
 function StatusText({ status }) {
@@ -2681,6 +2380,7 @@ class ListReporter extends BaseReporter {
                 this.#hasReportedError = false;
                 break;
             case "task:error":
+            case "collect:error":
                 for (const diagnostic of payload.diagnostics) {
                     this.#fileView.addMessage(diagnosticText(diagnostic));
                 }
@@ -2776,9 +2476,6 @@ class SummaryReporter extends BaseReporter {
                 duration: payload.result.timing.duration,
                 expectCount: payload.result.expectCount,
                 fileCount: payload.result.fileCount,
-                onlyMatch: payload.result.resolvedConfig.only,
-                pathMatch: payload.result.resolvedConfig.pathMatch,
-                skipMatch: payload.result.resolvedConfig.skip,
                 targetCount: payload.result.targetCount,
                 testCount: payload.result.testCount,
             }));
@@ -3173,20 +2870,512 @@ class WatchService {
     }
 }
 
-class ProjectService {
-    #compiler;
-    #lastSeenProject = "";
-    #resolvedConfig;
-    #seenPrograms = new WeakSet();
-    #service;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
-        this.#compiler = compiler;
-        const noop = () => undefined;
-        const noopLogger = {
-            close: noop,
-            endGroup: noop,
-            getLogFileName: noop,
+class TestTreeNode {
+    brand;
+    children = [];
+    diagnostics = new Set();
+    flags;
+    name = "";
+    node;
+    parent;
+    constructor(compiler, brand, node, parent, flags) {
+        this.brand = brand;
+        this.node = node;
+        this.parent = parent;
+        this.flags = flags;
+        if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
+            this.name = node.arguments[0].text;
+        }
+        if (node.arguments[1] != null && compiler.isFunctionLike(node.arguments[1])) {
+            for (const diagnostic of parent.diagnostics) {
+                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
+                    this.diagnostics.add(diagnostic);
+                    parent.diagnostics.delete(diagnostic);
+                }
+            }
+        }
+    }
+}
+
+class AssertionNode extends TestTreeNode {
+    abilityDiagnostics;
+    isNot;
+    matcherNode;
+    matcherNameNode;
+    modifierNode;
+    notNode;
+    source;
+    target;
+    constructor(compiler, brand, node, parent, flags, matcherNode, matcherNameNode, modifierNode, notNode) {
+        super(compiler, brand, node, parent, flags);
+        this.isNot = notNode != null;
+        this.matcherNode = matcherNode;
+        this.matcherNameNode = matcherNameNode;
+        this.modifierNode = modifierNode;
+        this.source = this.node.typeArguments ?? this.node.arguments;
+        if (compiler.isCallExpression(this.matcherNode)) {
+            this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
+        }
+        for (const diagnostic of parent.diagnostics) {
+            if (diagnosticBelongsToNode(diagnostic, this.source)) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
+    }
+}
+
+function nodeBelongsToArgumentList(compiler, node) {
+    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+}
+function nodeIsChildOfExpressionStatement(compiler, node) {
+    return compiler.isExpressionStatement(node.parent);
+}
+
+class AbilityLayer {
+    #compiler;
+    #filePath = "";
+    #nodes = [];
+    #projectService;
+    #resolvedConfig;
+    #text = "";
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#projectService = projectService;
+        this.#resolvedConfig = resolvedConfig;
+    }
+    #getErasedRangeText(range) {
+        if (this.#text.indexOf("\n", range.start) >= range.end) {
+            return " ".repeat(range.end - range.start);
+        }
+        const text = [];
+        for (let index = range.start; index < range.end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
+                case "\n":
+                case "\r":
+                    text.push(character);
+                    break;
+                default:
+                    text.push(" ");
+            }
+        }
+        return text.join("");
+    }
+    #addRanges(node, ranges) {
+        this.#nodes.push(node);
+        for (const range of ranges) {
+            const rangeText = range.replacement != null
+                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
+                : this.#getErasedRangeText(range);
+            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
+        }
+    }
+    close() {
+        if (this.#nodes.length > 0) {
+            this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
+            const languageService = this.#projectService.getLanguageService(this.#filePath);
+            const diagnostics = new Set(languageService?.getSemanticDiagnostics(this.#filePath));
+            for (const node of this.#nodes.reverse()) {
+                for (const diagnostic of diagnostics) {
+                    if (diagnosticBelongsToNode(diagnostic, "matcherNode" in node ? node.matcherNode : node.actionNode)) {
+                        if (!node.abilityDiagnostics) {
+                            node.abilityDiagnostics = new Set();
+                        }
+                        node.abilityDiagnostics.add(diagnostic);
+                        diagnostics.delete(diagnostic);
+                    }
+                }
+            }
+        }
+        this.#filePath = "";
+        this.#nodes = [];
+        this.#text = "";
+    }
+    #eraseTrailingComma(node, parent) {
+        if (node.hasTrailingComma) {
+            this.#addRanges(parent, [{ start: node.end - 1, end: node.end }]);
+        }
+    }
+    handleWhen(whenNode) {
+        const whenStart = whenNode.node.getStart();
+        const whenExpressionEnd = whenNode.node.expression.getEnd();
+        const whenEnd = whenNode.node.getEnd();
+        const actionNameEnd = whenNode.actionNameNode.getEnd();
+        switch (whenNode.actionNameNode.name.text) {
+            case "isCalledWith":
+                this.#eraseTrailingComma(whenNode.target, whenNode);
+                this.#addRanges(whenNode, [
+                    {
+                        start: whenStart,
+                        end: whenExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
+                    },
+                    { start: whenEnd, end: actionNameEnd },
+                ]);
+                break;
+        }
+    }
+    handleAssertion(assertionNode) {
+        const expectStart = assertionNode.node.getStart();
+        const expectExpressionEnd = assertionNode.node.expression.getEnd();
+        const expectEnd = assertionNode.node.getEnd();
+        const matcherNameEnd = assertionNode.matcherNameNode.getEnd();
+        switch (assertionNode.matcherNameNode.name.text) {
+            case "toBeApplicable":
+                this.#addRanges(assertionNode, [
+                    { start: expectStart, end: expectExpressionEnd },
+                    { start: expectEnd, end: matcherNameEnd },
+                ]);
+                break;
+            case "toBeCallableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
+                this.#addRanges(assertionNode, [
+                    {
+                        start: expectStart,
+                        end: expectExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? ";" : "",
+                    },
+                    { start: expectEnd, end: matcherNameEnd },
+                ]);
+                break;
+            case "toBeConstructableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
+                this.#addRanges(assertionNode, [
+                    {
+                        start: expectStart,
+                        end: expectExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? "; new" : "new",
+                    },
+                    { start: expectEnd, end: matcherNameEnd },
+                ]);
+                break;
+        }
+    }
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+    }
+}
+
+class CollectDiagnosticText {
+    static cannotBeNestedWithin(source, target) {
+        return `'${source}()' cannot be nested within '${target}()'.`;
+    }
+}
+
+var TestTreeNodeBrand;
+(function (TestTreeNodeBrand) {
+    TestTreeNodeBrand["Describe"] = "describe";
+    TestTreeNodeBrand["Test"] = "test";
+    TestTreeNodeBrand["Expect"] = "expect";
+    TestTreeNodeBrand["When"] = "when";
+})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
+
+var TestTreeNodeFlags;
+(function (TestTreeNodeFlags) {
+    TestTreeNodeFlags[TestTreeNodeFlags["None"] = 0] = "None";
+    TestTreeNodeFlags[TestTreeNodeFlags["Fail"] = 1] = "Fail";
+    TestTreeNodeFlags[TestTreeNodeFlags["Only"] = 2] = "Only";
+    TestTreeNodeFlags[TestTreeNodeFlags["Skip"] = 4] = "Skip";
+    TestTreeNodeFlags[TestTreeNodeFlags["Todo"] = 8] = "Todo";
+})(TestTreeNodeFlags || (TestTreeNodeFlags = {}));
+
+class IdentifierLookup {
+    #compiler;
+    #identifiers;
+    #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    handleImportDeclaration(node) {
+        if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
+            node.importClause?.isTypeOnly !== true &&
+            node.importClause?.namedBindings != null) {
+            if (this.#compiler.isNamedImports(node.importClause.namedBindings)) {
+                for (const element of node.importClause.namedBindings.elements) {
+                    if (element.isTypeOnly) {
+                        continue;
+                    }
+                    let identifierKey;
+                    if (element.propertyName) {
+                        identifierKey = element.propertyName.getText();
+                    }
+                    else {
+                        identifierKey = element.name.getText();
+                    }
+                    if (identifierKey in this.#identifiers.namedImports) {
+                        this.#identifiers.namedImports[identifierKey] = element.name.getText();
+                    }
+                }
+            }
+            if (this.#compiler.isNamespaceImport(node.importClause.namedBindings)) {
+                this.#identifiers.namespace = node.importClause.namedBindings.name.getText();
+            }
+        }
+    }
+    open() {
+        this.#identifiers = {
+            namedImports: {
+                describe: undefined,
+                expect: undefined,
+                it: undefined,
+                namespace: undefined,
+                test: undefined,
+                when: undefined,
+            },
+            namespace: undefined,
+        };
+    }
+    resolveTestTreeNodeMeta(node) {
+        let flags = TestTreeNodeFlags.None;
+        let expression = node.expression;
+        while (this.#compiler.isPropertyAccessExpression(expression)) {
+            if (expression.expression.getText() === this.#identifiers.namespace) {
+                break;
+            }
+            switch (expression.name.getText()) {
+                case "fail":
+                    flags |= TestTreeNodeFlags.Fail;
+                    break;
+                case "only":
+                    flags |= TestTreeNodeFlags.Only;
+                    break;
+                case "skip":
+                    flags |= TestTreeNodeFlags.Skip;
+                    break;
+                case "todo":
+                    flags |= TestTreeNodeFlags.Todo;
+                    break;
+            }
+            expression = expression.expression;
+        }
+        let identifier;
+        if (this.#compiler.isPropertyAccessExpression(expression) &&
+            expression.expression.getText() === this.#identifiers.namespace) {
+            identifier = expression.name.getText();
+        }
+        else {
+            identifier = Object.keys(this.#identifiers.namedImports).find((key) => this.#identifiers.namedImports[key] === expression.getText());
+        }
+        if (!identifier) {
+            return;
+        }
+        switch (identifier) {
+            case "describe":
+                return { brand: TestTreeNodeBrand.Describe, flags, identifier };
+            case "it":
+            case "test":
+                return { brand: TestTreeNodeBrand.Test, flags, identifier };
+            case "expect":
+                return { brand: TestTreeNodeBrand.Expect, flags, identifier };
+            case "when":
+                return { brand: TestTreeNodeBrand.When, flags, identifier };
+        }
+        return;
+    }
+}
+
+class TestTree {
+    children = [];
+    diagnostics;
+    hasOnly = false;
+    sourceFile;
+    constructor(diagnostics, sourceFile) {
+        this.diagnostics = diagnostics;
+        this.sourceFile = sourceFile;
+    }
+}
+
+class WhenNode extends TestTreeNode {
+    actionNode;
+    actionNameNode;
+    abilityDiagnostics;
+    target;
+    constructor(compiler, brand, node, parent, flags, actionNode, actionNameNode) {
+        super(compiler, brand, node, parent, flags);
+        this.actionNode = actionNode;
+        this.actionNameNode = actionNameNode;
+        this.target = this.node.typeArguments ?? this.node.arguments;
+        for (const diagnostic of parent.diagnostics) {
+            if (diagnosticBelongsToNode(diagnostic, node)) {
+                this.diagnostics.add(diagnostic);
+                parent.diagnostics.delete(diagnostic);
+            }
+        }
+    }
+}
+
+class CollectService {
+    #abilityLayer;
+    #compiler;
+    #identifierLookup;
+    constructor(compiler, projectService, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#abilityLayer = new AbilityLayer(compiler, projectService, resolvedConfig);
+        this.#identifierLookup = new IdentifierLookup(compiler);
+    }
+    #collectTestTreeNodes(node, parent, testTree) {
+        if (this.#compiler.isCallExpression(node)) {
+            const meta = this.#identifierLookup.resolveTestTreeNodeMeta(node);
+            if (meta != null) {
+                if (!this.#checkNode(node, meta, parent)) {
+                    return;
+                }
+                if (meta.brand === TestTreeNodeBrand.Describe || meta.brand === TestTreeNodeBrand.Test) {
+                    const testTreeNode = new TestTreeNode(this.#compiler, meta.brand, node, parent, meta.flags);
+                    this.#compiler.forEachChild(node, (node) => {
+                        this.#collectTestTreeNodes(node, testTreeNode, testTree);
+                    });
+                    this.#onNode(testTreeNode, parent, testTree);
+                    return;
+                }
+                if (meta.brand === TestTreeNodeBrand.Expect) {
+                    const modifierNode = this.#getChainedNode(node, "type");
+                    if (!modifierNode) {
+                        return;
+                    }
+                    const notNode = this.#getChainedNode(modifierNode, "not");
+                    const matcherNameNode = this.#getChainedNode(notNode ?? modifierNode);
+                    if (!matcherNameNode) {
+                        return;
+                    }
+                    const matcherNode = this.#getMatcherNode(matcherNameNode);
+                    if (!matcherNode) {
+                        return;
+                    }
+                    const assertionNode = new AssertionNode(this.#compiler, meta.brand, node, parent, meta.flags, matcherNode, matcherNameNode, modifierNode, notNode);
+                    this.#abilityLayer.handleAssertion(assertionNode);
+                    this.#compiler.forEachChild(node, (node) => {
+                        this.#collectTestTreeNodes(node, assertionNode, testTree);
+                    });
+                    this.#onNode(assertionNode, parent, testTree);
+                    return;
+                }
+                if (meta.brand === TestTreeNodeBrand.When) {
+                    const actionNameNode = this.#getChainedNode(node);
+                    if (!actionNameNode) {
+                        return;
+                    }
+                    const actionNode = this.#getActionNode(actionNameNode);
+                    if (!actionNode) {
+                        return;
+                    }
+                    this.#compiler.forEachChild(actionNode, (node) => {
+                        if (this.#compiler.isCallExpression(node)) {
+                            const meta = this.#identifierLookup.resolveTestTreeNodeMeta(node);
+                            if (meta?.brand === TestTreeNodeBrand.Describe || meta?.brand === TestTreeNodeBrand.Test) {
+                                const text = CollectDiagnosticText.cannotBeNestedWithin(meta.identifier, "when");
+                                const origin = DiagnosticOrigin.fromNode(node);
+                                this.#onDiagnostics(Diagnostic.error(text, origin));
+                            }
+                        }
+                    });
+                    const whenNode = new WhenNode(this.#compiler, meta.brand, node, parent, meta.flags, actionNode, actionNameNode);
+                    this.#abilityLayer.handleWhen(whenNode);
+                    this.#onNode(whenNode, parent, testTree);
+                    return;
+                }
+            }
+        }
+        if (this.#compiler.isImportDeclaration(node)) {
+            this.#identifierLookup.handleImportDeclaration(node);
+            return;
+        }
+        this.#compiler.forEachChild(node, (node) => {
+            this.#collectTestTreeNodes(node, parent, testTree);
+        });
+    }
+    createTestTree(sourceFile, semanticDiagnostics = []) {
+        const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
+        EventEmitter.dispatch(["collect:start", { tree: testTree }]);
+        this.#abilityLayer.open(sourceFile);
+        this.#identifierLookup.open();
+        this.#collectTestTreeNodes(sourceFile, testTree, testTree);
+        this.#abilityLayer.close();
+        EventEmitter.dispatch(["collect:end", { tree: testTree }]);
+        return testTree;
+    }
+    #checkNode(node, meta, parent) {
+        if ("brand" in parent && !this.#isNodeAllowed(meta, parent)) {
+            const text = CollectDiagnosticText.cannotBeNestedWithin(meta.identifier, parent.node.expression.getText());
+            const origin = DiagnosticOrigin.fromNode(node);
+            this.#onDiagnostics(Diagnostic.error(text, origin));
+            return false;
+        }
+        return true;
+    }
+    #isNodeAllowed(meta, parent) {
+        switch (meta.brand) {
+            case TestTreeNodeBrand.Describe:
+            case TestTreeNodeBrand.Test:
+                if (parent.brand === TestTreeNodeBrand.Test || parent.brand === TestTreeNodeBrand.Expect) {
+                    return false;
+                }
+                break;
+            case TestTreeNodeBrand.Expect:
+            case TestTreeNodeBrand.When:
+                if (parent.brand === TestTreeNodeBrand.Describe) {
+                    return false;
+                }
+                break;
+        }
+        return true;
+    }
+    #getChainedNode({ parent }, name) {
+        if (!this.#compiler.isPropertyAccessExpression(parent)) {
+            return;
+        }
+        if (name != null && name !== parent.name.getText()) {
+            return;
+        }
+        return parent;
+    }
+    #getMatcherNode(node) {
+        if (this.#compiler.isCallExpression(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isDecorator(node.parent)) {
+            return node.parent;
+        }
+        if (this.#compiler.isParenthesizedExpression(node.parent)) {
+            return this.#getMatcherNode(node.parent);
+        }
+        return;
+    }
+    #getActionNode(node) {
+        if (this.#compiler.isCallExpression(node.parent)) {
+            return node.parent;
+        }
+        return;
+    }
+    #onDiagnostics(diagnostic) {
+        EventEmitter.dispatch(["collect:error", { diagnostics: [diagnostic] }]);
+    }
+    #onNode(node, parent, testTree) {
+        parent.children.push(node);
+        if (node.flags & TestTreeNodeFlags.Only) {
+            testTree.hasOnly = true;
+        }
+        EventEmitter.dispatch(["collect:node", { node }]);
+    }
+}
+
+class ProjectService {
+    #compiler;
+    #lastSeenProject = "";
+    #resolvedConfig;
+    #seenPrograms = new WeakSet();
+    #seenTestFiles = new Set();
+    #service;
+    constructor(compiler, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#resolvedConfig = resolvedConfig;
+        const noop = () => undefined;
+        const noopLogger = {
+            close: noop,
+            endGroup: noop,
+            getLogFileName: noop,
             hasLevel: () => false,
             info: noop,
             loggingEnabled: () => false,
@@ -3215,15 +3404,6 @@ class ProjectService {
             useInferredProjectPerProjectRoot: true,
             useSingleInferredProject: false,
         });
-        switch (this.#resolvedConfig.tsconfig) {
-            case "findup":
-                break;
-            case "ignore":
-                this.#service.getConfigFileNameForFile = () => undefined;
-                break;
-            default:
-                this.#service.getConfigFileNameForFile = () => this.#resolvedConfig.tsconfig;
-        }
         this.#service.setCompilerOptionsForInferredProjects(this.#getDefaultCompilerOptions());
     }
     closeFile(filePath) {
@@ -3231,7 +3411,6 @@ class ProjectService {
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
-            allowImportingTsExtensions: true,
             allowJs: true,
             checkJs: true,
             exactOptionalPropertyTypes: true,
@@ -3242,8 +3421,11 @@ class ProjectService {
             resolveJsonModule: true,
             strict: true,
             target: this.#compiler.ScriptTarget.ESNext,
-            verbatimModuleSyntax: true,
         };
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.0")) {
+            defaultCompilerOptions.allowImportingTsExtensions = true;
+            defaultCompilerOptions.verbatimModuleSyntax = true;
+        }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
@@ -3258,7 +3440,23 @@ class ProjectService {
         const project = this.getDefaultProject(filePath);
         return project?.getLanguageService(true);
     }
+    #isFileIncluded(filePath) {
+        const configSourceFile = this.#compiler.readJsonConfigFile(this.#resolvedConfig.tsconfig, this.#compiler.sys.readFile);
+        const { fileNames } = this.#compiler.parseJsonSourceFileConfigFileContent(configSourceFile, this.#compiler.sys, Path.dirname(this.#resolvedConfig.tsconfig), undefined, this.#resolvedConfig.tsconfig);
+        return fileNames.includes(filePath);
+    }
     openFile(filePath, sourceText, projectRootPath) {
+        switch (this.#resolvedConfig.tsconfig) {
+            case "findup":
+                break;
+            case "ignore":
+                this.#service.getConfigFileNameForFile = () => undefined;
+                break;
+            default:
+                this.#service.getConfigFileNameForFile = this.#isFileIncluded(filePath)
+                    ? () => this.#resolvedConfig.tsconfig
+                    : () => undefined;
+        }
         const { configFileErrors, configFileName } = this.#service.openClientFile(filePath, sourceText, undefined, projectRootPath);
         if (configFileName !== this.#lastSeenProject) {
             this.#lastSeenProject = configFileName;
@@ -3273,29 +3471,29 @@ class ProjectService {
                 { diagnostics: Diagnostic.fromDiagnostics(configFileErrors) },
             ]);
         }
-        if (this.#resolvedConfig.checkSourceFiles) {
+        if (this.#resolvedConfig.checkSourceFiles && !this.#seenTestFiles.has(filePath)) {
+            this.#seenTestFiles.add(filePath);
             const languageService = this.getLanguageService(filePath);
             const program = languageService?.getProgram();
             if (!program || this.#seenPrograms.has(program)) {
                 return;
             }
             this.#seenPrograms.add(program);
-            const filesToCheck = [];
-            for (const sourceFile of program.getSourceFiles()) {
+            const sourceFilesToCheck = program.getSourceFiles().filter((sourceFile) => {
                 if (program.isSourceFileFromExternalLibrary(sourceFile) || program.isSourceFileDefaultLibrary(sourceFile)) {
-                    continue;
+                    return false;
                 }
-                if (!Select.isTestFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
-                    filesToCheck.push(sourceFile);
+                if (Select.isTestFile(sourceFile.fileName, { ...this.#resolvedConfig, pathMatch: [] })) {
+                    return false;
                 }
-            }
+                return true;
+            });
             const diagnostics = [];
-            for (const sourceFile of filesToCheck) {
+            for (const sourceFile of sourceFilesToCheck) {
                 diagnostics.push(...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile));
             }
             if (diagnostics.length > 0) {
                 EventEmitter.dispatch(["project:error", { diagnostics: Diagnostic.fromDiagnostics(diagnostics) }]);
-                return;
             }
         }
     }
@@ -3310,30 +3508,74 @@ var RunMode;
     RunMode[RunMode["Todo"] = 8] = "Todo";
 })(RunMode || (RunMode = {}));
 
-class Format {
-    static capitalize(text) {
-        return text.replace(/^./, text.charAt(0).toUpperCase());
+class EnsureDiagnosticText {
+    static argumentMustBeProvided(argumentNameText) {
+        return `An argument for '${argumentNameText}' must be provided.`;
+    }
+    static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
+        return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
+    }
+}
+
+function argumentIsProvided(argumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node) {
+        const text = EnsureDiagnosticText.argumentMustBeProvided(argumentNameText);
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+        return false;
+    }
+    return true;
+}
+
+function argumentOrTypeArgumentIsProvided(argumentNameText, typeArgumentNameText, node, enclosingNode, onDiagnostics) {
+    if (!node) {
+        const text = EnsureDiagnosticText.argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText);
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+        return false;
+    }
+    return true;
+}
+
+class ExpectDiagnosticText {
+    static argumentMustBe(argumentNameText, expectedText) {
+        return `An argument for '${argumentNameText}' must be ${expectedText}.`;
+    }
+    static typeArgumentMustBe(argumentNameText, expectedText) {
+        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
+    }
+    static isCallable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is callable ${targetText}.`;
+    }
+    static isNotCallable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is not callable ${targetText}.`;
+    }
+    static isConstructable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is constructable ${targetText}.`;
+    }
+    static isNotConstructable(isExpression, targetText) {
+        return `${isExpression ? "Expression" : "Type"} is not constructable ${targetText}.`;
     }
-}
-
-class ExpectDiagnosticText {
-    static argumentCannotBeOfType(argumentNameText, typeText) {
-        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
+    static acceptsProps(isExpression) {
+        return `${isExpression ? "Component" : "Component type"} accepts props of the given type.`;
     }
-    static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
-        return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
+    static doesNotAcceptProps(isExpression) {
+        return `${isExpression ? "Component" : "Component type"} does not accept props of the given type.`;
     }
-    static argumentMustBe(argumentNameText, expectedText) {
-        return `An argument for '${argumentNameText}' must be ${expectedText}.`;
+    static canBeApplied(targetText) {
+        return `The decorator function can be applied${targetText}.`;
     }
-    static argumentMustBeProvided(argumentNameText) {
-        return `An argument for '${argumentNameText}' must be provided.`;
+    static cannotBeApplied(targetText) {
+        return `The decorator function cannot be applied${targetText}.`;
+    }
+    static hasProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
-    static componentAcceptsProps(isTypeNode) {
-        return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
+    static doesNotHaveProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
     }
-    static componentDoesNotAcceptProps(isTypeNode) {
-        return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
+    static didYouMeanToUse(suggestionText) {
+        return `Did you mean to use ${suggestionText}?`;
     }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
@@ -3344,87 +3586,73 @@ class ExpectDiagnosticText {
     static raisedTypeError(count = 1) {
         return `The raised type error${count === 1 ? "" : "s"}:`;
     }
-    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
-        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
-    }
-    static typeArgumentMustBe(argumentNameText, expectedText) {
-        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
-    }
-    static typeDidNotRaiseError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
+    static raisedError(isExpression, count, targetCount) {
+        let countText = "a";
+        if (count > 1 || targetCount > 1) {
+            countText = count > targetCount ? `${count}` : `only ${count}`;
+        }
+        return `${isExpression ? "Expression" : "Type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
     }
-    static typeDidNotRaiseMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
+    static didNotRaiseError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} did not raise a type error.`;
     }
-    static typeDoesNotHaveProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    static raisedMatchingError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} raised a matching type error.`;
     }
-    static typeHasProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' has property '${propertyNameText}'.`;
+    static didNotRaiseMatchingError(isExpression) {
+        return `${isExpression ? "Expression" : "Type"} did not raise a matching type error.`;
     }
-    static typeIsAssignableTo(sourceTypeText, targetTypeText) {
+    static isAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
     }
-    static typeIsAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
-    }
-    static typeIsIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
-    }
-    static typeIsNotAssignableTo(sourceTypeText, targetTypeText) {
+    static isNotAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable to type '${targetTypeText}'.`;
     }
-    static typeIsNotAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
+    static isAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
     }
-    static typeIsNotCompatibleWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
+    static isNotAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
     }
-    static typeIsNotIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
+    static isTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is the same as type '${targetTypeText}'.`;
     }
-    static typeRaisedError(isTypeNode, count, targetCount) {
-        let countText = "a";
-        if (count > 1 || targetCount > 1) {
-            countText = count > targetCount ? `${count}` : `only ${count}`;
-        }
-        return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
+    static isNotTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not the same as type '${targetTypeText}'.`;
     }
-    static typeRaisedMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
+    static isNotCompatibleWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
     }
-    static typeRequiresProperty(typeText, propertyNameText) {
+    static requiresProperty(typeText, propertyNameText) {
         return `Type '${typeText}' requires property '${propertyNameText}'.`;
     }
     static typesOfPropertyAreNotCompatible(propertyNameText) {
         return `Types of property '${propertyNameText}' are not compatible.`;
     }
-    static typeWasRejected(typeText) {
-        const optionNameText = `reject${Format.capitalize(typeText)}Type`;
-        return [
-            `The '${typeText}' type was rejected because the '${optionNameText}' option is enabled.`,
-            `If this check is necessary, pass '${typeText}' as the type argument explicitly.`,
-        ];
-    }
 }
 
+var Relation;
+(function (Relation) {
+    Relation["Assignable"] = "assignable";
+    Relation["Identical"] = "identical";
+})(Relation || (Relation = {}));
+
 class MatchWorker {
     assertion;
     #compiler;
     #signatureCache = new Map();
-    #typeCache = new Map();
-    #typeChecker;
+    typeChecker;
     constructor(compiler, typeChecker, assertion) {
         this.#compiler = compiler;
-        this.#typeChecker = typeChecker;
+        this.typeChecker = typeChecker;
         this.assertion = assertion;
     }
     checkHasApplicableIndexType(sourceNode, targetNode) {
         const sourceType = this.getType(sourceNode);
         const targetType = this.getType(targetNode);
-        return this.#typeChecker
+        return this.typeChecker
             .getIndexInfosOfType(sourceType)
-            .some(({ keyType }) => this.#typeChecker.isApplicableIndexType(targetType, keyType));
+            .some(({ keyType }) => this.typeChecker.isApplicableIndexType(targetType, keyType));
     }
     checkHasProperty(sourceNode, propertyNameText) {
         const sourceType = this.getType(sourceNode);
@@ -3433,38 +3661,36 @@ class MatchWorker {
             .some((property) => this.#compiler.unescapeLeadingUnderscores(property.escapedName) === propertyNameText);
     }
     checkIsAssignableTo(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.assignable;
-        return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
+        return this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Assignable);
     }
     checkIsAssignableWith(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.assignable;
-        return this.#checkIsRelatedTo(targetNode, sourceNode, relation);
+        return this.#checkIsRelatedTo(targetNode, sourceNode, Relation.Assignable);
     }
     checkIsIdenticalTo(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.identity;
-        return (this.#checkIsRelatedTo(sourceNode, targetNode, relation) &&
+        return (this.#checkIsRelatedTo(sourceNode, targetNode, Relation.Identical) &&
             this.checkIsAssignableTo(sourceNode, targetNode) &&
             this.checkIsAssignableWith(sourceNode, targetNode));
     }
     #checkIsRelatedTo(sourceNode, targetNode, relation) {
-        const sourceType = relation === this.#typeChecker.relation.identity
-            ? this.#simplifyType(this.getType(sourceNode))
-            : this.getType(sourceNode);
-        const targetType = relation === this.#typeChecker.relation.identity
-            ? this.#simplifyType(this.getType(targetNode))
-            : this.getType(targetNode);
-        return this.#typeChecker.isTypeRelatedTo(sourceType, targetType, relation);
+        const sourceType = relation === "identical" ? this.#simplifyType(this.getType(sourceNode)) : this.getType(sourceNode);
+        const targetType = relation === "identical" ? this.#simplifyType(this.getType(targetNode)) : this.getType(targetNode);
+        switch (relation) {
+            case Relation.Assignable:
+                return this.typeChecker.isTypeAssignableTo(sourceType, targetType);
+            case Relation.Identical:
+                return this.typeChecker.isTypeIdenticalTo(sourceType, targetType);
+        }
     }
     extendsObjectType(type) {
         const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
-        return this.#typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
+        return this.typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
     }
     getParameterType(signature, index) {
         const parameter = signature.getDeclaration().parameters[index];
         if (!parameter) {
             return;
         }
-        return this.#getTypeOfNode(parameter);
+        return this.getType(parameter);
     }
     getSignatures(node) {
         let signatures = this.#signatureCache.get(node);
@@ -3478,37 +3704,10 @@ class MatchWorker {
         return signatures;
     }
     getTypeText(node) {
-        const type = this.getType(node);
-        return this.#typeChecker.typeToString(type);
+        return this.typeChecker.typeToString(this.getType(node));
     }
     getType(node) {
-        return this.#compiler.isTypeNode(node) ? this.#getTypeOfTypeNode(node) : this.#getTypeOfNode(node);
-    }
-    #getTypeOfNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeAtLocation(node);
-        }
-        return type;
-    }
-    #getTypeOfTypeNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeFromTypeNode(node);
-        }
-        return type;
-    }
-    isStringOrNumberLiteralType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
-    }
-    isObjectType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.Object);
-    }
-    isUnionType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.Union);
-    }
-    isUniqueSymbolType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
+        return this.typeChecker.getTypeAtLocation(node);
     }
     resolveDiagnosticOrigin(symbol, enclosingNode) {
         if (symbol.valueDeclaration != null &&
@@ -3524,7 +3723,7 @@ class MatchWorker {
     #simplifyType(type) {
         if (type.isUnionOrIntersection()) {
             const candidateType = this.#simplifyType(type.types[0]);
-            if (type.types.every((type) => this.#typeChecker.isTypeRelatedTo(this.#simplifyType(type), candidateType, this.#typeChecker.relation.identity))) {
+            if (type.types.every((type) => this.typeChecker.isTypeIdenticalTo(this.#simplifyType(type), candidateType))) {
                 return candidateType;
             }
         }
@@ -3532,6 +3731,16 @@ class MatchWorker {
     }
 }
 
+function isStringOrNumberLiteralType(compiler, type) {
+    return !!(type.flags & compiler.TypeFlags.StringOrNumberLiteral);
+}
+function isUnionType(compiler, type) {
+    return !!(type.flags & compiler.TypeFlags.Union);
+}
+function isUniqueSymbolType(compiler, type) {
+    return !!(type.flags & compiler.TypeFlags.UniqueESSymbol);
+}
+
 class ToAcceptProps {
     #compiler;
     #typeChecker;
@@ -3540,12 +3749,13 @@ class ToAcceptProps {
         this.#typeChecker = typeChecker;
     }
     #explain(matchWorker, sourceNode, targetNode) {
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const signatures = matchWorker.getSignatures(sourceNode);
         return signatures.reduce((accumulator, signature, index) => {
             let diagnostic;
             const introText = matchWorker.assertion.isNot
-                ? ExpectDiagnosticText.componentAcceptsProps(this.#compiler.isTypeNode(sourceNode))
-                : ExpectDiagnosticText.componentDoesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
+                ? ExpectDiagnosticText.acceptsProps(isExpression)
+                : ExpectDiagnosticText.doesNotAcceptProps(isExpression);
             const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
@@ -3565,7 +3775,7 @@ class ToAcceptProps {
     #isOptionalProperty(symbol) {
         return symbol.declarations?.every((declaration) => this.#compiler.isPropertySignature(declaration) && declaration.questionToken != null);
     }
-    #checkProperties(matchWorker, sourceType, targetType) {
+    #checkProperties(sourceType, targetType) {
         const check = (sourceType, targetType) => {
             for (const targetProperty of targetType.getProperties()) {
                 const targetPropertyName = targetProperty.getName();
@@ -3593,7 +3803,7 @@ class ToAcceptProps {
             }
             return true;
         };
-        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             return sourceType.types.some((sourceType) => check(sourceType, targetType));
         }
         return check(sourceType, targetType);
@@ -3611,8 +3821,8 @@ class ToAcceptProps {
                 const sourceProperty = sourceType?.getProperty(targetPropertyName);
                 if (!sourceProperty) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotCompatibleWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotCompatibleWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3620,8 +3830,8 @@ class ToAcceptProps {
                 }
                 if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.requiresProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3633,9 +3843,9 @@ class ToAcceptProps {
                     const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
                     const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
                         ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3647,26 +3857,26 @@ class ToAcceptProps {
                     const targetProperty = targetType.getProperty(sourcePropertyName);
                     if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
                         const text = [
-                            ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                            ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, sourcePropertyName),
+                            ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                            ExpectDiagnosticText.requiresProperty(sourceTypeText, sourcePropertyName),
                         ];
                         diagnostics.push(diagnostic.extendWith(text));
                     }
                 }
             }
             if (diagnostics.length === 0) {
-                const text = ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText);
+                const text = ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText);
                 diagnostics.push(diagnostic.extendWith(text));
                 return { diagnostics, isMatch: true };
             }
             return { diagnostics, isMatch: false };
         };
-        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText);
+                    ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
                 if (isMatch) {
                     accumulator = diagnostics;
@@ -3685,18 +3895,18 @@ class ToAcceptProps {
         const signatures = matchWorker.getSignatures(sourceNode);
         if (signatures.length === 0) {
             const expectedText = "of a function or class type";
-            const text = this.#compiler.isTypeNode(sourceNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
         const targetType = matchWorker.getType(targetNode);
-        if (!matchWorker.isObjectType(targetType)) {
+        if (!(targetType.flags & this.#compiler.TypeFlags.Object)) {
             const expectedText = "of an object type";
-            const text = this.#compiler.isTypeNode(targetNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("target", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, targetNode)
+                ? ExpectDiagnosticText.argumentMustBe("target", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText);
             const origin = DiagnosticOrigin.fromNode(targetNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
@@ -3706,7 +3916,7 @@ class ToAcceptProps {
         }
         const isMatch = signatures.some((signature) => {
             const sourceType = matchWorker.getParameterType(signature, 0);
-            return this.#checkProperties(matchWorker, sourceType, targetType);
+            return this.#checkProperties(sourceType, targetType);
         });
         return {
             explain: () => this.#explain(matchWorker, sourceNode, targetNode),
@@ -3728,8 +3938,8 @@ class RelationMatcherBase {
 }
 
 class ToBe extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsIdenticalTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotIdenticalTo;
+    explainText = ExpectDiagnosticText.isTheSame;
+    explainNotText = ExpectDiagnosticText.isNotTheSame;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3738,9 +3948,74 @@ class ToBe extends RelationMatcherBase {
     }
 }
 
+class ToBeApplicable {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(node) {
+        let text = "";
+        switch (node.kind) {
+            case this.#compiler.SyntaxKind.ClassDeclaration:
+                text = "class";
+                break;
+            case this.#compiler.SyntaxKind.MethodDeclaration:
+                text = "method";
+                break;
+            case this.#compiler.SyntaxKind.PropertyDeclaration:
+                text = node.modifiers?.some((modifier) => modifier.kind === this.#compiler.SyntaxKind.AccessorKeyword)
+                    ? "accessor"
+                    : "field";
+                break;
+            case this.#compiler.SyntaxKind.GetAccessor:
+                text = "getter";
+                break;
+            case this.#compiler.SyntaxKind.SetAccessor:
+                text = "setter";
+                break;
+        }
+        if (text.length > 0) {
+            text = ` to this ${text}`;
+        }
+        return text;
+    }
+    #explain(matchWorker, sourceNode) {
+        const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [ExpectDiagnosticText.cannotBeApplied(targetText), getDiagnosticMessageText(diagnostic)];
+                const origin = DiagnosticOrigin.fromNode(sourceNode);
+                diagnostics.push(Diagnostic.error(text.flat(), origin));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeApplied(targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, onDiagnostics) {
+        const type = matchWorker.getType(sourceNode);
+        if (type.getCallSignatures().length === 0) {
+            const expectedText = "of a function type";
+            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToBeAssignableTo extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
+    explainText = ExpectDiagnosticText.isAssignableTo;
+    explainNotText = ExpectDiagnosticText.isNotAssignableTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3750,8 +4025,8 @@ class ToBeAssignableTo extends RelationMatcherBase {
 }
 
 class ToBeAssignableWith extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableWith;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableWith;
+    explainText = ExpectDiagnosticText.isAssignableWith;
+    explainNotText = ExpectDiagnosticText.isNotAssignableWith;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3760,6 +4035,167 @@ class ToBeAssignableWith extends RelationMatcherBase {
     }
 }
 
+class ToBeCallableWith {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(nodes) {
+        if (nodes.length === 0) {
+            return "without arguments";
+        }
+        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
+            return "with the given arguments";
+        }
+        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
+    }
+    #explain(matchWorker, sourceNode, targetNodes) {
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
+        const targetText = this.#resolveTargetText(targetNodes);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.isNotCallable(isExpression, targetText),
+                    getDiagnosticMessageText(diagnostic),
+                ];
+                let origin;
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
+                }
+                else {
+                    origin =
+                        targetNodes.length > 0
+                            ? DiagnosticOrigin.fromNodes(targetNodes)
+                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                }
+                let related;
+                if (diagnostic.relatedInformation != null) {
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                }
+                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isCallable(isExpression, targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
+        let type;
+        if (this.#compiler.isCallExpression(sourceNode)) {
+            type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
+        }
+        if (this.#compiler.isArrowFunction(sourceNode) ||
+            this.#compiler.isFunctionDeclaration(sourceNode) ||
+            this.#compiler.isFunctionExpression(sourceNode) ||
+            this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.#compiler.isIdentifier(sourceNode) ||
+            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+            type = matchWorker.getType(sourceNode);
+        }
+        if (!type || type.getCallSignatures().length === 0) {
+            const text = [];
+            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
+            }
+            else {
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a callable type"));
+            }
+            if (type != null && type.getConstructSignatures().length > 0) {
+                text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeConstructableWith()' matcher"));
+            }
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
+class ToBeConstructableWith {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    #resolveTargetText(nodes) {
+        if (nodes.length === 0) {
+            return "without arguments";
+        }
+        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
+            return "with the given arguments";
+        }
+        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
+    }
+    #explain(matchWorker, sourceNode, targetNodes) {
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
+        const targetText = this.#resolveTargetText(targetNodes);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [
+                    ExpectDiagnosticText.isNotConstructable(isExpression, targetText),
+                    getDiagnosticMessageText(diagnostic),
+                ];
+                let origin;
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
+                }
+                else {
+                    origin =
+                        targetNodes.length > 0
+                            ? DiagnosticOrigin.fromNodes(targetNodes)
+                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                }
+                let related;
+                if (diagnostic.relatedInformation != null) {
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                }
+                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
+            }
+        }
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isExpression, targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
+        let type;
+        if (this.#compiler.isCallExpression(sourceNode)) {
+            type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
+        }
+        if (this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.#compiler.isIdentifier(sourceNode) ||
+            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+            type = matchWorker.getType(sourceNode);
+        }
+        if (!type || type.getConstructSignatures().length === 0) {
+            const text = [];
+            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
+            }
+            else {
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a constructable type"));
+            }
+            if (type != null && type.getCallSignatures().length > 0) {
+                text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeCallableWith()' matcher"));
+            }
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToHaveProperty {
     #compiler;
     constructor(compiler) {
@@ -3769,7 +4205,7 @@ class ToHaveProperty {
         const sourceTypeText = matchWorker.getTypeText(sourceNode);
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText;
-        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+        if (isStringOrNumberLiteralType(this.#compiler, targetType)) {
             propertyNameText = targetType.value.toString();
         }
         else {
@@ -3777,8 +4213,8 @@ class ToHaveProperty {
         }
         const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
         return matchWorker.assertion.isNot
-            ? [Diagnostic.error(ExpectDiagnosticText.typeHasProperty(sourceTypeText, propertyNameText), origin)]
-            : [Diagnostic.error(ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
+            ? [Diagnostic.error(ExpectDiagnosticText.hasProperty(sourceTypeText, propertyNameText), origin)]
+            : [Diagnostic.error(ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
     }
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
@@ -3786,18 +4222,18 @@ class ToHaveProperty {
         if (sourceType.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never) ||
             !matchWorker.extendsObjectType(sourceType)) {
             const expectedText = "of an object type";
-            const text = this.#compiler.isTypeNode(sourceNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
-                : ExpectDiagnosticText.argumentMustBe("source", expectedText);
+            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText = "";
-        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+        if (isStringOrNumberLiteralType(this.#compiler, targetType)) {
             propertyNameText = targetType.value.toString();
         }
-        else if (matchWorker.isUniqueSymbolType(targetType)) {
+        else if (isUniqueSymbolType(this.#compiler, targetType)) {
             propertyNameText = this.#compiler.unescapeLeadingUnderscores(targetType.escapedName);
         }
         else {
@@ -3825,15 +4261,15 @@ class ToRaiseError {
         this.#compiler = compiler;
     }
     #explain(matchWorker, sourceNode, targetNodes) {
-        const isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
         const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
         if (matchWorker.assertion.diagnostics.size === 0) {
-            const text = ExpectDiagnosticText.typeDidNotRaiseError(isTypeNode);
+            const text = ExpectDiagnosticText.didNotRaiseError(isExpression);
             return [Diagnostic.error(text, origin)];
         }
         if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
             const count = matchWorker.assertion.diagnostics.size;
-            const text = ExpectDiagnosticText.typeRaisedError(isTypeNode, count, targetNodes.length);
+            const text = ExpectDiagnosticText.raisedError(isExpression, count, targetNodes.length);
             const related = [
                 Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
                 ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics]),
@@ -3845,8 +4281,8 @@ class ToRaiseError {
             const isMatch = this.#matchExpectedError(diagnostic, targetNode);
             if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeRaisedMatchingError(isTypeNode)
-                    : ExpectDiagnosticText.typeDidNotRaiseMatchingError(isTypeNode);
+                    ? ExpectDiagnosticText.raisedMatchingError(isExpression)
+                    : ExpectDiagnosticText.didNotRaiseMatchingError(isExpression);
                 const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
                 const related = [
                     Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
@@ -3891,9 +4327,10 @@ class ToRaiseError {
         if (this.#compiler.isNumericLiteral(targetNode)) {
             return Number.parseInt(targetNode.text, 10) === diagnostic.code;
         }
-        const messageText = typeof diagnostic.messageText === "string"
-            ? diagnostic.messageText
-            : Diagnostic.toMessageText(diagnostic.messageText).join("\n");
+        let messageText = getDiagnosticMessageText(diagnostic);
+        if (Array.isArray(messageText)) {
+            messageText = messageText.join("\n");
+        }
         if (this.#compiler.isRegularExpressionLiteral(targetNode)) {
             const targetRegex = new RegExp(...targetNode.text.slice(1).split("/"));
             return targetRegex.test(messageText);
@@ -3904,61 +4341,64 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
-    #rejectTypes = new Set();
+    #reject;
     #typeChecker;
     toAcceptProps;
     toBe;
+    toBeApplicable;
     toBeAssignableTo;
     toBeAssignableWith;
+    toBeCallableWith;
+    toBeConstructableWith;
     toHaveProperty;
     toRaiseError;
-    constructor(compiler, typeChecker, resolvedConfig) {
+    constructor(compiler, typeChecker, reject) {
         this.#compiler = compiler;
+        this.#reject = reject;
         this.#typeChecker = typeChecker;
-        if (resolvedConfig?.rejectAnyType) {
-            this.#rejectTypes.add("any");
-        }
-        if (resolvedConfig?.rejectNeverType) {
-            this.#rejectTypes.add("never");
-        }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
+        this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
+        this.toBeCallableWith = new ToBeCallableWith(compiler);
+        this.toBeConstructableWith = new ToBeConstructableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
     match(assertion, onDiagnostics) {
-        const matcherNameText = assertion.matcherName.getText();
-        if (!assertion.source[0]) {
-            this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
+        const matcherNameText = assertion.matcherNameNode.name.text;
+        if (!argumentOrTypeArgumentIsProvided("source", "Source", assertion.source[0], assertion.node.expression, onDiagnostics)) {
             return;
         }
         const matchWorker = new MatchWorker(this.#compiler, this.#typeChecker, assertion);
+        if (!(matcherNameText === "toRaiseError" && assertion.isNot === false) &&
+            this.#reject.argumentType([
+                ["source", assertion.source[0]],
+                ["target", assertion.target?.[0]],
+            ], onDiagnostics)) {
+            return;
+        }
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-                if (!assertion.target[0]) {
-                    this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
-                    return;
-                }
-                if (this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+                if (!argumentOrTypeArgumentIsProvided("target", "Target", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
+            case "toBeApplicable":
+                return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
+            case "toBeCallableWith":
+            case "toBeConstructableWith":
+            case "toRaiseError":
+                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
             case "toHaveProperty":
-                if (!assertion.target[0]) {
-                    this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
+                if (!argumentIsProvided("key", assertion.target?.[0], assertion.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            case "toRaiseError":
-                if (assertion.isNot && this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
-                    return;
-                }
-                return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
         }
@@ -3966,45 +4406,64 @@ class ExpectService {
     }
     #onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics) {
         const text = ExpectDiagnosticText.matcherIsNotSupported(matcherNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
+        const origin = DiagnosticOrigin.fromNode(assertion.matcherNameNode.name);
         onDiagnostics(Diagnostic.error(text, origin));
     }
-    #onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("source", "Source");
-        const origin = DiagnosticOrigin.fromNode(assertion.node.expression);
-        onDiagnostics(Diagnostic.error(text, origin));
+}
+
+function capitalize(text) {
+    return text.replace(/^./, text.charAt(0).toUpperCase());
+}
+
+class RejectDiagnosticText {
+    static argumentCannotBeOfType(argumentNameText, typeText) {
+        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
     }
-    #onTargetArgumentMustBeProvided(argumentNameText, assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-        onDiagnostics(Diagnostic.error(text, origin));
+    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
+        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
     }
-    #onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics) {
-        const text = ExpectDiagnosticText.argumentOrTypeArgumentMustBeProvided("target", "Target");
-        const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
-        onDiagnostics(Diagnostic.error(text, origin));
+    static typeWasRejected(typeText) {
+        const optionNameText = `reject${capitalize(typeText)}Type`;
+        return [
+            `The '${typeText}' type was rejected because the '${optionNameText}' option is enabled.`,
+            `If this check is necessary, pass '${typeText}' as the type argument explicitly.`,
+        ];
+    }
+}
+
+class Reject {
+    #compiler;
+    #rejectedArgumentTypes = new Set();
+    #typeChecker;
+    constructor(compiler, typeChecker, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#typeChecker = typeChecker;
+        if (resolvedConfig?.rejectAnyType) {
+            this.#rejectedArgumentTypes.add("any");
+        }
+        if (resolvedConfig?.rejectNeverType) {
+            this.#rejectedArgumentTypes.add("never");
+        }
     }
-    #rejectsTypeArguments(matchWorker, onDiagnostics) {
-        for (const rejectedType of this.#rejectTypes) {
-            const allowedKeyword = this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`];
-            if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
-                matchWorker.assertion.target[0]?.kind === allowedKeyword) {
+    argumentType(target, onDiagnostics) {
+        for (const rejectedType of this.#rejectedArgumentTypes) {
+            const allowedKeyword = this.#compiler.SyntaxKind[`${capitalize(rejectedType)}Keyword`];
+            if (target.some(([, node]) => node?.kind === allowedKeyword)) {
                 continue;
             }
-            for (const argumentName of ["source", "target"]) {
-                const argumentNode = matchWorker.assertion[argumentName][0];
-                if (!argumentNode) {
+            for (const [name, node] of target) {
+                if (!node) {
                     continue;
                 }
-                if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[Format.capitalize(rejectedType)]) {
+                if (this.#typeChecker.getTypeAtLocation(node).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
                     const text = [
-                        this.#compiler.isTypeNode(argumentNode)
-                            ? ExpectDiagnosticText.typeArgumentCannotBeOfType(Format.capitalize(argumentName), rejectedType)
-                            : ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType),
-                        ...ExpectDiagnosticText.typeWasRejected(rejectedType),
+                        nodeBelongsToArgumentList(this.#compiler, node)
+                            ? RejectDiagnosticText.argumentCannotBeOfType(name, rejectedType)
+                            : RejectDiagnosticText.typeArgumentCannotBeOfType(capitalize(name), rejectedType),
+                        ...RejectDiagnosticText.typeWasRejected(rejectedType),
                     ];
-                    const origin = DiagnosticOrigin.fromNode(argumentNode);
-                    onDiagnostics(Diagnostic.error(text, origin));
+                    const origin = DiagnosticOrigin.fromNode(node);
+                    onDiagnostics([Diagnostic.error(text, origin)]);
                     return true;
                 }
             }
@@ -4013,20 +4472,78 @@ class ExpectService {
     }
 }
 
+class WhenDiagnosticText {
+    static actionIsNotSupported(actionNameText) {
+        return `The '.${actionNameText}()' action is not supported.`;
+    }
+}
+
+class WhenService {
+    #onDiagnostics;
+    #reject;
+    constructor(reject, onDiagnostics) {
+        this.#reject = reject;
+        this.#onDiagnostics = onDiagnostics;
+    }
+    action(when) {
+        if (!argumentIsProvided("target", when.target[0], when.node.expression, this.#onDiagnostics) ||
+            this.#reject.argumentType([["target", when.target[0]]], this.#onDiagnostics)) {
+            return;
+        }
+        const actionNameText = when.actionNameNode.name.getText();
+        switch (actionNameText) {
+            case "isCalledWith":
+                break;
+            default:
+                this.#onActionIsNotSupported(actionNameText, when, this.#onDiagnostics);
+                return;
+        }
+        if (when.abilityDiagnostics != null && when.abilityDiagnostics.size > 0) {
+            const diagnostics = [];
+            for (const diagnostic of when.abilityDiagnostics) {
+                if (isDiagnosticWithLocation(diagnostic)) {
+                    const text = getDiagnosticMessageText(diagnostic);
+                    let origin;
+                    if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, when.node)) {
+                        origin = DiagnosticOrigin.fromNodes(when.target);
+                    }
+                    else {
+                        origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), when.node.getSourceFile());
+                    }
+                    let related;
+                    if (diagnostic.relatedInformation != null) {
+                        related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                    }
+                    diagnostics.push(Diagnostic.error(text, origin).add({ related }));
+                }
+            }
+            this.#onDiagnostics(diagnostics);
+        }
+    }
+    #onActionIsNotSupported(actionNameText, when, onDiagnostics) {
+        const text = WhenDiagnosticText.actionIsNotSupported(actionNameText);
+        const origin = DiagnosticOrigin.fromNode(when.actionNameNode.name);
+        onDiagnostics([Diagnostic.error(text, origin)]);
+    }
+}
+
 class TestTreeWalker {
     #cancellationToken;
     #expectService;
     #hasOnly;
+    #onTaskDiagnostics;
     #position;
     #resolvedConfig;
-    #taskResult;
-    constructor(resolvedConfig, compiler, typeChecker, options) {
+    #whenService;
+    constructor(compiler, typeChecker, resolvedConfig, onTaskDiagnostics, options) {
         this.#resolvedConfig = resolvedConfig;
+        this.#onTaskDiagnostics = onTaskDiagnostics;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
-        this.#taskResult = options.taskResult;
-        this.#expectService = new ExpectService(compiler, typeChecker, this.#resolvedConfig);
+        const reject = new Reject(compiler, typeChecker, resolvedConfig);
+        this.#expectService = new ExpectService(compiler, typeChecker, reject);
+        this.#whenService = new WhenService(reject, onTaskDiagnostics);
     }
     #resolveRunMode(mode, testNode) {
         if (testNode.flags & TestTreeNodeFlags.Fail) {
@@ -4051,25 +4568,23 @@ class TestTreeWalker {
         }
         return mode;
     }
-    visit(testNodes, runMode, parentResult) {
-        for (const testNode of testNodes) {
+    visit(nodes, runMode, parentResult) {
+        for (const node of nodes) {
             if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
-            const validationError = testNode.validate();
-            if (validationError.length > 0) {
-                EventEmitter.dispatch(["task:error", { diagnostics: validationError, result: this.#taskResult }]);
-                break;
-            }
-            switch (testNode.brand) {
+            switch (node.brand) {
                 case TestTreeNodeBrand.Describe:
-                    this.#visitDescribe(testNode, runMode, parentResult);
+                    this.#visitDescribe(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Test:
-                    this.#visitTest(testNode, runMode, parentResult);
+                    this.#visitTest(node, runMode, parentResult);
                     break;
                 case TestTreeNodeBrand.Expect:
-                    this.#visitAssertion(testNode, runMode, parentResult);
+                    this.#visitAssertion(node, runMode, parentResult);
+                    break;
+                case TestTreeNodeBrand.When:
+                    this.#visitWhen(node);
                     break;
             }
         }
@@ -4089,7 +4604,7 @@ class TestTreeWalker {
                 { diagnostics: Array.isArray(diagnostics) ? diagnostics : [diagnostics], result: expectResult },
             ]);
         };
-        if (assertion.diagnostics.size > 0 && assertion.matcherName.getText() !== "toRaiseError") {
+        if (assertion.diagnostics.size > 0 && assertion.matcherNameNode.name.text !== "toRaiseError") {
             onExpectDiagnostics(Diagnostic.fromDiagnostics([...assertion.diagnostics]));
             return;
         }
@@ -4120,13 +4635,7 @@ class TestTreeWalker {
         runMode = this.#resolveRunMode(runMode, describe);
         if (!(runMode & RunMode.Skip || (this.#hasOnly && !(runMode & RunMode.Only)) || runMode & RunMode.Todo) &&
             describe.diagnostics.size > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                {
-                    diagnostics: Diagnostic.fromDiagnostics([...describe.diagnostics]),
-                    result: this.#taskResult,
-                },
-            ]);
+            this.#onTaskDiagnostics(Diagnostic.fromDiagnostics([...describe.diagnostics]));
         }
         else {
             this.visit(describe.children, runMode, describeResult);
@@ -4163,71 +4672,86 @@ class TestTreeWalker {
             EventEmitter.dispatch(["test:pass", { result: testResult }]);
         }
     }
+    #visitWhen(when) {
+        this.#whenService.action(when);
+    }
 }
 
 class TaskRunner {
-    #compiler;
     #collectService;
+    #compiler;
     #resolvedConfig;
     #projectService;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
+    constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
-        this.#collectService = new CollectService(compiler);
-        this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
+        this.#resolvedConfig = resolvedConfig;
+        this.#projectService = new ProjectService(compiler, this.#resolvedConfig);
+        this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
-    run(task, cancellationToken) {
-        if (cancellationToken?.isCancellationRequested) {
+    #onDiagnostics(diagnostics, result) {
+        EventEmitter.dispatch(["task:error", { diagnostics, result }]);
+    }
+    async run(task, cancellationToken) {
+        if (cancellationToken.isCancellationRequested) {
             return;
         }
         this.#projectService.openFile(task.filePath, undefined, this.#resolvedConfig.rootPath);
         const taskResult = new TaskResult(task);
         EventEmitter.dispatch(["task:start", { result: taskResult }]);
-        this.#run(task, taskResult, cancellationToken);
+        await this.#run(task, taskResult, cancellationToken);
         EventEmitter.dispatch(["task:end", { result: taskResult }]);
         this.#projectService.closeFile(task.filePath);
     }
-    #run(task, taskResult, cancellationToken) {
+    async #run(task, taskResult, cancellationToken) {
         if (!existsSync(task.filePath)) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: [Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], result: taskResult },
-            ]);
-            return;
-        }
-        const languageService = this.#projectService.getLanguageService(task.filePath);
-        if (!languageService) {
+            this.#onDiagnostics([Diagnostic.error(`Test file '${task.filePath}' does not exist.`)], taskResult);
             return;
         }
-        const syntacticDiagnostics = languageService.getSyntacticDiagnostics(task.filePath);
-        if (syntacticDiagnostics.length > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: Diagnostic.fromDiagnostics(syntacticDiagnostics), result: taskResult },
-            ]);
+        let languageService = this.#projectService.getLanguageService(task.filePath);
+        const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
+        if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
+            this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
             return;
         }
-        const semanticDiagnostics = languageService.getSemanticDiagnostics(task.filePath);
-        const program = languageService.getProgram();
-        if (!program) {
-            return;
+        let semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+        let program = languageService?.getProgram();
+        let sourceFile = program?.getSourceFile(task.filePath);
+        if (sourceFile?.text.startsWith("// @tstyche-template")) {
+            if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), taskResult);
+                return;
+            }
+            const moduleSpecifier = pathToFileURL(task.filePath).toString();
+            const testText = (await import(moduleSpecifier))?.default;
+            if (typeof testText !== "string") {
+                this.#onDiagnostics([Diagnostic.error("A template test file must export a string.")], taskResult);
+                return;
+            }
+            this.#projectService.openFile(task.filePath, testText, this.#resolvedConfig.rootPath);
+            languageService = this.#projectService.getLanguageService(task.filePath);
+            const syntacticDiagnostics = languageService?.getSyntacticDiagnostics(task.filePath);
+            if (syntacticDiagnostics != null && syntacticDiagnostics.length > 0) {
+                this.#onDiagnostics(Diagnostic.fromDiagnostics(syntacticDiagnostics), taskResult);
+                return;
+            }
+            semanticDiagnostics = languageService?.getSemanticDiagnostics(task.filePath);
+            program = languageService?.getProgram();
+            sourceFile = program?.getSourceFile(task.filePath);
         }
-        const sourceFile = program.getSourceFile(task.filePath);
         if (!sourceFile) {
             return;
         }
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
         if (testTree.diagnostics.size > 0) {
-            EventEmitter.dispatch([
-                "task:error",
-                { diagnostics: Diagnostic.fromDiagnostics([...testTree.diagnostics]), result: taskResult },
-            ]);
+            this.#onDiagnostics(Diagnostic.fromDiagnostics([...testTree.diagnostics]), taskResult);
             return;
         }
-        const typeChecker = program.getTypeChecker();
-        const testTreeWalker = new TestTreeWalker(this.#resolvedConfig, this.#compiler, typeChecker, {
+        const typeChecker = program?.getTypeChecker();
+        const onTaskDiagnostics = (diagnostics) => {
+            this.#onDiagnostics(diagnostics, taskResult);
+        };
+        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, onTaskDiagnostics, {
             cancellationToken,
-            taskResult,
             hasOnly: testTree.hasOnly,
             position: task.position,
         });
@@ -4238,15 +4762,13 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.0";
+    static version = "4.0.0-beta.10";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
     #addHandlers(cancellationToken) {
         const resultHandler = new ResultHandler();
         this.#eventEmitter.addHandler(resultHandler);
-        const testTreeHandler = new TestTreeHandler();
-        this.#eventEmitter.addHandler(testTreeHandler);
         if (this.#resolvedConfig.failFast) {
             const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.FailFast);
             this.#eventEmitter.addHandler(cancellationHandler);
@@ -4289,16 +4811,16 @@ class Runner {
         this.#eventEmitter.removeHandlers();
     }
     async #run(tasks, cancellationToken) {
-        const result = new Result(this.#resolvedConfig, tasks);
+        const result = new Result(tasks);
         EventEmitter.dispatch(["run:start", { result }]);
         for (const target of this.#resolvedConfig.target) {
             const targetResult = new TargetResult(target, tasks);
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
             const compiler = await Store.load(target);
             if (compiler) {
-                const taskRunner = new TaskRunner(this.#resolvedConfig, compiler);
+                const taskRunner = new TaskRunner(compiler, this.#resolvedConfig);
                 for (const task of tasks) {
-                    taskRunner.run(task, cancellationToken);
+                    await taskRunner.run(task, cancellationToken);
                 }
             }
             EventEmitter.dispatch(["target:end", { result: targetResult }]);
@@ -4440,4 +4962,4 @@ class Cli {
     }
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, WhenService, addsPackageText, argumentIsProvided, argumentOrTypeArgumentIsProvided, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };