Add support for tuple values on except clauses

Issue #1590

Author: pdmccormick

mypy/checker.py

@@ -1839,18 +1839,38 @@ def exception_type(self, n: Node) -> Type:
         self.fail('Unsupported exception', n)
         return AnyType()
 
+    def check_for_function_like_exception_type(self, type: Type, context: Context) -> Type:
+        if not isinstance(type, FunctionLike):
+            return None
+
+        item = type.items()[0]
+        ret = item.ret_type
+        if (is_subtype(ret, self.named_type('builtins.BaseException'))
+                and item.is_type_obj()):
+            return ret
+        else:
+            self.fail(messages.INVALID_EXCEPTION_TYPE, context)
+            return AnyType()
+
     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'))
-                    and item.is_type_obj()):
-                return ret
-            else:
-                self.fail(messages.INVALID_EXCEPTION_TYPE, context)
-                return AnyType()
+        ret = self.check_for_function_like_exception_type(type, context)
+        if ret is not None:
+            return ret
         elif isinstance(type, AnyType):
             return AnyType()
+        elif isinstance(type, TupleType):
+            t = None  # type: Type
+            for item in type.items:
+                tt = self.check_for_function_like_exception_type(item, context)
+
+                if tt is None:
+                    tt = AnyType()
+
+                if t:
+                    t = join_types(t, tt)
+                else:
+                    t = tt
+            return t
         else:
             self.fail(messages.INVALID_EXCEPTION_TYPE, context)
             return AnyType()

mypy/test/data/check-statements.test

@@ -573,6 +573,8 @@ 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 testReuseTryExceptionVariable]
@@ -618,6 +620,36 @@ 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 E2(E1): pass
+class E3(E1): pass
+
+exs1 = (E1, E2)
+try: pass
+except exs1 as e1:
+    reveal_type(e1) # E: Revealed type is '__main__.E1'
+
+exs3 = (E2, E3)
+try: pass
+except exs3 as e3:
+    reveal_type(e3) # E: Revealed type is '__main__.E1'
+[builtins fixtures/exception.py]
+
+[case testInvalidTupleValueAsExceptionType]
+import typing
+def exc() -> BaseException: pass
+class E1(BaseException): pass
+class E2(E1): pass
+class E3(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):