mirror of
https://github.com/astral-sh/ruff.git
synced 2025-08-04 02:38:25 +00:00
[ty] Synthetic function-like callables (#18242)
## Summary We create `Callable` types for synthesized functions like the `__init__` method of a dataclass. These generated functions are real functions though, with descriptor-like behavior. That is, they can bind `self` when accessed on an instance. This was modeled incorrectly so far. ## Test Plan Updated tests
This commit is contained in:
David Peter
GitHub
parent
48c425c15b
commit
bbcd7e0196
4 changed files with 167 additions and 32 deletions
|
|
@ -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
|
||||
|
|
@ -529,7 +527,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
|
||||
|
|
@ -582,7 +580,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
|
||||
|
|
@ -628,7 +626,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
|
||||
|
|
@ -667,7 +665,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`
|
||||
|
|
@ -728,7 +726,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
|
||||
|
|
@ -821,10 +819,57 @@ 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
|
||||
|
||||
reveal_type(Person.__eq__) # revealed: def __eq__(self, value: object, /) -> bool
|
||||
```
|
||||
|
||||
## Function-like behavior of synthesized methods
|
||||
|
||||
Here, we make sure that the synthesized methods of dataclasses behave like proper functions.
|
||||
|
||||
```toml
|
||||
[environment]
|
||||
python-version = "3.12"
|
||||
```
|
||||
|
||||
```py
|
||||
from dataclasses import dataclass
|
||||
from typing import Callable
|
||||
from types import FunctionType
|
||||
from ty_extensions import CallableTypeOf, TypeOf, static_assert, is_subtype_of, is_assignable_to
|
||||
|
||||
@dataclass
|
||||
class C:
|
||||
x: int
|
||||
|
||||
reveal_type(C.__init__) # revealed: (self: C, x: int) -> None
|
||||
reveal_type(type(C.__init__)) # revealed: <class 'FunctionType'>
|
||||
|
||||
# We can access attributes that are defined on functions:
|
||||
reveal_type(type(C.__init__).__code__) # revealed: CodeType
|
||||
reveal_type(C.__init__.__code__) # revealed: CodeType
|
||||
|
||||
def equivalent_signature(self: C, x: int) -> None:
|
||||
pass
|
||||
|
||||
type DunderInitType = TypeOf[C.__init__]
|
||||
type EquivalentPureCallableType = Callable[[C, int], None]
|
||||
type EquivalentFunctionLikeCallableType = CallableTypeOf[equivalent_signature]
|
||||
|
||||
static_assert(is_subtype_of(DunderInitType, EquivalentPureCallableType))
|
||||
static_assert(is_assignable_to(DunderInitType, EquivalentPureCallableType))
|
||||
|
||||
static_assert(not is_subtype_of(EquivalentPureCallableType, DunderInitType))
|
||||
static_assert(not is_assignable_to(EquivalentPureCallableType, DunderInitType))
|
||||
|
||||
static_assert(is_subtype_of(DunderInitType, EquivalentFunctionLikeCallableType))
|
||||
static_assert(is_assignable_to(DunderInitType, EquivalentFunctionLikeCallableType))
|
||||
|
||||
static_assert(not is_subtype_of(EquivalentFunctionLikeCallableType, DunderInitType))
|
||||
static_assert(not is_assignable_to(EquivalentFunctionLikeCallableType, DunderInitType))
|
||||
|
||||
static_assert(is_subtype_of(DunderInitType, FunctionType))
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1235,6 +1235,14 @@ impl<'db> Type<'db> {
|
|||
) => (self.literal_fallback_instance(db))
|
||||
.is_some_and(|instance| instance.is_subtype_of(db, target)),
|
||||
|
||||
// Function-like callables are subtypes of `FunctionType`
|
||||
(Type::Callable(callable), Type::NominalInstance(target))
|
||||
if callable.is_function_like(db)
|
||||
&& target.class.is_known(db, KnownClass::FunctionType) =>
|
||||
{
|
||||
true
|
||||
}
|
||||
|
||||
(Type::FunctionLiteral(self_function_literal), Type::Callable(_)) => {
|
||||
self_function_literal
|
||||
.into_callable_type(db)
|
||||
|
|
@ -2747,6 +2755,26 @@ 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__`.
|
||||
//
|
||||
// It is a shortcut to model this in `try_call_dunder_get`. If we want to be really precise,
|
||||
// we should instead return a new method-wrapper type variant for the synthesized `__get__`
|
||||
// method of these synthesized functions. The method-wrapper would then be returned from
|
||||
// `find_name_in_mro` when called on function-like `Callable`s. This would allow us to
|
||||
// correctly model the behavior of *explicit* `SomeDataclass.__init__.__get__` calls.
|
||||
return if instance.is_none(db) {
|
||||
Some((self, AttributeKind::NormalOrNonDataDescriptor))
|
||||
} else {
|
||||
Some((
|
||||
Type::Callable(callable.bind_self(db)),
|
||||
AttributeKind::NormalOrNonDataDescriptor,
|
||||
))
|
||||
};
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let descr_get = self.class_member(db, "__get__".into()).symbol;
|
||||
|
||||
|
|
@ -3080,6 +3108,11 @@ impl<'db> Type<'db> {
|
|||
Type::Callable(_) | Type::DataclassTransformer(_) if name_str == "__call__" => {
|
||||
Symbol::bound(self).into()
|
||||
}
|
||||
|
||||
Type::Callable(callable) if callable.is_function_like(db) => KnownClass::FunctionType
|
||||
.to_instance(db)
|
||||
.member_lookup_with_policy(db, name, policy),
|
||||
|
||||
Type::Callable(_) | Type::DataclassTransformer(_) => KnownClass::Object
|
||||
.to_instance(db)
|
||||
.member_lookup_with_policy(db, name, policy),
|
||||
|
|
@ -5139,6 +5172,9 @@ impl<'db> Type<'db> {
|
|||
Type::MethodWrapper(_) => KnownClass::MethodWrapperType.to_class_literal(db),
|
||||
Type::WrapperDescriptor(_) => KnownClass::WrapperDescriptorType.to_class_literal(db),
|
||||
Type::DataclassDecorator(_) => KnownClass::FunctionType.to_class_literal(db),
|
||||
Type::Callable(callable) if callable.is_function_like(db) => {
|
||||
KnownClass::FunctionType.to_class_literal(db)
|
||||
}
|
||||
Type::Callable(_) | Type::DataclassTransformer(_) => KnownClass::Type.to_instance(db),
|
||||
Type::ModuleLiteral(_) => KnownClass::ModuleType.to_class_literal(db),
|
||||
Type::Tuple(_) => KnownClass::Tuple.to_class_literal(db),
|
||||
|
|
@ -6936,6 +6972,7 @@ impl<'db> FunctionType<'db> {
|
|||
Type::Callable(CallableType::from_overloads(
|
||||
db,
|
||||
self.signature(db).overloads.iter().cloned(),
|
||||
false,
|
||||
))
|
||||
}
|
||||
|
||||
|
|
@ -7562,6 +7599,7 @@ impl<'db> BoundMethodType<'db> {
|
|||
.overloads
|
||||
.iter()
|
||||
.map(signatures::Signature::bind_self),
|
||||
false,
|
||||
))
|
||||
}
|
||||
|
||||
|
|
@ -7626,12 +7664,23 @@ impl<'db> BoundMethodType<'db> {
|
|||
pub struct CallableType<'db> {
|
||||
#[returns(deref)]
|
||||
signatures: Box<[Signature<'db>]>,
|
||||
/// We use `CallableType` to represent function-like objects, like the synthesized methods
|
||||
/// of dataclasses or NamedTuples. These callables act like real functions when accessed
|
||||
/// as attributes on instances, i.e. they bind `self`.
|
||||
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, function-like callable type with a single signature.
|
||||
///
|
||||
/// A function-like callable will bind `self` when accessed as an attribute on an instance.
|
||||
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.
|
||||
|
|
@ -7639,7 +7688,7 @@ impl<'db> CallableType<'db> {
|
|||
/// # 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>>,
|
||||
{
|
||||
|
|
@ -7648,7 +7697,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.
|
||||
|
|
@ -7659,6 +7708,14 @@ 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::bind_self),
|
||||
false,
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a callable type which represents a fully-static "bottom" callable.
|
||||
///
|
||||
/// Specifically, this represents a callable type with a single signature:
|
||||
|
|
@ -7677,6 +7734,7 @@ impl<'db> CallableType<'db> {
|
|||
self.signatures(db)
|
||||
.iter()
|
||||
.map(|signature| signature.normalized(db)),
|
||||
self.is_function_like(db),
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -7686,6 +7744,7 @@ impl<'db> CallableType<'db> {
|
|||
self.signatures(db)
|
||||
.iter()
|
||||
.map(|signature| signature.apply_type_mapping(db, type_mapping)),
|
||||
self.is_function_like(db),
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -7734,6 +7793,13 @@ impl<'db> CallableType<'db> {
|
|||
where
|
||||
F: Fn(&Signature<'db>, &Signature<'db>) -> bool,
|
||||
{
|
||||
let self_is_function_like = self.is_function_like(db);
|
||||
let other_is_function_like = other.is_function_like(db);
|
||||
|
||||
if !self_is_function_like && other_is_function_like {
|
||||
return false;
|
||||
}
|
||||
|
||||
match (self.signatures(db), other.signatures(db)) {
|
||||
([self_signature], [other_signature]) => {
|
||||
// Base case: both callable types contain a single signature.
|
||||
|
|
@ -7776,6 +7842,10 @@ impl<'db> CallableType<'db> {
|
|||
///
|
||||
/// See [`Type::is_equivalent_to`] for more details.
|
||||
fn is_equivalent_to(self, db: &'db dyn Db, other: Self) -> bool {
|
||||
if self.is_function_like(db) != other.is_function_like(db) {
|
||||
return false;
|
||||
}
|
||||
|
||||
match (self.signatures(db), other.signatures(db)) {
|
||||
([self_signature], [other_signature]) => {
|
||||
// Common case: both callable types contain a single signature, use the custom
|
||||
|
|
@ -7802,6 +7872,10 @@ impl<'db> CallableType<'db> {
|
|||
///
|
||||
/// See [`Type::is_gradual_equivalent_to`] for more details.
|
||||
fn is_gradual_equivalent_to(self, db: &'db dyn Db, other: Self) -> bool {
|
||||
if self.is_function_like(db) != other.is_function_like(db) {
|
||||
return false;
|
||||
}
|
||||
|
||||
match (self.signatures(db), other.signatures(db)) {
|
||||
([self_signature], [other_signature]) => {
|
||||
self_signature.is_gradual_equivalent_to(db, other_signature)
|
||||
|
|
@ -7821,6 +7895,7 @@ impl<'db> CallableType<'db> {
|
|||
.iter()
|
||||
.cloned()
|
||||
.map(|signature| signature.replace_self_reference(db, class)),
|
||||
self.is_function_like(db),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1267,7 +1267,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) {
|
||||
|
|
@ -1281,7 +1281,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"))
|
||||
|
|
@ -1294,16 +1300,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
|
||||
|
|
|
|||
|
|
@ -8737,6 +8737,7 @@ impl<'db> TypeInferenceBuilder<'db> {
|
|||
Type::Callable(CallableType::from_overloads(
|
||||
db,
|
||||
std::iter::once(signature).chain(signature_iter),
|
||||
false,
|
||||
))
|
||||
}
|
||||
},
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue