Merge branch 'master' into update-imports

Author: JelleZijlstra

mypy/argmap.py

@@ -36,8 +36,8 @@ def map_actuals_to_formals(
     The result contains a list of caller argument indexes mapping to each
     callee argument index, indexed by callee index.
 
-    The caller_arg_type argument should evaluate to the type of the actual
-    argument type with the given index.
+    The actual_arg_type argument should evaluate to the type of the actual
+    argument with the given index.
     """
     nformals = len(formal_kinds)
     formal_to_actual: list[list[int]] = [[] for i in range(nformals)]

mypy/checker.py

@@ -5307,16 +5307,22 @@ def get_types_from_except_handler(self, typ: Type, n: Expression) -> list[Type]:
         """Helper for check_except_handler_test to retrieve handler types."""
         typ = get_proper_type(typ)
         if isinstance(typ, TupleType):
-            return typ.items
+            merged_type = make_simplified_union(typ.items)
+            if isinstance(merged_type, UnionType):
+                return merged_type.relevant_items()
+            return [merged_type]
+        elif is_named_instance(typ, "builtins.tuple"):
+            # variadic tuple
+            merged_type = make_simplified_union((typ.args[0],))
+            if isinstance(merged_type, UnionType):
+                return merged_type.relevant_items()
+            return [merged_type]
         elif isinstance(typ, UnionType):
             return [
                 union_typ
                 for item in typ.relevant_items()
                 for union_typ in self.get_types_from_except_handler(item, n)
             ]
-        elif is_named_instance(typ, "builtins.tuple"):
-            # variadic tuple
-            return [typ.args[0]]
         else:
             return [typ]
 

mypy/fastparse.py

@@ -286,7 +286,7 @@ def parse_type_ignore_tag(tag: str | None) -> list[str] | None:
     if m is None:
         # Invalid "# type: ignore" comment.
         return None
-    return [code.strip() for code in m.group(1).split(",")]
+    return [stripped_code for code in m.group(1).split(",") if (stripped_code := code.strip())]
 
 
 def parse_type_comment(

test-data/unit/check-errorcodes.test

@@ -118,6 +118,20 @@ x              # type: ignore[name-defined]                # E: Unused "type: ig
 "x"  # type: ignore[xyz, unused-ignore]
 x    # type: ignore[name-defined, unused-ignore]
 
+[case testErrorCodeWarnUnusedIgnores9_SloppyFormattingNotEmptyBrackets]
+# flags: --warn-unused-ignores
+1 + "ok" + "ok".foo # type: ignore[  operator,attr-defined]
+1 + "ok" + "ok".foo # type: ignore[  ,operator,attr-defined]
+1 + "ok" + "ok".foo # type: ignore[  operator,attr-defined,]
+1 + "ok" + "ok".foo # type: ignore[  operator,attr-defined,,]
+
+[case testErrorCodeWarnUnusedIgnores10_SloppyFormattingEmptyBrackets]
+# flags: --warn-unused-ignores
+1+1 # type: ignore    # E: Unused "type: ignore" comment  [unused-ignore]
+1+1 # type: ignore[]  # E: Unused "type: ignore" comment  [unused-ignore]
+1+1 # type: ignore[ ] # E: Unused "type: ignore" comment  [unused-ignore]
+1+1 # type: ignore[,,, ] # E: Unused "type: ignore" comment  [unused-ignore]
+
 [case testErrorCodeMissingWhenRequired]
 # flags: --enable-error-code ignore-without-code
 "x" # type: ignore # E: "type: ignore" comment without error code  [ignore-without-code]

test-data/unit/check-statements.test

@@ -801,6 +801,57 @@ def error_in_variadic(exc: Tuple[int, ...]) -> None:
 
 [builtins fixtures/tuple.pyi]
 
+[case testExceptWithMultipleTypes5]
+from typing import Tuple, Type, Union
+
+class E1(BaseException): pass
+class E2(BaseException): pass
+class E3(BaseException): pass
+
+def union_in_variadic(exc: Tuple[Union[Type[E1], Type[E2]], ...]) -> None:
+    try:
+        pass
+    except exc as e:
+        reveal_type(e)  # N: Revealed type is "Union[__main__.E1, __main__.E2]"
+
+def nested_union_in_variadic(exc: Tuple[Union[Type[E1], Union[Type[E2], Type[E3]]], ...]) -> None:
+    try:
+        pass
+    except exc as e:
+        reveal_type(e)  # N: Revealed type is "Union[__main__.E1, __main__.E2, __main__.E3]"
+
+def union_in_tuple(exc: Tuple[Union[Type[E1], Type[E2]], Type[E3]]) -> None:
+    try:
+        pass
+    except exc as e:
+        reveal_type(e)  # N: Revealed type is "Union[__main__.E1, __main__.E2, __main__.E3]"
+
+def error_in_variadic_union(exc: Tuple[Union[Type[E1], int], ...]) -> None:
+    try:
+        pass
+    except exc as e:  # E: Exception type must be derived from BaseException (or be a tuple of exception classes)
+        pass
+
+def error_in_variadic_nested_union(exc: Tuple[Union[Type[E1], Union[Type[E2], int]], ...]) -> None:
+    try:
+        pass
+    except exc as e:  # E: Exception type must be derived from BaseException (or be a tuple of exception classes)
+        pass
+
+def error_in_tuple_inside_variadic_nested_union(exc: Tuple[Union[Type[E1], Union[Type[E2], Tuple[Type[E3]]]], ...]) -> None:
+    try:
+        pass
+    except exc as e:  # E: Exception type must be derived from BaseException (or be a tuple of exception classes)
+        pass
+
+def error_in_tuple_union(exc: Tuple[Union[Type[E1], Type[E2]], Union[Type[E3], int]]) -> None:
+    try:
+        pass
+    except exc as e:  # E: Exception type must be derived from BaseException (or be a tuple of exception classes)
+        pass
+
+[builtins fixtures/tuple.pyi]
+
 [case testExceptWithAnyTypes]
 from typing import Any