Apply the fix propsed by @ecprice instead. With tests

Author: Guido van Rossum

mypy/checker.py

@@ -202,6 +202,8 @@ def check_second_pass(self) -> bool:
         for node, type_name in todo:
             if node in done:
                 continue
+            ## print('REDO %d %s.%s' %
+            ##       (self.pass_num, type_name or '', node.fullname() or node.name()))
             done.add(node)
             if type_name:
                 self.errors.push_type(type_name)
@@ -1704,7 +1706,12 @@ def visit_try_without_finally(self, s: TryStmt, try_frame: bool) -> None:
                                 # To support local variables, we make this a definition line,
                                 # causing assignment to set the variable's type.
                                 s.vars[i].is_def = True
+                                # We also temporarily set current_node_deferred to False to
+                                # make sure the inference happens.
+                                am_deferring = self.current_node_deferred
+                                self.current_node_deferred = False
                                 self.check_assignment(s.vars[i], self.temp_node(t, s.vars[i]))
+                                self.current_node_deferred = am_deferring
                         self.accept(s.handlers[i])
                         if s.vars[i]:
                             # Exception variables are deleted in python 3 but not python 2.
@@ -1720,8 +1727,7 @@ def visit_try_without_finally(self, s: TryStmt, try_frame: bool) -> None:
                                           'accept outside except: blocks even in '
                                           'python 2)'.format(s.vars[i].name))
                             var = cast(Var, s.vars[i].node)
-                            if not self.current_node_deferred:
-                                var.type = DeletedType(source=source)
+                            var.type = DeletedType(source=source)
                             self.binder.cleanse(s.vars[i])
             if s.else_body:
                 self.accept(s.else_body)

test-data/unit/check-statements.test

@@ -717,6 +717,79 @@ def f(*a: BaseException) -> int:
 x = f()
 [builtins fixtures/exception.pyi]
 
+[case testExceptionVariableReuseInDeferredNode4]
+class EA(BaseException):
+    a = None  # type: int
+class EB(BaseException):
+    b = None  # type: str
+def f(*arg: BaseException) -> int:
+    x
+    try: pass
+    except EA as err:
+        f(err)
+        a = err.a
+        reveal_type(a)
+    try: pass
+    except EB as err:
+        f(err)
+        b = err.b
+        reveal_type(b)
+x = f()
+[builtins fixtures/exception.pyi]
+[out]
+main: note: In function "f":
+main:11: error: Revealed type is 'builtins.int'
+main:16: error: Revealed type is 'builtins.str'
+
+[case testExceptionVariableReuseInDeferredNode5]
+class EA(BaseException):
+    a = None  # type: int
+class EB(BaseException):
+    b = None  # type: str
+def f(*arg: BaseException) -> int:
+    try: pass
+    except EA as err:
+        f(err)
+        a = err.a
+        reveal_type(a)
+    x
+    try: pass
+    except EB as err:
+        f(err)
+        b = err.b
+        reveal_type(b)
+x = f()
+[builtins fixtures/exception.pyi]
+[out]
+main: note: In function "f":
+main:10: error: Revealed type is 'builtins.int'
+main:16: error: Revealed type is 'builtins.str'
+
+[case testExceptionVariableReuseInDeferredNode6]
+class EA(BaseException):
+    a = None  # type: int
+class EB(BaseException):
+    b = None  # type: str
+def f(*arg: BaseException) -> int:
+    try: pass
+    except EA as err:
+        f(err)
+        a = err.a
+        reveal_type(a)
+    try: pass
+    except EB as err:
+        f(err)
+        b = err.b
+        reveal_type(b)
+    x
+x = f()
+[builtins fixtures/exception.pyi]
+[out]
+main: note: In function "f":
+main:10: error: Revealed type is 'builtins.int'
+main:15: error: Revealed type is 'builtins.str'
+
+
 
 [case testArbitraryExpressionAsExceptionType]
 import typing