eslint 8.34.0 → 8.37.0

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

@@ -3,17 +3,16 @@
  */
 "use strict";
 
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("eslint-utils");
-const { RegExpValidator, RegExpParser, visitRegExpAST } = require("regexpp");
+const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
 const { isCombiningCharacter, isEmojiModifier, isRegionalIndicatorSymbol, isSurrogatePair } = require("./utils/unicode");
 const astUtils = require("./utils/ast-utils.js");
+const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-const REGEXPP_LATEST_ECMA_VERSION = 2022;
-
 /**
  * Iterate character sequences of a given nodes.
  *
@@ -185,46 +184,18 @@ module.exports = {
             }
         }
 
-        /**
-         * Checks if the given regular expression pattern would be valid with the `u` flag.
-         * @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(pattern) {
-            const { ecmaVersion } = context.languageOptions;
-
-            // ecmaVersion <= 5 doesn't support the 'u' flag
-            if (ecmaVersion <= 5) {
-                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;
-        }
-
         return {
             "Literal[regex]"(node) {
                 verify(node, node.regex.pattern, node.regex.flags, fixer => {
-                    if (!isValidWithUnicodeFlag(node.regex.pattern)) {
+                    if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)) {
                         return null;
                     }
 
                     return fixer.insertTextAfter(node, "u");
                 });
             },
-            "Program"() {
-                const scope = context.getScope();
+            "Program"(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
 
                 /*
@@ -232,22 +203,22 @@ module.exports = {
                  * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`,
                  *       `const {RegExp: a} = window; new a()`, etc...
                  */
