+++ /dev/null
-/**
- * @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);
- }
- }
- };
-
- }
-};
projects / dotfiles / .git / blobdiff