A more principled fix for the subtyping issue

Author: ilevkivskyi

mypy/subtypes.py

@@ -1719,11 +1719,16 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
         ):
             return False
 
+    if trivial_suffix:
+        # For trivial right suffix we *only* check that every non-star right argument
+        # has a valid match on the left.
+        return True
+
     # Phase 1c: Check var args. Right has an infinite series of optional positional
     #           arguments. Get all further positional args of left, and make sure
     #           they're more general than the corresponding member in right.
     # TODO: are we handling UnpackType correctly here?
-    if right_star is not None and not trivial_suffix:
+    if right_star is not None:
         # Synthesize an anonymous formal argument for the right
         right_by_position = right.try_synthesizing_arg_from_vararg(None)
         assert right_by_position is not None
@@ -1750,7 +1755,7 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
     # Phase 1d: Check kw args. Right has an infinite series of optional named
     #           arguments. Get all further named args of left, and make sure
     #           they're more general than the corresponding member in right.
-    if right_star2 is not None and not trivial_suffix:
+    if right_star2 is not None:
         right_names = {name for name in right.arg_names if name is not None}
         left_only_names = set()
         for name, kind in zip(left.arg_names, left.arg_kinds):
@@ -1796,12 +1801,12 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N
         )
 
         # If the left hand argument corresponds to two right-hand arguments,
-        # both of them can't be required.
+        # neither of them can be required.
         if (
             right_by_name is not None
             and right_by_pos is not None
             and right_by_name != right_by_pos
-            and (right_by_pos.required and right_by_name.required)
+            and (right_by_pos.required or right_by_name.required)
             and strict_concatenate_check
             and not right.imprecise_arg_kinds
         ):

test-data/unit/check-functions.test

@@ -106,14 +106,33 @@ if int():
 
 [case testSubtypingFunctionsDoubleCorrespondence]
 def l(x) -> None: ...
-def r(__a, *, x) -> None: ...
+def r(__x, *, x) -> None: ...
 r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, NamedArg(Any, 'x')], None]")
 
 [case testSubtypingFunctionsDoubleCorrespondenceNamedOptional]
 def l(x) -> None: ...
-def r(__a, *, x = 1) -> None: ...
+def r(__x, *, x = 1) -> None: ...
 r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, DefaultNamedArg(Any, 'x')], None]")
 
+[case testSubtypingFunctionsDoubleCorrespondenceBothNamedOptional]
+def l(x = 1) -> None: ...
+def r(__x, *, x = 1) -> None: ...
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, DefaultNamedArg(Any, 'x')], None]")
+
+[case testSubtypingFunctionsTrivialSuffixRequired]
+def l(__x) -> None: ...
+def r(x, *args, **kwargs) -> None: ...
+
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Arg(Any, 'x'), VarArg(Any), KwArg(Any)], None]")
+[builtins fixtures/dict.pyi]
+
+[case testSubtypingFunctionsTrivialSuffixOptional]
+def l(__x = 1) -> None: ...
+def r(x = 1, *args, **kwargs) -> None: ...
+
+r = l  # E: Incompatible types in assignment (expression has type "Callable[[DefaultArg(Any)], None]", variable has type "Callable[[DefaultArg(Any, 'x'), VarArg(Any), KwArg(Any)], None]")
+[builtins fixtures/dict.pyi]
+
 [case testSubtypingFunctionsRequiredLeftArgNotPresent]
 def l(x, y) -> None: ...
 def r(x) -> None: ...