eslint 6.5.1 → 6.7.2

package/lib/rules/operator-assignment.js

@@ -71,6 +71,9 @@ function same(a, b) {
              */
             return same(a.object, b.object) && same(a.property, b.property);
 
+        case "ThisExpression":
+            return true;
+
         default:
             return false;
     }
@@ -83,8 +86,14 @@ function same(a, b) {
  * @returns {boolean} `true` if the node can be fixed
  */
 function canBeFixed(node) {
-    return node.type === "Identifier" ||
-        node.type === "MemberExpression" && node.object.type === "Identifier" && (!node.computed || node.property.type === "Literal");
+    return (
+        node.type === "Identifier" ||
+        (
+            node.type === "MemberExpression" &&
+            (node.object.type === "Identifier" || node.object.type === "ThisExpression") &&
+            (!node.computed || node.property.type === "Literal")
+        )
+    );
 }
 
 module.exports = {
@@ -150,6 +159,11 @@ module.exports = {
                                 const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);
                                 const rightText = sourceCode.getText().slice(operatorToken.range[1], node.right.range[1]);
 
+                                // Check for comments that would be removed.
+                                if (sourceCode.commentsExistBetween(equalsToken, operatorToken)) {
+                                    return null;
+                                }
+
                                 return fixer.replaceText(node, `${leftText}${expr.operator}=${rightText}`);
                             }
                             return null;
@@ -182,11 +196,17 @@ module.exports = {
                     messageId: "unexpected",
                     fix(fixer) {
                         if (canBeFixed(node.left)) {
+                            const firstToken = sourceCode.getFirstToken(node);
                             const operatorToken = getOperatorToken(node);
                             const leftText = sourceCode.getText().slice(node.range[0], operatorToken.range[0]);
                             const newOperator = node.operator.slice(0, -1);
                             let rightText;
 
+                            // Check for comments that would be duplicated.
+                            if (sourceCode.commentsExistBetween(firstToken, operatorToken)) {
+                                return null;
+                            }
+
                             // If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.
                             if (
                                 astUtils.getPrecedence(node.right) <= astUtils.getPrecedence({ type: "BinaryExpression", operator: newOperator }) &&
@@ -194,7 +214,17 @@ module.exports = {
                             ) {
                                 rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
                             } else {
-                                rightText = sourceCode.text.slice(operatorToken.range[1], node.range[1]);
+                                const firstRightToken = sourceCode.getFirstToken(node.right);
+                                let rightTextPrefix = "";
+
+                                if (
+                                    operatorToken.range[1] === firstRightToken.range[0] &&
+                                    !astUtils.canTokensBeAdjacent(newOperator, firstRightToken)
+                                ) {
+                                    rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
+                                }
+
+                                rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
                             }
 
                             return fixer.replaceText(node, `${leftText}= ${leftText}${newOperator}${rightText}`);

package/lib/rules/padded-blocks.js

@@ -97,7 +97,7 @@ module.exports = {
 
         /**
          * Gets the open brace token from a given node.
-         * @param {ASTNode} node - A BlockStatement or SwitchStatement node from which to get the open brace.
+         * @param {ASTNode} node A BlockStatement or SwitchStatement node from which to get the open brace.
          * @returns {Token} The token of the open brace.
          */
         function getOpenBrace(node) {

package/lib/rules/padding-line-between-statements.js

@@ -25,7 +25,6 @@ const CJS_IMPORT = /^require\(/u;
 
 /**
  * Creates tester which check if a node starts with specific keyword.
- *
  * @param {string} keyword The keyword to test.
  * @returns {Object} the created tester.
  * @private
@@ -39,7 +38,6 @@ function newKeywordTester(keyword) {
 
 /**
  * Creates tester which check if a node starts with specific keyword and spans a single line.
- *
  * @param {string} keyword The keyword to test.
  * @returns {Object} the created tester.
  * @private
@@ -54,7 +52,6 @@ function newSinglelineKeywordTester(keyword) {
 
 /**
  * Creates tester which check if a node starts with specific keyword and spans multiple lines.
- *
  * @param {string} keyword The keyword to test.
  * @returns {Object} the created tester.
  * @private
@@ -69,7 +66,6 @@ function newMultilineKeywordTester(keyword) {
 
 /**
  * Creates tester which check if a node is specific type.
- *
  * @param {string} type The node type to test.
  * @returns {Object} the created tester.
  * @private
@@ -83,7 +79,6 @@ function newNodeTypeTester(type) {
 
 /**
  * Checks the given node is an expression statement of IIFE.
- *
  * @param {ASTNode} node The node to check.
  * @returns {boolean} `true` if the node is an expression statement of IIFE.
  * @private
@@ -103,7 +98,6 @@ function isIIFEStatement(node) {
 /**
  * Checks whether the given node is a block-like statement.
  * This checks the last token of the node is the closing brace of a block.
- *
  * @param {SourceCode} sourceCode The source code to get tokens.
  * @param {ASTNode} node The node to check.
  * @returns {boolean} `true` if the node is a block-like statement.
@@ -187,7 +181,6 @@ function isDirectivePrologue(node, sourceCode) {
  *
  *     foo()
  *     ;[1, 2, 3].forEach(bar)
- *
  * @param {SourceCode} sourceCode The source code to get tokens.
  * @param {ASTNode} node The node to get.
  * @returns {Token} The actual last token.
@@ -224,7 +217,6 @@ function replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) {
 /**
  * Check and report statements for `any` configuration.
  * It does nothing.
- *
  * @returns {void}
  * @private
  */
@@ -236,7 +228,6 @@ function verifyForAny() {
  * This autofix removes blank lines between the given 2 statements.
  * However, if comments exist between 2 blank lines, it does not remove those
  * blank lines automatically.
- *
  * @param {RuleContext} context The rule context to report.
  * @param {ASTNode} _ Unused. The previous node to check.
  * @param {ASTNode} nextNode The next node to check.
@@ -276,7 +267,6 @@ function verifyForNever(context, _, nextNode, paddingLines) {
  * This autofix inserts a blank line between the given 2 statements.
  * If the `prevNode` has trailing comments, it inserts a blank line after the
  * trailing comments.
- *
  * @param {RuleContext} context The rule context to report.
  * @param {ASTNode} prevNode The previous node to check.
  * @param {ASTNode} nextNode The next node to check.
@@ -318,7 +308,6 @@ function verifyForAlways(context, prevNode, nextNode, paddingLines) {
                      *
                      *     // comment.
                      *     bar();
-                     *
                      * @param {Token} token The token to check.
                      * @returns {boolean} `true` if the token is not a trailing comment.
                      * @private
@@ -511,7 +500,6 @@ module.exports = {
 
         /**
          * Checks whether the given node matches the given type.
-         *
          * @param {ASTNode} node The statement node to check.
          * @param {string|string[]} type The statement type to check.
          * @returns {boolean} `true` if the statement node matched the type.
@@ -531,7 +519,6 @@ module.exports = {
 
         /**
          * Finds the last matched configure from configureList.
-         *
          * @param {ASTNode} prevNode The previous statement to match.
          * @param {ASTNode} nextNode The current statement to match.
          * @returns {Object} The tester of the last matched configure.
@@ -554,7 +541,6 @@ module.exports = {
         /**
          * Gets padding line sequences between the given 2 statements.
          * Comments are separators of the padding line sequences.
-         *
          * @param {ASTNode} prevNode The previous statement to count.
          * @param {ASTNode} nextNode The current statement to count.
          * @returns {Array<Token[]>} The array of token pairs.
@@ -584,7 +570,6 @@ module.exports = {
 
         /**
          * Verify padding lines between the given node and the previous node.
-         *
          * @param {ASTNode} node The node to verify.
          * @returns {void}
          * @private
@@ -616,7 +601,6 @@ module.exports = {
         /**
          * Verify padding lines between the given node and the previous node.
          * Then process to enter to new scope.
-         *
          * @param {ASTNode} node The node to verify.
          * @returns {void}
          * @private

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

@@ -11,7 +11,7 @@
 
 /**
  * Checks whether or not a given variable is a function name.
- * @param {eslint-scope.Variable} variable - A variable to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
  * @returns {boolean} `true` if the variable is a function name.
  */
 function isFunctionName(variable) {
@@ -20,9 +20,9 @@ function isFunctionName(variable) {
 
 /**
  * Checks whether or not a given MetaProperty node equals to a given value.
- * @param {ASTNode} node - A MetaProperty node to check.
- * @param {string} metaName - The name of `MetaProperty.meta`.
- * @param {string} propertyName - The name of `MetaProperty.property`.
+ * @param {ASTNode} node A MetaProperty node to check.
+ * @param {string} metaName The name of `MetaProperty.meta`.
+ * @param {string} propertyName The name of `MetaProperty.property`.
  * @returns {boolean} `true` if the node is the specific value.
  */
 function checkMetaProperty(node, metaName, propertyName) {
@@ -31,7 +31,7 @@ function checkMetaProperty(node, metaName, propertyName) {
 
 /**
  * Gets the variable object of `arguments` which is defined implicitly.
- * @param {eslint-scope.Scope} scope - A scope to get.
+ * @param {eslint-scope.Scope} scope A scope to get.
  * @returns {eslint-scope.Variable} The found variable object.
  */
 function getVariableOfArguments(scope) {
@@ -57,7 +57,7 @@ function getVariableOfArguments(scope) {
 
 /**
  * Checkes whether or not a given node is a callback.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {Object}
  *   {boolean} retv.isCallback - `true` if the node is a callback.
  *   {boolean} retv.isLexicalThis - `true` if the node is with `.bind(this)`.

package/lib/rules/prefer-const.js

@@ -17,8 +17,7 @@ const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u
 
 /**
  * Checks whether a given node is located at `ForStatement.init` or not.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is located at `ForStatement.init`.
  */
 function isInitOfForStatement(node) {
@@ -27,8 +26,7 @@ function isInitOfForStatement(node) {
 
 /**
  * Checks whether a given Identifier node becomes a VariableDeclaration or not.
- *
- * @param {ASTNode} identifier - An Identifier node to check.
+ * @param {ASTNode} identifier An Identifier node to check.
  * @returns {boolean} `true` if the node can become a VariableDeclaration.
  */
 function canBecomeVariableDeclaration(identifier) {
@@ -51,9 +49,8 @@ function canBecomeVariableDeclaration(identifier) {
 /**
  * Checks if an property or element is from outer scope or function parameters
  * in destructing pattern.
- *
- * @param {string} name - A variable name to be checked.
- * @param {eslint-scope.Scope} initScope - A scope to start find.
+ * @param {string} name A variable name to be checked.
+ * @param {eslint-scope.Scope} initScope A scope to start find.
  * @returns {boolean} Indicates if the variable is from outer scope or function parameters.
  */
 function isOuterVariableInDestructing(name, initScope) {
@@ -76,8 +73,7 @@ function isOuterVariableInDestructing(name, initScope) {
  * belongs to.
  * This is used to detect a mix of reassigned and never reassigned in a
  * destructuring.
- *
- * @param {eslint-scope.Reference} reference - A reference to get.
+ * @param {eslint-scope.Reference} reference A reference to get.
  * @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or
  *      null.
  */
@@ -162,9 +158,8 @@ function hasMemberExpressionAssignment(node) {
  *   `/*exported foo` directive comment makes such variables. This rule does not
  *   warn such variables because this rule cannot distinguish whether the
  *   exported variables are reassigned or not.
- *
- * @param {eslint-scope.Variable} variable - A variable to get.
- * @param {boolean} ignoreReadBeforeAssign -
+ * @param {eslint-scope.Variable} variable A variable to get.
+ * @param {boolean} ignoreReadBeforeAssign
  *      The value of `ignoreReadBeforeAssign` option.
  * @returns {ASTNode|null}
  *      An Identifier node if the variable should change to const.
@@ -262,9 +257,8 @@ function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
  * reference of given variables belongs to.
  * This is used to detect a mix of reassigned and never reassigned in a
  * destructuring.
- *
- * @param {eslint-scope.Variable[]} variables - Variables to group by destructuring.
- * @param {boolean} ignoreReadBeforeAssign -
+ * @param {eslint-scope.Variable[]} variables Variables to group by destructuring.
+ * @param {boolean} ignoreReadBeforeAssign
  *      The value of `ignoreReadBeforeAssign` option.
  * @returns {Map<ASTNode, ASTNode[]>} Grouped identifier nodes.
  */
@@ -308,10 +302,9 @@ function groupByDestructuring(variables, ignoreReadBeforeAssign) {
 
 /**
  * Finds the nearest parent of node with a given type.
- *
- * @param {ASTNode} node – The node to search from.
- * @param {string} type – The type field of the parent node.
- * @param {Function} shouldStop – a predicate that returns true if the traversal should stop, and false otherwise.
+ * @param {ASTNode} node The node to search from.
+ * @param {string} type The type field of the parent node.
+ * @param {Function} shouldStop A predicate that returns true if the traversal should stop, and false otherwise.
  * @returns {ASTNode} The closest ancestor with the specified type; null if no such ancestor exists.
  */
 function findUp(node, type, shouldStop) {
@@ -363,7 +356,9 @@ module.exports = {
         const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;
         const variables = [];
         let reportCount = 0;
-        let name = "";
+        let checkedId = null;
+        let checkedName = "";
+
 
         /**
          * Reports given identifier nodes if all of the nodes should be declared
@@ -374,8 +369,7 @@ module.exports = {
          * nullable. In simple declaration or assignment cases, the length of
          * the array is 1. In destructuring cases, the length of the array can
          * be 2 or more.
-         *
-         * @param {(eslint-scope.Reference|null)[]} nodes -
+         * @param {(eslint-scope.Reference|null)[]} nodes
          *      References which are grouped by destructuring to report.
          * @returns {void}
          */
@@ -395,25 +389,30 @@ module.exports = {
                         /*
                          * First we check the declaration type and then depending on
                          * if the type is a "VariableDeclarator" or its an "ObjectPattern"
-                         * we compare the name from the first identifier, if the names are different
-                         * we assign the new name and reset the count of reportCount and nodeCount in
+                         * we compare the name and id from the first identifier, if the names are different
+                         * we assign the new name, id and reset the count of reportCount and nodeCount in
                          * order to check each block for the number of reported errors and base our fix
                          * based on comparing nodes.length and nodesToReport.length.
                          */
 
                         if (firstDecParent.type === "VariableDeclarator") {
 
-                            if (firstDecParent.id.name !== name) {
-                                name = firstDecParent.id.name;
+                            if (firstDecParent.id.name !== checkedName) {
+                                checkedName = firstDecParent.id.name;
                                 reportCount = 0;
                             }
 
                             if (firstDecParent.id.type === "ObjectPattern") {
-                                if (firstDecParent.init.name !== name) {
-                                    name = firstDecParent.init.name;
+                                if (firstDecParent.init.name !== checkedName) {
+                                    checkedName = firstDecParent.init.name;
                                     reportCount = 0;
                                 }
                             }
+
+                            if (firstDecParent.id !== checkedId) {
+                                checkedId = firstDecParent.id;
+                                reportCount = 0;
+                            }
                         }
                     }
                 }

package/lib/rules/prefer-destructuring.js

@@ -103,6 +103,7 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
          * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
          * @param {string} destructuringType "array" or "object"
@@ -119,7 +120,6 @@ module.exports = {
          *
          * This is used to differentiate array index access from object property
          * access.
-         *
          * @param {ASTNode} node the node to evaluate
          * @returns {boolean} whether or not the node is an integer
          */
@@ -129,7 +129,6 @@ module.exports = {
 
         /**
          * Report that the given node should use destructuring
-         *
          * @param {ASTNode} reportNode the node to report
          * @param {string} type the type of destructuring that should have been done
          * @param {Function|null} fix the fix function or null to pass to context.report
@@ -153,7 +152,6 @@ module.exports = {
          * Assignment expression is not fixed.
          * Array destructuring is not fixed.
          * Renamed property is not fixed.
-         *
          * @param {ASTNode} node the the node to evaluate
          * @returns {boolean} whether or not the node should be fixed
          */
@@ -168,7 +166,6 @@ module.exports = {
          * Fix a node into object destructuring.
          * This function only handles the simplest case of object destructuring,
          * see {@link shouldFix}.
-         *
          * @param {SourceCodeFixer} fixer the fixer object
          * @param {ASTNode} node the node to be fixed.
          * @returns {Object} a fix for the node
@@ -189,7 +186,6 @@ module.exports = {
          *
          * Pulled out into a separate method so that VariableDeclarators and
          * AssignmentExpressions can share the same verification logic.
-         *
          * @param {ASTNode} leftNode the left-hand side of the assignment
          * @param {ASTNode} rightNode the right-hand side of the assignment
          * @param {ASTNode} reportNode the node to report the error on
@@ -231,7 +227,6 @@ module.exports = {
         /**
          * Check if a given variable declarator is coming from an property access
          * that should be using destructuring instead
-         *
          * @param {ASTNode} node the variable declarator to check
          * @returns {void}
          */
@@ -252,7 +247,6 @@ module.exports = {
 
         /**
          * Run the `prefer-destructuring` check on an AssignmentExpression
-         *
          * @param {ASTNode} node the AssignmentExpression node
          * @returns {void}
          */

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

@@ -0,0 +1,189 @@
+/**
+ * @fileoverview Rule to disallow Math.pow in favor of the ** operator
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { CALL, ReferenceTracker } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({ type: "BinaryExpression", operator: "**" });
+
+/**
+ * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
+ * @param {ASTNode} base The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesBaseNeedParens(base) {
+    return (
+
+        // '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c
+        astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR ||
+
+        // An unary operator cannot be used immediately before an exponentiation expression
+        base.type === "UnaryExpression"
+    );
+}
+
+/**
+ * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.
+ * @param {ASTNode} exponent The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesExponentNeedParens(exponent) {
+
+    // '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c
+    return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;
+}
+
+/**
+ * Determines whether an exponentiation binary expression at the place of the given node would need parens.
+ * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.
+ * @param {SourceCode} sourceCode A SourceCode object.
+ * @returns {boolean} `true` if the expression needs to be parenthesised.
+ */
+function doesExponentiationExpressionNeedParens(node, sourceCode) {
+    const parent = node.parent;
+
+    const needsParens = (
+        parent.type === "ClassDeclaration" ||
+        (
+            parent.type.endsWith("Expression") &&
+            astUtils.getPrecedence(parent) >= PRECEDENCE_OF_EXPONENTIATION_EXPR &&
+            !(parent.type === "BinaryExpression" && parent.operator === "**" && parent.right === node) &&
+            !((parent.type === "CallExpression" || parent.type === "NewExpression") && parent.arguments.includes(node)) &&
+            !(parent.type === "MemberExpression" && parent.computed && parent.property === node) &&
+            !(parent.type === "ArrayExpression")
+        )
+    );
+
+    return needsParens && !astUtils.isParenthesised(sourceCode, node);
+}
+
+/**
+ * Optionally parenthesizes given text.
+ * @param {string} text The text to parenthesize.
+ * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.
+ * @returns {string} parenthesised or unchanged text.
+ */
+function parenthesizeIfShould(text, shouldParenthesize) {
+    return shouldParenthesize ? `(${text})` : text;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow the use of `Math.pow` in favor of the `**` operator",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-exponentiation-operator"
+        },
+
+        schema: [],
+        fixable: "code",
+
+        messages: {
+            useExponentiation: "Use the '**' operator instead of 'Math.pow'."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Reports the given node.
+         * @param {ASTNode} node 'Math.pow()' node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({
+                node,
+                messageId: "useExponentiation",
+                fix(fixer) {
+                    if (
+                        node.arguments.length !== 2 ||
+                        node.arguments.some(arg => arg.type === "SpreadElement") ||
+                        sourceCode.getCommentsInside(node).length > 0
+                    ) {
+                        return null;
+                    }
+
+                    const base = node.arguments[0],
+                        exponent = node.arguments[1],
+                        baseText = sourceCode.getText(base),
+                        exponentText = sourceCode.getText(exponent),
+                        shouldParenthesizeBase = doesBaseNeedParens(base),
+                        shouldParenthesizeExponent = doesExponentNeedParens(exponent),
+                        shouldParenthesizeAll = doesExponentiationExpressionNeedParens(node, sourceCode);
+
+                    let prefix = "",
+                        suffix = "";
+
+                    if (!shouldParenthesizeAll) {
+                        if (!shouldParenthesizeBase) {
+                            const firstReplacementToken = sourceCode.getFirstToken(base),
+                                tokenBefore = sourceCode.getTokenBefore(node);
+
+                            if (
+                                tokenBefore &&
+                                tokenBefore.range[1] === node.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)
+                            ) {
+                                prefix = " "; // a+Math.pow(++b, c) -> a+ ++b**c
+                            }
+                        }
+                        if (!shouldParenthesizeExponent) {
+                            const lastReplacementToken = sourceCode.getLastToken(exponent),
+                                tokenAfter = sourceCode.getTokenAfter(node);
+
+                            if (
+                                tokenAfter &&
+                                node.range[1] === tokenAfter.range[0] &&
+                                !astUtils.canTokensBeAdjacent(lastReplacementToken, tokenAfter)
+                            ) {
+                                suffix = " "; // Math.pow(a, b)in c -> a**b in c
+                            }
+                        }
+                    }
+
+                    const baseReplacement = parenthesizeIfShould(baseText, shouldParenthesizeBase),
+                        exponentReplacement = parenthesizeIfShould(exponentText, shouldParenthesizeExponent),
+                        replacement = parenthesizeIfShould(`${baseReplacement}**${exponentReplacement}`, shouldParenthesizeAll);
+
+                    return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
+                }
+            });
+        }
+
+        return {
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const trackMap = {
+                    Math: {
+                        pow: { [CALL]: true }
+                    }
+                };
+
+                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
+                    report(node);
+                }
+            }
+        };
+    }
+};

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

@@ -49,7 +49,6 @@ module.exports = {
 
         /**
          * Function to check regular expression.
-         *
          * @param {string} pattern The regular expression pattern to be check.
          * @param {ASTNode} node AST node which contains regular expression.
          * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.