Permalink
Cannot retrieve contributors at this time
| /** | |
| * @fileoverview Disallow parenthesising higher precedence subexpressions. | |
| * @author Michael Ficarra | |
| */ | |
| "use strict"; | |
| //------------------------------------------------------------------------------ | |
| // Rule Definition | |
| //------------------------------------------------------------------------------ | |
| const { isParenthesized: isParenthesizedRaw } = require("eslint-utils"); | |
| const astUtils = require("./utils/ast-utils.js"); | |
| module.exports = { | |
| meta: { | |
| type: "layout", | |
| docs: { | |
| description: "disallow unnecessary parentheses", | |
| category: "Possible Errors", | |
| recommended: false, | |
| url: "https://eslint.org/docs/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" }, | |
| nestedBinaryExpressions: { type: "boolean" }, | |
| returnAssign: { type: "boolean" }, | |
| ignoreJSX: { enum: ["none", "all", "single-line", "multi-line"] }, | |
| enforceForArrowConditionals: { type: "boolean" }, | |
| enforceForSequenceExpressions: { type: "boolean" }, | |
| enforceForNewInMemberExpressions: { type: "boolean" } | |
| }, | |
| additionalProperties: false | |
| } | |
| ], | |
| minItems: 0, | |
| maxItems: 2 | |
| } | |
| ] | |
| }, | |
| messages: { | |
| unexpected: "Unnecessary parentheses around expression." | |
| } | |
| }, | |
| create(context) { | |
| const sourceCode = context.getSourceCode(); | |
| 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 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 PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" }); | |
| const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" }); | |
| let reportsBuffer; | |
| /** | |
| * 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; | |
| } | |
| 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 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(node, 1); | |
| const firstToken = sourceCode.getFirstToken(node); | |
| return tokenBeforeLeftParen && | |
| tokenBeforeLeftParen.range[1] === leftParenToken.range[0] && | |
| leftParenToken.range[1] === firstToken.range[0] && | |
| !astUtils.canTokensBeAdjacent(tokenBeforeLeftParen, firstToken); | |
| } | |
| /** | |
| * 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) { | |
| return node.type === "CallExpression" && node.callee.type === "FunctionExpression"; | |
| } | |
| /** | |
| * 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; | |
| } | |
| } | |
| /** | |
| * Finishes reporting | |
| * @returns {void} | |
| * @private | |
| */ | |
| function finishReport() { | |
| context.report({ | |
| node, | |
| loc: leftParenToken.loc, | |
| messageId: "unexpected", | |
| fix(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) ? " " : "")); | |
| } | |
| }); | |
| } | |
| if (reportsBuffer) { | |
| reportsBuffer.reports.push({ node, finishReport }); | |
| return; | |
| } | |
| finishReport(); | |
| } | |
| /** | |
| * Evaluate Unary update | |
| * @param {ASTNode} node node to evaluate | |
| * @returns {void} | |
| * @private | |
| */ | |
| function checkUnaryUpdate(node) { | |
| if (node.type === "UnaryExpression" && node.argument.type === "BinaryExpression" && node.argument.operator === "**") { | |
| return; | |
| } | |
| if (hasExcessParens(node.argument) && precedence(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 (hasExcessParens(callee) && precedence(callee) >= precedence(node)) { | |
| const hasNewParensException = callee.type === "NewExpression" && !isNewExpressionWithParens(callee); | |
| if ( | |
| hasDoubleExcessParens(callee) || | |
| !isIIFE(node) && !hasNewParensException && !( | |
| /* | |
| * Allow extra parens around a new expression if | |
| * there are intervening parentheses. | |
| */ | |
| (callee.type === "MemberExpression" && doesMemberExpressionContainCallExpression(callee)) | |
| ) | |
| ) { | |
| report(node.callee); | |
| } | |
| } | |
| node.arguments | |
| .filter(arg => hasExcessParens(arg) && precedence(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")) || | |
| node.left.type === "UnaryExpression" && isExponentiation; | |
| const shouldSkipRight = NESTED_BINARY && (node.right.type === "BinaryExpression" || node.right.type === "LogicalExpression"); | |
| if (!shouldSkipLeft && hasExcessParens(node.left) && (leftPrecedence > prec || (leftPrecedence === prec && !isExponentiation))) { | |
| report(node.left); | |
| } | |
| if (!shouldSkipRight && hasExcessParens(node.right) && (rightPrecedence > prec || (rightPrecedence === prec && isExponentiation))) { | |
| 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) { | |
| const hasExtraParens = precedence(node.argument) >= PRECEDENCE_OF_ASSIGNMENT_EXPR | |
| ? hasExcessParens(node.argument) | |
| : hasDoubleExcessParens(node.argument); | |
| if (hasExtraParens) { | |
| 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); | |
| } | |
| if (hasExcessParens(node)) { | |
| 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; | |
| /* istanbul ignore if */ | |
| if (currentNode === null) { | |
| throw new Error("Nodes are not in the ancestor-descendant relationship."); | |
| } | |
| 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); | |
| } | |
| return { | |
| ArrayExpression(node) { | |
| node.elements | |
| .filter(e => e && hasExcessParens(e) && precedence(e) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) | |
| .forEach(report); | |
| }, | |
| ArrowFunctionExpression(node) { | |
| if (isReturnAssignException(node)) { | |
| return; | |
| } | |
| if (node.body.type === "ConditionalExpression" && | |
| IGNORE_ARROW_CONDITIONALS && | |
| !isParenthesisedTwice(node.body) | |
| ) { | |
| 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 (hasExcessParens(node.body) && precedence(node.body) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) { | |
| report(node.body); | |
| } | |
| } | |
| }, | |
| AssignmentExpression(node) { | |
| if (isReturnAssignException(node)) { | |
| return; | |
| } | |
| if (hasExcessParens(node.right) && precedence(node.right) >= precedence(node)) { | |
| report(node.right); | |
| } | |
| }, | |
| BinaryExpression(node) { | |
| if (reportsBuffer && node.operator === "in") { | |
| reportsBuffer.inExpressionNodes.push(node); | |
| } | |
| checkBinaryLogical(node); | |
| }, | |
| CallExpression: checkCallNew, | |
| ClassBody(node) { | |
| node.body | |
| .filter(member => member.type === "MethodDefinition" && member.computed && | |
| member.key && hasExcessParens(member.key) && precedence(member.key) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) | |
| .forEach(member => report(member.key)); | |
| }, | |
| ConditionalExpression(node) { | |
| if (isReturnAssignException(node)) { | |
| return; | |
| } | |
| if (hasExcessParens(node.test) && precedence(node.test) >= precedence({ type: "LogicalExpression", operator: "||" })) { | |
| report(node.test); | |
| } | |
| if (hasExcessParens(node.consequent) && precedence(node.consequent) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) { | |
| report(node.consequent); | |
| } | |
| if (hasExcessParens(node.alternate) && precedence(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, ForOfStatement"(node) { | |
| if (node.left.type !== "VariableDeclarator") { | |
| const firstLeftToken = sourceCode.getFirstToken(node.left, astUtils.isNotOpeningParenToken); | |
| if ( | |
| firstLeftToken.value === "let" && ( | |
| /* | |
| * If `let` is the only thing on the left side of the loop, it's the loop variable: `for ((let) of foo);` | |
| * Removing it will cause a syntax error, because it will be parsed as the start of a VariableDeclarator. | |
| */ | |
| (firstLeftToken.range[1] === node.left.range[1] || /* | |
| * If `let` is followed by a `[` token, it's a property access on the `let` value: `for ((let[foo]) of bar);` | |
| * Removing it will cause the property access to be parsed as a destructuring declaration of `foo` instead. | |
| */ | |
| astUtils.isOpeningBracketToken( | |
| sourceCode.getTokenAfter(firstLeftToken, astUtils.isNotClosingParenToken) | |
| )) | |
| ) | |
| ) { | |
| tokensToIgnore.add(firstLeftToken); | |
| } | |
| } | |
| if (!(node.type === "ForOfStatement" && node.right.type === "SequenceExpression") && hasExcessParens(node.right)) { | |
| report(node.right); | |
| } | |
| if (hasExcessParens(node.left)) { | |
| report(node.left); | |
| } | |
| }, | |
| 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) { | |
| 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 nodeObjHasExcessParens = hasExcessParens(node.object); | |
| 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" && | |
| node.parent.type !== "NewExpression") { | |
| report(node.object); | |
| } | |
| if (nodeObjHasExcessParens && | |
| !IGNORE_NEW_IN_MEMBER_EXPR && | |
| node.object.type === "NewExpression" && | |
| isNewExpressionWithParens(node.object)) { | |
| report(node.object); | |
| } | |
| if (node.computed && hasExcessParens(node.property)) { | |
| report(node.property); | |
| } | |
| }, | |
| NewExpression: checkCallNew, | |
| ObjectExpression(node) { | |
| node.properties | |
| .filter(property => { | |
| const value = property.value; | |
| return value && hasExcessParens(value) && precedence(value) >= PRECEDENCE_OF_ASSIGNMENT_EXPR; | |
| }).forEach(property => report(property.value)); | |
| }, | |
| Property(node) { | |
| if (node.computed) { | |
| const { key } = node; | |
| if (key && hasExcessParens(key) && precedence(key) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) { | |
| report(key); | |
| } | |
| } | |
| }, | |
| 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) { | |
| node.expressions | |
| .filter(e => hasExcessParens(e) && precedence(e) >= precedence(node)) | |
| .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: checkUnaryUpdate, | |
| UpdateExpression: checkUnaryUpdate, | |
| AwaitExpression: checkUnaryUpdate, | |
| VariableDeclarator(node) { | |
| if (node.init && hasExcessParens(node.init) && | |
| precedence(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 { right } = node; | |
| if (right && hasExcessParens(right) && precedence(right) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) { | |
| report(right); | |
| } | |
| } | |
| }; | |
| } | |
| }; |