fix: unintended version of espree loaded

Author: ota-meshi

src/common/espree.ts

@@ -2,7 +2,7 @@ import type { ParserOptions } from "../common/parser-options"
 import { getLinterRequire } from "./linter-require"
 // @ts-expect-error -- ignore
 import * as dependencyEspree from "espree"
-import { lte, lt } from "semver"
+import { lte, satisfies } from "semver"
 import { createRequire } from "./create-require"
 import path from "path"
 import type { BasicParserObject } from "./parser-object"
@@ -11,73 +11,100 @@ type Espree = BasicParserObject & {
     latestEcmaVersion?: number
     version: string
 }
-let espreeCache: Espree | null = null
-
-/**
- * Gets the espree that the given ecmaVersion can parse.
- */
-export function getEspreeFromEcmaVersion(
-    ecmaVersion: ParserOptions["ecmaVersion"],
-): Espree {
-    const linterEspree = getEspreeFromLinter()
-    if (ecmaVersion == null) {
-        return linterEspree
-    }
-    if (ecmaVersion === "latest") {
-        return getNewestEspree()
-    }
-    if (
-        normalizeEcmaVersion(ecmaVersion) <= getLatestEcmaVersion(linterEspree)
-    ) {
-        return linterEspree
-    }
-    const userEspree = getEspreeFromUser()
-    if (normalizeEcmaVersion(ecmaVersion) <= getLatestEcmaVersion(userEspree)) {
-        return userEspree
-    }
-    return linterEspree
-}
 
 /**
  * Load `espree` from the user dir.
  */
