tstyche 4.0.0-beta.2 → 4.0.0-beta.4

package/README.md

@@ -63,7 +63,8 @@ Here is the list of all matchers:
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()` compare types or types of expression,
 - `.toAcceptProps()` checks the type of JSX component props,
 - `.toBeApplicable` ensures that the decorator function can be applied,
-- `.toBeCallableWith()` checks whether a function can be called with the given arguments,
+- `.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.
 

package/build/index.d.cts

@@ -128,9 +128,13 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type can be called with the target arguments.
+     * Checks if the source type is callable with the given arguments.
      */
     toBeCallableWith: (...target: Array<unknown>) => void;
+    /**
+     * Checks if the source type is constructable with the given arguments.
+     */
+    toBeConstructableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/index.d.ts

@@ -128,9 +128,13 @@ interface Matchers {
         (target: unknown): void;
     };
     /**
-     * Checks if the source type can be called with the target arguments.
+     * Checks if the source type is callable with the given arguments.
      */
     toBeCallableWith: (...target: Array<unknown>) => void;
+    /**
+     * Checks if the source type is constructable with the given arguments.
+     */
+    toBeConstructableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/tstyche.d.ts

@@ -62,10 +62,14 @@ declare class Diagnostic {
     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 toMessageText(chain: ts.DiagnosticMessageChain): Array<string>;
     static warning(text: string | Array<string>, origin?: DiagnosticOrigin): Diagnostic;
 }
 
+declare function diagnosticBelongsToNode(diagnostic: ts.Diagnostic, node: ts.NodeArray<ts.Node> | ts.Node): boolean;
+declare function getDiagnosticMessageText(diagnostic: ts.Diagnostic): string | Array<string>;
+declare function getTextSpanEnd(span: ts.TextSpan): number;
+declare function isDiagnosticWithLocation(diagnostic: ts.Diagnostic): diagnostic is ts.DiagnosticWithLocation;
+
 type DiagnosticsHandler<T extends Diagnostic | Array<Diagnostic> = Diagnostic> = (this: void, diagnostics: T) => void;
 
 declare enum TestTreeNodeBrand {
@@ -604,6 +608,7 @@ declare class ExpectService {
     private toBeAssignableTo;
     private toBeAssignableWith;
     private toBeCallableWith;
+    private toBeConstructableWith;
     private toHaveProperty;
     private toRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig: ResolvedConfig);
@@ -868,5 +873,5 @@ declare class WatchService {
     watch(cancellationToken: CancellationToken): AsyncIterable<Array<Task>>;
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, ScribblerJsx, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
 export type { CodeFrameOptions, CommandLineOptions, ConfigFileOptions, DiagnosticsHandler, EnvironmentOptions, Event, EventHandler, FileWatchHandler, InputHandler, ItemDefinition, MatchResult, OptionDefinition, Plugin, Reporter, ReporterEvent, ResolvedConfig, ScribblerOptions, SelectHookContext, TargetResultStatus, TaskResultStatus, TypeChecker, WatchHandler, WatcherOptions };

package/build/tstyche.js

@@ -104,6 +104,30 @@ class DiagnosticOrigin {
     }
 }
 
+function diagnosticBelongsToNode(diagnostic, node) {
+    return diagnostic.start != null && diagnostic.start >= node.pos && diagnostic.start <= node.end;
+}
+function diagnosticMessageChainToText(chain) {
+    const result = [chain.messageText];
+    if (chain.next != null) {
+        for (const nextChain of chain.next) {
+            result.push(...diagnosticMessageChainToText(nextChain));
+        }
+    }
+    return result;
+}
+function getDiagnosticMessageText(diagnostic) {
+    return typeof diagnostic.messageText === "string"
+        ? diagnostic.messageText
+        : diagnosticMessageChainToText(diagnostic.messageText);
+}
+function getTextSpanEnd(span) {
+    return span.start + span.length;
+}
+function isDiagnosticWithLocation(diagnostic) {
+    return diagnostic.file != null && diagnostic.start != null && diagnostic.length != null;
+}
+
 class Diagnostic {
     category;
     code;
@@ -141,21 +165,10 @@ class Diagnostic {
             if (diagnostic.relatedInformation != null) {
                 related = Diagnostic.fromDiagnostics(diagnostic.relatedInformation);
             }
-            const text = typeof diagnostic.messageText === "string"
-                ? diagnostic.messageText
-                : Diagnostic.toMessageText(diagnostic.messageText);
+            const text = getDiagnosticMessageText(diagnostic);
             return new Diagnostic(text, DiagnosticCategory.Error, origin).add({ code, related });
         });
     }
