%PDF-
%PDF-
Mini Shell
Mini Shell
/**
* @fileoverview Rule to flag no-unneeded-ternary
* @author Gyandeep Singh
*/
"use strict";
const astUtils = require("./utils/ast-utils");
// Operators that always result in a boolean value
const BOOLEAN_OPERATORS = new Set([
"==",
"===",
"!=",
"!==",
">",
">=",
"<",
"<=",
"in",
"instanceof",
]);
const OPERATOR_INVERSES = {
"==": "!=",
"!=": "==",
"===": "!==",
"!==": "===",
// Operators like < and >= are not true inverses, since both will return false with NaN.
};
const OR_PRECEDENCE = astUtils.getPrecedence({
type: "LogicalExpression",
operator: "||",
});
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
type: "suggestion",
defaultOptions: [{ defaultAssignment: true }],
docs: {
description:
"Disallow ternary operators when simpler alternatives exist",
recommended: false,
frozen: true,
url: "https://eslint.org/docs/latest/rules/no-unneeded-ternary",
},
schema: [
{
type: "object",
properties: {
defaultAssignment: {
type: "boolean",
},
},
additionalProperties: false,
},
],
fixable: "code",
messages: {
unnecessaryConditionalExpression:
"Unnecessary use of boolean literals in conditional expression.",
unnecessaryConditionalAssignment:
"Unnecessary use of conditional expression for default assignment.",
},
},
create(context) {
const [{ defaultAssignment }] = context.options;
const sourceCode = context.sourceCode;
/**
* Test if the node is a boolean literal
* @param {ASTNode} node The node to report.
* @returns {boolean} True if the its a boolean literal
* @private
*/
function isBooleanLiteral(node) {
return node.type === "Literal" && typeof node.value === "boolean";
}
/**
* Creates an expression that represents the boolean inverse of the expression represented by the original node
* @param {ASTNode} node A node representing an expression
* @returns {string} A string representing an inverted expression
*/
function invertExpression(node) {
if (
node.type === "BinaryExpression" &&
Object.hasOwn(OPERATOR_INVERSES, node.operator)
) {
const operatorToken = sourceCode.getFirstTokenBetween(
node.left,
node.right,
token => token.value === node.operator,
);
const text = sourceCode.getText();
return (
text.slice(node.range[0], operatorToken.range[0]) +
OPERATOR_INVERSES[node.operator] +
text.slice(operatorToken.range[1], node.range[1])
);
}
if (
astUtils.getPrecedence(node) <
astUtils.getPrecedence({ type: "UnaryExpression" })
) {
return `!(${astUtils.getParenthesisedText(sourceCode, node)})`;
}
return `!${astUtils.getParenthesisedText(sourceCode, node)}`;
}
/**
* Tests if a given node always evaluates to a boolean value
* @param {ASTNode} node An expression node
* @returns {boolean} True if it is determined that the node will always evaluate to a boolean value
*/
function isBooleanExpression(node) {
return (
(node.type === "BinaryExpression" &&
BOOLEAN_OPERATORS.has(node.operator)) ||
(node.type === "UnaryExpression" && node.operator === "!")
);
}
/**
* Test if the node matches the pattern id ? id : expression
* @param {ASTNode} node The ConditionalExpression to check.
* @returns {boolean} True if the pattern is matched, and false otherwise
* @private
*/
function matchesDefaultAssignment(node) {
return (
node.test.type === "Identifier" &&
node.consequent.type === "Identifier" &&
node.test.name === node.consequent.name
);
}
return {
ConditionalExpression(node) {
if (
isBooleanLiteral(node.alternate) &&
isBooleanLiteral(node.consequent)
) {
context.report({
node,
messageId: "unnecessaryConditionalExpression",
fix(fixer) {
if (
node.consequent.value === node.alternate.value
) {
// Replace `foo ? true : true` with just `true`, but don't replace `foo() ? true : true`
return node.test.type === "Identifier"
? fixer.replaceText(
node,
node.consequent.value.toString(),
)
: null;
}
if (node.alternate.value) {
// Replace `foo() ? false : true` with `!(foo())`
return fixer.replaceText(
node,
invertExpression(node.test),
);
}
// Replace `foo ? true : false` with `foo` if `foo` is guaranteed to be a boolean, or `!!foo` otherwise.
return fixer.replaceText(
node,
isBooleanExpression(node.test)
? astUtils.getParenthesisedText(
sourceCode,
node.test,
)
: `!${invertExpression(node.test)}`,
);
},
});
} else if (
!defaultAssignment &&
matchesDefaultAssignment(node)
) {
context.report({
node,
messageId: "unnecessaryConditionalAssignment",
fix(fixer) {
const shouldParenthesizeAlternate =
(astUtils.getPrecedence(node.alternate) <
OR_PRECEDENCE ||
astUtils.isCoalesceExpression(
node.alternate,
)) &&
!astUtils.isParenthesised(
sourceCode,
node.alternate,
);
const alternateText = shouldParenthesizeAlternate
? `(${sourceCode.getText(node.alternate)})`
: astUtils.getParenthesisedText(
sourceCode,
node.alternate,
);
const testText = astUtils.getParenthesisedText(
sourceCode,
node.test,
);
return fixer.replaceText(
node,
`${testText} || ${alternateText}`,
);
},
});
}
},
};
},
};
Zerion Mini Shell 1.0