Fix subtyping of callable with gradual parameters.

Author: carljm

crates/ty_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -1219,6 +1219,27 @@ static_assert(is_subtype_of(TypeOf[C.foo], object))
 static_assert(not is_subtype_of(object, TypeOf[C.foo]))
 ```
 
+#### Gradual form
+
+A callable type with `...` parameters can be considered a supertype of a callable type that accepts
+any arguments of any type, but otherwise is not a subtype or supertype of any callable type.
+
+```py
+from typing import Callable, Never
+from ty_extensions import CallableTypeOf, is_subtype_of, static_assert
+
+def bottom(*args: object, **kwargs: object) -> Never:
+    raise Exception()
+
+type BottomCallable = CallableTypeOf[bottom]
+
+static_assert(is_subtype_of(BottomCallable, Callable[..., Never]))
+static_assert(is_subtype_of(BottomCallable, Callable[..., int]))
+
+static_assert(not is_subtype_of(Callable[[], object], Callable[..., object]))
+static_assert(not is_subtype_of(Callable[..., object], Callable[[], object]))
+```
+
 ### Classes with `__call__`
 
 ```py

crates/ty_python_semantic/src/types/signatures.rs

@@ -562,12 +562,27 @@ impl<'db> Signature<'db> {
             return false;
         }
 
-        if self.parameters.is_gradual() || other.parameters.is_gradual() {
-            // If either of the parameter lists contains a gradual form (`...`), then it is
-            // assignable / subtype to and from any other callable type.
+        // A gradual parameter list is a supertype of the "bottom" parameter list (*args: object,
+        // **kwargs: object).
+        if other.parameters.is_gradual()
+            && self
+                .parameters
+                .variadic()
+                .is_some_and(|(_, param)| param.annotated_type().is_some_and(|ty| ty.is_object(db)))
+            && self
+                .parameters
+                .keyword_variadic()
+                .is_some_and(|(_, param)| param.annotated_type().is_some_and(|ty| ty.is_object(db)))
+        {
             return true;
         }
 
+        // If either of the parameter lists is gradual (`...`), then it is assignable to and from
+        // any other parameter list, but not a subtype or supertype of any other parameter list.
+        if self.parameters.is_gradual() || other.parameters.is_gradual() {
+            return relation.is_assignability();
+        }
+
         let mut parameters = ParametersZip {
             current_self: None,
             current_other: None,