tstyche 4.0.0-beta.8 → 4.0.0-rc.0

package/build/tstyche.js

@@ -572,7 +572,6 @@ class ManifestService {
     #manifestFilePath;
     #npmRegistry;
     #storePath;
-    #supportedVersionRegex = /^(5)\.\d\.\d$/;
     constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
         this.#npmRegistry = npmRegistry;
@@ -602,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 };
             }
@@ -701,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)) {
@@ -808,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));
@@ -2547,7 +2545,6 @@ var CancellationReason;
 (function (CancellationReason) {
     CancellationReason["ConfigChange"] = "configChange";
     CancellationReason["ConfigError"] = "configError";
-    CancellationReason["CollectError"] = "collectError";
     CancellationReason["FailFast"] = "failFast";
     CancellationReason["WatchClose"] = "watchClose";
 })(CancellationReason || (CancellationReason = {}));
@@ -2873,18 +2870,9 @@ class WatchService {
     }
 }
 
-var TestTreeNodeBrand;
-(function (TestTreeNodeBrand) {
-    TestTreeNodeBrand["Describe"] = "describe";
-    TestTreeNodeBrand["Test"] = "test";
-    TestTreeNodeBrand["Expect"] = "expect";
-    TestTreeNodeBrand["When"] = "when";
-})(TestTreeNodeBrand || (TestTreeNodeBrand = {}));
-
 class TestTreeNode {
     brand;
     children = [];
-    #compiler;
     diagnostics = new Set();
     flags;
     name = "";
@@ -2892,7 +2880,6 @@ class TestTreeNode {
     parent;
     constructor(compiler, brand, node, parent, flags) {
         this.brand = brand;
-        this.#compiler = compiler;
         this.node = node;
         this.parent = parent;
         this.flags = flags;
@@ -2908,34 +2895,6 @@ class TestTreeNode {
             }
         }
     }
-    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 child of this.children) {
-                    if (child.brand === TestTreeNodeBrand.Expect || child.brand === TestTreeNodeBrand.When) {
-                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(getParentCallExpression(child.node))));
-                    }
-                }
-                break;
-            case TestTreeNodeBrand.Test:
-            case TestTreeNodeBrand.Expect:
-                for (const child of this.children) {
-                    if (child.brand === TestTreeNodeBrand.Describe || child.brand === TestTreeNodeBrand.Test) {
-                        diagnostics.push(Diagnostic.error(getText(child.node), DiagnosticOrigin.fromNode(child.node)));
-                    }
-                }
-                break;
-        }
-        return diagnostics;
-    }
 }
 
 class AssertionNode extends TestTreeNode {
@@ -2967,10 +2926,10 @@ class AssertionNode extends TestTreeNode {
 }
 
 function nodeBelongsToArgumentList(compiler, node) {
-    if (compiler.isCallExpression(node.parent)) {
-        return node.parent.arguments.some((argument) => argument === node);
-    }
-    return false;
+    return compiler.isCallExpression(node.parent) && node.parent.arguments.some((argument) => argument === node);
+}
+function nodeIsChildOfExpressionStatement(compiler, node) {
+    return compiler.isExpressionStatement(node.parent);
 }
 
 class AbilityLayer {
@@ -3033,6 +2992,11 @@ class AbilityLayer {
         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();
@@ -3040,13 +3004,14 @@ class AbilityLayer {
         const actionNameEnd = whenNode.actionNameNode.getEnd();
         switch (whenNode.actionNameNode.name.text) {
             case "isCalledWith":
+                this.#eraseTrailingComma(whenNode.target, whenNode);
                 this.#addRanges(whenNode, [
                     {
-                        end: whenExpressionEnd,
                         start: whenStart,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, whenNode.actionNode) ? "" : ";",
+                        end: whenExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
                     },
-                    { end: actionNameEnd, start: whenEnd },
+                    { start: whenEnd, end: actionNameEnd },
                 ]);
                 break;
         }
@@ -3059,28 +3024,30 @@ class AbilityLayer {
         switch (assertionNode.matcherNameNode.name.text) {
             case "toBeApplicable":
                 this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd, start: expectStart },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectStart, end: expectExpressionEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeCallableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
                 this.#addRanges(assertionNode, [
                     {
-                        end: expectExpressionEnd,
                         start: expectStart,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "" : ";",
+                        end: expectExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? ";" : "",
                     },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
             case "toBeConstructableWith":
+                this.#eraseTrailingComma(assertionNode.source, assertionNode);
                 this.#addRanges(assertionNode, [
                     {
-                        end: expectExpressionEnd,
                         start: expectStart,
-                        replacement: nodeBelongsToArgumentList(this.#compiler, assertionNode.matcherNode) ? "new" : "; new",
+                        end: expectExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, assertionNode.matcherNode) ? "; new" : "new",
                     },
-                    { end: matcherNameEnd, start: expectEnd },
+                    { start: expectEnd, end: matcherNameEnd },
                 ]);
                 break;
         }
