Use A5rock's approach of marking semanal unreachability.

Co-authored-by: A5rocks <[email protected]>

Author: ammaraskar

mypy/binder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 from collections import defaultdict
 from collections.abc import Iterator
 from contextlib import contextmanager
@@ -36,6 +37,11 @@ class CurrentType(NamedTuple):
     from_assignment: bool
 
 
+class UnreachableType(enum.Enum):
+    BINDER_UNREACHABLE = enum.auto()
+    SEMANAL_UNREACHABLE = enum.auto()
+
+
 class Frame:
     """A Frame represents a specific point in the execution of a program.
     It carries information about the current types of expressions at
@@ -51,7 +57,7 @@ class Frame:
     def __init__(self, id: int, conditional_frame: bool = False) -> None:
         self.id = id
         self.types: dict[Key, CurrentType] = {}
-        self.unreachable = False
+        self.unreachable: UnreachableType | None = None
         self.conditional_frame = conditional_frame
         self.suppress_unreachable_warnings = False
 
@@ -161,8 +167,11 @@ def put(self, expr: Expression, typ: Type, *, from_assignment: bool = True) -> N
             self._add_dependencies(key)
         self._put(key, typ, from_assignment)
 
-    def unreachable(self) -> None:
-        self.frames[-1].unreachable = True
+    def unreachable(self, from_semanal: bool = False) -> None:
+        unreachable_type = UnreachableType.BINDER_UNREACHABLE
+        if from_semanal:
+            unreachable_type = UnreachableType.SEMANAL_UNREACHABLE
+        self.frames[-1].unreachable = unreachable_type
 
     def suppress_unreachable_warnings(self) -> None:
         self.frames[-1].suppress_unreachable_warnings = True
@@ -175,12 +184,22 @@ def get(self, expr: Expression) -> Type | None:
             return None
         return found.type
 
-    def is_unreachable(self) -> bool:
+    def is_unreachable(self) -> UnreachableType | None:
         # TODO: Copy the value of unreachable into new frames to avoid
         # this traversal on every statement?
-        return any(f.unreachable for f in self.frames)
+        unreachable_type = None
+        for f in self.frames:
+            if f.unreachable and not unreachable_type:
+                unreachable_type = f.unreachable
+            elif f.unreachable == UnreachableType.SEMANAL_UNREACHABLE:
+                unreachable_type = f.unreachable
+        return unreachable_type
 
     def is_unreachable_warning_suppressed(self) -> bool:
+        # Do not report unreachable warnings from frames that were marked
+        # unreachable by the semanal_pass1.
+        if self.is_unreachable() == UnreachableType.SEMANAL_UNREACHABLE:
+            return True
         return any(f.suppress_unreachable_warnings for f in self.frames)
 
     def cleanse(self, expr: Expression) -> None:
@@ -202,6 +221,12 @@ def update_from_options(self, frames: list[Frame]) -> bool:
         If a key is declared as AnyType, only update it if all the
         options are the same.
         """
+        if all(f.unreachable for f in frames):
+            semanal_unreachable = any(
+                f.unreachable == UnreachableType.SEMANAL_UNREACHABLE for f in frames
+            )
+            self.unreachable(from_semanal=semanal_unreachable)
+
         all_reachable = all(not f.unreachable for f in frames)
         frames = [f for f in frames if not f.unreachable]
         changed = False
@@ -262,8 +287,6 @@ def update_from_options(self, frames: list[Frame]) -> bool:
                 self._put(key, type, from_assignment=True)
                 changed = True
 
-        self.frames[-1].unreachable = not frames
-
         return changed
 
     def pop_frame(self, can_skip: bool, fall_through: int) -> Frame:
@@ -411,7 +434,7 @@ def allow_jump(self, index: int) -> None:
         for f in self.frames[index + 1 :]:
             frame.types.update(f.types)
             if f.unreachable:
-                frame.unreachable = True
+                frame.unreachable = f.unreachable
         self.options_on_return[index].append(frame)
 
     def handle_break(self) -> None:

mypy/checker.py

@@ -3021,7 +3021,7 @@ def visit_block(self, b: Block) -> None:
             # This block was marked as being unreachable during semantic analysis.
             # It turns out any blocks marked in this way are *intentionally* marked
             # as unreachable -- so we don't display an error.
-            self.binder.unreachable()
+            self.binder.unreachable(from_semanal=True)
             return
         for s in b.body:
             if self.binder.is_unreachable():
@@ -4871,14 +4871,6 @@ def visit_if_stmt(self, s: IfStmt) -> None:
                 if s.else_body:
                     self.accept(s.else_body)
 
-        # If this if-statement had a block that is considered always true for
-        # semantic reachability in semanal_pass1 and it has no else block;
-        # then we surpress unreachable warnings for code after the
-        # if-statement. These can be caused by early returns or raises and
-        # are only applicable on certain platforms or versions.
-        if s.has_pass1_always_true_block and s.else_body and (not s.else_body.body):
-            self.binder.suppress_unreachable_warnings()
-
     def visit_while_stmt(self, s: WhileStmt) -> None:
         """Type check a while statement."""
         if_stmt = IfStmt([s.expr], [s.body], None)

mypy/nodes.py

@@ -1523,27 +1523,20 @@ def accept(self, visitor: StatementVisitor[T]) -> T:
 
 
 class IfStmt(Statement):
-    __slots__ = ("expr", "body", "else_body", "has_pass1_always_true_block")
+    __slots__ = ("expr", "body", "else_body")
 
-    __match_args__ = ("expr", "body", "else_body", "has_pass1_always_true_block")
+    __match_args__ = ("expr", "body", "else_body")
 
     expr: list[Expression]
     body: list[Block]
     else_body: Block | None
     pass1_always_true_block: bool
 
-    def __init__(
-        self,
-        expr: list[Expression],
-        body: list[Block],
-        else_body: Block | None,
-        has_pass1_always_true_block: bool = False,
-    ) -> None:
+    def __init__(self, expr: list[Expression], body: list[Block], else_body: Block | None) -> None:
         super().__init__()
         self.expr = expr
         self.body = body
         self.else_body = else_body
-        self.has_pass1_always_true_block = has_pass1_always_true_block
 
     def accept(self, visitor: StatementVisitor[T]) -> T:
         return visitor.visit_if_stmt(self)

mypy/reachability.py

@@ -57,7 +57,6 @@ def infer_reachability_of_if_statement(s: IfStmt, options: Options) -> None:
             # The condition is considered always false, so we skip the if/elif body.
             mark_block_unreachable(s.body[i])
         elif result in (ALWAYS_TRUE, MYPY_TRUE):
-            s.has_pass1_always_true_block = True
             # This condition is considered always true, so all of the remaining
             # elif/else bodies should not be checked.
             if result == MYPY_TRUE:

test-data/unit/check-unreachable-code.test

@@ -395,17 +395,16 @@ def foo() -> int:
 [builtins fixtures/ops.pyi]
 [out]
 
--- TODO: We currently suppress unreachability warnings past semantic
--- reachability checks. Need to decide if this should be fixed and enabled.
-[case testSysPlatformEarlyReturnActualUnreachableCodeNotForPlatform-skip]
+[case testSysPlatformEarlyReturnActualUnreachableCodeNotForPlatform]
 # flags: --warn-unreachable
 import sys
 
 def foo() -> int:
     if sys.platform != 'fictional':
         return 1
     return 0
-    return 0 + 1  # E: Statement is unreachable
+    return 0 + 1  # Will not throw `Statement is unreachable` because we are
+                  # not on the fictional platform.
 [builtins fixtures/ops.pyi]
 [out]