Fix crash involving Unpack-ed TypeVarTuple

mypy/typeops.py

@@ -508,7 +508,7 @@ def erase_to_bound(t: Type) -> Type:
 def callable_corresponding_argument(
     typ: NormalizedCallableType | Parameters, model: FormalArgument
 ) -> FormalArgument | None:
-    """Return the argument a function that corresponds to `model`"""
+    """Return the argument of a function that corresponds to `model`"""
 
     by_name = typ.argument_by_name(model.name)
     by_pos = typ.argument_by_position(model.pos)
@@ -522,7 +522,7 @@ def callable_corresponding_argument(
         # taking both *args and **args, or a pair of functions like so:
 
         # def right(a: int = ...) -> None: ...
-        # def left(__a: int = ..., *, a: int = ...) -> None: ...
+        # def left(x: int = ..., /, *, a: int = ...) -> None: ...
         from mypy.meet import meet_types
 
         if (
@@ -533,6 +533,8 @@ def callable_corresponding_argument(
             return FormalArgument(
                 by_name.name, by_pos.pos, meet_types(by_name.typ, by_pos.typ), False
             )
+        return by_name
+
     return by_name if by_name is not None else by_pos
 
 

mypy/types.py

@@ -1923,6 +1923,25 @@ def __hash__(self) -> int:
         return hash((self.name, self.pos, self.typ, self.required))
 
 
+def _synthesize_arg_from_vararg(vararg: FormalArgument | None, position: int | None) -> FormalArgument | None:
+    if vararg is None:
+        return None
+    typ = vararg.typ
+    if isinstance(typ, UnpackType):
+        # Similar to logic in ExpressionChecker.visit_tuple_index_helper
+        unpacked = get_proper_type(typ.type)
+        if isinstance(unpacked, TypeVarTupleType):
+            bound = get_proper_type(unpacked.upper_bound)
+            assert isinstance(bound, Instance)
+            assert bound.type.fullname == "builtins.tuple"
+            typ = bound.args[0]
+        else:
+            assert isinstance(unpacked, Instance)
+            assert unpacked.type.fullname == "builtins.tuple"
+            typ = unpacked.args[0]
+    return FormalArgument(None, position, typ, False)
+
+
 class Parameters(ProperType):
     """Type that represents the parameters to a function.
 
@@ -2069,11 +2088,7 @@ def try_synthesizing_arg_from_kwarg(self, name: str | None) -> FormalArgument |
             return None
 
     def try_synthesizing_arg_from_vararg(self, position: int | None) -> FormalArgument | None:
-        var_arg = self.var_arg()
-        if var_arg is not None:
-            return FormalArgument(None, position, var_arg.typ, False)
-        else:
-            return None
+        return _synthesize_arg_from_vararg(self.var_arg(), position)
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         return visitor.visit_parameters(self)
@@ -2418,11 +2433,7 @@ def try_synthesizing_arg_from_kwarg(self, name: str | None) -> FormalArgument |
             return None
 
     def try_synthesizing_arg_from_vararg(self, position: int | None) -> FormalArgument | None:
-        var_arg = self.var_arg()
-        if var_arg is not None:
-            return FormalArgument(None, position, var_arg.typ, False)
-        else:
-            return None
+        return _synthesize_arg_from_vararg(self.var_arg(), position)
 
     @property
     def items(self) -> list[CallableType]:

test-data/unit/check-overloading.test

@@ -263,6 +263,19 @@ def foo(*args: int | str, **kw: int | Foo) -> None:
     pass
 [builtins fixtures/tuple.pyi]
 
+
+[case testTypeCheckOverloadImplOverlapVarArgsAndKwargsNever]
+from __future__ import annotations
+from typing import overload
+
+@overload  # E: Single overload definition, multiple required
+def foo(x: int) -> None: ...
+
+def foo(*args: int, **kw: str) -> None:  # E: Overloaded function implementation does not accept all possible arguments of signature 1
+    pass
+[builtins fixtures/tuple.pyi]
+
+
 [case testTypeCheckOverloadWithImplTooSpecificRetType]
 from typing import overload, Any
 

test-data/unit/check-typevar-tuple.test

@@ -2716,3 +2716,25 @@ class MyTuple(tuple[Unpack[Union[int, str]]], Generic[Unpack[Ts]]):  # E: "Union
 x: MyTuple[int, str]
 reveal_type(x[0])  # N: Revealed type is "Any"
 [builtins fixtures/tuple.pyi]
+
+[case testHigherOrderFunctionUnpackTypeVarTupleViaParamSpec]
+from typing import Callable, ParamSpec, TypeVar, TypeVarTuple, Unpack
+
+P = ParamSpec("P")
+T = TypeVar("T")
+Ts = TypeVarTuple("Ts")
+
+def call(func: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    return func(*args, **kwargs)
+
+
+def run(func: Callable[[Unpack[Ts]], T], *args: Unpack[Ts], some_kwarg: str = "asdf") -> T:
+    raise
+
+
+def foo() -> str:
+    return "hello"
+
+
+call(run, foo, some_kwarg="a")  # E: Argument 1 to "call" has incompatible type "def [Ts`-1, T] run(func: def (*Unpack[Ts]) -> T, *args: Unpack[Ts], some_kwarg: str = ...) -> T"; expected "Callable[[Callable[[], str], str], str]"
+[builtins fixtures/tuple.pyi]