perf: reduce the amount of dynamic imports (#8465)

Author: sheremet-va

packages/vitest/src/integrations/chai/index.ts

@@ -11,7 +11,7 @@ import {
 } from '@vitest/expect'
 import { getCurrentTest } from '@vitest/runner'
 import { getTestName } from '@vitest/runner/utils'
-import { getCurrentEnvironment, getWorkerState } from '../../runtime/utils'
+import { getWorkerState } from '../../runtime/utils'
 import { createExpectPoll } from './poll'
 import './setup'
 
@@ -47,7 +47,6 @@ export function createExpect(test?: TaskPopulated): ExpectStatic {
       isExpectingAssertionsError: null,
       expectedAssertionsNumber: null,
       expectedAssertionsNumberErrorGen: null,
-      environment: getCurrentEnvironment(),
       get testPath() {
         return getWorkerState().filepath
       },

packages/vitest/src/integrations/vi.ts

@@ -422,23 +422,22 @@ export interface VitestUtils {
   setConfig: (config: RuntimeOptions) => void
 
   /**
-   * If config was changed with `vi.setConfig`, this will reset it to the original state.
+   * If config was changed with `vi.setConfig`, this will reset it to the original state().
    */
   resetConfig: () => void
 }
 
 function createVitest(): VitestUtils {
-  let _mockedDate: Date | null = null
   let _config: null | SerializedConfig = null
 
-  const workerState = getWorkerState()
+  const state = () => getWorkerState()
 
   let _timers: FakeTimers
 
   const timers = () =>
     (_timers ||= new FakeTimers({
       global: globalThis,
-      config: workerState.config.fakeTimers,
+      config: state().config.fakeTimers,
     }))
 
   const _stubsGlobal = new Map<
@@ -454,7 +453,7 @@ function createVitest(): VitestUtils {
       if (isChildProcess()) {
         if (
           config?.toFake?.includes('nextTick')
-          || workerState.config?.fakeTimers?.toFake?.includes('nextTick')
+          || state().config?.fakeTimers?.toFake?.includes('nextTick')
         ) {
           throw new Error(
             'vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.',
@@ -463,10 +462,10 @@ function createVitest(): VitestUtils {
       }
 
       if (config) {
-        timers().configure({ ...workerState.config.fakeTimers, ...config })
+        timers().configure({ ...state().config.fakeTimers, ...config })
       }
       else {
-        timers().configure(workerState.config.fakeTimers)
+        timers().configure(state().config.fakeTimers)
       }
 
       timers().useFakeTimers()
@@ -479,7 +478,6 @@ function createVitest(): VitestUtils {
 
     useRealTimers() {
       timers().useRealTimers()
-      _mockedDate = null
       return utils
     },
 
@@ -687,8 +685,7 @@ function createVitest(): VitestUtils {
     },
 
     stubEnv(name: string, value: string | boolean | undefined) {
-      const state = getWorkerState()
-      const env = state.metaEnv
+      const env = state().metaEnv
       if (!_stubsEnv.has(name)) {
         _stubsEnv.set(name, env[name])
       }
@@ -718,8 +715,7 @@ function createVitest(): VitestUtils {
     },
 
     unstubAllEnvs() {
-      const state = getWorkerState()
-      const env = state.metaEnv
+      const env = state().metaEnv
       _stubsEnv.forEach((original, name) => {
         if (original === undefined) {
           delete env[name]
@@ -733,7 +729,7 @@ function createVitest(): VitestUtils {
     },
 
     resetModules() {
-      resetModules(workerState.evaluatedModules)
+      resetModules(state().evaluatedModules)
       return utils
     },
 
@@ -743,14 +739,14 @@ function createVitest(): VitestUtils {
 
     setConfig(config: RuntimeOptions) {
       if (!_config) {
-        _config = { ...workerState.config }
+        _config = { ...state().config }
       }
-      Object.assign(workerState.config, config)
+      Object.assign(state().config, config)
     },
 
     resetConfig() {
       if (_config) {
-        Object.assign(workerState.config, _config)
+        Object.assign(state().config, _config)
       }
     },
   }

packages/vitest/src/node/config/serializeConfig.ts

@@ -1,11 +1,9 @@
-import type { ResolvedConfig as ViteConfig } from 'vite'
-import type { ResolvedConfig, SerializedConfig } from '../types/config'
+import type { TestProject } from '../project'
+import type { SerializedConfig } from '../types/config'
 
-export function serializeConfig(
-  config: ResolvedConfig,
-  coreConfig: ResolvedConfig,
-  viteConfig: ViteConfig | undefined,
-): SerializedConfig {
+export function serializeConfig(project: TestProject): SerializedConfig {
+  const { config, globalConfig } = project
+  const viteConfig = project._vite?.config
   const optimizer = config.deps?.optimizer || {}
   const poolOptions = config.poolOptions
 
@@ -69,35 +67,35 @@ export function serializeConfig(
       forks: {
         singleFork:
           poolOptions?.forks?.singleFork
-          ?? coreConfig.poolOptions?.forks?.singleFork
+          ?? globalConfig.poolOptions?.forks?.singleFork
           ?? false,
         isolate:
           poolOptions?.forks?.isolate
           ?? isolate
-          ?? coreConfig.poolOptions?.forks?.isolate
+          ?? globalConfig.poolOptions?.forks?.isolate
           ?? true,
       },
       threads: {
         singleThread:
           poolOptions?.threads?.singleThread
-          ?? coreConfig.poolOptions?.threads?.singleThread
+          ?? globalConfig.poolOptions?.threads?.singleThread
           ?? false,
         isolate:
           poolOptions?.threads?.isolate
           ?? isolate
-          ?? coreConfig.poolOptions?.threads?.isolate
+          ?? globalConfig.poolOptions?.threads?.isolate
           ?? true,
       },
       vmThreads: {
         singleThread:
           poolOptions?.vmThreads?.singleThread
-          ?? coreConfig.poolOptions?.vmThreads?.singleThread
+          ?? globalConfig.poolOptions?.vmThreads?.singleThread
           ?? false,
       },
       vmForks: {
         singleFork:
           poolOptions?.vmForks?.singleFork
-          ?? coreConfig.poolOptions?.vmForks?.singleFork
+          ?? globalConfig.poolOptions?.vmForks?.singleFork
           ?? false,
       },
     },
@@ -113,28 +111,28 @@ export function serializeConfig(
     snapshotOptions: {
       // TODO: store it differently, not on the config
       snapshotEnvironment: undefined!,
-      updateSnapshot: coreConfig.snapshotOptions.updateSnapshot,
+      updateSnapshot: globalConfig.snapshotOptions.updateSnapshot,
       snapshotFormat: {
-        ...coreConfig.snapshotOptions.snapshotFormat,
+        ...globalConfig.snapshotOptions.snapshotFormat,
       },
       expand:
         config.snapshotOptions.expand
-        ?? coreConfig.snapshotOptions.expand,
+        ?? globalConfig.snapshotOptions.expand,
     },
     sequence: {
-      shuffle: coreConfig.sequence.shuffle,
-      concurrent: coreConfig.sequence.concurrent,
-      seed: coreConfig.sequence.seed,
-      hooks: coreConfig.sequence.hooks,
-      setupFiles: coreConfig.sequence.setupFiles,
+      shuffle: globalConfig.sequence.shuffle,
+      concurrent: globalConfig.sequence.concurrent,
+      seed: globalConfig.sequence.seed,
+      hooks: globalConfig.sequence.hooks,
+      setupFiles: globalConfig.sequence.setupFiles,
     },
-    inspect: coreConfig.inspect,
-    inspectBrk: coreConfig.inspectBrk,
-    inspector: coreConfig.inspector,
+    inspect: globalConfig.inspect,
+    inspectBrk: globalConfig.inspectBrk,
+    inspector: globalConfig.inspector,
     watch: config.watch,
     includeTaskLocation:
       config.includeTaskLocation
-      ?? coreConfig.includeTaskLocation,
+      ?? globalConfig.includeTaskLocation,
     env: {
       ...viteConfig?.env,
       ...config.env,
@@ -161,9 +159,13 @@ export function serializeConfig(
     })(config.browser),
     standalone: config.standalone,
     printConsoleTrace:
-      config.printConsoleTrace ?? coreConfig.printConsoleTrace,
+      config.printConsoleTrace ?? globalConfig.printConsoleTrace,
     benchmark: config.benchmark && {
       includeSamples: config.benchmark.includeSamples,
     },
+    // the browser initialized them via `@vite/env` import
+    serializedDefines: config.browser.enabled
+      ? ''
+      : project._serializedDefines || '',
   }
 }

packages/vitest/src/node/project.ts

@@ -22,6 +22,7 @@ import { isAbsolute, join, relative } from 'pathe'
 import pm from 'picomatch'
 import { glob } from 'tinyglobby'
 import { setup } from '../api/setup'
+import { createDefinesScript } from '../utils/config-helpers'
 import { isBrowserEnabled, resolveConfig } from './config/resolveConfig'
 import { serializeConfig } from './config/serializeConfig'
 import { ServerModuleRunner } from './environments/serverRunner'
@@ -62,6 +63,7 @@ export class TestProject {
   /** @internal */ _vite?: ViteDevServer
   /** @internal */ _hash?: string
   /** @internal */ _resolver!: VitestResolver
+  /** @internal */ _serializedDefines?: string
   /** @inetrnal */ testFilesList: string[] | null = null
 
   private runner!: ModuleRunner
@@ -555,6 +557,7 @@ export class TestProject {
 
     this._resolver = new VitestResolver(server.config.cacheDir, this._config)
     this._vite = server
+    this._serializedDefines = createDefinesScript(server.config.define)
 
     const environment = server.environments.__vitest__
     this.runner = new ServerModuleRunner(
@@ -566,11 +569,7 @@ export class TestProject {
 
   private _serializeOverriddenConfig(): SerializedConfig {
     // TODO: serialize the config _once_ or when needed
-    const config = serializeConfig(
-      this.config,
-      this.vitest.config,
-      this.vite.config,
-    )
+    const config = serializeConfig(this)
     if (!this.vitest.configOverride) {
       return config
     }
@@ -619,6 +618,7 @@ export class TestProject {
     project._vite = vitest.vite
     project._config = vitest.config
     project._resolver = vitest._resolver
+    project._serializedDefines = createDefinesScript(vitest.vite.config.define)
     project._setHash()
     project._provideObject(vitest.config.provide)
     return project
@@ -633,6 +633,7 @@ export class TestProject {
     clone._config = config
     clone._setHash()
     clone._parent = parent
+    clone._serializedDefines = parent._serializedDefines
     clone._provideObject(config.provide)
     return clone
   }

packages/vitest/src/runtime/config.ts

@@ -130,6 +130,7 @@ export interface SerializedConfig {
   benchmark: {
     includeSamples: boolean
   } | undefined
+  serializedDefines: string
 }
 
 export interface SerializedCoverageConfig {

packages/vitest/src/runtime/moduleRunner/moduleMocker.ts

@@ -20,7 +20,7 @@ interface MockContext {
 
 export interface VitestMockerOptions {
   context?: vm.Context
-
+  spyModule?: typeof import('@vitest/spy')
   root: string
   moduleDirectories: string[]
   resolveId: (id: string, importer?: string) => Promise<{
@@ -72,6 +72,10 @@ export class VitestMocker {
       }
     }
 
+    if (options.spyModule) {
+      this.spyModule = options.spyModule
+    }
+
     const Symbol = this.primitives.Symbol
 
     this.filterPublicKeys = [

packages/vitest/src/runtime/moduleRunner/moduleRunner.ts

@@ -29,6 +29,7 @@ export class VitestModuleRunner extends ModuleRunner {
     )
     this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo
     this.mocker = options.mocker || new VitestMocker(this, {
+      spyModule: options.spyModule,
       context: options.vm?.context,
       resolveId: options.transport.resolveId,
       get root() {
@@ -143,6 +144,7 @@ export interface VitestModuleRunnerOptions {
   getWorkerState: () => WorkerGlobalState
   mocker?: VitestMocker
   vm?: VitestVmOptions
+  spyModule?: typeof import('@vitest/spy')
 }
 
 export interface VitestVmOptions {

packages/vitest/src/runtime/moduleRunner/startModuleRunner.ts

@@ -25,12 +25,13 @@ export interface ContextModuleRunnerOptions {
   context?: vm.Context
   externalModulesExecutor?: ExternalModulesExecutor
   state: WorkerGlobalState
+  spyModule?: typeof import('@vitest/spy')
 }
 
 const cwd = process.cwd()
 const isWindows = process.platform === 'win32'
 
-export async function startVitestModuleRunner(options: ContextModuleRunnerOptions): Promise<VitestModuleRunner> {
+export function startVitestModuleRunner(options: ContextModuleRunnerOptions): VitestModuleRunner {
   const state = (): WorkerGlobalState =>
     // @ts-expect-error injected untyped global
     globalThis.__vitest_worker__ || options.state
@@ -68,6 +69,7 @@ export async function startVitestModuleRunner(options: ContextModuleRunnerOption
   )
 
   const moduleRunner: VitestModuleRunner = new VitestModuleRunner({
+    spyModule: options.spyModule,
     evaluatedModules: options.evaluatedModules,
     evaluator,
     mocker: options.mocker,
@@ -161,8 +163,8 @@ export async function startVitestModuleRunner(options: ContextModuleRunnerOption
     vm,
   })
 
-  await moduleRunner.import('/@vite/env')
-  await moduleRunner.mocker.initializeSpyModule()
+  // await moduleRunner.import('/@vite/env')
+  // await moduleRunner.mocker.initializeSpyModule()
 
   return moduleRunner
 }

packages/vitest/src/runtime/runVmTests.ts

@@ -36,6 +36,9 @@ export async function run(
   })
 
   const viteEnvironment = workerState.environment.viteEnvironment || workerState.environment.name
+  VitestIndex.expect.setState({
+    environment: workerState.environment.name,
+  })
   if (viteEnvironment === 'client') {
     const _require = createRequire(import.meta.url)
     // always mock "required" `css` files, because we cannot process them