tstyche 4.0.2 → 4.2.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;
@@ -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;
@@ -546,6 +558,11 @@ declare class ExpectService {
     match(assertion: AssertionNode, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
 }
 
+declare class Glob {
+    #private;
+    static toRegex(patterns: Array<string>, target: "directories" | "files"): RegExp;
+}
+
 declare class CancellationHandler implements EventHandler {
     #private;
     constructor(cancellationToken: CancellationToken, cancellationReason: CancellationReason);
@@ -759,6 +776,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 +815,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, TextRange, TypeChecker, WatchHandler, WatcherOptions };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, Directive, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, Glob, 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

@@ -96,7 +96,7 @@ class Diagnostic {
             }
             let related;
             if (diagnostic.relatedInformation != null) {
-                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceFile);
+                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
             }
             const text = getDiagnosticMessageText(diagnostic);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
@@ -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,
@@ -2735,7 +2742,64 @@ class InputService {
     }
 }
 
-class GlobPattern {
+class Braces {
+    static expand(text) {
+        const start = text.indexOf("{");
+        if (start === -1) {
+            return [text];
+        }
+        let position = start;
+        let depth = 0;
+        for (position; position < text.length; position++) {
+            if (text[position] === "{") {
+                depth++;
+            }
+            else if (text[position] === "}") {
+                depth--;
+            }
+            if (depth === 0) {
+                break;
+            }
+        }
+        if (depth !== 0) {
+            return [text];
+        }
+        const before = text.slice(0, start);
+        const options = Braces.#splitOptions(text.slice(start + 1, position));
+        const after = text.slice(position + 1);
+        const result = [];
+        for (const option of options) {
+            for (const expanded of Braces.expand(option + after)) {
+                result.push(before + expanded);
+            }
+        }
+        return result;
+    }
+    static #splitOptions(optionText) {
+        const options = [];
+        let current = "";
+        let depth = 0;
+        for (const character of optionText) {
+            if (character === "," && depth === 0) {
+                options.push(current);
+                current = "";
+            }
+            else {
+                if (character === "{") {
+                    depth++;
+                }
+                if (character === "}") {
+                    depth--;
+                }
+                current += character;
+            }
+        }
+        options.push(current);
+        return options;
+    }
+}
+
+class Glob {
     static #reservedCharacterRegex = /[^\w\s/]/g;
     static #parse(pattern, usageTarget) {
         const segments = pattern.split("/");
@@ -2754,7 +2818,7 @@ class GlobPattern {
                 optionalSegmentCount++;
             }
             resultPattern += "\\/";
-            const segmentPattern = segment.replace(GlobPattern.#reservedCharacterRegex, GlobPattern.#replaceReservedCharacter);
+            const segmentPattern = segment.replace(Glob.#reservedCharacterRegex, Glob.#replaceReservedCharacter);
             if (segmentPattern !== segment) {
                 resultPattern += "(?!(node_modules)(\\/|$))";
             }
@@ -2774,7 +2838,10 @@ class GlobPattern {
         }
     }
     static toRegex(patterns, target) {
-        const patternText = patterns.map((pattern) => `(${GlobPattern.#parse(pattern, target)})`).join("|");
+        const patternText = patterns
+            .flatMap((pattern) => Braces.expand(pattern))
+            .map((pattern) => `(${Glob.#parse(pattern, target)})`)
+            .join("|");
         return new RegExp(`^(${patternText})$`);
     }
 }
@@ -2832,8 +2899,8 @@ class Select {
         let matchPatterns = Select.#patternsCache.get(globPatterns);
         if (!matchPatterns) {
             matchPatterns = {
-                includedDirectory: GlobPattern.toRegex(globPatterns, "directories"),
-                includedFile: GlobPattern.toRegex(globPatterns, "files"),
+                includedDirectory: Glob.toRegex(globPatterns, "directories"),
+                includedFile: Glob.toRegex(globPatterns, "files"),
             };
             Select.#patternsCache.set(globPatterns, matchPatterns);
         }
@@ -3030,7 +3097,7 @@ class TestTreeNode {
 }
 
 class AssertionNode extends TestTreeNode {
-    abilityDiagnostics;
+    abilityDiagnostics = new Set();
     isNot;
     matcherNode;
     matcherNameNode;
@@ -3072,12 +3139,51 @@ class AbilityLayer {
     #nodes = [];
     #projectService;
     #resolvedConfig;
+    #suppressedErrorsMap;
     #text = "";
     constructor(compiler, projectService, resolvedConfig) {
         this.#compiler = compiler;
         this.#projectService = projectService;
         this.#resolvedConfig = resolvedConfig;
     }
+    #addRanges(node, ranges) {
+        this.#nodes.push(node);
+        for (const range of ranges) {
+            const rangeText = range.replacement != null
+                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
+                : this.#getErasedRangeText(range);
+            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
+        }
+    }
+    #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)) {
@@ -3086,12 +3192,13 @@ class AbilityLayer {
             const ignoreText = match?.[3];
             const argumentSeparatorText = match?.[4];
             const argumentText = match?.[5]?.split(/--+/)[0]?.trimEnd();
-            if (typeof offsetText !== "string" || !directiveText || ignoreText === "!") {
+            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") {
@@ -3102,52 +3209,24 @@ class AbilityLayer {
         }
         return ranges;
     }
-    #getErasedRangeText(range) {
-        if (this.#text.indexOf("\n", range.start) >= range.end) {
-            return " ".repeat(range.end - range.start);
-        }
-        const text = [];
-        for (let index = range.start; index < range.end; index++) {
-            const character = this.#text.charAt(index);
-            switch (character) {
-                case "\n":
-                case "\r":
-                    text.push(character);
-                    break;
-                default:
-                    text.push(" ");
-            }
-        }
-        return text.join("");
-    }
-    #addRanges(node, ranges) {
-        this.#nodes.push(node);
-        for (const range of ranges) {
-            const rangeText = range.replacement != null
-                ? `${range.replacement}${this.#getErasedRangeText(range).slice(range.replacement.length)}`
-                : this.#getErasedRangeText(range);
-            this.#text = `${this.#text.slice(0, range.start)}${rangeText}${this.#text.slice(range.end)}`;
-        }
-    }
     close() {
-        if (this.#nodes.length > 0) {
+        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) {
@@ -3155,24 +3234,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();
@@ -3210,18 +3288,45 @@ class AbilityLayer {
                 break;
         }
     }
-    #handleSuppressedErrors() {
+    #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);
+            }
         }
     }
-    open(sourceFile) {
-        this.#filePath = sourceFile.fileName;
-        this.#text = sourceFile.text;
-        this.#handleSuppressedErrors();
+    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);
     }
 }
 
@@ -3348,6 +3453,7 @@ class TestTree {
     diagnostics;
     hasOnly = false;
     sourceFile;
+    suppressedErrors;
     constructor(diagnostics, sourceFile) {
         this.diagnostics = diagnostics;
         this.sourceFile = sourceFile;
@@ -3360,7 +3466,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);
@@ -3459,7 +3565,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();
@@ -3596,6 +3702,9 @@ class ProjectService {
             defaultCompilerOptions.allowImportingTsExtensions = true;
             defaultCompilerOptions.verbatimModuleSyntax = true;
         }
+        if (Version.isSatisfiedWith(this.#compiler.version, "5.6")) {
+            defaultCompilerOptions.noUncheckedSideEffectImports = true;
+        }
         return defaultCompilerOptions;
     }
     getDefaultProject(filePath) {
@@ -3669,6 +3778,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 the '!' 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";
@@ -3853,7 +4016,9 @@ class MatchWorker {
         }
     }
     extendsObjectType(type) {
-        const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
+        const nonPrimitiveType = "getNonPrimitiveType" in this.typeChecker
+            ? this.typeChecker.getNonPrimitiveType()
+            : { flags: this.#compiler.TypeFlags.NonPrimitive };
         return this.typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
     }
     getParameterType(signature, index) {
@@ -4153,7 +4318,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);
@@ -4179,7 +4344,7 @@ class ToBeApplicable {
         }
         return {
             explain: () => this.#explain(matchWorker, sourceNode),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4224,7 +4389,7 @@ class AbilityMatcherBase {
         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) {
                 let origin;
                 const text = [];
@@ -4289,7 +4454,7 @@ class ToBeCallableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4324,7 +4489,7 @@ class ToBeConstructableWith extends AbilityMatcherBase {
         }
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNodes),
-            isMatch: !matchWorker.assertion.abilityDiagnostics,
+            isMatch: matchWorker.assertion.abilityDiagnostics.size === 0,
         };
     }
 }
@@ -4631,7 +4796,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)) {
@@ -4827,8 +4992,9 @@ class TestTreeWalker {
 class TaskRunner {
     #collectService;
     #compiler;
-    #resolvedConfig;
     #projectService;
+    #resolvedConfig;
+    #suppressedService = new SuppressedService();
     constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
         this.#resolvedConfig = resolvedConfig;
@@ -4869,6 +5035,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);
@@ -4913,7 +5084,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.2";
+    static version = "4.2.0";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -5113,4 +5284,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, Glob, 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.2",
+  "version": "4.2.0",
   "description": "Everything You Need for Type Testing.",
   "keywords": [
     "typescript",