eslint 9.22.0 → 9.24.0

package/lib/rules/no-implicit-coercion.js

@@ -20,11 +20,11 @@ const ALLOWABLE_OPERATORS = ["~", "!!", "+", "- -", "-", "*"];
  * @returns {boolean} Whether or not the node is a double logical negating.
  */
 function isDoubleLogicalNegating(node) {
-    return (
-        node.operator === "!" &&
-        node.argument.type === "UnaryExpression" &&
-        node.argument.operator === "!"
-    );
+	return (
+		node.operator === "!" &&
+		node.argument.type === "UnaryExpression" &&
+		node.argument.operator === "!"
+	);
 }
 
 /**
@@ -33,15 +33,15 @@ function isDoubleLogicalNegating(node) {
  * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
  */
 function isBinaryNegatingOfIndexOf(node) {
-    if (node.operator !== "~") {
-        return false;
-    }
-    const callNode = astUtils.skipChainExpression(node.argument);
-
-    return (
-        callNode.type === "CallExpression" &&
-        astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN)
-    );
+	if (node.operator !== "~") {
+		return false;
+	}
+	const callNode = astUtils.skipChainExpression(node.argument);
+
+	return (
+		callNode.type === "CallExpression" &&
+		astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN)
+	);
 }
 
 /**
@@ -50,10 +50,11 @@ function isBinaryNegatingOfIndexOf(node) {
  * @returns {boolean} Whether or not the node is a multiplying by one.
  */
 function isMultiplyByOne(node) {
-    return node.operator === "*" && (
-        node.left.type === "Literal" && node.left.value === 1 ||
-        node.right.type === "Literal" && node.right.value === 1
-    );
+	return (
+		node.operator === "*" &&
+		((node.left.type === "Literal" && node.left.value === 1) ||
+			(node.right.type === "Literal" && node.right.value === 1))
+	);
 }
 
 /**
@@ -65,13 +66,16 @@ function isMultiplyByOne(node) {
  * @returns {boolean} Whether or not the node is a multiplying by a fraction of `1`.
  */
 function isMultiplyByFractionOfOne(node, sourceCode) {
-    return node.type === "BinaryExpression" &&
-        node.operator === "*" &&
-        (node.right.type === "Literal" && node.right.value === 1) &&
-        node.parent.type === "BinaryExpression" &&
-        node.parent.operator === "/" &&
-        node.parent.left === node &&
-        !astUtils.isParenthesised(sourceCode, node);
+	return (
+		node.type === "BinaryExpression" &&
+		node.operator === "*" &&
+		node.right.type === "Literal" &&
+		node.right.value === 1 &&
+		node.parent.type === "BinaryExpression" &&
+		node.parent.operator === "/" &&
+		node.parent.left === node &&
+		!astUtils.isParenthesised(sourceCode, node)
+	);
 }
 
 /**
@@ -80,14 +84,13 @@ function isMultiplyByFractionOfOne(node, sourceCode) {
  * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call
  */
 function isNumeric(node) {
-    return (
-        node.type === "Literal" && typeof node.value === "number" ||
-        node.type === "CallExpression" && (
-            node.callee.name === "Number" ||
-            node.callee.name === "parseInt" ||
-            node.callee.name === "parseFloat"
-        )
-    );
+	return (
+		(node.type === "Literal" && typeof node.value === "number") ||
+		(node.type === "CallExpression" &&
+			(node.callee.name === "Number" ||
+				node.callee.name === "parseInt" ||
+				node.callee.name === "parseFloat"))
+	);
 }
 
 /**
@@ -98,18 +101,18 @@ function isNumeric(node) {
  * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null
  */
 function getNonNumericOperand(node) {
-    const left = node.left,
-        right = node.right;
+	const left = node.left,
+		right = node.right;
 
-    if (right.type !== "BinaryExpression" && !isNumeric(right)) {
-        return right;
-    }
+	if (right.type !== "BinaryExpression" && !isNumeric(right)) {
+		return right;
+	}
 
-    if (left.type !== "BinaryExpression" && !isNumeric(left)) {
-        return left;
-    }
+	if (left.type !== "BinaryExpression" && !isNumeric(left)) {
+		return left;
+	}
 
-    return null;
+	return null;
 }
 
 /**
@@ -118,12 +121,12 @@ function getNonNumericOperand(node) {
  * @returns {boolean} Whether or not the expression evaluates to a string.
  */
 function isStringType(node) {
-    return astUtils.isStringLiteral(node) ||
-        (
-            node.type === "CallExpression" &&
-            node.callee.type === "Identifier" &&
-            node.callee.name === "String"
-        );
+	return (
+		astUtils.isStringLiteral(node) ||
+		(node.type === "CallExpression" &&
+			node.callee.type === "Identifier" &&
+			node.callee.name === "String")
+	);
 }
 
 /**
@@ -133,7 +136,13 @@ function isStringType(node) {
  * empty string literal or not.
  */
 function isEmptyString(node) {
-    return astUtils.isStringLiteral(node) && (node.value === "" || (node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === ""));
+	return (
+		astUtils.isStringLiteral(node) &&
+		(node.value === "" ||
+			(node.type === "TemplateLiteral" &&
+				node.quasis.length === 1 &&
+				node.quasis[0].value.cooked === ""))
+	);
 }
 
 /**
@@ -142,10 +151,11 @@ function isEmptyString(node) {
  * @returns {boolean} Whether or not the node is a concatenating with an empty string.
  */
 function isConcatWithEmptyString(node) {
-    return node.operator === "+" && (
-        (isEmptyString(node.left) && !isStringType(node.right)) ||
-        (isEmptyString(node.right) && !isStringType(node.left))
-    );
+	return (
+		node.operator === "+" &&
+		((isEmptyString(node.left) && !isStringType(node.right)) ||
+			(isEmptyString(node.right) && !isStringType(node.left)))
+	);
 }
 
 /**
@@ -154,7 +164,7 @@ function isConcatWithEmptyString(node) {
  * @returns {boolean} Whether or not the node is appended with an empty string.
  */
 function isAppendEmptyString(node) {
-    return node.operator === "+=" && isEmptyString(node.right);
+	return node.operator === "+=" && isEmptyString(node.right);
 }
 
 /**
@@ -163,250 +173,296 @@ function isAppendEmptyString(node) {
  * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
  */
 function getNonEmptyOperand(node) {
-    return isEmptyString(node.left) ? node.right : node.left;
+	return isEmptyString(node.left) ? node.right : node.left;
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        hasSuggestions: true,
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow shorthand type conversions",
-            recommended: false,
-            frozen: true,
-            url: "https://eslint.org/docs/latest/rules/no-implicit-coercion"
-        },
-
-        fixable: "code",
-
-        schema: [{
-            type: "object",
-            properties: {
-                boolean: {
-                    type: "boolean"
-                },
-                number: {
-                    type: "boolean"
-                },
-                string: {
-                    type: "boolean"
-                },
-                disallowTemplateShorthand: {
-                    type: "boolean"
-                },
-                allow: {
-                    type: "array",
-                    items: {
-                        enum: ALLOWABLE_OPERATORS
-                    },
-                    uniqueItems: true
-                }
-            },
-            additionalProperties: false
-        }],
-
-        defaultOptions: [{
-            allow: [],
-            boolean: true,
-            disallowTemplateShorthand: false,
-            number: true,
-            string: true
-        }],
-
-        messages: {
-            implicitCoercion: "Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
-            useRecommendation: "Use `{{recommendation}}` instead."
-        }
-    },
-
-    create(context) {
-        const [options] = context.options;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports an error and autofixes the node
-         * @param {ASTNode} node An ast node to report the error on.
-         * @param {string} recommendation The recommended code for the issue
-         * @param {bool} shouldSuggest Whether this report should offer a suggestion
-         * @param {bool} shouldFix Whether this report should fix the node
-         * @returns {void}
-         */
-        function report(node, recommendation, shouldSuggest, shouldFix) {
-
-            /**
-             * Fix function
-             * @param {RuleFixer} fixer The fixer to fix.
-             * @returns {Fix} The fix object.
-             */
-            function fix(fixer) {
-                const tokenBefore = sourceCode.getTokenBefore(node);
-
-                if (
-                    tokenBefore?.range[1] === node.range[0] &&
-                    !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
-                ) {
-                    return fixer.replaceText(node, ` ${recommendation}`);
-                }
-
-                return fixer.replaceText(node, recommendation);
-            }
-
-            context.report({
-                node,
-                messageId: "implicitCoercion",
-                data: { recommendation },
-                fix(fixer) {
-                    if (!shouldFix) {
-                        return null;
-                    }
-
-                    return fix(fixer);
-                },
-                suggest: [
-                    {
-                        messageId: "useRecommendation",
-                        data: { recommendation },
-                        fix(fixer) {
-                            if (shouldFix || !shouldSuggest) {
-                                return null;
-                            }
-
-                            return fix(fixer);
-                        }
-                    }
-                ]
-            });
-        }
-
-        return {
-            UnaryExpression(node) {
-                let operatorAllowed;
-
-                // !!foo
-                operatorAllowed = options.allow.includes("!!");
-                if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
-                    const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
-                    const variable = astUtils.getVariableByName(sourceCode.getScope(node), "Boolean");
-                    const booleanExists = variable?.identifiers.length === 0;
-
-                    report(node, recommendation, true, booleanExists);
-                }
-
-                // ~foo.indexOf(bar)
-                operatorAllowed = options.allow.includes("~");
-                if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
-
-                    // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
-                    const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
-                    const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
-
-                    report(node, recommendation, false, false);
-                }
-
-                // +foo
-                operatorAllowed = options.allow.includes("+");
-                if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
-                    const recommendation = `Number(${sourceCode.getText(node.argument)})`;
-
-                    report(node, recommendation, true, false);
-                }
-
-                // -(-foo)
-                operatorAllowed = options.allow.includes("- -");
-                if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
-                    const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
-
-                    report(node, recommendation, true, false);
-                }
-            },
-
-            // Use `:exit` to prevent double reporting
-            "BinaryExpression:exit"(node) {
-                let operatorAllowed;
-
-                // 1 * foo
-                operatorAllowed = options.allow.includes("*");
-                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && !isMultiplyByFractionOfOne(node, sourceCode) &&
-                    getNonNumericOperand(node);
-
-                if (nonNumericOperand) {
-                    const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
-
-                    report(node, recommendation, true, false);
-                }
-
-                // foo - 0
-                operatorAllowed = options.allow.includes("-");
-                if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
-                    const recommendation = `Number(${sourceCode.getText(node.left)})`;
-
-                    report(node, recommendation, true, false);
-                }
-
-                // "" + foo
-                operatorAllowed = options.allow.includes("+");
-                if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
-                    const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
-
-                    report(node, recommendation, true, false);
-                }
-            },
-
-            AssignmentExpression(node) {
-
-                // foo += ""
-                const operatorAllowed = options.allow.includes("+");
-
-                if (!operatorAllowed && options.string && isAppendEmptyString(node)) {
-                    const code = sourceCode.getText(getNonEmptyOperand(node));
-                    const recommendation = `${code} = String(${code})`;
-
-                    report(node, recommendation, true, false);
-                }
-            },
-
-            TemplateLiteral(node) {
-                if (!options.disallowTemplateShorthand) {
-                    return;
-                }
-
-                // tag`${foo}`
-                if (node.parent.type === "TaggedTemplateExpression") {
-                    return;
-                }
-
-                // `` or `${foo}${bar}`
-                if (node.expressions.length !== 1) {
-                    return;
-                }
-
-
-                //  `prefix${foo}`
-                if (node.quasis[0].value.cooked !== "") {
-                    return;
-                }
-
-                //  `${foo}postfix`
-                if (node.quasis[1].value.cooked !== "") {
-                    return;
-                }
-
-                // if the expression is already a string, then this isn't a coercion
-                if (isStringType(node.expressions[0])) {
-                    return;
-                }
-
-                const code = sourceCode.getText(node.expressions[0]);
-                const recommendation = `String(${code})`;
-
-                report(node, recommendation, true, false);
-            }
-        };
-    }
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow shorthand type conversions",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-implicit-coercion",
+		},
+
+		fixable: "code",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					boolean: {
+						type: "boolean",
+					},
+					number: {
+						type: "boolean",
+					},
+					string: {
+						type: "boolean",
+					},
+					disallowTemplateShorthand: {
+						type: "boolean",
+					},
+					allow: {
+						type: "array",
+						items: {
+							enum: ALLOWABLE_OPERATORS,
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [
+			{
+				allow: [],
+				boolean: true,
+				disallowTemplateShorthand: false,
+				number: true,
+				string: true,
+			},
+		],
+
+		messages: {
+			implicitCoercion:
+				"Unexpected implicit coercion encountered. Use `{{recommendation}}` instead.",
+			useRecommendation: "Use `{{recommendation}}` instead.",
+		},
+	},
+
+	create(context) {
+		const [options] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports an error and autofixes the node
+		 * @param {ASTNode} node An ast node to report the error on.
+		 * @param {string} recommendation The recommended code for the issue
+		 * @param {bool} shouldSuggest Whether this report should offer a suggestion
+		 * @param {bool} shouldFix Whether this report should fix the node
+		 * @returns {void}
+		 */
+		function report(node, recommendation, shouldSuggest, shouldFix) {
+			/**
+			 * Fix function
+			 * @param {RuleFixer} fixer The fixer to fix.
+			 * @returns {Fix} The fix object.
+			 */
+			function fix(fixer) {
+				const tokenBefore = sourceCode.getTokenBefore(node);
+
+				if (
+					tokenBefore?.range[1] === node.range[0] &&
+					!astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+				) {
+					return fixer.replaceText(node, ` ${recommendation}`);
+				}
+
+				return fixer.replaceText(node, recommendation);
+			}
+
+			context.report({
+				node,
+				messageId: "implicitCoercion",
+				data: { recommendation },
+				fix(fixer) {
+					if (!shouldFix) {
+						return null;
+					}
+
+					return fix(fixer);
+				},
+				suggest: [
+					{
+						messageId: "useRecommendation",
+						data: { recommendation },
+						fix(fixer) {
+							if (shouldFix || !shouldSuggest) {
+								return null;
+							}
+
+							return fix(fixer);
+						},
+					},
+				],
+			});
+		}
+
+		return {
+			UnaryExpression(node) {
+				let operatorAllowed;
+
+				// !!foo
+				operatorAllowed = options.allow.includes("!!");
+				if (
+					!operatorAllowed &&
+					options.boolean &&
+					isDoubleLogicalNegating(node)
+				) {
+					const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+					const variable = astUtils.getVariableByName(
+						sourceCode.getScope(node),
+						"Boolean",
+					);
+					const booleanExists = variable?.identifiers.length === 0;
+
+					report(node, recommendation, true, booleanExists);
+				}
+
+				// ~foo.indexOf(bar)
+				operatorAllowed = options.allow.includes("~");
+				if (
+					!operatorAllowed &&
+					options.boolean &&
+					isBinaryNegatingOfIndexOf(node)
+				) {
+					// `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
+					const comparison =
+						node.argument.type === "ChainExpression"
+							? ">= 0"
+							: "!== -1";
+					const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
+
+					report(node, recommendation, false, false);
+				}
+
+				// +foo
+				operatorAllowed = options.allow.includes("+");
+				if (
+					!operatorAllowed &&
+					options.number &&
+					node.operator === "+" &&
+					!isNumeric(node.argument)
+				) {
+					const recommendation = `Number(${sourceCode.getText(node.argument)})`;
+
+					report(node, recommendation, true, false);
+				}
+
+				// -(-foo)
+				operatorAllowed = options.allow.includes("- -");
+				if (
+					!operatorAllowed &&
+					options.number &&
+					node.operator === "-" &&
+					node.argument.type === "UnaryExpression" &&
+					node.argument.operator === "-" &&
+					!isNumeric(node.argument.argument)
+				) {
+					const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+
+					report(node, recommendation, true, false);
+				}
+			},
+
+			// Use `:exit` to prevent double reporting
+			"BinaryExpression:exit"(node) {
+				let operatorAllowed;
+
+				// 1 * foo
+				operatorAllowed = options.allow.includes("*");
+				const nonNumericOperand =
+					!operatorAllowed &&
+					options.number &&
+					isMultiplyByOne(node) &&
+					!isMultiplyByFractionOfOne(node, sourceCode) &&
+					getNonNumericOperand(node);
+
+				if (nonNumericOperand) {
+					const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
+
+					report(node, recommendation, true, false);
+				}
+
+				// foo - 0
+				operatorAllowed = options.allow.includes("-");
+				if (
+					!operatorAllowed &&
+					options.number &&
+					node.operator === "-" &&
+					node.right.type === "Literal" &&
+					node.right.value === 0 &&
+					!isNumeric(node.left)
+				) {
+					const recommendation = `Number(${sourceCode.getText(node.left)})`;
+
+					report(node, recommendation, true, false);
+				}
+
+				// "" + foo
+				operatorAllowed = options.allow.includes("+");
+				if (
+					!operatorAllowed &&
+					options.string &&
+					isConcatWithEmptyString(node)
+				) {
+					const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
+
+					report(node, recommendation, true, false);
+				}
+			},
+
+			AssignmentExpression(node) {
+				// foo += ""
+				const operatorAllowed = options.allow.includes("+");
+
+				if (
+					!operatorAllowed &&
+					options.string &&
+					isAppendEmptyString(node)
+				) {
+					const code = sourceCode.getText(getNonEmptyOperand(node));
+					const recommendation = `${code} = String(${code})`;
+
+					report(node, recommendation, true, false);
+				}
+			},
+
+			TemplateLiteral(node) {
+				if (!options.disallowTemplateShorthand) {
+					return;
+				}
+
+				// tag`${foo}`
+				if (node.parent.type === "TaggedTemplateExpression") {
+					return;
+				}
+
+				// `` or `${foo}${bar}`
+				if (node.expressions.length !== 1) {
+					return;
+				}
+
+				//  `prefix${foo}`
+				if (node.quasis[0].value.cooked !== "") {
+					return;
+				}
+
+				//  `${foo}postfix`
+				if (node.quasis[1].value.cooked !== "") {
+					return;
+				}
+
+				// if the expression is already a string, then this isn't a coercion
+				if (isStringType(node.expressions[0])) {
+					return;
+				}
+
+				const code = sourceCode.getText(node.expressions[0]);
+				const recommendation = `String(${code})`;
+
+				report(node, recommendation, true, false);
+			},
+		};
+	},
 };