tstyche 4.0.0-beta.1 → 4.0.0-beta.2

package/README.md

@@ -18,14 +18,18 @@ If you are used to test JavaScript, a simple type test file should look familiar
 ```ts
 import { expect, test } from "tstyche";
 
-function firstItem<T>(target: Array<T>): T | undefined {
-  return target[0];
+function pickLonger<T extends { length: number }>(a: T, b: T) {
+  return a.length >= b.length ? a : b;
 }
 
-test("firstItem", () => {
-  expect(firstItem(["a", "b", "c"])).type.toBe<string | undefined>();
+test("pickLonger()", () => {
+  expect(pickLonger([1, 2], [1, 2, 3])).type.toBe<Array<number>>();
+  expect(pickLonger("two", "three")).type.toBe<"two" | "three">();
 
-  expect(firstItem()).type.toRaiseError("Expected 1 argument");
+  expect(pickLonger).type.not.toBeCallableWith(1, 2);
+
+  expect(pickLonger).type.not.toBeCallableWith("zero", [123]);
+  expect(pickLonger<string | Array<number>>).type.toBeCallableWith("zero", [123]);
 });
 ```
 
@@ -59,6 +63,7 @@ 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,
 - `.toHaveProperty()` looks up keys on an object type,
 - `.toRaiseError()` captures the message or code of a type error.
 

package/build/index.d.cts

@@ -127,6 +127,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type can be called with the target arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/index.d.ts

@@ -127,6 +127,10 @@ interface Matchers {
          */
         (target: unknown): void;
     };
+    /**
+     * Checks if the source type can be called with the target arguments.
+     */
+    toBeCallableWith: (...target: Array<unknown>) => void;
     /**
      * Checks if a property key exists on the source type.
      */

package/build/tstyche.d.ts

