Fixes for try/finally binder

Author: ecprice

mypy/checker.py

@@ -1539,18 +1539,45 @@ def type_check_raise(self, e: Node, s: RaiseStmt) -> None:
 
     def visit_try_stmt(self, s: TryStmt) -> Type:
         """Type check a try statement."""
+        # Our enclosing frame will get the result if the try/except falls through.
+        # This one gets all possible intermediate states
+        with self.binder.frame_context():
+            if s.finally_body:
+                self.binder.try_frames.add(len(self.binder.frames) - 1)
+                broken = self.visit_try_without_finally(s)
+                self.binder.try_frames.remove(len(self.binder.frames) - 1)
+                # First we check finally_body is type safe for all intermediate frames
+                self.accept(s.finally_body)
+                broken = broken or self.binder.breaking_out
+            else:
+                broken = self.visit_try_without_finally(s)
+
+        if not broken and s.finally_body:
+            # Then we try again for the more restricted set of options that can fall through
+            self.accept(s.finally_body)
+        self.binder.breaking_out = broken
+        return None
+
+    def visit_try_without_finally(self, s: TryStmt) -> bool:
+        """Type check a try statement, ignoring the finally block.
+
+        Return whether we are guaranteed to be breaking out.
+        Otherwise, it will place the results possible frames of
+        that don't break out into self.binder.frames[-2].
+        """
         broken = True
         # This frame records the possible states that exceptions can leave variables in
+        # during the try: block
         with self.binder.frame_context():
-            with self.binder.frame_context(2) as frame:
+            with self.binder.frame_context(3) as frame:
                 self.binder.try_frames.add(len(self.binder.frames) - 2)
                 self.accept(s.body)
                 self.binder.try_frames.remove(len(self.binder.frames) - 2)
                 if s.else_body:
                     self.accept(s.else_body)
             broken = broken and frame.broken
             for i in range(len(s.handlers)):
-                with self.binder.frame_context(2) as frame:
+                with self.binder.frame_context(3) as frame:
                     if s.types[i]:
                         t = self.visit_except_handler_test(s.types[i])
                         if s.vars[i]:
@@ -1575,11 +1602,7 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
                         var.type = DeletedType(source=source)
                         self.binder.cleanse(s.vars[i])
                 broken = broken and frame.broken
-
-        if s.finally_body:
-            self.accept(s.finally_body)
-        if broken:
-            self.binder.breaking_out = True
+        return broken
 
     def visit_except_handler_test(self, n: Node) -> Type:
         """Type check an exception handler test clause."""

test-data/unit/check-isinstance.test

@@ -279,6 +279,78 @@ while 1:
         x = B()
     x.z
 [builtins fixtures/exception.py]
+[case testUnionTryFinally]
+class A: pass
+class B(A): b = 1
+
+x = A()
+x = B()
+try:
+    x = A()
+    x.b # E: "A" has no attribute "b"
+    x = B()
+finally:
+    x.b  # E: "A" has no attribute "b"
+x.b
+[case testUnionTryFinally2]
+class A: pass
+class B(A): b = 1
+
+x = A()
+x = B()
+try:
+    x = A()
+    x = B()
+except:
+    pass
+finally:
+    pass
+x.b      # E: "A" has no attribute "b"
+[case testUnionTryFinally3]
+class A: pass
+class B(A): b = 1
+
+x = A()
+x = B()
+try:
+    x = A()
+    x = B()
+except:
+    pass
+finally:
+    x = B()
+x.b
+[case testUnionTryFinally4]
+class A: pass
+class B(A): b = 1
+
+while 2:
+    x = A()
+    x = B()
+    try:
+        x = A()
+        x = B()
+    except:
+        pass
+    finally:
+        if not isinstance(x, B):
+            break
+    x.b
+[builtins fixtures/isinstancelist.py]
+[case testUnionTryFinally5]
+class A: pass
+class B(A): b = 1
+
+while 2:
+    x = A()
+    try:
+        x = A()
+        x = B()
+    finally:
+        x.b    # E: "A" has no attribute "b"
+        break
+        x.b
+    x.b
 [case testUnionListIsinstance]
 
 from typing import Union, List