From fc1d0611cd1ccea775998de6149a410139905a37 Mon Sep 17 00:00:00 2001 From: lau0708 Date: Sat, 14 Nov 2026 13:05:18 +0800 Subject: [PATCH] Fix callback protocol assignability when trivial *args/**kwargs pair has retained parameters Per the typing spec, an input signature with both *args and **kwargs typed as Any is equivalent to '...' in Callable, even when other parameters are declared between them. The star parameters are gradual and impose no constraints on the assignable callable, while retained parameters are still checked. Fixes #22460 --- mypy/subtypes.py | 22 +++++++++++++--- test-data/unit/check-protocols.test | 40 +++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/mypy/subtypes.py b/mypy/subtypes.py index ca21e67f3a6e5..a5e30fe7eca99 100644 --- a/mypy/subtypes.py +++ b/mypy/subtypes.py @@ -1883,6 +1883,17 @@ def are_trivial_parameters(param: Parameters | NormalizedCallableType) -> bool: ) +def is_trivial_star_params(param: Parameters | NormalizedCallableType) -> bool: + param_star = param.var_arg() + param_star2 = param.kw_arg() + return ( + param_star is not None + and isinstance(get_proper_type(param_star.typ), AnyType) + and param_star2 is not None + and isinstance(get_proper_type(param_star2.typ), AnyType) + ) + + def is_trivial_suffix(param: Parameters | NormalizedCallableType) -> bool: param_star = param.var_arg() param_star2 = param.kw_arg() @@ -1918,6 +1929,11 @@ def are_parameters_compatible( if are_trivial_parameters(right) and not is_proper_subtype: return True trivial_suffix = is_trivial_suffix(right) and not is_proper_subtype + # Per the typing spec, a (*args: Any, **kwargs: Any) pair in the input signature + # is equivalent to "...", even if other parameters are declared between them. + # The star parameters then impose no constraints on the left callable, while + # any retained (non-star) parameters are still checked below. + trivial_star_params = is_trivial_star_params(right) and not is_proper_subtype trivial_vararg_suffix = False if ( @@ -1964,7 +1980,7 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N return not allow_partial_overlap and not trivial_suffix return not is_compat(right_arg.typ, left_arg.typ) - if ( + if not trivial_star_params and ( _incompatible(left_star, right_star) and not trivial_vararg_suffix or _incompatible(left_star2, right_star2) @@ -1999,7 +2015,7 @@ def _incompatible(left_arg: FormalArgument | None, right_arg: FormalArgument | N # arguments. Get all further positional args of left, and make sure # they're more general than the corresponding member in right. # TODO: handle suffix in UnpackType (i.e. *args: *Tuple[Ts, X, Y]). - if right_star is not None and not trivial_vararg_suffix: + if right_star is not None and not trivial_vararg_suffix and not trivial_star_params: # 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 @@ -2026,7 +2042,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: + if right_star2 is not None and not trivial_star_params: 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): diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test index 4c0fdd55b1224..f7f9c81ea12b7 100644 --- a/test-data/unit/check-protocols.test +++ b/test-data/unit/check-protocols.test @@ -4865,3 +4865,43 @@ from typing import Callable, TypeVar S = TypeVar("S") class C: def __init_subclass__(cls: type[S], item: Callable[[S], None]) -> None: ... + +[case testTrivialStarParamsInCallbackProtocol] +from typing import Any, Protocol + +class P(Protocol): + def __call__(self, *args: Any, k: int, **kwargs: Any) -> None: ... + +def cb1(*, k: int, extra: int = 0) -> None: ... +def cb2(x: int, *, k: int) -> None: ... +def cb3(*args: Any, k: int, **kwargs: Any) -> None: ... + +p1: P = cb1 +p2: P = cb2 +p3: P = cb3 +[builtins fixtures/primitives.pyi] +[case testTrivialStarParamsRetainedParamsChecked] +from typing import Any, Protocol + +class P(Protocol): + def __call__(self, *args: Any, k: int, **kwargs: Any) -> None: ... + +def missing_k(*, other: int = 0) -> None: ... +def wrong_k_type(*, k: str) -> None: ... + +p1: P = missing_k # E: Incompatible types in assignment (expression has type "def missing_k(*, other: int = ...) -> None", variable has type "P") \ + # N: "P.__call__" has type "def __call__(self, *args: Any, k: int, **kwargs: Any) -> None" +p2: P = wrong_k_type # E: Incompatible types in assignment (expression has type "def wrong_k_type(*, k: str) -> None", variable has type "P") \ + # N: "P.__call__" has type "def __call__(self, *args: Any, k: int, **kwargs: Any) -> None" +[builtins fixtures/primitives.pyi] +[case testNonTrivialStarParamsStillChecked] +from typing import Any, Protocol + +class P(Protocol): + def __call__(self, *args: str, k: int, **kwargs: Any) -> None: ... + +def no_varargs(*, k: int) -> None: ... + +p1: P = no_varargs # E: Incompatible types in assignment (expression has type "def no_varargs(*, k: int) -> None", variable has type "P") \ + # N: "P.__call__" has type "def __call__(self, *args: str, k: int, **kwargs: Any) -> None" +[builtins fixtures/primitives.pyi]