@@ -45,6 +45,7 @@ declare class DiagnosticOrigin {
     constructor(start: number, end: number, sourceFile: SourceFile | ts.SourceFile, assertion?: AssertionNode);
     static fromAssertion(assertion: AssertionNode): DiagnosticOrigin;
     static fromNode(node: ts.Node, assertion?: AssertionNode): DiagnosticOrigin;
+    static fromNodes(nodes: ts.NodeArray<ts.Node>, assertion?: AssertionNode): DiagnosticOrigin;
 }
 
 declare class Diagnostic {
@@ -324,7 +325,7 @@ declare const defaultOptions: Required<ConfigFileOptions>;
 
 declare class ProjectService {
     #private;
-    constructor(resolvedConfig: ResolvedConfig, compiler: typeof ts);
+    constructor(compiler: typeof ts, resolvedConfig: ResolvedConfig);
     closeFile(filePath: string): void;
     getDefaultProject(filePath: string): ts.server.Project | undefined;
     getLanguageService(filePath: string): ts.LanguageService | undefined;
@@ -602,6 +603,7 @@ declare class ExpectService {
     private toBeApplicable;
     private toBeAssignableTo;
     private toBeAssignableWith;
+    private toBeCallableWith;
     private toHaveProperty;
     private toRaiseError;
     constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig: ResolvedConfig);

package/build/tstyche.js

@@ -99,6 +99,9 @@ class DiagnosticOrigin {
     static fromNode(node, assertion) {
         return new DiagnosticOrigin(node.getStart(), node.getEnd(), node.getSourceFile(), assertion);
     }
+    static fromNodes(nodes, assertion) {
+        return new DiagnosticOrigin(nodes.pos, nodes.end, nodes[0].getSourceFile(), assertion);
+    }
 }
 
 class Diagnostic {
@@ -2010,11 +2013,12 @@ class AbilityLayer {
             return " ".repeat(range.end - range.start);
         }
         const text = [];
-        for (let i = range.start; i < range.end; i++) {
-            switch (this.#text.charAt(i)) {
+        for (let index = range.start; index < range.end; index++) {
+            const character = this.#text.charAt(index);
+            switch (character) {
                 case "\n":
                 case "\r":
-                    text.push(this.#text.charAt(i));
+                    text.push(character);
                     break;
                 default:
                     text.push(" ");
@@ -2033,19 +2037,18 @@ class AbilityLayer {
         if (this.#nodes.length > 0) {
             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)?.toReversed());
-            if (diagnostics.size > 0) {
-                for (const node of this.#nodes.toReversed()) {
-                    for (const diagnostic of diagnostics) {
-                        if (diagnostic.start != null &&
-                            diagnostic.start >= node.matcherNode.pos &&
-                            diagnostic.start <= node.matcherNode.end) {
-                            if (!node.abilityDiagnostics) {
-                                node.abilityDiagnostics = new Set();
-                            }
-                            node.abilityDiagnostics.add(diagnostic);
-                            diagnostics.delete(diagnostic);
+            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) {
+                        if (!node.abilityDiagnostics) {
+                            node.abilityDiagnostics = new Set();
                         }
+                        node.abilityDiagnostics.add(diagnostic);
+                        diagnostics.delete(diagnostic);
                     }
                 }
             }
@@ -2067,6 +2070,17 @@ class AbilityLayer {
                 ]);
                 break;
             }
+            case "toBeCallableWith": {
+                const expectStart = assertionNode.node.pos;
+                const expectExpressionEnd = assertionNode.node.expression.end;
+                const expectEnd = assertionNode.node.end;
+                const matcherNameEnd = assertionNode.matcherNameNode.end;
+                this.#addRanges(assertionNode, [
+                    { end: expectExpressionEnd + 1, start: expectStart },
+                    { end: matcherNameEnd, start: expectEnd - 1 },
+                ]);
+                break;
+            }
         }
     }
     open(sourceFile) {
@@ -3284,9 +3298,9 @@ class ProjectService {
     #resolvedConfig;
     #seenPrograms = new WeakSet();
     #service;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
+    constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
+        this.#resolvedConfig = resolvedConfig;
         const noop = () => undefined;
         const noopLogger = {
             close: noop,
@@ -3434,17 +3448,29 @@ class ExpectDiagnosticText {
     static argumentMustBeProvided(argumentNameText) {
         return `An argument for '${argumentNameText}' must be provided.`;
     }
-    static componentAcceptsProps(isTypeNode) {
+    static canBeCalled(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} can be called ${targetText}.`;
+    }
+    static cannotBeCalled(isTypeNode, targetText) {
+        return `${isTypeNode ? "Type" : "Expression"} cannot be called ${targetText}.`;
+    }
+    static acceptsProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} accepts props of the given type.`;
     }
-    static componentDoesNotAcceptProps(isTypeNode) {
+    static doesNotAcceptProps(isTypeNode) {
         return `${isTypeNode ? "Component type" : "Component"} does not accept props of the given type.`;
     }
-    static decoratorCanBeApplied(targetText) {
+    static canBeApplied(targetText) {
         return `The decorator function can be applied${targetText}.`;
     }
-    static decoratorCanNotBeApplied(targetText) {
-        return `The decorator function can not be applied${targetText}.`;
+    static cannotBeApplied(targetText) {
+        return `The decorator function cannot be applied${targetText}.`;
+    }
+    static doesNotHaveProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    }
+    static hasProperty(typeText, propertyNameText) {
+        return `Type '${typeText}' has property '${propertyNameText}'.`;
     }
     static matcherIsNotSupported(matcherNameText) {
         return `The '.${matcherNameText}()' matcher is not supported.`;
@@ -3461,50 +3487,44 @@ class ExpectDiagnosticText {
     static typeArgumentMustBe(argumentNameText, expectedText) {
         return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
-    static typeDidNotRaiseError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
+    static raisedError(isTypeNode, count, targetCount) {
+        let countText = "a";
+        if (count > 1 || targetCount > 1) {
+            countText = count > targetCount ? `${count}` : `only ${count}`;
+        }
+        return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
     }
-    static typeDidNotRaiseMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
+    static didNotRaiseError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a type error.`;
     }
-    static typeDoesNotHaveProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' does not have property '${propertyNameText}'.`;
+    static raisedMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
     }
-    static typeHasProperty(typeText, propertyNameText) {
-        return `Type '${typeText}' has property '${propertyNameText}'.`;
+    static didNotRaiseMatchingError(isTypeNode) {
+        return `${isTypeNode ? "Type" : "Expression type"} did not raise a matching type error.`;
     }
-    static typeIsAssignableTo(sourceTypeText, targetTypeText) {
+    static isAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is assignable to type '${targetTypeText}'.`;
     }
-    static typeIsAssignableWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
-    }
-    static typeIsIdenticalTo(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
-    }
-    static typeIsNotAssignableTo(sourceTypeText, targetTypeText) {
+    static isNotAssignableTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable to type '${targetTypeText}'.`;
     }
-    static typeIsNotAssignableWith(sourceTypeText, targetTypeText) {
+    static isAssignableWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is assignable with type '${targetTypeText}'.`;
+    }
+    static isNotAssignableWith(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not assignable with type '${targetTypeText}'.`;
     }
-    static typeIsNotCompatibleWith(sourceTypeText, targetTypeText) {
-        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
+    static isIdenticalTo(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is identical to type '${targetTypeText}'.`;
     }
-    static typeIsNotIdenticalTo(sourceTypeText, targetTypeText) {
+    static isNotIdenticalTo(sourceTypeText, targetTypeText) {
         return `Type '${sourceTypeText}' is not identical to type '${targetTypeText}'.`;
     }
-    static typeRaisedError(isTypeNode, count, targetCount) {
-        let countText = "a";
-        if (count > 1 || targetCount > 1) {
-            countText = count > targetCount ? `${count}` : `only ${count}`;
-        }
-        return `${isTypeNode ? "Type" : "Expression type"} raised ${countText} type error${count === 1 ? "" : "s"}.`;
-    }
-    static typeRaisedMatchingError(isTypeNode) {
-        return `${isTypeNode ? "Type" : "Expression type"} raised a matching type error.`;
+    static isNotCompatibleWith(sourceTypeText, targetTypeText) {
+        return `Type '${sourceTypeText}' is not compatible with type '${targetTypeText}'.`;
     }
-    static typeRequiresProperty(typeText, propertyNameText) {
+    static requiresProperty(typeText, propertyNameText) {
         return `Type '${typeText}' requires property '${propertyNameText}'.`;
     }
     static typesOfPropertyAreNotCompatible(propertyNameText) {
@@ -3523,7 +3543,6 @@ class MatchWorker {
     assertion;
     #compiler;
     #signatureCache = new Map();
-    #typeCache = new Map();
     #typeChecker;
     constructor(compiler, typeChecker, assertion) {
         this.#compiler = compiler;
@@ -3575,7 +3594,7 @@ class MatchWorker {
         if (!parameter) {
             return;
         }
-        return this.#getTypeOfNode(parameter);
+        return this.getType(parameter);
     }
     getSignatures(node) {
         let signatures = this.#signatureCache.get(node);
@@ -3593,21 +3612,7 @@ class MatchWorker {
         return this.#typeChecker.typeToString(type);
     }
     getType(node) {
-        return this.#compiler.isTypeNode(node) ? this.#getTypeOfTypeNode(node) : this.#getTypeOfNode(node);
-    }
-    #getTypeOfNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeAtLocation(node);
-        }
-        return type;
-    }
-    #getTypeOfTypeNode(node) {
-        let type = this.#typeCache.get(node);
-        if (!type) {
-            type = this.#typeChecker.getTypeFromTypeNode(node);
-        }
-        return type;
+        return this.#typeChecker.getTypeAtLocation(node);
     }
     isStringOrNumberLiteralType(type) {
         return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
@@ -3655,8 +3660,8 @@ class ToAcceptProps {
         return signatures.reduce((accumulator, signature, index) => {
             let diagnostic;
             const introText = matchWorker.assertion.isNot
-                ? ExpectDiagnosticText.componentAcceptsProps(this.#compiler.isTypeNode(sourceNode))
-                : ExpectDiagnosticText.componentDoesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
+                ? ExpectDiagnosticText.acceptsProps(this.#compiler.isTypeNode(sourceNode))
+                : ExpectDiagnosticText.doesNotAcceptProps(this.#compiler.isTypeNode(sourceNode));
             const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
             if (signatures.length > 1) {
                 const signatureText = this.#typeChecker.signatureToString(signature, sourceNode);
@@ -3722,8 +3727,8 @@ class ToAcceptProps {
                 const sourceProperty = sourceType?.getProperty(targetPropertyName);
                 if (!sourceProperty) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotCompatibleWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotCompatibleWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3731,8 +3736,8 @@ class ToAcceptProps {
                 }
                 if (this.#isOptionalProperty(targetProperty) && !this.#isOptionalProperty(sourceProperty)) {
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                        ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, targetPropertyName),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.requiresProperty(sourceTypeText, targetPropertyName),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3744,9 +3749,9 @@ class ToAcceptProps {
                     const targetPropertyTypeText = this.#typeChecker.typeToString(targetPropertyType);
                     const sourcePropertyTypeText = this.#typeChecker.typeToString(sourcePropertyType);
                     const text = [
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
                         ExpectDiagnosticText.typesOfPropertyAreNotCompatible(targetPropertyName),
-                        ExpectDiagnosticText.typeIsNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
+                        ExpectDiagnosticText.isNotAssignableWith(sourcePropertyTypeText, targetPropertyTypeText),
                     ];
                     const origin = matchWorker.resolveDiagnosticOrigin(targetProperty, targetNode);
                     diagnostics.push(diagnostic.extendWith(text, origin));
@@ -3758,15 +3763,15 @@ class ToAcceptProps {
                     const targetProperty = targetType.getProperty(sourcePropertyName);
                     if (!targetProperty && !this.#isOptionalProperty(sourceProperty)) {
                         const text = [
-                            ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText),
-                            ExpectDiagnosticText.typeRequiresProperty(sourceTypeText, sourcePropertyName),
+                            ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText),
+                            ExpectDiagnosticText.requiresProperty(sourceTypeText, sourcePropertyName),
                         ];
                         diagnostics.push(diagnostic.extendWith(text));
                     }
                 }
             }
             if (diagnostics.length === 0) {
-                const text = ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText);
+                const text = ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText);
                 diagnostics.push(diagnostic.extendWith(text));
                 return { diagnostics, isMatch: true };
             }
@@ -3776,8 +3781,8 @@ class ToAcceptProps {
             let accumulator = [];
             const isMatch = sourceType.types.some((sourceType) => {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeIsAssignableWith(sourceTypeText, targetTypeText)
-                    : ExpectDiagnosticText.typeIsNotAssignableWith(sourceTypeText, targetTypeText);
+                    ? ExpectDiagnosticText.isAssignableWith(sourceTypeText, targetTypeText)
+                    : ExpectDiagnosticText.isNotAssignableWith(sourceTypeText, targetTypeText);
                 const { diagnostics, isMatch } = explain(sourceType, targetType, diagnostic.extendWith(text));
                 if (isMatch) {
                     accumulator = diagnostics;
@@ -3839,8 +3844,8 @@ class RelationMatcherBase {
 }
 
 class ToBe extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsIdenticalTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotIdenticalTo;
+    explainText = ExpectDiagnosticText.isIdenticalTo;
+    explainNotText = ExpectDiagnosticText.isNotIdenticalTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3886,7 +3891,7 @@ class ToBeApplicable {
         if (matchWorker.assertion.abilityDiagnostics) {
             for (const diagnostic of matchWorker.assertion.abilityDiagnostics) {
                 const text = [
-                    ExpectDiagnosticText.decoratorCanNotBeApplied(targetText),
+                    ExpectDiagnosticText.cannotBeApplied(targetText),
                     typeof diagnostic.messageText === "string"
                         ? diagnostic.messageText
                         : Diagnostic.toMessageText(diagnostic.messageText),
@@ -3897,7 +3902,7 @@ class ToBeApplicable {
         }
         else {
             const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
-            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.decoratorCanBeApplied(targetText), origin));
+            diagnostics.push(Diagnostic.error(ExpectDiagnosticText.canBeApplied(targetText), origin));
         }
         return diagnostics;
     }
@@ -3920,8 +3925,8 @@ class ToBeApplicable {
 }
 
 class ToBeAssignableTo extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableTo;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableTo;
+    explainText = ExpectDiagnosticText.isAssignableTo;
+    explainNotText = ExpectDiagnosticText.isNotAssignableTo;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3931,8 +3936,8 @@ class ToBeAssignableTo extends RelationMatcherBase {
 }
 
 class ToBeAssignableWith extends RelationMatcherBase {
-    explainText = ExpectDiagnosticText.typeIsAssignableWith;
-    explainNotText = ExpectDiagnosticText.typeIsNotAssignableWith;
+    explainText = ExpectDiagnosticText.isAssignableWith;
+    explainNotText = ExpectDiagnosticText.isNotAssignableWith;
     match(matchWorker, sourceNode, targetNode) {
         return {
             explain: () => this.explain(matchWorker, sourceNode, targetNode),
@@ -3941,6 +3946,84 @@ class ToBeAssignableWith extends RelationMatcherBase {
     }
 }
 
+class ToBeCallableWith {
+    #compiler;
+    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.cannotBeCalled(isTypeNode, targetText),
+                    typeof diagnostic.messageText === "string"
+                        ? diagnostic.messageText
+                        : Diagnostic.toMessageText(diagnostic.messageText),
+                ];
+                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());
+                }
+                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.canBeCalled(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);
+            const origin = DiagnosticOrigin.fromNode(sourceNode);
+            onDiagnostics([Diagnostic.error(text, origin)]);
+            return;
+        }
+        return {
+            explain: () => this.#explain(matchWorker, sourceNode, targetNodes),
+            isMatch: !matchWorker.assertion.abilityDiagnostics,
+        };
+    }
+}
+
 class ToHaveProperty {
     #compiler;
     constructor(compiler) {
@@ -3958,8 +4041,8 @@ class ToHaveProperty {
         }
         const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
         return matchWorker.assertion.isNot
-            ? [Diagnostic.error(ExpectDiagnosticText.typeHasProperty(sourceTypeText, propertyNameText), origin)]
-            : [Diagnostic.error(ExpectDiagnosticText.typeDoesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
+            ? [Diagnostic.error(ExpectDiagnosticText.hasProperty(sourceTypeText, propertyNameText), origin)]
+            : [Diagnostic.error(ExpectDiagnosticText.doesNotHaveProperty(sourceTypeText, propertyNameText), origin)];
     }
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
@@ -4009,12 +4092,12 @@ class ToRaiseError {
         const isTypeNode = this.#compiler.isTypeNode(sourceNode);
         const origin = DiagnosticOrigin.fromAssertion(matchWorker.assertion);
         if (matchWorker.assertion.diagnostics.size === 0) {
-            const text = ExpectDiagnosticText.typeDidNotRaiseError(isTypeNode);
+            const text = ExpectDiagnosticText.didNotRaiseError(isTypeNode);
             return [Diagnostic.error(text, origin)];
         }
         if (matchWorker.assertion.diagnostics.size !== targetNodes.length) {
             const count = matchWorker.assertion.diagnostics.size;
-            const text = ExpectDiagnosticText.typeRaisedError(isTypeNode, count, targetNodes.length);
+            const text = ExpectDiagnosticText.raisedError(isTypeNode, count, targetNodes.length);
             const related = [
                 Diagnostic.error(ExpectDiagnosticText.raisedTypeError(count)),
                 ...Diagnostic.fromDiagnostics([...matchWorker.assertion.diagnostics]),
@@ -4026,8 +4109,8 @@ class ToRaiseError {
             const isMatch = this.#matchExpectedError(diagnostic, targetNode);
             if (matchWorker.assertion.isNot ? isMatch : !isMatch) {
                 const text = matchWorker.assertion.isNot
-                    ? ExpectDiagnosticText.typeRaisedMatchingError(isTypeNode)
-                    : ExpectDiagnosticText.typeDidNotRaiseMatchingError(isTypeNode);
+                    ? ExpectDiagnosticText.raisedMatchingError(isTypeNode)
+                    : ExpectDiagnosticText.didNotRaiseMatchingError(isTypeNode);
                 const origin = DiagnosticOrigin.fromNode(targetNode, matchWorker.assertion);
                 const related = [
                     Diagnostic.error(ExpectDiagnosticText.raisedTypeError()),
@@ -4092,6 +4175,7 @@ class ExpectService {
     toBeApplicable;
     toBeAssignableTo;
     toBeAssignableWith;
+    toBeCallableWith;
     toHaveProperty;
     toRaiseError;
     constructor(compiler, typeChecker, resolvedConfig) {
@@ -4108,6 +4192,7 @@ class ExpectService {
         this.toBeApplicable = new ToBeApplicable(compiler);
         this.toBeAssignableTo = new ToBeAssignableTo();
         this.toBeAssignableWith = new ToBeAssignableWith();
+        this.toBeCallableWith = new ToBeCallableWith(compiler);
         this.toHaveProperty = new ToHaveProperty(compiler);
         this.toRaiseError = new ToRaiseError(compiler);
     }
@@ -4134,14 +4219,15 @@ class ExpectService {
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             case "toBeApplicable":
                 return this.toBeApplicable.match(matchWorker, assertion.source[0], onDiagnostics);
+            case "toBeCallableWith":
+            case "toRaiseError":
+                return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target, onDiagnostics);
             case "toHaveProperty":
                 if (!assertion.target?.[0]) {
                     this.#onTargetArgumentMustBeProvided("key", assertion, onDiagnostics);
                     return;
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
-            case "toRaiseError":
-                return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
         }
@@ -4203,7 +4289,7 @@ class TestTreeWalker {
     #position;
     #resolvedConfig;
     #taskResult;
-    constructor(resolvedConfig, compiler, typeChecker, options) {
+    constructor(compiler, typeChecker, resolvedConfig, options) {
         this.#resolvedConfig = resolvedConfig;
         this.#cancellationToken = options.cancellationToken;
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
@@ -4349,14 +4435,14 @@ class TestTreeWalker {
 }
 
 class TaskRunner {
-    #compiler;
     #collectService;
+    #compiler;
     #resolvedConfig;
     #projectService;
-    constructor(resolvedConfig, compiler) {
-        this.#resolvedConfig = resolvedConfig;
+    constructor(compiler, resolvedConfig) {
         this.#compiler = compiler;
-        this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
+        this.#resolvedConfig = resolvedConfig;
+        this.#projectService = new ProjectService(compiler, this.#resolvedConfig);
         this.#collectService = new CollectService(compiler, this.#projectService, this.#resolvedConfig);
     }
     run(task, cancellationToken) {
@@ -4408,7 +4494,7 @@ class TaskRunner {
             return;
         }
         const typeChecker = program.getTypeChecker();
-        const testTreeWalker = new TestTreeWalker(this.#resolvedConfig, this.#compiler, typeChecker, {
+        const testTreeWalker = new TestTreeWalker(this.#compiler, typeChecker, this.#resolvedConfig, {
             cancellationToken,
             taskResult,
             hasOnly: testTree.hasOnly,
@@ -4421,7 +4507,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "4.0.0-beta.1";
+    static version = "4.0.0-beta.2";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4479,7 +4565,7 @@ class Runner {
             EventEmitter.dispatch(["target:start", { result: targetResult }]);
             const compiler = await Store.load(target);
             if (compiler) {
-                const taskRunner = new TaskRunner(this.#resolvedConfig, compiler);
+                const taskRunner = new TaskRunner(compiler, this.#resolvedConfig);
                 for (const task of tasks) {
                     taskRunner.run(task, cancellationToken);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.2",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -28,6 +28,8 @@
     "./package.json": "./package.json",
     "./tstyche": "./build/tstyche.js"
   },
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
   "bin": "./build/bin.js",
   "files": [
     "build/*"
@@ -80,7 +82,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.8.1",
+  "packageManager": "yarn@4.9.0",
   "engines": {
     "node": ">=20.9"
   }