From a1aadd713c767b047ef46976bb690a57351322e6 Mon Sep 17 00:00:00 2001
From: Vladimir <sleuths.slews0s@icloud.com>
Date: Thu, 19 Oct 2023 11:21:51 +0200
Subject: [PATCH] feat(vitest): run typecheck during tests (#4324)

---
 docs/advanced/api.md                          |   5 -
 docs/config/index.md                          |  20 ++-
 docs/guide/cli.md                             |   3 +
 docs/guide/testing-types.md                   |  10 +-
 packages/runner/src/utils/tasks.ts            |   4 +-
 packages/ui/client/components/Suites.vue      |   1 +
 packages/ui/client/components/TaskItem.vue    |   1 +
 .../ui/client/components/views/ViewEditor.vue |   2 +-
 packages/ui/client/composables/summary.ts     |  27 +++-
 packages/ui/package.json                      |   1 +
 packages/vitest/src/node/cli-api.ts           |   9 ++
 packages/vitest/src/node/cli.ts               |  12 +-
 packages/vitest/src/node/config.ts            |   9 +-
 packages/vitest/src/node/core.ts              |  20 +--
 packages/vitest/src/node/logger.ts            |  19 ++-
 packages/vitest/src/node/pool.ts              |  19 ++-
 packages/vitest/src/node/pools/typecheck.ts   | 123 ++++++++++++++++++
 packages/vitest/src/node/reporters/base.ts    |  32 +++--
 .../node/reporters/renderers/listRenderer.ts  |   2 +-
 packages/vitest/src/node/stdin.ts             |   4 -
 packages/vitest/src/node/workspace.ts         |  75 ++---------
 packages/vitest/src/runtime/execute.ts        |   2 +
 packages/vitest/src/typecheck/collect.ts      |   2 +
 packages/vitest/src/typecheck/typechecker.ts  |  34 ++++-
 packages/vitest/src/types/config.ts           |  14 +-
 packages/vitest/src/types/pool-options.ts     |   2 +-
 pnpm-lock.yaml                                |  13 +-
 test/coverage-test/package.json               |   2 +-
 test/typescript/package.json                  |   2 +-
 test/typescript/test/runner.test.ts           |   7 +-
 test/typescript/test/vitest.custom.config.ts  |   1 +
 test/typescript/test/vitest.empty.config.ts   |   1 +
 32 files changed, 330 insertions(+), 148 deletions(-)
 create mode 100644 packages/vitest/src/node/pools/typecheck.ts

diff --git a/docs/advanced/api.md b/docs/advanced/api.md
index fa4990699..e21fe2f0a 100644
--- a/docs/advanced/api.md
+++ b/docs/advanced/api.md
@@ -52,7 +52,6 @@ Vitest instance requires the current test mode. It can be either:
 
 - `test` when running runtime tests
 - `benchmark` when running benchmarks
-- `typecheck` when running type tests
 
 ### mode
 
@@ -64,10 +63,6 @@ Test mode will only call functions inside `test` or `it`, and throws an error wh
 
 Benchmark mode calls `bench` functions and throws an error, when it encounters `test` or `it`. This mode uses `benchmark.include` and `benchmark.exclude` options in the config to find benchmark files.
 
-#### typecheck
-
-Typecheck mode doesn't _run_ tests. It only analyses types and gives a summary. This mode uses `typecheck.include` and `typecheck.exclude` options in the config to find files to analyze.
-
 ### start
 
 You can start running tests or benchmarks with `start` method. You can pass an array of strings to filter test files.
diff --git a/docs/config/index.md b/docs/config/index.md
index 028b1d897..841e1e8b2 100644
--- a/docs/config/index.md
+++ b/docs/config/index.md
@@ -547,7 +547,7 @@ export default defineConfig({
 
 ### poolMatchGlobs
 
-- **Type:** `[string, 'threads' | 'forks' | 'vmThreads'][]`
+- **Type:** `[string, 'threads' | 'forks' | 'vmThreads' | 'typescript'][]`
 - **Default:** `[]`
 - **Version:** Since Vitest 0.29.4
 
@@ -1637,6 +1637,24 @@ Changes the order in which setup files are executed.
 
 Options for configuring [typechecking](/guide/testing-types) test environment.
 
+#### typecheck.enabled
+
+- **Type**: `boolean`
+- **Default**: `false`
+- **CLI**: `--typecheck`, `--typecheck.enabled`
+- **Version**: Since Vitest 1.0.0-beta.3
+
+Enable typechecking alongside your regular tests.
+
+#### typecheck.only
+
+- **Type**: `boolean`
+- **Default**: `false`
+- **CLI**: `--typecheck.only`
+- **Version**: Since Vitest 1.0.0-beta.3
+
+Run only typecheck tests, when typechecking is enabled. When using CLI, this option will automatically enable typechecking.
+
 #### typecheck.checker
 
 - **Type**: `'tsc' | 'vue-tsc' | string`
diff --git a/docs/guide/cli.md b/docs/guide/cli.md
index 5d7b7317f..c4569ec8a 100644
--- a/docs/guide/cli.md
+++ b/docs/guide/cli.md
@@ -96,6 +96,9 @@ Run only [benchmark](https://vitest.dev/guide/features.html#benchmarking-experim
 | `--inspect-brk` | Enables Node.js inspector with break |
 | `--bail <number>` | Stop test execution when given number of tests have failed |
 | `--retry <times>` | Retry the test specific number of times if it fails |
+| `--typecheck [options]` | Custom options for typecheck pool. If passed without options, enables typechecking |
+| `--typecheck.enabled` | Enable typechecking alongside tests (default: `false`) |
+| `--typecheck.only` | Run only typecheck tests. This automatically enables typecheck (default: `false`) |
 | `-h, --help` | Display available CLI options |
 
 ::: tip
diff --git a/docs/guide/testing-types.md b/docs/guide/testing-types.md
index 258e970ab..eb2f167db 100644
--- a/docs/guide/testing-types.md
+++ b/docs/guide/testing-types.md
@@ -66,12 +66,12 @@ assertType<string>(answr) //
 
 ## Run typechecking
 
-Add this command to your `scripts` section in `package.json`:
+To enabled typechecking, just add `--typecheck` flag to your Vitest command in `package.json`:
 
 ```json
 {
   "scripts": {
-    "typecheck": "vitest typecheck"
+    "test": "vitest --typecheck"
   }
 }
 ```
@@ -80,13 +80,13 @@ Now you can run typecheck:
 
 ```sh
 # npm
-npm run typecheck
+npm run test
 
 # yarn
-yarn typecheck
+yarn test
 
 # pnpm
-pnpm run typecheck
+pnpm run test
 ```
 
 Vitest uses `tsc --noEmit` or `vue-tsc --noEmit`, depending on your configuration, so you can remove these scripts from your pipeline.
diff --git a/packages/runner/src/utils/tasks.ts b/packages/runner/src/utils/tasks.ts
index 40244da59..d692a7995 100644
--- a/packages/runner/src/utils/tasks.ts
+++ b/packages/runner/src/utils/tasks.ts
@@ -7,8 +7,8 @@ function isAtomTest(s: Task): s is Test | Custom {
 
 export function getTests(suite: Arrayable<Task>): (Test | Custom)[] {
   const tests: (Test | Custom)[] = []
-  const suite_arr = toArray(suite)
-  for (const s of suite_arr) {
+  const arraySuites = toArray(suite)
+  for (const s of arraySuites) {
     if (isAtomTest(s)) {
       tests.push(s)
     }
diff --git a/packages/ui/client/components/Suites.vue b/packages/ui/client/components/Suites.vue
index 492b10d3b..c9a1d8038 100644
--- a/packages/ui/client/components/Suites.vue
+++ b/packages/ui/client/components/Suites.vue
@@ -23,6 +23,7 @@ async function onRunCurrent() {
     <TasksList :tasks="current.tasks" :nested="true">
       <template #header>
         <StatusIcon mx-1 :task="current" />
+        <div v-if="current.type === 'suite' && current.meta.typecheck" i-logos:typescript-icon flex-shrink-0 mr-1 />
         <span data-testid="filenames" font-bold text-sm flex-auto ws-nowrap overflow-hidden truncate>{{ name }}</span>
         <div class="flex text-lg">
           <IconButton
diff --git a/packages/ui/client/components/TaskItem.vue b/packages/ui/client/components/TaskItem.vue
index fc8bf180a..f9ba4ee05 100644
--- a/packages/ui/client/components/TaskItem.vue
+++ b/packages/ui/client/components/TaskItem.vue
@@ -22,6 +22,7 @@ const duration = computed(() => {
     hover="bg-active"
   >
     <StatusIcon :task="task" mr-2 />
+    <div v-if="task.type === 'suite' && task.meta.typecheck" i-logos:typescript-icon flex-shrink-0 mr-2 />
     <div flex items-end gap-2 :text="task?.result?.state === 'fail' ? 'red-500' : ''">
       <span text-sm truncate font-light>{{ task.name }}</span>
       <span v-if="typeof duration === 'number'" text="xs" op20 style="white-space: nowrap">
diff --git a/packages/ui/client/components/views/ViewEditor.vue b/packages/ui/client/components/views/ViewEditor.vue
index 957fde0f2..dd7ae679b 100644
--- a/packages/ui/client/components/views/ViewEditor.vue
+++ b/packages/ui/client/components/views/ViewEditor.vue
@@ -72,7 +72,7 @@ function createErrorElement(e: ErrorWithDiff) {
   div.className = 'op80 flex gap-x-2 items-center'
   const pre = document.createElement('pre')
   pre.className = 'c-red-600 dark:c-red-400'
-  pre.textContent = `${' '.repeat(stack.column)}^ ${e?.nameStr}: ${e?.message}`
+  pre.textContent = `${' '.repeat(stack.column)}^ ${e?.nameStr || e.name}: ${e?.message || ''}`
   div.appendChild(pre)
   const span = document.createElement('span')
   span.className = 'i-carbon-launch c-red-600 dark:c-red-400 hover:cursor-pointer min-w-1em min-h-1em'
diff --git a/packages/ui/client/composables/summary.ts b/packages/ui/client/composables/summary.ts
index 18e056779..68d57d13c 100644
--- a/packages/ui/client/composables/summary.ts
+++ b/packages/ui/client/composables/summary.ts
@@ -1,5 +1,5 @@
 import { hasFailedSnapshot } from '@vitest/ws-client'
-import type { Benchmark, Task, Test, TypeCheck } from 'vitest/src'
+import type { Custom, Task, Test } from 'vitest/src'
 import { files, testRunState } from '~/composables/client'
 
 type Nullable<T> = T | null | undefined
@@ -33,7 +33,7 @@ export const testsSkipped = computed(() => testsIgnore.value.filter(f => f.mode
 export const testsTodo = computed(() => testsIgnore.value.filter(f => f.mode === 'todo'))
 export const totalTests = computed(() => testsFailed.value.length + testsSuccess.value.length)
 export const time = computed(() => {
-  const t = getTests(tests.value).reduce((acc, t) => {
+  const t = files.value.reduce((acc, t) => {
     acc += Math.max(0, t.collectDuration || 0)
     acc += Math.max(0, t.setupDuration || 0)
     acc += Math.max(0, t.result?.duration || 0)
@@ -53,10 +53,25 @@ function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T> {
   return [array]
 }
 
-function isAtomTest(s: Task): s is Test | Benchmark | TypeCheck {
-  return (s.type === 'test' || s.type === 'benchmark' || s.type === 'typecheck')
+function isAtomTest(s: Task): s is Test | Custom {
+  return (s.type === 'test' || s.type === 'custom')
 }
 
-function getTests(suite: Arrayable<Task>): (Test | Benchmark | TypeCheck)[] {
-  return toArray(suite).flatMap(s => isAtomTest(s) ? [s] : s.tasks.flatMap(c => isAtomTest(c) ? [c] : getTests(c)))
+function getTests(suite: Arrayable<Task>): (Test | Custom)[] {
+  const tests: (Test | Custom)[] = []
+  const arraySuites = toArray(suite)
+  for (const s of arraySuites) {
+    if (isAtomTest(s)) {
+      tests.push(s)
+    }
+    else {
+      for (const task of s.tasks) {
+        if (isAtomTest(task))
+          tests.push(task)
+        else
+          tests.push(...getTests(task))
+      }
+    }
+  }
+  return tests
 }
diff --git a/packages/ui/package.json b/packages/ui/package.json
index 0af2e08bd..15e517f0b 100644
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -57,6 +57,7 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^8.0.2",
+    "@iconify-json/logos": "^1.1.37",
     "@testing-library/cypress": "^9.0.0",
     "@types/codemirror": "^5.60.8",
     "@types/d3-force": "^3.0.4",
diff --git a/packages/vitest/src/node/cli-api.ts b/packages/vitest/src/node/cli-api.ts
index a64561389..d1d9f1702 100644
--- a/packages/vitest/src/node/cli-api.ts
+++ b/packages/vitest/src/node/cli-api.ts
@@ -56,6 +56,15 @@ export async function startVitest(
   if (typeof options.browser === 'object' && !('enabled' in options.browser))
     options.browser.enabled = true
 
+  if (typeof options.typecheck === 'boolean')
+    options.typecheck = { enabled: true }
+
+  if (typeof options.typecheck?.only === 'boolean') {
+    options.typecheck ??= {}
+    options.typecheck.only = true
+    options.typecheck.enabled = true
+  }
+
   const ctx = await createVitest(mode, options, viteOverrides)
 
   if (mode === 'test' && ctx.config.coverage.enabled) {
diff --git a/packages/vitest/src/node/cli.ts b/packages/vitest/src/node/cli.ts
index 02a6320cb..511e9d87d 100644
--- a/packages/vitest/src/node/cli.ts
+++ b/packages/vitest/src/node/cli.ts
@@ -51,6 +51,9 @@ cli
   .option('--bail <number>', 'Stop test execution when given number of tests have failed', { default: 0 })
   .option('--retry <times>', 'Retry the test specific number of times if it fails', { default: 0 })
   .option('--diff <path>', 'Path to a diff config that will be used to generate diff interface')
+  .option('--typecheck [options]', 'Custom options for typecheck pool')
+  .option('--typecheck.enabled', 'Enable typechecking alongside tests (default: false)')
+  .option('--typecheck.only', 'Run only typecheck tests. This automatically enables typecheck (default: false)')
   .help()
 
 cli
@@ -73,10 +76,6 @@ cli
   .command('bench [...filters]')
   .action(benchmark)
 
-cli
-  .command('typecheck [...filters]')
-  .action(typecheck)
-
 cli
   .command('[...filters]')
   .action((filters, options) => start('test', filters, options))
@@ -130,11 +129,6 @@ async function benchmark(cliFilters: string[], options: CliOptions): Promise<voi
   await start('benchmark', cliFilters, options)
 }
 
-async function typecheck(cliFilters: string[] = [], options: CliOptions = {}) {
-  console.warn(c.yellow('Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow semver, please pin Vitest\'s version when using it.'))
-  await start('typecheck', cliFilters, options)
-}
-
 function normalizeCliOptions(argv: CliOptions): CliOptions {
   if (argv.root)
     argv.root = normalize(argv.root)
diff --git a/packages/vitest/src/node/config.ts b/packages/vitest/src/node/config.ts
index 464b384a2..39e218047 100644
--- a/packages/vitest/src/node/config.ts
+++ b/packages/vitest/src/node/config.ts
@@ -378,10 +378,11 @@ export function resolveConfig(
 
   resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map(i => [resolve(resolved.root, i[0]), i[1]])
 
-  if (mode === 'typecheck') {
-    resolved.include = resolved.typecheck.include
-    resolved.exclude = resolved.typecheck.exclude
-  }
+  resolved.typecheck ??= {} as any
+  resolved.typecheck.enabled ??= false
+
+  if (resolved.typecheck.enabled)
+    console.warn(c.yellow('Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow semver, please pin Vitest\'s version when using it.'))
 
   resolved.browser ??= {} as any
   resolved.browser.enabled ??= false
diff --git a/packages/vitest/src/node/core.ts b/packages/vitest/src/node/core.ts
index d143c0f95..37225654d 100644
--- a/packages/vitest/src/node/core.ts
+++ b/packages/vitest/src/node/core.ts
@@ -72,6 +72,7 @@ export class Vitest {
   }
 
   private _onRestartListeners: OnServerRestartHandler[] = []
+  private _onClose: (() => Awaited<unknown>)[] = []
   private _onSetServer: OnServerRestartHandler[] = []
   private _onCancelListeners: ((reason: CancelReason) => Promise<void> | void)[] = []
 
@@ -93,7 +94,7 @@ export class Vitest {
     this.cache = new VitestCache()
     this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions })
 
-    if (this.config.watch && this.mode !== 'typecheck')
+    if (this.config.watch)
       this.registerWatcher()
 
     this.vitenode = new ViteNodeServer(server, this.config.server)
@@ -308,15 +309,8 @@ export class Vitest {
     return Promise.all(this.projects.map(w => w.initBrowserProvider()))
   }
 
-  typecheck(filters?: string[]) {
-    return Promise.all(this.projects.map(project => project.typecheck(filters)))
-  }
-
   async start(filters?: string[]) {
-    if (this.mode === 'typecheck') {
-      await this.typecheck(filters)
-      return
-    }
+    this._onClose = []
 
     try {
       await this.initCoverageProvider()
@@ -748,7 +742,7 @@ export class Vitest {
 
   async close() {
     if (!this.closingPromise) {
-      const closePromises = this.projects.map(w => w.close().then(() => w.server = undefined as any))
+      const closePromises: unknown[] = this.projects.map(w => w.close().then(() => w.server = undefined as any))
       // close the core workspace server only once
       // it's possible that it's not initialized at all because it's not running any tests
       if (!this.coreWorkspaceProject || !this.projects.includes(this.coreWorkspaceProject))
@@ -757,6 +751,8 @@ export class Vitest {
       if (this.pool)
         closePromises.push(this.pool.close().then(() => this.pool = undefined))
 
+      closePromises.push(...this._onClose.map(fn => fn()))
+
       this.closingPromise = Promise.allSettled(closePromises).then((results) => {
         results.filter(r => r.status === 'rejected').forEach((err) => {
           this.logger.error('error during close', (err as PromiseRejectedResult).reason)
@@ -834,4 +830,8 @@ export class Vitest {
   onCancel(fn: (reason: CancelReason) => void) {
     this._onCancelListeners.push(fn)
   }
+
+  onClose(fn: () => void) {
+    this._onClose.push(fn)
+  }
 }
diff --git a/packages/vitest/src/node/logger.ts b/packages/vitest/src/node/logger.ts
index bd18b3086..bb40205bb 100644
--- a/packages/vitest/src/node/logger.ts
+++ b/packages/vitest/src/node/logger.ts
@@ -95,10 +95,21 @@ export class Logger {
     const comma = c.dim(', ')
     if (filters?.length)
       this.console.error(c.dim('filter:  ') + c.yellow(filters.join(comma)))
-    if (config.include)
-      this.console.error(c.dim('include: ') + c.yellow(config.include.join(comma)))
-    if (config.exclude)
-      this.console.error(c.dim('exclude:  ') + c.yellow(config.exclude.join(comma)))
+    this.ctx.projects.forEach((project) => {
+      const config = project.config
+      const name = project.getName()
+      const output = project.isCore() || !name ? '' : `[${name}]`
+      if (output)
+        this.console.error(c.bgCyan(`${output} Config`))
+      if (config.include)
+        this.console.error(c.dim('include: ') + c.yellow(config.include.join(comma)))
+      if (config.exclude)
+        this.console.error(c.dim('exclude:  ') + c.yellow(config.exclude.join(comma)))
+      if (config.typecheck.enabled) {
+        this.console.error(c.dim('typecheck include: ') + c.yellow(config.typecheck.include.join(comma)))
+        this.console.error(c.dim('typecheck exclude: ') + c.yellow(config.typecheck.exclude.join(comma)))
+      }
+    })
     if (config.watchExclude)
       this.console.error(c.dim('watch exclude:  ') + c.yellow(config.watchExclude.join(comma)))
 
diff --git a/packages/vitest/src/node/pool.ts b/packages/vitest/src/node/pool.ts
index a1abf634d..f092473d1 100644
--- a/packages/vitest/src/node/pool.ts
+++ b/packages/vitest/src/node/pool.ts
@@ -9,6 +9,7 @@ import { createThreadsPool } from './pools/threads'
 import { createBrowserPool } from './pools/browser'
 import { createVmThreadsPool } from './pools/vm-threads'
 import type { WorkspaceProject } from './workspace'
+import { createTypecheckPool } from './pools/typecheck'
 
 export type WorkspaceSpec = [project: WorkspaceProject, testFile: string]
 export type RunWithFiles = (files: WorkspaceSpec[], invalidates?: string[]) => Promise<void>
@@ -35,12 +36,20 @@ export function createPool(ctx: Vitest): ProcessPool {
     threads: null,
     browser: null,
     vmThreads: null,
+    typescript: null,
   }
 
-  function getDefaultPoolName(project: WorkspaceProject): Pool {
+  function getDefaultPoolName(project: WorkspaceProject, file: string): Pool {
     if (project.config.browser.enabled)
       return 'browser'
 
+    if (project.config.typecheck.enabled) {
+      for (const glob of project.config.typecheck.include) {
+        if (mm.isMatch(file, glob, { cwd: project.config.root }))
+          return 'typescript'
+      }
+    }
+
     return project.config.pool
   }
 
@@ -51,7 +60,7 @@ export function createPool(ctx: Vitest): ProcessPool {
       if (mm.isMatch(file, glob, { cwd: project.config.root }))
         return pool as Pool
     }
-    return getDefaultPoolName(project)
+    return getDefaultPoolName(project, file)
   }
 
   async function runTests(files: WorkspaceSpec[], invalidate?: string[]) {
@@ -93,6 +102,7 @@ export function createPool(ctx: Vitest): ProcessPool {
       threads: [],
       browser: [],
       vmThreads: [],
+      typescript: [],
     }
 
     for (const spec of files) {
@@ -123,6 +133,11 @@ export function createPool(ctx: Vitest): ProcessPool {
         return pools.threads.runTests(files, invalidate)
       }
 
+      if (pool === 'typescript') {
+        pools.typescript ??= createTypecheckPool(ctx)
+        return pools.typescript.runTests(files)
+      }
+
       pools.forks ??= createChildProcessPool(ctx, options)
       return pools.forks.runTests(files, invalidate)
     }))
diff --git a/packages/vitest/src/node/pools/typecheck.ts b/packages/vitest/src/node/pools/typecheck.ts
new file mode 100644
index 000000000..a794d604f
--- /dev/null
+++ b/packages/vitest/src/node/pools/typecheck.ts
@@ -0,0 +1,123 @@
+import type { DeferPromise } from '@vitest/utils'
+import { createDefer } from '@vitest/utils'
+import type { TypecheckResults } from '../../typecheck/typechecker'
+import { Typechecker } from '../../typecheck/typechecker'
+import { groupBy } from '../../utils/base'
+import { hasFailed } from '../../utils/tasks'
+import type { Vitest } from '../core'
+import type { ProcessPool, WorkspaceSpec } from '../pool'
+import type { WorkspaceProject } from '../workspace'
+
+export function createTypecheckPool(ctx: Vitest): ProcessPool {
+  const promisesMap = new WeakMap<WorkspaceProject, DeferPromise<void>>()
+  const rerunTriggered = new WeakMap<WorkspaceProject, boolean>()
+
+  async function onParseEnd(project: WorkspaceProject, { files, sourceErrors }: TypecheckResults) {
+    const checker = project.typechecker!
+
+    await ctx.report('onTaskUpdate', checker.getTestPacks())
+
+    if (!project.config.typecheck.ignoreSourceErrors)
+      sourceErrors.forEach(error => ctx.state.catchError(error, 'Unhandled Source Error'))
+
+    const processError = !hasFailed(files) && checker.getExitCode()
+    if (processError) {
+      const error = new Error(checker.getOutput())
+      error.stack = ''
+      ctx.state.catchError(error, 'Typecheck Error')
+    }
+
+    promisesMap.get(project)?.resolve()
+
+    rerunTriggered.set(project, false)
+
+    // triggered by TSC watcher, not Vitest watcher, so we need to emulate what Vitest does in this case
+    if (ctx.config.watch && !ctx.runningPromise) {
+      await ctx.report('onFinished', files)
+      await ctx.report('onWatcherStart', files, [
+        ...(project.config.typecheck.ignoreSourceErrors ? [] : sourceErrors),
+        ...ctx.state.getUnhandledErrors(),
+      ])
+    }
+  }
+
+  async function createWorkspaceTypechecker(project: WorkspaceProject, files: string[]) {
+    const checker = project.typechecker ?? new Typechecker(project)
+    if (project.typechecker)
+      return checker
+
+    project.typechecker = checker
+    checker.setFiles(files)
+
+    checker.onParseStart(async () => {
+      ctx.state.collectFiles(checker.getTestFiles())
+      await ctx.report('onCollected')
+    })
+
+    checker.onParseEnd(result => onParseEnd(project, result))
+
+    checker.onWatcherRerun(async () => {
+      rerunTriggered.set(project, true)
+
+      if (!ctx.runningPromise) {
+        ctx.state.clearErrors()
+        await ctx.report('onWatcherRerun', files, 'File change detected. Triggering rerun.')
+      }
+
+      await checker.collectTests()
+      ctx.state.collectFiles(checker.getTestFiles())
+
+      await ctx.report('onTaskUpdate', checker.getTestPacks())
+      await ctx.report('onCollected')
+    })
+
+    await checker.prepare()
+    await checker.collectTests()
+    checker.start()
+    return checker
+  }
+
+  async function runTests(specs: WorkspaceSpec[]) {
+    const specsByProject = groupBy(specs, ([project]) => project.getName())
+    const promises: Promise<void>[] = []
+
+    for (const name in specsByProject) {
+      const project = specsByProject[name][0][0]
+      const files = specsByProject[name].map(([_, file]) => file)
+      const promise = createDefer<void>()
+      // check that watcher actually triggered rerun
+      const _p = new Promise<boolean>((resolve) => {
+        const _i = setInterval(() => {
+          if (!project.typechecker || rerunTriggered.get(project)) {
+            resolve(true)
+            clearInterval(_i)
+          }
+        })
+        setTimeout(() => {
+          resolve(false)
+          clearInterval(_i)
+        }, 500)
+      })
+      const triggered = await _p
+      if (project.typechecker && !triggered) {
+        ctx.state.collectFiles(project.typechecker.getTestFiles())
+        await ctx.report('onCollected')
+        await onParseEnd(project, project.typechecker.getResult())
+        continue
+      }
+      promises.push(promise)
+      promisesMap.set(project, promise)
+      createWorkspaceTypechecker(project, files)
+    }
+
+    await Promise.all(promises)
+  }
+
+  return {
+    runTests,
+    async close() {
+      const promises = ctx.projects.map(project => project.typechecker?.stop())
+      await Promise.all(promises)
+    },
+  }
+}
diff --git a/packages/vitest/src/node/reporters/base.ts b/packages/vitest/src/node/reporters/base.ts
index 48e9882c0..73a1c754b 100644
--- a/packages/vitest/src/node/reporters/base.ts
+++ b/packages/vitest/src/node/reporters/base.ts
@@ -30,6 +30,7 @@ export abstract class BaseReporter implements Reporter {
   private _lastRunTimer: NodeJS.Timer | undefined
   private _lastRunCount = 0
   private _timeStart = new Date()
+  private _offUnhandledRejection?: () => void
 
   constructor() {
     this.registerUnhandledRejection()
@@ -41,6 +42,9 @@ export abstract class BaseReporter implements Reporter {
 
   onInit(ctx: Vitest) {
     this.ctx = ctx
+    ctx.onClose(() => {
+      this._offUnhandledRejection?.()
+    })
     ctx.logger.printBanner()
     this.start = performance.now()
   }
@@ -114,9 +118,7 @@ export abstract class BaseReporter implements Reporter {
       this.ctx.logger.log(WAIT_FOR_CHANGE_PASS)
 
     const hints: string[] = []
-    // TODO typecheck doesn't support these for now
-    if (this.mode !== 'typecheck')
-      hints.push(HELP_HINT)
+    hints.push(HELP_HINT)
     if (failedSnap)
       hints.unshift(HELP_UPDATE_SNAP)
     else
@@ -258,19 +260,23 @@ export abstract class BaseReporter implements Reporter {
 
     logger.log(padTitle('Test Files'), getStateString(files))
     logger.log(padTitle('Tests'), getStateString(tests))
-    if (this.mode === 'typecheck') {
+    if (this.ctx.projects.some(c => c.config.typecheck.enabled)) {
       const failed = tests.filter(t => t.meta?.typecheck && t.result?.errors?.length)
       logger.log(padTitle('Type Errors'), failed.length ? c.bold(c.red(`${failed.length} failed`)) : c.dim('no errors'))
     }
     if (errors.length)
       logger.log(padTitle('Errors'), c.bold(c.red(`${errors.length} error${errors.length > 1 ? 's' : ''}`)))
     logger.log(padTitle('Start at'), formatTimeString(this._timeStart))
-    if (this.watchFilters)
+    if (this.watchFilters) {
       logger.log(padTitle('Duration'), time(threadTime))
-    else if (this.mode === 'typecheck')
-      logger.log(padTitle('Duration'), time(executionTime))
-    else
-      logger.log(padTitle('Duration'), time(executionTime) + c.dim(` (transform ${time(transformTime)}, setup ${time(setupTime)}, collect ${time(collectTime)}, tests ${time(testsTime)}, environment ${time(environmentTime)}, prepare ${time(prepareTime)})`))
+    }
+    else {
+      let timers = `transform ${time(transformTime)}, setup ${time(setupTime)}, collect ${time(collectTime)}, tests ${time(testsTime)}, environment ${time(environmentTime)}, prepare ${time(prepareTime)}`
+      const typecheck = this.ctx.projects.reduce((acc, c) => acc + (c.typechecker?.getResult().time || 0), 0)
+      if (typecheck)
+        timers += `, typecheck ${time(typecheck)}`
+      logger.log(padTitle('Duration'), time(executionTime) + c.dim(` (${timers})`))
+    }
 
     logger.log()
   }
@@ -368,11 +374,15 @@ export abstract class BaseReporter implements Reporter {
   }
 
   registerUnhandledRejection() {
-    process.on('unhandledRejection', async (err) => {
+    const onUnhandledRejection = async (err: unknown) => {
       process.exitCode = 1
       await this.ctx.logger.printError(err, { fullStack: true, type: 'Unhandled Rejection' })
       this.ctx.logger.error('\n\n')
       process.exit(1)
-    })
+    }
+    process.on('unhandledRejection', onUnhandledRejection)
+    this._offUnhandledRejection = () => {
+      process.off('unhandledRejection', onUnhandledRejection)
+    }
   }
 }
diff --git a/packages/vitest/src/node/reporters/renderers/listRenderer.ts b/packages/vitest/src/node/reporters/renderers/listRenderer.ts
index 254256da5..057a1e2f4 100644
--- a/packages/vitest/src/node/reporters/renderers/listRenderer.ts
+++ b/packages/vitest/src/node/reporters/renderers/listRenderer.ts
@@ -103,7 +103,7 @@ export function renderTree(tasks: Task[], options: ListRendererOptions, level =
     if (task.type === 'test' && task.result?.retryCount && task.result.retryCount > 0)
       suffix += c.yellow(` (retry x${task.result.retryCount})`)
 
-    if (task.type === 'suite' && !task.meta?.typecheck) {
+    if (task.type === 'suite') {
       const tests = getTests(task)
       suffix += c.dim(` (${tests.length})`)
     }
diff --git a/packages/vitest/src/node/stdin.ts b/packages/vitest/src/node/stdin.ts
index f4b3b82dc..e26a34ae6 100644
--- a/packages/vitest/src/node/stdin.ts
+++ b/packages/vitest/src/node/stdin.ts
@@ -65,10 +65,6 @@ export function registerConsoleShortcuts(ctx: Vitest) {
     if (name === 'q')
       return ctx.exit(true)
 
-    // TODO typechecking doesn't support shortcuts this yet
-    if (ctx.mode === 'typecheck')
-      return
-
     // help
     if (name === 'h')
       return printShortcutsHelp()
diff --git a/packages/vitest/src/node/workspace.ts b/packages/vitest/src/node/workspace.ts
index 947c40187..d22b22d81 100644
--- a/packages/vitest/src/node/workspace.ts
+++ b/packages/vitest/src/node/workspace.ts
@@ -8,8 +8,8 @@ import { ViteNodeServer } from 'vite-node/server'
 import c from 'picocolors'
 import { createBrowserServer } from '../integrations/browser/server'
 import type { ArgumentsType, Reporter, ResolvedConfig, UserConfig, UserWorkspaceConfig, Vitest } from '../types'
-import { deepMerge, hasFailed } from '../utils'
-import { Typechecker } from '../typecheck/typechecker'
+import { deepMerge } from '../utils'
+import type { Typechecker } from '../typecheck/typechecker'
 import type { BrowserProvider } from '../types/browser'
 import { getBrowserProvider } from '../integrations/browser'
 import { isBrowserEnabled, resolveConfig } from './config'
@@ -156,9 +156,14 @@ export class WorkspaceProject {
   async globTestFiles(filters: string[] = []) {
     const dir = this.config.dir || this.config.root
 
-    const testFiles = await this.globAllTestFiles(this.config, dir)
+    const typecheck = this.config.typecheck
 
-    return this.filterFiles(testFiles, filters, dir)
+    const [testFiles, typecheckTestFiles] = await Promise.all([
+      typecheck.enabled && typecheck.only ? [] : this.globAllTestFiles(this.config, dir),
+      typecheck.enabled ? this.globFiles(typecheck.include, typecheck.exclude, dir) : [],
+    ])
+
+    return this.filterFiles([...testFiles, ...typecheckTestFiles], filters, dir)
   }
 
   async globAllTestFiles(config: ResolvedConfig, cwd: string) {
@@ -275,68 +280,6 @@ export class WorkspaceProject {
     return this.ctx.report(name, ...args)
   }
 
-  async typecheck(filters: string[] = []) {
-    const dir = this.config.dir || this.config.root
-    const { include, exclude } = this.config.typecheck
-
-    const testFiles = await this.globFiles(include, exclude, dir)
-    const testsFilesList = this.filterFiles(testFiles, filters, dir)
-
-    const checker = new Typechecker(this, testsFilesList)
-    this.typechecker = checker
-    checker.onParseEnd(async ({ files, sourceErrors }) => {
-      this.ctx.state.collectFiles(checker.getTestFiles())
-      await this.report('onTaskUpdate', checker.getTestPacks())
-      await this.report('onCollected')
-      const failedTests = hasFailed(files)
-      const exitCode = !failedTests && checker.getExitCode()
-      if (exitCode) {
-        const error = new Error(checker.getOutput())
-        error.stack = ''
-        this.ctx.state.catchError(error, 'Typecheck Error')
-      }
-      if (!files.length) {
-        this.ctx.logger.printNoTestFound()
-      }
-      else {
-        if (failedTests)
-          process.exitCode = 1
-        await this.report('onFinished', files)
-      }
-      if (sourceErrors.length && !this.config.typecheck.ignoreSourceErrors) {
-        process.exitCode = 1
-        await this.ctx.logger.printSourceTypeErrors(sourceErrors)
-      }
-      // if there are source errors, we are showing it, and then terminating process
-      if (!files.length) {
-        const exitCode = this.config.passWithNoTests ? (process.exitCode ?? 0) : 1
-        await this.close()
-        process.exit(exitCode)
-      }
-      if (this.config.watch) {
-        await this.report('onWatcherStart', files, [
-          ...(this.config.typecheck.ignoreSourceErrors ? [] : sourceErrors),
-          ...this.ctx.state.getUnhandledErrors(),
-        ])
-      }
-    })
-    checker.onParseStart(async () => {
-      await this.report('onInit', this.ctx)
-      this.ctx.state.collectFiles(checker.getTestFiles())
-      await this.report('onCollected')
-    })
-    checker.onWatcherRerun(async () => {
-      await this.report('onWatcherRerun', testsFilesList, 'File change detected. Triggering rerun.')
-      await checker.collectTests()
-      this.ctx.state.collectFiles(checker.getTestFiles())
-      await this.report('onTaskUpdate', checker.getTestPacks())
-      await this.report('onCollected')
-    })
-    await checker.prepare()
-    await checker.collectTests()
-    await checker.start()
-  }
-
   isBrowserEnabled() {
     return isBrowserEnabled(this.config)
   }
diff --git a/packages/vitest/src/runtime/execute.ts b/packages/vitest/src/runtime/execute.ts
index 52c008edf..d4085e2e2 100644
--- a/packages/vitest/src/runtime/execute.ts
+++ b/packages/vitest/src/runtime/execute.ts
@@ -87,6 +87,8 @@ export async function startVitestExecutor(options: ContextExecutorOptions) {
     rpc().onUnhandledError(error, type)
   }
 
+  process.setMaxListeners(25)
+
   process.on('uncaughtException', e => catchError(e, 'Uncaught Exception'))
   process.on('unhandledRejection', e => catchError(e, 'Unhandled Rejection'))
 
diff --git a/packages/vitest/src/typecheck/collect.ts b/packages/vitest/src/typecheck/collect.ts
index 97e079b44..85be33376 100644
--- a/packages/vitest/src/typecheck/collect.ts
+++ b/packages/vitest/src/typecheck/collect.ts
@@ -57,6 +57,7 @@ export async function collectTests(ctx: WorkspaceProject, filepath: string): Pro
     tasks: [],
     start: ast.start,
     end: ast.end,
+    projectName: ctx.getName(),
     meta: { typecheck: true },
   }
   const definitions: LocalCallDefinition[] = []
@@ -122,6 +123,7 @@ export async function collectTests(ctx: WorkspaceProject, filepath: string): Pro
         name: definition.name,
         end: definition.end,
         start: definition.start,
+        projectName: ctx.getName(),
         meta: {
           typecheck: true,
         },
diff --git a/packages/vitest/src/typecheck/typechecker.ts b/packages/vitest/src/typecheck/typechecker.ts
index e56ce36fc..5475d8a0e 100644
--- a/packages/vitest/src/typecheck/typechecker.ts
+++ b/packages/vitest/src/typecheck/typechecker.ts
@@ -1,4 +1,5 @@
 import { rm } from 'node:fs/promises'
+import { performance } from 'node:perf_hooks'
 import type { ExecaChildProcess } from 'execa'
 import { execa } from 'execa'
 import { basename, extname, resolve } from 'pathe'
@@ -21,35 +22,44 @@ export class TypeCheckError extends Error {
   }
 }
 
-interface ErrorsCache {
+export interface TypecheckResults {
   files: File[]
   sourceErrors: TypeCheckError[]
+  time: number
 }
 
 type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>
 
 export class Typechecker {
   private _onParseStart?: Callback
-  private _onParseEnd?: Callback<[ErrorsCache]>
+  private _onParseEnd?: Callback<[TypecheckResults]>
   private _onWatcherRerun?: Callback
-  private _result: ErrorsCache = {
+  private _result: TypecheckResults = {
     files: [],
     sourceErrors: [],
+    time: 0,
   }
 
+  private _startTime = 0
   private _output = ''
   private _tests: Record<string, FileInformation> | null = {}
   private tempConfigPath?: string
   private allowJs?: boolean
   private process?: ExecaChildProcess
 
-  constructor(protected ctx: WorkspaceProject, protected files: string[]) { }
+  protected files: string[] = []
+
+  constructor(protected ctx: WorkspaceProject) { }
+
+  public setFiles(files: string[]) {
+    this.files = files
+  }
 
   public onParseStart(fn: Callback) {
     this._onParseStart = fn
   }
 
-  public onParseEnd(fn: Callback<[ErrorsCache]>) {
+  public onParseEnd(fn: Callback<[TypecheckResults]>) {
     this._onParseEnd = fn
   }
 
@@ -165,6 +175,7 @@ export class Typechecker {
     return {
       files,
       sourceErrors,
+      time: performance.now() - this._startTime,
     }
   }
 
@@ -187,7 +198,14 @@ export class Typechecker {
         Error.stackTraceLimit = limit
         return {
           originalError: info,
-          error,
+          error: {
+            name: error.name,
+            nameStr: String(error.name),
+            message: info.errMsg,
+            stacks: error.stacks,
+            stack: '',
+            stackStr: '',
+          },
         }
       })
       typesErrors.set(filepath, suiteErrors)
@@ -243,6 +261,7 @@ export class Typechecker {
     if (typecheck.allowJs)
       args.push('--allowJs', '--checkJs')
     this._output = ''
+    this._startTime = performance.now()
     const child = execa(typecheck.checker, args, {
       cwd: root,
       stdout: 'pipe',
@@ -257,6 +276,7 @@ export class Typechecker {
         return
       if (this._output.includes('File change detected') && !rerunTriggered) {
         this._onWatcherRerun?.()
+        this._startTime = performance.now()
         this._result.sourceErrors = []
         this._result.files = []
         this._tests = null // test structure might've changed
@@ -290,6 +310,6 @@ export class Typechecker {
     return Object.values(this._tests || {})
       .map(({ file }) => getTasks(file))
       .flat()
-      .map<TaskResultPack>(i => [i.id, undefined, { typecheck: true }])
+      .map<TaskResultPack>(i => [i.id, i.result, { typecheck: true }])
   }
 }
diff --git a/packages/vitest/src/types/config.ts b/packages/vitest/src/types/config.ts
index 4bc137329..b5f9e83e2 100644
--- a/packages/vitest/src/types/config.ts
+++ b/packages/vitest/src/types/config.ts
@@ -37,7 +37,7 @@ export interface EnvironmentOptions {
   [x: string]: unknown
 }
 
-export type VitestRunMode = 'test' | 'benchmark' | 'typecheck'
+export type VitestRunMode = 'test' | 'benchmark'
 
 interface SequenceOptions {
   /**
@@ -635,6 +635,14 @@ export interface InlineConfig {
 }
 
 export interface TypecheckConfig {
+  /**
+   * Run typechecking tests alongisde regular tests.
+   */
+  enabled?: boolean
+  /**
+   * When typechecking is enabled, only run typechecking tests.
+   */
+  only?: boolean
   /**
    * What tools to use for type checking.
    */
@@ -749,7 +757,9 @@ export interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'f
     seed: number
   }
 
-  typecheck: TypecheckConfig
+  typecheck: Omit<TypecheckConfig, 'enabled'> & {
+    enabled: boolean
+  }
   runner?: string
 }
 
diff --git a/packages/vitest/src/types/pool-options.ts b/packages/vitest/src/types/pool-options.ts
index c77b3c536..eb874614e 100644
--- a/packages/vitest/src/types/pool-options.ts
+++ b/packages/vitest/src/types/pool-options.ts
@@ -1,4 +1,4 @@
-export type Pool = 'browser' | 'threads' | 'forks' | 'vmThreads' // | 'vmForks'
+export type Pool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'typescript' // | 'vmForks'
 
 export interface PoolOptions {
   /**
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1e3ca72c1..a34a79b86 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1194,6 +1194,9 @@ importers:
       '@faker-js/faker':
         specifier: ^8.0.2
         version: 8.0.2
+      '@iconify-json/logos':
+        specifier: ^1.1.37
+        version: 1.1.37
       '@testing-library/cypress':
         specifier: ^9.0.0
         version: 9.0.0(cypress@12.16.0)
@@ -2948,7 +2951,7 @@ packages:
     dependencies:
       '@babel/core': 7.22.5
       '@babel/helper-environment-visitor': 7.22.5
-      '@babel/helper-module-imports': 7.22.5
+      '@babel/helper-module-imports': 7.22.15
       '@babel/helper-simple-access': 7.22.5
       '@babel/helper-split-export-declaration': 7.22.6
       '@babel/helper-validator-identifier': 7.22.20
@@ -6266,6 +6269,12 @@ packages:
       '@iconify/types': 2.0.0
     dev: true
 
+  /@iconify-json/logos@1.1.37:
+    resolution: {integrity: sha512-H2S8frTEznk6paX2kMzeUGn4KSiykghvO0b8UvEDd1fFFzt0WxCXpP1tBv67XaWK99e6JgA34hhv4lRGAm1hJg==}
+    dependencies:
+      '@iconify/types': 2.0.0
+    dev: true
+
   /@iconify/types@2.0.0:
     resolution: {integrity: sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==}
     dev: true
@@ -18535,7 +18544,7 @@ packages:
       '@jest/types': 27.5.1
       '@types/graceful-fs': 4.1.5
       '@types/node': 18.16.19
-      anymatch: 3.1.2
+      anymatch: 3.1.3
       fb-watchman: 2.0.1
       graceful-fs: 4.2.10
       jest-regex-util: 27.5.1
diff --git a/test/coverage-test/package.json b/test/coverage-test/package.json
index 16525ea6e..a2ab46d6e 100644
--- a/test/coverage-test/package.json
+++ b/test/coverage-test/package.json
@@ -8,7 +8,7 @@
     "test:istanbul": "node ./testing.mjs --provider istanbul",
     "test:browser": "node ./testing.mjs --browser --provider istanbul",
     "test:options": "node ./testing-options.mjs",
-    "test:types": "vitest typecheck --run --reporter verbose"
+    "test:types": "vitest --typecheck.only --run --reporter verbose"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "^2.0.4",
diff --git a/test/typescript/package.json b/test/typescript/package.json
index e1557eb23..d3a5ec4b6 100644
--- a/test/typescript/package.json
+++ b/test/typescript/package.json
@@ -1,7 +1,7 @@
 {
   "scripts": {
     "test": "vitest",
-    "types": "vitest typecheck --run",
+    "types": "vitest --typecheck --run",
     "tsc": "tsc --watch --pretty false --noEmit"
   },
   "dependencies": {
diff --git a/test/typescript/test/runner.test.ts b/test/typescript/test/runner.test.ts
index bbbc539f3..1a7a11e20 100644
--- a/test/typescript/test/runner.test.ts
+++ b/test/typescript/test/runner.test.ts
@@ -13,10 +13,11 @@ describe('should fail', async () => {
       root,
       dir: './failing',
       typecheck: {
+        enabled: true,
         allowJs: true,
         include: ['**/*.test-d.*'],
       },
-    }, [], 'typecheck')
+    }, [])
 
     expect(stderr).toBeTruthy()
     const lines = String(stderr).split(/\n/g)
@@ -44,12 +45,12 @@ describe('should fail', async () => {
   it('typecheks with custom tsconfig', async () => {
     const { stderr } = await runVitestCli(
       { cwd: root, env: { ...process.env, CI: 'true' } },
-      'typecheck',
       '--run',
       '--dir',
       resolve(__dirname, '..', './failing'),
       '--config',
       resolve(__dirname, './vitest.custom.config.ts'),
+      '--typecheck.enabled',
     )
 
     expect(stderr).toBeTruthy()
@@ -85,12 +86,12 @@ describe('should fail', async () => {
           NO_COLOR: 'true',
         },
       },
-      'typecheck',
       '--run',
       '--dir',
       resolve(__dirname, '..', './failing'),
       '--config',
       resolve(__dirname, './vitest.empty.config.ts'),
+      '--typecheck.enabled',
     )
 
     expect(stderr.replace(resolve(__dirname, '..'), '<root>')).toMatchSnapshot()
diff --git a/test/typescript/test/vitest.custom.config.ts b/test/typescript/test/vitest.custom.config.ts
index fe059cc66..8cde5c059 100644
--- a/test/typescript/test/vitest.custom.config.ts
+++ b/test/typescript/test/vitest.custom.config.ts
@@ -3,6 +3,7 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     typecheck: {
+      enabled: true,
       allowJs: true,
       include: ['**/*.test-d.*'],
       tsconfig: '../tsconfig.custom.json',
diff --git a/test/typescript/test/vitest.empty.config.ts b/test/typescript/test/vitest.empty.config.ts
index 96d934964..06ac35b4d 100644
--- a/test/typescript/test/vitest.empty.config.ts
+++ b/test/typescript/test/vitest.empty.config.ts
@@ -3,6 +3,7 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     typecheck: {
+      enabled: true,
       include: ['**/fail.test-d.ts'],
       tsconfig: '../tsconfig.empty.json',
     },
-- 
2.51.2