fix: fix capturePrintError logger duplicate event handlers

Author: hi-ogawa

packages/vitest/src/node/error.ts

@@ -1,8 +1,9 @@
 import type { ErrorWithDiff, ParsedStack } from '@vitest/utils'
 import type { Vitest } from './core'
-import type { ErrorOptions } from './logger'
+import type { ErrorOptions, Logger } from './logger'
 import type { TestProject } from './project'
 /* eslint-disable prefer-template */
+import { Console } from 'node:console'
 import { existsSync, readFileSync } from 'node:fs'
 import { Writable } from 'node:stream'
 import { stripVTControlCharacters } from 'node:util'
@@ -12,22 +13,24 @@ import c from 'tinyrainbow'
 import { TypeCheckError } from '../typecheck/typechecker'
 import {
   lineSplitRE,
+  parseErrorStacktrace,
   positionToOffset,
 } from '../utils/source-map'
-import { Logger } from './logger'
 import { F_POINTER } from './reporters/renderers/figures'
 import { divider, truncateString } from './reporters/renderers/utils'
 
+type ErrorLogger = Pick<Logger, 'error' | 'highlight'>
+
 interface PrintErrorOptions {
+  logger: ErrorLogger
   type?: string
-  logger: Logger
   showCodeFrame?: boolean
   printProperties?: boolean
   screenshotPaths?: string[]
   parseErrorStacktrace: (error: ErrorWithDiff) => ParsedStack[]
 }
 
-export interface PrintErrorResult {
+interface PrintErrorResult {
   nearest?: ParsedStack
 }
 
@@ -44,15 +47,52 @@ export function capturePrintError(
       callback()
     },
   })
