tstyche 7.1.0 → 7.2.1

package/dist/api.js

@@ -77,43 +77,6 @@ class JsonNode {
     }
 }
 
-class SourceService {
-    static #files = new Map();
-    static delete(filePath) {
-        SourceService.#files.delete(filePath);
-    }
-    static get(source) {
-        const file = SourceService.#files.get(source.fileName);
-        if (file != null) {
-            return file;
-        }
-        return source;
-    }
-    static set(source) {
-        SourceService.#files.set(source.fileName, source);
-    }
-}
-
-class DiagnosticOrigin {
-    assertionNode;
-    end;
-    sourceFile;
-    start;
-    constructor(start, end, sourceFile, assertionNode) {
-        this.start = start;
-        this.end = end;
-        this.sourceFile = SourceService.get(sourceFile);
-        this.assertionNode = assertionNode;
-    }
-    static fromAssertion(assertionNode) {
-        const node = assertionNode.matcherNameNode.name;
-        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
-    }
-    static fromNode(node, assertionNode) {
-        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
-    }
-}
-
 function diagnosticBelongsToNode(diagnostic, node) {
     return diagnostic.start != null && diagnostic.start >= node.pos && diagnostic.start <= node.end;
 }
@@ -131,6 +94,16 @@ function getDiagnosticMessageText(diagnostic) {
         ? diagnostic.messageText
         : diagnosticMessageChainToText(diagnostic.messageText);
 }
+function getOffset(position, offsets) {
+    let diff = 0;
+    for (const offset of offsets) {
+        if (offset.position > position - diff) {
+            break;
+        }
+        diff += offset.diff;
+    }
+    return diff;
+}
 function getTextSpanEnd(span) {
     return span.start + span.length;
 }
@@ -138,6 +111,29 @@ function isDiagnosticWithLocation(diagnostic) {
     return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
 }
 
+class DiagnosticOrigin {
+    assertionNode;
+    end;
+    sourceFile;
+    start;
+    constructor(start, end, sourceFile, assertionNode) {
+        this.start = start;
+        this.end = end;
+        this.sourceFile = sourceFile;
+        this.assertionNode = assertionNode;
+    }
+    static fromAbilityDiagnostic(diagnostic, assertionNode) {
+        return new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), diagnostic.file, assertionNode);
+    }
+    static fromAssertion(assertionNode) {
+        const node = assertionNode.matcherNameNode.name;
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
+    }
+    static fromNode(node, assertionNode) {
+        return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertionNode);
+    }
+}
+
 class Diagnostic {
     category;
     code;
@@ -190,6 +186,37 @@ var DiagnosticCategory;
     DiagnosticCategory["Warning"] = "warning";
 })(DiagnosticCategory || (DiagnosticCategory = {}));
 
