eslint 8.34.0 → 8.37.0

package/lib/rules/prefer-object-has-own.js

@@ -61,6 +61,9 @@ module.exports = {
         fixable: "code"
     },
     create(context) {
+
+        const sourceCode = context.getSourceCode();
+
         return {
             CallExpression(node) {
                 if (!(node.callee.type === "MemberExpression" && node.callee.object.type === "MemberExpression")) {
@@ -72,7 +75,7 @@ module.exports = {
                 const isObject = hasLeftHandObject(node.callee.object);
 
                 // check `Object` scope
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
                 const variable = astUtils.getVariableByName(scope, "Object");
 
                 if (
@@ -85,7 +88,6 @@ module.exports = {
                         node,
                         messageId: "useHasOwn",
                         fix(fixer) {
-                            const sourceCode = context.getSourceCode();
 
                             if (sourceCode.getCommentsInside(node.callee).length > 0) {
                                 return null;

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

@@ -6,7 +6,7 @@
 
 "use strict";
 
-const { CALL, ReferenceTracker } = require("eslint-utils");
+const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
 const {
     isCommaToken,
     isOpeningParenToken,
@@ -265,8 +265,8 @@ module.exports = {
         const sourceCode = context.getSourceCode();
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const trackMap = {
                     Object: {
@@ -275,22 +275,22 @@ module.exports = {
                 };
 
                 // Iterate all calls of `Object.assign` (only of the global variable `Object`).
-                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
+                for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
                     if (
-                        node.arguments.length >= 1 &&
-                        node.arguments[0].type === "ObjectExpression" &&
-                        !hasArraySpread(node) &&
+                        refNode.arguments.length >= 1 &&
+                        refNode.arguments[0].type === "ObjectExpression" &&
+                        !hasArraySpread(refNode) &&
                         !(
-                            node.arguments.length > 1 &&
-                            hasArgumentsWithAccessors(node)
+                            refNode.arguments.length > 1 &&
+                            hasArgumentsWithAccessors(refNode)
                         )
                     ) {
-                        const messageId = node.arguments.length === 1
+                        const messageId = refNode.arguments.length === 1
                             ? "useLiteralMessage"
                             : "useSpreadMessage";
-                        const fix = defineFixer(node, sourceCode);
+                        const fix = defineFixer(refNode, sourceCode);
 
-                        context.report({ node, messageId, fix });
+                        context.report({ node: refNode, messageId, fix });
                     }
                 }
             }

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

@@ -10,16 +10,15 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { CALL, CONSTRUCT, ReferenceTracker, findVariable } = require("eslint-utils");
-const { RegExpValidator, visitRegExpAST, RegExpParser } = require("regexpp");
+const { CALL, CONSTRUCT, ReferenceTracker, findVariable } = require("@eslint-community/eslint-utils");
+const { RegExpValidator, visitRegExpAST, RegExpParser } = require("@eslint-community/regexpp");
 const { canTokensBeAdjacent } = require("./utils/ast-utils");
+const { REGEXPP_LATEST_ECMA_VERSION } = require("./utils/regular-expressions");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-const REGEXPP_LATEST_ECMA_VERSION = 2022;
-
 /**
  * Determines whether the given node is a string literal.
  * @param {ASTNode} node Node to check.
@@ -163,7 +162,7 @@ module.exports = {
          * @returns {boolean} True if the identifier is a reference to a global variable.
          */
         function isGlobalReference(node) {
-            const scope = context.getScope();
+            const scope = sourceCode.getScope(node);
             const variable = findVariable(scope, node);
 
             return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
@@ -375,8 +374,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const traceMap = {
                     RegExp: {
@@ -385,16 +384,16 @@ module.exports = {
                     }
                 };
 
-                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
-                    if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(node)) {
-                        const regexNode = node.arguments[0];
+                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
+                    if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(refNode)) {
+                        const regexNode = refNode.arguments[0];
 
-                        if (node.arguments.length === 2) {
+                        if (refNode.arguments.length === 2) {
                             const suggests = [];
 
-                            const argFlags = getStringValue(node.arguments[1]) || "";
+                            const argFlags = getStringValue(refNode.arguments[1]) || "";
 
-                            if (canFixTo(node, regexNode.regex.pattern, argFlags)) {
+                            if (canFixTo(refNode, regexNode.regex.pattern, argFlags)) {
                                 suggests.push({
                                     messageId: "replaceWithLiteralAndFlags",
                                     pattern: regexNode.regex.pattern,
@@ -407,7 +406,7 @@ module.exports = {
 
                             if (
                                 !areFlagsEqual(mergedFlags, argFlags) &&
-                                canFixTo(node, regexNode.regex.pattern, mergedFlags)
+                                canFixTo(refNode, regexNode.regex.pattern, mergedFlags)
                             ) {
                                 suggests.push({
                                     messageId: "replaceWithIntendedLiteralAndFlags",
@@ -417,7 +416,7 @@ module.exports = {
                             }
 
                             context.report({
-                                node,
+                                node: refNode,
                                 messageId: "unexpectedRedundantRegExpWithFlags",
                                 suggest: suggests.map(({ flags, pattern, messageId }) => ({
                                     messageId,
@@ -425,42 +424,42 @@ module.exports = {
                                         flags
                                     },
                                     fix(fixer) {
-                                        return fixer.replaceText(node, getSafeOutput(node, `/${pattern}/${flags}`));
+                                        return fixer.replaceText(refNode, getSafeOutput(refNode, `/${pattern}/${flags}`));
                                     }
                                 }))
                             });
                         } else {
                             const outputs = [];
 
-                            if (canFixTo(node, regexNode.regex.pattern, regexNode.regex.flags)) {
+                            if (canFixTo(refNode, regexNode.regex.pattern, regexNode.regex.flags)) {
                                 outputs.push(sourceCode.getText(regexNode));
                             }
 
 
                             context.report({
-                                node,
+                                node: refNode,
                                 messageId: "unexpectedRedundantRegExp",
                                 suggest: outputs.map(output => ({
                                     messageId: "replaceWithLiteral",
                                     fix(fixer) {
                                         return fixer.replaceText(
-                                            node,
-                                            getSafeOutput(node, output)
+                                            refNode,
+                                            getSafeOutput(refNode, output)
                                         );
                                     }
                                 }))
                             });
                         }
-                    } else if (hasOnlyStaticStringArguments(node)) {
-                        let regexContent = getStringValue(node.arguments[0]);
+                    } else if (hasOnlyStaticStringArguments(refNode)) {
+                        let regexContent = getStringValue(refNode.arguments[0]);
                         let noFix = false;
                         let flags;
 
-                        if (node.arguments[1]) {
-                            flags = getStringValue(node.arguments[1]);
+                        if (refNode.arguments[1]) {
+                            flags = getStringValue(refNode.arguments[1]);
                         }
 
-                        if (!canFixTo(node, regexContent, flags)) {
+                        if (!canFixTo(refNode, regexContent, flags)) {
                             noFix = true;
                         }
 
@@ -494,12 +493,12 @@ module.exports = {
                         const newRegExpValue = `/${regexContent || "(?:)"}/${flags || ""}`;
 
                         context.report({
-                            node,
+                            node: refNode,
                             messageId: "unexpectedRegExp",
                             suggest: noFix ? [] : [{
                                 messageId: "replaceWithLiteral",
                                 fix(fixer) {
-                                    return fixer.replaceText(node, getSafeOutput(node, newRegExpValue));
+                                    return fixer.replaceText(refNode, getSafeOutput(refNode, newRegExpValue));
                                 }
                             }]
                         });

package/lib/rules/prefer-rest-params.js

@@ -79,6 +79,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports a given reference.
          * @param {eslint-scope.Reference} reference A reference to report.
@@ -94,10 +96,11 @@ module.exports = {
 
         /**
          * Reports references of the implicit `arguments` variable if exist.
+         * @param {ASTNode} node The node representing the function.
          * @returns {void}
          */
-        function checkForArguments() {
-            const argumentsVar = getVariableOfArguments(context.getScope());
+        function checkForArguments(node) {
+            const argumentsVar = getVariableOfArguments(sourceCode.getScope(node));
 
             if (argumentsVar) {
                 argumentsVar

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,79 @@ 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;
+                    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,8 +77,8 @@ module.exports = {
 
         return {
 
-            Program() {
-                globalScope = context.getScope();
+            Program(node) {
+                globalScope = sourceCode.getScope(node);
             },
 
             UnaryExpression(node) {

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/source-code/source-code.js

@@ -9,7 +9,7 @@
 //------------------------------------------------------------------------------
 
 const
-    { isCommentToken } = require("eslint-utils"),
+    { isCommentToken } = require("@eslint-community/eslint-utils"),
     TokenStore = require("./token-store"),
     astUtils = require("../shared/ast-utils"),
     Traverser = require("../shared/traverser");
@@ -143,6 +143,8 @@ function isSpaceBetween(sourceCode, first, second, checkInsideOfJSXText) {
 // Public Interface
 //------------------------------------------------------------------------------
 
+const caches = Symbol("caches");
+
 /**
  * Represents parsed source code.
  */
@@ -175,6 +177,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 +597,48 @@ 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];
+    }
+
 }
 
 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;