reworked is_valid_keyword_var_arg

Author: randolf-scholz

mypy/checkexpr.py

@@ -6144,9 +6144,29 @@ def is_valid_var_arg(self, typ: Type) -> bool:
     def is_valid_keyword_var_arg(self, typ: Type) -> bool:
         """Is a type valid as a **kwargs argument?"""
         typ = get_proper_type(typ)
-        if isinstance(typ, ParamSpecType | AnyType):
+
+        # factorize over unions
+        if isinstance(typ, UnionType):
+            return all(self.is_valid_keyword_var_arg(item) for item in typ.items)
+
+        if isinstance(typ, AnyType):
             return True
 
+        if isinstance(typ, ParamSpecType):
+            return typ.flavor == ParamSpecFlavor.KWARGS
+
+        # fast path for builtins.dict
+        if isinstance(typ, Instance) and typ.type.fullname == "builtins.dict":
+            return is_subtype(typ.args[0], self.named_type("builtins.str"))
+
+        # fast fail if not SupportsKeysAndGetItem[Any, Any]
+        any_type = AnyType(TypeOfAny.from_omitted_generics)
+        if not is_subtype(
+            typ,
+            self.chk.named_generic_type("_typeshed.SupportsKeysAndGetItem", [any_type, any_type]),
+        ):
+            return False
+
         # Check if 'typ' is a SupportsKeysAndGetItem[T, Any] for some T <: str
         # Note: is_subtype(typ, SupportsKeysAndGetItem[str, Any])` is too harsh
         #   since SupportsKeysAndGetItem is invariant in the key type parameter.
@@ -6158,11 +6178,9 @@ def is_valid_keyword_var_arg(self, typ: Type) -> bool:
             id=TypeVarId(-1, namespace="<kwargs>"),
             values=[],
             upper_bound=self.named_type("builtins.str"),
-            default=AnyType(TypeOfAny.from_omitted_generics),
-        )
-        template = self.chk.named_generic_type(
-            "_typeshed.SupportsKeysAndGetItem", [T, AnyType(TypeOfAny.special_form)]
+            default=any_type,
         )
+        template = self.chk.named_generic_type("_typeshed.SupportsKeysAndGetItem", [T, any_type])
 
         return solve_as_subtype(typ, template) is not None
 

mypy/messages.py

@@ -1401,7 +1401,7 @@ def invalid_var_arg(self, typ: Type, context: Context) -> None:
 
     def invalid_keyword_var_arg(self, typ: Type, is_mapping: bool, context: Context) -> None:
         typ = get_proper_type(typ)
-        if isinstance(typ, Instance) and is_mapping:
+        if is_mapping:
             self.fail("Argument after ** must have string keys", context, code=codes.ARG_TYPE)
         else:
             self.fail(

test-data/unit/check-kwargs.test

@@ -572,7 +572,7 @@ main:41: error: Argument 1 to "foo" has incompatible type "**dict[str, str]"; ex
 [builtins fixtures/dict.pyi]
 
 [case testLiteralKwargs]
-from typing import Literal, Mapping, Iterable
+from typing import Literal, Mapping, Iterable, Union
 def func(a: int, b: int) -> None: ...
 
 class GOOD_KW:
@@ -597,4 +597,19 @@ def test(
     func(**bad_dict)  # E: Argument after ** must have string keys
     func(**good_mapping)
     func(**bad_mapping)  # E: Argument after ** must have string keys
+
+def test_union(
+    good_kw: Union[GOOD_KW, dict[str, int]],
+    bad_kw: Union[BAD_KW, dict[str, int]],
+    good_dict: Union[dict[Literal["a", "b"], int], dict[str, int]],
+    bad_dict: Union[dict[Literal["one", 1], int], dict[str, int]],
+    good_mapping: Union[Mapping[Literal["a", "b"], int], dict[str, int]],
+    bad_mapping: Union[Mapping[Literal["one", 1], int], dict[str, int]],
+) -> None:
+    func(**good_kw)
+    func(**bad_kw)  # E: Argument after ** must have string keys
+    func(**good_dict)
+    func(**bad_dict)  # E: Argument after ** must have string keys
+    func(**good_mapping)
+    func(**bad_mapping)  # E: Argument after ** must have string keys
 [builtins fixtures/dict.pyi]

test-data/unit/check-parameter-specification.test

@@ -461,14 +461,16 @@ class C(Generic[P, P2]):
         self.m1(*args, **kwargs)
         self.m2(*args, **kwargs)  # E: Argument 1 to "m2" of "C" has incompatible type "*P.args"; expected "P2.args" \
             # E: Argument 2 to "m2" of "C" has incompatible type "**P.kwargs"; expected "P2.kwargs"
-        self.m1(*kwargs, **args)  # E: Argument 1 to "m1" of "C" has incompatible type "*P.kwargs"; expected "P.args" \
-            # E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"
+        self.m1(*kwargs, **args)  # E: Argument after ** must be a mapping, not "P.args" \
+                                  # E: Argument 1 to "m1" of "C" has incompatible type "*P.kwargs"; expected "P.args" \
+                                  # E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"
         self.m3(*args, **kwargs)  # E: Argument 1 to "m3" of "C" has incompatible type "*P.args"; expected "int" \
             # E: Argument 2 to "m3" of "C" has incompatible type "**P.kwargs"; expected "int"
         self.m4(*args, **kwargs)  # E: Argument 1 to "m4" of "C" has incompatible type "*P.args"; expected "int" \
             # E: Argument 2 to "m4" of "C" has incompatible type "**P.kwargs"; expected "int"
 
-        self.m1(*args, **args)  # E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"
+        self.m1(*args, **args)  # E: Argument after ** must be a mapping, not "P.args" \
+                                # E: Argument 2 to "m1" of "C" has incompatible type "**P.args"; expected "P.kwargs"
         self.m1(*kwargs, **kwargs)  # E: Argument 1 to "m1" of "C" has incompatible type "*P.kwargs"; expected "P.args"
 
     def m2(self, *args: P2.args, **kwargs: P2.kwargs) -> None:
@@ -479,6 +481,10 @@ class C(Generic[P, P2]):
 
     def m4(self, x: int) -> None:
         pass
+
+
+
+
 [builtins fixtures/dict.pyi]
 
 [case testParamSpecOverUnannotatedDecorator]