+class MappedDiagnostic {
+    category;
+    code;
+    file;
+    length;
+    messageText;
+    relatedInformation;
+    start;
+    constructor(sourceFile, diagnostic, offsets = []) {
+        this.file = sourceFile;
+        if (diagnostic.start != null) {
+            this.start = diagnostic.start - getOffset(diagnostic.start, offsets);
+        }
+        this.category = diagnostic.category;
+        this.code = diagnostic.code;
+        this.length = diagnostic.length;
+        this.messageText = diagnostic.messageText;
+        if ("relatedInformation" in diagnostic && Array.isArray(diagnostic.relatedInformation)) {
+            this.relatedInformation = [];
+            for (const related of diagnostic.relatedInformation) {
+                if (related.file?.fileName === sourceFile.fileName) {
+                    this.relatedInformation.push(new MappedDiagnostic(sourceFile, related, offsets));
+                }
+                else {
+                    this.relatedInformation.push(related);
+                }
+            }
+        }
+    }
+}
+
 class JsonScanner {
     #end;
     #position;
@@ -307,15 +334,20 @@ class JsonSourceFile {
         const result = [0];
         let position = 0;
         while (position < this.text.length) {
-            if (this.text.charAt(position - 1) === "\r") {
-                position++;
-            }
-            if (this.text.charAt(position - 1) === "\n") {
-                result.push(position);
+            const character = this.text.charAt(position);
+            switch (character) {
+                case "\n":
+                    result.push(position + 1);
+                    break;
+                case "\r":
+                    if (this.text.charAt(position + 1) === "\n") {
+                        result.push(position + 2);
+                        position++;
+                    }
+                    break;
             }
             position++;
         }
-        result.push(position);
         return result;
     }
     getLineStarts() {
@@ -417,15 +449,31 @@ class ConfigDiagnosticText {
 class Environment {
     static resolve() {
         return {
+            fetchRetries: Environment.#resolveFetchRetries(),
+            fetchTimeout: Environment.#resolveFetchTimeout(),
             isCi: Environment.#resolveIsCi(),
             noColor: Environment.#resolveNoColor(),
             noInteractive: Environment.#resolveNoInteractive(),
             npmRegistry: Environment.#resolveNpmRegistry(),
             storePath: Environment.#resolveStorePath(),
-            timeout: Environment.#resolveTimeout(),
             typescriptModule: Environment.#resolveTypeScriptModule(),
         };
     }
+    static #resolveFetchRetries() {
+        if (process.env["TSTYCHE_FETCH_RETRIES"] != null) {
+            return Number(process.env["TSTYCHE_FETCH_RETRIES"]);
+        }
+        return 2;
+    }
+    static #resolveFetchTimeout() {
+        if (process.env["TSTYCHE_FETCH_TIMEOUT"] != null) {
+            return Number.parseFloat(process.env["TSTYCHE_FETCH_TIMEOUT"]);
+        }
+        if (process.env["TSTYCHE_TIMEOUT"] != null) {
+            return Number.parseFloat(process.env["TSTYCHE_TIMEOUT"]);
+        }
+        return 30;
+    }
     static #resolveIsCi() {
         if (process.env["CI"] != null) {
             return process.env["CI"] !== "";
@@ -468,12 +516,6 @@ class Environment {
         }
         return Path.resolve(os.homedir(), ".local", "share", "TSTyche");
     }
-    static #resolveTimeout() {
-        if (process.env["TSTYCHE_TIMEOUT"] != null) {
-            return Number.parseFloat(process.env["TSTYCHE_TIMEOUT"]);
-        }
-        return 30;
-    }
     static #resolveTypeScriptModule() {
         let specifier = "typescript";
         if (process.env["TSTYCHE_TYPESCRIPT_MODULE"] != null) {
@@ -522,6 +564,10 @@ class Version {
     }
 }
 
+function sleep(delay) {
+    return new Promise((resolve) => setTimeout(resolve, delay));
+}
+
 class StoreDiagnosticText {
     static cannotAddTypeScriptPackage(tag) {
         return `Cannot add the 'typescript' package for the '${tag}' tag.`;
@@ -535,13 +581,13 @@ class StoreDiagnosticText {
     static failedToUpdateMetadata(registry) {
         return `Failed to update metadata of the 'typescript' package from '${registry}'.`;
     }
-    static maybeNetworkConnectionIssue() {
-        return "Might be there is an issue with the registry or the network connection.";
-    }
     static maybeOutdatedResolution(tag) {
         return `The resolution of the '${tag}' tag may be outdated.`;
     }
-    static requestFailedWithStatusCode(code) {
+    static networkFailure(retries) {
+        return `The network connection failed after ${retries + 1} attempts.`;
+    }
+    static requestFailed(code) {
         return `The request failed with status code ${code}.`;
     }
     static requestTimeoutWasExceeded(timeout) {
@@ -554,29 +600,48 @@ class StoreDiagnosticText {
 
 class Fetcher {
     #onDiagnostics;
+    #retries;
     #timeout;
-    constructor(onDiagnostics, timeout) {
+    constructor(onDiagnostics, retries, timeout) {
         this.#onDiagnostics = onDiagnostics;
+        this.#retries = retries;
         this.#timeout = timeout;
     }
     async get(request, diagnostic, options) {
-        try {
-            const response = await fetch(request, { signal: AbortSignal.timeout(this.#timeout) });
-            if (!response.ok) {
-                !options?.suppressErrors &&
-                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.requestFailedWithStatusCode(response.status)));
-                return;
+        let delay = 3000;
+        request.headers.set("User-Agent", `tstyche/${"7.2.1"} ${process.platform} ${process.arch}`);
+        for (let attempt = 0; attempt <= this.#retries; attempt++) {
+            const isLastAttempt = attempt === this.#retries;
+            const suppressErrors = options?.suppressErrors || !isLastAttempt;
+            try {
+                const response = await fetch(request, { signal: AbortSignal.timeout(this.#timeout) });
+                if (response.ok) {
+                    return response;
+                }
+                if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                    if (options?.suppressErrors) {
+                        return;
+                    }
+                    this.#onDiagnostics(diagnostic().extendWith(StoreDiagnosticText.requestFailed(response.status)));
+                    return;
+                }
+                if (!suppressErrors) {
+                    this.#onDiagnostics(diagnostic().extendWith(StoreDiagnosticText.requestFailed(response.status)));
+                }
             }
-            return response;
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "TimeoutError") {
-                !options?.suppressErrors &&
-                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.requestTimeoutWasExceeded(this.#timeout)));
+            catch (error) {
+                if (!suppressErrors) {
+                    if (error instanceof Error && error.name === "TimeoutError") {
+                        this.#onDiagnostics(diagnostic().extendWith(StoreDiagnosticText.requestTimeoutWasExceeded(this.#timeout)));
+                    }
+                    else {
+                        this.#onDiagnostics(diagnostic().extendWith(StoreDiagnosticText.networkFailure(this.#retries)));
+                    }
+                }
             }
-            else {
-                !options?.suppressErrors &&
-                    this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.maybeNetworkConnectionIssue()));
+            if (!isLastAttempt) {
+                await sleep(delay);
+                delay *= 2;
             }
         }
         return;
@@ -620,17 +685,14 @@ class LockService {
         const waitStartTime = Date.now();
         while (isLocked) {
             if (Date.now() - waitStartTime > this.#timeout) {
-                this.#onDiagnostics(diagnostic.extendWith(StoreDiagnosticText.lockWaitTimeoutWasExceeded(this.#timeout)));
+                this.#onDiagnostics(diagnostic().extendWith(StoreDiagnosticText.lockWaitTimeoutWasExceeded(this.#timeout)));
                 break;
             }
-            await this.#sleep(1000);
+            await sleep(1000);
             isLocked = existsSync(lockFilePath);
         }
         return isLocked;
     }
-    #sleep(delay) {
-        return new Promise((resolve) => setTimeout(resolve, delay));
-    }
 }
 
 class Manifest {
@@ -711,7 +773,7 @@ class ManifestService {
         return manifest;
     }
     async #load(options) {
-        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToFetchMetadata(this.#npmRegistry));
+        const diagnostic = () => Diagnostic.error(StoreDiagnosticText.failedToFetchMetadata(this.#npmRegistry));
         const request = new Request(new URL("typescript", this.#npmRegistry), {
             headers: {
                 ["Accept"]: "application/vnd.npm.install-v1+json;q=1.0, application/json;q=0.8, */*",
@@ -848,7 +910,7 @@ class PackageService {
     }
     async ensure(packageVersion, manifest) {
         const packagePath = Path.join(this.#storePath, `typescript@${packageVersion}`);
-        const diagnostic = Diagnostic.error(StoreDiagnosticText.failedToFetchPackage(packageVersion));
+        const diagnostic = () => Diagnostic.error(StoreDiagnosticText.failedToFetchPackage(packageVersion));
         if (await this.#lockService.isLocked(packagePath, diagnostic)) {
             return;
         }
@@ -889,12 +951,13 @@ class Store {
     static #manifestService;
     static #packageService;
     static #npmRegistry = environmentOptions.npmRegistry;
+    static #fetchRetries = environmentOptions.fetchRetries;
+    static #fetchTimeout = environmentOptions.fetchTimeout * 1000;
     static #storePath = environmentOptions.storePath;
     static #supportedTags;
-    static #timeout = environmentOptions.timeout * 1000;
     static {
-        Store.#fetcher = new Fetcher(Store.#onDiagnostics, Store.#timeout);
-        Store.#lockService = new LockService(Store.#onDiagnostics, Store.#timeout);
+        Store.#fetcher = new Fetcher(Store.#onDiagnostics, Store.#fetchRetries, Store.#fetchTimeout);
+        Store.#lockService = new LockService(Store.#onDiagnostics, Store.#fetchTimeout);
         Store.#packageService = new PackageService(Store.#storePath, Store.#fetcher, Store.#lockService);
         Store.#manifestService = new ManifestService(Store.#storePath, Store.#npmRegistry, Store.#fetcher);
     }
@@ -2255,8 +2318,8 @@ function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
     const linesBelow = options?.linesBelow ?? 3;
     const showBreadcrumbs = options?.showBreadcrumbs ?? true;
     const lineMap = diagnosticOrigin.sourceFile.getLineStarts();
-    const { character: firstMarkedLineCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
-    const { character: lastMarkedLineCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
+    const { character: firstMarkedCharacter, line: firstMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.start);
+    const { character: lastMarkedCharacter, line: lastMarkedLine } = diagnosticOrigin.sourceFile.getLineAndCharacterOfPosition(diagnosticOrigin.end);
     const firstLine = Math.max(firstMarkedLine - linesAbove, 0);
     const lastLine = Math.min(lastMarkedLine + linesBelow, lineMap.length - 1);
     const gutterWidth = (lastLine + 1).toString().length + 2;
@@ -2278,12 +2341,12 @@ function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
             codeFrame.push(jsx(CodeLineText, { gutterWidth: gutterWidth, lineNumber: index + 1, lineNumberColor: highlightColor, lineText: lineText }));
             if (index === firstMarkedLine) {
                 const squiggleLength = index === lastMarkedLine
-                    ? lastMarkedLineCharacter - firstMarkedLineCharacter
-                    : lineText.length - firstMarkedLineCharacter;
-                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedLineCharacter, squiggleColor: highlightColor, squiggleWidth: squiggleLength }));
+                    ? lastMarkedCharacter - firstMarkedCharacter
+                    : lineText.length - firstMarkedCharacter;
+                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, indentWidth: firstMarkedCharacter, squiggleColor: highlightColor, squiggleWidth: squiggleLength }));
             }
             else if (index === lastMarkedLine) {
-                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lastMarkedLineCharacter }));
+                codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lastMarkedCharacter }));
             }
             else {
                 codeFrame.push(jsx(SquiggleLineText, { gutterWidth: gutterWidth, squiggleColor: highlightColor, squiggleWidth: lineText.length }));
@@ -2297,7 +2360,7 @@ function CodeFrameText({ diagnosticCategory, diagnosticOrigin, options }) {
     if (showBreadcrumbs && diagnosticOrigin.assertionNode != null) {
         breadcrumbs = jsx(BreadcrumbsText, { ancestor: diagnosticOrigin.assertionNode.parent });
     }
-    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: `:${firstMarkedLine + 1}:${firstMarkedLineCharacter + 1}` }), breadcrumbs] }));
+    const location = (jsx(Line, { children: [" ".repeat(gutterWidth + 2), jsx(Text, { color: "90", children: " at " }), jsx(Text, { color: "36", children: Path.relative("", diagnosticOrigin.sourceFile.fileName) }), jsx(Text, { color: "90", children: `:${firstMarkedLine + 1}:${firstMarkedCharacter + 1}` }), breadcrumbs] }));
     return (jsx(Text, { children: [codeFrame, jsx(Line, {}), location] }));
 }
 
@@ -3160,7 +3223,7 @@ class Select {
         if (testFilePaths.length === 0) {
             Select.#onDiagnostics(Diagnostic.error(SelectDiagnosticText.noTestFilesWereSelected(resolvedConfig)));
         }
-        return testFilePaths.sort();
+        return testFilePaths.sort((a, b) => a.localeCompare(b));
     }
     static async #visitDirectory(currentPath, testFilePaths, matchPatterns, resolvedConfig) {
         const targetPath = Path.join(resolvedConfig.rootPath, currentPath);
@@ -3290,7 +3353,7 @@ class WatchService {
         while (!cancellationToken.isCancellationRequested()) {
             const testFiles = await debounce.schedule();
             if (testFiles.length > 0) {
-                yield testFiles;
+                yield testFiles.sort((a, b) => a.path.localeCompare(b.path));
             }
         }
     }
@@ -3335,11 +3398,10 @@ class AbilityLayer {
         this.#editor = editor;
     }
     #belongsToNode(node, diagnostic) {
-        return (diagnosticBelongsToNode(diagnostic, node.matcherNode) ||
-            diagnosticBelongsToNode(diagnostic, node.source));
+        return diagnosticBelongsToNode(diagnostic, node.matcherNode) || diagnosticBelongsToNode(diagnostic, node.source);
     }
     close(diagnostics) {
-        if (diagnostics != null && this.#nodes.length > 0) {
+        if (diagnostics.length > 0 && this.#nodes.length > 0) {
             this.#nodes.reverse();
             for (const diagnostic of diagnostics) {
                 this.#mapToNodes(diagnostic);
@@ -3362,12 +3424,63 @@ class AbilityLayer {
         const matcherNameEnd = expect.matcherNameNode.getEnd();
         const matcherNodeEnd = expect.matcherNode.getEnd();
         switch (expect.matcherNameNode.name.text) {
+            case "toAcceptProps": {
+                this.#nodes.push(expect);
+                const sourceNode = expect.source[0];
+                const targetNode = expect.target?.[0];
+                if (!sourceNode ||
+                    !targetNode ||
+                    !(this.#compiler.isIdentifier(sourceNode) ||
+                        this.#compiler.isPropertyAccessExpression(sourceNode) ||
+                        this.#compiler.isTypeReferenceNode(sourceNode) ||
+                        this.#compiler.isExpressionWithTypeArguments(sourceNode)) ||
+                    !/^[A-Z_$]/.test(sourceNode.getText()[0]) ||
+                    !this.#compiler.isObjectLiteralExpression(targetNode) ||
+                    !targetNode.properties.every((property) => (this.#compiler.isPropertyAssignment(property) &&
+                        (this.#compiler.isIdentifier(property.name) || this.#compiler.isStringLiteral(property.name))) ||
+                        this.#compiler.isSpreadAssignment(property))) {
+                    return;
+                }
+                const sourceText = sourceNode.getText();
+                if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+                    this.#editor
+                        .eraseTrailingComma(expect.source)
+                        .erase(expectStart, matcherNodeEnd)
+                        .update(expectStart, matcherNameEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "")
+                        .update(sourceNode.getStart() - 1, sourceNode.getEnd(), `<${sourceText}`);
+                }
+                else {
+                    const id = ["SC", expectStart, Date.now().toString(36)].join("_");
+                    this.#editor
+                        .erase(expectStart, matcherNodeEnd)
+                        .update(expectStart, matcherNameEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                        ? `;const ${id} = undefined as any as ${sourceText};<${id}`
+                        : `const ${id} = undefined as any as ${sourceText};<${id}`);
+                }
+                for (const property of targetNode.properties) {
+                    if (this.#compiler.isPropertyAssignment(property)) {
+                        this.#editor
+                            .update(property.name.getStart(), property.name.getEnd(), this.#compiler.isStringLiteral(property.name)
+                            ? ` ${property.name.getText().slice(1, -1)} `
+                            : property.name.getText())
+                            .insert(property.initializer.getStart(), "={")
+                            .update(property.initializer.getStart(), property.initializer.getEnd(), property.initializer.getText())
+                            .insert(property.initializer.getEnd(), "}");
+                        continue;
+                    }
+                    if (this.#compiler.isSpreadAssignment(property)) {
+                        this.#editor
+                            .insert(property.getStart(), "{")
+                            .update(property.getStart(), property.getEnd(), property.getText())
+                            .insert(property.getEnd(), "}");
+                    }
+                }
+                this.#editor.insert(matcherNodeEnd, "/>");
+                break;
+            }
             case "toBeApplicable":
                 this.#nodes.push(expect);
-                this.#editor.replaceRanges([
-                    [expectStart, expectExpressionEnd],
-                    [expectEnd, matcherNameEnd],
-                ]);
+                this.#editor.erase(expectStart, expectExpressionEnd).erase(expectEnd, matcherNameEnd);
                 break;
             case "toBeCallableWith": {
                 this.#nodes.push(expect);
@@ -3376,27 +3489,16 @@ class AbilityLayer {
                     return;
                 }
                 if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
-                    this.#editor.eraseTrailingComma(expect.source);
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            expectExpressionEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
-                        ],
-                        [expectEnd, matcherNameEnd],
-                    ]);
+                    this.#editor
+                        .eraseTrailingComma(expect.source)
+                        .update(expectStart, expectExpressionEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "")
+                        .erase(expectEnd, matcherNameEnd);
                 }
                 else {
                     const sourceText = sourceNode.getFullText();
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            matcherNameEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
-                                ? `;(undefined as any as ${sourceText})`
-                                : `(undefined as any as ${sourceText})`,
-                        ],
-                    ]);
+                    this.#editor.update(expectStart, matcherNameEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                        ? `;(undefined as any as ${sourceText})`
+                        : `(undefined as any as ${sourceText})`);
                 }
                 break;
             }
@@ -3407,27 +3509,16 @@ class AbilityLayer {
                     return;
                 }
                 if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
-                    this.#editor.eraseTrailingComma(expect.source);
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            expectExpressionEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? "; new" : "new",
-                        ],
-                        [expectEnd, matcherNameEnd],
-                    ]);
+                    this.#editor
+                        .eraseTrailingComma(expect.source)
+                        .update(expectStart, expectExpressionEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? "; new" : "new")
+                        .erase(expectEnd, matcherNameEnd);
                 }
                 else {
                     const sourceText = sourceNode.getFullText();
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            matcherNameEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
-                                ? `;new (undefined as any as ${sourceText})`
-                                : `new (undefined as any as ${sourceText})`,
-                        ],
-                    ]);
+                    this.#editor.update(expectStart, matcherNameEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                        ? `;new (undefined as any as ${sourceText})`
+                        : `new (undefined as any as ${sourceText})`);
                 }
                 break;
             }
