/** * @fileoverview Require spaces around infix operators * @author Michael Ficarra * @deprecated in ESLint v8.53.0 */ "use strict"; const { isEqToken } = require("./utils/ast-utils"); //------------------------------------------------------------------------------ // Rule Definition //------------------------------------------------------------------------------ /** @type {import('../types').Rule.RuleModule} */ module.exports = { meta: { deprecated: { message: "Formatting rules are being moved out of ESLint core.", url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/", deprecatedSince: "8.53.0", availableUntil: "10.0.0", replacedBy: [ { message: "ESLint Stylistic now maintains deprecated stylistic core rules.", url: "https://eslint.style/guide/migration", plugin: { name: "@stylistic/eslint-plugin-js", url: "https://eslint.style/packages/js", }, rule: { name: "space-infix-ops", url: "https://eslint.style/rules/js/space-infix-ops", }, }, ], }, type: "layout", docs: { description: "Require spacing around infix operators", recommended: false, url: "https://eslint.org/docs/latest/rules/space-infix-ops", }, fixable: "whitespace", schema: [ { type: "object", properties: { int32Hint: { type: "boolean", default: false, }, }, additionalProperties: false, }, ], messages: { missingSpace: "Operator '{{operator}}' must be spaced.", }, }, create(context) { const int32Hint = context.options[0] ? context.options[0].int32Hint === true : false; const sourceCode = context.sourceCode; /** * Returns the first token which violates the rule * @param {ASTNode} left The left node of the main node * @param {ASTNode} right The right node of the main node * @param {string} op The operator of the main node * @returns {Object} The violator token or null * @private */ function getFirstNonSpacedToken(left, right, op) { const operator = sourceCode.getFirstTokenBetween( left, right, token => token.value === op, ); const prev = sourceCode.getTokenBefore(operator); const next = sourceCode.getTokenAfter(operator); if ( !sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next) ) { return operator; } return null; } /** * Reports an AST node as a rule violation * @param {ASTNode} mainNode The node to report * @param {Object} culpritToken The token which has a problem * @returns {void} * @private */ function report(mainNode, culpritToken) { context.report({ node: mainNode, loc: culpritToken.loc, messageId: "missingSpace", data: { operator: culpritToken.value, }, fix(fixer) { const previousToken = sourceCode.getTokenBefore(culpritToken); const afterToken = sourceCode.getTokenAfter(culpritToken); let fixString = ""; if (culpritToken.range[0] - previousToken.range[1] === 0) { fixString = " "; } fixString += culpritToken.value; if (afterToken.range[0] - culpritToken.range[1] === 0) { fixString += " "; } return fixer.replaceText(culpritToken, fixString); }, }); } /** * Check if the node is binary then report * @param {ASTNode} node node to evaluate * @returns {void} * @private */ function checkBinary(node) { const leftNode = node.left.typeAnnotation ? node.left.typeAnnotation : node.left; const rightNode = node.right; // search for = in AssignmentPattern nodes const operator = node.operator || "="; const nonSpacedNode = getFirstNonSpacedToken( leftNode, rightNode, operator, ); if (nonSpacedNode) { if (!(int32Hint && sourceCode.getText(node).endsWith("|0"))) { report(node, nonSpacedNode); } } } /** * Check if the node is conditional * @param {ASTNode} node node to evaluate * @returns {void} * @private */ function checkConditional(node) { const nonSpacedConsequentNode = getFirstNonSpacedToken( node.test, node.consequent, "?", ); const nonSpacedAlternateNode = getFirstNonSpacedToken( node.consequent, node.alternate, ":", ); if (nonSpacedConsequentNode) { report(node, nonSpacedConsequentNode); } if (nonSpacedAlternateNode) { report(node, nonSpacedAlternateNode); } } /** * Check if the node is a variable * @param {ASTNode} node node to evaluate * @returns {void} * @private */ function checkVar(node) { const leftNode = node.id.typeAnnotation ? node.id.typeAnnotation : node.id; const rightNode = node.init; if (rightNode) { const nonSpacedNode = getFirstNonSpacedToken( leftNode, rightNode, "=", ); if (nonSpacedNode) { report(node, nonSpacedNode); } } } return { AssignmentExpression: checkBinary, AssignmentPattern: checkBinary, BinaryExpression: checkBinary, LogicalExpression: checkBinary, ConditionalExpression: checkConditional, VariableDeclarator: checkVar, PropertyDefinition(node) { if (!node.value) { return; } /* * Because of computed properties and type annotations, some * tokens may exist between `node.key` and `=`. * Therefore, find the `=` from the right. */ const operatorToken = sourceCode.getTokenBefore( node.value, isEqToken, ); const leftToken = sourceCode.getTokenBefore(operatorToken); const rightToken = sourceCode.getTokenAfter(operatorToken); if ( !sourceCode.isSpaceBetweenTokens( leftToken, operatorToken, ) || !sourceCode.isSpaceBetweenTokens(operatorToken, rightToken) ) { report(node, operatorToken); } }, }; }, };