-    static toMessageText(chain) {
-        const result = [chain.messageText];
-        if (chain.next != null) {
-            for (const nextChain of chain.next) {
-                result.push(...Diagnostic.toMessageText(nextChain));
-            }
-        }
-        return result;
-    }
     static warning(text, origin) {
         return new Diagnostic(text, DiagnosticCategory.Warning, origin);
     }
@@ -1927,13 +1940,9 @@ class TestTreeNode {
         if (node.arguments[0] != null && compiler.isStringLiteralLike(node.arguments[0])) {
             this.name = node.arguments[0].text;
         }
-        if (node.arguments[1] != null &&
-            compiler.isFunctionLike(node.arguments[1]) &&
-            compiler.isBlock(node.arguments[1].body)) {
-            const blockStart = node.arguments[1].body.getStart();
-            const blockEnd = node.arguments[1].body.getEnd();
+        if (node.arguments[1] != null && compiler.isFunctionLike(node.arguments[1])) {
             for (const diagnostic of parent.diagnostics) {
-                if (diagnostic.start != null && diagnostic.start >= blockStart && diagnostic.start <= blockEnd) {
+                if (diagnosticBelongsToNode(diagnostic, node.arguments[1].body)) {
                     this.diagnostics.add(diagnostic);
                     parent.diagnostics.delete(diagnostic);
                 }
@@ -1990,7 +1999,7 @@ class AssertionNode extends TestTreeNode {
             this.target = this.matcherNode.typeArguments ?? this.matcherNode.arguments;
         }
         for (const diagnostic of parent.diagnostics) {
-            if (diagnostic.start != null && diagnostic.start >= this.source.pos && diagnostic.start <= this.source.end) {
+            if (diagnosticBelongsToNode(diagnostic, this.source)) {
                 this.diagnostics.add(diagnostic);
                 parent.diagnostics.delete(diagnostic);
             }
@@ -2029,7 +2038,9 @@ class AbilityLayer {
     #addRanges(node, ranges) {
         this.#nodes.push(node);
         for (const range of ranges) {
-            const rangeText = this.#getErasedRangeText(range);
+            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)}`;
         }
     }
@@ -2038,12 +2049,9 @@ class AbilityLayer {
             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));
-            const nodes = this.#nodes.reverse();
-            for (const diagnostic of diagnostics) {
-                for (const node of nodes) {
-                    if (diagnostic.start != null &&
-                        diagnostic.start >= node.matcherNode.pos &&
-                        diagnostic.start <= node.matcherNode.end) {
+            for (const node of this.#nodes.reverse()) {
+                for (const diagnostic of diagnostics) {
+                    if (diagnosticBelongsToNode(diagnostic, node.matcherNode)) {
                         if (!node.abilityDiagnostics) {
                             node.abilityDiagnostics = new Set();
                         }
@@ -2058,29 +2066,24 @@ class AbilityLayer {
         this.#text = "";
     }
     handleNode(assertionNode) {
+        const expectStart = assertionNode.node.getStart();
+        const expectExpressionEnd = assertionNode.node.expression.getEnd();
+        const expectEnd = assertionNode.node.getEnd();
+        const matcherNameEnd = assertionNode.matcherNameNode.getEnd();
         switch (assertionNode.matcherNameNode.name.text) {
-            case "toBeApplicable": {
-                const expectStart = assertionNode.node.pos;
-                const expectExpressionEnd = assertionNode.node.expression.end;
-                const expectEnd = assertionNode.node.end;
-                const matcherNameEnd = assertionNode.matcherNameNode.end;
+            case "toBeApplicable":
+            case "toBeCallableWith":
                 this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd + 1, start: expectStart },
-                    { end: matcherNameEnd, start: expectEnd - 1 },
+                    { end: expectExpressionEnd, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd },
                 ]);
                 break;
-            }
-            case "toBeCallableWith": {
-                const expectStart = assertionNode.node.pos;
-                const expectExpressionEnd = assertionNode.node.expression.end;
-                const expectEnd = assertionNode.node.end;
-                const matcherNameEnd = assertionNode.matcherNameNode.end;
+            case "toBeConstructableWith":
                 this.#addRanges(assertionNode, [
-                    { end: expectExpressionEnd + 1, start: expectStart },
-                    { end: matcherNameEnd, start: expectEnd - 1 },
+                    { end: expectExpressionEnd, start: expectStart, replacement: "new" },
+                    { end: matcherNameEnd, start: expectEnd },
                 ]);
                 break;
-            }
         }
     }
     open(sourceFile) {
@@ -3448,11 +3451,17 @@ class ExpectDiagnosticText {
     static argumentMustBeProvided(argumentNameText) {
         return `An argument for '${argumentNameText}' must be provided.`;
     }
-    static canBeCalled(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} can be called ${targetText}.`;
+    static isCallable(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} is callable ${targetText}.`;
+    }
+    static isNotCallable(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} is not callable ${targetText}.`;
+    }
+    static isConstructable(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} is constructable ${targetText}.`;
     }
-    static cannotBeCalled(isTypeNode, targetText) {
-        return `${isTypeNode ? "Type" : "Expression"} cannot be called ${targetText}.`;
+    static isNotConstructable(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} is not constructable ${targetText}.`;
     }
     static acceptsProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
@@ -3472,6 +3481,9 @@ class ExpectDiagnosticText {
     static hasProperty(typeText, propertyNameText) {
         return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
+    static didYouMeanToUse(suggestionText) {
+        return `Did you mean to use ${suggestionText}?`;
+    }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
     }
@@ -3543,18 +3555,18 @@ class MatchWorker {
     assertion;
     #compiler;
     #signatureCache = new Map();
-    #typeChecker;
+    typeChecker;
     constructor(compiler, typeChecker, assertion) {
         this.#compiler = compiler;
-        this.#typeChecker = typeChecker;
+        this.typeChecker = typeChecker;
         this.assertion = assertion;
     }
     checkHasApplicableIndexType(sourceNode, targetNode) {
         const sourceType = this.getType(sourceNode);
         const targetType = this.getType(targetNode);
-        return this.#typeChecker
+        return this.typeChecker
             .getIndexInfosOfType(sourceType)
-            .some(({ keyType }) => this.#typeChecker.isApplicableIndexType(targetType, keyType));
+            .some(({ keyType }) => this.typeChecker.isApplicableIndexType(targetType, keyType));
     }
     checkHasProperty(sourceNode, propertyNameText) {
         const sourceType = this.getType(sourceNode);
@@ -3563,31 +3575,31 @@ class MatchWorker {
             .some((property) => this.#compiler.unescapeLeadingUnderscores(property.escapedName) === propertyNameText);
     }
     checkIsAssignableTo(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.assignable;
+        const relation = this.typeChecker.relation.assignable;
         return this.#checkIsRelatedTo(sourceNode, targetNode, relation);
     }
     checkIsAssignableWith(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.assignable;
+        const relation = this.typeChecker.relation.assignable;
         return this.#checkIsRelatedTo(targetNode, sourceNode, relation);
     }
     checkIsIdenticalTo(sourceNode, targetNode) {
-        const relation = this.#typeChecker.relation.identity;
+        const relation = this.typeChecker.relation.identity;
         return (this.#checkIsRelatedTo(sourceNode, targetNode, relation) &&
             this.checkIsAssignableTo(sourceNode, targetNode) &&
             this.checkIsAssignableWith(sourceNode, targetNode));
     }
     #checkIsRelatedTo(sourceNode, targetNode, relation) {
-        const sourceType = relation === this.#typeChecker.relation.identity
+        const sourceType = relation === this.typeChecker.relation.identity
             ? this.#simplifyType(this.getType(sourceNode))
             : this.getType(sourceNode);
-        const targetType = relation === this.#typeChecker.relation.identity
+        const targetType = relation === this.typeChecker.relation.identity
             ? this.#simplifyType(this.getType(targetNode))
             : this.getType(targetNode);
-        return this.#typeChecker.isTypeRelatedTo(sourceType, targetType, relation);
+        return this.typeChecker.isTypeRelatedTo(sourceType, targetType, relation);
     }
     extendsObjectType(type) {
         const nonPrimitiveType = { flags: this.#compiler.TypeFlags.NonPrimitive };
-        return this.#typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
+        return this.typeChecker.isTypeAssignableTo(type, nonPrimitiveType);
     }
     getParameterType(signature, index) {
         const parameter = signature.getDeclaration().parameters[index];
@@ -3608,23 +3620,10 @@ class MatchWorker {
         return signatures;
     }
     getTypeText(node) {
-        const type = this.getType(node);
-        return this.#typeChecker.typeToString(type);
+        return this.typeChecker.typeToString(this.getType(node));
     }
     getType(node) {
-        return this.#typeChecker.getTypeAtLocation(node);
-    }
-    isStringOrNumberLiteralType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
-    }
-    isObjectType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.Object);
-    }
-    isUnionType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.Union);
-    }
-    isUniqueSymbolType(type) {
-        return !!(type.flags & this.#compiler.TypeFlags.UniqueESSymbol);
+        return this.typeChecker.getTypeAtLocation(node);
     }
     resolveDiagnosticOrigin(symbol, enclosingNode) {
         if (symbol.valueDeclaration != null &&
@@ -3640,7 +3639,7 @@ class MatchWorker {
     #simplifyType(type) {
         if (type.isUnionOrIntersection()) {
             const candidateType = this.#simplifyType(type.types[0]);
-            if (type.types.every((type) => this.#typeChecker.isTypeRelatedTo(this.#simplifyType(type), candidateType, this.#typeChecker.relation.identity))) {
+            if (type.types.every((type) => this.typeChecker.isTypeRelatedTo(this.#simplifyType(type), candidateType, this.typeChecker.relation.identity))) {
                 return candidateType;
             }
         }
@@ -3648,6 +3647,16 @@ class MatchWorker {
     }
 }
 
+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;
@@ -3681,7 +3690,7 @@ class ToAcceptProps {
     #isOptionalProperty(symbol) {
         return symbol.declarations?.every((declaration) => this.#compiler.isPropertySignature(declaration) && declaration.questionToken != null);
     }
-    #checkProperties(matchWorker, sourceType, targetType) {
+    #checkProperties(sourceType, targetType) {
         const check = (sourceType, targetType) => {
             for (const targetProperty of targetType.getProperties()) {
                 const targetPropertyName = targetProperty.getName();
@@ -3709,7 +3718,7 @@ class ToAcceptProps {
             }
             return true;
         };
-        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             return sourceType.types.some((sourceType) => check(sourceType, targetType));
         }
         return check(sourceType, targetType);
@@ -3777,7 +3786,7 @@ class ToAcceptProps {
             }
             return { diagnostics, isMatch: false };
         };
-        if (sourceType != null && matchWorker.isUnionType(sourceType)) {
+        if (sourceType != null && isUnionType(this.#compiler, sourceType)) {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertion.isNot
@@ -3808,7 +3817,7 @@ class ToAcceptProps {
             diagnostics.push(Diagnostic.error(text, origin));
         }
         const targetType = matchWorker.getType(targetNode);
-        if (!matchWorker.isObjectType(targetType)) {
+        if (!(targetType.flags & this.#compiler.TypeFlags.Object)) {
             const expectedText = "of an object type";
             const text = this.#compiler.isTypeNode(targetNode)
                 ? ExpectDiagnosticText.typeArgumentMustBe("Target", expectedText)
@@ -3822,7 +3831,7 @@ class ToAcceptProps {
         }
         const isMatch = signatures.some((signature) => {
             const sourceType = matchWorker.getParameterType(signature, 0);
-            return this.#checkProperties(matchWorker, sourceType, targetType);
+            return this.#checkProperties(sourceType, targetType);
         });
         return {
             explain: () => this.#explain(matchWorker, sourceNode, targetNode),
@@ -3890,12 +3899,7 @@ class ToBeApplicable {
         const diagnostics = [];
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
-                const text = [
-                    ExpectDiagnosticText.cannotBeApplied(targetText),
-                    typeof diagnostic.messageText === "string"
-                        ? diagnostic.messageText
-                        : Diagnostic.toMessageText(diagnostic.messageText),
-                ];
+                const text = [ExpectDiagnosticText.cannotBeApplied(targetText), getDiagnosticMessageText(diagnostic)];
                 const origin = DiagnosticOrigin.fromNode(sourceNode);
                 diagnostics.push(Diagnostic.error(text.flat(), origin));
             }
@@ -3951,8 +3955,83 @@ class ToBeCallableWith {
     constructor(compiler) {
         this.#compiler = compiler;
     }
-    isDiagnosticWithLocation(diagnostic) {
-        return diagnostic.start != null;
+    #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 isTypeNode = this.#compiler.isTypeNode(sourceNode);
+        const targetText = this.#resolveTargetText(targetNodes);
+        const diagnostics = [];
+        if (matchWorker.assertion.abilityDiagnostics) {
+            for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
+                const text = [ExpectDiagnosticText.isNotCallable(isTypeNode, 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.isCallable(isTypeNode, targetText), origin));
+        }
+        return diagnostics;
+    }
+    match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
+        let type;
+        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)) {
+            type = matchWorker.getType(sourceNode);
+        }
+        if (!type || type.getCallSignatures().length === 0) {
+            const text = [];
+            if (this.#compiler.isTypeNode(sourceNode)) {
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a callable type"));
+            }
+            else {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a callable expression"));
+            }
+            if (type != null && type.getConstructSignatures().length > 0) {
+                text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeConstructableWith()' matcher"));
+            }
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
+class ToBeConstructableWith {
+    #compiler;
+    constructor(compiler) {
+        this.#compiler = compiler;
     }
     #resolveTargetText(nodes) {
         if (nodes.length === 0) {
@@ -3970,16 +4049,12 @@ class ToBeCallableWith {
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
                 const text = [
-                    ExpectDiagnosticText.cannotBeCalled(isTypeNode, targetText),
-                    typeof diagnostic.messageText === "string"
-                        ? diagnostic.messageText
-                        : Diagnostic.toMessageText(diagnostic.messageText),
+                    ExpectDiagnosticText.isNotConstructable(isTypeNode, targetText),
+                    getDiagnosticMessageText(diagnostic),
                 ];
                 let origin;
-                if (this.isDiagnosticWithLocation(diagnostic) &&
-                    diagnostic.start >= targetNodes.pos &&
-                    diagnostic.start <= targetNodes.end) {
-                    origin = new DiagnosticOrigin(diagnostic.start, diagnostic.start + diagnostic.length, sourceNode.getSourceFile());
+                if (isDiagnosticWithLocation(diagnostic) && diagnosticBelongsToNode(diagnostic, targetNodes)) {
+                    origin = new DiagnosticOrigin(diagnostic.start, getTextSpanEnd(diagnostic), sourceNode.getSourceFile());
                 }
                 else {
                     origin =
@@ -3996,23 +4071,30 @@ class ToBeCallableWith {
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeCalled(isTypeNode, targetText), origin));
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.isConstructable(isTypeNode, targetText), origin));
         }
         return diagnostics;
     }
     match(matchWorker, sourceNode, targetNodes, onDiagnostics) {
-        let mustBeText;
-        if (!(sourceNode.kind === this.#compiler.SyntaxKind.Identifier ||
-            sourceNode.kind === this.#compiler.SyntaxKind.ExpressionWithTypeArguments)) {
-            mustBeText = "an identifier or instantiation expression";
-        }
-        if (matchWorker.getType(sourceNode).getCallSignatures().length === 0) {
-            mustBeText = "of a function type";
-        }
-        if (mustBeText != null) {
-            const text = this.#compiler.isTypeNode(sourceNode)
-                ? ExpectDiagnosticText.typeArgumentMustBe("Source", mustBeText)
-                : ExpectDiagnosticText.argumentMustBe("source", mustBeText);
+        let type;
+        if (this.#compiler.isCallExpression(sourceNode)) {
+            type = matchWorker.typeChecker.getResolvedSignature(sourceNode)?.getReturnType();
+        }
+        if (this.#compiler.isExpressionWithTypeArguments(sourceNode) ||
+            this.#compiler.isIdentifier(sourceNode)) {
+            type = matchWorker.getType(sourceNode);
+        }
+        if (!type || type.getConstructSignatures().length === 0) {
+            const text = [];
+            if (this.#compiler.isTypeNode(sourceNode)) {
+                text.push(ExpectDiagnosticText.typeArgumentMustBe("Source", "a constructable type"));
+            }
+            else {
+                text.push(ExpectDiagnosticText.argumentMustBe("source", "a constructable expression"));
+            }
+            if (type != null && type.getCallSignatures().length > 0) {
+                text.push(ExpectDiagnosticText.didYouMeanToUse("the '.toBeCallableWith()' matcher"));
+            }
             const origin = DiagnosticOrigin.fromNode(sourceNode);
             onDiagnostics([Diagnostic.error(text, origin)]);
             return;
@@ -4033,7 +4115,7 @@ class ToHaveProperty {
         const sourceTypeText = matchWorker.getTypeText(sourceNode);
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText;
-        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+        if (isStringOrNumberLiteralType(this.#compiler, targetType)) {
             propertyNameText = targetType.value.toString();
         }
         else {
@@ -4058,10 +4140,10 @@ class ToHaveProperty {
         }
         const targetType = matchWorker.getType(targetNode);
         let propertyNameText = "";
-        if (matchWorker.isStringOrNumberLiteralType(targetType)) {
+        if (isStringOrNumberLiteralType(this.#compiler, targetType)) {
             propertyNameText = targetType.value.toString();
         }
-        else if (matchWorker.isUniqueSymbolType(targetType)) {
+        else if (isUniqueSymbolType(this.#compiler, targetType)) {
             propertyNameText = this.#compiler.unescapeLeadingUnderscores(targetType.escapedName);
         }
         else {
@@ -4155,9 +4237,10 @@ class ToRaiseError {
         if (this.#compiler.isNumericLiteral(targetNode)) {
             return Number.parseInt(targetNode.text, 10) === diagnostic.code;
         }
-        const messageText = typeof diagnostic.messageText === "string"
-            ? diagnostic.messageText
-            : Diagnostic.toMessageText(diagnostic.messageText).join("\n");
+        let messageText = getDiagnosticMessageText(diagnostic);
+        if (Array.isArray(messageText)) {
+            messageText = messageText.join("\n");
+        }
         if (this.#compiler.isRegularExpressionLiteral(targetNode)) {
             const targetRegex = new RegExp(...targetNode.text.slice(1).split("/"));
             return targetRegex.test(messageText);
@@ -4176,6 +4259,7 @@ class ExpectService {
     toBeAssignableTo;
     toBeAssignableWith;
     toBeCallableWith;
+    toBeConstructableWith;
     toHaveProperty;
     toRaiseError;
     constructor(compiler, typeChecker, resolvedConfig) {
@@ -4193,6 +4277,7 @@ class ExpectService {
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
         this.toBeCallableWith = new ToBeCallableWith(compiler);
+        this.toBeConstructableWith = new ToBeConstructableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
@@ -4220,6 +4305,7 @@ class ExpectService {
             case "toBeApplicable":
                 return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
             case "toBeCallableWith":
+            case "toBeConstructableWith":
             case "toRaiseError":
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
             case "toHaveProperty":
@@ -4507,7 +4593,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.2";
+    static version = "4.0.0-beta.4";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4709,4 +4795,4 @@ class Cli {
     }
 }
 
-export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticText, environmentOptions, fileViewText, formattedText, helpText, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };
+export { AssertionNode, BaseReporter, CancellationHandler, CancellationReason, CancellationToken, Cli, CollectService, Color, Config, ConfigDiagnosticText, DescribeResult, Diagnostic, DiagnosticCategory, DiagnosticOrigin, EventEmitter, ExitCodeHandler, ExpectResult, ExpectService, FileWatcher, InputService, Line, ListReporter, OptionBrand, OptionGroup, Options, OutputService, Path, PluginService, ProjectResult, ProjectService, Result, ResultCount, ResultHandler, ResultStatus, ResultTiming, Runner, Scribbler, Select, SelectDiagnosticText, SetupReporter, SourceFile, Store, SummaryReporter, TargetResult, Task, TaskResult, TestResult, TestTree, TestTreeHandler, TestTreeNode, TestTreeNodeBrand, TestTreeNodeFlags, Text, Version, WatchReporter, WatchService, Watcher, addsPackageText, defaultOptions, describeNameText, diagnosticBelongsToNode, diagnosticText, environmentOptions, fileViewText, formattedText, getDiagnosticMessageText, getTextSpanEnd, helpText, isDiagnosticWithLocation, summaryText, taskStatusText, testNameText, usesCompilerText, waitingForFileChangesText, watchUsageText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-beta.2",
+  "version": "4.0.0-beta.4",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -62,14 +62,14 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.2",
-    "@types/node": "22.14.0",
-    "@types/react": "19.1.0",
+    "@types/node": "22.14.1",
+    "@types/react": "19.1.1",
     "ajv": "8.17.1",
     "cspell": "8.18.1",
     "magic-string": "0.30.17",
     "monocart-coverage-reports": "2.12.3",
     "pretty-ansi": "3.0.0",
-    "rollup": "4.39.0",
+    "rollup": "4.40.0",
     "rollup-plugin-dts": "6.2.1",
     "tslib": "2.8.1",
     "typescript": "5.8.3"