Add the test case testPersistentUnreachableLinesNestedInInpersistentUnreachableLines provided by @A5rocks and extend the current logic to fix it.

Author: tyralla

mypy/checker.py

@@ -600,22 +600,25 @@ def accept_loop(
             # on without bound otherwise)
             widened_old = len(self.widened_vars)
 
+            # one set of `unreachable` and `redundant-expr`errors per iteration step:
+            uselessness_errors = []
+            # one set of unreachable line numbers per iteration step:
+            unreachable_lines = []
+            # one set of revealed types per line where `reveal_type` is used (each
+            # created set can grow during the iteration):
+            revealed_types = defaultdict(set)
             iter = 1
             while True:
                 with self.binder.frame_context(can_skip=True, break_frame=2, continue_frame=1):
                     if on_enter_body is not None:
                         on_enter_body()
 
-                    # We collect errors that indicate unreachability or redundant expressions
-                    # in the first iteration and remove them in subsequent iterations if the
-                    # related statement becomes reachable or non-redundant due to changes in
-                    # partial types:
                     with LoopErrorWatcher(self.msg.errors) as watcher:
                         self.accept(body)
-                    if iter == 1:
-                        uselessness_errors = watcher.useless_statements
-                    else:
-                        uselessness_errors.intersection_update(watcher.useless_statements)
+                    uselessness_errors.append(watcher.uselessness_errors)
+                    unreachable_lines.append(watcher.unreachable_lines)
+                    for key, values in watcher.revealed_types.items():
+                        revealed_types[key].update(values)
 
                 partials_new = sum(len(pts.map) for pts in self.partial_types)
                 widened_new = len(self.widened_vars)
@@ -637,15 +640,23 @@ def accept_loop(
                 if iter == 20:
                     raise RuntimeError("Too many iterations when checking a loop")
 
-            # Report those unreachable and redundant expression errors identified in all
-            # iteration steps:
-            for error_info in uselessness_errors:
+            # Report only those `unreachable` and `redundant-expr` errors that could not
+            # be ruled out in any iteration step:
+            persistent_uselessness_errors = set()
+            for candidate in set(itertools.chain(*uselessness_errors)):
+                if all(
+                    (candidate in errors) or (candidate[2] in lines)
+                    for errors, lines in zip(uselessness_errors, unreachable_lines)
+                ):
+                    persistent_uselessness_errors.add(candidate)
+            for error_info in persistent_uselessness_errors:
                 context = Context(line=error_info[2], column=error_info[3])
                 context.end_line = error_info[4]
                 context.end_column = error_info[5]
                 self.msg.fail(error_info[1], context, code=error_info[0])
+
             #  Report all types revealed in at least one iteration step:
-            for note_info, types in watcher.revealed_types.items():
+            for note_info, types in revealed_types.items():
                 sorted_ = sorted(types, key=lambda typ: typ.lower())
                 revealed = sorted_[0] if len(types) == 1 else f"Union[{', '.join(sorted_)}]"
                 context = Context(line=note_info[1], column=note_info[2])

mypy/errors.py

@@ -221,15 +221,19 @@ def filtered_errors(self) -> list[ErrorInfo]:
 
 
 class LoopErrorWatcher(ErrorWatcher):
-    """Error watcher that filters and separately collects unreachable errors, redundant
-    expression errors, and revealed types when analysing loops iteratively to help avoid
-    making too-hasty reports."""
+    """Error watcher that filters and separately collects `unreachable` errors,
+    `redundant-expr` errors, and revealed types when analysing loops iteratively
+    to help avoid making too-hasty reports."""
 
     # Meaning of the tuple items: ErrorCode, message, line, column, end_line, end_column:
-    useless_statements: set[tuple[ErrorCode, str, int, int, int, int]]
+    uselessness_errors: set[tuple[ErrorCode, str, int, int, int, int]]
+
     # Meaning of the tuple items: function_or_member, line, column, end_line, end_column:
     revealed_types: dict[tuple[str | None, int, int, int, int], set[str]]
 
+    # Not only the lines where the error report occurs but really all unreachable lines:
+    unreachable_lines: set[int]
+
     def __init__(
         self,
         errors: Errors,
@@ -244,15 +248,20 @@ def __init__(
             save_filtered_errors=save_filtered_errors,
             filter_deprecated=filter_deprecated,
         )
-        self.useless_statements = set()
+        self.uselessness_errors = set()
+        self.unreachable_lines = set()
         self.revealed_types = defaultdict(set)
 
     def on_error(self, file: str, info: ErrorInfo) -> bool:
+
         if info.code in (codes.UNREACHABLE, codes.REDUNDANT_EXPR):
-            self.useless_statements.add(
+            self.uselessness_errors.add(
                 (info.code, info.message, info.line, info.column, info.end_line, info.end_column)
             )
+            if info.code == codes.UNREACHABLE:
+                self.unreachable_lines.update(range(info.line, info.end_line + 1))
             return True
+
         if info.code == codes.MISC and info.message.startswith("Revealed type is "):
             key = info.function_or_member, info.line, info.column, info.end_line, info.end_column
             types = info.message.split('"')[1]
@@ -261,6 +270,7 @@ def on_error(self, file: str, info: ErrorInfo) -> bool:
             else:
                 self.revealed_types[key].add(types)
             return True
+
         return super().on_error(file, info)
 
 

test-data/unit/check-narrowing.test

@@ -2369,6 +2369,19 @@ class A:
 
 [builtins fixtures/primitives.pyi]
 
+[case testPersistentUnreachableLinesNestedInInpersistentUnreachableLines]
+# flags: --warn-unreachable --python-version 3.11
+
+x = None
+y = None
+while True:
+    if x is not None:
+        if y is not None:
+            reveal_type(y)  # E: Statement is unreachable
+    x = 1
+
+[builtins fixtures/bool.pyi]
+
 [case testAvoidFalseUnreachableInLoop1]
 # flags: --warn-unreachable --python-version 3.11