Add support for tuple values on except clauses

mypy/checker.py

@@ -1782,7 +1782,7 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
         for i in range(len(s.handlers)):
             self.binder.push_frame()
             if s.types[i]:
-                t = self.exception_type(s.types[i])
+                t = self.visit_except_handler_test(s.types[i])
                 if s.vars[i]:
                     # To support local variables, we make this a definition line,
                     # causing assignment to set the variable's type.
@@ -1822,38 +1822,30 @@ def visit_try_stmt(self, s: TryStmt) -> Type:
         if s.finally_body:
             self.accept(s.finally_body)
 
-    def exception_type(self, n: Node) -> Type:
-        if isinstance(n, TupleExpr):
-            t = None  # type: Type
-            for item in n.items:
-                tt = self.exception_type(item)
-                if t:
-                    t = join_types(t, tt)
-                else:
-                    t = tt
-            return t
-        else:
-            # A single exception type; should evaluate to a type object type.
-            type = self.accept(n)
-            return self.check_exception_type(type, n)
-        self.fail('Unsupported exception', n)
-        return AnyType()
+    def visit_except_handler_test(self, n: Node) -> Type:
+        """Type check an exception handler test clause."""
+        type = self.accept(n)
+        if isinstance(type, AnyType):
+            return type
 
-    def check_exception_type(self, type: Type, context: Context) -> Type:
-        if isinstance(type, FunctionLike):
-            item = type.items()[0]
-            ret = item.ret_type
-            if (is_subtype(ret, self.named_type('builtins.BaseException'))
+        all_types = []  # type: List[Type]
+        test_types = type.items if isinstance(type, TupleType) else [type]
+
+        for ttype in test_types:
+            if not isinstance(ttype, FunctionLike):
+                self.fail(messages.INVALID_EXCEPTION_TYPE, n)
+                return AnyType()
+
+            item = ttype.items()[0]
+            ret_type = item.ret_type
+            if not (is_subtype(ret_type, self.named_type('builtins.BaseException'))
                     and item.is_type_obj()):
-                return ret
-            else:
-                self.fail(messages.INVALID_EXCEPTION_TYPE, context)
+                self.fail(messages.INVALID_EXCEPTION_TYPE, n)
                 return AnyType()
-        elif isinstance(type, AnyType):
-            return AnyType()
-        else:
-            self.fail(messages.INVALID_EXCEPTION_TYPE, context)
-            return AnyType()
+
+            all_types.append(ret_type)
+
+        return UnionType.make_simplified_union(all_types)
 
     def visit_for_stmt(self, s: ForStmt) -> Type:
         """Type check a for statement."""

mypy/test/data/check-statements.test

@@ -573,6 +573,24 @@ except (E1, E2) as e1:
 except (E2, E1) as e2:
     a = e2 # type: E1
     b = e2 # type: E2 # E: Incompatible types in assignment (expression has type "E1", variable has type "E2")
+except (E1, E2, int) as e3: # E: Exception type must be derived from BaseException
+    pass
+[builtins fixtures/exception.py]
+
+[case testExceptWithMultipleTypes3]
+import typing
+class E1(BaseException): pass
+class E1_1(E1): pass
+class E1_2(E1): pass
+try: pass
+except (E1, E1_1, E1_2) as e1:
+    x = e1 # type: E1
+    y = e1 # type: E1_1 # E: Incompatible types in assignment (expression has type "E1", variable has type "E1_1")
+    z = e1 # type: E1_2 # E: Incompatible types in assignment (expression has type "E1", variable has type "E1_2")
+except (E1_1, E1_2) as e2:
+    a = e2 # type: E1
+    b = e2 # type: E1_1 # E: Incompatible types in assignment (expression has type "Union[E1_1, E1_2]", variable has type "E1_1")
+    c = e2 # type: E1_2 # E: Incompatible types in assignment (expression has type "Union[E1_1, E1_2]", variable has type "E1_2")
 [builtins fixtures/exception.py]
 
 [case testReuseTryExceptionVariable]
@@ -618,6 +636,39 @@ except exc as e: pass             # E: Exception type must be derived from BaseE
 except BaseException() as b: pass # E: Exception type must be derived from BaseException
 [builtins fixtures/exception.py]
 
+[case testTupleValueAsExceptionType]
+import typing
+def exc() -> BaseException: pass
+class E1(BaseException): pass
+class E1_1(E1): pass
+class E1_2(E1): pass
+
+exs1 = (E1, E1_1, E1_2)
+try: pass
+except exs1 as e1:
+    x = e1 # type: E1
+    y = e1 # type: E1_1 # E: Incompatible types in assignment (expression has type "E1", variable has type "E1_1")
+    z = e1 # type: E1_2 # E: Incompatible types in assignment (expression has type "E1", variable has type "E1_2")
+
+exs2 = (E1_1, E1_2)
+try: pass
+except exs2 as e2:
+    a = e2 # type: E1
+    b = e2 # type: E1_1 # E: Incompatible types in assignment (expression has type "Union[E1_1, E1_2]", variable has type "E1_1")
+    c = e2 # type: E1_2 # E: Incompatible types in assignment (expression has type "Union[E1_1, E1_2]", variable has type "E1_2")
+[builtins fixtures/exception.py]
+
+[case testInvalidTupleValueAsExceptionType]
+import typing
+def exc() -> BaseException: pass
+class E1(BaseException): pass
+class E2(E1): pass
+
+exs1 = (E1, E2, int)
+try: pass
+except exs1 as e: pass # E: Exception type must be derived from BaseException
+[builtins fixtures/exception.py]
+
 [case testOverloadedExceptionType]
 from typing import overload
 class E(BaseException):