node_modules/eslint/lib/rules/logical-assignment-operators.js - devtools/devtools-frontend.git - Git at Google

 /**
  * @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,
 						),
 					);
 				}
 			},
 		};
 	},
 };
	/**
	* @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,
	),
	);
	}
	},
	};
	},
	};