[ty] Synthetic function-like callables

Author: sharkdp

crates/ty_python_semantic/resources/mdtest/dataclasses.md

@@ -56,8 +56,6 @@ Person(20, "Eve")
 
 ## Signature of `__init__`
 
-TODO: All of the following tests are missing the `self` argument in the `__init__` signature.
-
 Declarations in the class body are used to generate the signature of the `__init__` method. If the
 attributes are not just declarations, but also bindings, the type inferred from bindings is used as
 the default value.
@@ -71,7 +69,7 @@ class D:
     y: str = "default"
     z: int | None = 1 + 2
 
-reveal_type(D.__init__)  # revealed: (x: int, y: str = Literal["default"], z: int | None = Literal[3]) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int, y: str = Literal["default"], z: int | None = Literal[3]) -> None
 ```
 
 This also works if the declaration and binding are split:
@@ -82,7 +80,7 @@ class D:
     x: int | None
     x = None
 
-reveal_type(D.__init__)  # revealed: (x: int | None = None) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int | None = None) -> None
 ```
 
 Non-fully static types are handled correctly:
@@ -96,7 +94,7 @@ class C:
     y: int | Any
     z: tuple[int, Any]
 
-reveal_type(C.__init__)  # revealed: (x: Any, y: int | Any, z: tuple[int, Any]) -> None
+reveal_type(C.__init__)  # revealed: (self: C, x: Any, y: int | Any, z: tuple[int, Any]) -> None
 ```
 
 Variables without annotations are ignored:
@@ -107,7 +105,7 @@ class D:
     x: int
     y = 1
 
-reveal_type(D.__init__)  # revealed: (x: int) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int) -> None
 ```
 
 If attributes without default values are declared after attributes with default values, a
@@ -132,7 +130,7 @@ class D:
     y: ClassVar[str] = "default"
     z: bool
 
-reveal_type(D.__init__)  # revealed: (x: int, z: bool) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int, z: bool) -> None
 
 d = D(1, True)
 reveal_type(d.x)  # revealed: int
@@ -150,7 +148,7 @@ class D:
     def y(self) -> str:
         return ""
 
-reveal_type(D.__init__)  # revealed: (x: int) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int) -> None
 ```
 
 And neither do nested class declarations:
@@ -163,7 +161,7 @@ class D:
     class Nested:
         y: str
 
-reveal_type(D.__init__)  # revealed: (x: int) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int) -> None
 ```
 
 But if there is a variable annotation with a function or class literal type, the signature of
@@ -181,7 +179,7 @@ class D:
     class_literal: TypeOf[SomeClass]
     class_subtype_of: type[SomeClass]
 
-# revealed: (function_literal: def some_function() -> None, class_literal: <class 'SomeClass'>, class_subtype_of: type[SomeClass]) -> None
+# revealed: (self: D, function_literal: def some_function() -> None, class_literal: <class 'SomeClass'>, class_subtype_of: type[SomeClass]) -> None
 reveal_type(D.__init__)
 ```
 
@@ -194,7 +192,7 @@ from typing import Callable
 class D:
     c: Callable[[int], str]
 
-reveal_type(D.__init__)  # revealed: (c: (int, /) -> str) -> None
+reveal_type(D.__init__)  # revealed: (self: D, c: (int, /) -> str) -> None
 ```
 
 Implicit instance attributes do not affect the signature of `__init__`:
@@ -209,7 +207,7 @@ class D:
 
 reveal_type(D(1).y)  # revealed: str
 
-reveal_type(D.__init__)  # revealed: (x: int) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int) -> None
 ```
 
 Annotating expressions does not lead to an entry in `__annotations__` at runtime, and so it wouldn't
@@ -222,7 +220,7 @@ class D:
     (x): int = 1
 
 # TODO: should ideally not include a `x` parameter
-reveal_type(D.__init__)  # revealed: (x: int = Literal[1]) -> None
+reveal_type(D.__init__)  # revealed: (self: D, x: int = Literal[1]) -> None
 ```
 
 ## `@dataclass` calls with arguments
@@ -471,7 +469,7 @@ class C(Base):
     z: int = 10
     x: int = 15
 
