[red-knot] Allow classes with __call__ method to be a subtype of Callable

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

@@ -1053,5 +1053,22 @@ static_assert(is_subtype_of(TypeOf[C.foo], object))
 static_assert(not is_subtype_of(object, TypeOf[C.foo]))
 ```
 
+### Classes with __call__
+
+#### Normal instance method
+
+```py
+from typing import Callable
+from knot_extensions import TypeOf, is_subtype_of, static_assert, is_assignable_to
+
+class A:
+    def __call__(self, a: int) -> int:
+        return a
+
+static_assert(is_subtype_of(A, Callable[[int], int]))
+static_assert(not is_subtype_of(A, Callable[[], int]))
+static_assert(not is_subtype_of(Callable[[int], int], A))
+```
+
 [special case for float and complex]: https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex
 [typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#subtype-supertype-and-type-equivalence

crates/red_knot_python_semantic/src/types.rs

@@ -710,6 +710,28 @@ impl<'db> Type<'db> {
                 self_subclass_ty.is_subtype_of(db, target_subclass_ty)
             }
 
+            // An instance type with `__call__` method can be a subtype of Callable
+            (Type::Instance(InstanceType { class }), Type::Callable(_)) => {
+                let call_symbol = class.class_member(db, "__call__").symbol;
+                if call_symbol.is_unbound() {
+                    false
+                } else {
+                    match call_symbol {
+                        Symbol::Type(Type::FunctionLiteral(call_function), _) => {
+                            let callable_type =
+                                call_function.into_callable_type_without_self_parameter(db);
+                            match callable_type {
+                                Type::Callable(CallableType::General(_)) => {
+                                    callable_type.is_subtype_of(db, target)
+                                }
+                                _ => false,
+                            }
+                        }
+                        _ => false,
+                    }
+                }
+            }
+
             // `Literal[str]` is a subtype of `type` because the `str` class object is an instance of its metaclass `type`.
             // `Literal[abc.ABC]` is a subtype of `abc.ABCMeta` because the `abc.ABC` class object
             // is an instance of its metaclass `abc.ABCMeta`.
@@ -4135,6 +4157,15 @@ impl<'db> FunctionType<'db> {
         )))
     }
 
+    pub(crate) fn into_callable_type_without_self_parameter(self, db: &'db dyn Db) -> Type<'db> {
+        let signature = self.signature(db);
+        let new_parameters = signature.parameters().clone().without_self_parameter();
+        Type::Callable(CallableType::General(GeneralCallableType::new(
+            db,
+            Signature::new(new_parameters, signature.return_ty),
+        )))
+    }
+
     /// Typed externally-visible signature for this function.
     ///
     /// This is the signature as seen by external callers, possibly modified by decorators and/or

crates/red_knot_python_semantic/src/types/signatures.rs

@@ -493,6 +493,19 @@ impl<'db> Parameters<'db> {
             .enumerate()
             .rfind(|(_, parameter)| parameter.is_keyword_variadic())
     }
+
+    /// Return a new Parameters type with the first parameter.
+    pub(crate) fn without_self_parameter(self) -> Self {
+        if let Some(first_param) = self.get(0) {
+            return if first_param.name().map(ruff_python_ast::name::Name::as_str) == Some("self") {
+                let new_parameters = self.as_slice()[1..].to_vec();
+                Parameters::new(new_parameters)
+            } else {
+                self
+            };
+        }
+        self
+    }
 }
 
 impl<'db, 'a> IntoIterator for &'a Parameters<'db> {