@@ -3097,6 +3064,14 @@ class CollectDiagnosticText {
     }
 }
 
+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";
@@ -3110,19 +3085,8 @@ class IdentifierLookup {
     #compiler;
     #identifiers;
     #moduleSpecifiers = ['"tstyche"', "'tstyche'"];
-    constructor(compiler, identifiers) {
+    constructor(compiler) {
         this.#compiler = compiler;
-        this.#identifiers = identifiers ?? {
-            namedImports: {
-                describe: undefined,
-                expect: undefined,
-                it: undefined,
-                namespace: undefined,
-                test: undefined,
-                when: undefined,
-            },
-            namespace: undefined,
-        };
     }
     handleImportDeclaration(node) {
         if (this.#moduleSpecifiers.includes(node.moduleSpecifier.getText()) &&
@@ -3150,7 +3114,20 @@ class IdentifierLookup {
             }
         }
     }
-    resolveTestMemberMeta(node) {
+    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)) {
@@ -3233,72 +3210,72 @@ class CollectService {
     #abilityLayer;
     #compiler;
     #identifierLookup;
-    #projectService;
-    #resolvedConfig;
-    #testTree;
     constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
-        this.#projectService = projectService;
-        this.#resolvedConfig = resolvedConfig;
-        this.#abilityLayer = new AbilityLayer(compiler, this.#projectService, this.#resolvedConfig);
+        this.#abilityLayer = new AbilityLayer(compiler, projectService, resolvedConfig);
         this.#identifierLookup = new IdentifierLookup(compiler);
     }
-    #collectTestTreeNodes(node, parent) {
+    #collectTestTreeNodes(node, parent, testTree) {
         if (this.#compiler.isCallExpression(node)) {
-            const meta = this.#identifierLookup.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);
-                this.#compiler.forEachChild(node, (node) => {
-                    this.#collectTestTreeNodes(node, testTreeNode);
-                });
-                this.#onNode(testTreeNode, parent);
-                return;
-            }
-            if (meta != null && 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) {
+            const meta = this.#identifierLookup.resolveTestTreeNodeMeta(node);
+            if (meta != null) {
+                if (!this.#checkNode(node, meta, parent)) {
                     return;
                 }
-                const matcherNode = this.#getMatcherNode(matcherNameNode);
-                if (!matcherNode) {
+                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;
                 }
-                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);
-                });
-                this.#onNode(assertionNode, parent);
-                return;
-            }
-            if (meta != null && meta.brand === TestTreeNodeBrand.When) {
-                const actionNameNode = this.#getChainedNode(node);
-                if (!actionNameNode) {
+                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;
                 }
-                const actionNode = this.#getActionNode(actionNameNode);
-                if (!actionNode) {
+                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;
                 }
-                this.#compiler.forEachChild(actionNode, (node) => {
-                    if (this.#compiler.isCallExpression(node)) {
-                        const meta = this.#identifierLookup.resolveTestMemberMeta(node);
-                        if (meta != null && (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);
-                return;
             }
         }
         if (this.#compiler.isImportDeclaration(node)) {
@@ -3306,20 +3283,45 @@ class CollectService {
             return;
         }
         this.#compiler.forEachChild(node, (node) => {
-            this.#collectTestTreeNodes(node, parent);
+            this.#collectTestTreeNodes(node, parent, testTree);
         });
     }
     createTestTree(sourceFile, semanticDiagnostics = []) {
         const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
         EventEmitter.dispatch(["collect:start", { tree: testTree }]);
-        this.#testTree = testTree;
         this.#abilityLayer.open(sourceFile);
-        this.#collectTestTreeNodes(sourceFile, testTree);
+        this.#identifierLookup.open();
+        this.#collectTestTreeNodes(sourceFile, testTree, testTree);
         this.#abilityLayer.close();
-        this.#testTree = undefined;
         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;
@@ -3350,10 +3352,10 @@ class CollectService {
     #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["collect:error", { diagnostics: [diagnostic] }]);
     }
-    #onNode(node, parent) {
+    #onNode(node, parent, testTree) {
         parent.children.push(node);
         if (node.flags & TestTreeNodeFlags.Only) {
-            this.#testTree.hasOnly = true;
+            testTree.hasOnly = true;
         }
         EventEmitter.dispatch(["collect:node", { node }]);
     }
