Decouple checker and binder by adding more options to frame_context

No more poking around by the checker in loop_frames and try_frames.

Author: rwbarton

mypy/binder.py

@@ -73,7 +73,8 @@ def __init__(self) -> None:
         self.last_pop_changed = False
 
         self.try_frames = set()  # type: Set[int]
-        self.loop_frames = []  # type: List[int]
+        self.break_frames = []  # type: List[int]
+        self.continue_frames = []  # type: List[int]
 
     def _add_dependencies(self, key: Key, value: Key = None) -> None:
         if value is None:
@@ -266,14 +267,18 @@ def allow_jump(self, index: int) -> None:
                 frame.unreachable = True
         self.options_on_return[index].append(frame)
 
-    def push_loop_frame(self) -> None:
-        self.loop_frames.append(len(self.frames) - 1)
+    def handle_break(self) -> None:
+        self.allow_jump(self.break_frames[-1])
+        self.unreachable()
 
-    def pop_loop_frame(self) -> None:
-        self.loop_frames.pop()
+    def handle_continue(self) -> None:
+        self.allow_jump(self.continue_frames[-1])
+        self.unreachable()
 
     @contextmanager
-    def frame_context(self, *, can_skip: bool, fall_through: int = 1) -> Iterator[Frame]:
+    def frame_context(self, *, can_skip: bool, fall_through: int = 1,
+                      break_frame: int = 0, continue_frame: int = 0,
+                      try_frame: bool = False) -> Iterator[Frame]:
         """Return a context manager that pushes/pops frames on enter/exit.
 
         If can_skip is True, control flow is allowed to bypass the
@@ -284,14 +289,43 @@ def frame_context(self, *, can_skip: bool, fall_through: int = 1) -> Iterator[Fr
         `fall_through` levels higher. Otherwise control flow ends
         at the end of the frame.
 
+        If break_frame > 0, then 'break' statements within this frame
+        will jump out to the frame break_frame levels higher than the
+        frame created by this call to frame_context. Similarly for
+        continue_frame and 'continue' statements.
+
+        If try_frame is true, then execution is allowed to jump at any
+        point within the newly created frame (or its descendents) to
+        its parent (i.e., to the frame that was on top before this
+        call to frame_context).
+
         After the context manager exits, self.last_pop_changed indicates
         whether any types changed in the newly-topmost frame as a result
         of popping this frame.
         """
         assert len(self.frames) > 1
-        yield self.push_frame()
+
+        if break_frame:
+            self.break_frames.append(len(self.frames) - break_frame)
+        if continue_frame:
+            self.continue_frames.append(len(self.frames) - continue_frame)
+        if try_frame:
+            self.try_frames.add(len(self.frames) - 1)
+
+        new_frame = self.push_frame()
+        if try_frame:
+            # An exception may occur immediately
+            self.allow_jump(-1)
+        yield new_frame
         self.pop_frame(can_skip, fall_through)
 
+        if break_frame:
+            self.break_frames.pop()
+        if continue_frame:
+            self.continue_frames.pop()
+        if try_frame:
+            self.try_frames.remove(len(self.frames) - 1)
+
     @contextmanager
     def top_frame_context(self) -> Iterator[Frame]:
         """A variant of frame_context for use at the top level of

mypy/checker.py

@@ -233,13 +233,12 @@ def accept_loop(self, body: Node, else_body: Node = None, *,
         """
         # The outer frame accumulates the results of all iterations
         with self.binder.frame_context(can_skip=False):
-            self.binder.push_loop_frame()
             while True:
-                with self.binder.frame_context(can_skip=True):
+                with self.binder.frame_context(can_skip=True,
+                                               break_frame=2, continue_frame=1):
                     self.accept(body)
                 if not self.binder.last_pop_changed:
                     break
-            self.binder.pop_loop_frame()
             if exit_condition:
                 _, else_map = self.find_isinstance_check(exit_condition)
                 self.push_type_map(else_map)
@@ -1639,19 +1638,17 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
         # This one gets all possible states after the try block exited abnormally
         # (by exception, return, break, etc.)
         with self.binder.frame_context(can_skip=False, fall_through=0):
+            # Not only might the body of the try statement exit
+            # abnormally, but so might an exception handler or else
+            # clause. The finally clause runs in *all* cases, so we
+            # need an outer try frame to catch all intermediate states
+            # in case an exception is raised during an except or else
+            # clause. As an optimization, only create the outer try
+            # frame when there actually is a finally clause.
+            self.visit_try_without_finally(s, try_frame=bool(s.finally_body))
             if s.finally_body:
-                # Not only might the body of the try statement exit abnormally,
-                # but so might an exception handler or else clause. The finally
-                # clause runs in *all* cases, so we need an outer try frame to
-                # catch all intermediate states in case an exception is raised
-                # during an except or else clause.
-                self.binder.try_frames.add(len(self.binder.frames) - 1)
-                self.visit_try_without_finally(s)
-                self.binder.try_frames.remove(len(self.binder.frames) - 1)
                 # First we check finally_body is type safe on all abnormal exit paths
                 self.accept(s.finally_body)
-            else:
-                self.visit_try_without_finally(s)
 
         if s.finally_body:
             # Then we try again for the more restricted set of options
@@ -1669,7 +1666,7 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
 
         return None
 
-    def visit_try_without_finally(self, s: TryStmt) -> None:
+    def visit_try_without_finally(self, s: TryStmt, try_frame: bool) -> None:
         """Type check a try statement, ignoring the finally block.
 
         On entry, the top frame should receive all flow that exits the
@@ -1680,15 +1677,12 @@ def visit_try_without_finally(self, s: TryStmt) -> None:
         # This frame will run the else block if the try fell through.
         # In that case, control flow continues to the parent of what
         # was the top frame on entry.
-        with self.binder.frame_context(can_skip=False, fall_through=2):
+        with self.binder.frame_context(can_skip=False, fall_through=2, try_frame=try_frame):
             # This frame receives exit via exception, and runs exception handlers
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 # Finally, the body of the try statement
-                with self.binder.frame_context(can_skip=False, fall_through=2):
-                    self.binder.try_frames.add(len(self.binder.frames) - 2)
-                    self.binder.allow_jump(-1)
+                with self.binder.frame_context(can_skip=False, fall_through=2, try_frame=True):
                     self.accept(s.body)
-                    self.binder.try_frames.remove(len(self.binder.frames) - 2)
                 for i in range(len(s.handlers)):
                     with self.binder.frame_context(can_skip=True, fall_through=4):
                         if s.types[i]:
@@ -2018,13 +2012,11 @@ def visit_member_expr(self, e: MemberExpr) -> Type:
         return self.expr_checker.visit_member_expr(e)
 
     def visit_break_stmt(self, s: BreakStmt) -> Type:
-        self.binder.allow_jump(self.binder.loop_frames[-1] - 1)
-        self.binder.unreachable()
+        self.binder.handle_break()
         return None
 
     def visit_continue_stmt(self, s: ContinueStmt) -> Type:
-        self.binder.allow_jump(self.binder.loop_frames[-1])
-        self.binder.unreachable()
+        self.binder.handle_continue()
         return None
 
     def visit_int_expr(self, e: IntExpr) -> Type: