eslint 9.22.0 → 9.23.0

package/lib/rules/no-else-return.js

@@ -18,388 +18,433 @@ const FixTracker = require("./utils/fix-tracker");
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        defaultOptions: [{ allowElseIf: true }],
-
-        docs: {
-            description: "Disallow `else` blocks after `return` statements in `if` statements",
-            recommended: false,
-            frozen: true,
-            url: "https://eslint.org/docs/latest/rules/no-else-return"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                allowElseIf: {
-                    type: "boolean"
-                }
-            },
-            additionalProperties: false
-        }],
-
-        fixable: "code",
-
-        messages: {
-            unexpected: "Unnecessary 'else' after 'return'."
-        }
-    },
-
-    create(context) {
-        const [{ allowElseIf }] = context.options;
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Checks whether the given names can be safely used to declare block-scoped variables
-         * in the given scope. Name collisions can produce redeclaration syntax errors,
-         * or silently change references and modify behavior of the original code.
-         *
-         * This is not a generic function. In particular, it is assumed that the scope is a function scope or
-         * a function's inner scope, and that the names can be valid identifiers in the given scope.
-         * @param {string[]} names Array of variable names.
-         * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
-         * @returns {boolean} True if all names can be safely declared, false otherwise.
-         */
-        function isSafeToDeclare(names, scope) {
-
-            if (names.length === 0) {
-                return true;
-            }
-
-            const functionScope = scope.variableScope;
-
-            /*
-             * If this is a function scope, scope.variables will contain parameters, implicit variables such as "arguments",
-             * all function-scoped variables ('var'), and block-scoped variables defined in the scope.
-             * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope.
-             *
-             * Redeclaring any of these would cause a syntax error, except for the implicit variables.
-             */
-            const declaredVariables = scope.variables.filter(({ defs }) => defs.length > 0);
-
-            if (declaredVariables.some(({ name }) => names.includes(name))) {
-                return false;
-            }
-
-            // Redeclaring a catch variable would also cause a syntax error.
-            if (scope !== functionScope && scope.upper.type === "catch") {
-                if (scope.upper.variables.some(({ name }) => names.includes(name))) {
-                    return false;
-                }
-            }
-
-            /*
-             * Redeclaring an implicit variable, such as "arguments", would not cause a syntax error.
-             * However, if the variable was used, declaring a new one with the same name would change references
-             * and modify behavior.
-             */
-            const usedImplicitVariables = scope.variables.filter(({ defs, references }) =>
-                defs.length === 0 && references.length > 0);
-
-            if (usedImplicitVariables.some(({ name }) => names.includes(name))) {
-                return false;
-            }
-
-            /*
-             * Declaring a variable with a name that was already used to reference a variable from an upper scope
-             * would change references and modify behavior.
-             */
-            if (scope.through.some(t => names.includes(t.identifier.name))) {
-                return false;
-            }
-
-            /*
-             * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside
-             * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope.
-             *
-             * For example, this would be a syntax error "Identifier 'a' has already been declared":
-             * function foo() { if (bar) { let a; if (baz) { var a; } } }
-             */
-            if (scope !== functionScope) {
-                const scopeNodeRange = scope.block.range;
-                const variablesToCheck = functionScope.variables.filter(({ name }) => names.includes(name));
-
-                if (variablesToCheck.some(v => v.defs.some(({ node: { range } }) =>
-                    scopeNodeRange[0] <= range[0] && range[1] <= scopeNodeRange[1]))) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-
-        /**
-         * Checks whether the removal of `else` and its braces is safe from variable name collisions.
-         * @param {Node} node The 'else' node.
-         * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
-         * @returns {boolean} True if it is safe, false otherwise.
-         */
-        function isSafeFromNameCollisions(node, scope) {
-
-            if (node.type === "FunctionDeclaration") {
-
-                // Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently.
-                return false;
-            }
-
-            if (node.type !== "BlockStatement") {
-                return true;
-            }
-
-            const elseBlockScope = scope.childScopes.find(({ block }) => block === node);
-
-            if (!elseBlockScope) {
-
-                // ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions.
-                return true;
-            }
-
-            /*
-             * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains
-             * only block-scoped variables (such as let and const variables or class and function declarations)
-             * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions.
-             */
-            const namesToCheck = elseBlockScope.variables.map(({ name }) => name);
-
-            return isSafeToDeclare(namesToCheck, scope);
-        }
-
-        /**
-         * Display the context report if rule is violated
-         * @param {Node} elseNode The 'else' node
-         * @returns {void}
-         */
-        function displayReport(elseNode) {
-            const currentScope = sourceCode.getScope(elseNode.parent);
-
-            context.report({
-                node: elseNode,
-                messageId: "unexpected",
-                fix(fixer) {
-
-                    if (!isSafeFromNameCollisions(elseNode, currentScope)) {
-                        return null;
-                    }
-
-                    const startToken = sourceCode.getFirstToken(elseNode);
-                    const elseToken = sourceCode.getTokenBefore(startToken);
-                    const source = sourceCode.getText(elseNode);
-                    const lastIfToken = sourceCode.getTokenBefore(elseToken);
-                    let fixedSource, firstTokenOfElseBlock;
-
-                    if (startToken.type === "Punctuator" && startToken.value === "{") {
-                        firstTokenOfElseBlock = sourceCode.getTokenAfter(startToken);
-                    } else {
-                        firstTokenOfElseBlock = startToken;
-                    }
-
-                    /*
-                     * If the if block does not have curly braces and does not end in a semicolon
-                     * and the else block starts with (, [, /, +, ` or -, then it is not
-                     * safe to remove the else keyword, because ASI will not add a semicolon
-                     * after the if block
-                     */
-                    const ifBlockMaybeUnsafe = elseNode.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";";
-                    const elseBlockUnsafe = /^[([/+`-]/u.test(firstTokenOfElseBlock.value);
-
-                    if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
-                        return null;
-                    }
-
-                    const endToken = sourceCode.getLastToken(elseNode);
-                    const lastTokenOfElseBlock = sourceCode.getTokenBefore(endToken);
-
-                    if (lastTokenOfElseBlock.value !== ";") {
-                        const nextToken = sourceCode.getTokenAfter(endToken);
-
-                        const nextTokenUnsafe = nextToken && /^[([/+`-]/u.test(nextToken.value);
-                        const nextTokenOnSameLine = nextToken && nextToken.loc.start.line === lastTokenOfElseBlock.loc.start.line;
-
-                        /*
-                         * If the else block contents does not end in a semicolon,
-                         * and the else block starts with (, [, /, +, ` or -, then it is not
-                         * safe to remove the else block, because ASI will not add a semicolon
-                         * after the remaining else block contents
-                         */
-                        if (nextTokenUnsafe || (nextTokenOnSameLine && nextToken.value !== "}")) {
-                            return null;
-                        }
-                    }
-
-                    if (startToken.type === "Punctuator" && startToken.value === "{") {
-                        fixedSource = source.slice(1, -1);
-                    } else {
-                        fixedSource = source;
-                    }
-
-                    /*
-                     * Extend the replacement range to include the entire
-                     * function to avoid conflicting with no-useless-return.
-                     * https://github.com/eslint/eslint/issues/8026
-                     *
-                     * Also, to avoid name collisions between two else blocks.
-                     */
-                    return new FixTracker(fixer, sourceCode)
-                        .retainEnclosingFunction(elseNode)
-                        .replaceTextRange([elseToken.range[0], elseNode.range[1]], fixedSource);
-                }
-            });
-        }
-
-        /**
-         * Check to see if the node is a ReturnStatement
-         * @param {Node} node The node being evaluated
-         * @returns {boolean} True if node is a return
-         */
-        function checkForReturn(node) {
-            return node.type === "ReturnStatement";
-        }
-
-        /**
-         * Naive return checking, does not iterate through the whole
-         * BlockStatement because we make the assumption that the ReturnStatement
-         * will be the last node in the body of the BlockStatement.
-         * @param {Node} node The consequent/alternate node
-         * @returns {boolean} True if it has a return
-         */
-        function naiveHasReturn(node) {
-            if (node.type === "BlockStatement") {
-                const body = node.body,
-                    lastChildNode = body.at(-1);
-
-                return lastChildNode && checkForReturn(lastChildNode);
-            }
-            return checkForReturn(node);
-        }
-
-        /**
-         * Check to see if the node is valid for evaluation,
-         * meaning it has an else.
-         * @param {Node} node The node being evaluated
-         * @returns {boolean} True if the node is valid
-         */
-        function hasElse(node) {
-            return node.alternate && node.consequent;
-        }
-
-        /**
-         * If the consequent is an IfStatement, check to see if it has an else
-         * and both its consequent and alternate path return, meaning this is
-         * a nested case of rule violation.  If-Else not considered currently.
-         * @param {Node} node The consequent node
-         * @returns {boolean} True if this is a nested rule violation
-         */
-        function checkForIf(node) {
-            return node.type === "IfStatement" && hasElse(node) &&
-                naiveHasReturn(node.alternate) && naiveHasReturn(node.consequent);
-        }
-
-        /**
-         * Check the consequent/body node to make sure it is not
-         * a ReturnStatement or an IfStatement that returns on both
-         * code paths.
-         * @param {Node} node The consequent or body node
-         * @returns {boolean} `true` if it is a Return/If node that always returns.
-         */
-        function checkForReturnOrIf(node) {
-            return checkForReturn(node) || checkForIf(node);
-        }
-
-
-        /**
-         * Check whether a node returns in every codepath.
-         * @param {Node} node The node to be checked
-         * @returns {boolean} `true` if it returns on every codepath.
-         */
-        function alwaysReturns(node) {
-            if (node.type === "BlockStatement") {
-
-                // If we have a BlockStatement, check each consequent body node.
-                return node.body.some(checkForReturnOrIf);
-            }
-
-            /*
-             * If not a block statement, make sure the consequent isn't a
-             * ReturnStatement or an IfStatement with returns on both paths.
-             */
-            return checkForReturnOrIf(node);
-        }
-
-
-        /**
-         * Check the if statement, but don't catch else-if blocks.
-         * @returns {void}
-         * @param {Node} node The node for the if statement to check
-         * @private
-         */
-        function checkIfWithoutElse(node) {
-            const parent = node.parent;
-
-            /*
-             * Fixing this would require splitting one statement into two, so no error should
-             * be reported if this node is in a position where only one statement is allowed.
-             */
-            if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
-                return;
-            }
-
-            const consequents = [];
-            let alternate;
-
-            for (let currentNode = node; currentNode.type === "IfStatement"; currentNode = currentNode.alternate) {
-                if (!currentNode.alternate) {
-                    return;
-                }
-                consequents.push(currentNode.consequent);
-                alternate = currentNode.alternate;
-            }
-
-            if (consequents.every(alwaysReturns)) {
-                displayReport(alternate);
-            }
-        }
-
-        /**
-         * Check the if statement
-         * @returns {void}
-         * @param {Node} node The node for the if statement to check
-         * @private
-         */
-        function checkIfWithElse(node) {
-            const parent = node.parent;
-
-
-            /*
-             * Fixing this would require splitting one statement into two, so no error should
-             * be reported if this node is in a position where only one statement is allowed.
-             */
-            if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
-                return;
-            }
-
-            const alternate = node.alternate;
-
-            if (alternate && alwaysReturns(node.consequent)) {
-                displayReport(alternate);
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            "IfStatement:exit": allowElseIf ? checkIfWithoutElse : checkIfWithElse
-
-        };
-
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [{ allowElseIf: true }],
+
+		docs: {
+			description:
+				"Disallow `else` blocks after `return` statements in `if` statements",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-else-return",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowElseIf: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			unexpected: "Unnecessary 'else' after 'return'.",
+		},
+	},
+
+	create(context) {
+		const [{ allowElseIf }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks whether the given names can be safely used to declare block-scoped variables
+		 * in the given scope. Name collisions can produce redeclaration syntax errors,
+		 * or silently change references and modify behavior of the original code.
+		 *
+		 * This is not a generic function. In particular, it is assumed that the scope is a function scope or
+		 * a function's inner scope, and that the names can be valid identifiers in the given scope.
+		 * @param {string[]} names Array of variable names.
+		 * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
+		 * @returns {boolean} True if all names can be safely declared, false otherwise.
+		 */
+		function isSafeToDeclare(names, scope) {
+			if (names.length === 0) {
+				return true;
+			}
+
+			const functionScope = scope.variableScope;
+
+			/*
+			 * If this is a function scope, scope.variables will contain parameters, implicit variables such as "arguments",
+			 * all function-scoped variables ('var'), and block-scoped variables defined in the scope.
+			 * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope.
+			 *
+			 * Redeclaring any of these would cause a syntax error, except for the implicit variables.
+			 */
+			const declaredVariables = scope.variables.filter(
+				({ defs }) => defs.length > 0,
+			);
+
+			if (declaredVariables.some(({ name }) => names.includes(name))) {
+				return false;
+			}
+
+			// Redeclaring a catch variable would also cause a syntax error.
+			if (scope !== functionScope && scope.upper.type === "catch") {
+				if (
+					scope.upper.variables.some(({ name }) =>
+						names.includes(name),
+					)
+				) {
+					return false;
+				}
+			}
+
+			/*
+			 * Redeclaring an implicit variable, such as "arguments", would not cause a syntax error.
+			 * However, if the variable was used, declaring a new one with the same name would change references
+			 * and modify behavior.
+			 */
+			const usedImplicitVariables = scope.variables.filter(
+				({ defs, references }) =>
+					defs.length === 0 && references.length > 0,
+			);
+
+			if (
+				usedImplicitVariables.some(({ name }) => names.includes(name))
+			) {
+				return false;
+			}
+
+			/*
+			 * Declaring a variable with a name that was already used to reference a variable from an upper scope
+			 * would change references and modify behavior.
+			 */
+			if (scope.through.some(t => names.includes(t.identifier.name))) {
+				return false;
+			}
+
+			/*
+			 * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside
+			 * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope.
+			 *
+			 * For example, this would be a syntax error "Identifier 'a' has already been declared":
+			 * function foo() { if (bar) { let a; if (baz) { var a; } } }
+			 */
+			if (scope !== functionScope) {
+				const scopeNodeRange = scope.block.range;
+				const variablesToCheck = functionScope.variables.filter(
+					({ name }) => names.includes(name),
+				);
+
+				if (
+					variablesToCheck.some(v =>
+						v.defs.some(
+							({ node: { range } }) =>
+								scopeNodeRange[0] <= range[0] &&
+								range[1] <= scopeNodeRange[1],
+						),
+					)
+				) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/**
+		 * Checks whether the removal of `else` and its braces is safe from variable name collisions.
+		 * @param {Node} node The 'else' node.
+		 * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
+		 * @returns {boolean} True if it is safe, false otherwise.
+		 */
+		function isSafeFromNameCollisions(node, scope) {
+			if (node.type === "FunctionDeclaration") {
+				// Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently.
+				return false;
+			}
+
+			if (node.type !== "BlockStatement") {
+				return true;
+			}
+
+			const elseBlockScope = scope.childScopes.find(
+				({ block }) => block === node,
+			);
+
+			if (!elseBlockScope) {
+				// ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions.
+				return true;
+			}
+
+			/*
+			 * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains
+			 * only block-scoped variables (such as let and const variables or class and function declarations)
+			 * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions.
+			 */
+			const namesToCheck = elseBlockScope.variables.map(
+				({ name }) => name,
+			);
+
+			return isSafeToDeclare(namesToCheck, scope);
+		}
+
+		/**
+		 * Display the context report if rule is violated
+		 * @param {Node} elseNode The 'else' node
+		 * @returns {void}
+		 */
+		function displayReport(elseNode) {
+			const currentScope = sourceCode.getScope(elseNode.parent);
+
+			context.report({
+				node: elseNode,
+				messageId: "unexpected",
+				fix(fixer) {
+					if (!isSafeFromNameCollisions(elseNode, currentScope)) {
+						return null;
+					}
+
+					const startToken = sourceCode.getFirstToken(elseNode);
+					const elseToken = sourceCode.getTokenBefore(startToken);
+					const source = sourceCode.getText(elseNode);
+					const lastIfToken = sourceCode.getTokenBefore(elseToken);
+					let fixedSource, firstTokenOfElseBlock;
+
+					if (
+						startToken.type === "Punctuator" &&
+						startToken.value === "{"
+					) {
+						firstTokenOfElseBlock =
+							sourceCode.getTokenAfter(startToken);
+					} else {
+						firstTokenOfElseBlock = startToken;
+					}
+
+					/*
+					 * If the if block does not have curly braces and does not end in a semicolon
+					 * and the else block starts with (, [, /, +, ` or -, then it is not
+					 * safe to remove the else keyword, because ASI will not add a semicolon
+					 * after the if block
+					 */
+					const ifBlockMaybeUnsafe =
+						elseNode.parent.consequent.type !== "BlockStatement" &&
+						lastIfToken.value !== ";";
+					const elseBlockUnsafe = /^[([/+`-]/u.test(
+						firstTokenOfElseBlock.value,
+					);
+
+					if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
+						return null;
+					}
+
+					const endToken = sourceCode.getLastToken(elseNode);
+					const lastTokenOfElseBlock =
+						sourceCode.getTokenBefore(endToken);
+
+					if (lastTokenOfElseBlock.value !== ";") {
+						const nextToken = sourceCode.getTokenAfter(endToken);
+
+						const nextTokenUnsafe =
+							nextToken && /^[([/+`-]/u.test(nextToken.value);
+						const nextTokenOnSameLine =
+							nextToken &&
+							nextToken.loc.start.line ===
+								lastTokenOfElseBlock.loc.start.line;
+
+						/*
+						 * If the else block contents does not end in a semicolon,
+						 * and the else block starts with (, [, /, +, ` or -, then it is not
+						 * safe to remove the else block, because ASI will not add a semicolon
+						 * after the remaining else block contents
+						 */
+						if (
+							nextTokenUnsafe ||
+							(nextTokenOnSameLine && nextToken.value !== "}")
+						) {
+							return null;
+						}
+					}
+
+					if (
+						startToken.type === "Punctuator" &&
+						startToken.value === "{"
+					) {
+						fixedSource = source.slice(1, -1);
+					} else {
+						fixedSource = source;
+					}
+
+					/*
+					 * Extend the replacement range to include the entire
+					 * function to avoid conflicting with no-useless-return.
+					 * https://github.com/eslint/eslint/issues/8026
+					 *
+					 * Also, to avoid name collisions between two else blocks.
+					 */
+					return new FixTracker(fixer, sourceCode)
+						.retainEnclosingFunction(elseNode)
+						.replaceTextRange(
+							[elseToken.range[0], elseNode.range[1]],
+							fixedSource,
+						);
+				},
+			});
+		}
+
+		/**
+		 * Check to see if the node is a ReturnStatement
+		 * @param {Node} node The node being evaluated
+		 * @returns {boolean} True if node is a return
+		 */
+		function checkForReturn(node) {
+			return node.type === "ReturnStatement";
+		}
+
+		/**
+		 * Naive return checking, does not iterate through the whole
+		 * BlockStatement because we make the assumption that the ReturnStatement
+		 * will be the last node in the body of the BlockStatement.
+		 * @param {Node} node The consequent/alternate node
+		 * @returns {boolean} True if it has a return
+		 */
+		function naiveHasReturn(node) {
+			if (node.type === "BlockStatement") {
+				const body = node.body,
+					lastChildNode = body.at(-1);
+
+				return lastChildNode && checkForReturn(lastChildNode);
+			}
+			return checkForReturn(node);
+		}
+
+		/**
+		 * Check to see if the node is valid for evaluation,
+		 * meaning it has an else.
+		 * @param {Node} node The node being evaluated
+		 * @returns {boolean} True if the node is valid
+		 */
+		function hasElse(node) {
+			return node.alternate && node.consequent;
+		}
+
+		/**
+		 * If the consequent is an IfStatement, check to see if it has an else
+		 * and both its consequent and alternate path return, meaning this is
+		 * a nested case of rule violation.  If-Else not considered currently.
+		 * @param {Node} node The consequent node
+		 * @returns {boolean} True if this is a nested rule violation
+		 */
+		function checkForIf(node) {
+			return (
+				node.type === "IfStatement" &&
+				hasElse(node) &&
+				naiveHasReturn(node.alternate) &&
+				naiveHasReturn(node.consequent)
+			);
+		}
+
+		/**
+		 * Check the consequent/body node to make sure it is not
+		 * a ReturnStatement or an IfStatement that returns on both
+		 * code paths.
+		 * @param {Node} node The consequent or body node
+		 * @returns {boolean} `true` if it is a Return/If node that always returns.
+		 */
+		function checkForReturnOrIf(node) {
+			return checkForReturn(node) || checkForIf(node);
+		}
+
+		/**
+		 * Check whether a node returns in every codepath.
+		 * @param {Node} node The node to be checked
+		 * @returns {boolean} `true` if it returns on every codepath.
+		 */
+		function alwaysReturns(node) {
+			if (node.type === "BlockStatement") {
+				// If we have a BlockStatement, check each consequent body node.
+				return node.body.some(checkForReturnOrIf);
+			}
+
+			/*
+			 * If not a block statement, make sure the consequent isn't a
+			 * ReturnStatement or an IfStatement with returns on both paths.
+			 */
+			return checkForReturnOrIf(node);
+		}
+
+		/**
+		 * Check the if statement, but don't catch else-if blocks.
+		 * @returns {void}
+		 * @param {Node} node The node for the if statement to check
+		 * @private
+		 */
+		function checkIfWithoutElse(node) {
+			const parent = node.parent;
+
+			/*
+			 * Fixing this would require splitting one statement into two, so no error should
+			 * be reported if this node is in a position where only one statement is allowed.
+			 */
+			if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+				return;
+			}
+
+			const consequents = [];
+			let alternate;
+
+			for (
+				let currentNode = node;
+				currentNode.type === "IfStatement";
+				currentNode = currentNode.alternate
+			) {
+				if (!currentNode.alternate) {
+					return;
+				}
+				consequents.push(currentNode.consequent);
+				alternate = currentNode.alternate;
+			}
+
+			if (consequents.every(alwaysReturns)) {
+				displayReport(alternate);
+			}
+		}
+
+		/**
+		 * Check the if statement
+		 * @returns {void}
+		 * @param {Node} node The node for the if statement to check
+		 * @private
+		 */
+		function checkIfWithElse(node) {
+			const parent = node.parent;
+
+			/*
+			 * Fixing this would require splitting one statement into two, so no error should
+			 * be reported if this node is in a position where only one statement is allowed.
+			 */
+			if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+				return;
+			}
+
+			const alternate = node.alternate;
+
+			if (alternate && alwaysReturns(node.consequent)) {
+				displayReport(alternate);
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			"IfStatement:exit": allowElseIf
+				? checkIfWithoutElse
+				: checkIfWithElse,
+		};
+	},
 };