Give preference to --never-returning-functions in inconsistent-return-statements check

doc/whatsnew/fragments/7565.false_negative

@@ -0,0 +1,3 @@
+Fix computation of never-returning function: `Never` is handled in addition to `NoReturn`, and priority is given to the explicit `--never-returning-functions` option.
+
+Closes #7565.

pylint/checkers/refactoring/refactoring_checker.py

@@ -2030,12 +2030,13 @@
         if isinstance(node, nodes.Return):
             return True
         if isinstance(node, nodes.Call):
-            try:
-                funcdef_node = node.func.inferred()[0]
-                if self._is_function_def_never_returning(funcdef_node):
-                    return True
-            except astroid.InferenceError:
-                pass
+            return any(
+                (
+                    isinstance(maybe_func, (nodes.FunctionDef, bases.BoundMethod))
+                    and self._is_function_def_never_returning(maybe_func)
+                )
+                for maybe_func in utils.infer_all(node.func)
+            )
         if isinstance(node, nodes.While):
             # A while-loop is considered return-ended if it has a
             # truthy test and no break statements
@@ -2087,17 +2088,21 @@
         Returns:
             bool: True if the function never returns, False otherwise.
         """
-        if isinstance(node, (nodes.FunctionDef, astroid.BoundMethod)) and node.returns:
-            return (
+        try:
+            if node.qname() in self._never_returning_functions:
+                return True
+        except (TypeError, AttributeError):
+            pass
+        return (
+            isinstance(node, (nodes.FunctionDef, astroid.BoundMethod))
+            and node.returns
+            and (
                 isinstance(node.returns, nodes.Attribute)
-                and node.returns.attrname == "NoReturn"
+                and node.returns.attrname in {"NoReturn", "Never"}
                 or isinstance(node.returns, nodes.Name)
-                and node.returns.name == "NoReturn"
+                and node.returns.name in {"NoReturn", "Never"}
             )
-        try:
-            return node.qname() in self._never_returning_functions
-        except (TypeError, AttributeError):
-            return False
+        )
 
     def _check_return_at_the_end(self, node: nodes.FunctionDef) -> None:
         """Check for presence of a *single* return statement at the end of a

pylint/checkers/variables.py

@@ -2613,6 +2613,7 @@ def _loopvar_name(self, node: astroid.Name) -> None:
             ):
                 return
             # TODO: 4.0: Consider using utils.is_terminating_func
+            # after merging it with RefactoringChecker._is_function_def_never_returning
             if isinstance(else_stmt, nodes.Expr) and isinstance(
                 else_stmt.value, nodes.Call
             ):

tests/functional/i/inconsistent/inconsistent_returns_noreturn.py

@@ -4,14 +4,22 @@
 import sys
 import typing
 
+from pylint.constants import PY311_PLUS
+
+if PY311_PLUS:
+    from typing import assert_never  # pylint: disable=no-name-in-module
+else:
+    from typing_extensions import assert_never
+
+
 def parser_error(msg) -> typing.NoReturn:  # pylint: disable=unused-argument
     sys.exit(1)
 
 def parser_error_nortype(msg):  # pylint: disable=unused-argument
     sys.exit(2)
 
 
-from typing import NoReturn  # pylint: disable=wrong-import-position
+from typing import NoReturn  # pylint: disable=wrong-import-position,wrong-import-order
 
 def parser_error_name(msg) -> NoReturn:  # pylint: disable=unused-argument
     sys.exit(3)
@@ -95,3 +103,34 @@ def bug_pylint_8747_incorrect_annotation(self, s: str) -> int:
             return n
         except ValueError:
             self._falsely_no_return_method()
+
+# https://github.com/pylint-dev/pylint/issues/7565
+def never_is_handled_like_noreturn(arg: typing.Union[int, str]) -> int:
+    if isinstance(arg, int):
+        return 1
+    if isinstance(arg, str):
+        return 2
+    assert_never(arg)
+
+
+def declared_to_not_return() -> None:
+    return
+
+
+def config_takes_precedence_over_inference(arg: typing.Union[int, str]) -> int:
+    if isinstance(arg, int):
+        return 1
+    if isinstance(arg, str):
+        return 2
+    declared_to_not_return()
+
+
+def unrelated() -> None:
+    return
+
+
+# +1: [inconsistent-return-statements]
+def ensure_message(arg: typing.Union[int, str]) -> int:
+    if isinstance(arg, int):
+        return 1
+    unrelated()

tests/functional/i/inconsistent/inconsistent_returns_noreturn.rc

@@ -1,2 +1,2 @@
 [REFACTORING]
-never-returning-functions=sys.exit,sys.getdefaultencoding
+never-returning-functions=sys.exit,sys.getdefaultencoding,inconsistent_returns_noreturn.declared_to_not_return

tests/functional/i/inconsistent/inconsistent_returns_noreturn.txt

@@ -1,2 +1,3 @@
-inconsistent-return-statements:32:0:32:25:bug_pylint_4122_wrong:Either all return statements in a function should return an expression, or none of them should.:UNDEFINED
-inconsistent-return-statements:77:4:77:29:ClassUnderTest.bug_pylint_8747_wrong:Either all return statements in a function should return an expression, or none of them should.:UNDEFINED
+inconsistent-return-statements:40:0:40:25:bug_pylint_4122_wrong:Either all return statements in a function should return an expression, or none of them should.:UNDEFINED
+inconsistent-return-statements:85:4:85:29:ClassUnderTest.bug_pylint_8747_wrong:Either all return statements in a function should return an expression, or none of them should.:UNDEFINED
+inconsistent-return-statements:133:0:133:18:ensure_message:Either all return statements in a function should return an expression, or none of them should.:UNDEFINED