-reveal_type(C.__init__)  # revealed: (x: int = Literal[15], y: int = Literal[0], z: int = Literal[10]) -> None
+reveal_type(C.__init__)  # revealed: (self: C, x: int = Literal[15], y: int = Literal[0], z: int = Literal[10]) -> None
 ```
 
 ## Generic dataclasses
@@ -524,7 +522,7 @@ class UppercaseString:
 class C:
     upper: UppercaseString = UppercaseString()
 
-reveal_type(C.__init__)  # revealed: (upper: str = str) -> None
+reveal_type(C.__init__)  # revealed: (self: C, upper: str = str) -> None
 
 c = C("abc")
 reveal_type(c.upper)  # revealed: str
@@ -570,7 +568,7 @@ class ConvertToLength:
 class C:
     converter: ConvertToLength = ConvertToLength()
 
-reveal_type(C.__init__)  # revealed: (converter: str = Literal[""]) -> None
+reveal_type(C.__init__)  # revealed: (self: C, converter: str = Literal[""]) -> None
 
 c = C("abc")
 reveal_type(c.converter)  # revealed: int
@@ -609,7 +607,7 @@ class AcceptsStrAndInt:
 class C:
     field: AcceptsStrAndInt = AcceptsStrAndInt()
 
-reveal_type(C.__init__)  # revealed: (field: str | int = int) -> None
+reveal_type(C.__init__)  # revealed: (self: C, field: str | int = int) -> None
 ```
 
 ## `dataclasses.field`
@@ -670,7 +668,7 @@ import dataclasses
 class C:
     x: str
 
-reveal_type(C.__init__)  # revealed: (x: str) -> None
+reveal_type(C.__init__)  # revealed: (self: C, x: str) -> None
 ```
 
 ### Dataclass with custom `__init__` method
@@ -763,8 +761,7 @@ reveal_type(Person.__mro__)  # revealed: tuple[<class 'Person'>, <class 'object'
 The generated methods have the following signatures:
 
 ```py
-# TODO: `self` is missing here
-reveal_type(Person.__init__)  # revealed: (name: str, age: int | None = None) -> None
+reveal_type(Person.__init__)  # revealed: (self: Person, name: str, age: int | None = None) -> None
 
 reveal_type(Person.__repr__)  # revealed: def __repr__(self) -> str
 

crates/ty_python_semantic/src/types.rs

@@ -2746,6 +2746,21 @@ impl<'db> Type<'db> {
             instance.display(db),
             owner.display(db)
         );
+        match self {
+            Type::Callable(callable) if callable.is_function_like(db) => {
+                // For "function-like" callables, model the the behavior of `FunctionType.__get__`:
+                if instance.is_none(db) {
+                    return Some((self, AttributeKind::NormalOrNonDataDescriptor));
+                } else {
+                    return Some((
+                        Type::Callable(callable.bind_self(db)),
+                        AttributeKind::NormalOrNonDataDescriptor,
+                    ));
+                }
+            }
+            _ => {}
+        };
+
         let descr_get = self.class_member(db, "__get__".into()).symbol;
 
         if let Symbol::Type(descr_get, descr_get_boundness) = descr_get {
@@ -6860,6 +6875,7 @@ impl<'db> FunctionType<'db> {
         Type::Callable(CallableType::from_overloads(
             db,
             self.signature(db).overloads.iter().cloned(),
+            false, // TODO?
         ))
     }
 
@@ -7486,6 +7502,7 @@ impl<'db> BoundMethodType<'db> {
                 .overloads
                 .iter()
                 .map(signatures::Signature::bind_self),
+            false,
         ))
     }
 
