eslint 8.34.0 → 8.38.0

package/lib/rules/radix.js

@@ -104,6 +104,7 @@ module.exports = {
 
     create(context) {
         const mode = context.options[0] || MODE_ALWAYS;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks the arguments of a given CallExpression node and reports it if it
@@ -131,7 +132,6 @@ module.exports = {
                                 {
                                     messageId: "addRadixParameter10",
                                     fix(fixer) {
-                                        const sourceCode = context.getSourceCode();
                                         const tokens = sourceCode.getTokens(node);
                                         const lastToken = tokens[tokens.length - 1]; // Parenthesis.
                                         const secondToLastToken = tokens[tokens.length - 2]; // May or may not be a comma.
@@ -162,18 +162,18 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const scope = context.getScope();
+            "Program:exit"(node) {
+                const scope = sourceCode.getScope(node);
                 let variable;
 
                 // Check `parseInt()`
                 variable = astUtils.getVariableByName(scope, "parseInt");
                 if (variable && !isShadowed(variable)) {
                     variable.references.forEach(reference => {
-                        const node = reference.identifier;
+                        const idNode = reference.identifier;
 
-                        if (astUtils.isCallee(node)) {
-                            checkArguments(node.parent);
+                        if (astUtils.isCallee(idNode)) {
+                            checkArguments(idNode.parent);
                         }
                     });
                 }
@@ -182,12 +182,12 @@ module.exports = {
                 variable = astUtils.getVariableByName(scope, "Number");
                 if (variable && !isShadowed(variable)) {
                     variable.references.forEach(reference => {
-                        const node = reference.identifier.parent;
-                        const maybeCallee = node.parent.type === "ChainExpression"
-                            ? node.parent
-                            : node;
+                        const parentNode = reference.identifier.parent;
+                        const maybeCallee = parentNode.parent.type === "ChainExpression"
+                            ? parentNode.parent
+                            : parentNode;
 
-                        if (isParseIntMethod(node) && astUtils.isCallee(maybeCallee)) {
+                        if (isParseIntMethod(parentNode) && astUtils.isCallee(maybeCallee)) {
                             checkArguments(maybeCallee.parent);
                         }
                     });

package/lib/rules/require-atomic-updates.js

@@ -204,8 +204,8 @@ module.exports = {
         let stack = null;
 
         return {
-            onCodePathStart(codePath) {
-                const scope = context.getScope();
+            onCodePathStart(codePath, node) {
+                const scope = sourceCode.getScope(node);
                 const shouldVerify =
                     scope.type === "function" &&
                     (scope.block.async || scope.block.generator);

package/lib/rules/require-unicode-regexp.js

@@ -14,7 +14,9 @@ const {
     CONSTRUCT,
     ReferenceTracker,
     getStringIfConstant
-} = require("eslint-utils");
+} = require("@eslint-community/eslint-utils");
+const astUtils = require("./utils/ast-utils.js");
+const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -31,7 +33,10 @@ module.exports = {
             url: "https://eslint.org/docs/rules/require-unicode-regexp"
         },
 
+        hasSuggestions: true,
+
         messages: {
+            addUFlag: "Add the 'u' flag.",
             requireUFlag: "Use the 'u' flag."
         },
 
@@ -39,28 +44,83 @@ module.exports = {
     },
 
     create(context) {
+
+        const sourceCode = context.getSourceCode();
+
         return {
             "Literal[regex]"(node) {
                 const flags = node.regex.flags || "";
 
                 if (!flags.includes("u")) {
-                    context.report({ node, messageId: "requireUFlag" });
+                    context.report({
+                        messageId: "requireUFlag",
+                        node,
+                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)
+                            ? [
+                                {
+                                    fix(fixer) {
+                                        return fixer.insertTextAfter(node, "u");
+                                    },
+                                    messageId: "addUFlag"
+                                }
+                            ]
+                            : null
+                    });
                 }
             },
 
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const trackMap = {
                     RegExp: { [CALL]: true, [CONSTRUCT]: true }
                 };
 
-                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
-                    const flagsNode = node.arguments[1];
+                for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
+                    const [patternNode, flagsNode] = refNode.arguments;
+
+                    if (patternNode && patternNode.type === "SpreadElement") {
+                        continue;
+                    }
+                    const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 
                     if (!flagsNode || (typeof flags === "string" && !flags.includes("u"))) {
-                        context.report({ node, messageId: "requireUFlag" });
+                        context.report({
+                            messageId: "requireUFlag",
+                            node: refNode,
+                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)
+                                ? [
+                                    {
+                                        fix(fixer) {
+                                            if (flagsNode) {
+                                                if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
+                                                    const flagsNodeText = sourceCode.getText(flagsNode);
+
+                                                    return fixer.replaceText(flagsNode, [
+                                                        flagsNodeText.slice(0, flagsNodeText.length - 1),
+                                                        flagsNodeText.slice(flagsNodeText.length - 1)
+                                                    ].join("u"));
+                                                }
+
+                                                // We intentionally don't suggest concatenating + "u" to non-literals
+                                                return null;
+                                            }
+
+                                            const penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 }); // skip closing parenthesis
+
+                                            return fixer.insertTextAfter(
+                                                penultimateToken,
+                                                astUtils.isCommaToken(penultimateToken)
+                                                    ? ' "u",'
+                                                    : ', "u"'
+                                            );
+                                        },
+                                        messageId: "addUFlag"
+                                    }
+                                ]
+                                : null
+                        });
                     }
                 }
             }

package/lib/rules/symbol-description.js

@@ -35,6 +35,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports if node does not conform the rule in case rule is set to
          * report missing description
@@ -51,16 +53,16 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const scope = context.getScope();
+            "Program:exit"(node) {
+                const scope = sourceCode.getScope(node);
                 const variable = astUtils.getVariableByName(scope, "Symbol");
 
                 if (variable && variable.defs.length === 0) {
                     variable.references.forEach(reference => {
-                        const node = reference.identifier;
+                        const idNode = reference.identifier;
 
-                        if (astUtils.isCallee(node)) {
-                            checkArgument(node.parent);
+                        if (astUtils.isCallee(idNode)) {
+                            checkArgument(idNode.parent);
                         }
                     });
                 }

package/lib/rules/utils/regular-expressions.js

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Common utils for regular expressions.
+ * @author Josh Goldberg
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const { RegExpValidator } = require("@eslint-community/regexpp");
+
+const REGEXPP_LATEST_ECMA_VERSION = 2022;
+
+/**
+ * Checks if the given regular expression pattern would be valid with the `u` flag.
+ * @param {number} ecmaVersion ECMAScript version to parse in.
+ * @param {string} pattern The regular expression pattern to verify.
+ * @returns {boolean} `true` if the pattern would be valid with the `u` flag.
+ * `false` if the pattern would be invalid with the `u` flag or the configured
+ * ecmaVersion doesn't support the `u` flag.
+ */
+function isValidWithUnicodeFlag(ecmaVersion, pattern) {
+    if (ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+        return false;
+    }
+
+    const validator = new RegExpValidator({
+        ecmaVersion: Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION)
+    });
+
+    try {
+        validator.validatePattern(pattern, void 0, void 0, /* uFlag = */ true);
+    } catch {
+        return false;
+    }
+
+    return true;
+}
+
+module.exports = {
+    isValidWithUnicodeFlag,
+    REGEXPP_LATEST_ECMA_VERSION
+};

package/lib/rules/valid-typeof.js

@@ -44,7 +44,7 @@ module.exports = {
 
         const VALID_TYPES = new Set(["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"]),
             OPERATORS = new Set(["==", "===", "!=", "!=="]);
-
+        const sourceCode = context.getSourceCode();
         const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;
 
         let globalScope;
@@ -77,13 +77,13 @@ module.exports = {
 
         return {
 
-            Program() {
-                globalScope = context.getScope();
+            Program(node) {
+                globalScope = sourceCode.getScope(node);
             },
 
             UnaryExpression(node) {
                 if (isTypeofExpression(node)) {
-                    const parent = context.getAncestors().pop();
+                    const parent = sourceCode.getAncestors(node).pop();
 
                     if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
                         const sibling = parent.left === node ? parent.right : parent.left;

package/lib/rules/wrap-iife.js

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("eslint-utils");
+const eslintUtils = require("@eslint-community/eslint-utils");
 
 //----------------------------------------------------------------------
 // Helpers

package/lib/rules/wrap-regex.js

@@ -40,7 +40,7 @@ module.exports = {
                 if (nodeType === "RegularExpression") {
                     const beforeToken = sourceCode.getTokenBefore(node);
                     const afterToken = sourceCode.getTokenAfter(node);
-                    const ancestors = context.getAncestors();
+                    const ancestors = sourceCode.getAncestors(node);
                     const grandparent = ancestors[ancestors.length - 1];
 
                     if (grandparent.type === "MemberExpression" && grandparent.object === node &&

package/lib/rules/yoda.js

@@ -343,7 +343,7 @@ module.exports = {
                     ) &&
                     !(!isEqualityOperator(node.operator) && onlyEquality) &&
                     isComparisonOperator(node.operator) &&
-                    !(exceptRange && isRangeTest(context.getAncestors().pop()))
+                    !(exceptRange && isRangeTest(sourceCode.getAncestors(node).pop()))
                 ) {
                     context.report({
                         node,

package/lib/source-code/source-code.js

@@ -9,11 +9,17 @@
 //------------------------------------------------------------------------------
 
 const
-    { isCommentToken } = require("eslint-utils"),
+    { isCommentToken } = require("@eslint-community/eslint-utils"),
     TokenStore = require("./token-store"),
     astUtils = require("../shared/ast-utils"),
     Traverser = require("../shared/traverser");
 
+//------------------------------------------------------------------------------
+// Type Definitions
+//------------------------------------------------------------------------------
+
+/** @typedef {import("eslint-scope").Variable} Variable */
+
 //------------------------------------------------------------------------------
 // Private
 //------------------------------------------------------------------------------
@@ -143,6 +149,8 @@ function isSpaceBetween(sourceCode, first, second, checkInsideOfJSXText) {
 // Public Interface
 //------------------------------------------------------------------------------
 
+const caches = Symbol("caches");
+
 /**
  * Represents parsed source code.
  */
@@ -175,6 +183,13 @@ class SourceCode extends TokenStore {
         validate(ast);
         super(ast.tokens, ast.comments);
 
+        /**
+         * General purpose caching for the class.
+         */
+        this[caches] = new Map([
+            ["scopes", new WeakMap()]
+        ]);
+
         /**
          * The flag to indicate that the source code has Unicode BOM.
          * @type {boolean}
@@ -588,6 +603,84 @@ class SourceCode extends TokenStore {
 
         return positionIndex;
     }
+
+    /**
+     * Gets the scope for the given node
+     * @param {ASTNode} currentNode The node to get the scope of
+     * @returns {eslint-scope.Scope} The scope information for this node
+     * @throws {TypeError} If the `currentNode` argument is missing.
+     */
+    getScope(currentNode) {
+
+        if (!currentNode) {
+            throw new TypeError("Missing required argument: node.");
+        }
+
+        // check cache first
+        const cache = this[caches].get("scopes");
+        const cachedScope = cache.get(currentNode);
+
+        if (cachedScope) {
+            return cachedScope;
+        }
+
+        // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
+        const inner = currentNode.type !== "Program";
+
+        for (let node = currentNode; node; node = node.parent) {
+            const scope = this.scopeManager.acquire(node, inner);
+
+            if (scope) {
+                if (scope.type === "function-expression-name") {
+                    cache.set(currentNode, scope.childScopes[0]);
+                    return scope.childScopes[0];
+                }
+
+                cache.set(currentNode, scope);
+                return scope;
+            }
+        }
+
+        cache.set(currentNode, this.scopeManager.scopes[0]);
+        return this.scopeManager.scopes[0];
+    }
+
+    /**
+     * Gets all of the declared variables in the scope associated
+     * with `node`. This is a convenience method that passes through
+     * to the same method on the `scopeManager`.
+     * @param {ASTNode} node The node from which to retrieve the scope to check.
+     * @returns {Array<Variable>} An array of variable nodes representing
+     *      the declared variables in the scope associated with `node`.
+     */
+    getDeclaredVariables(node) {
+        return this.scopeManager.getDeclaredVariables(node);
+    }
+
+    /* eslint-disable class-methods-use-this -- node is owned by SourceCode */
+    /**
+     * Gets all the ancestors of a given node
+     * @param {ASTNode} node The node
+     * @returns {Array<ASTNode>} All the ancestor nodes in the AST, not including the provided node, starting
+     * from the root node at index 0 and going inwards to the parent node.
+     * @throws {TypeError} When `node` is missing.
+     */
+    getAncestors(node) {
+
+        if (!node) {
+            throw new TypeError("Missing required argument: node.");
+        }
+
+        const ancestorsStartingAtParent = [];
+
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+            ancestorsStartingAtParent.push(ancestor);
+        }
+
+        return ancestorsStartingAtParent.reverse();
+    }
+    /* eslint-enable class-methods-use-this -- node is owned by SourceCode */
+
 }
 
 module.exports = SourceCode;

package/lib/source-code/token-store/index.js

@@ -9,7 +9,7 @@
 //------------------------------------------------------------------------------
 
 const assert = require("assert");
-const { isCommentToken } = require("eslint-utils");
+const { isCommentToken } = require("@eslint-community/eslint-utils");
 const cursors = require("./cursors");
 const ForwardTokenCursor = require("./forward-token-cursor");
 const PaddedTokenCursor = require("./padded-token-cursor");

package/lib/source-code/token-store/utils.js

@@ -49,13 +49,18 @@ exports.getFirstIndex = function getFirstIndex(tokens, indexMap, startLoc) {
     }
     if ((startLoc - 1) in indexMap) {
         const index = indexMap[startLoc - 1];
-        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
+        const token = tokens[index];
+
+        // If the mapped index is out of bounds, the returned cursor index will point after the end of the tokens array.
+        if (!token) {
+            return tokens.length;
+        }
 
         /*
          * For the map of "comment's location -> token's index", it points the next token of a comment.
          * In that case, +1 is unnecessary.
          */
-        if (token && token.range[0] >= startLoc) {
+        if (token.range[0] >= startLoc) {
             return index;
         }
         return index + 1;
@@ -77,13 +82,18 @@ exports.getLastIndex = function getLastIndex(tokens, indexMap, endLoc) {
     }
     if ((endLoc - 1) in indexMap) {
         const index = indexMap[endLoc - 1];
-        const token = (index >= 0 && index < tokens.length) ? tokens[index] : null;
+        const token = tokens[index];
+
+        // If the mapped index is out of bounds, the returned cursor index will point before the end of the tokens array.
+        if (!token) {
+            return tokens.length - 1;
+        }
 
         /*
          * For the map of "comment's location -> token's index", it points the next token of a comment.
          * In that case, -1 is necessary.
          */
-        if (token && token.range[1] > endLoc) {
+        if (token.range[1] > endLoc) {
             return index - 1;
         }
         return index;

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.38.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,10 @@
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
-    "@eslint/eslintrc": "^1.4.1",
+    "@eslint-community/eslint-utils": "^4.2.0",
+    "@eslint-community/regexpp": "^4.4.0",
+    "@eslint/eslintrc": "^2.0.2",
+    "@eslint/js": "8.38.0",
     "@humanwhocodes/config-array": "^0.11.8",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",
@@ -67,10 +74,9 @@
     "doctrine": "^3.0.0",
     "escape-string-regexp": "^4.0.0",
     "eslint-scope": "^7.1.1",
-    "eslint-utils": "^3.0.0",
-    "eslint-visitor-keys": "^3.3.0",
-    "espree": "^9.4.0",
-    "esquery": "^1.4.0",
+    "eslint-visitor-keys": "^3.4.0",
+    "espree": "^9.5.1",
+    "esquery": "^1.4.2",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^6.0.1",
@@ -91,7 +97,6 @@
     "minimatch": "^3.1.2",
     "natural-compare": "^1.4.0",
     "optionator": "^0.9.1",
-    "regexpp": "^3.2.0",
     "strip-ansi": "^6.0.1",
     "strip-json-comments": "^3.1.0",
     "text-table": "^0.2.0"

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"
-    }
-};