Add components
This commit is contained in:
688
slider/node_modules/eslint/lib/rules/logical-assignment-operators.js
generated
vendored
Normal file
688
slider/node_modules/eslint/lib/rules/logical-assignment-operators.js
generated
vendored
Normal file
@@ -0,0 +1,688 @@
|
||||
/**
|
||||
* @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,
|
||||
),
|
||||
);
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
Reference in New Issue
Block a user