tstyche 4.0.1 → 4.1.0

package/README.md

@@ -70,8 +70,7 @@ Here is the list of all matchers:
 - `.toBeApplicable` ensures that the decorator function can be applied,
 - `.toBeCallableWith()` checks whether a function is callable with the given arguments,
 - `.toBeConstructableWith()` checks whether a class is constructable with the given arguments,
-- `.toHaveProperty()` looks up keys on an object type,
-- `.toRaiseError()` captures the message or code of a type error.
+- `.toHaveProperty()` looks up keys on an object type.
 
 ## Runner
 

package/build/tstyche.d.ts

@@ -41,6 +41,7 @@ interface CommandLineOptions {
 }
 interface ConfigFileOptions {
     checkSourceFiles?: boolean;
+    checkSuppressedErrors?: boolean;
     failFast?: boolean;
     plugins?: Array<string>;
     rejectAnyType?: boolean;
@@ -177,7 +178,7 @@ declare class Diagnostic {
     }): this;
     static error(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
     extendWith(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
-    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>): Array<Diagnostic>;
+    static fromDiagnostics(diagnostics: Array<ts.Diagnostic>, sourceFile?: ts.SourceFile): Array<Diagnostic>;
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
@@ -231,7 +232,7 @@ declare enum TestTreeNodeFlags {
 declare class WhenNode extends TestTreeNode {
     actionNode: ts.CallExpression;
     actionNameNode: ts.PropertyAccessExpression;
-    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
+    abilityDiagnostics: Set<ts.Diagnostic>;
     target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
     constructor(compiler: typeof ts, brand: TestTreeNodeBrand, node: ts.CallExpression, parent: TestTree | TestTreeNode, flags: TestTreeNodeFlags, actionNode: ts.CallExpression, actionNameNode: ts.PropertyAccessExpression);
 }
@@ -248,17 +249,28 @@ declare class TestTreeNode {
     getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
 }
 
+interface SuppressedError {
+    directive: TextRange;
+    ignore: boolean;
+    argument?: TextRange;
+    diagnostics: Array<ts.Diagnostic>;
+}
+type SuppressedErrors = Array<SuppressedError> & {
+    sourceFile: ts.SourceFile;
+};
+
 declare class TestTree {
     children: Array<TestTreeNode | AssertionNode | WhenNode>;
     diagnostics: Set<ts.Diagnostic>;
     hasOnly: boolean;
     sourceFile: ts.SourceFile;
+    suppressedErrors: SuppressedErrors | undefined;
     constructor(diagnostics: Set<ts.Diagnostic>, sourceFile: ts.SourceFile);
     getDirectiveRanges(compiler: typeof ts): DirectiveRanges | undefined;
 }
 
 declare class AssertionNode extends TestTreeNode {
-    abilityDiagnostics: Set<ts.Diagnostic> | undefined;
+    abilityDiagnostics: Set<ts.Diagnostic>;
     isNot: boolean;
     matcherNode: ts.CallExpression | ts.Decorator;
     matcherNameNode: ts.PropertyAccessExpression;
@@ -759,6 +771,10 @@ declare class Store {
     static validateTag(tag: string): Promise<boolean | undefined>;
 }
 
+declare class SuppressedService {
+    match(suppressedErrors: SuppressedErrors, onDiagnostics: DiagnosticsHandler<Array<Diagnostic>>): void;
+}
+
 declare class Version {
     #private;
     static isGreaterThan(source: string, target: string): boolean;
@@ -794,5 +810,5 @@ declare class WhenService {
     action(when: WhenNode): void;
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, 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 };
-export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Reject, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, SuppressedService, 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 };
+export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, DirectiveRange, DirectiveRanges, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InlineConfig, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, SuppressedError, SuppressedErrors, TargetResultStatus, TaskResultStatus, TextRange, TypeChecker, WatchHandler, WatcherOptions };

package/build/tstyche.js

@@ -87,12 +87,12 @@ class Diagnostic {
     extendWith(text, origin) {
         return new Diagnostic([this.text, text].flat(), this.category, origin ?? this.origin);
     }
-    static fromDiagnostics(diagnostics) {
+    static fromDiagnostics(diagnostics, sourceFile) {
         return diagnostics.map((diagnostic) => {
             const code = `ts(${diagnostic.code})`;
             let origin;
-            if (diagnostic.file != null && diagnostic.start != null && diagnostic.length != null) {
-                origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file);
+            if (isDiagnosticWithLocation(diagnostic)) {
+                origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceFile ?? diagnostic.file);
             }
             let related;
             if (diagnostic.relatedInformation != null) {
@@ -910,6 +910,12 @@ class Options {
             group: OptionGroup.ConfigFile,
             name: "checkSourceFiles",
         },
+        {
+            brand: OptionBrand.Boolean,
+            description: "Check errors silenced by '// @ts-expect-error' directives.",
+            group: OptionGroup.ConfigFile,
+            name: "checkSuppressedErrors",
+        },
         {
             brand: OptionBrand.String,
             description: "The path to a TSTyche configuration file.",
@@ -1394,6 +1400,7 @@ class ConfigParser {
 
 const defaultOptions = {
     checkSourceFiles: true,
+    checkSuppressedErrors: false,
     failFast: false,
     plugins: [],
     rejectAnyType: true,
@@ -2130,7 +2137,9 @@ function describeNameText(name, indent = 0) {
 function BreadcrumbsText({ ancestor }) {
     const text = [];
     while ("name" in ancestor) {
-        text.push(ancestor.name);
+        if (ancestor.name !== "") {
+            text.push(ancestor.name);
+        }
         ancestor = ancestor.parent;
     }
     text.push("");
@@ -3028,7 +3037,7 @@ class TestTreeNode {
 }
 
 class AssertionNode extends TestTreeNode {
-    abilityDiagnostics;
+    abilityDiagnostics = new Set();
     isNot;
     matcherNode;
     matcherNameNode;
@@ -3065,34 +3074,18 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
+    #expectErrorRegex = /^( *)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
     #filePath = "";
     #nodes = [];
     #projectService;
     #resolvedConfig;
+    #suppressedErrorsMap;
     #text = "";
     constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
         this.#projectService = projectService;
         this.#resolvedConfig = resolvedConfig;
     }
-    #getErasedRangeText(range) {
-        if (this.#text.indexOf("\n", range.start) >= range.end) {
-            return " ".repeat(range.end - range.start);
-        }
-        const text = [];
-        for (let index = range.start; index < range.end; index++) {
-            const character = this.#text.charAt(index);
-            switch (character) {
-                case "\n":
-                case "\r":
-                    text.push(character);
-                    break;
-                default:
-                    text.push(" ");
-            }
-        }
-        return text.join("");
-    }
     #addRanges(node, ranges) {
         this.#nodes.push(node);
         for (const range of ranges) {
@@ -3102,25 +3095,78 @@ class AbilityLayer {
             this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
         }
     }
+    #belongsToNode(diagnostic) {
+        for (const node of this.#nodes) {
+            if (diagnosticBelongsToNode(diagnostic, "matcherNode" in node ? node.matcherNode : node.actionNode)) {
+                node.abilityDiagnostics.add(diagnostic);
+                return true;
+            }
+        }
+        return false;
+    }
+    #belongsToDirective(diagnostic) {
+        if (!isDiagnosticWithLocation(diagnostic)) {
+            return;
+        }
+        const { file, start } = diagnostic;
+        const lineMap = file.getLineStarts();
+        let line = this.#compiler.getLineAndCharacterOfPosition(file, start).line - 1;
+        while (line >= 0) {
+            const suppressedError = this.#suppressedErrorsMap?.get(line);
+            if (suppressedError != null) {
+                suppressedError.diagnostics.push(diagnostic);
+                break;
+            }
+            const lineText = file.text.slice(lineMap[line], lineMap[line + 1]).trim();
+            if (lineText !== "" && !lineText.startsWith("//")) {
+                break;
+            }
+            line--;
+        }
+    }
+    #collectSuppressedErrors() {
+        const ranges = [];
+        for (const match of this.#text.matchAll(this.#expectErrorRegex)) {
+            const offsetText = match?.[1];
+            const directiveText = match?.[2];
+            const ignoreText = match?.[3];
+            const argumentSeparatorText = match?.[4];
+            const argumentText = match?.[5]?.split(/--+/)[0]?.trimEnd();
+            if (typeof offsetText !== "string" || !directiveText) {
+                continue;
+            }
+            const start = match.index + offsetText.length;
+            const range = {
+                directive: { start, end: start + directiveText.length, text: directiveText },
+                ignore: ignoreText === "!",
+                diagnostics: [],
+            };
+            if (typeof argumentSeparatorText === "string" && typeof argumentText === "string") {
+                const start = range.directive.end + argumentSeparatorText.length;
+                range.argument = { start, end: start + argumentText.length, text: argumentText };
+            }
+            ranges.push(range);
+        }
+        return ranges;
+    }
     close() {
-        if (this.#nodes.length > 0) {
+        if (this.#nodes.length > 0 || this.#suppressedErrorsMap != null) {
             this.#projectService.openFile(this.#filePath, this.#text, this.#resolvedConfig.rootPath);
             const languageService = this.#projectService.getLanguageService(this.#filePath);
-            const diagnostics = new Set(languageService?.getSemanticDiagnostics(this.#filePath));
-            for (const node of this.#nodes.reverse()) {
+            const diagnostics = languageService?.getSemanticDiagnostics(this.#filePath);
+            if (diagnostics != null) {
+                this.#nodes.reverse();
                 for (const diagnostic of diagnostics) {
-                    if (diagnosticBelongsToNode(diagnostic, "matcherNode" in node ? node.matcherNode : node.actionNode)) {
-                        if (!node.abilityDiagnostics) {
-                            node.abilityDiagnostics = new Set();
-                        }
-                        node.abilityDiagnostics.add(diagnostic);
-                        diagnostics.delete(diagnostic);
+                    if (this.#belongsToNode(diagnostic)) {
+                        continue;
                     }
+                    this.#belongsToDirective(diagnostic);
                 }
             }
         }
         this.#filePath = "";
         this.#nodes = [];
+        this.#suppressedErrorsMap = undefined;
         this.#text = "";
     }
     #eraseTrailingComma(node, parent) {
@@ -3128,24 +3174,23 @@ class AbilityLayer {
             this.#addRanges(parent, [{ start: node.end - 1, end: node.end }]);
         }
     }
-    handleWhen(whenNode) {
-        const whenStart = whenNode.node.getStart();
-        const whenExpressionEnd = whenNode.node.expression.getEnd();
-        const whenEnd = whenNode.node.getEnd();
-        const actionNameEnd = whenNode.actionNameNode.getEnd();
-        switch (whenNode.actionNameNode.name.text) {
-            case "isCalledWith":
-                this.#eraseTrailingComma(whenNode.target, whenNode);
-                this.#addRanges(whenNode, [
-                    {
-                        start: whenStart,
-                        end: whenExpressionEnd,
-                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
-                    },
-                    { start: whenEnd, end: actionNameEnd },
-                ]);
-                break;
+    #getErasedRangeText(range) {
+        if (this.#text.indexOf("\n", range.start) >= range.end) {
+            return " ".repeat(range.end - range.start);
+        }
+        const text = [];
+        for (let index = range.start; index < range.end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
+                case "\n":
+                case "\r":
+                    text.push(character);
+                    break;
+                default:
+                    text.push(" ");
+            }
         }
+        return text.join("");
     }
     handleAssertion(assertionNode) {
         const expectStart = assertionNode.node.getStart();
@@ -3183,9 +3228,45 @@ class AbilityLayer {
                 break;
         }
     }
-    open(sourceFile) {
-        this.#filePath = sourceFile.fileName;
-        this.#text = sourceFile.text;
+    #handleSuppressedErrors(testTree) {
+        const suppressedErrors = this.#collectSuppressedErrors();
+        if (this.#resolvedConfig.checkSuppressedErrors) {
+            testTree.suppressedErrors = Object.assign(suppressedErrors, { sourceFile: testTree.sourceFile });
+            this.#suppressedErrorsMap = new Map();
+        }
+        for (const suppressedError of suppressedErrors) {
+            const { start, end } = suppressedError.directive;
+            const rangeText = this.#getErasedRangeText({ start: start + 2, end });
+            this.#text = `${this.#text.slice(0, start + 2)}${rangeText}${this.#text.slice(end)}`;
+            if (this.#suppressedErrorsMap != null) {
+                const { line } = testTree.sourceFile.getLineAndCharacterOfPosition(start);
+                this.#suppressedErrorsMap.set(line, suppressedError);
+            }
+        }
+    }
+    handleWhen(whenNode) {
+        const whenStart = whenNode.node.getStart();
+        const whenExpressionEnd = whenNode.node.expression.getEnd();
+        const whenEnd = whenNode.node.getEnd();
+        const actionNameEnd = whenNode.actionNameNode.getEnd();
+        switch (whenNode.actionNameNode.name.text) {
+            case "isCalledWith":
+                this.#eraseTrailingComma(whenNode.target, whenNode);
+                this.#addRanges(whenNode, [
+                    {
+                        start: whenStart,
+                        end: whenExpressionEnd,
+                        replacement: nodeIsChildOfExpressionStatement(this.#compiler, whenNode.actionNode) ? ";" : "",
+                    },
+                    { start: whenEnd, end: actionNameEnd },
+                ]);
+                break;
+        }
+    }
+    open(testTree) {
+        this.#filePath = testTree.sourceFile.fileName;
+        this.#text = testTree.sourceFile.text;
+        this.#handleSuppressedErrors(testTree);
     }
 }
 
@@ -3312,6 +3393,7 @@ class TestTree {
     diagnostics;
     hasOnly = false;
     sourceFile;
+    suppressedErrors;
     constructor(diagnostics, sourceFile) {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
@@ -3324,7 +3406,7 @@ class TestTree {
 class WhenNode extends TestTreeNode {
     actionNode;
     actionNameNode;
-    abilityDiagnostics;
+    abilityDiagnostics = new Set();
     target;
     constructor(compiler, brand, node, parent, flags, actionNode, actionNameNode) {
         super(compiler, brand, node, parent, flags);
@@ -3423,7 +3505,7 @@ class CollectService {
     createTestTree(sourceFile, semanticDiagnostics = []) {
         const testTree = new TestTree(new Set(semanticDiagnostics), sourceFile);
         EventEmitter.dispatch(["collect:start", { tree: testTree }]);
-        this.#abilityLayer.open(sourceFile);
+        this.#abilityLayer.open(testTree);
         this.#identifierLookup.open();
         this.#collectTestTreeNodes(sourceFile, testTree, testTree);
         this.#abilityLayer.close();
@@ -3560,6 +3642,9 @@ class ProjectService {
             defaultCompilerOptions.allowImportingTsExtensions = true;
             defaultCompilerOptions.verbatimModuleSyntax = true;
         }
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.6")) {
+            defaultCompilerOptions.noUncheckedSideEffectImports = true;
+        }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
@@ -3633,6 +3718,60 @@ class ProjectService {
     }
 }
 
+class SuppressedDiagnosticText {
+    static directiveRequires() {
+        return [
+            "Directive requires an argument.",
+            "Add a fragment of the expected error message after the directive.",
+            "To ignore the directive, append a '!' character after it.",
+        ];
+    }
+    static messageDidNotMatch() {
+        return "The diagnostic message did not match.";
+    }
+    static onlySingleError() {
+        return "Only a single error can be suppressed.";
+    }
+    static suppressedError(count = 1) {
+        return `The suppressed error${count === 1 ? "" : "s"}:`;
+    }
+}
+
+class SuppressedService {
+    match(suppressedErrors, onDiagnostics) {
+        for (const suppressedError of suppressedErrors) {
+            if (suppressedError.diagnostics.length === 0 || suppressedError.ignore) {
+                continue;
+            }
+            if (!suppressedError.argument?.text) {
+                const text = SuppressedDiagnosticText.directiveRequires();
+                const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, suppressedErrors.sourceFile);
+                onDiagnostics([Diagnostic.error(text, origin)]);
+                continue;
+            }
+            const related = [
+                Diagnostic.error(SuppressedDiagnosticText.suppressedError(suppressedError.diagnostics.length)),
+                ...Diagnostic.fromDiagnostics(suppressedError.diagnostics, suppressedErrors.sourceFile),
+            ];
+            if (suppressedError.diagnostics.length > 1) {
+                const text = [SuppressedDiagnosticText.onlySingleError()];
+                const origin = new DiagnosticOrigin(suppressedError.directive.start, suppressedError.directive.end, suppressedErrors.sourceFile);
+                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+                continue;
+            }
+            let messageText = getDiagnosticMessageText(suppressedError.diagnostics[0]);
+            if (Array.isArray(messageText)) {
+                messageText = messageText.join("\n");
+            }
+            if (!messageText.includes(suppressedError.argument.text)) {
+                const text = [SuppressedDiagnosticText.messageDidNotMatch()];
+                const origin = new DiagnosticOrigin(suppressedError.argument.start, suppressedError.argument.end, suppressedErrors.sourceFile);
+                onDiagnostics([Diagnostic.error(text, origin).add({ related })]);
+            }
+        }
+    }
+}
+
 var RunMode;
 (function (RunMode) {
     RunMode[RunMode["Normal"] = 0] = "Normal";
@@ -4117,7 +4256,7 @@ class ToBeApplicable {
     #explain(matchWorker, sourceNode) {
         const targetText = this.#resolveTargetText(matchWorker.assertion.matcherNode.parent);
         const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics) {
+        if (matchWorker.assertion.abilityDiagnostics.size > 0) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
                 const text = [ExpectDiagnosticText.cannotBeApplied(targetText), getDiagnosticMessageText(diagnostic)];
                 const origin = DiagnosticOrigin.fromNode(sourceNode);
@@ -4143,7 +4282,7 @@ class ToBeApplicable {
         }
         return {
             explain: () => this.#explain(matchWorker, sourceNode),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4170,69 +4309,75 @@ class ToBeAssignableWith extends RelationMatcherBase {
     }
 }
 
-class ToBeCallableWith {
-    #compiler;
+class AbilityMatcherBase {
+    compiler;
     constructor(compiler) {
-        this.#compiler = compiler;
+        this.compiler = compiler;
     }
     #resolveTargetText(nodes) {
         if (nodes.length === 0) {
             return "without arguments";
         }
-        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
+        if (nodes.length === 1 && nodes[0]?.kind === this.compiler.SyntaxKind.SpreadElement) {
             return "with the given arguments";
         }
         return `with the given argument${nodes.length === 1 ? "" : "s"}`;
     }
-    #explain(matchWorker, sourceNode, targetNodes) {
-        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
+    explain(matchWorker, sourceNode, targetNodes) {
+        const isExpression = nodeBelongsToArgumentList(this.compiler, sourceNode);
         const targetText = this.#resolveTargetText(targetNodes);
         const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics) {
+        if (matchWorker.assertion.abilityDiagnostics.size > 0) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.isNotCallable(isExpression, targetText),
-                    getDiagnosticMessageText(diagnostic),
-                ];
                 let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
+                const text = [];
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, sourceNode)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
+                    text.push(getDiagnosticMessageText(diagnostic));
                 }
                 else {
-                    origin =
-                        targetNodes.length > 0
-                            ? DiagnosticOrigin.fromNodes(targetNodes)
-                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                    if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                        origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile(), matchWorker.assertion);
+                    }
+                    else {
+                        origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
+                    }
+                    text.push(this.explainNotText(isExpression, targetText), getDiagnosticMessageText(diagnostic));
                 }
                 let related;
                 if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceNode.getSourceFile());
                 }
                 diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
             }
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isCallable(isExpression, targetText), origin));
+            diagnostics.push(Diagnostic.error(this.explainText(isExpression, targetText), origin));
         }
         return diagnostics;
     }
+}
+
+class ToBeCallableWith extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.isCallable;
+    explainNotText = ExpectDiagnosticText.isNotCallable;
     match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
         let type;
-        if (this.#compiler.isCallExpression(sourceNode)) {
+        if (this.compiler.isCallExpression(sourceNode)) {
             type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
         }
-        if (this.#compiler.isArrowFunction(sourceNode) ||
-            this.#compiler.isFunctionDeclaration(sourceNode) ||
-            this.#compiler.isFunctionExpression(sourceNode) ||
-            this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
-            this.#compiler.isIdentifier(sourceNode) ||
-            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+        if (this.compiler.isArrowFunction(sourceNode) ||
+            this.compiler.isFunctionDeclaration(sourceNode) ||
+            this.compiler.isFunctionExpression(sourceNode) ||
+            this.compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode)) {
             type = matchWorker.getType(sourceNode);
         }
         if (!type || type.getCallSignatures().length === 0) {
             const text = [];
-            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+            if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
                 text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
             }
             else {
@@ -4246,72 +4391,28 @@ class ToBeCallableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
 
-class ToBeConstructableWith {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
-    }
-    #resolveTargetText(nodes) {
-        if (nodes.length === 0) {
-            return "without arguments";
-        }
-        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
-            return "with the given arguments";
-        }
-        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
-    }
-    #explain(matchWorker, sourceNode, targetNodes) {
-        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
-        const targetText = this.#resolveTargetText(targetNodes);
-        const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics) {
-            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.isNotConstructable(isExpression, targetText),
-                    getDiagnosticMessageText(diagnostic),
-                ];
-                let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
-                }
-                else {
-                    origin =
-                        targetNodes.length > 0
-                            ? DiagnosticOrigin.fromNodes(targetNodes)
-                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-                }
-                let related;
-                if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
-                }
-                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
-            }
-        }
-        else {
-            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isExpression, targetText), origin));
-        }
-        return diagnostics;
-    }
+class ToBeConstructableWith extends AbilityMatcherBase {
+    explainText = ExpectDiagnosticText.isConstructable;
+    explainNotText = ExpectDiagnosticText.isNotConstructable;
     match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
         let type;
-        if (this.#compiler.isCallExpression(sourceNode)) {
+        if (this.compiler.isCallExpression(sourceNode)) {
             type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
         }
-        if (this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
-            this.#compiler.isIdentifier(sourceNode) ||
-            this.#compiler.isPropertyAccessExpression(sourceNode)) {
+        if (this.compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.compiler.isIdentifier(sourceNode) ||
+            this.compiler.isPropertyAccessExpression(sourceNode)) {
             type = matchWorker.getType(sourceNode);
         }
         if (!type || type.getConstructSignatures().length === 0) {
             const text = [];
-            if (nodeBelongsToArgumentList(this.#compiler, sourceNode)) {
+            if (nodeBelongsToArgumentList(this.compiler, sourceNode)) {
                 text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
             }
             else {
@@ -4325,8 +4426,8 @@ class ToBeConstructableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4633,7 +4734,7 @@ class WhenService {
                 this.#onActionIsNotSupported(actionNameText, when, this.#onDiagnostics);
                 return;
         }
-        if (when.abilityDiagnostics != null && when.abilityDiagnostics.size > 0) {
+        if (when.abilityDiagnostics.size > 0) {
             const diagnostics = [];
             for (const diagnostic of when.abilityDiagnostics) {
                 if (isDiagnosticWithLocation(diagnostic)) {
@@ -4829,8 +4930,9 @@ class TestTreeWalker {
 class TaskRunner {
     #collectService;
     #compiler;
-    #resolvedConfig;
     #projectService;
+    #resolvedConfig;
+    #suppressedService = new SuppressedService();
     constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
         this.#resolvedConfig = resolvedConfig;
@@ -4871,6 +4973,11 @@ class TaskRunner {
         if (inlineConfig?.if?.target != null && !Version.isIncluded(this.#compiler.version, inlineConfig.if.target)) {
             runMode |= RunMode.Skip;
         }
+        if (testTree.suppressedErrors != null) {
+            this.#suppressedService.match(testTree.suppressedErrors, (diagnostics) => {
+                this.#onDiagnostics(diagnostics, taskResult);
+            });
+        }
         if (inlineConfig?.template) {
             if (semanticDiagnostics != null && semanticDiagnostics.length > 0) {
                 this.#onDiagnostics(Diagnostic.fromDiagnostics(semanticDiagnostics), taskResult);
@@ -4915,7 +5022,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.1";
+    static version = "4.1.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5115,4 +5222,4 @@ class Cli {
     }
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, 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 };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, 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, SuppressedService, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",