398 lines
12 KiB
JavaScript
398 lines
12 KiB
JavaScript
/**
|
|
* @fileoverview Rule to flag unnecessary double negation in Boolean contexts
|
|
* @author Brandon Mills
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const astUtils = require('./utils/ast-utils');
|
|
const eslintUtils = require('@eslint-community/eslint-utils');
|
|
|
|
const precedence = astUtils.getPrecedence;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** @type {import('../types').Rule.RuleModule} */
|
|
module.exports = {
|
|
meta: {
|
|
type: 'suggestion',
|
|
|
|
defaultOptions: [{}],
|
|
|
|
docs: {
|
|
description: 'Disallow unnecessary boolean casts',
|
|
recommended: true,
|
|
frozen: true,
|
|
url: 'https://eslint.org/docs/latest/rules/no-extra-boolean-cast',
|
|
},
|
|
|
|
schema: [
|
|
{
|
|
anyOf: [
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
enforceForInnerExpressions: {
|
|
type: 'boolean',
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
|
|
// deprecated
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
enforceForLogicalOperands: {
|
|
type: 'boolean',
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
fixable: 'code',
|
|
|
|
messages: {
|
|
unexpectedCall: 'Redundant Boolean call.',
|
|
unexpectedNegation: 'Redundant double negation.',
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const sourceCode = context.sourceCode;
|
|
const [{ enforceForLogicalOperands, enforceForInnerExpressions }] =
|
|
context.options;
|
|
|
|
// Node types which have a test which will coerce values to booleans.
|
|
const BOOLEAN_NODE_TYPES = new Set([
|
|
'IfStatement',
|
|
'DoWhileStatement',
|
|
'WhileStatement',
|
|
'ConditionalExpression',
|
|
'ForStatement',
|
|
]);
|
|
|
|
/**
|
|
* Check if a node is a Boolean function or constructor.
|
|
* @param {ASTNode} node the node
|
|
* @returns {boolean} If the node is Boolean function or constructor
|
|
*/
|
|
function isBooleanFunctionOrConstructorCall(node) {
|
|
// Boolean(<bool>) and new Boolean(<bool>)
|
|
return (
|
|
(node.type === 'CallExpression' || node.type === 'NewExpression') &&
|
|
node.callee.type === 'Identifier' &&
|
|
node.callee.name === 'Boolean'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check if a node is in a context where its value would be coerced to a boolean at runtime.
|
|
* @param {ASTNode} node The node
|
|
* @returns {boolean} If it is in a boolean context
|
|
*/
|
|
function isInBooleanContext(node) {
|
|
return (
|
|
(isBooleanFunctionOrConstructorCall(node.parent) &&
|
|
node === node.parent.arguments[0]) ||
|
|
(BOOLEAN_NODE_TYPES.has(node.parent.type) &&
|
|
node === node.parent.test) ||
|
|
// !<bool>
|
|
(node.parent.type === 'UnaryExpression' && node.parent.operator === '!')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks whether the node is a context that should report an error
|
|
* Acts recursively if it is in a logical context
|
|
* @param {ASTNode} node the node
|
|
* @returns {boolean} If the node is in one of the flagged contexts
|
|
*/
|
|
function isInFlaggedContext(node) {
|
|
if (node.parent.type === 'ChainExpression') {
|
|
return isInFlaggedContext(node.parent);
|
|
}
|
|
|
|
/*
|
|
* legacy behavior - enforceForLogicalOperands will only recurse on
|
|
* logical expressions, not on other contexts.
|
|
* enforceForInnerExpressions will recurse on logical expressions
|
|
* as well as the other recursive syntaxes.
|
|
*/
|
|
|
|
if (enforceForLogicalOperands || enforceForInnerExpressions) {
|
|
if (node.parent.type === 'LogicalExpression') {
|
|
if (node.parent.operator === '||' || node.parent.operator === '&&') {
|
|
return isInFlaggedContext(node.parent);
|
|
}
|
|
|
|
// Check the right hand side of a `??` operator.
|
|
if (
|
|
enforceForInnerExpressions &&
|
|
node.parent.operator === '??' &&
|
|
node.parent.right === node
|
|
) {
|
|
return isInFlaggedContext(node.parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (enforceForInnerExpressions) {
|
|
if (
|
|
node.parent.type === 'ConditionalExpression' &&
|
|
(node.parent.consequent === node || node.parent.alternate === node)
|
|
) {
|
|
return isInFlaggedContext(node.parent);
|
|
}
|
|
|
|
/*
|
|
* Check last expression only in a sequence, i.e. if ((1, 2, Boolean(3))) {}, since
|
|
* the others don't affect the result of the expression.
|
|
*/
|
|
if (
|
|
node.parent.type === 'SequenceExpression' &&
|
|
node.parent.expressions.at(-1) === node
|
|
) {
|
|
return isInFlaggedContext(node.parent);
|
|
}
|
|
}
|
|
|
|
return isInBooleanContext(node);
|
|
}
|
|
|
|
/**
|
|
* Check if a node has comments inside.
|
|
* @param {ASTNode} node The node to check.
|
|
* @returns {boolean} `true` if it has comments inside.
|
|
*/
|
|
function hasCommentsInside(node) {
|
|
return Boolean(sourceCode.getCommentsInside(node).length);
|
|
}
|
|
|
|
/**
|
|
* Checks if the given node is wrapped in grouping parentheses. Parentheses for constructs such as if() don't count.
|
|
* @param {ASTNode} node The node to check.
|
|
* @returns {boolean} `true` if the node is parenthesized.
|
|
* @private
|
|
*/
|
|
function isParenthesized(node) {
|
|
return eslintUtils.isParenthesized(1, node, sourceCode);
|
|
}
|
|
|
|
/**
|
|
* Determines whether the given node needs to be parenthesized when replacing the previous node.
|
|
* It assumes that `previousNode` is the node to be reported by this rule, so it has a limited list
|
|
* of possible parent node types. By the same assumption, the node's role in a particular parent is already known.
|
|
* @param {ASTNode} previousNode Previous node.
|
|
* @param {ASTNode} node The node to check.
|
|
* @throws {Error} (Unreachable.)
|
|
* @returns {boolean} `true` if the node needs to be parenthesized.
|
|
*/
|
|
function needsParens(previousNode, node) {
|
|
if (previousNode.parent.type === 'ChainExpression') {
|
|
return needsParens(previousNode.parent, node);
|
|
}
|
|
|
|
if (isParenthesized(previousNode)) {
|
|
// parentheses around the previous node will stay, so there is no need for an additional pair
|
|
return false;
|
|
}
|
|
|
|
// parent of the previous node will become parent of the replacement node
|
|
const parent = previousNode.parent;
|
|
|
|
switch (parent.type) {
|
|
case 'CallExpression':
|
|
case 'NewExpression':
|
|
return node.type === 'SequenceExpression';
|
|
case 'IfStatement':
|
|
case 'DoWhileStatement':
|
|
case 'WhileStatement':
|
|
case 'ForStatement':
|
|
case 'SequenceExpression':
|
|
return false;
|
|
case 'ConditionalExpression':
|
|
if (previousNode === parent.test) {
|
|
return precedence(node) <= precedence(parent);
|
|
}
|
|
if (
|
|
previousNode === parent.consequent ||
|
|
previousNode === parent.alternate
|
|
) {
|
|
return (
|
|
precedence(node) < precedence({ type: 'AssignmentExpression' })
|
|
);
|
|
}
|
|
|
|
/* c8 ignore next */
|
|
throw new Error(
|
|
'Ternary child must be test, consequent, or alternate.'
|
|
);
|
|
case 'UnaryExpression':
|
|
return precedence(node) < precedence(parent);
|
|
case 'LogicalExpression':
|
|
if (astUtils.isMixedLogicalAndCoalesceExpressions(node, parent)) {
|
|
return true;
|
|
}
|
|
if (previousNode === parent.left) {
|
|
return precedence(node) < precedence(parent);
|
|
}
|
|
return precedence(node) <= precedence(parent);
|
|
|
|
/* c8 ignore next */
|
|
default:
|
|
throw new Error(`Unexpected parent type: ${parent.type}`);
|
|
}
|
|
}
|
|
|
|
return {
|
|
UnaryExpression(node) {
|
|
const parent = node.parent;
|
|
|
|
// Exit early if it's guaranteed not to match
|
|
if (
|
|
node.operator !== '!' ||
|
|
parent.type !== 'UnaryExpression' ||
|
|
parent.operator !== '!'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
if (isInFlaggedContext(parent)) {
|
|
context.report({
|
|
node: parent,
|
|
messageId: 'unexpectedNegation',
|
|
fix(fixer) {
|
|
if (hasCommentsInside(parent)) {
|
|
return null;
|
|
}
|
|
|
|
if (needsParens(parent, node.argument)) {
|
|
return fixer.replaceText(
|
|
parent,
|
|
`(${sourceCode.getText(node.argument)})`
|
|
);
|
|
}
|
|
|
|
let prefix = '';
|
|
const tokenBefore = sourceCode.getTokenBefore(parent);
|
|
const firstReplacementToken = sourceCode.getFirstToken(
|
|
node.argument
|
|
);
|
|
|
|
if (
|
|
tokenBefore &&
|
|
tokenBefore.range[1] === parent.range[0] &&
|
|
!astUtils.canTokensBeAdjacent(
|
|
tokenBefore,
|
|
firstReplacementToken
|
|
)
|
|
) {
|
|
prefix = ' ';
|
|
}
|
|
|
|
return fixer.replaceText(
|
|
parent,
|
|
prefix + sourceCode.getText(node.argument)
|
|
);
|
|
},
|
|
});
|
|
}
|
|
},
|
|
|
|
CallExpression(node) {
|
|
if (
|
|
node.callee.type !== 'Identifier' ||
|
|
node.callee.name !== 'Boolean'
|
|
) {
|
|
return;
|
|
}
|
|
|
|
if (isInFlaggedContext(node)) {
|
|
context.report({
|
|
node,
|
|
messageId: 'unexpectedCall',
|
|
fix(fixer) {
|
|
const parent = node.parent;
|
|
|
|
if (node.arguments.length === 0) {
|
|
if (
|
|
parent.type === 'UnaryExpression' &&
|
|
parent.operator === '!'
|
|
) {
|
|
/*
|
|
* !Boolean() -> true
|
|
*/
|
|
|
|
if (hasCommentsInside(parent)) {
|
|
return null;
|
|
}
|
|
|
|
const replacement = 'true';
|
|
let prefix = '';
|
|
const tokenBefore = sourceCode.getTokenBefore(parent);
|
|
|
|
if (
|
|
tokenBefore &&
|
|
tokenBefore.range[1] === parent.range[0] &&
|
|
!astUtils.canTokensBeAdjacent(tokenBefore, replacement)
|
|
) {
|
|
prefix = ' ';
|
|
}
|
|
|
|
return fixer.replaceText(parent, prefix + replacement);
|
|
}
|
|
|
|
/*
|
|
* Boolean() -> false
|
|
*/
|
|
|
|
if (hasCommentsInside(node)) {
|
|
return null;
|
|
}
|
|
|
|
return fixer.replaceText(node, 'false');
|
|
}
|
|
|
|
if (node.arguments.length === 1) {
|
|
const argument = node.arguments[0];
|
|
|
|
if (
|
|
argument.type === 'SpreadElement' ||
|
|
hasCommentsInside(node)
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Boolean(expression) -> expression
|
|
*/
|
|
|
|
if (needsParens(node, argument)) {
|
|
return fixer.replaceText(
|
|
node,
|
|
`(${sourceCode.getText(argument)})`
|
|
);
|
|
}
|
|
|
|
return fixer.replaceText(node, sourceCode.getText(argument));
|
|
}
|
|
|
|
// two or more arguments
|
|
return null;
|
|
},
|
|
});
|
|
}
|
|
},
|
|
};
|
|
},
|
|
};
|