claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-extra-parens.js

@@ -0,0 +1,1322 @@
+/**
+ * @fileoverview Disallow parenthesising higher precedence subexpressions.
+ * @author Michael Ficarra
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const { isParenthesized: isParenthesizedRaw } = require("@eslint-community/eslint-utils");
+const astUtils = require("./utils/ast-utils.js");
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: [],
+        type: "layout",
+
+        docs: {
+            description: "Disallow unnecessary parentheses",
+            recommended: false,
+            url: "https://eslint.org/docs/latest/rules/no-extra-parens"
+        },
+
+        fixable: "code",
+
+        schema: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["functions"]
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 1
+                },
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["all"]
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                conditionalAssign: { type: "boolean" },
+                                ternaryOperandBinaryExpressions: { type: "boolean" },
+                                nestedBinaryExpressions: { type: "boolean" },
+                                returnAssign: { type: "boolean" },
+                                ignoreJSX: { enum: ["none", "all", "single-line", "multi-line"] },
+                                enforceForArrowConditionals: { type: "boolean" },
+                                enforceForSequenceExpressions: { type: "boolean" },
+                                enforceForNewInMemberExpressions: { type: "boolean" },
+                                enforceForFunctionPrototypeMethods: { type: "boolean" },
+                                allowParensAfterCommentPattern: { type: "string" }
+                            },
+                            additionalProperties: false
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 2
+                }
+            ]
+        },
+
+        messages: {
+            unexpected: "Unnecessary parentheses around expression."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        const tokensToIgnore = new WeakSet();
+        const precedence = astUtils.getPrecedence;
+        const ALL_NODES = context.options[0] !== "functions";
+        const EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === false;
+        const EXCEPT_COND_TERNARY = ALL_NODES && context.options[1] && context.options[1].ternaryOperandBinaryExpressions === false;
+        const NESTED_BINARY = ALL_NODES && context.options[1] && context.options[1].nestedBinaryExpressions === false;
+        const EXCEPT_RETURN_ASSIGN = ALL_NODES && context.options[1] && context.options[1].returnAssign === false;
+        const IGNORE_JSX = ALL_NODES && context.options[1] && context.options[1].ignoreJSX;
+        const IGNORE_ARROW_CONDITIONALS = ALL_NODES && context.options[1] &&
+            context.options[1].enforceForArrowConditionals === false;
+        const IGNORE_SEQUENCE_EXPRESSIONS = ALL_NODES && context.options[1] &&
+            context.options[1].enforceForSequenceExpressions === false;
+        const IGNORE_NEW_IN_MEMBER_EXPR = ALL_NODES && context.options[1] &&
+            context.options[1].enforceForNewInMemberExpressions === false;
+        const IGNORE_FUNCTION_PROTOTYPE_METHODS = ALL_NODES && context.options[1] &&
+            context.options[1].enforceForFunctionPrototypeMethods === false;
+        const ALLOW_PARENS_AFTER_COMMENT_PATTERN = ALL_NODES && context.options[1] && context.options[1].allowParensAfterCommentPattern;
+
+        const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
+        const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" });
+
+        let reportsBuffer;
+
+        /**
+         * Determines whether the given node is a `call` or `apply` method call, invoked directly on a `FunctionExpression` node.
+         * Example: function(){}.call()
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is an immediate `call` or `apply` method call.
+         * @private
+         */
+        function isImmediateFunctionPrototypeMethodCall(node) {
+            const callNode = astUtils.skipChainExpression(node);
+
+            if (callNode.type !== "CallExpression") {
+                return false;
+            }
+            const callee = astUtils.skipChainExpression(callNode.callee);
+
+            return (
+                callee.type === "MemberExpression" &&
+                callee.object.type === "FunctionExpression" &&
+                ["call", "apply"].includes(astUtils.getStaticPropertyName(callee))
+            );
+        }
+
+        /**
+         * Determines if this rule should be enforced for a node given the current configuration.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the rule should be enforced for this node.
+         * @private
+         */
+        function ruleApplies(node) {
+            if (node.type === "JSXElement" || node.type === "JSXFragment") {
+                const isSingleLine = node.loc.start.line === node.loc.end.line;
+
+                switch (IGNORE_JSX) {
+
+                    // Exclude this JSX element from linting
+                    case "all":
+                        return false;
+
+                    // Exclude this JSX element if it is multi-line element
+                    case "multi-line":
+                        return isSingleLine;
+
+                    // Exclude this JSX element if it is single-line element
+                    case "single-line":
+                        return !isSingleLine;
+
+                    // Nothing special to be done for JSX elements
+                    case "none":
+                        break;
+
+                    // no default
+                }
+            }
+
+            if (node.type === "SequenceExpression" && IGNORE_SEQUENCE_EXPRESSIONS) {
+                return false;
+            }
+
+            if (isImmediateFunctionPrototypeMethodCall(node) && IGNORE_FUNCTION_PROTOTYPE_METHODS) {
+                return false;
+            }
+
+            return ALL_NODES || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+        }
+
+        /**
+         * Determines if a node is surrounded by parentheses.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is parenthesised.
+         * @private
+         */
+        function isParenthesised(node) {
+            return isParenthesizedRaw(1, node, sourceCode);
+        }
+
+        /**
+         * Determines if a node is surrounded by parentheses twice.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is doubly parenthesised.
+         * @private
+         */
+        function isParenthesisedTwice(node) {
+            return isParenthesizedRaw(2, node, sourceCode);
+        }
+
+        /**
+         * Determines if a node is surrounded by (potentially) invalid parentheses.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is incorrectly parenthesised.
+         * @private
+         */
+        function hasExcessParens(node) {
+            return ruleApplies(node) && isParenthesised(node);
+        }
+
+        /**
+         * Determines if a node that is expected to be parenthesised is surrounded by
+         * (potentially) invalid extra parentheses.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is has an unexpected extra pair of parentheses.
+         * @private
+         */
+        function hasDoubleExcessParens(node) {
+            return ruleApplies(node) && isParenthesisedTwice(node);
+        }
+
+        /**
+         * Determines if a node that is expected to be parenthesised is surrounded by
+         * (potentially) invalid extra parentheses with considering precedence level of the node.
+         * If the preference level of the node is not higher or equal to precedence lower limit, it also checks
+         * whether the node is surrounded by parentheses twice or not.
+         * @param {ASTNode} node The node to be checked.
+         * @param {number} precedenceLowerLimit The lower limit of precedence.
+         * @returns {boolean} True if the node is has an unexpected extra pair of parentheses.
+         * @private
+         */
+        function hasExcessParensWithPrecedence(node, precedenceLowerLimit) {
+            if (ruleApplies(node) && isParenthesised(node)) {
+                if (
+                    precedence(node) >= precedenceLowerLimit ||
+                    isParenthesisedTwice(node)
+                ) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /**
+         * Determines if a node test expression is allowed to have a parenthesised assignment
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the assignment can be parenthesised.
+         * @private
+         */
+        function isCondAssignException(node) {
+            return EXCEPT_COND_ASSIGN && node.test.type === "AssignmentExpression";
+        }
+
+        /**
+         * Determines if a node is in a return statement
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is in a return statement.
+         * @private
+         */
+        function isInReturnStatement(node) {
+            for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
+                if (
+                    currentNode.type === "ReturnStatement" ||
+                    (currentNode.type === "ArrowFunctionExpression" && currentNode.body.type !== "BlockStatement")
+                ) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /**
+         * Determines if a constructor function is newed-up with parens
+         * @param {ASTNode} newExpression The NewExpression node to be checked.
+         * @returns {boolean} True if the constructor is called with parens.
+         * @private
+         */
+        function isNewExpressionWithParens(newExpression) {
+            const lastToken = sourceCode.getLastToken(newExpression);
+            const penultimateToken = sourceCode.getTokenBefore(lastToken);
+
+            return newExpression.arguments.length > 0 ||
+                (
+
+                    // The expression should end with its own parens, e.g., new new foo() is not a new expression with parens
+                    astUtils.isOpeningParenToken(penultimateToken) &&
+                    astUtils.isClosingParenToken(lastToken) &&
+                    newExpression.callee.range[1] < newExpression.range[1]
+                );
+        }
+
+        /**
+         * Determines if a node is or contains an assignment expression
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is or contains an assignment expression.
+         * @private
+         */
+        function containsAssignment(node) {
+            if (node.type === "AssignmentExpression") {
+                return true;
+            }
+            if (node.type === "ConditionalExpression" &&
+                    (node.consequent.type === "AssignmentExpression" || node.alternate.type === "AssignmentExpression")) {
+                return true;
+            }
+            if ((node.left && node.left.type === "AssignmentExpression") ||
+                    (node.right && node.right.type === "AssignmentExpression")) {
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Determines if a node is contained by or is itself a return statement and is allowed to have a parenthesised assignment
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the assignment can be parenthesised.
+         * @private
+         */
+        function isReturnAssignException(node) {
+            if (!EXCEPT_RETURN_ASSIGN || !isInReturnStatement(node)) {
+                return false;
+            }
+
+            if (node.type === "ReturnStatement") {
+                return node.argument && containsAssignment(node.argument);
+            }
+            if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+                return containsAssignment(node.body);
+            }
+            return containsAssignment(node);
+
+        }
+
+        /**
+         * Determines if a node following a [no LineTerminator here] restriction is
+         * surrounded by (potentially) invalid extra parentheses.
+         * @param {Token} token The token preceding the [no LineTerminator here] restriction.
+         * @param {ASTNode} node The node to be checked.
+         * @returns {boolean} True if the node is incorrectly parenthesised.
+         * @private
+         */
+        function hasExcessParensNoLineTerminator(token, node) {
+            if (token.loc.end.line === node.loc.start.line) {
+                return hasExcessParens(node);
+            }
+
+            return hasDoubleExcessParens(node);
+        }
+
+        /**
+         * Determines whether a node should be preceded by an additional space when removing parens
+         * @param {ASTNode} node node to evaluate; must be surrounded by parentheses
+         * @returns {boolean} `true` if a space should be inserted before the node
+         * @private
+         */
+        function requiresLeadingSpace(node) {
+            const leftParenToken = sourceCode.getTokenBefore(node);
+            const tokenBeforeLeftParen = sourceCode.getTokenBefore(leftParenToken, { includeComments: true });
+            const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParenToken, { includeComments: true });
+
+            return tokenBeforeLeftParen &&
+                tokenBeforeLeftParen.range[1] === leftParenToken.range[0] &&
+                leftParenToken.range[1] === tokenAfterLeftParen.range[0] &&
+                !astUtils.canTokensBeAdjacent(tokenBeforeLeftParen, tokenAfterLeftParen);
+        }
+
+        /**
+         * Determines whether a node should be followed by an additional space when removing parens
+         * @param {ASTNode} node node to evaluate; must be surrounded by parentheses
+         * @returns {boolean} `true` if a space should be inserted after the node
+         * @private
+         */
+        function requiresTrailingSpace(node) {
+            const nextTwoTokens = sourceCode.getTokensAfter(node, { count: 2 });
+            const rightParenToken = nextTwoTokens[0];
+            const tokenAfterRightParen = nextTwoTokens[1];
+            const tokenBeforeRightParen = sourceCode.getLastToken(node);
+
+            return rightParenToken && tokenAfterRightParen &&
+                !sourceCode.isSpaceBetweenTokens(rightParenToken, tokenAfterRightParen) &&
+                !astUtils.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
+        }
+
+        /**
+         * Determines if a given expression node is an IIFE
+         * @param {ASTNode} node The node to check
+         * @returns {boolean} `true` if the given node is an IIFE
+         */
+        function isIIFE(node) {
+            const maybeCallNode = astUtils.skipChainExpression(node);
+
+            return maybeCallNode.type === "CallExpression" && maybeCallNode.callee.type === "FunctionExpression";
+        }
+
+        /**
+         * Determines if the given node can be the assignment target in destructuring or the LHS of an assignment.
+         * This is to avoid an autofix that could change behavior because parsers mistakenly allow invalid syntax,
+         * such as `(a = b) = c` and `[(a = b) = c] = []`. Ideally, this function shouldn't be necessary.
+         * @param {ASTNode} [node] The node to check
+         * @returns {boolean} `true` if the given node can be a valid assignment target
+         */
+        function canBeAssignmentTarget(node) {
+            return node && (node.type === "Identifier" || node.type === "MemberExpression");
+        }
+
+        /**
+         * Checks if a node is fixable.
+         * A node is fixable if removing a single pair of surrounding parentheses does not turn it
+         * into a directive after fixing other nodes.
+         * Almost all nodes are fixable, except if all of the following conditions are met:
+         * The node is a string Literal
+         * It has a single pair of parentheses
+         * It is the only child of an ExpressionStatement
+         * @param {ASTNode} node The node to evaluate.
+         * @returns {boolean} Whether or not the node is fixable.
+         * @private
+         */
+        function isFixable(node) {
+
+            // if it's not a string literal it can be autofixed
+            if (node.type !== "Literal" || typeof node.value !== "string") {
+                return true;
+            }
+            if (isParenthesisedTwice(node)) {
+                return true;
+            }
+            return !astUtils.isTopLevelExpressionStatement(node.parent);
+        }
+
+        /**
+         * Report the node
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function report(node) {
+            const leftParenToken = sourceCode.getTokenBefore(node);
+            const rightParenToken = sourceCode.getTokenAfter(node);
+
+            if (!isParenthesisedTwice(node)) {
+                if (tokensToIgnore.has(sourceCode.getFirstToken(node))) {
+                    return;
+                }
+
+                if (isIIFE(node) && !isParenthesised(node.callee)) {
+                    return;
+                }
+
+                if (ALLOW_PARENS_AFTER_COMMENT_PATTERN) {
+                    const commentsBeforeLeftParenToken = sourceCode.getCommentsBefore(leftParenToken);
+                    const totalCommentsBeforeLeftParenTokenCount = commentsBeforeLeftParenToken.length;
+                    const ignorePattern = new RegExp(ALLOW_PARENS_AFTER_COMMENT_PATTERN, "u");
+
+                    if (
+                        totalCommentsBeforeLeftParenTokenCount > 0 &&
+                        ignorePattern.test(commentsBeforeLeftParenToken[totalCommentsBeforeLeftParenTokenCount - 1].value)
+                    ) {
+                        return;
+                    }
+                }
+            }
+
+            /**
+             * Finishes reporting
+             * @returns {void}
+             * @private
+             */
+            function finishReport() {
+                context.report({
+                    node,
+                    loc: leftParenToken.loc,
+                    messageId: "unexpected",
+                    fix: isFixable(node)
+                        ? fixer => {
+                            const parenthesizedSource = sourceCode.text.slice(leftParenToken.range[1], rightParenToken.range[0]);
+
+                            return fixer.replaceTextRange([
+                                leftParenToken.range[0],
+                                rightParenToken.range[1]
+                            ], (requiresLeadingSpace(node) ? " " : "") + parenthesizedSource + (requiresTrailingSpace(node) ? " " : ""));
+                        }
+                        : null
+                });
+            }
+
+            if (reportsBuffer) {
+                reportsBuffer.reports.push({ node, finishReport });
+                return;
+            }
+
+            finishReport();
+        }
+
+        /**
+         * Evaluate a argument of the node.
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkArgumentWithPrecedence(node) {
+            if (hasExcessParensWithPrecedence(node.argument, precedence(node))) {
+                report(node.argument);
+            }
+        }
+
+        /**
+         * Check if a member expression contains a call expression
+         * @param {ASTNode} node MemberExpression node to evaluate
+         * @returns {boolean} true if found, false if not
+         */
+        function doesMemberExpressionContainCallExpression(node) {
+            let currentNode = node.object;
+            let currentNodeType = node.object.type;
+
+            while (currentNodeType === "MemberExpression") {
+                currentNode = currentNode.object;
+                currentNodeType = currentNode.type;
+            }
+
+            return currentNodeType === "CallExpression";
+        }
+
+        /**
+         * Evaluate a new call
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkCallNew(node) {
+            const callee = node.callee;
+
+            if (hasExcessParensWithPrecedence(callee, precedence(node))) {
+                if (
+                    hasDoubleExcessParens(callee) ||
+                    !(
+                        isIIFE(node) ||
+
+                        // (new A)(); new (new A)();
+                        (
+                            callee.type === "NewExpression" &&
+                            !isNewExpressionWithParens(callee) &&
+                            !(
+                                node.type === "NewExpression" &&
+                                !isNewExpressionWithParens(node)
+                            )
+                        ) ||
+
+                        // new (a().b)(); new (a.b().c);
+                        (
+                            node.type === "NewExpression" &&
+                            callee.type === "MemberExpression" &&
+                            doesMemberExpressionContainCallExpression(callee)
+                        ) ||
+
+                        // (a?.b)(); (a?.())();
+                        (
+                            !node.optional &&
+                            callee.type === "ChainExpression"
+                        )
+                    )
+                ) {
+                    report(node.callee);
+                }
+            }
+            node.arguments
+                .filter(arg => hasExcessParensWithPrecedence(arg, PRECEDENCE_OF_ASSIGNMENT_EXPR))
+                .forEach(report);
+        }
+
+        /**
+         * Evaluate binary logicals
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkBinaryLogical(node) {
+            const prec = precedence(node);
+            const leftPrecedence = precedence(node.left);
+            const rightPrecedence = precedence(node.right);
+            const isExponentiation = node.operator === "**";
+            const shouldSkipLeft = NESTED_BINARY && (node.left.type === "BinaryExpression" || node.left.type === "LogicalExpression");
+            const shouldSkipRight = NESTED_BINARY && (node.right.type === "BinaryExpression" || node.right.type === "LogicalExpression");
+
+            if (!shouldSkipLeft && hasExcessParens(node.left)) {
+                if (
+                    !(["AwaitExpression", "UnaryExpression"].includes(node.left.type) && isExponentiation) &&
+                    !astUtils.isMixedLogicalAndCoalesceExpressions(node.left, node) &&
+                    (leftPrecedence > prec || (leftPrecedence === prec && !isExponentiation)) ||
+                    isParenthesisedTwice(node.left)
+                ) {
+                    report(node.left);
+                }
+            }
+
+            if (!shouldSkipRight && hasExcessParens(node.right)) {
+                if (
+                    !astUtils.isMixedLogicalAndCoalesceExpressions(node.right, node) &&
+                    (rightPrecedence > prec || (rightPrecedence === prec && isExponentiation)) ||
+                    isParenthesisedTwice(node.right)
+                ) {
+                    report(node.right);
+                }
+            }
+        }
+
+        /**
+         * Check the parentheses around the super class of the given class definition.
+         * @param {ASTNode} node The node of class declarations to check.
+         * @returns {void}
+         */
+        function checkClass(node) {
+            if (!node.superClass) {
+                return;
+            }
+
+            /*
+             * If `node.superClass` is a LeftHandSideExpression, parentheses are extra.
+             * Otherwise, parentheses are needed.
+             */
+            const hasExtraParens = precedence(node.superClass) > PRECEDENCE_OF_UPDATE_EXPR
+                ? hasExcessParens(node.superClass)
+                : hasDoubleExcessParens(node.superClass);
+
+            if (hasExtraParens) {
+                report(node.superClass);
+            }
+        }
+
+        /**
+         * Check the parentheses around the argument of the given spread operator.
+         * @param {ASTNode} node The node of spread elements/properties to check.
+         * @returns {void}
+         */
+        function checkSpreadOperator(node) {
+            if (hasExcessParensWithPrecedence(node.argument, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                report(node.argument);
+            }
+        }
+
+        /**
+         * Checks the parentheses for an ExpressionStatement or ExportDefaultDeclaration
+         * @param {ASTNode} node The ExpressionStatement.expression or ExportDefaultDeclaration.declaration node
+         * @returns {void}
+         */
+        function checkExpressionOrExportStatement(node) {
+            const firstToken = isParenthesised(node) ? sourceCode.getTokenBefore(node) : sourceCode.getFirstToken(node);
+            const secondToken = sourceCode.getTokenAfter(firstToken, astUtils.isNotOpeningParenToken);
+            const thirdToken = secondToken ? sourceCode.getTokenAfter(secondToken) : null;
+            const tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, astUtils.isNotClosingParenToken) : null;
+
+            if (
+                astUtils.isOpeningParenToken(firstToken) &&
+                (
+                    astUtils.isOpeningBraceToken(secondToken) ||
+                    secondToken.type === "Keyword" && (
+                        secondToken.value === "function" ||
+                        secondToken.value === "class" ||
+                        secondToken.value === "let" &&
+                            tokenAfterClosingParens &&
+                            (
+                                astUtils.isOpeningBracketToken(tokenAfterClosingParens) ||
+                                tokenAfterClosingParens.type === "Identifier"
+                            )
+                    ) ||
+                    secondToken && secondToken.type === "Identifier" && secondToken.value === "async" && thirdToken && thirdToken.type === "Keyword" && thirdToken.value === "function"
+                )
+            ) {
+                tokensToIgnore.add(secondToken);
+            }
+
+            const hasExtraParens = node.parent.type === "ExportDefaultDeclaration"
+                ? hasExcessParensWithPrecedence(node, PRECEDENCE_OF_ASSIGNMENT_EXPR)
+                : hasExcessParens(node);
+
+            if (hasExtraParens) {
+                report(node);
+            }
+        }
+
+        /**
+         * Finds the path from the given node to the specified ancestor.
+         * @param {ASTNode} node First node in the path.
+         * @param {ASTNode} ancestor Last node in the path.
+         * @returns {ASTNode[]} Path, including both nodes.
+         * @throws {Error} If the given node does not have the specified ancestor.
+         */
+        function pathToAncestor(node, ancestor) {
+            const path = [node];
+            let currentNode = node;
+
+            while (currentNode !== ancestor) {
+
+                currentNode = currentNode.parent;
+
+                /* c8 ignore start */
+                if (currentNode === null) {
+                    throw new Error("Nodes are not in the ancestor-descendant relationship.");
+                }/* c8 ignore stop */
+
+                path.push(currentNode);
+            }
+
+            return path;
+        }
+
+        /**
+         * Finds the path from the given node to the specified descendant.
+         * @param {ASTNode} node First node in the path.
+         * @param {ASTNode} descendant Last node in the path.
+         * @returns {ASTNode[]} Path, including both nodes.
+         * @throws {Error} If the given node does not have the specified descendant.
+         */
+        function pathToDescendant(node, descendant) {
+            return pathToAncestor(descendant, node).reverse();
+        }
+
+        /**
+         * Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer
+         * is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop.
+         * @param {ASTNode} node Ancestor of an 'in' expression.
+         * @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself.
+         * @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis.
+         */
+        function isSafelyEnclosingInExpression(node, child) {
+            switch (node.type) {
+                case "ArrayExpression":
+                case "ArrayPattern":
+                case "BlockStatement":
+                case "ObjectExpression":
+                case "ObjectPattern":
+                case "TemplateLiteral":
+                    return true;
+                case "ArrowFunctionExpression":
+                case "FunctionExpression":
+                    return node.params.includes(child);
+                case "CallExpression":
+                case "NewExpression":
+                    return node.arguments.includes(child);
+                case "MemberExpression":
+                    return node.computed && node.property === child;
+                case "ConditionalExpression":
+                    return node.consequent === child;
+                default:
+                    return false;
+            }
+        }
+
+        /**
+         * Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately.
+         * An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings.
+         * @returns {void}
+         */
+        function startNewReportsBuffering() {
+            reportsBuffer = {
+                upper: reportsBuffer,
+                inExpressionNodes: [],
+                reports: []
+            };
+        }
+
+        /**
+         * Ends the current reports buffering.
+         * @returns {void}
+         */
+        function endCurrentReportsBuffering() {
+            const { upper, inExpressionNodes, reports } = reportsBuffer;
+
+            if (upper) {
+                upper.inExpressionNodes.push(...inExpressionNodes);
+                upper.reports.push(...reports);
+            } else {
+
+                // flush remaining reports
+                reports.forEach(({ finishReport }) => finishReport());
+            }
+
+            reportsBuffer = upper;
+        }
+
+        /**
+         * Checks whether the given node is in the current reports buffer.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if the node is in the current buffer, false otherwise.
+         */
+        function isInCurrentReportsBuffer(node) {
+            return reportsBuffer.reports.some(r => r.node === node);
+        }
+
+        /**
+         * Removes the given node from the current reports buffer.
+         * @param {ASTNode} node Node to remove.
+         * @returns {void}
+         */
+        function removeFromCurrentReportsBuffer(node) {
+            reportsBuffer.reports = reportsBuffer.reports.filter(r => r.node !== node);
+        }
+
+        /**
+         * Checks whether a node is a MemberExpression at NewExpression's callee.
+         * @param {ASTNode} node node to check.
+         * @returns {boolean} True if the node is a MemberExpression at NewExpression's callee. false otherwise.
+         */
+        function isMemberExpInNewCallee(node) {
+            if (node.type === "MemberExpression") {
+                return node.parent.type === "NewExpression" && node.parent.callee === node
+                    ? true
+                    : node.parent.object === node && isMemberExpInNewCallee(node.parent);
+            }
+            return false;
+        }
+
+        /**
+         * Checks if the left-hand side of an assignment is an identifier, the operator is one of
+         * `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous class or function.
+         *
+         * As per https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation, an
+         * assignment involving one of the operators `=`, `&&=`, `||=` or `??=` where the right-hand
+         * side is an anonymous class or function and the left-hand side is an *unparenthesized*
+         * identifier has different semantics than other assignments.
+         * Specifically, when an expression like `foo = function () {}` is evaluated, `foo.name`
+         * will be set to the string "foo", i.e. the identifier name. The same thing does not happen
+         * when evaluating `(foo) = function () {}`.
+         * Since the parenthesizing of the identifier in the left-hand side is significant in this
+         * special case, the parentheses, if present, should not be flagged as unnecessary.
+         * @param {ASTNode} node an AssignmentExpression node.
+         * @returns {boolean} `true` if the left-hand side of the assignment is an identifier, the
+         * operator is one of `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous
+         * class or function; otherwise, `false`.
+         */
+        function isAnonymousFunctionAssignmentException({ left, operator, right }) {
+            if (left.type === "Identifier" && ["=", "&&=", "||=", "??="].includes(operator)) {
+                const rhsType = right.type;
+
+                if (rhsType === "ArrowFunctionExpression") {
+                    return true;
+                }
+                if ((rhsType === "FunctionExpression" || rhsType === "ClassExpression") && !right.id) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        return {
+            ArrayExpression(node) {
+                node.elements
+                    .filter(e => e && hasExcessParensWithPrecedence(e, PRECEDENCE_OF_ASSIGNMENT_EXPR))
+                    .forEach(report);
+            },
+
+            ArrayPattern(node) {
+                node.elements
+                    .filter(e => canBeAssignmentTarget(e) && hasExcessParens(e))
+                    .forEach(report);
+            },
+
+            ArrowFunctionExpression(node) {
+                if (isReturnAssignException(node)) {
+                    return;
+                }
+
+                if (node.body.type === "ConditionalExpression" &&
+                    IGNORE_ARROW_CONDITIONALS
+                ) {
+                    return;
+                }
+
+                if (node.body.type !== "BlockStatement") {
+                    const firstBodyToken = sourceCode.getFirstToken(node.body, astUtils.isNotOpeningParenToken);
+                    const tokenBeforeFirst = sourceCode.getTokenBefore(firstBodyToken);
+
+                    if (astUtils.isOpeningParenToken(tokenBeforeFirst) && astUtils.isOpeningBraceToken(firstBodyToken)) {
+                        tokensToIgnore.add(firstBodyToken);
+                    }
+                    if (hasExcessParensWithPrecedence(node.body, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                        report(node.body);
+                    }
+                }
+            },
+
+            AssignmentExpression(node) {
+                if (canBeAssignmentTarget(node.left) && hasExcessParens(node.left) &&
+                    (!isAnonymousFunctionAssignmentException(node) || isParenthesisedTwice(node.left))) {
+                    report(node.left);
+                }
+
+                if (!isReturnAssignException(node) && hasExcessParensWithPrecedence(node.right, precedence(node))) {
+                    report(node.right);
+                }
+            },
+
+            BinaryExpression(node) {
+                if (reportsBuffer && node.operator === "in") {
+                    reportsBuffer.inExpressionNodes.push(node);
+                }
+
+                checkBinaryLogical(node);
+            },
+
+            CallExpression: checkCallNew,
+
+            ConditionalExpression(node) {
+                if (isReturnAssignException(node)) {
+                    return;
+                }
+
+                const availableTypes = new Set(["BinaryExpression", "LogicalExpression"]);
+
+                if (
+                    !(EXCEPT_COND_TERNARY && availableTypes.has(node.test.type)) &&
+                    !isCondAssignException(node) &&
+                    hasExcessParensWithPrecedence(node.test, precedence({ type: "LogicalExpression", operator: "||" }))
+                ) {
+                    report(node.test);
+                }
+
+                if (
+                    !(EXCEPT_COND_TERNARY && availableTypes.has(node.consequent.type)) &&
+                    hasExcessParensWithPrecedence(node.consequent, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.consequent);
+                }
+
+                if (
+                    !(EXCEPT_COND_TERNARY && availableTypes.has(node.alternate.type)) &&
+                    hasExcessParensWithPrecedence(node.alternate, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.alternate);
+                }
+            },
+
+            DoWhileStatement(node) {
+                if (hasExcessParens(node.test) && !isCondAssignException(node)) {
+                    report(node.test);
+                }
+            },
+
+            ExportDefaultDeclaration: node => checkExpressionOrExportStatement(node.declaration),
+            ExpressionStatement: node => checkExpressionOrExportStatement(node.expression),
+
+            ForInStatement(node) {
+                if (node.left.type !== "VariableDeclaration") {
+                    const firstLeftToken = sourceCode.getFirstToken(node.left, astUtils.isNotOpeningParenToken);
+
+                    if (
+                        firstLeftToken.value === "let" &&
+                        astUtils.isOpeningBracketToken(
+                            sourceCode.getTokenAfter(firstLeftToken, astUtils.isNotClosingParenToken)
+                        )
+                    ) {
+
+                        // ForInStatement#left expression cannot start with `let[`.
+                        tokensToIgnore.add(firstLeftToken);
+                    }
+                }
+
+                if (hasExcessParens(node.left)) {
+                    report(node.left);
+                }
+
+                if (hasExcessParens(node.right)) {
+                    report(node.right);
+                }
+            },
+
+            ForOfStatement(node) {
+                if (node.left.type !== "VariableDeclaration") {
+                    const firstLeftToken = sourceCode.getFirstToken(node.left, astUtils.isNotOpeningParenToken);
+
+                    if (firstLeftToken.value === "let") {
+
+                        // ForOfStatement#left expression cannot start with `let`.
+                        tokensToIgnore.add(firstLeftToken);
+                    }
+                }
+
+                if (hasExcessParens(node.left)) {
+                    report(node.left);
+                }
+
+                if (hasExcessParensWithPrecedence(node.right, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.right);
+                }
+            },
+
+            ForStatement(node) {
+                if (node.test && hasExcessParens(node.test) && !isCondAssignException(node)) {
+                    report(node.test);
+                }
+
+                if (node.update && hasExcessParens(node.update)) {
+                    report(node.update);
+                }
+
+                if (node.init) {
+
+                    if (node.init.type !== "VariableDeclaration") {
+                        const firstToken = sourceCode.getFirstToken(node.init, astUtils.isNotOpeningParenToken);
+
+                        if (
+                            firstToken.value === "let" &&
+                            astUtils.isOpeningBracketToken(
+                                sourceCode.getTokenAfter(firstToken, astUtils.isNotClosingParenToken)
+                            )
+                        ) {
+
+                            // ForStatement#init expression cannot start with `let[`.
+                            tokensToIgnore.add(firstToken);
+                        }
+                    }
+
+                    startNewReportsBuffering();
+
+                    if (hasExcessParens(node.init)) {
+                        report(node.init);
+                    }
+                }
+            },
+
+            "ForStatement > *.init:exit"(node) {
+
+                /*
+                 * Removing parentheses around `in` expressions might change semantics and cause errors.
+                 *
+                 * For example, this valid for loop:
+                 *      for (let a = (b in c); ;);
+                 * after removing parentheses would be treated as an invalid for-in loop:
+                 *      for (let a = b in c; ;);
+                 */
+
+                if (reportsBuffer.reports.length) {
+                    reportsBuffer.inExpressionNodes.forEach(inExpressionNode => {
+                        const path = pathToDescendant(node, inExpressionNode);
+                        let nodeToExclude;
+
+                        for (let i = 0; i < path.length; i++) {
+                            const pathNode = path[i];
+
+                            if (i < path.length - 1) {
+                                const nextPathNode = path[i + 1];
+
+                                if (isSafelyEnclosingInExpression(pathNode, nextPathNode)) {
+
+                                    // The 'in' expression in safely enclosed by the syntax of its ancestor nodes (e.g. by '{}' or '[]').
+                                    return;
+                                }
+                            }
+
+                            if (isParenthesised(pathNode)) {
+                                if (isInCurrentReportsBuffer(pathNode)) {
+
+                                    // This node was supposed to be reported, but parentheses might be necessary.
+
+                                    if (isParenthesisedTwice(pathNode)) {
+
+                                        /*
+                                         * This node is parenthesised twice, it certainly has at least one pair of `extra` parentheses.
+                                         * If the --fix option is on, the current fixing iteration will remove only one pair of parentheses.
+                                         * The remaining pair is safely enclosing the 'in' expression.
+                                         */
+                                        return;
+                                    }
+
+                                    // Exclude the outermost node only.
+                                    if (!nodeToExclude) {
+                                        nodeToExclude = pathNode;
+                                    }
+
+                                    // Don't break the loop here, there might be some safe nodes or parentheses that will stay inside.
+
+                                } else {
+
+                                    // This node will stay parenthesised, the 'in' expression in safely enclosed by '()'.
+                                    return;
+                                }
+                            }
+                        }
+
+                        // Exclude the node from the list (i.e. treat parentheses as necessary)
+                        removeFromCurrentReportsBuffer(nodeToExclude);
+                    });
+                }
+
+                endCurrentReportsBuffering();
+            },
+
+            IfStatement(node) {
+                if (hasExcessParens(node.test) && !isCondAssignException(node)) {
+                    report(node.test);
+                }
+            },
+
+            ImportExpression(node) {
+                const { source } = node;
+
+                if (source.type === "SequenceExpression") {
+                    if (hasDoubleExcessParens(source)) {
+                        report(source);
+                    }
+                } else if (hasExcessParens(source)) {
+                    report(source);
+                }
+            },
+
+            LogicalExpression: checkBinaryLogical,
+
+            MemberExpression(node) {
+                const shouldAllowWrapOnce = isMemberExpInNewCallee(node) &&
+                  doesMemberExpressionContainCallExpression(node);
+                const nodeObjHasExcessParens = shouldAllowWrapOnce
+                    ? hasDoubleExcessParens(node.object)
+                    : hasExcessParens(node.object) &&
+                    !(
+                        isImmediateFunctionPrototypeMethodCall(node.parent) &&
+                        node.parent.callee === node &&
+                        IGNORE_FUNCTION_PROTOTYPE_METHODS
+                    );
+
+                if (
+                    nodeObjHasExcessParens &&
+                    precedence(node.object) >= precedence(node) &&
+                    (
+                        node.computed ||
+                        !(
+                            astUtils.isDecimalInteger(node.object) ||
+
+                            // RegExp literal is allowed to have parens (#1589)
+                            (node.object.type === "Literal" && node.object.regex)
+                        )
+                    )
+                ) {
+                    report(node.object);
+                }
+
+                if (nodeObjHasExcessParens &&
+                  node.object.type === "CallExpression"
+                ) {
+                    report(node.object);
+                }
+
+                if (nodeObjHasExcessParens &&
+                  !IGNORE_NEW_IN_MEMBER_EXPR &&
+                  node.object.type === "NewExpression" &&
+                  isNewExpressionWithParens(node.object)) {
+                    report(node.object);
+                }
+
+                if (nodeObjHasExcessParens &&
+                    node.optional &&
+                    node.object.type === "ChainExpression"
+                ) {
+                    report(node.object);
+                }
+
+                if (node.computed && hasExcessParens(node.property)) {
+                    report(node.property);
+                }
+            },
+
+            "MethodDefinition[computed=true]"(node) {
+                if (hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.key);
+                }
+            },
+
+            NewExpression: checkCallNew,
+
+            ObjectExpression(node) {
+                node.properties
+                    .filter(property => property.value && hasExcessParensWithPrecedence(property.value, PRECEDENCE_OF_ASSIGNMENT_EXPR))
+                    .forEach(property => report(property.value));
+            },
+
+            ObjectPattern(node) {
+                node.properties
+                    .filter(property => {
+                        const value = property.value;
+
+                        return canBeAssignmentTarget(value) && hasExcessParens(value);
+                    }).forEach(property => report(property.value));
+            },
+
+            Property(node) {
+                if (node.computed) {
+                    const { key } = node;
+
+                    if (key && hasExcessParensWithPrecedence(key, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                        report(key);
+                    }
+                }
+            },
+
+            PropertyDefinition(node) {
+                if (node.computed && hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.key);
+                }
+
+                if (node.value && hasExcessParensWithPrecedence(node.value, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(node.value);
+                }
+            },
+
+            RestElement(node) {
+                const argument = node.argument;
+
+                if (canBeAssignmentTarget(argument) && hasExcessParens(argument)) {
+                    report(argument);
+                }
+            },
+
+            ReturnStatement(node) {
+                const returnToken = sourceCode.getFirstToken(node);
+
+                if (isReturnAssignException(node)) {
+                    return;
+                }
+
+                if (node.argument &&
+                        hasExcessParensNoLineTerminator(returnToken, node.argument) &&
+
+                        // RegExp literal is allowed to have parens (#1589)
+                        !(node.argument.type === "Literal" && node.argument.regex)) {
+                    report(node.argument);
+                }
+            },
+
+            SequenceExpression(node) {
+                const precedenceOfNode = precedence(node);
+
+                node.expressions
+                    .filter(e => hasExcessParensWithPrecedence(e, precedenceOfNode))
+                    .forEach(report);
+            },
+
+            SwitchCase(node) {
+                if (node.test && hasExcessParens(node.test)) {
+                    report(node.test);
+                }
+            },
+
+            SwitchStatement(node) {
+                if (hasExcessParens(node.discriminant)) {
+                    report(node.discriminant);
+                }
+            },
+
+            ThrowStatement(node) {
+                const throwToken = sourceCode.getFirstToken(node);
+
+                if (hasExcessParensNoLineTerminator(throwToken, node.argument)) {
+                    report(node.argument);
+                }
+            },
+
+            UnaryExpression: checkArgumentWithPrecedence,
+            UpdateExpression(node) {
+                if (node.prefix) {
+                    checkArgumentWithPrecedence(node);
+                } else {
+                    const { argument } = node;
+                    const operatorToken = sourceCode.getLastToken(node);
+
+                    if (argument.loc.end.line === operatorToken.loc.start.line) {
+                        checkArgumentWithPrecedence(node);
+                    } else {
+                        if (hasDoubleExcessParens(argument)) {
+                            report(argument);
+                        }
+                    }
+                }
+            },
+            AwaitExpression: checkArgumentWithPrecedence,
+
+            VariableDeclarator(node) {
+                if (
+                    node.init && hasExcessParensWithPrecedence(node.init, PRECEDENCE_OF_ASSIGNMENT_EXPR) &&
+
+                    // RegExp literal is allowed to have parens (#1589)
+                    !(node.init.type === "Literal" && node.init.regex)
+                ) {
+                    report(node.init);
+                }
+            },
+
+            WhileStatement(node) {
+                if (hasExcessParens(node.test) && !isCondAssignException(node)) {
+                    report(node.test);
+                }
+            },
+
+            WithStatement(node) {
+                if (hasExcessParens(node.object)) {
+                    report(node.object);
+                }
+            },
+
+            YieldExpression(node) {
+                if (node.argument) {
+                    const yieldToken = sourceCode.getFirstToken(node);
+
+                    if ((precedence(node.argument) >= precedence(node) &&
+                            hasExcessParensNoLineTerminator(yieldToken, node.argument)) ||
+                            hasDoubleExcessParens(node.argument)) {
+                        report(node.argument);
+                    }
+                }
+            },
+
+            ClassDeclaration: checkClass,
+            ClassExpression: checkClass,
+
+            SpreadElement: checkSpreadOperator,
+            SpreadProperty: checkSpreadOperator,
+            ExperimentalSpreadProperty: checkSpreadOperator,
+
+            TemplateLiteral(node) {
+                node.expressions
+                    .filter(e => e && hasExcessParens(e))
+                    .forEach(report);
+            },
+
+            AssignmentPattern(node) {
+                const { left, right } = node;
+
+                if (canBeAssignmentTarget(left) && hasExcessParens(left)) {
+                    report(left);
+                }
+
+                if (right && hasExcessParensWithPrecedence(right, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+                    report(right);
+                }
+            }
+        };
+
+    }
+};