-                for (const { node } of tracker.iterateGlobalReferences({
+                for (const { node: refNode } of tracker.iterateGlobalReferences({
                     RegExp: { [CALL]: true, [CONSTRUCT]: true }
                 })) {
-                    const [patternNode, flagsNode] = node.arguments;
+                    const [patternNode, flagsNode] = refNode.arguments;
                     const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 
                     if (typeof pattern === "string") {
-                        verify(node, pattern, flags || "", fixer => {
+                        verify(refNode, pattern, flags || "", fixer => {
 
-                            if (!isValidWithUnicodeFlag(pattern)) {
+                            if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)) {
                                 return null;
                             }
 
-                            if (node.arguments.length === 1) {
-                                const penultimateToken = sourceCode.getLastToken(node, { skip: 1 }); // skip closing parenthesis
+                            if (refNode.arguments.length === 1) {
+                                const penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 }); // skip closing parenthesis
 
                                 return fixer.insertTextAfter(
                                     penultimateToken,

package/lib/rules/no-native-reassign.js

@@ -47,6 +47,7 @@ module.exports = {
     create(context) {
         const config = context.options[0];
         const exceptions = (config && config.exceptions) || [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports write references.
@@ -87,8 +88,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const globalScope = context.getScope();
+            Program(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 globalScope.variables.forEach(checkVariable);
             }

package/lib/rules/no-new-func.js

@@ -40,27 +40,28 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         return {
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
                 const variable = globalScope.set.get("Function");
 
                 if (variable && variable.defs.length === 0) {
                     variable.references.forEach(ref => {
-                        const node = ref.identifier;
-                        const { parent } = node;
+                        const idNode = ref.identifier;
+                        const { parent } = idNode;
                         let evalNode;
 
                         if (parent) {
-                            if (node === parent.callee && (
+                            if (idNode === parent.callee && (
                                 parent.type === "NewExpression" ||
                                 parent.type === "CallExpression"
                             )) {
                                 evalNode = parent;
                             } else if (
                                 parent.type === "MemberExpression" &&
-                                node === parent.object &&
+                                idNode === parent.object &&
                                 callMethods.has(astUtils.getStaticPropertyName(parent))
                             ) {
                                 const maybeCallee = parent.parent.type === "ChainExpression" ? parent.parent : parent;

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

@@ -35,21 +35,23 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         return {
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 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;
+                            const idNode = ref.identifier;
+                            const parent = idNode.parent;
 
-                            if (parent && parent.type === "NewExpression" && parent.callee === node) {
+                            if (parent && parent.type === "NewExpression" && parent.callee === idNode) {
                                 context.report({
-                                    node,
+                                    node: idNode,
                                     messageId: "noNewNonconstructor",
                                     data: { name: nonConstructorName }
                                 });

package/lib/rules/no-new-object.js

@@ -34,10 +34,13 @@ module.exports = {
     },
 
     create(context) {
+
+        const sourceCode = context.getSourceCode();
+
         return {
             NewExpression(node) {
                 const variable = astUtils.getVariableByName(
-                    context.getScope(),
+                    sourceCode.getScope(node),
                     node.callee.name
                 );
 

package/lib/rules/no-new-symbol.js

@@ -29,19 +29,21 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         return {
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
                 const variable = globalScope.set.get("Symbol");
 
                 if (variable && variable.defs.length === 0) {
                     variable.references.forEach(ref => {
-                        const node = ref.identifier;
-                        const parent = node.parent;
+                        const idNode = ref.identifier;
+                        const parent = idNode.parent;
 
-                        if (parent && parent.type === "NewExpression" && parent.callee === node) {
+                        if (parent && parent.type === "NewExpression" && parent.callee === idNode) {
                             context.report({
-                                node,
+                                node: idNode,
                                 messageId: "noNewSymbol"
                             });
                         }

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

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CALL, CONSTRUCT, ReferenceTracker } = require("eslint-utils");
+const { CALL, CONSTRUCT, ReferenceTracker } = require("@eslint-community/eslint-utils");
 const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 
 //------------------------------------------------------------------------------
@@ -58,9 +58,11 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const traceMap = {};
 
@@ -71,12 +73,12 @@ module.exports = {
                     };
                 }
 
-                for (const { node, path } of tracker.iterateGlobalReferences(traceMap)) {
-                    const name = getReportNodeName(node.callee);
+                for (const { node: refNode, path } of tracker.iterateGlobalReferences(traceMap)) {
+                    const name = getReportNodeName(refNode.callee);
                     const ref = path[0];
                     const messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
 
-                    context.report({ node, messageId, data: { name, ref } });
+                    context.report({ node: refNode, messageId, data: { name, ref } });
                 }
             }
         };

package/lib/rules/no-promise-executor-return.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("eslint-utils");
+const { findVariable } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -84,6 +84,7 @@ module.exports = {
     create(context) {
 
         let funcInfo = null;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports the given node.
@@ -99,7 +100,7 @@ module.exports = {
             onCodePathStart(_, node) {
                 funcInfo = {
                     upper: funcInfo,
-                    shouldCheck: functionTypesToCheck.has(node.type) && isPromiseExecutor(node, context.getScope())
+                    shouldCheck: functionTypesToCheck.has(node.type) && isPromiseExecutor(node, sourceCode.getScope(node))
                 };
 
                 if (funcInfo.shouldCheck && node.type === "ArrowFunctionExpression" && node.expression) {

package/lib/rules/no-redeclare.js

@@ -129,7 +129,7 @@ module.exports = {
          * @private
          */
         function checkForBlock(node) {
-            const scope = context.getScope();
+            const scope = sourceCode.getScope(node);
 
             /*
              * In ES5, some node type such as `BlockStatement` doesn't have that scope.
@@ -141,8 +141,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
 
                 findVariablesInScope(scope);
 

package/lib/rules/no-regex-spaces.js

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const regexpp = require("regexpp");
+const regexpp = require("@eslint-community/regexpp");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -54,6 +54,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Validate regular expression
          * @param {ASTNode} nodeToReport Node to report.
@@ -149,7 +151,7 @@ module.exports = {
          * @private
          */
         function checkFunction(node) {
-            const scope = context.getScope();
+            const scope = sourceCode.getScope(node);
             const regExpVar = astUtils.getVariableByName(scope, "RegExp");
             const shadowed = regExpVar && regExpVar.defs.length > 0;
             const patternNode = node.arguments[0];

package/lib/rules/no-restricted-globals.js

@@ -50,6 +50,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         // If no globals are restricted, we don't need to do anything
         if (context.options.length === 0) {
             return {};
@@ -99,8 +101,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
 
                 // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
                 scope.variables.forEach(variable => {

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

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { findVariable } = require("eslint-utils");
+const { findVariable } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -156,6 +156,7 @@ module.exports = {
 
     create(context) {
         let funcInfo = null;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Creates and pushes to the stack a function info object for the given function node.
@@ -163,7 +164,7 @@ module.exports = {
          * @returns {void}
          */
         function enterFunction(node) {
-            const outerScope = getOuterScope(context.getScope());
+            const outerScope = getOuterScope(sourceCode.getScope(node));
 
             funcInfo = {
                 upper: funcInfo,

package/lib/rules/no-shadow.js

@@ -67,6 +67,7 @@ module.exports = {
             allow: (context.options[0] && context.options[0].allow) || [],
             ignoreOnInitialization: context.options[0] && context.options[0].ignoreOnInitialization
         };
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether or not a given location is inside of the range of a given node.
@@ -318,8 +319,8 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
                 const stack = globalScope.childScopes.slice();
 
                 while (stack.length) {

package/lib/rules/no-undef-init.js

@@ -39,7 +39,7 @@ module.exports = {
             VariableDeclarator(node) {
                 const name = sourceCode.getText(node.id),
                     init = node.init && node.init.name,
-                    scope = context.getScope(),
+                    scope = sourceCode.getScope(node),
                     undefinedVar = astUtils.getVariableByName(scope, "undefined"),
                     shadowed = undefinedVar && undefinedVar.defs.length > 0,
                     lastToken = sourceCode.getLastToken(node);

package/lib/rules/no-undef.js

@@ -54,10 +54,11 @@ module.exports = {
     create(context) {
         const options = context.options[0];
         const considerTypeOf = options && options.typeof === true || false;
+        const sourceCode = context.getSourceCode();
 
         return {
-            "Program:exit"(/* node */) {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 globalScope.through.forEach(ref => {
                     const identifier = ref.identifier;

package/lib/rules/no-undefined.js

@@ -28,6 +28,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Report an invalid "undefined" identifier node.
          * @param {ASTNode} node The node to report.
@@ -66,8 +68,8 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 const stack = [globalScope];
 

package/lib/rules/no-unmodified-loop-condition.js

@@ -340,8 +340,8 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const queue = [context.getScope()];
+            "Program:exit"(node) {
+                const queue = [sourceCode.getScope(node)];
 
                 groupMap = new Map();
 

package/lib/rules/no-unused-vars.js

@@ -673,7 +673,7 @@ module.exports = {
 
         return {
             "Program:exit"(programNode) {
-                const unusedVars = collectUnusedVariables(context.getScope(), []);
+                const unusedVars = collectUnusedVariables(sourceCode.getScope(programNode), []);
 
                 for (let i = 0, l = unusedVars.length; i < l; ++i) {
                     const unusedVar = unusedVars[i];

package/lib/rules/no-use-before-define.js

@@ -258,6 +258,7 @@ module.exports = {
 
     create(context) {
         const options = parseOptions(context.options[0]);
+        const sourceCode = context.getSourceCode();
 
         /**
          * Determines whether a given reference should be checked.
@@ -339,8 +340,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                checkReferencesInScope(context.getScope());
+            Program(node) {
+                checkReferencesInScope(sourceCode.getScope(node));
             }
         };
     }

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

@@ -9,8 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("regexpp");
+const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -82,6 +82,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Checks and reports useless backreferences in the given regular expression.
          * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
@@ -167,8 +169,8 @@ module.exports = {
 
                 checkRegex(node, pattern, flags);
             },
-            Program() {
-                const scope = context.getScope(),
+            Program(node) {
+                const scope = sourceCode.getScope(node),
                     tracker = new ReferenceTracker(scope),
                     traceMap = {
                         RegExp: {
@@ -177,13 +179,13 @@ module.exports = {
                         }
                     };
 
-                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
-                    const [patternNode, flagsNode] = node.arguments,
+                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
+                    const [patternNode, flagsNode] = refNode.arguments,
                         pattern = getStringIfConstant(patternNode, scope),
                         flags = getStringIfConstant(flagsNode, scope);
 
                     if (typeof pattern === "string") {
-                        checkRegex(node, pattern, flags || "");
+                        checkRegex(refNode, pattern, flags || "");
                     }
                 }
             }

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/lib/rules/object-shorthand.js

@@ -354,11 +354,12 @@ module.exports = {
         /**
          * Enters a function. This creates a new lexical identifier scope, so a new Set of arrow functions is pushed onto the stack.
          * Also, this marks all `arguments` identifiers so that they can be detected later.
+         * @param {ASTNode} node The node representing the function.
          * @returns {void}
          */
-        function enterFunction() {
+        function enterFunction(node) {
             lexicalScopeStack.unshift(new Set());
-            context.getScope().variables.filter(variable => variable.name === "arguments").forEach(variable => {
+            sourceCode.getScope(node).variables.filter(variable => variable.name === "arguments").forEach(variable => {
                 variable.references.map(ref => ref.identifier).forEach(identifier => argumentsIdentifiers.add(identifier));
             });
         }

package/lib/rules/prefer-arrow-callback.js

@@ -270,7 +270,7 @@ module.exports = {
                 }
 
                 // Skip if it's using arguments.
-                const variable = getVariableOfArguments(context.getScope());
+                const variable = getVariableOfArguments(sourceCode.getScope(node));
 
                 if (variable && variable.references.length > 0) {
                     return;

package/lib/rules/prefer-exponentiation-operator.js

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { CALL, ReferenceTracker } = require("eslint-utils");
+const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -172,8 +172,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const trackMap = {
                     Math: {
@@ -181,8 +181,8 @@ module.exports = {
                     }
                 };
 
-                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
-                    report(node);
+                for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
+                    report(refNode);
                 }
             }
         };

package/lib/rules/prefer-named-capture-group.js

@@ -14,8 +14,8 @@ const {
     CONSTRUCT,
     ReferenceTracker,
     getStringIfConstant
-} = require("eslint-utils");
-const regexpp = require("regexpp");
+} = require("@eslint-community/eslint-utils");
+const regexpp = require("@eslint-community/regexpp");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -151,8 +151,8 @@ module.exports = {
                     checkRegex(node.regex.pattern, node, node, node.regex.flags.includes("u"));
                 }
             },
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
                 const tracker = new ReferenceTracker(scope);
                 const traceMap = {
                     RegExp: {
@@ -161,12 +161,12 @@ module.exports = {
                     }
                 };
 
-                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
-                    const regex = getStringIfConstant(node.arguments[0]);
-                    const flags = getStringIfConstant(node.arguments[1]);
+                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
+                    const regex = getStringIfConstant(refNode.arguments[0]);
+                    const flags = getStringIfConstant(refNode.arguments[1]);
 
                     if (regex) {
-                        checkRegex(regex, node, node.arguments[0], flags && flags.includes("u"));
+                        checkRegex(regex, refNode, refNode.arguments[0], flags && flags.includes("u"));
                     }
                 }
             }