613 lines
20 KiB
JavaScript
613 lines
20 KiB
JavaScript
/**
|
|
* @fileoverview Rule to replace assignment expressions with logical operator assignment
|
|
* @author Daniel Martens
|
|
*/
|
|
'use strict';
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
const astUtils = require('./utils/ast-utils.js');
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helpers
|
|
//------------------------------------------------------------------------------
|
|
|
|
const baseTypes = new Set(['Identifier', 'Super', 'ThisExpression']);
|
|
|
|
/**
|
|
* Returns true iff either "undefined" or a void expression (eg. "void 0")
|
|
* @param {ASTNode} expression Expression to check
|
|
* @param {import('eslint-scope').Scope} scope Scope of the expression
|
|
* @returns {boolean} True iff "undefined" or "void ..."
|
|
*/
|
|
function isUndefined(expression, scope) {
|
|
if (expression.type === 'Identifier' && expression.name === 'undefined') {
|
|
return astUtils.isReferenceToGlobalVariable(scope, expression);
|
|
}
|
|
|
|
return (
|
|
expression.type === 'UnaryExpression' &&
|
|
expression.operator === 'void' &&
|
|
expression.argument.type === 'Literal' &&
|
|
expression.argument.value === 0
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true iff the reference is either an identifier or member expression
|
|
* @param {ASTNode} expression Expression to check
|
|
* @returns {boolean} True for identifiers and member expressions
|
|
*/
|
|
function isReference(expression) {
|
|
return (
|
|
(expression.type === 'Identifier' && expression.name !== 'undefined') ||
|
|
expression.type === 'MemberExpression'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true iff the expression checks for nullish with loose equals.
|
|
* Examples: value == null, value == void 0
|
|
* @param {ASTNode} expression Test condition
|
|
* @param {import('eslint-scope').Scope} scope Scope of the expression
|
|
* @returns {boolean} True iff implicit nullish comparison
|
|
*/
|
|
function isImplicitNullishComparison(expression, scope) {
|
|
if (expression.type !== 'BinaryExpression' || expression.operator !== '==') {
|
|
return false;
|
|
}
|
|
|
|
const reference = isReference(expression.left) ? 'left' : 'right';
|
|
const nullish = reference === 'left' ? 'right' : 'left';
|
|
|
|
return (
|
|
isReference(expression[reference]) &&
|
|
(astUtils.isNullLiteral(expression[nullish]) ||
|
|
isUndefined(expression[nullish], scope))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Condition with two equal comparisons.
|
|
* @param {ASTNode} expression Condition
|
|
* @returns {boolean} True iff matches ? === ? || ? === ?
|
|
*/
|
|
function isDoubleComparison(expression) {
|
|
return (
|
|
expression.type === 'LogicalExpression' &&
|
|
expression.operator === '||' &&
|
|
expression.left.type === 'BinaryExpression' &&
|
|
expression.left.operator === '===' &&
|
|
expression.right.type === 'BinaryExpression' &&
|
|
expression.right.operator === '==='
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true iff the expression checks for undefined and null.
|
|
* Example: value === null || value === undefined
|
|
* @param {ASTNode} expression Test condition
|
|
* @param {import('eslint-scope').Scope} scope Scope of the expression
|
|
* @returns {boolean} True iff explicit nullish comparison
|
|
*/
|
|
function isExplicitNullishComparison(expression, scope) {
|
|
if (!isDoubleComparison(expression)) {
|
|
return false;
|
|
}
|
|
const leftReference = isReference(expression.left.left) ? 'left' : 'right';
|
|
const leftNullish = leftReference === 'left' ? 'right' : 'left';
|
|
const rightReference = isReference(expression.right.left) ? 'left' : 'right';
|
|
const rightNullish = rightReference === 'left' ? 'right' : 'left';
|
|
|
|
return (
|
|
astUtils.isSameReference(
|
|
expression.left[leftReference],
|
|
expression.right[rightReference]
|
|
) &&
|
|
((astUtils.isNullLiteral(expression.left[leftNullish]) &&
|
|
isUndefined(expression.right[rightNullish], scope)) ||
|
|
(isUndefined(expression.left[leftNullish], scope) &&
|
|
astUtils.isNullLiteral(expression.right[rightNullish])))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true for Boolean(arg) calls
|
|
* @param {ASTNode} expression Test condition
|
|
* @param {import('eslint-scope').Scope} scope Scope of the expression
|
|
* @returns {boolean} Whether the expression is a boolean cast
|
|
*/
|
|
function isBooleanCast(expression, scope) {
|
|
return (
|
|
expression.type === 'CallExpression' &&
|
|
expression.callee.name === 'Boolean' &&
|
|
expression.arguments.length === 1 &&
|
|
astUtils.isReferenceToGlobalVariable(scope, expression.callee)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true for:
|
|
* truthiness checks: value, Boolean(value), !!value
|
|
* falsiness checks: !value, !Boolean(value)
|
|
* nullish checks: value == null, value === undefined || value === null
|
|
* @param {ASTNode} expression Test condition
|
|
* @param {import('eslint-scope').Scope} scope Scope of the expression
|
|
* @returns {?{ reference: ASTNode, operator: '??'|'||'|'&&'}} Null if not a known existence
|
|
*/
|
|
function getExistence(expression, scope) {
|
|
const isNegated =
|
|
expression.type === 'UnaryExpression' && expression.operator === '!';
|
|
const base = isNegated ? expression.argument : expression;
|
|
|
|
switch (true) {
|
|
case isReference(base):
|
|
return { reference: base, operator: isNegated ? '||' : '&&' };
|
|
case base.type === 'UnaryExpression' &&
|
|
base.operator === '!' &&
|
|
isReference(base.argument):
|
|
return { reference: base.argument, operator: '&&' };
|
|
case isBooleanCast(base, scope) && isReference(base.arguments[0]):
|
|
return {
|
|
reference: base.arguments[0],
|
|
operator: isNegated ? '||' : '&&',
|
|
};
|
|
case isImplicitNullishComparison(expression, scope):
|
|
return {
|
|
reference:
|
|
isReference(expression.left) ? expression.left : expression.right,
|
|
operator: '??',
|
|
};
|
|
case isExplicitNullishComparison(expression, scope):
|
|
return {
|
|
reference:
|
|
isReference(expression.left.left) ?
|
|
expression.left.left
|
|
: expression.left.right,
|
|
operator: '??',
|
|
};
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true iff the node is inside a with block
|
|
* @param {ASTNode} node Node to check
|
|
* @returns {boolean} True iff passed node is inside a with block
|
|
*/
|
|
function isInsideWithBlock(node) {
|
|
if (node.type === 'Program') {
|
|
return false;
|
|
}
|
|
|
|
return node.parent.type === 'WithStatement' && node.parent.body === node ?
|
|
true
|
|
: isInsideWithBlock(node.parent);
|
|
}
|
|
|
|
/**
|
|
* Gets the leftmost operand of a consecutive logical expression.
|
|
* @param {SourceCode} sourceCode The ESLint source code object
|
|
* @param {LogicalExpression} node LogicalExpression
|
|
* @returns {Expression} Leftmost operand
|
|
*/
|
|
function getLeftmostOperand(sourceCode, node) {
|
|
let left = node.left;
|
|
|
|
while (left.type === 'LogicalExpression' && left.operator === node.operator) {
|
|
if (astUtils.isParenthesised(sourceCode, left)) {
|
|
/*
|
|
* It should have associativity,
|
|
* but ignore it if use parentheses to make the evaluation order clear.
|
|
*/
|
|
return left;
|
|
}
|
|
left = left.left;
|
|
}
|
|
return left;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
/** @type {import('../types').Rule.RuleModule} */
|
|
module.exports = {
|
|
meta: {
|
|
type: 'suggestion',
|
|
|
|
docs: {
|
|
description: 'Require or disallow logical assignment operator shorthand',
|
|
recommended: false,
|
|
frozen: true,
|
|
url: 'https://eslint.org/docs/latest/rules/logical-assignment-operators',
|
|
},
|
|
|
|
schema: {
|
|
type: 'array',
|
|
oneOf: [
|
|
{
|
|
items: [
|
|
{ const: 'always' },
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
enforceForIfStatements: {
|
|
type: 'boolean',
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
minItems: 0, // 0 for allowing passing no options
|
|
maxItems: 2,
|
|
},
|
|
{
|
|
items: [{ const: 'never' }],
|
|
minItems: 1,
|
|
maxItems: 1,
|
|
},
|
|
],
|
|
},
|
|
fixable: 'code',
|
|
hasSuggestions: true,
|
|
messages: {
|
|
assignment:
|
|
'Assignment (=) can be replaced with operator assignment ({{operator}}).',
|
|
useLogicalOperator:
|
|
'Convert this assignment to use the operator {{ operator }}.',
|
|
logical:
|
|
'Logical expression can be replaced with an assignment ({{ operator }}).',
|
|
convertLogical:
|
|
'Replace this logical expression with an assignment with the operator {{ operator }}.',
|
|
if: "'if' statement can be replaced with a logical operator assignment with operator {{ operator }}.",
|
|
convertIf:
|
|
"Replace this 'if' statement with a logical assignment with operator {{ operator }}.",
|
|
unexpected:
|
|
'Unexpected logical operator assignment ({{operator}}) shorthand.',
|
|
separate:
|
|
'Separate the logical assignment into an assignment with a logical operator.',
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const mode = context.options[0] === 'never' ? 'never' : 'always';
|
|
const checkIf =
|
|
mode === 'always' &&
|
|
context.options.length > 1 &&
|
|
context.options[1].enforceForIfStatements;
|
|
const sourceCode = context.sourceCode;
|
|
const isStrict = sourceCode.getScope(sourceCode.ast).isStrict;
|
|
|
|
/**
|
|
* Returns false if the access could be a getter
|
|
* @param {ASTNode} node Assignment expression
|
|
* @returns {boolean} True iff the fix is safe
|
|
*/
|
|
function cannotBeGetter(node) {
|
|
return (
|
|
node.type === 'Identifier' && (isStrict || !isInsideWithBlock(node))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check whether only a single property is accessed
|
|
* @param {ASTNode} node reference
|
|
* @returns {boolean} True iff a single property is accessed
|
|
*/
|
|
function accessesSingleProperty(node) {
|
|
if (!isStrict && isInsideWithBlock(node)) {
|
|
return node.type === 'Identifier';
|
|
}
|
|
|
|
return (
|
|
node.type === 'MemberExpression' &&
|
|
baseTypes.has(node.object.type) &&
|
|
(!node.computed ||
|
|
(node.property.type !== 'MemberExpression' &&
|
|
node.property.type !== 'ChainExpression'))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Adds a fixer or suggestion whether on the fix is safe.
|
|
* @param {{ messageId: string, node: ASTNode }} descriptor Report descriptor without fix or suggest
|
|
* @param {{ messageId: string, fix: Function }} suggestion Adds the fix or the whole suggestion as only element in "suggest" to suggestion
|
|
* @param {boolean} shouldBeFixed Fix iff the condition is true
|
|
* @returns {Object} Descriptor with either an added fix or suggestion
|
|
*/
|
|
function createConditionalFixer(descriptor, suggestion, shouldBeFixed) {
|
|
if (shouldBeFixed) {
|
|
return {
|
|
...descriptor,
|
|
fix: suggestion.fix,
|
|
};
|
|
}
|
|
|
|
return {
|
|
...descriptor,
|
|
suggest: [suggestion],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns the operator token for assignments and binary expressions
|
|
* @param {ASTNode} node AssignmentExpression or BinaryExpression
|
|
* @returns {import('eslint').AST.Token} Operator token between the left and right expression
|
|
*/
|
|
function getOperatorToken(node) {
|
|
return sourceCode.getFirstTokenBetween(
|
|
node.left,
|
|
node.right,
|
|
(token) => token.value === node.operator
|
|
);
|
|
}
|
|
|
|
if (mode === 'never') {
|
|
return {
|
|
// foo ||= bar
|
|
AssignmentExpression(assignment) {
|
|
if (!astUtils.isLogicalAssignmentOperator(assignment.operator)) {
|
|
return;
|
|
}
|
|
|
|
const descriptor = {
|
|
messageId: 'unexpected',
|
|
node: assignment,
|
|
data: { operator: assignment.operator },
|
|
};
|
|
const suggestion = {
|
|
messageId: 'separate',
|
|
*fix(ruleFixer) {
|
|
if (sourceCode.getCommentsInside(assignment).length > 0) {
|
|
return;
|
|
}
|
|
|
|
const operatorToken = getOperatorToken(assignment);
|
|
|
|
// -> foo = bar
|
|
yield ruleFixer.replaceText(operatorToken, '=');
|
|
|
|
const assignmentText = sourceCode.getText(assignment.left);
|
|
const operator = assignment.operator.slice(0, -1);
|
|
|
|
// -> foo = foo || bar
|
|
yield ruleFixer.insertTextAfter(
|
|
operatorToken,
|
|
` ${assignmentText} ${operator}`
|
|
);
|
|
|
|
const precedence =
|
|
astUtils.getPrecedence(assignment.right) <=
|
|
astUtils.getPrecedence({
|
|
type: 'LogicalExpression',
|
|
operator,
|
|
});
|
|
|
|
// ?? and || / && cannot be mixed but have same precedence
|
|
const mixed =
|
|
assignment.operator === '??=' &&
|
|
astUtils.isLogicalExpression(assignment.right);
|
|
|
|
if (
|
|
!astUtils.isParenthesised(sourceCode, assignment.right) &&
|
|
(precedence || mixed)
|
|
) {
|
|
// -> foo = foo || (bar)
|
|
yield ruleFixer.insertTextBefore(assignment.right, '(');
|
|
yield ruleFixer.insertTextAfter(assignment.right, ')');
|
|
}
|
|
},
|
|
};
|
|
|
|
context.report(
|
|
createConditionalFixer(
|
|
descriptor,
|
|
suggestion,
|
|
cannotBeGetter(assignment.left)
|
|
)
|
|
);
|
|
},
|
|
};
|
|
}
|
|
|
|
return {
|
|
// foo = foo || bar
|
|
"AssignmentExpression[operator='='][right.type='LogicalExpression']"(
|
|
assignment
|
|
) {
|
|
const leftOperand = getLeftmostOperand(sourceCode, assignment.right);
|
|
|
|
if (!astUtils.isSameReference(assignment.left, leftOperand)) {
|
|
return;
|
|
}
|
|
|
|
const descriptor = {
|
|
messageId: 'assignment',
|
|
node: assignment,
|
|
data: { operator: `${assignment.right.operator}=` },
|
|
};
|
|
const suggestion = {
|
|
messageId: 'useLogicalOperator',
|
|
data: { operator: `${assignment.right.operator}=` },
|
|
*fix(ruleFixer) {
|
|
if (sourceCode.getCommentsInside(assignment).length > 0) {
|
|
return;
|
|
}
|
|
|
|
// No need for parenthesis around the assignment based on precedence as the precedence stays the same even with changed operator
|
|
const assignmentOperatorToken = getOperatorToken(assignment);
|
|
|
|
// -> foo ||= foo || bar
|
|
yield ruleFixer.insertTextBefore(
|
|
assignmentOperatorToken,
|
|
assignment.right.operator
|
|
);
|
|
|
|
// -> foo ||= bar
|
|
const logicalOperatorToken = getOperatorToken(leftOperand.parent);
|
|
const firstRightOperandToken =
|
|
sourceCode.getTokenAfter(logicalOperatorToken);
|
|
|
|
yield ruleFixer.removeRange([
|
|
leftOperand.parent.range[0],
|
|
firstRightOperandToken.range[0],
|
|
]);
|
|
},
|
|
};
|
|
|
|
context.report(
|
|
createConditionalFixer(
|
|
descriptor,
|
|
suggestion,
|
|
cannotBeGetter(assignment.left)
|
|
)
|
|
);
|
|
},
|
|
|
|
// foo || (foo = bar)
|
|
'LogicalExpression[right.type="AssignmentExpression"][right.operator="="]'(
|
|
logical
|
|
) {
|
|
// Right side has to be parenthesized, otherwise would be parsed as (foo || foo) = bar which is illegal
|
|
if (
|
|
isReference(logical.left) &&
|
|
astUtils.isSameReference(logical.left, logical.right.left)
|
|
) {
|
|
const descriptor = {
|
|
messageId: 'logical',
|
|
node: logical,
|
|
data: { operator: `${logical.operator}=` },
|
|
};
|
|
const suggestion = {
|
|
messageId: 'convertLogical',
|
|
data: { operator: `${logical.operator}=` },
|
|
*fix(ruleFixer) {
|
|
if (sourceCode.getCommentsInside(logical).length > 0) {
|
|
return;
|
|
}
|
|
|
|
const parentPrecedence = astUtils.getPrecedence(logical.parent);
|
|
const requiresOuterParenthesis =
|
|
logical.parent.type !== 'ExpressionStatement' &&
|
|
(parentPrecedence === -1 ||
|
|
astUtils.getPrecedence({
|
|
type: 'AssignmentExpression',
|
|
}) < parentPrecedence);
|
|
|
|
if (
|
|
!astUtils.isParenthesised(sourceCode, logical) &&
|
|
requiresOuterParenthesis
|
|
) {
|
|
yield ruleFixer.insertTextBefore(logical, '(');
|
|
yield ruleFixer.insertTextAfter(logical, ')');
|
|
}
|
|
|
|
// Also removes all opening parenthesis
|
|
yield ruleFixer.removeRange([
|
|
logical.range[0],
|
|
logical.right.range[0],
|
|
]); // -> foo = bar)
|
|
|
|
// Also removes all ending parenthesis
|
|
yield ruleFixer.removeRange([
|
|
logical.right.range[1],
|
|
logical.range[1],
|
|
]); // -> foo = bar
|
|
|
|
const operatorToken = getOperatorToken(logical.right);
|
|
|
|
yield ruleFixer.insertTextBefore(operatorToken, logical.operator); // -> foo ||= bar
|
|
},
|
|
};
|
|
const fix =
|
|
cannotBeGetter(logical.left) ||
|
|
accessesSingleProperty(logical.left);
|
|
|
|
context.report(createConditionalFixer(descriptor, suggestion, fix));
|
|
}
|
|
},
|
|
|
|
// if (foo) foo = bar
|
|
'IfStatement[alternate=null]'(ifNode) {
|
|
if (!checkIf) {
|
|
return;
|
|
}
|
|
|
|
const hasBody = ifNode.consequent.type === 'BlockStatement';
|
|
|
|
if (hasBody && ifNode.consequent.body.length !== 1) {
|
|
return;
|
|
}
|
|
|
|
const body = hasBody ? ifNode.consequent.body[0] : ifNode.consequent;
|
|
const scope = sourceCode.getScope(ifNode);
|
|
const existence = getExistence(ifNode.test, scope);
|
|
|
|
if (
|
|
body.type === 'ExpressionStatement' &&
|
|
body.expression.type === 'AssignmentExpression' &&
|
|
body.expression.operator === '=' &&
|
|
existence !== null &&
|
|
astUtils.isSameReference(existence.reference, body.expression.left)
|
|
) {
|
|
const descriptor = {
|
|
messageId: 'if',
|
|
node: ifNode,
|
|
data: { operator: `${existence.operator}=` },
|
|
};
|
|
const suggestion = {
|
|
messageId: 'convertIf',
|
|
data: { operator: `${existence.operator}=` },
|
|
*fix(ruleFixer) {
|
|
if (sourceCode.getCommentsInside(ifNode).length > 0) {
|
|
return;
|
|
}
|
|
|
|
const firstBodyToken = sourceCode.getFirstToken(body);
|
|
const prevToken = sourceCode.getTokenBefore(ifNode);
|
|
|
|
if (
|
|
prevToken !== null &&
|
|
prevToken.value !== ';' &&
|
|
prevToken.value !== '{' &&
|
|
firstBodyToken.type !== 'Identifier' &&
|
|
firstBodyToken.type !== 'Keyword'
|
|
) {
|
|
// Do not fix if the fixed statement could be part of the previous statement (eg. fn() if (a == null) (a) = b --> fn()(a) ??= b)
|
|
return;
|
|
}
|
|
|
|
const operatorToken = getOperatorToken(body.expression);
|
|
|
|
yield ruleFixer.insertTextBefore(
|
|
operatorToken,
|
|
existence.operator
|
|
); // -> if (foo) foo ||= bar
|
|
|
|
yield ruleFixer.removeRange([ifNode.range[0], body.range[0]]); // -> foo ||= bar
|
|
|
|
yield ruleFixer.removeRange([body.range[1], ifNode.range[1]]); // -> foo ||= bar, only present if "if" had a body
|
|
|
|
const nextToken = sourceCode.getTokenAfter(body.expression);
|
|
|
|
if (hasBody && nextToken !== null && nextToken.value !== ';') {
|
|
yield ruleFixer.insertTextAfter(ifNode, ';');
|
|
}
|
|
},
|
|
};
|
|
const shouldBeFixed =
|
|
cannotBeGetter(existence.reference) ||
|
|
(ifNode.test.type !== 'LogicalExpression' &&
|
|
accessesSingleProperty(existence.reference));
|
|
|
|
context.report(
|
|
createConditionalFixer(descriptor, suggestion, shouldBeFixed)
|
|
);
|
|
}
|
|
},
|
|
};
|
|
},
|
|
};
|