@@ -3439,39 +3530,26 @@ class AbilityLayer {
                     return;
                 }
                 if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
-                    this.#editor.eraseTrailingComma(expect.source);
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            expectExpressionEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "",
-                        ],
-                        [expectEnd, matcherNodeEnd],
-                    ]);
+                    this.#editor
+                        .eraseTrailingComma(expect.source)
+                        .update(expectStart, expectExpressionEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "")
+                        .erase(expectEnd, matcherNodeEnd);
                     if (this.#compiler.isExpressionWithTypeArguments(sourceNode)) {
-                        this.#editor.replaceRanges([[sourceNode.expression.getEnd(), sourceNode.getEnd()]]);
+                        this.#editor.erase(sourceNode.expression.getEnd(), sourceNode.getEnd());
                     }
                 }
                 else {
                     const sourceText = this.#compiler.isTypeReferenceNode(sourceNode)
-                        ? sourceNode.typeName.getText()
-                        : sourceNode.getText();
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            matcherNodeEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
-                                ? `;undefined as any as ${sourceText}`
-                                : `undefined as any as ${sourceText}`,
-                        ],
-                    ]);
+                        ? sourceNode.typeName.getFullText()
+                        : sourceNode.getFullText();
+                    this.#editor.update(expectStart, matcherNodeEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                        ? `;undefined as any as ${sourceText}`
+                        : `undefined as any as ${sourceText}`);
                 }
                 if (targetNode != null) {
                     const targetText = targetNode.getText().slice(1, -1);
-                    if (targetText.trim().length > 1) {
-                        this.#editor.replaceRanges([
-                            [targetNode.getFullStart(), targetNode.getEnd(), `<${targetText}>`.padStart(targetNode.getFullWidth())],
-                        ]);
+                    if (targetText.trim().length > 0) {
+                        this.#editor.update(targetNode.getFullStart(), targetNode.getEnd(), `<${targetText}>`.padStart(targetNode.getFullWidth()));
                     }
                 }
                 break;