-export function getEspreeFromUser(): Espree {
+function getEspreeFromUser(): Espree {
     try {
         const cwd = process.cwd()
         const relativeTo = path.join(cwd, "__placeholder__.js")
-        return createRequire(relativeTo)("espree")
+        const require = createRequire(relativeTo)
+        const espree = getEspreeFromRequireFunction(require)
+        if (espree) {
+            if (espree !== dependencyEspree) {
+                return espree
+            }
+            // If the user's espree is the same as the parser package's dependency espree,
+            // it checks whether the user has explicitly installed it.
+            if (isExplicitlyInstalledEspree(require as NodeRequire)) {
+                return espree
+            }
+        }
     } catch {
-        return getEspreeFromLinter()
+        // ignore
+    }
+    return getEspreeFromLinter()
+
+    function isExplicitlyInstalledEspree(require: NodeRequire): boolean {
+        try {
+            const espreeRootPath = path.dirname(
+                require.resolve("espree/package.json"),
+            )
+            const nodeModulesPath = path.dirname(espreeRootPath)
+            const packageRootPath = path.dirname(nodeModulesPath)
+            let pkg
+            try {
+                pkg = require(path.join(packageRootPath, "package.json"))
+            } catch {
+                // ignore
+            }
+            if (pkg) {
+                return Boolean(
+                    pkg.dependencies?.espree || pkg.devDependencies?.espree,
+                )
+            }
+        } catch {
+            // ignore
+        }
+        // If no package.json is found,
+        // it is assumed to have been explicitly installed by the user.
+        return true
     }
 }
 
 /**
  * Load `espree` from the loaded ESLint.
  * If the loaded ESLint was not found, just returns `require("espree")`.
  */
-export function getEspreeFromLinter(): Espree {
-    if (!espreeCache) {
-        espreeCache = getLinterRequire()?.("espree")
-        if (!espreeCache) {
-            espreeCache = dependencyEspree
+function getEspreeFromLinter(): Espree {
+    const require = getLinterRequire()
+    if (require) {
+        const espree = getEspreeFromRequireFunction(require)
+        if (espree) {
+            return espree
         }
     }
+    return dependencyEspree
+}
 
-    return espreeCache!
+/**
+ * Load `espree` from the given require function.
+ */
+function getEspreeFromRequireFunction(
+    require: (name: string) => any,
+): Espree | null {
+    try {
+        const pkg = require("espree/package.json")
+        const supportNodeVersion = pkg.engines?.node
+        if (
+            // If the node version is not supported then espree will not use it.
+            !supportNodeVersion ||
+            satisfies(process.version, supportNodeVersion)
+        ) {
+            return require("espree")
+        }
+    } catch {
+        // ignore
+    }
+    return null
 }
 
 /**
  * Load the newest `espree` from the loaded ESLint or dependency.
  */
-function getNewestEspree(): Espree {
-    let newest = dependencyEspree
-    const linterEspree = getEspreeFromLinter()
-    if (
-        linterEspree.version != null &&
-        lte(newest.version, linterEspree.version)
-    ) {
-        newest = linterEspree
-    }
+export function getNewestEspree(): Espree {
+    let newest = getEspreeFromLinter()
     const userEspree = getEspreeFromUser()
     if (userEspree.version != null && lte(newest.version, userEspree.version)) {
         newest = userEspree
@@ -87,30 +114,20 @@ function getNewestEspree(): Espree {
 
 export function getEcmaVersionIfUseEspree(
     parserOptions: ParserOptions,
-    getDefault?: (defaultVer: number) => number,
 ): number | undefined {
     if (parserOptions.parser != null && parserOptions.parser !== "espree") {
         return undefined
     }
 
-    if (parserOptions.ecmaVersion === "latest") {
+    if (
+        parserOptions.ecmaVersion === "latest" ||
+        parserOptions.ecmaVersion == null
+    ) {
         return normalizeEcmaVersion(getLatestEcmaVersion(getNewestEspree()))
     }
-    if (parserOptions.ecmaVersion == null) {
-        const defVer = getDefaultEcmaVersion()
-        return getDefault?.(defVer) ?? defVer
-    }
     return normalizeEcmaVersion(parserOptions.ecmaVersion)
 }
 
-function getDefaultEcmaVersion(): number {
-    if (lt(getEspreeFromLinter().version, "9.0.0")) {
-        return 5
-    }
-    // Perhaps the version 9 will change the default to "latest".
-    return normalizeEcmaVersion(getLatestEcmaVersion(getNewestEspree()))
-}
-
 /**
  * Normalize ECMAScript version
  */

src/script-setup/parser-options.ts

@@ -1,5 +1,4 @@
-import { lte } from "semver"
-import { getEcmaVersionIfUseEspree, getEspreeFromUser } from "../common/espree"
+import { getEcmaVersionIfUseEspree } from "../common/espree"
 import type { ParserOptions } from "../common/parser-options"
 
 export const DEFAULT_ECMA_VERSION = 2017
@@ -10,21 +9,11 @@ export const DEFAULT_ECMA_VERSION = 2017
 export function getScriptSetupParserOptions(
     parserOptions: ParserOptions,
 ): ParserOptions {
-    const espreeEcmaVersion = getEcmaVersionIfUseEspree(
-        parserOptions,
-        getDefaultEcmaVersion,
-    )
+    const espreeEcmaVersion =
+        getEcmaVersionIfUseEspree(parserOptions) ?? parserOptions.ecmaVersion
 
     return {
         ...parserOptions,
         ecmaVersion: espreeEcmaVersion,
     }
 }
-
-function getDefaultEcmaVersion(def: number) {
-    if (lte("8.0.0", getEspreeFromUser().version)) {
-        // Script setup requires top level await support, so default the ecma version to 2022.
-        return getEspreeFromUser().latestEcmaVersion!
-    }
-    return Math.max(def, DEFAULT_ECMA_VERSION)
-}

src/script/index.ts

@@ -43,11 +43,7 @@ import {
     analyzeExternalReferences,
     analyzeVariablesAndExternalReferences,
 } from "./scope-analyzer"
-import {
-    getEcmaVersionIfUseEspree,
-    getEspreeFromUser,
-    getEspreeFromEcmaVersion,
-} from "../common/espree"
+import { getEcmaVersionIfUseEspree, getNewestEspree } from "../common/espree"
 import type { ParserOptions } from "../common/parser-options"
 import {
     fixErrorLocation,
@@ -571,7 +567,7 @@ function loadParser(parser: string) {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         return require(parser)
     }
-    return getEspreeFromUser()
+    return getNewestEspree()
 }
 
 /**
@@ -590,7 +586,7 @@ export function parseScript(
             ? loadParser(parserOptions.parser)
             : isParserObject(parserOptions.parser)
             ? parserOptions.parser
-            : getEspreeFromEcmaVersion(parserOptions.ecmaVersion)
+            : getNewestEspree()
 
     const result: any = isEnhancedParserObject(parser)
         ? parser.parseForESLint(code, parserOptions)