[red-knot] Class literal __new__ function callable subtyping

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

@@ -1166,6 +1166,47 @@ static_assert(is_subtype_of(TypeOf[C], Callable[[int], int]))
 static_assert(is_subtype_of(TypeOf[C], Callable[[], str]))
 ```
 
+#### Classes with `__new__`
+
+```py
+from typing import Callable
+from knot_extensions import TypeOf, static_assert, is_subtype_of
+
+class A:
+    def __new__(cls, a: int) -> int:
+        return a
+
+static_assert(is_subtype_of(TypeOf[A], Callable[[int], int]))
+static_assert(not is_subtype_of(TypeOf[A], Callable[[], int]))
+
+class B: ...
+class C(B): ...
+
+class D:
+    def __new__(cls) -> B:
+        return B()
+
+class E(D):
+    def __new__(cls) -> C:
+        return C()
+
+static_assert(is_subtype_of(TypeOf[E], Callable[[], C]))
+static_assert(is_subtype_of(TypeOf[E], Callable[[], B]))
+static_assert(not is_subtype_of(TypeOf[D], Callable[[], C]))
+static_assert(is_subtype_of(TypeOf[D], Callable[[], B]))
+
+class MetaWithIntReturn(type):
+    def __call__(cls) -> int:
+        return super().__call__()
+
+class F(metaclass=MetaWithIntReturn):
+    def __new__(cls) -> str:
+        return super().__new__(cls)
+
+static_assert(is_subtype_of(TypeOf[F], Callable[[], int]))
+static_assert(not is_subtype_of(TypeOf[F], Callable[[], str]))
+```
+
 ### Bound methods
 
 ```py

crates/red_knot_python_semantic/src/types.rs

@@ -1152,6 +1152,21 @@ impl<'db> Type<'db> {
                     let new_function = new_function.into_callable_type(db);
                     return new_function.is_subtype_of(db, target);
                 }
+
+                let new_function_symbol = self
+                    .member_lookup_with_policy(
+                        db,
+                        "__new__".into(),
+                        MemberLookupPolicy::MRO_NO_OBJECT_FALLBACK
+                            | MemberLookupPolicy::META_CLASS_NO_TYPE_FALLBACK,
+                    )
+                    .symbol;
+
+                if let Symbol::Type(Type::FunctionLiteral(new_function), _) = new_function_symbol {
+                    let new_function = new_function.into_bound_method_type(db, self);
+                    return new_function.is_subtype_of(db, target);
+                }
+
                 false
             }
 
@@ -5904,6 +5919,15 @@ impl<'db> FunctionType<'db> {
         ))
     }
 
+    /// Convert the `FunctionType` into a [`Type::BoundMethod`].
+    pub(crate) fn into_bound_method_type(
+        self,
+        db: &'db dyn Db,
+        self_instance: Type<'db>,
+    ) -> Type<'db> {
+        Type::BoundMethod(BoundMethodType::new(db, self, self_instance))
+    }
+
     /// Returns the [`FileRange`] of the function's name.
     pub fn focus_range(self, db: &dyn Db) -> FileRange {
         FileRange::new(