added fast path for tuple[Any, ...] comparison

Author: randolf-scholz

mypy/subtypes.py

@@ -69,6 +69,7 @@
     UnpackType,
     flatten_nested_unions,
     get_proper_type,
+    is_any_tuple,
     is_named_instance,
     split_with_prefix_and_suffix,
 )
@@ -797,6 +798,9 @@ def visit_tuple_type(self, left: TupleType) -> bool:
                 return True
             return False
         elif isinstance(right, TupleType):
+            # fast path: left or right is equivalent to tuple[Any, ...]
+            if is_any_tuple(left) or is_any_tuple(right):
+                return True
             # If right has a variadic unpack this needs special handling. If there is a TypeVarTuple
             # unpack, item count must coincide. If the left has variadic unpack but right
             # doesn't have one, we will fall through to False down the line.
@@ -844,11 +848,6 @@ def variadic_tuple_subtype(self, left: TupleType, right: TupleType) -> bool:
             tuple[X, ...] <: tuple[*tuple[X, ...], X]
             then result is False if proper_subtype is True, otherwise True.
 
-        X <: AnyOf[U1, U2, ...]  iff  X <: Ui for some i
-        AnyOf[T1, T2, ...] <: X  iff  X <: Ui for some i
-        X <: Union[U1, U2, ...]  iff  X <: Ui for some i
-        Union[T1, T2, ...] <: X  iff  X <: Ui for all i
-
         Note: the cases where right is fixed or has *Ts unpack should be handled
         by the caller.
         """
@@ -862,6 +861,7 @@ def variadic_tuple_subtype(self, left: TupleType, right: TupleType) -> bool:
         right_unpacked = get_proper_type(right_unpack.type)
         if not isinstance(right_unpacked, Instance):
             # This case should be handled by the caller.
+            # TODO: actually handle it here.
             return False
         assert right_unpacked.type.fullname == "builtins.tuple"
         right_item = right_unpacked.args[0]

mypy/types.py

@@ -3044,6 +3044,26 @@ def simplify(self) -> TupleType | TupleInstanceType | ParamSpecType:
         return self
 
 
+def is_any_tuple(t: Type) -> bool:
+    """Is this `tuple[Any, ...]`?"""
+    t = get_proper_type(t)
+
+    if isinstance(t, Instance):
+        assert len(t.args) == 1
+        return t.type.fullname == "builtins.tuple" and isinstance(
+            get_proper_type(t.args[0]), AnyType
+        )
+
+    if isinstance(t, TupleType):
+        return (
+            len(items := t.flattened_items) == 1
+            and isinstance(item := items[0], UnpackType)
+            and is_any_tuple(item.type)
+        )
+
+    return False
+
+
 class TypedDictType(ProperType):
     """Type of TypedDict object {'k1': v1, ..., 'kn': vn}.
 

test-data/unit/check-varargs.test

@@ -1858,3 +1858,15 @@ def test_takes_exactly_3(
     takes_exactly_3(*x3)
     takes_exactly_3(*x4)  # E: Too many positional arguments for "takes_exactly_3"
 [builtins fixtures/tuple.pyi]
+
+[case testAnyTupleAssignableToParamSpecVarArgs]
+from typing import Callable, Any, ParamSpec, TypeVar
+
+R = TypeVar('R')
+P = ParamSpec('P')
+
+def decorator(func: Callable[P, R]) -> Callable[P, R]:
+    def wrapper(*args: Any, **kwargs: Any) -> R:
+        return func(*args, **kwargs)
+    return wrapper
+[builtins fixtures/tuple.pyi]