@@ -3483,30 +3561,21 @@ class AbilityLayer {
                 if (!sourceNode || !targetNode) {
                     return;
                 }
-                const sourceText = sourceNode.getFullText();
-                const targetText = targetNode.getFullText();
                 if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
-                    this.#editor.eraseTrailingComma(expect.source);
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            matcherNodeEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
-                                ? `;(${sourceText})[${targetText}]`
-                                : `(${sourceText})[${targetText}]`,
-                        ],
-                    ]);
+                    this.#editor
+                        .eraseTrailingComma(expect.source)
+                        .update(expectStart, expectExpressionEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode) ? ";" : "")
+                        .erase(expectEnd, matcherNodeEnd);
                 }
                 else {
-                    this.#editor.replaceRanges([
-                        [
-                            expectStart,
-                            matcherNodeEnd,
-                            nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
-                                ? `;(undefined as any as ${sourceText})[${targetText}]`
-                                : `(undefined as any as ${sourceText})[${targetText}]`,
-                        ],
-                    ]);
+                    const sourceText = sourceNode.getFullText();
+                    this.#editor.update(expectStart, matcherNodeEnd, nodeIsChildOfExpressionStatement(this.#compiler, expect.matcherNode)
+                        ? `;(undefined as any as ${sourceText})`
+                        : `(undefined as any as ${sourceText})`);
+                }
+                const targetText = targetNode.getText();
+                if (targetText.trim().length > 0) {
+                    this.#editor.update(targetNode.getFullStart() - 1, targetNode.getEnd() + 1, `[${targetText}]`.padStart(targetNode.getFullWidth()));
                 }
                 break;
             }
@@ -3514,65 +3583,6 @@ class AbilityLayer {
     }
 }
 