@@ -3409,7 +3411,6 @@ class ProjectService {
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
-            allowImportingTsExtensions: true,
             allowJs: true,
             checkJs: true,
             exactOptionalPropertyTypes: true,
@@ -3420,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) {
@@ -3504,22 +3508,41 @@ var RunMode;
     RunMode[RunMode["Todo"] = 8] = "Todo";
 })(RunMode || (RunMode = {}));
 
-function capitalize(text) {
-    return text.replace(/^./, text.charAt(0).toUpperCase());
-}
-
-class ExpectDiagnosticText {
-    static argumentCannotBeOfType(argumentNameText, typeText) {
-        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
+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 argumentMustBeProvided(argumentNameText) {
-        return `An argument for '${argumentNameText}' must be provided.`;
+    static typeArgumentMustBe(argumentNameText, expectedText) {
+        return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
     static isCallable(isExpression, targetText) {
         return `${isExpression ? "Expression" : "Type"} is callable ${targetText}.`;
@@ -3545,12 +3568,12 @@ class ExpectDiagnosticText {
     static cannotBeApplied(targetText) {
         return `The decorator function cannot be applied${targetText}.`;
     }
-    static doesNotHaveProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
-    }
     static hasProperty(typeText, propertyNameText) {
         return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
+    static doesNotHaveProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    }
     static didYouMeanToUse(suggestionText) {
         return `Did you mean to use ${suggestionText}?`;
     }
@@ -3563,12 +3586,6 @@ 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 raisedError(isExpression, count, targetCount) {
         let countText = "a";
         if (count > 1 || targetCount > 1) {
@@ -3597,11 +3614,11 @@ class ExpectDiagnosticText {
     static isNotAssignableWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
     }
-    static isIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
+    static isTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is the same as type '${targetTypeText}'.`;
     }
-    static isNotIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
+    static isNotTheSame(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not the same as type '${targetTypeText}'.`;
     }
     static isNotCompatibleWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
@@ -3612,15 +3629,14 @@ class ExpectDiagnosticText {
     static typesOfPropertyAreNotCompatible(propertyNameText) {
         return `Types of property '${propertyNameText}' are not compatible.`;
     }
-    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.`,
-        ];
-    }
 }
 
+var Relation;
+(function (Relation) {
+    Relation["Assignable"] = "assignable";
+    Relation["Identical"] = "identical";
+})(Relation || (Relation = {}));
+
 class MatchWorker {
     assertion;
     #compiler;
@@ -3645,27 +3661,25 @@ 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 };
@@ -3709,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;
             }
         }
@@ -3924,8 +3938,8 @@ class RelationMatcherBase {
 }
 
 class ToBe extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.isIdenticalTo;
-    explainNotText = ExpectDiagnosticText.isNotIdenticalTo;
+    explainText = ExpectDiagnosticText.isTheSame;
+    explainNotText = ExpectDiagnosticText.isNotTheSame;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -4327,7 +4341,7 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
-    #rejectTypes = new Set();
+    #reject;
     #typeChecker;
     toAcceptProps;
     toBe;
@@ -4338,15 +4352,10 @@ class ExpectService {
     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);
@@ -4359,13 +4368,15 @@ class ExpectService {
     }
     match(assertion, onDiagnostics) {
         const matcherNameText = assertion.matcherNameNode.name.text;
-        if (!assertion.source[0]) {
-            this.#onSourceArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
+        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.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+            this.#reject.argumentType([
+                ["source", assertion.source[0]],
+                ["target", assertion.target?.[0]],
+            ], onDiagnostics)) {
             return;
         }
         switch (matcherNameText) {
@@ -4373,8 +4384,7 @@ class ExpectService {
             case "toBe":
             case "toBeAssignableTo":
             case "toBeAssignableWith":
-                if (!assertion.target?.[0]) {
-                    this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, 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);
@@ -4385,8 +4395,7 @@ class ExpectService {
             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);
@@ -4400,42 +4409,61 @@ class ExpectService {
         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.matcherNameNode.name);
-        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.matcherNameNode.name);
-        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) {
+    argumentType(target, onDiagnostics) {
+        for (const rejectedType of this.#rejectedArgumentTypes) {
             const allowedKeyword = this.#compiler.SyntaxKind[`${capitalize(rejectedType)}Keyword`];
-            if (matchWorker.assertion.source[0]?.kind === allowedKeyword ||
-                matchWorker.assertion.target?.[0]?.kind === allowedKeyword) {
+            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[capitalize(rejectedType)]) {
+                if (this.#typeChecker.getTypeAtLocation(node).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
                     const text = [
-                        nodeBelongsToArgumentList(this.#compiler, argumentNode)
-                            ? ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType)
-                            : ExpectDiagnosticText.typeArgumentCannotBeOfType(capitalize(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;
                 }
             }
@@ -4444,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(compiler, typeChecker, resolvedConfig, 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) {
@@ -4482,28 +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(testNode, runMode, parentResult);
+                    this.#visitWhen(node);
                     break;
             }
         }
@@ -4554,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);
@@ -4597,37 +4672,14 @@ class TestTreeWalker {
             EventEmitter.dispatch(["test:pass", { result: testResult }]);
         }
     }
-    #visitWhen(when, runMode, parentResult) {
-        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 }));
-                }
-            }
-            EventEmitter.dispatch(["task:error", { diagnostics, result: this.#taskResult }]);
-            return;
-        }
-        this.visit(when.children, runMode, parentResult);
+    #visitWhen(when) {
+        this.#whenService.action(when);
     }
 }
 
 class TaskRunner {
     #collectService;
     #compiler;
-    #eventEmitter = new EventEmitter();
     #resolvedConfig;
     #projectService;
     constructor(compiler, resolvedConfig) {
@@ -4689,21 +4741,17 @@ class TaskRunner {
         if (!sourceFile) {
             return;
         }
-        const cancellationHandler = new CancellationHandler(cancellationToken, CancellationReason.CollectError);
-        this.#eventEmitter.addHandler(cancellationHandler);
         const testTree = this.#collectService.createTestTree(sourceFile, semanticDiagnostics);
-        this.#eventEmitter.removeHandler(cancellationHandler);
-        if (cancellationToken.isCancellationRequested) {
-            return;
-        }
         if (testTree.diagnostics.size > 0) {
             this.#onDiagnostics(Diagnostic.fromDiagnostics([...testTree.diagnostics]), taskResult);
             return;
         }
         const typeChecker = program?.getTypeChecker();
-        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, {
+        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,
         });
@@ -4714,7 +4762,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.8";
+    static version = "4.0.0-rc.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4914,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, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, WhenNode, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, nodeBelongsToArgumentList, 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 };