tstyche 3.0.0 → 3.1.1

package/README.md

@@ -57,17 +57,17 @@ test("handles numbers", () => {
 Here is the list of all matchers:
 
 - `.toBe()`, `.toBeAssignableTo()`, `.toBeAssignableWith()` compare types or types of expression,
-- `.toAcceptProps()` checks types of JSX component's props,
+- `.toAcceptProps()` checks JSX component props type,
 - `.toHaveProperty()` looks up keys on an object type,
 - `.toRaiseError()` captures the type error message or code,
 - `.toBeString()`, `.toBeNumber()`, `.toBeVoid()` and 9 more shorthand checks for primitive types.
 
 ## Runner
 
-The `tstyche` command is the heart of TSTyche. For example, it can select test files by path, filter tests by name and pass them through TypeScript `4.8` and `latest`:
+The `tstyche` command is the heart of TSTyche. For example, it can select test files by path, filter tests by name and pass them through a range of TypeScript versions:
 
-```sh
-tstyche JsonObject --only external --target 4.8,latest
+```shell
+tstyche query-params --only multiple --target '>=5.0 <5.3'
 ```
 
 This simple! (And it has watch mode too.)

package/build/tstyche.d.ts

@@ -107,13 +107,13 @@ interface MatcherNode extends ts.CallExpression {
 }
 declare class Assertion extends TestMember {
     isNot: boolean;
+    matcherName: ts.MemberName;
     matcherNode: MatcherNode;
     modifierNode: ts.PropertyAccessExpression;
     notNode: ts.PropertyAccessExpression | undefined;
+    source: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
+    target: ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
     constructor(compiler: typeof ts, brand: TestMemberBrand, node: ts.CallExpression, parent: TestTree | TestMember, flags: TestMemberFlags, matcherNode: MatcherNode, modifierNode: ts.PropertyAccessExpression, notNode?: ts.PropertyAccessExpression);
-    get matcherName(): ts.MemberName;
-    get source(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
-    get target(): ts.NodeArray<ts.Expression> | ts.NodeArray<ts.TypeNode>;
 }
 
 declare class CollectService {
@@ -135,12 +135,15 @@ declare class ConfigDiagnosticText {
     static expectsListItemType(optionName: string, optionBrand: OptionBrand): string;
     static expectsValue(optionName: string): string;
     static fileDoesNotExist(filePath: string): string;
+    static inspectSupportedVersions(): string;
     static moduleWasNotFound(specifier: string): string;
+    static rangeIsNotValid(value: string): string;
+    static rangeUsage(): Array<string>;
+    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
     static seen(element: string): string;
     static testFileMatchCannotStartWith(segment: string): Array<string>;
-    static requiresValueType(optionName: string, optionBrand: OptionBrand): string;
     static unknownOption(optionName: string): string;
-    static usage(optionName: string, optionBrand: OptionBrand): Promise<Array<string>>;
+    static usage(optionName: string, optionBrand: OptionBrand): Array<string>;
     static versionIsNotSupported(value: string): string;
     static watchCannotBeEnabled(): string;
 }
@@ -157,6 +160,14 @@ interface ConfigFileOptions {
      * The list of plugins to use.
      */
     plugins?: Array<string>;
+    /**
+     * Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.
+     */
+    rejectAnyType?: boolean;
+    /**
+     * Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.
+     */
+    rejectNeverType?: boolean;
     /**
      * The list of reporters to use.
      */
@@ -199,6 +210,10 @@ interface CommandLineOptions {
      * Install specified versions of the 'typescript' package and exit.
      */
     install?: boolean;
+    /**
+     * Print the list of supported versions of the 'typescript' package and exit.
+     */
+    list?: boolean;
     /**
      * Print the list of the selected test files and exit.
      */
@@ -296,7 +311,6 @@ interface PrimitiveTypeOptionDefinition extends BaseOptionDefinition {
 interface ItemDefinition {
     brand: OptionBrand.String;
     name: string;
-    pattern?: string;
 }
 interface ListTypeOptionDefinition extends BaseOptionDefinition {
     brand: OptionBrand.List;
@@ -588,7 +602,7 @@ declare class ExpectService {
     private toHaveProperty;
     private toMatch;
     private toRaiseError;
-    constructor(compiler: typeof ts, typeChecker: TypeChecker);
+    constructor(compiler: typeof ts, typeChecker: TypeChecker, resolvedConfig?: ResolvedConfig);
     match(assertion: Assertion, onDiagnostics: DiagnosticsHandler<Diagnostic | Array<Diagnostic>>): MatchResult | undefined;
 }
 
@@ -779,8 +793,41 @@ declare class SelectDiagnosticText {
     static noTestFilesWereSelected(resolvedConfig: ResolvedConfig): Array<string>;
 }
 
+interface ManifestData {
+    $version?: string;
+    lastUpdated?: number;
+    npmRegistry: string;
+    packages: Record<string, {
+        integrity: string;
+        tarball: string;
+    }>;
+    resolutions: Record<string, string>;
+    versions: Array<string>;
+}
+declare class Manifest {
+    #private;
+    $version: string;
+    lastUpdated: number;
+    npmRegistry: string;
+    packages: Record<string, {
+        integrity: string;
+        tarball: string;
+    }>;
+    resolutions: Record<string, string>;
+    versions: Array<string>;
+    constructor(data: ManifestData);
+    isOutdated(options?: {
+        ageTolerance?: number;
+    }): boolean;
+    static parse(text: string): Manifest | undefined;
+    resolve(tag: string): string | undefined;
+    stringify(): string;
+}
+
 declare class Store {
     #private;
+    static manifest: Manifest | undefined;
+    /** @deprecated Use 'Store.manifest' directly. */
     static getSupportedTags(): Promise<Array<string> | undefined>;
     static install(tag: string): Promise<void>;
     static load(tag: string): Promise<typeof ts | undefined>;
@@ -794,6 +841,7 @@ declare class Version {
     #private;
     static isGreaterThan(source: string, target: string): boolean;
     static isSatisfiedWith(source: string, target: string): boolean;
+    /** @deprecated Name of this method is misleading and it is also not needed. */
     static isVersionTag(target: string): boolean;
 }
 

package/build/tstyche.js

@@ -1,13 +1,80 @@
+import { writeFileSync, rmSync, existsSync, watch } from 'node:fs';
 import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
+import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import vm from 'node:vm';
 import os from 'node:os';
 import process from 'node:process';
-import path from 'node:path';
-import { writeFileSync, rmSync, existsSync, watch } from 'node:fs';
+import { createRequire } from 'node:module';
+import vm from 'node:vm';
 import streamConsumers from 'node:stream/consumers';
 
+class ConfigDiagnosticText {
+    static expected(element) {
+        return `Expected ${element}.`;
+    }
+    static expectsListItemType(optionName, optionBrand) {
+        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
+    }
+    static expectsValue(optionName) {
+        return `Option '${optionName}' expects a value.`;
+    }
+    static fileDoesNotExist(filePath) {
+        return `The specified path '${filePath}' does not exist.`;
+    }
+    static inspectSupportedVersions() {
+        return "Use the '--list' command line option to inspect the list of supported versions.";
+    }
+    static moduleWasNotFound(specifier) {
+        return `The specified module '${specifier}' was not found.`;
+    }
+    static rangeIsNotValid(value) {
+        return `The specified range '${value}' is not valid.`;
+    }
+    static rangeUsage() {
+        return [
+            "A range must be specified using an operator and a minor version.",
+            "To set an upper bound, the intersection of two ranges can be used.",
+            "Examples: '>=5.5', '>=5.0 <5.3'.",
+        ];
+    }
+    static requiresValueType(optionName, optionBrand) {
+        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
+    }
+    static seen(element) {
+        return `The ${element} was seen here.`;
+    }
+    static testFileMatchCannotStartWith(segment) {
+        return [
+            `A test file match pattern cannot start with '${segment}'.`,
+            "The test files are only collected within the 'rootPath' directory.",
+        ];
+    }
+    static unknownOption(optionName) {
+        return `Unknown option '${optionName}'.`;
+    }
+    static usage(optionName, optionBrand) {
+        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
+            case "target": {
+                const text = [];
+                if (optionName.startsWith("--")) {
+                    text.push("Value for the '--target' option must be a string or a comma separated list.", "Examples: '--target 5.2', '--target next', '--target '>=5.0 <5.3, 5.4.2, >=5.5''.");
+                }
+                return text;
+            }
+        }
+        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
+    }
+    static versionIsNotSupported(value) {
+        if (value === "current") {
+            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
+        }
+        return `TypeScript version '${value}' is not supported.`;
+    }
+    static watchCannotBeEnabled() {
+        return "Watch mode cannot be enabled in continuous integration environment.";
+    }
+}
+
 class DiagnosticOrigin {
     assertion;
     end;
@@ -117,6 +184,49 @@ class SourceFile {
     }
 }
 
+class EventEmitter {
+    static instanceCount = 0;
+    static #handlers = new Map();
+    static #reporters = new Map();
+    #scope;
+    constructor() {
+        this.#scope = EventEmitter.instanceCount++;
+        EventEmitter.#handlers.set(this.#scope, new Set());
+        EventEmitter.#reporters.set(this.#scope, new Set());
+    }
+    addHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.add(handler);
+    }
+    addReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
+    }
+    static dispatch(event) {
+        function forEachHandler(handlers, event) {
+            for (const handler of handlers) {
+                handler.on(event);
+            }
+        }
+        for (const handlers of EventEmitter.#handlers.values()) {
+            forEachHandler(handlers, event);
+        }
+        for (const handlers of EventEmitter.#reporters.values()) {
+            forEachHandler(handlers, event);
+        }
+    }
+    removeHandler(handler) {
+        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
+    }
+    removeReporter(reporter) {
+        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
+    }
+    removeHandlers() {
+        EventEmitter.#handlers.get(this.#scope)?.clear();
+    }
+    removeReporters() {
+        EventEmitter.#reporters.get(this.#scope)?.clear();
+    }
+}
+
 class Path {
     static normalizeSlashes;
     static {
@@ -222,49 +332,6 @@ class Environment {
 
 const environmentOptions = Environment.resolve();
 
-class EventEmitter {
-    static instanceCount = 0;
-    static #handlers = new Map();
-    static #reporters = new Map();
-    #scope;
-    constructor() {
-        this.#scope = EventEmitter.instanceCount++;
-        EventEmitter.#handlers.set(this.#scope, new Set());
-        EventEmitter.#reporters.set(this.#scope, new Set());
-    }
-    addHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.add(handler);
-    }
-    addReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.add(reporter);
-    }
-    static dispatch(event) {
-        function forEachHandler(handlers, event) {
-            for (const handler of handlers) {
-                handler.on(event);
-            }
-        }
-        for (const handlers of EventEmitter.#handlers.values()) {
-            forEachHandler(handlers, event);
-        }
-        for (const handlers of EventEmitter.#reporters.values()) {
-            forEachHandler(handlers, event);
-        }
-    }
-    removeHandler(handler) {
-        EventEmitter.#handlers.get(this.#scope)?.delete(handler);
-    }
-    removeReporter(reporter) {
-        EventEmitter.#reporters.get(this.#scope)?.delete(reporter);
-    }
-    removeHandlers() {
-        EventEmitter.#handlers.get(this.#scope)?.clear();
-    }
-    removeReporters() {
-        EventEmitter.#reporters.get(this.#scope)?.clear();
-    }
-}
-
 class Version {
     static isGreaterThan(source, target) {
         return !(source === target) && Version.#satisfies(source, target);
@@ -465,6 +532,7 @@ class ManifestService {
     #manifestFilePath;
     #npmRegistry;
     #storePath;
+    #supportedVersionRegex = /^(4|5)\.\d\.\d$/;
     constructor(storePath, npmRegistry, fetcher) {
         this.#storePath = storePath;
         this.#npmRegistry = npmRegistry;
@@ -494,12 +562,12 @@ class ManifestService {
         const versions = [];
         const packageMetadata = (await response.json());
         for (const [tag, meta] of Object.entries(packageMetadata.versions)) {
-            if (/^(4|5)\.\d\.\d$/.test(tag)) {
+            if (this.#supportedVersionRegex.test(tag)) {
                 versions.push(tag);
                 packages[tag] = { integrity: meta.dist.integrity, tarball: meta.dist.tarball };
             }
         }
-        const minorVersions = [...new Set(versions.map((version) => version.slice(0, -2)))];
+        const minorVersions = new Set(versions.map((version) => version.slice(0, -2)));
         for (const tag of minorVersions) {
             const resolvedVersion = versions.findLast((version) => version.startsWith(tag));
             if (resolvedVersion != null) {
@@ -528,7 +596,7 @@ class ManifestService {
             await this.prune();
             return this.#create();
         }
-        if (manifest.isOutdated() || options?.refresh === true) {
+        if (manifest.isOutdated() || options?.refresh) {
             const freshManifest = await this.#load({ suppressErrors: !options?.refresh });
             if (freshManifest != null) {
                 await this.#persist(freshManifest);
@@ -637,7 +705,7 @@ class Store {
     static #compilerInstanceCache = new Map();
     static #fetcher;
     static #lockService;
-    static #manifest;
+    static manifest;
     static #manifestService;
     static #packageService;
     static #npmRegistry = environmentOptions.npmRegistry;
@@ -659,12 +727,12 @@ class Store {
             return;
         }
         await Store.open();
-        const version = Store.#manifest?.resolve(tag);
+        const version = Store.manifest?.resolve(tag);
         if (!version) {
             Store.#onDiagnostics(Diagnostic.error(StoreDiagnosticText.cannotAddTypeScriptPackage(tag)));
             return;
         }
-        await Store.#packageService.ensure(version, Store.#manifest);
+        await Store.#packageService.ensure(version, Store.manifest);
     }
     static async load(tag) {
         let compilerInstance = Store.#compilerInstanceCache.get(tag);
@@ -677,7 +745,7 @@ class Store {
         }
         else {
             await Store.open();
-            const version = Store.#manifest?.resolve(tag);
+            const version = Store.manifest?.resolve(tag);
             if (!version) {
                 Store.#onDiagnostics(Diagnostic.error(StoreDiagnosticText.cannotAddTypeScriptPackage(tag)));
                 return;
@@ -686,7 +754,7 @@ class Store {
             if (compilerInstance != null) {
                 return compilerInstance;
             }
-            const packagePath = await Store.#packageService.ensure(version, Store.#manifest);
+            const packagePath = await Store.#packageService.ensure(version, Store.manifest);
             if (packagePath != null) {
                 modulePath = Path.join(packagePath, "lib", "typescript.js");
             }
@@ -725,13 +793,9 @@ class Store {
     }
     static async open() {
         Store.open = () => Promise.resolve();
-        Store.#manifest = await Store.#manifestService.open();
-        if (Store.#manifest != null) {
-            Store.#supportedTags = [
-                ...Object.keys(Store.#manifest.resolutions),
-                ...Store.#manifest.versions,
-                "current",
-            ].sort();
+        Store.manifest = await Store.#manifestService.open();
+        if (Store.manifest != null) {
+            Store.#supportedTags = [...Object.keys(Store.manifest.resolutions), ...Store.manifest.versions, "current"].sort();
         }
     }
     static async prune() {
@@ -745,10 +809,10 @@ class Store {
             return environmentOptions.typescriptModule != null;
         }
         await Store.open();
-        if (Store.#manifest?.isOutdated({ ageTolerance: 60 }) &&
-            (!Version.isVersionTag(tag) ||
-                (Store.#manifest.resolutions["latest"] != null &&
-                    Version.isGreaterThan(tag, Store.#manifest.resolutions["latest"])))) {
+        if (Store.manifest?.isOutdated({ ageTolerance: 60 }) &&
+            (!/^\d/.test(tag) ||
+                (Store.manifest.resolutions["latest"] != null &&
+                    Version.isGreaterThan(tag, Store.manifest.resolutions["latest"])))) {
             Store.#onDiagnostics(Diagnostic.warning([
                 StoreDiagnosticText.failedToUpdateMetadata(Store.#npmRegistry),
                 StoreDiagnosticText.maybeOutdatedResolution(tag),
@@ -758,64 +822,42 @@ class Store {
     }
 }
 
-class ConfigDiagnosticText {
-    static expected(element) {
-        return `Expected ${element}.`;
-    }
-    static expectsListItemType(optionName, optionBrand) {
-        return `Item of the '${optionName}' list must be of type ${optionBrand}.`;
-    }
-    static expectsValue(optionName) {
-        return `Option '${optionName}' expects a value.`;
-    }
-    static fileDoesNotExist(filePath) {
-        return `The specified path '${filePath}' does not exist.`;
-    }
-    static moduleWasNotFound(specifier) {
-        return `The specified module '${specifier}' was not found.`;
-    }
-    static seen(element) {
-        return `The ${element} was seen here.`;
-    }
-    static testFileMatchCannotStartWith(segment) {
-        return [
-            `A test file match pattern cannot start with '${segment}'.`,
-            "The test files are only collected within the 'rootPath' directory.",
-        ];
-    }
-    static requiresValueType(optionName, optionBrand) {
-        return `Option '${optionName}' requires a value of type ${optionBrand}.`;
-    }
-    static unknownOption(optionName) {
-        return `Unknown option '${optionName}'.`;
-    }
-    static async usage(optionName, optionBrand) {
-        switch (optionName.startsWith("--") ? optionName.slice(2) : optionName) {
-            case "target": {
-                const text = [];
-                if (optionName.startsWith("--")) {
-                    text.push("Value for the '--target' option must be a single tag or a comma separated list.", "Usage examples: '--target 4.9', '--target latest', '--target 4.9,5.3.2,current'.");
-                }
-                else {
-                    text.push("Item of the 'target' list must be a supported version tag.");
-                }
-                const supportedTags = await Store.getSupportedTags();
-                if (supportedTags != null) {
-                    text.push(`Supported tags: ${["'", supportedTags.join("', '"), "'"].join("")}.`);
+class Target {
+    static #rangeRegex = /^[<>]=?\d\.\d( [<>]=?\d\.\d)?$/;
+    static async expand(queries) {
+        const include = [];
+        for (const query of queries) {
+            if (!Target.isRange(query)) {
+                include.push(query);
+                continue;
+            }
+            await Store.open();
+            if (Store.manifest != null) {
+                let versions = Object.keys(Store.manifest.resolutions).slice(0, -4);
+                for (const comparator of query.split(" ")) {
+                    versions = Target.#filter(comparator, versions);
                 }
-                return text;
+                include.push(...versions);
             }
         }
-        return [ConfigDiagnosticText.requiresValueType(optionName, optionBrand)];
+        return include;
     }
-    static versionIsNotSupported(value) {
-        if (value === "current") {
-            return "Cannot use 'current' as a target. Failed to resolve the installed TypeScript module.";
+    static #filter(comparator, versions) {
+        const targetVersion = comparator.replace(/^[<>]=?/, "");
+        switch (comparator.charAt(0)) {
+            case ">":
+                return versions.filter((sourceVersion) => comparator.charAt(1) === "="
+                    ? Version.isSatisfiedWith(sourceVersion, targetVersion)
+                    : Version.isGreaterThan(sourceVersion, targetVersion));
+            case "<":
+                return versions.filter((sourceVersion) => comparator.charAt(1) === "="
+                    ? Version.isSatisfiedWith(targetVersion, sourceVersion)
+                    : Version.isGreaterThan(targetVersion, sourceVersion));
         }
-        return `TypeScript version '${value}' is not supported.`;
+        return [];
     }
-    static watchCannotBeEnabled() {
-        return "Watch mode cannot be enabled in continuous integration environment.";
+    static isRange(query) {
+        return Target.#rangeRegex.test(query);
     }
 }
 
@@ -851,6 +893,12 @@ class Options {
             group: 2,
             name: "install",
         },
+        {
+            brand: "bareTrue",
+            description: "Print the list of supported versions of the 'typescript' package and exit.",
+            group: 2,
+            name: "list",
+        },
         {
             brand: "bareTrue",
             description: "Print the list of the selected test files and exit.",
@@ -879,6 +927,18 @@ class Options {
             group: 2,
             name: "prune",
         },
+        {
+            brand: "boolean",
+            description: "Reject the 'any' type passed as an argument to the 'expect()' function or a matcher.",
+            group: 4,
+            name: "rejectAnyType",
+        },
+        {
+            brand: "boolean",
+            description: "Reject the 'never' type passed as an argument to the 'expect()' function or a matcher.",
+            group: 4,
+            name: "rejectNeverType",
+        },
         {
             brand: "list",
             description: "The list of reporters to use.",
@@ -914,7 +974,6 @@ class Options {
             items: {
                 brand: "string",
                 name: "target",
-                pattern: "^([45]\\.[0-9](\\.[0-9])?)|beta|current|latest|next|rc$",
             },
             name: "target",
         },
@@ -1025,14 +1084,22 @@ class Options {
                 }
                 onDiagnostics(Diagnostic.error(ConfigDiagnosticText.moduleWasNotFound(optionValue), origin));
                 break;
-            case "target":
+            case "target": {
+                if (/[<>=]/.test(optionValue)) {
+                    if (!Target.isRange(optionValue)) {
+                        onDiagnostics(Diagnostic.error([ConfigDiagnosticText.rangeIsNotValid(optionValue), ...ConfigDiagnosticText.rangeUsage()], origin));
+                    }
+                    break;
+                }
                 if ((await Store.validateTag(optionValue)) === false) {
                     onDiagnostics(Diagnostic.error([
                         ConfigDiagnosticText.versionIsNotSupported(optionValue),
-                        await ConfigDiagnosticText.usage(optionName, optionBrand),
-                    ].flat(), origin));
+                        ...ConfigDiagnosticText.usage(optionName, optionBrand),
+                        ConfigDiagnosticText.inspectSupportedVersions(),
+                    ], origin));
                 }
                 break;
+            }
             case "testFileMatch":
                 for (const segment of ["/", "../"]) {
                     if (optionValue.startsWith(segment)) {
@@ -1311,13 +1378,13 @@ class ConfigFileParser {
                 break;
             }
             case "list": {
+                optionValue = [];
                 const leftBracketToken = this.#jsonScanner.readToken("[");
                 if (!leftBracketToken.text) {
                     jsonNode = this.#jsonScanner.read();
                     this.#onRequiresValue(optionDefinition, jsonNode, isListItem);
                     break;
                 }
-                optionValue = [];
                 while (!this.#jsonScanner.isRead()) {
                     if (this.#jsonScanner.peekToken("]")) {
                         break;
@@ -1409,6 +1476,8 @@ class ConfigFileParser {
 const defaultOptions = {
     failFast: false,
     plugins: [],
+    rejectAnyType: false,
+    rejectNeverType: false,
     reporters: ["list", "summary"],
     rootPath: Path.resolve("./"),
     target: environmentOptions.typescriptModule != null ? ["current"] : ["latest"],
@@ -1425,6 +1494,9 @@ class Config {
         const pathMatch = [];
         const commandLineParser = new CommandLineParser(commandLineOptions, pathMatch, Config.#onDiagnostics);
         await commandLineParser.parse(commandLine);
+        if (commandLineOptions.target != null) {
+            commandLineOptions.target = await Target.expand(commandLineOptions.target);
+        }
         return { commandLineOptions, pathMatch };
     }
     static async parseConfigFile(filePath) {
@@ -1439,6 +1511,9 @@ class Config {
             const sourceFile = new SourceFile(configFilePath, configFileText);
             const configFileParser = new ConfigFileParser(configFileOptions, sourceFile, Config.#onDiagnostics);
             await configFileParser.parse();
+            if (configFileOptions.target != null) {
+                configFileOptions.target = await Target.expand(configFileOptions.target);
+            }
         }
         return { configFileOptions, configFilePath };
     }
@@ -2182,7 +2257,7 @@ function usesCompilerText(compilerVersion, projectConfigFilePath, options) {
     if (projectConfigFilePath != null) {
         projectConfigPathText = (jsx(Text, { color: "90", children: [" with ", Path.relative("", projectConfigFilePath)] }));
     }
-    return (jsx(Text, { children: [options?.prependEmptyLine === true ? jsx(Line, {}) : undefined, jsx(Line, { children: [jsx(Text, { color: "34", children: "uses" }), " TypeScript ", compilerVersion, projectConfigPathText] }), jsx(Line, {})] }));
+    return (jsx(Text, { children: [options?.prependEmptyLine ? jsx(Line, {}) : undefined, jsx(Line, { children: [jsx(Text, { color: "34", children: "uses" }), " TypeScript ", compilerVersion, projectConfigPathText] }), jsx(Line, {})] }));
 }
 
 function waitingForFileChangesText() {
@@ -2255,7 +2330,7 @@ class FileView {
         return this.#messages;
     }
     getViewText(options) {
-        return fileViewText(this.#lines, options?.appendEmptyLine === true || this.hasErrors);
+        return fileViewText(this.#lines, options?.appendEmptyLine || this.hasErrors);
     }
 }
 
@@ -2413,7 +2488,7 @@ class SetupReporter {
 
 class SummaryReporter extends BaseReporter {
     on([event, payload]) {
-        if (this.resolvedConfig.watch === true) {
+        if (this.resolvedConfig.watch) {
             return;
         }
         if (event === "run:end") {
@@ -2625,6 +2700,28 @@ class SelectDiagnosticText {
 
 class Select {
     static #patternsCache = new WeakMap();
+    static async #getAccessibleFileSystemEntries(targetPath) {
+        const directories = [];
+        const files = [];
+        try {
+            const entries = await fs.readdir(targetPath, { withFileTypes: true });
+            for (const entry of entries) {
+                let entryMeta = entry;
+                if (entry.isSymbolicLink()) {
+                    entryMeta = await fs.stat([targetPath, entry.name].join("/"));
+                }
+                if (entryMeta.isDirectory()) {
+                    directories.push(entry.name);
+                }
+                else if (entryMeta.isFile()) {
+                    files.push(entry.name);
+                }
+            }
+        }
+        catch {
+        }
+        return { directories, files };
+    }
     static #getMatchPatterns(globPatterns) {
         let matchPatterns = Select.#patternsCache.get(globPatterns);
         if (!matchPatterns) {
@@ -2653,18 +2750,6 @@ class Select {
     static #onDiagnostics(diagnostic) {
         EventEmitter.dispatch(["select:error", { diagnostics: [diagnostic] }]);
     }
-    static async #resolveEntryMeta(entry, targetPath) {
-        if (!entry.isSymbolicLink()) {
-            return entry;
-        }
-        let entryMeta;
-        try {
-            entryMeta = await fs.stat([targetPath, entry.name].join("/"));
-        }
-        catch {
-        }
-        return entryMeta;
-    }
     static async selectFiles(resolvedConfig) {
         const matchPatterns = Select.#getMatchPatterns(resolvedConfig.testFileMatch);
         const testFilePaths = [];
@@ -2676,20 +2761,18 @@ class Select {
     }
     static async #visitDirectory(currentPath, testFilePaths, matchPatterns, resolvedConfig) {
         const targetPath = Path.join(resolvedConfig.rootPath, currentPath);
-        try {
-            const entries = await fs.readdir(targetPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const entryMeta = await Select.#resolveEntryMeta(entry, targetPath);
-                const entryPath = [currentPath, entry.name].join("/");
-                if (entryMeta?.isDirectory() && Select.#isDirectoryIncluded(entryPath, matchPatterns)) {
-                    await Select.#visitDirectory(entryPath, testFilePaths, matchPatterns, resolvedConfig);
-                }
-                else if (entryMeta?.isFile() && Select.#isFileIncluded(entryPath, matchPatterns, resolvedConfig)) {
-                    testFilePaths.push([targetPath, entry.name].join("/"));
-                }
+        const entries = await Select.#getAccessibleFileSystemEntries(targetPath);
+        for (const directoryName of entries.directories) {
+            const directoryPath = [currentPath, directoryName].join("/");
+            if (Select.#isDirectoryIncluded(directoryPath, matchPatterns)) {
+                await Select.#visitDirectory(directoryPath, testFilePaths, matchPatterns, resolvedConfig);
             }
         }
-        catch {
+        for (const fileName of entries.files) {
+            const filePath = [currentPath, fileName].join("/");
+            if (Select.#isFileIncluded(filePath, matchPatterns, resolvedConfig)) {
+                testFilePaths.push([targetPath, fileName].join("/"));
+            }
         }
     }
 }
@@ -2871,14 +2954,20 @@ class TestMember {
 
 class Assertion extends TestMember {
     isNot;
+    matcherName;
     matcherNode;
     modifierNode;
     notNode;
+    source;
+    target;
     constructor(compiler, brand, node, parent, flags, matcherNode, modifierNode, notNode) {
         super(compiler, brand, node, parent, flags);
         this.isNot = notNode != null;
+        this.matcherName = matcherNode.expression.name;
         this.matcherNode = matcherNode;
         this.modifierNode = modifierNode;
+        this.source = this.node.typeArguments ?? this.node.arguments;
+        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) {
                 this.diagnostics.add(diagnostic);
@@ -2886,15 +2975,6 @@ class Assertion extends TestMember {
             }
         }
     }
-    get matcherName() {
-        return this.matcherNode.expression.name;
-    }
-    get source() {
-        return this.node.typeArguments ?? this.node.arguments;
-    }
-    get target() {
-        return this.matcherNode.typeArguments ?? this.matcherNode.arguments;
-    }
 }
 
 class IdentifierLookup {
@@ -3178,7 +3258,16 @@ class ProjectService {
     }
 }
 
+class Format {
+    static capitalize(text) {
+        return text.replace(/^./, text.charAt(0).toUpperCase());
+    }
+}
+
 class ExpectDiagnosticText {
+    static argumentCannotBeOfType(argumentNameText, typeText) {
+        return `An argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
+    }
     static argumentOrTypeArgumentMustBeProvided(argumentNameText, typeArgumentNameText) {
         return `An argument for '${argumentNameText}' or type argument for '${typeArgumentNameText}' must be provided.`;
     }
@@ -3209,6 +3298,9 @@ class ExpectDiagnosticText {
     static raisedTypeError(count = 1) {
         return `The raised type error${count === 1 ? "" : "s"}:`;
     }
+    static typeArgumentCannotBeOfType(argumentNameText, typeText) {
+        return `A type argument for '${argumentNameText}' cannot be of the '${typeText}' type.`;
+    }
     static typeArgumentMustBe(argumentNameText, expectedText) {
         return `A type argument for '${argumentNameText}' must be ${expectedText}.`;
     }
@@ -3270,6 +3362,13 @@ class ExpectDiagnosticText {
     static typesOfPropertyAreNotCompatible(propertyNameText) {
         return `Types of property '${propertyNameText}' are not compatible.`;
     }
+    static typeWasRejected(typeText) {
+        const optionNameText = `reject${Format.capitalize(typeText)}Type`;
+        return [
+            `The '${typeText}' type was rejected because the '${optionNameText}' option is enabled.`,
+            `If this check is necessary, pass '${typeText}' as the type argument explicitly.`,
+        ];
+    }
 }
 
 class MatchWorker {
@@ -3371,9 +3470,6 @@ class MatchWorker {
         }
         return type;
     }
-    isAnyOrNeverType(type) {
-        return !!(type.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never));
-    }
     isStringOrNumberLiteralType(type) {
         return !!(type.flags & this.#compiler.TypeFlags.StringOrNumberLiteral);
     }
@@ -3670,7 +3766,8 @@ class ToHaveProperty {
     match(matchWorker, sourceNode, targetNode, onDiagnostics) {
         const diagnostics = [];
         const sourceType = matchWorker.getType(sourceNode);
-        if (matchWorker.isAnyOrNeverType(sourceType) || !matchWorker.extendsObjectType(sourceType)) {
+        if (sourceType.flags & (this.#compiler.TypeFlags.Any | this.#compiler.TypeFlags.Never) ||
+            !matchWorker.extendsObjectType(sourceType)) {
             const expectedText = "of an object type";
             const text = this.#compiler.isTypeNode(sourceNode)
                 ? ExpectDiagnosticText.typeArgumentMustBe("Source", expectedText)
@@ -3798,6 +3895,7 @@ class ToRaiseError {
 
 class ExpectService {
     #compiler;
+    #rejectTypes = new Set();
     #typeChecker;
     toAcceptProps;
     toBe;
@@ -3818,9 +3916,15 @@ class ExpectService {
     toHaveProperty;
     toMatch;
     toRaiseError;
-    constructor(compiler, typeChecker) {
+    constructor(compiler, typeChecker, resolvedConfig) {
         this.#compiler = compiler;
         this.#typeChecker = typeChecker;
+        if (resolvedConfig?.rejectAnyType) {
+            this.#rejectTypes.add("any");
+        }
+        if (resolvedConfig?.rejectNeverType) {
+            this.#rejectTypes.add("never");
+        }
         this.toAcceptProps = new ToAcceptProps(compiler, typeChecker);
         this.toBe = new ToBe();
         this.toBeAny = new PrimitiveTypeMatcher(compiler.TypeFlags.Any);
@@ -3863,6 +3967,9 @@ class ExpectService {
                     this.#onTargetArgumentOrTypeArgumentMustBeProvided(assertion, onDiagnostics);
                     return;
                 }
+                if (this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+                    return;
+                }
                 return this[matcherNameText].match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             case "toBeAny":
             case "toBeBigInt":
@@ -3884,6 +3991,9 @@ class ExpectService {
                 }
                 return this.toHaveProperty.match(matchWorker, assertion.source[0], assertion.target[0], onDiagnostics);
             case "toRaiseError":
+                if (assertion.isNot && this.#rejectsTypeArguments(matchWorker, onDiagnostics)) {
+                    return;
+                }
                 return this.toRaiseError.match(matchWorker, assertion.source[0], [...assertion.target], onDiagnostics);
             default:
                 this.#onMatcherIsNotSupported(matcherNameText, assertion, onDiagnostics);
@@ -3910,6 +4020,29 @@ class ExpectService {
         const origin = DiagnosticOrigin.fromNode(assertion.matcherName);
         onDiagnostics(Diagnostic.error(text, origin));
     }
+    #rejectsTypeArguments(matchWorker, onDiagnostics) {
+        for (const rejectedType of this.#rejectTypes) {
+            for (const argumentName of ["source", "target"]) {
+                const argumentNode = matchWorker.assertion[argumentName][0];
+                if (!argumentNode ||
+                    argumentNode.kind === this.#compiler.SyntaxKind[`${Format.capitalize(rejectedType)}Keyword`]) {
+                    continue;
+                }
+                if (matchWorker.getType(argumentNode).flags & this.#compiler.TypeFlags[Format.capitalize(rejectedType)]) {
+                    const text = [
+                        this.#compiler.isTypeNode(argumentNode)
+                            ? ExpectDiagnosticText.typeArgumentCannotBeOfType(Format.capitalize(argumentName), rejectedType)
+                            : ExpectDiagnosticText.argumentCannotBeOfType(argumentName, rejectedType),
+                        ...ExpectDiagnosticText.typeWasRejected(rejectedType),
+                    ];
+                    const origin = DiagnosticOrigin.fromNode(argumentNode);
+                    onDiagnostics(Diagnostic.error(text, origin));
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }
 
 class TestTreeWalker {
@@ -3927,7 +4060,7 @@ class TestTreeWalker {
         this.#hasOnly = options.hasOnly || resolvedConfig.only != null || options.position != null;
         this.#position = options.position;
         this.#taskResult = options.taskResult;
-        this.#expectService = new ExpectService(compiler, typeChecker);
+        this.#expectService = new ExpectService(compiler, typeChecker, this.#resolvedConfig);
     }
     #resolveRunMode(mode, member) {
         if (member.flags & 1) {
@@ -3952,7 +4085,7 @@ class TestTreeWalker {
     }
     visit(members, runMode, parentResult) {
         for (const member of members) {
-            if (this.#cancellationToken?.isCancellationRequested === true) {
+            if (this.#cancellationToken?.isCancellationRequested) {
                 break;
             }
             const validationError = member.validate();
@@ -4076,7 +4209,7 @@ class TaskRunner {
         this.#projectService = new ProjectService(this.#resolvedConfig, compiler);
     }
     run(task, cancellationToken) {
-        if (cancellationToken?.isCancellationRequested === true) {
+        if (cancellationToken?.isCancellationRequested) {
             return;
         }
         this.#projectService.openFile(task.filePath, undefined, this.#resolvedConfig.rootPath);
@@ -4137,7 +4270,7 @@ class TaskRunner {
 class Runner {
     #eventEmitter = new EventEmitter();
     #resolvedConfig;
-    static version = "3.0.0";
+    static version = "3.1.1";
     constructor(resolvedConfig) {
         this.#resolvedConfig = resolvedConfig;
     }
@@ -4161,7 +4294,7 @@ class Runner {
                 }
             }
         }
-        if (this.#resolvedConfig.watch === true) {
+        if (this.#resolvedConfig.watch) {
             const watchReporter = new WatchReporter(this.#resolvedConfig);
             this.#eventEmitter.addReporter(watchReporter);
         }
@@ -4176,7 +4309,7 @@ class Runner {
             this.#eventEmitter.addHandler(cancellationHandler);
         }
         await this.#run(tasks, cancellationToken);
-        if (this.#resolvedConfig.watch === true) {
+        if (this.#resolvedConfig.watch) {
             await this.#watch(tasks, cancellationToken);
         }
         this.#eventEmitter.removeReporters();
@@ -4228,6 +4361,13 @@ class Cli {
             OutputService.writeMessage(formattedText(Runner.version));
             return;
         }
+        if (commandLine.includes("--list")) {
+            await Store.open();
+            if (Store.manifest != null) {
+                OutputService.writeMessage(formattedText({ resolutions: Store.manifest.resolutions, versions: Store.manifest.versions }));
+            }
+            return;
+        }
         if (commandLine.includes("--prune")) {
             await Store.prune();
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tstyche",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "The Essential Type Testing Tool.",
   "keywords": [
     "typescript",
@@ -63,17 +63,17 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@rollup/plugin-typescript": "12.1.1",
-    "@types/node": "22.9.0",
-    "@types/react": "18.3.12",
+    "@types/node": "22.10.1",
+    "@types/react": "18.3.13",
     "ajv": "8.17.1",
-    "cspell": "8.15.7",
-    "magic-string": "0.30.12",
-    "monocart-coverage-reports": "2.11.1",
-    "pretty-ansi": "2.0.0",
-    "rollup": "4.24.4",
+    "cspell": "8.16.1",
+    "magic-string": "0.30.14",
+    "monocart-coverage-reports": "2.11.3",
+    "pretty-ansi": "3.0.0",
+    "rollup": "4.28.0",
     "rollup-plugin-dts": "6.1.1",
     "tslib": "2.8.1",
-    "typescript": "5.6.3"
+    "typescript": "5.7.2"
   },
   "peerDependencies": {
     "typescript": "4.x || 5.x"
@@ -83,7 +83,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.5.1",
+  "packageManager": "yarn@4.5.3",
   "engines": {
     "node": ">=18.19"
   }