Preserve nested variadic ParamSpec arguments

Keep a residual unpack and its suffix together as one vararg when expanding Parameters. This avoids positional arguments after *args and preserves nested TypeVarTuple call semantics.

Author: KirschBluteX

mypy/expandtype.py

@@ -410,14 +410,29 @@ def visit_parameters(self, t: Parameters) -> Type:
                 and isinstance(arg_type.type, TypeVarTupleType)
             ):
                 expanded = self.expand_unpack(arg_type)
-                for item in expanded:
-                    arg_types.append(item)
-                    if isinstance(item, UnpackType):
-                        arg_kinds.append(ARG_STAR)
-                        arg_names.append(arg_name)
-                    else:
-                        arg_kinds.append(ArgKind.ARG_POS)
-                        arg_names.append(None)
+                # Keep a residual unpack and its suffix together as one vararg. Otherwise
+                # the suffix would become positional arguments placed after *args.
+                unpack_index = next(
+                    (i for i, item in enumerate(expanded) if isinstance(item, UnpackType)), None
+                )
+                if unpack_index is not None:
+                    arg_types.extend(expanded[:unpack_index])
+                    arg_kinds.extend([ArgKind.ARG_POS] * unpack_index)
+                    arg_names.extend([None] * unpack_index)
+
+                    unpack = expanded[unpack_index]
+                    assert isinstance(unpack, UnpackType)
+                    if unpack_index < len(expanded) - 1:
+                        unpack = UnpackType(
+                            TupleType(expanded[unpack_index:], arg_type.type.tuple_fallback)
+                        )
+                    arg_types.append(unpack)
+                    arg_kinds.append(ARG_STAR)
+                    arg_names.append(arg_name)
+                else:
+                    arg_types.extend(expanded)
+                    arg_kinds.extend([ArgKind.ARG_POS] * len(expanded))
+                    arg_names.extend([None] * len(expanded))
             else:
                 arg_types.append(arg_type.accept(self))
                 arg_kinds.append(arg_kind)

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

@@ -148,6 +148,7 @@ from typing_extensions import ParamSpec
 P = ParamSpec("P")
 R = TypeVar("R")
 Ts = TypeVarTuple("Ts")
+Us = TypeVarTuple("Us")
 
 class contextmanager(Generic[P, R]):
     def __init__(self, func: Callable[P, R]) -> None: ...
@@ -157,6 +158,7 @@ class contextmanager(Generic[P, R]):
 class _contextmanager_cls(Generic[P, R]):
     def __enter__(self) -> R: ...
     def __exit__(self, *args: object) -> bool: ...
+    def invoke(self, *args: P.args, **kwargs: P.kwargs) -> R: ...
 
 @contextmanager
 def print_args(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]: ...
@@ -165,6 +167,10 @@ with print_args(2, "x") as value:
     reveal_type(value)  # N: Revealed type is "tuple[builtins.int, builtins.str]"
 
 reveal_type(print_args(2, "x"))  # N: Revealed type is "__main__._contextmanager_cls[[Literal[2]?, Literal['x']?], tuple[Literal[2]?, Literal['x']?]]"
+
+def forward(*args: Unpack[Us]) -> None:
+    manager = print_args(0, *args, "end")
+    reveal_type(manager.invoke(0, *args, "end"))  # N: Revealed type is "tuple[builtins.int, Unpack[Us`-1], builtins.str]"
 [builtins fixtures/tuple.pyi]
 
 [case testInvalidParamSpecType]