eslint 8.26.0 → 8.28.0

package/lib/cli-engine/formatters/html.js

@@ -43,85 +43,110 @@ function pageTemplate(it) {
         <link rel="icon" type="image/svg+xml" href="data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PScwIDAgMjk0LjgyNSAyNTguOTgyJyB4bWxucz0naHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmcnPg0KPHBhdGggZmlsbD0nIzgwODBGMicgZD0nTTk3LjAyMSw5OS4wMTZsNDguNDMyLTI3Ljk2MmMxLjIxMi0wLjcsMi43MDYtMC43LDMuOTE4LDBsNDguNDMzLDI3Ljk2MiBjMS4yMTEsMC43LDEuOTU5LDEuOTkzLDEuOTU5LDMuMzkzdjU1LjkyNGMwLDEuMzk5LTAuNzQ4LDIuNjkzLTEuOTU5LDMuMzk0bC00OC40MzMsMjcuOTYyYy0xLjIxMiwwLjctMi43MDYsMC43LTMuOTE4LDAgbC00OC40MzItMjcuOTYyYy0xLjIxMi0wLjctMS45NTktMS45OTQtMS45NTktMy4zOTR2LTU1LjkyNEM5NS4wNjMsMTAxLjAwOSw5NS44MSw5OS43MTYsOTcuMDIxLDk5LjAxNicvPg0KPHBhdGggZmlsbD0nIzRCMzJDMycgZD0nTTI3My4zMzYsMTI0LjQ4OEwyMTUuNDY5LDIzLjgxNmMtMi4xMDItMy42NC01Ljk4NS02LjMyNS0xMC4xODgtNi4zMjVIODkuNTQ1IGMtNC4yMDQsMC04LjA4OCwyLjY4NS0xMC4xOSw2LjMyNWwtNTcuODY3LDEwMC40NWMtMi4xMDIsMy42NDEtMi4xMDIsOC4yMzYsMCwxMS44NzdsNTcuODY3LDk5Ljg0NyBjMi4xMDIsMy42NCw1Ljk4Niw1LjUwMSwxMC4xOSw1LjUwMWgxMTUuNzM1YzQuMjAzLDAsOC4wODctMS44MDUsMTAuMTg4LTUuNDQ2bDU3Ljg2Ny0xMDAuMDEgQzI3NS40MzksMTMyLjM5NiwyNzUuNDM5LDEyOC4xMjgsMjczLjMzNiwxMjQuNDg4IE0yMjUuNDE5LDE3Mi44OThjMCwxLjQ4LTAuODkxLDIuODQ5LTIuMTc0LDMuNTlsLTczLjcxLDQyLjUyNyBjLTEuMjgyLDAuNzQtMi44ODgsMC43NC00LjE3LDBsLTczLjc2Ny00Mi41MjdjLTEuMjgyLTAuNzQxLTIuMTc5LTIuMTA5LTIuMTc5LTMuNTlWODcuODQzYzAtMS40ODEsMC44ODQtMi44NDksMi4xNjctMy41OSBsNzMuNzA3LTQyLjUyN2MxLjI4Mi0wLjc0MSwyLjg4Ni0wLjc0MSw0LjE2OCwwbDczLjc3Miw0Mi41MjdjMS4yODMsMC43NDEsMi4xODYsMi4xMDksMi4xODYsMy41OVYxNzIuODk4eicvPg0KPC9zdmc+">
         <style>
             body {
-                font-family:Arial, "Helvetica Neue", Helvetica, sans-serif;
-                font-size:16px;
-                font-weight:normal;
-                margin:0;
-                padding:0;
-                color:#333
+                font-family: Arial, "Helvetica Neue", Helvetica, sans-serif;
+                font-size: 16px;
+                font-weight: normal;
+                margin: 0;
+                padding: 0;
+                color: #333;
             }
+
             #overview {
-                padding:20px 30px
+                padding: 20px 30px;
             }