-class SourceTextEditor {
-    #filePath = "";
-    #sourceFile;
-    #text = "";
-    open(sourceFile) {
-        this.#sourceFile = sourceFile;
-        this.#filePath = sourceFile.fileName;
-        this.#text = sourceFile.text;
-    }
-    close() {
-        if (this.#sourceFile != null) {
-            SourceService.set(this.#sourceFile);
-            this.#sourceFile = undefined;
-        }
-        this.#filePath = "";
-        this.#text = "";
-    }
-    eraseTrailingComma(node) {
-        if (node.hasTrailingComma) {
-            this.replaceRange(node.end - 1, node.end);
-        }
-    }
-    #getErasedRange(start, end) {
-        if (this.#text.indexOf("\n", start) >= end) {
-            return " ".repeat(end - start);
-        }
-        const text = [];
-        for (let index = start; index < end; index++) {
-            const character = this.#text.charAt(index);
-            switch (character) {
-                case "\n":
-                case "\r":
-                    text.push(character);
-                    break;
-                default:
-                    text.push(" ");
-            }
-        }
-        return text.join("");
-    }
-    getFilePath() {
-        return this.#filePath;
-    }
-    getText() {
-        return this.#text;
-    }
-    replaceRange(start, end, replacement) {
-        const rangeText = replacement != null
-            ? `${replacement}${this.#getErasedRange(start, end).slice(replacement.length)}`
-            : this.#getErasedRange(start, end);
-        this.#text = `${this.#text.slice(0, start)}${rangeText}${this.#text.slice(end)}`;
-    }
-    replaceRanges(ranges) {
-        for (const [start, end, replacement] of ranges) {
-            this.replaceRange(start, end, replacement);
-        }
-    }
-}
-
 class SuppressedLayer {
     #compiler;
     #editor;
@@ -3645,7 +3655,7 @@ class SuppressedLayer {
         }
         for (const suppressedError of suppressedErrors) {
             const { start, end } = suppressedError.directive;
-            this.#editor.replaceRange(start + 2, end);
+            this.#editor.erase(start, end);
             if (this.#suppressedErrorsMap != null) {
                 const { line } = tree.sourceFile.getLineAndCharacterOfPosition(start);
                 this.#suppressedErrorsMap.set(line, suppressedError);
@@ -3654,9 +3664,88 @@ class SuppressedLayer {
     }
 }
 
+class TextEditor {
+    #filePath = "";
+    #offset = 0;
+    #offsets = [];
+    #text = "";
+    open(sourceFile) {
+        this.#filePath = sourceFile.fileName;
+        this.#text = sourceFile.text;
+        this.#offset = 0;
+        this.#offsets = [];
+    }
+    close() {
+        this.#filePath = "";
+        this.#text = "";
+        this.#offset = 0;
+        this.#offsets = [];
+    }
+    erase(start, end) {
+        this.#text =
+            this.#text.slice(0, start + this.#offset) +
+                this.#getErased(start + this.#offset, end + this.#offset) +
+                this.#text.slice(end + this.#offset);
+        return this;
+    }
+    eraseTrailingComma(node) {
+        if (node.hasTrailingComma) {
+            this.erase(node.end - 1, node.end);
+        }
+        return this;
+    }
+    insert(position, text) {
+        this.update(position, position, text);
+        return this;
+    }
+    #getErased(start, end) {
+        if (this.#text.indexOf("\n", start) >= end) {
+            return " ".repeat(end - start);
+        }
+        const text = [];
+        for (let index = start; index < end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
+                case "\n":
+                case "\r":
+                    text.push(character);
+                    break;
+                default:
+                    text.push(" ");
+            }
+        }
+        return text.join("");
+    }
+    getFilePath() {
+        return this.#filePath;
+    }
+    getOffsets() {
+        return this.#offsets;
+    }
+    getText() {
+        return this.#text;
+    }
+    #setOffset(start, end, text) {
+        const diff = text.length - (end - start);
+        if (diff > 0) {
+            this.#offset += diff;
+            this.#offsets.push({ position: end, diff });
+        }
+    }
+    update(start, end, text) {
+        this.#text =
+            this.#text.slice(0, start + this.#offset) +
+                text +
+                this.#getErased(start + this.#offset, end + this.#offset).slice(text.length) +
+                this.#text.slice(end + this.#offset);
+        this.#setOffset(start, end, text);
+        return this;
+    }
+}
+
 class Layers {
     #abilityLayer;
-    #editor = new SourceTextEditor();
+    #editor = new TextEditor();
     #projectService;
     #suppressedDiagnostics;
     #suppressedLayer;
@@ -3665,14 +3754,23 @@ class Layers {
         this.#abilityLayer = new AbilityLayer(compiler, this.#editor);
         this.#suppressedLayer = new SuppressedLayer(compiler, this.#editor, resolvedConfig);
     }
-    close() {
-        let isSeenDiagnostic;
+    close(tree) {
+        let seenDiagnostics = [];
         if (this.#suppressedDiagnostics != null) {
-            const seenDiagnostics = this.#suppressedDiagnostics;
+            seenDiagnostics = this.#suppressedDiagnostics;
             this.#suppressedDiagnostics = undefined;
-            isSeenDiagnostic = (diagnostic) => !seenDiagnostics.some((seenDiagnostic) => compareDiagnostics(diagnostic, seenDiagnostic));
         }
-        const abilityDiagnostics = this.#projectService.getDiagnostics(this.#editor.getFilePath(), this.#editor.getText(), isSeenDiagnostic);
+        const diagnostics = this.#projectService.getDiagnostics(this.#editor.getFilePath(), this.#editor.getText());
+        const offsets = this.#editor.getOffsets();
+        const abilityDiagnostics = [];
+        if (diagnostics != null) {
+            for (const diagnostic of diagnostics) {
+                const mappedDiagnostic = new MappedDiagnostic(tree.sourceFile, diagnostic, offsets);
+                if (!seenDiagnostics.some((seenDiagnostic) => compareDiagnostics(mappedDiagnostic, seenDiagnostic))) {
+                    abilityDiagnostics.push(mappedDiagnostic);
+                }
+            }
+        }
         this.#abilityLayer.close(abilityDiagnostics);
         this.#editor.close();
     }
@@ -3680,7 +3778,7 @@ class Layers {
         this.#editor.open(tree.sourceFile);
         this.#suppressedLayer.open(tree);
         this.#suppressedDiagnostics = this.#projectService.getDiagnostics(this.#editor.getFilePath(), this.#editor.getText());
-        this.#suppressedLayer.close(this.#suppressedDiagnostics);
+        this.#suppressedLayer.close(this.#suppressedDiagnostics?.map((diagnostic) => new MappedDiagnostic(tree.sourceFile, diagnostic)));
     }
     visit(node) {
         this.#abilityLayer.visitExpect(node);
@@ -3927,7 +4025,7 @@ class CollectService {
         this.#layers.open(testTree);
         this.#identifierLookup.open();
         this.#collectTestTreeNodes(sourceFile, testTree, testTree);
-        this.#layers.close();
+        this.#layers.close(testTree);
         EventEmitter.dispatch(["collect:end", { tree: testTree }]);
         return testTree;
     }
@@ -4061,7 +4159,6 @@ class ProjectService {
     }
     closeFile(filePath) {
         this.#service.closeClientFile(filePath);
-        SourceService.delete(filePath);
     }
     #getDefaultCompilerOptions() {
         const defaultCompilerOptions = {
@@ -4091,14 +4188,10 @@ class ProjectService {
         }
         return project;
     }
-    getDiagnostics(filePath, sourceText, shouldInclude) {
+    getDiagnostics(filePath, sourceText) {
         this.openFile(filePath, sourceText);
         const languageService = this.getLanguageService(filePath);
-        const diagnostics = languageService?.getSemanticDiagnostics(filePath);
-        if (diagnostics != null && shouldInclude != null) {
-            return diagnostics.filter(shouldInclude);
-        }
-        return diagnostics;
+        return languageService?.getSemanticDiagnostics(filePath);
     }
     getLanguageService(filePath) {
         const project = this.getDefaultProject(filePath);
@@ -4263,63 +4356,131 @@ class SuppressedService {
     }
 }
 
-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.`;
-    }
-    static typeArgumentMustBeProvided(typeArgumentNameText) {
-        return `Type argument for '${typeArgumentNameText}' must be provided.`;
-    }
+function capitalize(text) {
+    return text.replace(/^./, text.charAt(0).toUpperCase());
 }
 
-function argumentIsProvided(compiler, argumentNameText, node, enclosingNode, onDiagnostics) {
-    if (!node || !nodeBelongsToArgumentList(compiler, node)) {
-        const text = EnsureDiagnosticText.argumentMustBeProvided(argumentNameText);
-        const origin = DiagnosticOrigin.fromNode(enclosingNode);
-        onDiagnostics([Diagnostic.error(text, origin)]);
-        return false;
+class RejectDiagnosticText {
+    static argumentCannotBeOfType(typeText) {
+        return `The argument cannot be of the '${typeText}' type.`;
     }
-    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;
+    static typeArgumentCannotBeOfType(typeText) {
+        return `The type argument cannot be of the '${typeText}' type.`;
     }
-    return true;
-}
-
-function typeArgumentIsProvided(compiler, typeArgumentNameText, node, enclosingNode, onDiagnostics) {
-    if (!node || nodeBelongsToArgumentList(compiler, node)) {
-        const text = EnsureDiagnosticText.typeArgumentMustBeProvided(typeArgumentNameText);
-        const origin = DiagnosticOrigin.fromNode(enclosingNode);
-        onDiagnostics([Diagnostic.error(text, origin)]);
-        return false;
+    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.`,
+        ];
     }
-    return true;
 }
 
-class ExpectDiagnosticText {
-    static argumentMustBe(argumentNameText, expectedText) {
-        return `An argument for '${argumentNameText}' must be ${expectedText}.`;
-    }
-    static typeArgumentMustBe(expectedText) {
-        return `The type argument 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}.`;
+class Reject {
+    #compiler;
+    #rejectedArgumentTypes = new Set();
+    #typeChecker;
+    constructor(compiler, program, resolvedConfig) {
+        this.#compiler = compiler;
+        this.#typeChecker = program.getTypeChecker();
+        if (resolvedConfig.rejectAnyType) {
+            this.#rejectedArgumentTypes.add("any");
+        }
+        if (resolvedConfig.rejectNeverType) {
+            this.#rejectedArgumentTypes.add("never");
+        }
+    }
+    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 node of target) {
+                if (!node) {
+                    continue;
+                }
+                if (this.#typeChecker.getTypeAtLocation(node).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
+                    const text = [
+                        nodeBelongsToArgumentList(this.#compiler, node)
+                            ? RejectDiagnosticText.argumentCannotBeOfType(rejectedType)
+                            : RejectDiagnosticText.typeArgumentCannotBeOfType(rejectedType),
+                        ...RejectDiagnosticText.typeWasRejected(rejectedType),
+                    ];
+                    const origin = DiagnosticOrigin.fromNode(node);
+                    onDiagnostics([Diagnostic.error(text, origin)]);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+class Ensure {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
+    }
+    argument(node, enclosingNode, onDiagnostics) {
+        if (!node || !nodeBelongsToArgumentList(this.#compiler, node)) {
+            this.#emitDiagnostic("An argument must be provided.", enclosingNode, onDiagnostics);
+            return false;
+        }
+        return true;
+    }
+    argumentOrTypeArgument(node, enclosingNode, onDiagnostics) {
+        if (!node) {
+            this.#emitDiagnostic("An argument or type argument must be provided.", enclosingNode, onDiagnostics);
+            return false;
+        }
+        return true;
+    }
+    jsxSetup(program, node, onDiagnostics) {
+        const diagnosticText = [];
+        if (!program.getCompilerOptions().jsx) {
+            diagnosticText.push("The matcher requires the 'jsx' compiler option to be configured.");
+        }
+        if (node.getSourceFile().languageVariant !== this.#compiler.LanguageVariant.JSX) {
+            diagnosticText.push("The matcher requires a '.tsx' file extension.");
+        }
+        if (diagnosticText.length > 0) {
+            this.#emitDiagnostic(diagnosticText, node, onDiagnostics);
+            return false;
+        }
+        return true;
+    }
+    typeArgument(node, enclosingNode, onDiagnostics) {
+        if (!node || nodeBelongsToArgumentList(this.#compiler, node)) {
+            this.#emitDiagnostic("A type argument must be provided.", enclosingNode, onDiagnostics);
+            return false;
+        }
+        return true;
+    }
+    #emitDiagnostic(text, enclosingNode, onDiagnostics) {
+        if (!Array.isArray(text)) {
+            text = [text];
+        }
+        const origin = DiagnosticOrigin.fromNode(enclosingNode);
+        onDiagnostics(text.map((text) => Diagnostic.error(text, origin)));
+    }
+}
+
+class ExpectDiagnosticText {
+    static argumentMustBe(expectedText) {
+        return `The argument must be ${expectedText}.`;
+    }
+    static typeArgumentMustBe(expectedText) {
+        return `The type argument 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}.`;
@@ -4331,10 +4492,10 @@ class ExpectDiagnosticText {
         return `${isExpression ? "Expression" : "Type"} is not instantiable ${targetText}.`;
     }
     static acceptsProps(isExpression) {
-        return `${isExpression ? "Component" : "Component type"} accepts props of the given type.`;
+        return `${isExpression ? "Component" : "Type"} accepts props of the given type.`;
     }
     static doesNotAcceptProps(isExpression) {
-        return `${isExpression ? "Component" : "Component type"} does not accept props of the given type.`;
+        return `${isExpression ? "Component" : "Type"} does not accept props of the given type.`;
     }
     static canBeApplied(targetText) {
         return `The decorator function can be applied${targetText}.`;
@@ -4354,9 +4515,6 @@ class ExpectDiagnosticText {
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
-    static overloadGaveTheFollowingError(index, count, signatureText) {
-        return `Overload ${index} of ${count}, '${signatureText}', gave the following error.`;
-    }
     static raisedTypeError(count = 1) {
         return `The raised type error${count === 1 ? "" : "s"}:`;
     }
@@ -4394,21 +4552,11 @@ class ExpectDiagnosticText {
     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}'.`;
-    }
-    static requiresProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' requires property '${propertyNameText}'.`;
-    }
-    static typesOfPropertyAreNotCompatible(propertyNameText) {
-        return `Types of property '${propertyNameText}' are not compatible.`;
-    }
 }
 
 class MatchWorker {
     assertionNode;
     #compiler;
-    #signatureCache = new Map();
     typeChecker;
     constructor(compiler, program, assertionNode) {
         this.#compiler = compiler;
@@ -4432,219 +4580,118 @@ class MatchWorker {
             : { flags: this.#compiler.TypeFlags.NonPrimitive };
         return this.typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
     }
-    getParameterType(signature, index) {
-        const parameter = signature.getDeclaration().parameters[index];
-        if (!parameter) {
-            return;
-        }
-        return this.getType(parameter);
-    }
-    getSignatures(node) {
-        let signatures = this.#signatureCache.get(node);
-        if (!signatures) {
-            const type = this.getType(node);
-            signatures = type.getCallSignatures();
-            if (signatures.length === 0) {
-                signatures = type.getConstructSignatures();
-            }
-        }
-        return signatures;
-    }
     getTypeText(node) {
         return this.typeChecker.typeToString(this.getType(node));
     }
     getType(node) {
         return this.typeChecker.getTypeAtLocation(node);
     }
-    resolveDiagnosticOrigin(symbol, enclosingNode) {
-        if (symbol.valueDeclaration != null &&
-            (this.#compiler.isPropertySignature(symbol.valueDeclaration) ||
-                this.#compiler.isPropertyAssignment(symbol.valueDeclaration) ||
-                this.#compiler.isShorthandPropertyAssignment(symbol.valueDeclaration)) &&
-            symbol.valueDeclaration.getStart() >= enclosingNode.getStart() &&
-            symbol.valueDeclaration.getEnd() <= enclosingNode.getEnd()) {
-            return DiagnosticOrigin.fromNode(symbol.valueDeclaration.name, this.assertionNode);
-        }
-        return DiagnosticOrigin.fromNode(enclosingNode, this.assertionNode);
-    }
 }
 
-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;
-    constructor(compiler, program) {
-        this.#compiler = compiler;
-        this.#typeChecker = program.getTypeChecker();
-    }
-    #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.assertionNode.isNot
-                ? ExpectDiagnosticText.acceptsProps(isExpression)
-                : ExpectDiagnosticText.doesNotAcceptProps(isExpression);
-            const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertionNode);
-            if (signatures.length > 1) {
-                const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
-                const overloadText = ExpectDiagnosticText.overloadGaveTheFollowingError(index + 1, signatures.length, signatureText);
-                diagnostic = Diagnostic.error([introText, overloadText], origin);
-            }
-            else {
-                diagnostic = Diagnostic.error([introText], origin);
-            }
-            const { diagnostics, isMatch } = this.#explainProperties(matchWorker, signature, targetNode, diagnostic);
-            if (matchWorker.assertionNode.isNot ? isMatch : !isMatch) {
-                accumulator.push(...diagnostics);
-            }
-            return accumulator;
-        }, []);
+class AbilityMatcherBase {
+    compiler;
+    constructor(compiler) {
+        this.compiler = compiler;
     }
-    #isOptionalProperty(symbol) {
-        return symbol.declarations?.every((declaration) => this.#compiler.isPropertySignature(declaration) && declaration.questionToken != null);
+    getArgumentCountText(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"}`;
     }
-    #checkProperties(sourceType, targetType) {
-        const check = (sourceType, targetType) => {
-            for (const targetProperty of targetType.getProperties()) {
-                const targetPropertyName = targetProperty.getName();
-                const sourceProperty = sourceType?.getProperty(targetPropertyName);
-                if (!sourceProperty) {
-                    return false;
-                }
-                const targetPropertyType = this.#typeChecker.getTypeOfSymbol(targetProperty);
-                const sourcePropertyType = this.#typeChecker.getTypeOfSymbol(sourceProperty);
-                if (!this.#typeChecker.isTypeAssignableTo(targetPropertyType, sourcePropertyType)) {
-                    return false;
-                }
-            }
-            if (sourceType != null) {
-                const sourceProperties = sourceType.getProperties();
-                for (const sourceProperty of sourceProperties) {
-                    const targetProperty = targetType.getProperty(sourceProperty.getName());
-                    if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
-            return sourceType.types.some((sourceType) => check(sourceType, targetType));
+    getTypeArgumentCountText(targetNode) {
+        if (targetNode.elements.length === 0) {
+            return "without type arguments";
         }
-        return check(sourceType, targetType);
+        return `with the given type argument${targetNode.elements.length === 1 ? "" : "s"}`;
     }
-    #explainProperties(matchWorker, signature, targetNode, diagnostic) {
-        const sourceType = matchWorker.getParameterType(signature, 0);
-        const sourceTypeText = sourceType != null ? this.#typeChecker.typeToString(sourceType) : "{}";
-        const targetType = matchWorker.getType(targetNode);
-        const targetTypeText = this.#typeChecker.typeToString(targetType);
-        const explain = (sourceType, targetType, diagnostic) => {
-            const sourceTypeText = sourceType != null ? this.#typeChecker.typeToString(sourceType) : "{}";
-            const diagnostics = [];
-            for (const targetProperty of targetType.getProperties()) {
-                const targetPropertyName = targetProperty.getName();
-                const sourceProperty = sourceType?.getProperty(targetPropertyName);
-                if (!sourceProperty) {
-                    const text = [
-                        ExpectDiagnosticText.isNotCompatibleWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, targetPropertyName),
-                    ];
-                    const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
-                    diagnostics.push(diagnostic.extendWith(text, origin));
-                    continue;
+    explain(matchWorker, sourceNode, targetNode, getArgumentCountText) {
+        const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
+        const argumentCountText = getArgumentCountText?.();
+        const diagnostics = [];
+        if (matchWorker.assertionNode.abilityDiagnostics.size > 0) {
+            for (const diagnostic of matchWorker.assertionNode.abilityDiagnostics) {
+                const text = [this.explainNotText(isExpression, argumentCountText), getDiagnosticMessageText(diagnostic)];
+                let origin;
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNode)) {
+                    origin = DiagnosticOrigin.fromAbilityDiagnostic(diagnostic, matchWorker.assertionNode);
                 }
-                const targetPropertyType = this.#typeChecker.getTypeOfSymbol(targetProperty);
-                const sourcePropertyType = this.#typeChecker.getTypeOfSymbol(sourceProperty);
-                if (!this.#typeChecker.isTypeAssignableTo(targetPropertyType, sourcePropertyType)) {
-                    const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
-                    const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
-                    const text = [
-                        ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
-                        ExpectDiagnosticText.isNotAssignableFrom(sourcePropertyTypeText, targetPropertyTypeText),
-                    ];
-                    const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
-                    diagnostics.push(diagnostic.extendWith(text, origin));
+                else {
+                    origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
                 }
-            }
-            if (sourceType != null) {
-                for (const sourceProperty of sourceType.getProperties()) {
-                    const sourcePropertyName = sourceProperty.getName();
-                    const targetProperty = targetType.getProperty(sourcePropertyName);
-                    if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
-                        const text = [
-                            ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText),
-                            ExpectDiagnosticText.requiresProperty(sourceTypeText, sourcePropertyName),
-                        ];
-                        diagnostics.push(diagnostic.extendWith(text));
-                    }
+                let related;
+                if (diagnostic.relatedInformation != null) {
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
                 }
+                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
             }
-            if (diagnostics.length === 0) {
-                const text = ExpectDiagnosticText.isAssignableFrom(sourceTypeText, targetTypeText);
-                diagnostics.push(diagnostic.extendWith(text));
-                return { diagnostics, isMatch: true };
-            }
-            return { diagnostics, isMatch: false };
-        };
-        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
-            let accumulator = [];
-            const isMatch = sourceType.types.some((sourceType) => {
-                const text = matchWorker.assertionNode.isNot
-                    ? ExpectDiagnosticText.isAssignableFrom(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.isNotAssignableFrom(sourceTypeText, targetTypeText);
-                const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
-                if (isMatch) {
-                    accumulator = diagnostics;
-                }
-                else {
-                    accumulator.push(...diagnostics);
-                }
-                return isMatch;
-            });
-            return { diagnostics: accumulator, isMatch };
         }
-        return explain(sourceType, targetType, diagnostic);
+        else {
+            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
+            diagnostics.push(Diagnostic.error(this.explainText(isExpression, argumentCountText), origin));
+        }
+        return diagnostics;
     }
+}
+
+class ToAcceptProps extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.acceptsProps;
+    explainNotText = ExpectDiagnosticText.doesNotAcceptProps;
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
-        const signatures = matchWorker.getSignatures(sourceNode);
-        if (signatures.length === 0) {
-            const expectedText = "of a function or class type";
-            const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
-                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+        const sourceType = matchWorker.getType(sourceNode);
+        if (!(this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode) ||
+            this.compiler.isTypeReferenceNode(sourceNode) ||
+            this.compiler.isExpressionWithTypeArguments(sourceNode)) ||
+            !(sourceType.getCallSignatures().length > 0 || sourceType.getConstructSignatures().length > 0)) {
+            const expectedText = "an identifier of a JSX component";
+            const text = nodeBelongsToArgumentList(this.compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe(expectedText)
                 : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
-        const targetType = matchWorker.getType(targetNode);
-        if (!(targetType.flags & this.#compiler.TypeFlags.Object)) {
-            const expectedText = "of an object type";
-            const text = ExpectDiagnosticText.argumentMustBe("props", expectedText);
+        else if (!/^[A-Z_$]/.test(sourceNode.getText()[0])) {
+            const expectedText = "an identifier that begins with an uppercase letter";
+            const text = nodeBelongsToArgumentList(this.compiler, sourceNode)
+                ? ExpectDiagnosticText.argumentMustBe(expectedText)
+                : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            diagnostics.push(Diagnostic.error(text, origin));
+        }
+        if (!this.compiler.isObjectLiteralExpression(targetNode)) {
+            const expectedText = "an object literal with key-value pairs";
+            const text = ExpectDiagnosticText.argumentMustBe(expectedText);
             const origin = DiagnosticOrigin.fromNode(targetNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
+        else {
+            for (const property of targetNode.properties) {
+                if (!(this.compiler.isPropertyAssignment(property) || this.compiler.isSpreadAssignment(property))) {
+                    const text = "Each property must be a key-value pair or a spread element.";
+                    const origin = DiagnosticOrigin.fromNode(property);
+                    diagnostics.push(Diagnostic.error(text, origin));
+                    continue;
+                }
+                if (this.compiler.isPropertyAssignment(property) &&
+                    !(this.compiler.isIdentifier(property.name) || this.compiler.isStringLiteral(property.name))) {
+                    const text = "Property keys must be static identifiers or string literals.";
+                    const origin = DiagnosticOrigin.fromNode(property.name);
+                    diagnostics.push(Diagnostic.error(text, origin));
+                }
+            }
+        }
         if (diagnostics.length > 0) {
             onDiagnostics(diagnostics);
             return;
         }
-        const isMatch = signatures.some((signature) => {
-            const sourceType = matchWorker.getParameterType(signature, 0);
-            return this.#checkProperties(sourceType, targetType);
-        });
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNode),
-            isMatch,
+            explain: () => this.explain(matchWorker, sourceNode, targetNode),
+            isMatch: matchWorker.assertionNode.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -5245,7 +5292,7 @@ class ToBeApplicable {
         if (type.getCallSignatures().length === 0) {
             const expectedText = "of a function type";
             const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
-                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                ? ExpectDiagnosticText.argumentMustBe(expectedText)
                 : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             onDiagnostics([Diagnostic.error(text, origin)]);
@@ -5280,55 +5327,6 @@ class ToBeAssignableTo extends RelationMatcherBase {
     }
 }
 
-class AbilityMatcherBase {
-    compiler;
-    constructor(compiler) {
-        this.compiler = compiler;
-    }
-    getArgumentCountText(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"}`;
-    }
-    getTypeArgumentCountText(targetNode) {
-        if (targetNode.elements.length === 0) {
-            return "without type arguments";
-        }
-        return `with the given type argument${targetNode.elements.length === 1 ? "" : "s"}`;
-    }
-    explain(matchWorker, sourceNode, targetNode, getArgumentCountText) {
-        const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
-        const argumentCountText = getArgumentCountText();
-        const diagnostics = [];
-        if (matchWorker.assertionNode.abilityDiagnostics.size > 0) {
-            for (const diagnostic of matchWorker.assertionNode.abilityDiagnostics) {
-                const text = [this.explainNotText(isExpression, argumentCountText), getDiagnosticMessageText(diagnostic)];
-                let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNode)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertionNode);
-                }
-                else {
-                    origin = DiagnosticOrigin.fromAssertion(matchWorker.assertionNode);
-                }
-                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.assertionNode);
-            diagnostics.push(Diagnostic.error(this.explainText(isExpression, argumentCountText), origin));
-        }
-        return diagnostics;
-    }
-}
-
 class ToBeCallableWith extends AbilityMatcherBase {
     explainText = ExpectDiagnosticText.isCallable;
     explainNotText = ExpectDiagnosticText.isNotCallable;
@@ -5337,7 +5335,7 @@ class ToBeCallableWith extends AbilityMatcherBase {
         if (sourceType.getCallSignatures().length === 0) {
             const text = [];
             if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
-                text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
+                text.push(ExpectDiagnosticText.argumentMustBe("a callable expression"));
             }
             else {
                 text.push(ExpectDiagnosticText.typeArgumentMustBe("a callable type"));
@@ -5364,7 +5362,7 @@ class ToBeConstructableWith extends AbilityMatcherBase {
         if (sourceType.getConstructSignatures().length === 0) {
             const text = [];
             if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
-                text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
+                text.push(ExpectDiagnosticText.argumentMustBe("a constructable expression"));
             }
             else {
                 text.push(ExpectDiagnosticText.typeArgumentMustBe("a constructable type"));
@@ -5393,7 +5391,7 @@ class ToBeInstantiableWith extends AbilityMatcherBase {
             this.compiler.isExpressionWithTypeArguments(sourceNode))) {
             let text;
             if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
-                text = ExpectDiagnosticText.argumentMustBe("source", "an instantiable expression");
+                text = ExpectDiagnosticText.argumentMustBe("an instantiable expression");
             }
             else {
                 text = ExpectDiagnosticText.typeArgumentMustBe("an instantiable type");
@@ -5424,7 +5422,7 @@ class ToHaveProperty {
         const sourceTypeText = matchWorker.getTypeText(sourceNode);
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText;
-        if (isStringOrNumberLiteralType(this.#compiler, targetType)) {
+        if (targetType.flags & (this.#compiler.TypeFlags.StringLiteral | this.#compiler.TypeFlags.NumberLiteral)) {
             propertyNameText = targetType.value.toString();
         }
         else {
@@ -5442,15 +5440,18 @@ class ToHaveProperty {
             !matchWorker.extendsObjectType(sourceType)) {
             const expectedText = "of an object type";
             const text = nodeBelongsToArgumentList(this.#compiler, sourceNode)
-                ? ExpectDiagnosticText.argumentMustBe("source", expectedText)
+                ? ExpectDiagnosticText.argumentMustBe(expectedText)
                 : ExpectDiagnosticText.typeArgumentMustBe(expectedText);
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
         const targetType = matchWorker.getType(targetNode);
-        if (!(isStringOrNumberLiteralType(this.#compiler, targetType) || isUniqueSymbolType(this.#compiler, targetType))) {
-            const expectedText = "of type 'string | number | symbol'";
-            const text = ExpectDiagnosticText.argumentMustBe("key", expectedText);
+        if (!(targetType.flags &
+            (this.#compiler.TypeFlags.StringLiteral |
+                this.#compiler.TypeFlags.NumberLiteral |
+                this.#compiler.TypeFlags.UniqueESSymbol))) {
+            const expectedText = "a string, number or symbol";
+            const text = ExpectDiagnosticText.argumentMustBe(expectedText);
             const origin = DiagnosticOrigin.fromNode(targetNode);
             diagnostics.push(Diagnostic.error(text, origin));
         }
@@ -5509,8 +5510,8 @@ class ToRaiseError {
             if (!(this.#compiler.isStringLiteralLike(targetNode) ||
                 this.#compiler.isNumericLiteral(targetNode) ||
                 this.#compiler.isRegularExpressionLiteral(targetNode))) {
-                const expectedText = "a string, number or regular expression literal";
-                const text = ExpectDiagnosticText.argumentMustBe("target", expectedText);
+                const expectedText = "a string, number or regular expression";
+                const text = ExpectDiagnosticText.argumentMustBe(expectedText);
                 const origin = DiagnosticOrigin.fromNode(targetNode);
                 diagnostics.push(Diagnostic.error(text, origin));
             }
@@ -5551,6 +5552,7 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
+    #ensure;
     #program;
     #reject;
     toAcceptProps;
@@ -5563,11 +5565,12 @@ class ExpectService {
     toBeInstantiableWith;
     toHaveProperty;
     toRaiseError;
-    constructor(compiler, program, reject) {
+    constructor(compiler, program, resolvedConfig) {
         this.#compiler = compiler;
         this.#program = program;
-        this.#reject = reject;
-        this.toAcceptProps = new ToAcceptProps(compiler, program);
+        this.#ensure = new Ensure(compiler);
+        this.#reject = new Reject(compiler, program, resolvedConfig);
+        this.toAcceptProps = new ToAcceptProps(compiler);
         this.toBe = new ToBe(compiler, program);
         this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableFrom = new ToBeAssignableFrom();
@@ -5580,23 +5583,24 @@ class ExpectService {
     }
     match(assertionNode, onDiagnostics) {
         const matcherNameText = assertionNode.matcherNameNode.name.text;
-        if (!argumentOrTypeArgumentIsProvided("source", "Source", assertionNode.source[0], assertionNode.node.expression, onDiagnostics)) {
+        if (matcherNameText === "toAcceptProps" &&
+            !this.#ensure.jsxSetup(this.#program, assertionNode.matcherNameNode.name, onDiagnostics)) {
+            return;
+        }
+        if (!this.#ensure.argumentOrTypeArgument(assertionNode.source[0], assertionNode.node.expression, onDiagnostics)) {
             return;
         }
-        const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
         if (!(matcherNameText === "toBeInstantiableWith" || (matcherNameText === "toRaiseError" && !assertionNode.isNot)) &&
-            this.#reject.argumentType([
-                ["source", assertionNode.source[0]],
-                ["target", assertionNode.target?.[0]],
-            ], onDiagnostics)) {
+            this.#reject.argumentType([assertionNode.source[0], assertionNode.target?.[0]], onDiagnostics)) {
             return;
         }
+        const matchWorker = new MatchWorker(this.#compiler, this.#program, assertionNode);
         switch (matcherNameText) {
             case "toAcceptProps":
             case "toBe":
             case "toBeAssignableFrom":
             case "toBeAssignableTo":
-                if (!argumentOrTypeArgumentIsProvided("target", "Target", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
+                if (!this.#ensure.argumentOrTypeArgument(assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this[matcherNameText].match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
@@ -5607,13 +5611,13 @@ class ExpectService {
             case "toRaiseError":
                 return this[matcherNameText].match(matchWorker, assertionNode.source[0], assertionNode.target, onDiagnostics);
             case "toBeInstantiableWith": {
-                if (!typeArgumentIsProvided(this.#compiler, "Target", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
+                if (!this.#ensure.typeArgument(assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this.toBeInstantiableWith.match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
             }
             case "toHaveProperty":
-                if (!argumentIsProvided(this.#compiler, "key", assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
+                if (!this.#ensure.argument(assertionNode.target?.[0], assertionNode.matcherNameNode.name, onDiagnostics)) {
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertionNode.source[0], assertionNode.target[0], onDiagnostics);
@@ -5629,67 +5633,6 @@ class ExpectService {
     }
 }
 
-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.`;
-    }
-    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
-        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
-    }
-    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, program, resolvedConfig) {
-        this.#compiler = compiler;
-        this.#typeChecker = program.getTypeChecker();
-        if (resolvedConfig.rejectAnyType) {
-            this.#rejectedArgumentTypes.add("any");
-        }
-        if (resolvedConfig.rejectNeverType) {
-            this.#rejectedArgumentTypes.add("never");
-        }
-    }
-    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 [name, node] of target) {
-                if (!node) {
-                    continue;
-                }
-                if (this.#typeChecker.getTypeAtLocation(node).flags & this.#compiler.TypeFlags[capitalize(rejectedType)]) {
-                    const text = [
-                        nodeBelongsToArgumentList(this.#compiler, node)
-                            ? RejectDiagnosticText.argumentCannotBeOfType(name, rejectedType)
-                            : RejectDiagnosticText.typeArgumentCannotBeOfType(capitalize(name), rejectedType),
-                        ...RejectDiagnosticText.typeWasRejected(rejectedType),
-                    ];
-                    const origin = DiagnosticOrigin.fromNode(node);
-                    onDiagnostics([Diagnostic.error(text, origin)]);
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-}
-
 class FixmeDiagnosticText {
     static considerRemoving() {
         return "Consider removing the '// @tstyche fixme' directive.";
@@ -5763,8 +5706,7 @@ class TestTreeWalker {
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
-        const reject = new Reject(compiler, program, resolvedConfig);
-        this.#expectService = new ExpectService(compiler, program, reject);
+        this.#expectService = new ExpectService(compiler, program, resolvedConfig);
     }
     async #resolveRunMode(flags, node) {
         const ifDirective = Directive.getDirectiveRange(this.#compiler, node, "if");
@@ -5998,7 +5940,7 @@ class FileRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "7.1.0";
+    static version = "7.2.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -6223,4 +6165,4 @@ class Cli {
     }
 }
 
-export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, DotReporter, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectConfigKind, ProjectResult, Result, ResultStatus, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, Store, StreamController, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, dotText, environmentOptions, fileStatusText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesText, waitingForFileChangesText, watchUsageText };
+export { BaseReporter, CancellationReason, CancellationToken, Cli, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, DotReporter, EventEmitter, ExpectResult, FileLocation, FileResult, Line, ListReporter, MappedDiagnostic, OptionBrand, OptionGroup, Options, OutputService, Path, ProjectConfigKind, ProjectResult, Result, ResultStatus, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, Store, StreamController, SummaryReporter, SuppressedResult, TargetResult, TestResult, Text, Version, WatchReporter, addsText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, dotText, environmentOptions, fileStatusText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, prologueText, summaryText, testNameText, usesText, waitingForFileChangesText, watchUsageText };