eslint 8.34.0 → 8.39.0

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

@@ -31,6 +31,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports a reference if is non initializer and writable.
          * @param {References} references Collection of reference to check.
@@ -65,7 +67,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForFunction(node) {
-            context.getDeclaredVariables(node).forEach(checkVariable);
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
         }
 
         return {

package/lib/rules/no-global-assign.js

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

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

@@ -43,6 +43,7 @@ module.exports = {
     create(context) {
 
         const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports the node.
@@ -62,8 +63,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
 
                 scope.variables.forEach(variable => {
 

package/lib/rules/no-implied-eval.js

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { getStaticValue } = require("eslint-utils");
+const { getStaticValue } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -37,6 +37,7 @@ module.exports = {
     create(context) {
         const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
         const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether a node is evaluated as a string or not.
@@ -66,7 +67,7 @@ module.exports = {
 
             if (firstArgument) {
 
-                const staticValue = getStaticValue(firstArgument, context.getScope());
+                const staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
                 const isStaticString = staticValue && typeof staticValue.value === "string";
                 const isString = isStaticString || isEvaluatedString(firstArgument);
 
@@ -117,8 +118,8 @@ module.exports = {
                     reportImpliedEvalCallExpression(node);
                 }
             },
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 GLOBAL_CANDIDATES
                     .map(candidate => astUtils.getVariableByName(globalScope, candidate))

package/lib/rules/no-import-assign.js

@@ -9,7 +9,7 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("eslint-utils");
+const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 const WellKnownMutationFunctions = {
@@ -194,11 +194,13 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             ImportDeclaration(node) {
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
-                for (const variable of context.getDeclaredVariables(node)) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
                     const shouldCheckMembers = variable.defs.some(
                         d => d.node.type === "ImportNamespaceSpecifier"
                     );

package/lib/rules/no-invalid-regexp.js

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const RegExpValidator = require("regexpp").RegExpValidator;
+const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const validator = new RegExpValidator();
 const validFlags = /[dgimsuy]/gu;
 const undefined1 = void 0;

package/lib/rules/no-invalid-this.js

@@ -95,7 +95,7 @@ module.exports = {
                 }
 
                 if (codePath.origin === "program") {
-                    const scope = context.getScope();
+                    const scope = sourceCode.getScope(node);
                     const features = context.parserOptions.ecmaFeatures || {};
 
                     // `this` at the top level of scripts always refers to the global object
@@ -120,7 +120,7 @@ module.exports = {
                  * always valid, so we can set `init: true` right away.
                  */
                 stack.push({
-                    init: !context.getScope().isStrict,
+                    init: !sourceCode.getScope(node).isStrict,
                     node,
                     valid: true
                 });

package/lib/rules/no-label-var.js

@@ -34,6 +34,7 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -59,7 +60,7 @@ module.exports = {
             LabeledStatement(node) {
 
                 // Fetch the innermost scope.
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
                 /*
                  * Recursively find the identifier walking up the scope, starting

package/lib/rules/no-lone-blocks.js

@@ -33,6 +33,7 @@ module.exports = {
         // A stack of lone blocks to be checked for block-level bindings
         const loneBlocks = [];
         let ruleDef;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports a node as invalid.
@@ -67,14 +68,15 @@ module.exports = {
         /**
          * Checks the enclosing block of the current node for block-level bindings,
          * and "marks it" as valid if any.
+         * @param {ASTNode} node The current node to check.
          * @returns {void}
          */
-        function markLoneBlock() {
+        function markLoneBlock(node) {
             if (loneBlocks.length === 0) {
                 return;
             }
 
-            const block = context.getAncestors().pop();
+            const block = node.parent;
 
             if (loneBlocks[loneBlocks.length - 1] === block) {
                 loneBlocks.pop();
@@ -116,13 +118,13 @@ module.exports = {
 
             ruleDef.VariableDeclaration = function(node) {
                 if (node.kind === "let" || node.kind === "const") {
-                    markLoneBlock();
+                    markLoneBlock(node);
                 }
             };
 
-            ruleDef.FunctionDeclaration = function() {
-                if (context.getScope().isStrict) {
-                    markLoneBlock();
+            ruleDef.FunctionDeclaration = function(node) {
+                if (sourceCode.getScope(node).isStrict) {
+                    markLoneBlock(node);
                 }
             };
 

package/lib/rules/no-lonely-if.js

@@ -32,9 +32,8 @@ module.exports = {
 
         return {
             IfStatement(node) {
-                const ancestors = context.getAncestors(),
-                    parent = ancestors.pop(),
-                    grandparent = ancestors.pop();
+                const parent = node.parent,
+                    grandparent = parent.parent;
 
                 if (parent && parent.type === "BlockStatement" &&
                         parent.body.length === 1 && grandparent &&

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

@@ -168,6 +168,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports functions which match the following condition:
          *
@@ -183,7 +185,7 @@ module.exports = {
                 return;
             }
 
-            const references = context.getScope().through;
+            const references = sourceCode.getScope(node).through;
             const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name);
 
             if (unsafeRefs.length > 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-param-reassign.js

@@ -70,6 +70,7 @@ module.exports = {
         const props = context.options[0] && context.options[0].props;
         const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];
         const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether or not the reference modifies properties of its variable.
@@ -214,7 +215,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForFunction(node) {
-            context.getDeclaredVariables(node).forEach(checkVariable);
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
         }
 
         return {

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-exports.js

@@ -99,6 +99,7 @@ module.exports = {
 
         const restrictedNames = new Set(context.options[0] && context.options[0].restrictedNamedExports);
         const restrictDefaultExports = context.options[0] && context.options[0].restrictDefaultExports;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks and reports given exported name.
@@ -176,7 +177,7 @@ module.exports = {
                     if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
                         checkExportedName(declaration.id);
                     } else if (declaration.type === "VariableDeclaration") {
-                        context.getDeclaredVariables(declaration)
+                        sourceCode.getDeclaredVariables(declaration)
                             .map(v => v.defs.find(d => d.parent === declaration))
                             .map(d => d.name) // Identifier nodes
                             .forEach(checkExportedName);

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 => {