fix testLiteralKwargs false positive for good_kw

Author: randolf-scholz

mypy/checkexpr.py

@@ -19,6 +19,7 @@
 from mypy.checkmember import analyze_member_access, has_operator
 from mypy.checkstrformat import StringFormatterChecker
 from mypy.constant_fold import constant_fold_expr
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints
 from mypy.erasetype import erase_type, remove_instance_last_known_values, replace_meta_vars
 from mypy.errors import ErrorInfo, ErrorWatcher, report_internal_error
 from mypy.expandtype import (
@@ -118,6 +119,7 @@
     Plugin,
 )
 from mypy.semanal_enum import ENUM_BASES
+from mypy.solve import solve_constraints
 from mypy.state import state
 from mypy.subtypes import (
     covers_at_runtime,
@@ -6143,28 +6145,41 @@ 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)
-        return (
-            (
-                # This is a little ad hoc, ideally we would have a map_instance_to_supertype
-                # that worked for protocols
-                isinstance(typ, Instance)
-                and typ.type.fullname == "builtins.dict"
-                and is_subtype(typ.args[0], self.named_type("builtins.str"))
-            )
-            or isinstance(typ, ParamSpecType)
-            or is_subtype(
-                typ,
-                self.chk.named_generic_type(
-                    "_typeshed.SupportsKeysAndGetItem",
-                    [self.named_type("builtins.str"), AnyType(TypeOfAny.special_form)],
-                ),
-            )
-            or is_subtype(
-                typ,
-                self.chk.named_generic_type(
-                    "_typeshed.SupportsKeysAndGetItem", [UninhabitedType(), UninhabitedType()]
-                ),
-            )
+        if isinstance(typ, ParamSpecType | AnyType):
+            return True
+
+        # 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.
+
+        # create a TypeVar and template type
+        T = TypeVarType(
+            "T",
+            "T",
+            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)]
+        )
+
+        # infer constraints and solve
+        constraints: list[Constraint] = [
+            # solve_constraints seems to completely ignore upper bounds.
+            # So we need to include it manually.
+            Constraint(T, SUBTYPE_OF, T.upper_bound),
+            *infer_constraints(template, typ, SUPERTYPE_OF),
+        ]
+        solution, _ = solve_constraints([T], constraints)
+        assert len(solution) == 1
+
+        return solution[0] is not None and is_subtype(
+            typ,
+            self.chk.named_generic_type(
+                "_typeshed.SupportsKeysAndGetItem", [solution[0], AnyType(TypeOfAny.special_form)]
+            ),
         )
 
     def not_ready_callback(self, name: str, context: Context) -> None:

test-data/unit/check-kwargs.test

@@ -572,11 +572,13 @@ main:41: error: Argument 1 to "foo" has incompatible type "**dict[str, str]"; ex
 [builtins fixtures/dict.pyi]
 
 [case testLiteralKwargs]
-from typing import Any, Literal
-kw: dict[Literal["a", "b"], Any]
-def func(a, b): ...
-func(**kw)
-
-bad_kw: dict[Literal["one", 1], Any]
-func(**bad_kw)  # E: Argument after ** must have string keys
+from typing import Literal
+def func(a: int, b: int) -> None: ...
+
+def test(
+    good_kw: dict[Literal["a", "b"], int],
+    bad_kw: dict[Literal["one", 1], int],
+) -> None:
+    func(**good_kw)
+    func(**bad_kw)  # E: Argument after ** must have string keys
 [builtins fixtures/dict.pyi]