-            td, th {
-                padding:5px 10px
+
+            td,
+            th {
+                padding: 5px 10px;
             }
+
             h1 {
-                margin:0
+                margin: 0;
             }
+
             table {
-                margin:30px;
-                width:calc(100% - 60px);
-                max-width:1000px;
-                border-radius:5px;
-                border:1px solid #ddd;
-                border-spacing:0px;
+                margin: 30px;
+                width: calc(100% - 60px);
+                max-width: 1000px;
+                border-radius: 5px;
+                border: 1px solid #ddd;
+                border-spacing: 0;
             }
+
             th {
-                font-weight:400;
-                font-size:medium;
-                text-align:left;
-                cursor:pointer
+                font-weight: 400;
+                font-size: medium;
+                text-align: left;
+                cursor: pointer;
             }
-            td.clr-1, td.clr-2, th span {
-                font-weight:700
+
+            td.clr-1,
+            td.clr-2,
+            th span {
+                font-weight: 700;
             }
+
             th span {
-                float:right;
-                margin-left:20px
+                float: right;
+                margin-left: 20px;
             }
-            th span:after {
-                content:"";
-                clear:both;
-                display:block
+
+            th span::after {
+                content: "";
+                clear: both;
+                display: block;
             }
+
             tr:last-child td {
-                border-bottom:none
+                border-bottom: none;
             }
-            tr td:first-child, tr td:last-child {
-                color:#9da0a4
+
+            tr td:first-child,
+            tr td:last-child {
+                color: #9da0a4;
             }
-            #overview.bg-0, tr.bg-0 th {
-                color:#468847;
-                background:#dff0d8;
-                border-bottom:1px solid #d6e9c6
+
+            #overview.bg-0,
+            tr.bg-0 th {
+                color: #468847;
+                background: #dff0d8;
+                border-bottom: 1px solid #d6e9c6;
             }
-            #overview.bg-1, tr.bg-1 th {
-                color:#f0ad4e;
-                background:#fcf8e3;
-                border-bottom:1px solid #fbeed5
+
+            #overview.bg-1,
+            tr.bg-1 th {
+                color: #f0ad4e;
+                background: #fcf8e3;
+                border-bottom: 1px solid #fbeed5;
             }
-            #overview.bg-2, tr.bg-2 th {
-                color:#b94a48;
-                background:#f2dede;
-                border-bottom:1px solid #eed3d7
+
+            #overview.bg-2,
+            tr.bg-2 th {
+                color: #b94a48;
+                background: #f2dede;
+                border-bottom: 1px solid #eed3d7;
             }
+
             td {
-                border-bottom:1px solid #ddd
+                border-bottom: 1px solid #ddd;
             }
+
             td.clr-1 {
-                color:#f0ad4e
+                color: #f0ad4e;
             }
+
             td.clr-2 {
-                color:#b94a48
+                color: #b94a48;
             }
+
             td a {
-                color:#3a33d1;
-                text-decoration:none
+                color: #3a33d1;
+                text-decoration: none;
             }
+
             td a:hover {
-                color:#272296;
-                text-decoration:underline
+                color: #272296;
+                text-decoration: underline;
             }
         </style>
     </head>
@@ -214,7 +239,7 @@ function messageTemplate(it) {
     } = it;
 
     return `
-<tr style="display:none" class="f-${parentIndex}">
+<tr style="display: none;" class="f-${parentIndex}">
     <td>${lineNumber}:${columnNumber}</td>
     <td class="clr-${severityNumber}">${severityName}</td>
     <td>${encodeHTML(message)}</td>

package/lib/eslint/eslint-helpers.js

@@ -26,6 +26,18 @@ const isPathInside = require("is-path-inside");
 
 const doFsWalk = util.promisify(fswalk.walk);
 const Minimatch = minimatch.Minimatch;
+const MINIMATCH_OPTIONS = { dot: true };
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+/**
+ * @typedef {Object} GlobSearch
+ * @property {Array<string>} patterns The normalized patterns to use for a search.
+ * @property {Array<string>} rawPatterns The patterns as entered by the user
+ *      before doing any normalization.
+ */
 
 //-----------------------------------------------------------------------------
 // Errors
@@ -47,6 +59,30 @@ class NoFilesFoundError extends Error {
     }
 }
 
+/**
+ * The error type when a search fails to match multiple patterns.
+ */
+class UnmatchedSearchPatternsError extends Error {
+
+    /**
+     * @param {Object} options The options for the error.
+     * @param {string} options.basePath The directory that was searched.
+     * @param {Array<string>} options.unmatchedPatterns The glob patterns
+     *      which were not found.
+     * @param {Array<string>} options.patterns The glob patterns that were
+     *      searched.
+     * @param {Array<string>} options.rawPatterns The raw glob patterns that
+     *      were searched.
+     */
+    constructor({ basePath, unmatchedPatterns, patterns, rawPatterns }) {
+        super(`No files matching '${rawPatterns}' in '${basePath}' were found.`);
+        this.basePath = basePath;
+        this.unmatchedPatterns = unmatchedPatterns;
+        this.patterns = patterns;
+        this.rawPatterns = rawPatterns;
+    }
+}
+
 /**
  * The error type when there are files matched by a glob, but all of them have been ignored.
  */
@@ -107,6 +143,69 @@ function isGlobPattern(pattern) {
     return isGlob(path.sep === "\\" ? normalizeToPosix(pattern) : pattern);
 }
 
+
+/**
+ * Determines if a given glob pattern will return any results.
+ * Used primarily to help with useful error messages.
+ * @param {Object} options The options for the function.
+ * @param {string} options.basePath The directory to search.
+ * @param {string} options.pattern A glob pattern to match.
+ * @returns {Promise<boolean>} True if there is a glob match, false if not.
+ */
+function globMatch({ basePath, pattern }) {
+
+    let found = false;
+    const patternToUse = path.isAbsolute(pattern)
+        ? normalizeToPosix(path.relative(basePath, pattern))
+        : pattern;
+
+    const matcher = new Minimatch(patternToUse, MINIMATCH_OPTIONS);
+
+    const fsWalkSettings = {
+
+        deepFilter(entry) {
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            return !found && matcher.match(relativePath, true);
+        },
+
+        entryFilter(entry) {
+            if (found || entry.dirent.isDirectory()) {
+                return false;
+            }
+
+            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+
+            if (matcher.match(relativePath)) {
+                found = true;
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+    return new Promise(resolve => {
+
+        // using a stream so we can exit early because we just need one match
+        const globStream = fswalk.walkStream(basePath, fsWalkSettings);
+
+        globStream.on("data", () => {
+            globStream.destroy();
+            resolve(true);
+        });
+
+        // swallow errors as they're not important here
+        globStream.on("error", () => { });
+
+        globStream.on("end", () => {
+            resolve(false);
+        });
+        globStream.read();
+    });
+
+}
+
 /**
  * Searches a directory looking for matching glob patterns. This uses
  * the config array's logic to determine if a directory or file should
@@ -116,26 +215,62 @@ function isGlobPattern(pattern) {
  * @param {string} options.basePath The directory to search.
  * @param {Array<string>} options.patterns An array of glob patterns
  *      to match.
+ * @param {Array<string>} options.rawPatterns An array of glob patterns
+ *      as the user inputted them. Used for errors.
  * @param {FlatConfigArray} options.configs The config array to use for
  *      determining what to ignore.
+ * @param {boolean} options.errorOnUnmatchedPattern Determines if an error
+ *      should be thrown when a pattern is unmatched.
  * @returns {Promise<Array<string>>} An array of matching file paths
  *      or an empty array if there are no matches.
+ * @throws {UnmatchedSearchPatternsErrror} If there is a pattern that doesn't
+ *      match any files.
  */
-async function globSearch({ basePath, patterns, configs }) {
+async function globSearch({
+    basePath,
+    patterns,
+    rawPatterns,
+    configs,
+    errorOnUnmatchedPattern
+}) {
 
     if (patterns.length === 0) {
         return [];
     }
 
-    const matchers = patterns.map(pattern => {
+    /*
+     * In this section we are converting the patterns into Minimatch
+     * instances for performance reasons. Because we are doing the same
+     * matches repeatedly, it's best to compile those patterns once and
+     * reuse them multiple times.
+     *
+     * To do that, we convert any patterns with an absolute path into a
+     * relative path and normalize it to Posix-style slashes. We also keep
+     * track of the relative patterns to map them back to the original
+     * patterns, which we need in order to throw an error if there are any
+     * unmatched patterns.
+     */
+    const relativeToPatterns = new Map();
+    const matchers = patterns.map((pattern, i) => {
         const patternToUse = path.isAbsolute(pattern)
             ? normalizeToPosix(path.relative(basePath, pattern))
             : pattern;
 
-        return new minimatch.Minimatch(patternToUse);
+        relativeToPatterns.set(patternToUse, patterns[i]);
+
+        return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
     });
 
-    return (await doFsWalk(basePath, {
+    /*
+     * We track unmatched patterns because we may want to throw an error when
+     * they occur. To start, this set is initialized with all of the patterns.
+     * Every time a match occurs, the pattern is removed from the set, making
+     * it easy to tell if we have any unmatched patterns left at the end of
+     * search.
+     */
+    const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
+
+    const filePaths = (await doFsWalk(basePath, {
 
         deepFilter(entry) {
             const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
@@ -151,94 +286,171 @@ async function globSearch({ basePath, patterns, configs }) {
                 return false;
             }
 
-            const matchesPattern = matchers.some(matcher => matcher.match(relativePath));
+            /*
+             * Optimization: We need to track when patterns are left unmatched
+             * and so we use `unmatchedPatterns` to do that. There is a bit of
+             * complexity here because the same file can be matched by more than
+             * one pattern. So, when we start, we actually need to test every
+             * pattern against every file. Once we know there are no remaining
+             * unmatched patterns, then we can switch to just looking for the
+             * first matching pattern for improved speed.
+             */
+            const matchesPattern = unmatchedPatterns.size > 0
+                ? matchers.reduce((previousValue, matcher) => {
+                    const pathMatches = matcher.match(relativePath);
+
+                    /*
+                     * We updated the unmatched patterns set only if the path
+                     * matches and the file isn't ignored. If the file is
+                     * ignored, that means there wasn't a match for the
+                     * pattern so it should not be removed.
+                     *
+                     * Performance note: isFileIgnored() aggressively caches
+                     * results so there is no performance penalty for calling
+                     * it twice with the same argument.
+                     */
+                    if (pathMatches && !configs.isFileIgnored(entry.path)) {
+                        unmatchedPatterns.delete(matcher.pattern);
+                    }
+
+                    return pathMatches || previousValue;
+                }, false)
+                : matchers.some(matcher => matcher.match(relativePath));
 
             return matchesPattern && !configs.isFileIgnored(entry.path);
         }
+
     })).map(entry => entry.path);
 
+    // now check to see if we have any unmatched patterns
+    if (errorOnUnmatchedPattern && unmatchedPatterns.size > 0) {
+        throw new UnmatchedSearchPatternsError({
+            basePath,
+            unmatchedPatterns: [...unmatchedPatterns].map(
+                pattern => relativeToPatterns.get(pattern)
+            ),
+            patterns,
+            rawPatterns
+        });
+    }
+
+    return filePaths;
+}
+
+/**
+ * Throws an error for unmatched patterns. The error will only contain information about the first one.
+ * Checks to see if there are any ignored results for a given search.
+ * @param {Object} options The options for this function.
+ * @param {string} options.basePath The directory to search.
+ * @param {Array<string>} options.patterns An array of glob patterns
+ *      that were used in the original search.
+ * @param {Array<string>} options.rawPatterns An array of glob patterns
+ *      as the user inputted them. Used for errors.
+ * @param {Array<string>} options.unmatchedPatterns A non-empty array of glob patterns
+ *      that were unmatched in the original search.
+ * @returns {void} Always throws an error.
+ * @throws {NoFilesFoundError} If the first unmatched pattern
+ *      doesn't match any files even when there are no ignores.
+ * @throws {AllFilesIgnoredError} If the first unmatched pattern
+ *      matches some files when there are no ignores.
+ */
+async function throwErrorForUnmatchedPatterns({
+    basePath,
+    patterns,
+    rawPatterns,
+    unmatchedPatterns
+}) {
+
+    const pattern = unmatchedPatterns[0];
+    const rawPattern = rawPatterns[patterns.indexOf(pattern)];
+
+    const patternHasMatch = await globMatch({
+        basePath,
+        pattern
+    });
+
+    if (patternHasMatch) {
+        throw new AllFilesIgnoredError(rawPattern);
+    }
+
+    // if we get here there are truly no matches
+    throw new NoFilesFoundError(rawPattern, true);
 }
 
 /**
  * Performs multiple glob searches in parallel.
  * @param {Object} options The options for this function.
- * @param {Array<{patterns:Array<string>,rawPatterns:Array<string>}>} options.searches
+ * @param {Map<string,GlobSearch>} options.searches
  *      An array of glob patterns to match.
  * @param {FlatConfigArray} options.configs The config array to use for
  *      determining what to ignore.
+ * @param {boolean} options.errorOnUnmatchedPattern Determines if an
+ *      unmatched glob pattern should throw an error.
  * @returns {Promise<Array<string>>} An array of matching file paths
  *      or an empty array if there are no matches.
  */
-async function globMultiSearch({ searches, configs }) {
+async function globMultiSearch({ searches, configs, errorOnUnmatchedPattern }) {
 
-    const results = await Promise.all(
-        [...searches].map(
-            ([basePath, { patterns }]) => globSearch({ basePath, patterns, configs })
+    /*
+     * For convenience, we normalized the search map into an array of objects.
+     * Next, we filter out all searches that have no patterns. This happens
+     * primarily for the cwd, which is prepopulated in the searches map as an
+     * optimization. However, if it has no patterns, it means all patterns
+     * occur outside of the cwd and we can safely filter out that search.
+     */
+    const normalizedSearches = [...searches].map(
+        ([basePath, { patterns, rawPatterns }]) => ({ basePath, patterns, rawPatterns })
+    ).filter(({ patterns }) => patterns.length > 0);
+
+    const results = await Promise.allSettled(
+        normalizedSearches.map(
+            ({ basePath, patterns, rawPatterns }) => globSearch({
+                basePath,
+                patterns,
+                rawPatterns,
+                configs,
+                errorOnUnmatchedPattern
+            })
         )
     );
 
-    return [...new Set(results.flat())];
-}
+    const filePaths = [];
 
-/**
- * Determines if a given glob pattern will return any results.
- * Used primarily to help with useful error messages.
- * @param {Object} options The options for the function.
- * @param {string} options.basePath The directory to search.
- * @param {string} options.pattern A glob pattern to match.
- * @returns {Promise<boolean>} True if there is a glob match, false if not.
- */
-function globMatch({ basePath, pattern }) {
-
-    let found = false;
-    const patternToUse = path.isAbsolute(pattern)
-        ? normalizeToPosix(path.relative(basePath, pattern))
-        : pattern;
+    for (let i = 0; i < results.length; i++) {
 
-    const matcher = new Minimatch(patternToUse);
+        const result = results[i];
+        const currentSearch = normalizedSearches[i];
 
-    const fsWalkSettings = {
-
-        deepFilter(entry) {
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+        if (result.status === "fulfilled") {
 
-            return !found && matcher.match(relativePath, true);
-        },
-
-        entryFilter(entry) {
-            if (found || entry.dirent.isDirectory()) {
-                return false;
+            // if the search was successful just add the results
+            if (result.value.length > 0) {
+                filePaths.push(...result.value);
             }
 
-            const relativePath = normalizeToPosix(path.relative(basePath, entry.path));
+            continue;
+        }
 
-            if (matcher.match(relativePath)) {
-                found = true;
-                return true;
-            }
+        // if we make it here then there was an error
+        const error = result.reason;
 
-            return false;
+        // unexpected errors should be re-thrown
+        if (!error.basePath) {
+            throw error;
         }
-    };
 
-    return new Promise(resolve => {
+        if (errorOnUnmatchedPattern) {
 
-        // using a stream so we can exit early because we just need one match
-        const globStream = fswalk.walkStream(basePath, fsWalkSettings);
+            await throwErrorForUnmatchedPatterns({
+                ...currentSearch,
+                unmatchedPatterns: error.unmatchedPatterns
+            });
 
-        globStream.on("data", () => {
-            globStream.destroy();
-            resolve(true);
-        });
+        }
 
-        // swallow errors as they're not important here
-        globStream.on("error", () => {});
+    }
 
-        globStream.on("end", () => {
-            resolve(false);
-        });
-        globStream.read();
-    });
+    return [...new Set(filePaths)];
 
 }
 
@@ -335,47 +547,17 @@ async function findFiles({
         }
     });
 
-    const globbyResults = await globMultiSearch({
-        searches,
-        configs
-    });
-
-    // if there are no results, tell the user why
-    if (!results.length && !globbyResults.length) {
-
-        for (const [basePath, { patterns: patternsToCheck, rawPatterns: patternsToReport }] of searches) {
-
-            let index = 0;
-
-            // try globby without ignoring anything
-            for (const patternToCheck of patternsToCheck) {
-
-                // check if there are any matches at all
-                const patternHasMatch = await globMatch({
-                    basePath,
-                    pattern: patternToCheck
-                });
-
-                if (patternHasMatch) {
-                    throw new AllFilesIgnoredError(patternsToReport[index]);
-                }
-
-                // otherwise no files were found
-                if (errorOnUnmatchedPattern) {
-                    throw new NoFilesFoundError(patternsToReport[index], globInputPaths);
-                }
-
-                index++;
-            }
-        }
-
-    }
-
     // there were patterns that didn't match anything, tell the user
     if (errorOnUnmatchedPattern && missingPatterns.length) {
         throw new NoFilesFoundError(missingPatterns[0], globInputPaths);
     }
 
+    // now we are safe to do the search
+    const globbyResults = await globMultiSearch({
+        searches,
+        configs,
+        errorOnUnmatchedPattern
+    });
 
     return [
         ...results,

package/lib/eslint/flat-eslint.js

@@ -161,6 +161,16 @@ function createRulesMeta(rules) {
     }, {});
 }
 
+/**
+ * Return the absolute path of a file named `"__placeholder__.js"` in a given directory.
+ * This is used as a replacement for a missing file path.
+ * @param {string} cwd An absolute directory path.
+ * @returns {string} The absolute path of a file named `"__placeholder__.js"` in the given directory.
+ */
+function getPlaceholderPath(cwd) {
+    return path.join(cwd, "__placeholder__.js");
+}
+
 /** @type {WeakMap<ExtractedConfig, DeprecatedRuleInfo[]>} */
 const usedDeprecatedRulesCache = new WeakMap();
 
@@ -177,7 +187,7 @@ function getOrFindUsedDeprecatedRules(eslint, maybeFilePath) {
     } = privateMembers.get(eslint);
     const filePath = path.isAbsolute(maybeFilePath)
         ? maybeFilePath
-        : path.join(cwd, "__placeholder__.js");
+        : getPlaceholderPath(cwd);
     const config = configs.getConfig(filePath);
 
     // Most files use the same config, so cache it.
@@ -422,7 +432,7 @@ function verifyText({
      * `config.extractConfig(filePath)` requires an absolute path, but `linter`
      * doesn't know CWD, so it gives `linter` an absolute path always.
      */
-    const filePathToVerify = filePath === "<text>" ? path.join(cwd, "__placeholder__.js") : filePath;
+    const filePathToVerify = filePath === "<text>" ? getPlaceholderPath(cwd) : filePath;
     const { fixed, messages, output } = linter.verifyAndFix(
         text,
         configs,
@@ -519,6 +529,14 @@ function *iterateRuleDeprecationWarnings(configs) {
     }
 }
 
+/**
+ * Creates an error to be thrown when an array of results passed to `getRulesMetaForResults` was not created by the current engine.
+ * @returns {TypeError} An error object.
+ */
+function createExtraneousResultsError() {
+    return new TypeError("Results object was not created from this ESLint instance.");
+}
+
 //-----------------------------------------------------------------------------
 // Main API
 //-----------------------------------------------------------------------------
@@ -655,7 +673,10 @@ class FlatESLint {
         }
 
         const resultRules = new Map();
-        const { configs } = privateMembers.get(this);
+        const {
+            configs,
+            options: { cwd }
+        } = privateMembers.get(this);
 
         /*
          * We can only accurately return rules meta information for linting results if the
@@ -664,7 +685,7 @@ class FlatESLint {
          * to let the user know we can't do anything here.
          */
         if (!configs) {
-            throw new TypeError("Results object was not created from this ESLint instance.");
+            throw createExtraneousResultsError();
         }
 
         for (const result of results) {
@@ -673,13 +694,7 @@ class FlatESLint {
              * Normalize filename for <text>.
              */
             const filePath = result.filePath === "<text>"
-                ? "__placeholder__.js" : result.filePath;
-
-            /*
-             * All of the plugin and rule information is contained within the
-             * calculated config for the given file.
-             */
-            const config = configs.getConfig(filePath);
+                ? getPlaceholderPath(cwd) : result.filePath;
             const allMessages = result.messages.concat(result.suppressedMessages);
 
             for (const { ruleId } of allMessages) {
@@ -687,6 +702,15 @@ class FlatESLint {
                     continue;
                 }
 
+                /*
+                 * All of the plugin and rule information is contained within the
+                 * calculated config for the given file.
+                 */
+                const config = configs.getConfig(filePath);
+
+                if (!config) {
+                    throw createExtraneousResultsError();
+                }
                 const rule = getRuleFromConfig(ruleId, config);
 
                 // ensure the rule exists
@@ -1024,7 +1048,7 @@ class FlatESLint {
                 const npmFormat = naming.normalizePackageName(normalizedFormatName, "eslint-formatter");
 
                 // TODO: This is pretty dirty...would be nice to clean up at some point.
-                formatterPath = ModuleResolver.resolve(npmFormat, path.join(cwd, "__placeholder__.js"));
+                formatterPath = ModuleResolver.resolve(npmFormat, getPlaceholderPath(cwd));
             } catch {
                 formatterPath = path.resolve(__dirname, "../", "cli-engine", "formatters", `${normalizedFormatName}.js`);
             }

package/lib/rules/comma-dangle.js

@@ -50,7 +50,7 @@ function normalizeOptions(optionValue, ecmaVersion) {
             objects: optionValue,
             imports: optionValue,
             exports: optionValue,
-            functions: (!ecmaVersion || ecmaVersion < 8) ? "ignore" : optionValue
+            functions: ecmaVersion < 2017 ? "ignore" : optionValue
         };
     }
     if (typeof optionValue === "object" && optionValue !== null) {
@@ -134,7 +134,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = normalizeOptions(context.options[0], context.parserOptions.ecmaVersion);
+        const options = normalizeOptions(context.options[0], context.languageOptions.ecmaVersion);
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/for-direction.js

@@ -15,7 +15,7 @@ module.exports = {
         type: "problem",
 
         docs: {
-            description: "Enforce \"for\" loop update clause moving the counter in the right direction.",
+            description: "Enforce \"for\" loop update clause moving the counter in the right direction",
             recommended: true,
             url: "https://eslint.org/docs/rules/for-direction"
         },

package/lib/rules/func-name-matching.js

@@ -44,7 +44,7 @@ function isModuleExports(pattern) {
  * @returns {boolean} True if the string is a valid identifier
  */
 function isIdentifier(name, ecmaVersion) {
-    if (ecmaVersion >= 6) {
+    if (ecmaVersion >= 2015) {
         return esutils.keyword.isIdentifierES6(name);
     }
     return esutils.keyword.isIdentifierES5(name);
@@ -104,7 +104,7 @@ module.exports = {
         const nameMatches = typeof context.options[0] === "string" ? context.options[0] : "always";
         const considerPropertyDescriptor = options.considerPropertyDescriptor;
         const includeModuleExports = options.includeCommonJSModuleExports;
-        const ecmaVersion = context.parserOptions && context.parserOptions.ecmaVersion ? context.parserOptions.ecmaVersion : 5;
+        const ecmaVersion = context.languageOptions.ecmaVersion;
 
         /**
          * Check whether node is a certain CallExpression.

package/lib/rules/index.js

@@ -123,6 +123,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-empty-character-class": () => require("./no-empty-character-class"),
     "no-empty-function": () => require("./no-empty-function"),
     "no-empty-pattern": () => require("./no-empty-pattern"),
+    "no-empty-static-block": () => require("./no-empty-static-block"),
     "no-eq-null": () => require("./no-eq-null"),
     "no-eval": () => require("./no-eval"),
     "no-ex-assign": () => require("./no-ex-assign"),
@@ -167,6 +168,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-nested-ternary": () => require("./no-nested-ternary"),
     "no-new": () => require("./no-new"),
     "no-new-func": () => require("./no-new-func"),
+    "no-new-native-nonconstructor": () => require("./no-new-native-nonconstructor"),
     "no-new-object": () => require("./no-new-object"),
     "no-new-require": () => require("./no-new-require"),
     "no-new-symbol": () => require("./no-new-symbol"),

package/lib/rules/key-spacing.js

@@ -334,6 +334,19 @@ module.exports = {
 
         const sourceCode = context.getSourceCode();
 
+        /**
+         * Determines if the given property is key-value property.
+         * @param {ASTNode} property Property node to check.
+         * @returns {boolean} Whether the property is a key-value property.
+         */
+        function isKeyValueProperty(property) {
+            return !(
+                (property.method ||
+                property.shorthand ||
+                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+            );
+        }
+
         /**
          * Checks whether a property is a member of the property group it follows.
          * @param {ASTNode} lastMember The last Property known to be in the group.
@@ -342,9 +355,9 @@ module.exports = {
          */
         function continuesPropertyGroup(lastMember, candidate) {
             const groupEndLine = lastMember.loc.start.line,
-                candidateStartLine = candidate.loc.start.line;
+                candidateValueStartLine = (isKeyValueProperty(candidate) ? candidate.value : candidate).loc.start.line;
 
-            if (candidateStartLine - groupEndLine <= 1) {
+            if (candidateValueStartLine - groupEndLine <= 1) {
                 return true;
             }
 
@@ -358,7 +371,7 @@ module.exports = {
             if (
                 leadingComments.length &&
                 leadingComments[0].loc.start.line - groupEndLine <= 1 &&
-                candidateStartLine - last(leadingComments).loc.end.line <= 1
+                candidateValueStartLine - last(leadingComments).loc.end.line <= 1
             ) {
                 for (let i = 1; i < leadingComments.length; i++) {
                     if (leadingComments[i].loc.start.line - leadingComments[i - 1].loc.end.line > 1) {
@@ -371,19 +384,6 @@ module.exports = {
             return false;
         }
 
-        /**
-         * Determines if the given property is key-value property.
-         * @param {ASTNode} property Property node to check.
-         * @returns {boolean} Whether the property is a key-value property.
-         */
-        function isKeyValueProperty(property) {
-            return !(
-                (property.method ||
-                property.shorthand ||
-                property.kind !== "init" || property.type !== "Property") // Could be "ExperimentalSpreadProperty" or "SpreadElement"
-            );
-        }
-
         /**
          * Starting from the given a node (a property.key node here) looks forward
          * until it finds the last token before a colon punctuator and returns it.

package/lib/rules/no-empty-static-block.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Rule to disallow empty static blocks.
+ * @author Sosuke Suzuki
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "Disallow empty static blocks",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-empty-static-block"
+        },
+
+        schema: [],
+
+        messages: {
+            unexpected: "Unexpected empty static block."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        return {
+            StaticBlock(node) {
+                if (node.body.length === 0) {
+                    const closingBrace = sourceCode.getLastToken(node);
+
+                    if (sourceCode.getCommentsBefore(closingBrace).length === 0) {
+                        context.report({
+                            node,
+                            messageId: "unexpected"
+                        });
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-empty.js

@@ -17,6 +17,7 @@ const astUtils = require("./utils/ast-utils");
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
+        hasSuggestions: true,
         type: "suggestion",
 
         docs: {
@@ -39,7 +40,8 @@ module.exports = {
         ],
 
         messages: {
-            unexpected: "Empty {{type}} statement."
+            unexpected: "Empty {{type}} statement.",
+            suggestComment: "Add comment inside empty {{type}} statement."
         }
     },
 
@@ -71,7 +73,22 @@ module.exports = {
                     return;
                 }
 
-                context.report({ node, messageId: "unexpected", data: { type: "block" } });
+                context.report({
+                    node,
+                    messageId: "unexpected",
+                    data: { type: "block" },
+                    suggest: [
+                        {
+                            messageId: "suggestComment",
+                            data: { type: "block" },
+                            fix(fixer) {
+                                const range = [node.range[0] + 1, node.range[1] - 1];
+
+                                return fixer.replaceTextRange(range, " /* empty */ ");
+                            }
+                        }
+                    ]
+                });
             },
 
             SwitchStatement(node) {

package/lib/rules/no-implicit-coercion.js

@@ -71,6 +71,24 @@ function isMultiplyByOne(node) {
     );
 }
 
+/**
+ * Checks whether the given node logically represents multiplication by a fraction of `1`.
+ * For example, `a * 1` in `a * 1 / b` is technically multiplication by `1`, but the
+ * whole expression can be logically interpreted as `a * (1 / b)` rather than `(a * 1) / b`.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
+ * @param {SourceCode} sourceCode The source code object.
+ * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
+ */
+function isMultiplyByFractionOfOne(node, sourceCode) {
+    return node.type === "BinaryExpression" &&
+        node.operator === "*" &&
+        (node.right.type === "Literal" && node.right.value === 1) &&
+        node.parent.type === "BinaryExpression" &&
+        node.parent.operator === "/" &&
+        node.parent.left === node &&
+        !astUtils.isParenthesised(sourceCode, node);
+}
+
 /**
  * Checks whether the result of a node is numeric or not
  * @param {ASTNode} node The node to test
@@ -290,7 +308,8 @@ module.exports = {
 
                 // 1 * foo
                 operatorAllowed = options.allow.includes("*");
-                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);
+                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
+                    getNonNumericOperand(node);
 
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;

package/lib/rules/no-magic-numbers.js

@@ -65,6 +65,10 @@ module.exports = {
                 ignoreDefaultValues: {
                     type: "boolean",
                     default: false
+                },
+                ignoreClassFieldInitialValues: {
+                    type: "boolean",
+                    default: false
                 }
             },
             additionalProperties: false
@@ -82,7 +86,8 @@ module.exports = {
             enforceConst = !!config.enforceConst,
             ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes,
-            ignoreDefaultValues = !!config.ignoreDefaultValues;
+            ignoreDefaultValues = !!config.ignoreDefaultValues,
+            ignoreClassFieldInitialValues = !!config.ignoreClassFieldInitialValues;
 
         const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
@@ -106,6 +111,17 @@ module.exports = {
             return parent.type === "AssignmentPattern" && parent.right === fullNumberNode;
         }
 
+        /**
+         * Returns whether the number is the initial value of a class field.
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the number is the initial value of a class field.
+         */
+        function isClassFieldInitialValue(fullNumberNode) {
+            const parent = fullNumberNode.parent;
+
+            return parent.type === "PropertyDefinition" && parent.value === fullNumberNode;
+        }
+
         /**
          * Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
          * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
@@ -194,6 +210,7 @@ module.exports = {
                 if (
                     isIgnoredValue(value) ||
                     (ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
+                    (ignoreClassFieldInitialValues && isClassFieldInitialValue(fullNumberNode)) ||
                     isParseIntRadix(fullNumberNode) ||
                     isJSXNumber(fullNumberNode) ||
                     (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))

package/lib/rules/no-misleading-character-class.js

@@ -193,15 +193,15 @@ module.exports = {
          * ecmaVersion doesn't support the `u` flag.
          */
         function isValidWithUnicodeFlag(pattern) {
-            const { ecmaVersion } = context.parserOptions;
+            const { ecmaVersion } = context.languageOptions;
 
-            // ecmaVersion is unknown or it doesn't support the 'u' flag
-            if (typeof ecmaVersion !== "number" || ecmaVersion <= 5) {
+            // ecmaVersion <= 5 doesn't support the 'u' flag
+            if (ecmaVersion <= 5) {
                 return false;
             }
 
             const validator = new RegExpValidator({
-                ecmaVersion: Math.min(ecmaVersion + 2009, REGEXPP_LATEST_ECMA_VERSION)
+                ecmaVersion: Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION)
             });
 
             try {

package/lib/rules/no-new-native-nonconstructor.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Rule to disallow use of the new operator with global non-constructor functions
+ * @author Sosuke Suzuki
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const nonConstructorGlobalFunctionNames = ["Symbol", "BigInt"];
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "Disallow `new` operators with global non-constructor functions",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-new-native-nonconstructor"
+        },
+
+        schema: [],
+
+        messages: {
+            noNewNonconstructor: "`{{name}}` cannot be called as a constructor."
+        }
+    },
+
+    create(context) {
+
+        return {
+            "Program:exit"() {
+                const globalScope = context.getScope();
+
+                for (const nonConstructorName of nonConstructorGlobalFunctionNames) {
+                    const variable = globalScope.set.get(nonConstructorName);
+
+                    if (variable && variable.defs.length === 0) {
+                        variable.references.forEach(ref => {
+                            const node = ref.identifier;
+                            const parent = node.parent;
+
+                            if (parent && parent.type === "NewExpression" && parent.callee === node) {
+                                context.report({
+                                    node,
+                                    messageId: "noNewNonconstructor",
+                                    data: { name: nonConstructorName }
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+        };
+
+    }
+};

package/lib/rules/no-obj-calls.js

@@ -16,7 +16,7 @@ const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 // Helpers
 //------------------------------------------------------------------------------
 
-const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
+const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
 
 /**
  * Returns the name of the node to report

package/lib/rules/prefer-object-spread.js

@@ -247,7 +247,7 @@ module.exports = {
 
         docs: {
             description:
-                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.",
+                "Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead",
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-object-spread"
         },

package/lib/rules/prefer-regex-literals.js

@@ -248,14 +248,14 @@ module.exports = {
 
         /**
          * Returns a ecmaVersion compatible for regexpp.
-         * @param {any} ecmaVersion The ecmaVersion to convert.
+         * @param {number} ecmaVersion The ecmaVersion to convert.
          * @returns {import("regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
          */
         function getRegexppEcmaVersion(ecmaVersion) {
-            if (typeof ecmaVersion !== "number" || ecmaVersion <= 5) {
+            if (ecmaVersion <= 5) {
                 return 5;
             }
-            return Math.min(ecmaVersion + 2009, REGEXPP_LATEST_ECMA_VERSION);
+            return Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION);
         }
 
         /**
@@ -320,7 +320,7 @@ module.exports = {
                             flags = getStringValue(node.arguments[1]);
                         }
 
-                        const regexppEcmaVersion = getRegexppEcmaVersion(context.parserOptions.ecmaVersion);
+                        const regexppEcmaVersion = getRegexppEcmaVersion(context.languageOptions.ecmaVersion);
                         const RegExpValidatorInstance = new RegExpValidator({ ecmaVersion: regexppEcmaVersion });
 
                         try {

package/lib/shared/runtime-info.js

@@ -97,7 +97,7 @@ function environment() {
      */
     function getNpmPackageVersion(pkg, { global = false } = {}) {
         const npmBinArgs = ["bin", "-g"];
-        const npmLsArgs = ["ls", "--depth=0", "--json", "eslint"];
+        const npmLsArgs = ["ls", "--depth=0", "--json", pkg];
 
         if (global) {
             npmLsArgs.push("-g");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.26.0",
+  "version": "8.28.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {