tstyche 4.0.1 → 4.0.2

package/build/tstyche.d.ts

@@ -177,7 +177,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;
 }
 
@@ -795,4 +795,4 @@ declare class WhenService {
 }
 
 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 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 };

package/build/tstyche.js

@@ -87,16 +87,16 @@ 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) {
-                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
+                related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation, sourceFile);
             }
             const text = getDiagnosticMessageText(diagnostic);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
@@ -2130,7 +2130,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("");
@@ -3065,6 +3067,7 @@ function nodeIsChildOfExpressionStatement(compiler, node) {
 
 class AbilityLayer {
     #compiler;
+    #expectErrorRegex = /^( *)(\/\/ *@ts-expect-error)(!?)(:? *)(.*)?$/gim;
     #filePath = "";
     #nodes = [];
     #projectService;
@@ -3075,6 +3078,30 @@ class AbilityLayer {
         this.#projectService = projectService;
         this.#resolvedConfig = resolvedConfig;
     }
+    #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 || ignoreText === "!") {
+                continue;
+            }
+            const start = match.index + offsetText.length;
+            const range = {
+                directive: { start, end: start + directiveText.length, text: directiveText },
+                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;
+    }
     #getErasedRangeText(range) {
         if (this.#text.indexOf("\n", range.start) >= range.end) {
             return " ".repeat(range.end - range.start);
@@ -3183,9 +3210,18 @@ class AbilityLayer {
                 break;
         }
     }
+    #handleSuppressedErrors() {
+        const suppressedErrors = this.#collectSuppressedErrors();
+        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)}`;
+        }
+    }
     open(sourceFile) {
         this.#filePath = sourceFile.fileName;
         this.#text = sourceFile.text;
+        this.#handleSuppressedErrors();
     }
 }
 
@@ -4170,69 +4206,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) {
             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 +4288,28 @@ class ToBeCallableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
             isMatch: !matchWorker.assertion.abilityDiagnostics,
         };
     }
 }
 
-class ToBeConstructableWith {
-    #compiler;
-    constructor(compiler) {
-        this.#compiler = compiler;
-    }
-    #resolveTargetText(nodes) {
-        if (nodes.length === 0) {
-            return "without arguments";
-        }
-        if (nodes.length === 1 && nodes[0]?.kind === this.#compiler.SyntaxKind.SpreadElement) {
-            return "with the given arguments";
-        }
-        return `with the given argument${nodes.length === 1 ? "" : "s"}`;
-    }
-    #explain(matchWorker, sourceNode, targetNodes) {
-        const isExpression = nodeBelongsToArgumentList(this.#compiler, sourceNode);
-        const targetText = this.#resolveTargetText(targetNodes);
-        const diagnostics = [];
-        if (matchWorker.assertion.abilityDiagnostics) {
-            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.isNotConstructable(isExpression, targetText),
-                    getDiagnosticMessageText(diagnostic),
-                ];
-                let origin;
-                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
-                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
-                }
-                else {
-                    origin =
-                        targetNodes.length > 0
-                            ? DiagnosticOrigin.fromNodes(targetNodes)
-                            : DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-                }
-                let related;
-                if (diagnostic.relatedInformation != null) {
-                    related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
-                }
-                diagnostics.push(Diagnostic.error(text.flat(), origin).add({ related }));
-            }
-        }
-        else {
-            const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isExpression, targetText), origin));
-        }
-        return diagnostics;
-    }
+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,7 +4323,7 @@ class ToBeConstructableWith {
             return;
         }
         return {
-            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            explain: () => this.explain(matchWorker, sourceNode, targetNodes),
             isMatch: !matchWorker.assertion.abilityDiagnostics,
         };
     }
@@ -4915,7 +4913,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.1";
+    static version = "4.0.2";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }

package/package.json

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