Allow partial overlap when checking overload alternatives

Author: dlax

mypy/checker.py

@@ -799,7 +799,12 @@ def check_overlapping_overloads(self, defn: OverloadedFuncDef) -> None:
 
                 # Is the overload alternative's arguments subtypes of the implementation's?
                 if not is_callable_compatible(
-                    impl, sig1, is_compat=is_subtype, is_proper_subtype=False, ignore_return=True
+                    impl,
+                    sig1,
+                    is_compat=is_subtype,
+                    allow_partial_overlap=True,
+                    is_proper_subtype=False,
+                    ignore_return=True,
                 ):
                     self.msg.overloaded_signatures_arg_specific(i + 1, defn.impl)
 

test-data/unit/check-overloading.test

@@ -5323,7 +5323,6 @@ x = register(Foo)
 reveal_type(x)  # N: Revealed type is "builtins.int"
 [builtins fixtures/dict.pyi]
 
-
 [case testOverloadWithObjectDecorator]
 from typing import Any, Callable, Union, overload
 
@@ -6693,3 +6692,24 @@ class B:
     def f(self, *args, **kwargs):
         pass
 [builtins fixtures/tuple.pyi]
+
+[case testOverloadKeywordArgsAndKwargs]
+from typing import Optional, overload
+
+@overload
+def f(x: int = 0, **kwargs: str) -> None:
+    ...
+@overload
+def f(x: int = 0, *, y: int, **kwargs: str) -> str:
+    ...
+def f(x: int = 0, *, y: Optional[int] = None, **kwargs: str) -> Optional[str]:
+    ...
+
+reveal_type(f(0)) # N: Revealed type is "None"
+reveal_type(f(1, foo='bar')) # N: Revealed type is "None"
+reveal_type(f(1, y=2, foo='bar')) # N: Revealed type is "builtins.str"
+f(1, **{'y': 0, 'z': 'a'}) # E: No overload variant of "f" matches argument types "int", "Dict[str, object]" \
+                           # N: Possible overload variants: \
+                           # N:     def f(x: int = ..., **kwargs: str) -> None \
+                           # N:     def f(x: int = ..., *, y: int, **kwargs: str) -> str
+[builtins fixtures/dict.pyi]