eslint 8.25.0 → 8.27.0

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.
@@ -262,24 +272,16 @@ function findFlatConfigFile(cwd) {
 /**
  * Load the config array from the given filename.
  * @param {string} filePath The filename to load from.
- * @param {Object} options Options to help load the config file.
- * @param {string} options.basePath The base path for the config array.
- * @param {boolean} options.shouldIgnore Whether to honor ignore patterns.
- * @returns {Promise<FlatConfigArray>} The config array loaded from the config file.
+ * @returns {Promise<any>} The config loaded from the config file.
  */
-async function loadFlatConfigFile(filePath, { basePath, shouldIgnore }) {
+async function loadFlatConfigFile(filePath) {
     debug(`Loading config from ${filePath}`);
 
     const fileURL = pathToFileURL(filePath);
 
     debug(`Config file URL is ${fileURL}`);
 
-    const module = await import(fileURL);
-
-    return new FlatConfigArray(module.default, {
-        basePath,
-        shouldIgnore
-    });
+    return (await import(fileURL)).default;
 }
 
 /**
@@ -290,6 +292,7 @@ async function loadFlatConfigFile(filePath, { basePath, shouldIgnore }) {
  */
 async function calculateConfigArray(eslint, {
     cwd,
+    baseConfig,
     overrideConfig,
     configFile,
     ignore: shouldIgnore,
@@ -321,16 +324,18 @@ async function calculateConfigArray(eslint, {
         basePath = path.resolve(path.dirname(configFilePath));
     }
 
-    // load config array
-    let configs;
 
+    const configs = new FlatConfigArray(baseConfig || [], { basePath, shouldIgnore });
+
+    // load config file
     if (configFilePath) {
-        configs = await loadFlatConfigFile(configFilePath, {
-            basePath,
-            shouldIgnore
-        });
-    } else {
-        configs = new FlatConfigArray([], { basePath, shouldIgnore });
+        const fileConfig = await loadFlatConfigFile(configFilePath);
+
+        if (Array.isArray(fileConfig)) {
+            configs.push(...fileConfig);
+        } else {
+            configs.push(fileConfig);
+        }
     }
 
     // add in any configured defaults
@@ -362,17 +367,6 @@ async function calculateConfigArray(eslint, {
             const negated = pattern.startsWith("!");
             const basePattern = negated ? pattern.slice(1) : pattern;
 
-            /*
-             * Ignore patterns are considered relative to a directory
-             * when the pattern contains a slash in a position other
-             * than the last character. If that's the case, we need to
-             * add the relative ignore path to the current pattern to
-             * get the correct behavior. Otherwise, no change is needed.
-             */
-            if (!basePattern.includes("/") || basePattern.endsWith("/")) {
-                return pattern;
-            }
-
             return (negated ? "!" : "") +
                 path.posix.join(relativeIgnorePath, basePattern);
         });
@@ -438,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,
@@ -535,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
 //-----------------------------------------------------------------------------
@@ -665,14 +667,16 @@ class FlatESLint {
      */
     getRulesMetaForResults(results) {
 
-        const resultRules = new Map();
-
         // short-circuit simple case
         if (results.length === 0) {
-            return resultRules;
+            return {};
         }
 
-        const { configs } = privateMembers.get(this);
+        const resultRules = new Map();
+        const {
+            configs,
+            options: { cwd }
+        } = privateMembers.get(this);
 
         /*
          * We can only accurately return rules meta information for linting results if the
@@ -681,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) {
@@ -690,16 +694,23 @@ 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) {
+                if (!ruleId) {
+                    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
@@ -1037,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/linter/linter.js

@@ -213,6 +213,7 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
 
         if (variable) {
             variable.eslintUsed = true;
+            variable.eslintExported = true;
         }
     });
 

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/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/getter-return.js

@@ -112,18 +112,24 @@ module.exports = {
                 }
                 if (parent.type === "Property" && astUtils.getStaticPropertyName(parent) === "get" && parent.parent.type === "ObjectExpression") {
 
-                    // Object.defineProperty()
-                    if (parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.callee) === "defineProperty") {
-                        return true;
+                    // Object.defineProperty() or Reflect.defineProperty()
+                    if (parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.callee;
+
+                        if (astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperty") ||
+                            astUtils.isSpecificMemberAccess(callNode, "Reflect", "defineProperty")) {
+                            return true;
+                        }
                     }
 
-                    // Object.defineProperties()
+                    // Object.defineProperties() or Object.create()
                     if (parent.parent.parent.type === "Property" &&
                         parent.parent.parent.parent.type === "ObjectExpression" &&
-                        parent.parent.parent.parent.parent.type === "CallExpression" &&
-                        astUtils.getStaticPropertyName(parent.parent.parent.parent.parent.callee) === "defineProperties") {
-                        return true;
+                        parent.parent.parent.parent.parent.type === "CallExpression") {
+                        const callNode = parent.parent.parent.parent.parent.callee;
+
+                        return astUtils.isSpecificMemberAccess(callNode, "Object", "defineProperties") ||
+                               astUtils.isSpecificMemberAccess(callNode, "Object", "create");
                     }
                 }
             }

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/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-globals.js

@@ -77,6 +77,11 @@ module.exports = {
                         return;
                     }
 
+                    // Variables exported by "exported" block comments
+                    if (variable.eslintExported) {
+                        return;
+                    }
+
                     variable.defs.forEach(def => {
                         const defNode = def.node;
 

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.25.0",
+  "version": "8.27.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -56,8 +56,9 @@
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@eslint/eslintrc": "^1.3.3",
-    "@humanwhocodes/config-array": "^0.10.5",
+    "@humanwhocodes/config-array": "^0.11.6",
     "@humanwhocodes/module-importer": "^1.0.1",
+    "@nodelib/fs.walk": "^1.2.8",
     "ajv": "^6.10.0",
     "chalk": "^4.0.0",
     "cross-spawn": "^7.0.2",
@@ -73,14 +74,14 @@
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",
     "find-up": "^5.0.0",
-    "glob-parent": "^6.0.1",
+    "glob-parent": "^6.0.2",
     "globals": "^13.15.0",
-    "globby": "^11.1.0",
     "grapheme-splitter": "^1.0.4",
     "ignore": "^5.2.0",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
     "is-glob": "^4.0.0",
+    "is-path-inside": "^3.0.3",
     "js-sdsl": "^4.1.4",
     "js-yaml": "^4.1.0",
     "json-stable-stringify-without-jsonify": "^1.0.1",