eslint 8.34.0 → 8.35.0

package/README.md

@@ -16,8 +16,7 @@
 [Report Bugs](https://eslint.org/docs/latest/contribute/report-bugs) |
 [Code of Conduct](https://eslint.org/conduct) |
 [Twitter](https://twitter.com/geteslint) |
-[Mailing List](https://groups.google.com/group/eslint) |
-[Chat Room](https://eslint.org/chat)
+[Discord](https://eslint.org/chat)
 
 ESLint is a tool for identifying and reporting on patterns found in ECMAScript/JavaScript code. In many ways, it is similar to JSLint and JSHint with a few exceptions:
 
@@ -129,7 +128,7 @@ Once a language feature has been adopted into the ECMAScript standard (stage 4 a
 
 ### Where to ask for help?
 
-Join our [Mailing List](https://groups.google.com/group/eslint) or [Chatroom](https://eslint.org/chat).
+Open a [discussion](https://github.com/eslint/eslint/discussions) or stop by our [Discord server](https://eslint.org/chat).
 
 ### Why doesn't ESLint lock dependency versions?
 
@@ -255,6 +254,11 @@ Bryan Mishkin
 Sara Soueidan
 </a>
 </td><td align="center" valign="top" width="11%">
+<a href="https://github.com/fasttime">
+<img src="https://github.com/fasttime.png?s=75" width="75" height="75"><br />
+Francesco Trotta
+</a>
+</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/yeonjuan">
 <img src="https://github.com/yeonjuan.png?s=75" width="75" height="75"><br />
 YeonJuan

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

@@ -615,8 +615,8 @@ class CLIEngine {
             useEslintrc: options.useEslintrc,
             builtInRules,
             loadRules,
-            getEslintRecommendedConfig: () => require("../../conf/eslint-recommended.js"),
-            getEslintAllConfig: () => require("../../conf/eslint-all.js")
+            getEslintRecommendedConfig: () => require("@eslint/js").configs.recommended,
+            getEslintAllConfig: () => require("@eslint/js").configs.all
         });
         const fileEnumerator = new FileEnumerator({
             configArrayFactory,

package/lib/cli-engine/file-enumerator.js

@@ -217,8 +217,8 @@ class FileEnumerator {
         cwd = process.cwd(),
         configArrayFactory = new CascadingConfigArrayFactory({
             cwd,
-            getEslintRecommendedConfig: () => require("../../conf/eslint-recommended.js"),
-            getEslintAllConfig: () => require("../../conf/eslint-all.js")
+            getEslintRecommendedConfig: () => require("@eslint/js").configs.recommended,
+            getEslintAllConfig: () => require("@eslint/js").configs.all
         }),
         extensions = null,
         globInputPaths = true,

package/lib/config/flat-config-array.js

@@ -13,7 +13,7 @@ const { ConfigArray, ConfigArraySymbol } = require("@humanwhocodes/config-array"
 const { flatConfigSchema } = require("./flat-config-schema");
 const { RuleValidator } = require("./rule-validator");
 const { defaultConfig } = require("./default-config");
-const recommendedConfig = require("../../conf/eslint-recommended");
+const jsPlugin = require("@eslint/js");
 
 //-----------------------------------------------------------------------------
 // Helpers
@@ -96,17 +96,23 @@ class FlatConfigArray extends ConfigArray {
      */
     [ConfigArraySymbol.preprocessConfig](config) {
         if (config === "eslint:recommended") {
-            return recommendedConfig;
+
+            // if we are in a Node.js environment warn the user
+            if (typeof process !== "undefined" && process.emitWarning) {
+                process.emitWarning("The 'eslint:recommended' string configuration is deprecated and will be replaced by the @eslint/js package's 'recommended' config.");
+            }
+
+            return jsPlugin.configs.recommended;
         }
 
         if (config === "eslint:all") {
 
-            /*
-             * Load `eslint-all.js` here instead of at the top level to avoid loading all rule modules
-             * when it isn't necessary. `eslint-all.js` reads `meta` of rule objects to filter out deprecated ones,
-             * so requiring `eslint-all.js` module loads all rule modules as a consequence.
-             */
-            return require("../../conf/eslint-all");
+            // if we are in a Node.js environment warn the user
+            if (typeof process !== "undefined" && process.emitWarning) {
+                process.emitWarning("The 'eslint:all' string configuration is deprecated and will be replaced by the @eslint/js package's 'all' config.");
+            }
+
+            return jsPlugin.configs.all;
         }
 
         /*

package/lib/eslint/eslint-helpers.js

@@ -223,7 +223,7 @@ function globMatch({ basePath, pattern }) {
  *      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
+ * @throws {UnmatchedSearchPatternsError} If there is a pattern that doesn't
  *      match any files.
  */
 async function globSearch({

package/lib/rules/lines-around-comment.js

@@ -113,6 +113,10 @@ module.exports = {
                     },
                     applyDefaultIgnorePatterns: {
                         type: "boolean"
+                    },
+                    afterHashbangComment: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -449,6 +453,13 @@ module.exports = {
                                 before: options.beforeBlockComment
                             });
                         }
+                    } else if (token.type === "Shebang") {
+                        if (options.afterHashbangComment) {
+                            checkForEmptyLine(token, {
+                                after: options.afterHashbangComment,
+                                before: false
+                            });
+                        }
                     }
                 });
             }

package/lib/rules/logical-assignment-operators.js

@@ -112,7 +112,7 @@ function isBooleanCast(expression, scope) {
 /**
  * Returns true for:
  * truthiness checks:  value, Boolean(value), !!value
- * falsyness checks:   !value, !Boolean(value)
+ * falsiness checks:   !value, !Boolean(value)
  * nullish checks:     value == null, value === undefined || value === null
  * @param {ASTNode} expression Test condition
  * @param {import('eslint-scope').Scope} scope Scope of the expression

package/lib/rules/no-constant-binary-expression.js

@@ -14,6 +14,23 @@ const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|"
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Checks whether or not a node is `null` or `undefined`. Similar to the one
+ * found in ast-utils.js, but this one correctly handles the edge case that
+ * `undefined` has been redefined.
+ * @param {Scope} scope Scope in which the expression was found.
+ * @param {ASTNode} node A node to check.
+ * @returns {boolean} Whether or not the node is a `null` or `undefined`.
+ * @public
+ */
+function isNullOrUndefined(scope, node) {
+    return (
+        isNullLiteral(node) ||
+        (node.type === "Identifier" && node.name === "undefined" && isReferenceToGlobalVariable(scope, node)) ||
+        (node.type === "UnaryExpression" && node.operator === "void")
+    );
+}
+
 /**
  * Test if an AST node has a statically knowable constant nullishness. Meaning,
  * it will always resolve to a constant value of either: `null`, `undefined`
@@ -21,9 +38,14 @@ const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|"
  * three states at runtime would return `false`.
  * @param {Scope} scope The scope in which the node was found.
  * @param {ASTNode} node The AST node being tested.
+ * @param {boolean} nonNullish if `true` then nullish values are not considered constant.
  * @returns {boolean} Does `node` have constant nullishness?
  */
-function hasConstantNullishness(scope, node) {
+function hasConstantNullishness(scope, node, nonNullish) {
+    if (nonNullish && isNullOrUndefined(scope, node)) {
+        return false;
+    }
+
     switch (node.type) {
         case "ObjectExpression": // Objects are never nullish
         case "ArrayExpression": // Arrays are never nullish
@@ -45,9 +67,12 @@ function hasConstantNullishness(scope, node) {
             return (functionName === "Boolean" || functionName === "String" || functionName === "Number") &&
                 isReferenceToGlobalVariable(scope, node.callee);
         }
+        case "LogicalExpression": {
+            return node.operator === "??" && hasConstantNullishness(scope, node.right, true);
+        }
         case "AssignmentExpression":
             if (node.operator === "=") {
-                return hasConstantNullishness(scope, node.right);
+                return hasConstantNullishness(scope, node.right, nonNullish);
             }
 
             /*
@@ -80,7 +105,7 @@ function hasConstantNullishness(scope, node) {
         case "SequenceExpression": {
             const last = node.expressions[node.expressions.length - 1];
 
-            return hasConstantNullishness(scope, last);
+            return hasConstantNullishness(scope, last, nonNullish);
         }
         case "Identifier":
             return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
@@ -348,7 +373,7 @@ function isAlwaysNew(scope, node) {
              * user-defined constructors could return a sentinel
              * object.
              *
-             * Catching these is especially useful for primitive constructures
+             * Catching these is especially useful for primitive constructors
              * which return boxed values, a surprising gotcha' in JavaScript.
              */
             return Object.hasOwnProperty.call(globals.builtin, node.callee.name) &&
@@ -378,24 +403,6 @@ function isAlwaysNew(scope, node) {
     }
 }
 
-/**
- * Checks whether or not a node is `null` or `undefined`. Similar to the one
- * found in ast-utils.js, but this one correctly handles the edge case that
- * `undefined` has been redefined.
- * @param {Scope} scope Scope in which the expression was found.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} Whether or not the node is a `null` or `undefined`.
- * @public
- */
-function isNullOrUndefined(scope, node) {
-    return (
-        isNullLiteral(node) ||
-        (node.type === "Identifier" && node.name === "undefined" && isReferenceToGlobalVariable(scope, node)) ||
-        (node.type === "UnaryExpression" && node.operator === "void")
-    );
-}
-
-
 /**
  * Checks if one operand will cause the result to be constant.
  * @param {Scope} scope Scope in which the expression was found.
@@ -407,14 +414,14 @@ function isNullOrUndefined(scope, node) {
 function findBinaryExpressionConstantOperand(scope, a, b, operator) {
     if (operator === "==" || operator === "!=") {
         if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b)) ||
+            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
             (isStaticBoolean(scope, a) && hasConstantLooseBooleanComparison(scope, b))
         ) {
             return b;
         }
     } else if (operator === "===" || operator === "!==") {
         if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b)) ||
+            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
             (isStaticBoolean(scope, a) && hasConstantStrictBooleanComparison(scope, b))
         ) {
             return b;
@@ -453,7 +460,7 @@ module.exports = {
 
                 if ((operator === "&&" || operator === "||") && isConstant(scope, left, true)) {
                     context.report({ node: left, messageId: "constantShortCircuit", data: { property: "truthiness", operator } });
-                } else if (operator === "??" && hasConstantNullishness(scope, left)) {
+                } else if (operator === "??" && hasConstantNullishness(scope, left, false)) {
                     context.report({ node: left, messageId: "constantShortCircuit", data: { property: "nullishness", operator } });
                 }
             },

package/lib/rules/no-eval.js

@@ -72,7 +72,7 @@ module.exports = {
         let funcInfo = null;
 
         /**
-         * Pushs a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
+         * Pushes a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
          * Top-level scopes are handled separately.
          *
          * This is used in order to check whether or not `this` binding is a

package/lib/rules/no-useless-return.js

@@ -197,7 +197,7 @@ module.exports = {
 
         return {
 
-            // Makes and pushs a new scope information.
+            // Makes and pushes a new scope information.
             onCodePathStart(codePath) {
                 scopeInfo = {
                     upper: scopeInfo,

package/messages/no-config-found.js

@@ -10,6 +10,6 @@ ESLint couldn't find a configuration file. To set up a configuration file for th
 
 ESLint looked for configuration files in ${directoryPath} and its ancestors. If it found none, it then looked in your home directory.
 
-If you think you already have a configuration file or if you need more help, please stop by the ESLint chat room: https://eslint.org/chat/help
+If you think you already have a configuration file or if you need more help, please stop by the ESLint Discord server: https://eslint.org/chat
 `.trimStart();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.34.0",
+  "version": "8.35.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -37,6 +37,10 @@
   "lint-staged": {
     "*.js": "eslint --fix",
     "*.md": "markdownlint --fix",
+    "lib/rules/*.js": [
+      "node tools/update-eslint-all.js",
+      "git add packages/js/src/configs/eslint-all.js"
+    ],
     "docs/src/rules/*.md": [
       "node tools/fetch-docs-links.js",
       "git add docs/src/_data/further_reading_links.json"
@@ -56,7 +60,8 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.4.1",
+    "@eslint/eslintrc": "^2.0.0",
+    "@eslint/js": "8.35.0",
     "@humanwhocodes/config-array": "^0.11.8",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -70,7 +75,7 @@
     "eslint-utils": "^3.0.0",
     "eslint-visitor-keys": "^3.3.0",
     "espree": "^9.4.0",
-    "esquery": "^1.4.0",
+    "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",

package/conf/eslint-all.js

@@ -1,31 +0,0 @@
-/**
- * @fileoverview Config to enable all rules.
- * @author Robert Fletcher
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const builtInRules = require("../lib/rules");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const allRules = {};
-
-for (const [ruleId, rule] of builtInRules) {
-    if (!rule.meta.deprecated) {
-        allRules[ruleId] = "error";
-    }
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-/** @type {import("../lib/shared/types").ConfigData} */
-module.exports = { rules: allRules };

package/conf/eslint-recommended.js

@@ -1,76 +0,0 @@
-/**
- * @fileoverview Configuration applied when a user configuration extends from
- * eslint:recommended.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-/* eslint sort-keys: ["error", "asc"] -- Long, so make more readable */
-
-/** @type {import("../lib/shared/types").ConfigData} */
-module.exports = {
-    rules: {
-        "constructor-super": "error",
-        "for-direction": "error",
-        "getter-return": "error",
-        "no-async-promise-executor": "error",
-        "no-case-declarations": "error",
-        "no-class-assign": "error",
-        "no-compare-neg-zero": "error",
-        "no-cond-assign": "error",
-        "no-const-assign": "error",
-        "no-constant-condition": "error",
-        "no-control-regex": "error",
-        "no-debugger": "error",
-        "no-delete-var": "error",
-        "no-dupe-args": "error",
-        "no-dupe-class-members": "error",
-        "no-dupe-else-if": "error",
-        "no-dupe-keys": "error",
-        "no-duplicate-case": "error",
-        "no-empty": "error",
-        "no-empty-character-class": "error",
-        "no-empty-pattern": "error",
-        "no-ex-assign": "error",
-        "no-extra-boolean-cast": "error",
-        "no-extra-semi": "error",
-        "no-fallthrough": "error",
-        "no-func-assign": "error",
-        "no-global-assign": "error",
-        "no-import-assign": "error",
-        "no-inner-declarations": "error",
-        "no-invalid-regexp": "error",
-        "no-irregular-whitespace": "error",
-        "no-loss-of-precision": "error",
-        "no-misleading-character-class": "error",
-        "no-mixed-spaces-and-tabs": "error",
-        "no-new-symbol": "error",
-        "no-nonoctal-decimal-escape": "error",
-        "no-obj-calls": "error",
-        "no-octal": "error",
-        "no-prototype-builtins": "error",
-        "no-redeclare": "error",
-        "no-regex-spaces": "error",
-        "no-self-assign": "error",
-        "no-setter-return": "error",
-        "no-shadow-restricted-names": "error",
-        "no-sparse-arrays": "error",
-        "no-this-before-super": "error",
-        "no-undef": "error",
-        "no-unexpected-multiline": "error",
-        "no-unreachable": "error",
-        "no-unsafe-finally": "error",
-        "no-unsafe-negation": "error",
-        "no-unsafe-optional-chaining": "error",
-        "no-unused-labels": "error",
-        "no-unused-vars": "error",
-        "no-useless-backreference": "error",
-        "no-useless-catch": "error",
-        "no-useless-escape": "error",
-        "no-with": "error",
-        "require-yield": "error",
-        "use-isnan": "error",
-        "valid-typeof": "error"
-    }
-};