-  const logger = new Logger(ctx, writable, writable)
-  const result = logger.printError(error, {
-    showCodeFrame: false,
+  const console = new Console(writable)
+  const logger: ErrorLogger = {
+    error: console.error.bind(console),
+    highlight: ctx.logger.highlight.bind(ctx.logger),
+  }
+  const result = printError(error, ctx, logger, {
     ...options,
+    showCodeFrame: false,
   })
   return { nearest: result?.nearest, output }
 }
 
 export function printError(
+  error: unknown,
+  ctx: Vitest,
+  logger: ErrorLogger,
+  options: ErrorOptions,
+) {
+  const project = options.project
+    ?? ctx.coreWorkspaceProject
+    ?? ctx.projects[0]
+  return printErrorInner(error, project, {
+    logger,
+    type: options.type,
+    showCodeFrame: options.showCodeFrame,
+    screenshotPaths: options.screenshotPaths,
+    printProperties: options.verbose,
+    parseErrorStacktrace(error) {
+      // browser stack trace needs to be processed differently,
+      // so there is a separate method for that
+      if (options.task?.file.pool === 'browser' && project.browser) {
+        return project.browser.parseErrorStacktrace(error, {
+          ignoreStackEntries: options.fullStack ? [] : undefined,
+        })
+      }
+
+      // node.js stack trace already has correct source map locations
+      return parseErrorStacktrace(error, {
+        frameFilter: project.config.onStackTrace,
+        ignoreStackEntries: options.fullStack ? [] : undefined,
+      })
+    },
+  })
+}
+
+function printErrorInner(
   error: unknown,
   project: TestProject | undefined,
   options: PrintErrorOptions,
@@ -129,7 +169,7 @@ export function printError(
 
   // E.g. AssertionError from assert does not set showDiff but has both actual and expected properties
   if (e.diff) {
-    displayDiff(e.diff, logger.console)
+    displayDiff(e.diff, logger)
   }
 
   // if the error provide the frame
@@ -193,7 +233,7 @@ export function printError(
 
   if (typeof e.cause === 'object' && e.cause && 'name' in e.cause) {
     (e.cause as any).name = `Caused by: ${(e.cause as any).name}`
-    printError(e.cause, project, {
+    printErrorInner(e.cause, project, {
       showCodeFrame: false,
       logger: options.logger,
       parseErrorStacktrace: options.parseErrorStacktrace,
@@ -251,7 +291,7 @@ const esmErrors = [
   'Unexpected token \'export\'',
 ]
 
-function handleImportOutsideModuleError(stack: string, logger: Logger) {
+function handleImportOutsideModuleError(stack: string, logger: ErrorLogger) {
   if (!esmErrors.some(e => stack.includes(e))) {
     return
   }
@@ -274,7 +314,7 @@ function handleImportOutsideModuleError(stack: string, logger: Logger) {
 }
 
 function printModuleWarningForPackage(
-  logger: Logger,
+  logger: ErrorLogger,
   path: string,
   name: string,
 ) {
@@ -305,7 +345,7 @@ function printModuleWarningForPackage(
   )
 }
 
-function printModuleWarningForSourceCode(logger: Logger, path: string) {
+function printModuleWarningForSourceCode(logger: ErrorLogger, path: string) {
   logger.error(
     c.yellow(
       `Module ${path} seems to be an ES Module but shipped in a CommonJS package. `
@@ -314,13 +354,13 @@ function printModuleWarningForSourceCode(logger: Logger, path: string) {
   )
 }
 
-export function displayDiff(diff: string | undefined, console: Console) {
+function displayDiff(diff: string | undefined, logger: ErrorLogger) {
   if (diff) {
-    console.error(`\n${diff}\n`)
+    logger.error(`\n${diff}\n`)
   }
 }
 
-function printErrorMessage(error: ErrorWithDiff, logger: Logger) {
+function printErrorMessage(error: ErrorWithDiff, logger: ErrorLogger) {
   const errorName = error.name || error.nameStr || 'Unknown Error'
   if (!error.message) {
     logger.error(error)
@@ -335,8 +375,8 @@ function printErrorMessage(error: ErrorWithDiff, logger: Logger) {
   }
 }
 
-export function printStack(
-  logger: Logger,
+function printStack(
+  logger: ErrorLogger,
   project: TestProject,
   stack: ParsedStack[],
   highlight: ParsedStack | undefined,

packages/vitest/src/node/logger.ts

@@ -3,11 +3,9 @@ import type { ErrorWithDiff } from '@vitest/utils'
 import type { Writable } from 'node:stream'
 import type { TypeCheckError } from '../typecheck/typechecker'
 import type { Vitest } from './core'
-import type { PrintErrorResult } from './error'
 import type { TestProject } from './project'
 import { Console } from 'node:console'
 import { toArray } from '@vitest/utils'
-import { parseErrorStacktrace } from '@vitest/utils/source-map'
 import c from 'tinyrainbow'
 import { highlightCode } from '../utils/colors'
 import { printError } from './error'
@@ -106,33 +104,8 @@ export class Logger {
     this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`)
   }
 
-  printError(err: unknown, options: ErrorOptions = {}): PrintErrorResult | undefined {
-    const { fullStack = false, type } = options
-    const project = options.project
-      ?? this.ctx.coreWorkspaceProject
-      ?? this.ctx.projects[0]
-    return printError(err, project, {
-      type,
-      showCodeFrame: options.showCodeFrame ?? true,
-      logger: this,
-      printProperties: options.verbose,
-      screenshotPaths: options.screenshotPaths,
-      parseErrorStacktrace: (error) => {
-        // browser stack trace needs to be processed differently,
-        // so there is a separate method for that
-        if (options.task?.file.pool === 'browser' && project.browser) {
-          return project.browser.parseErrorStacktrace(error, {
-            ignoreStackEntries: fullStack ? [] : undefined,
-          })
-        }
-
-        // node.js stack trace already has correct source map locations
-        return parseErrorStacktrace(error, {
-          frameFilter: project.config.onStackTrace,
-          ignoreStackEntries: fullStack ? [] : undefined,
-        })
-      },
-    })
+  printError(err: unknown, options: ErrorOptions = {}) {
+    printError(err, this.ctx, this, options)
   }
 
   clearHighlightCache(filename?: string) {