@@ -7550,20 +7567,26 @@ impl<'db> BoundMethodType<'db> {
 pub struct CallableType<'db> {
     #[returns(deref)]
     signatures: Box<[Signature<'db>]>,
+    is_function_like: bool,
 }
 
 impl<'db> CallableType<'db> {
     /// Create a non-overloaded callable type with a single signature.
     pub(crate) fn single(db: &'db dyn Db, signature: Signature<'db>) -> Self {
-        CallableType::new(db, vec![signature].into_boxed_slice())
+        CallableType::new(db, vec![signature].into_boxed_slice(), false)
+    }
+
+    /// Create a non-overloaded callable type with a single signature.
+    pub(crate) fn function_like(db: &'db dyn Db, signature: Signature<'db>) -> Self {
+        CallableType::new(db, vec![signature].into_boxed_slice(), true)
     }
 
     /// Create an overloaded callable type with multiple signatures.
     ///
     /// # Panics
     ///
     /// Panics if `overloads` is empty.
-    pub(crate) fn from_overloads<I>(db: &'db dyn Db, overloads: I) -> Self
+    pub(crate) fn from_overloads<I>(db: &'db dyn Db, overloads: I, is_function_like: bool) -> Self
     where
         I: IntoIterator<Item = Signature<'db>>,
     {
@@ -7572,7 +7595,7 @@ impl<'db> CallableType<'db> {
             !overloads.is_empty(),
             "CallableType must have at least one signature"
         );
-        CallableType::new(db, overloads)
+        CallableType::new(db, overloads, is_function_like)
     }
 
     /// Create a callable type which accepts any parameters and returns an `Unknown` type.
@@ -7583,6 +7606,16 @@ impl<'db> CallableType<'db> {
         )
     }
 
+    pub(crate) fn bind_self(self, db: &'db dyn Db) -> Self {
+        CallableType::from_overloads(
+            db,
+            self.signatures(db)
+                .iter()
+                .map(|signature| signature.bind_self()),
+            false,
+        )
+    }
+
     /// Create a callable type which represents a fully-static "bottom" callable.
     ///
     /// Specifically, this represents a callable type with a single signature:
@@ -7601,6 +7634,7 @@ impl<'db> CallableType<'db> {
             self.signatures(db)
                 .iter()
                 .map(|signature| signature.normalized(db)),
+            self.is_function_like(db),
         )
     }
 
@@ -7610,6 +7644,7 @@ impl<'db> CallableType<'db> {
             self.signatures(db)
                 .iter()
                 .map(|signature| signature.apply_type_mapping(db, type_mapping)),
+            self.is_function_like(db),
         )
     }
 
@@ -7745,6 +7780,7 @@ impl<'db> CallableType<'db> {
                 .iter()
                 .cloned()
                 .map(|signature| signature.replace_self_reference(db, class)),
+            self.is_function_like(db),
         )
     }
 }

crates/ty_python_semantic/src/types/class.rs

@@ -1261,7 +1261,7 @@ impl<'db> ClassLiteral<'db> {
             }
 
             let signature = Signature::new(Parameters::new(parameters), Some(Type::none(db)));
-            Some(Type::Callable(CallableType::single(db, signature)))
+            Some(Type::Callable(CallableType::function_like(db, signature)))
         };
 
         match (field_policy, name) {
@@ -1275,7 +1275,13 @@ impl<'db> ClassLiteral<'db> {
                     return None;
                 }
 
-                signature_from_fields(vec![])
+                let self_parameter = Parameter::positional_or_keyword(Name::new_static("self"))
+                    // TODO: could be `Self`.
+                    .with_annotated_type(Type::instance(
+                        db,
+                        self.apply_optional_specialization(db, specialization),
+                    ));
+                signature_from_fields(vec![self_parameter])
             }
             (CodeGeneratorKind::NamedTuple, "__new__") => {
                 let cls_parameter = Parameter::positional_or_keyword(Name::new_static("cls"))
@@ -1288,16 +1294,24 @@ impl<'db> ClassLiteral<'db> {
                 }
 
                 let signature = Signature::new(
-                    Parameters::new([Parameter::positional_or_keyword(Name::new_static("other"))
-                        // TODO: could be `Self`.
-                        .with_annotated_type(Type::instance(
-                            db,
-                            self.apply_optional_specialization(db, specialization),
-                        ))]),
+                    Parameters::new([
+                        Parameter::positional_or_keyword(Name::new_static("self"))
+                            // TODO: could be `Self`.
+                            .with_annotated_type(Type::instance(
+                                db,
+                                self.apply_optional_specialization(db, specialization),
+                            )),
+                        Parameter::positional_or_keyword(Name::new_static("other"))
+                            // TODO: could be `Self`.
+                            .with_annotated_type(Type::instance(
+                                db,
+                                self.apply_optional_specialization(db, specialization),
+                            )),
+                    ]),
                     Some(KnownClass::Bool.to_instance(db)),
                 );
 
-                Some(Type::Callable(CallableType::single(db, signature)))
+                Some(Type::Callable(CallableType::function_like(db, signature)))
             }
             (CodeGeneratorKind::NamedTuple, name) if name != "__init__" => {
                 KnownClass::NamedTupleFallback

crates/ty_python_semantic/src/types/infer.rs

@@ -8609,6 +8609,7 @@ impl<'db> TypeInferenceBuilder<'db> {
                     Type::Callable(CallableType::from_overloads(
                         db,
                         std::iter::once(signature).chain(signature_iter),
+                        false,
                     ))
                 }
             },