language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-29 05:15:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

[red-knot] Implement disjointness for Instance types where the underlying class is @final (#15539)

Browse source 
## Summary

Closes https://github.com/astral-sh/ruff/issues/15508

For any two instance types `T` and `S`, we know they are disjoint if
either `T` is final and `T` is not a subclass of `S` or `S` is final and
`S` is not a subclass of `T`.

Correspondingly, for any two types `type[T]` and `S` where `S` is an
instance type, `type[T]` can be said to be disjoint from `S` if `S` is
disjoint from `U`, where `U` is the type that represents all instances
of `T`'s metaclass.

And a heterogeneous tuple type can be said to be disjoint from an
instance type if the instance type is disjoint from `tuple` (a type
representing all instances of the `tuple` class at runtime).

## Test Plan

- A new mdtest added. Most of our `is_disjoint_from()` tests are not
written as mdtests just yet, but it's pretty hard to test some of these
edge cases from a Rust unit test!
- Ran `QUICKCHECK_TESTS=1000000 cargo test --release -p
red_knot_python_semantic -- --ignored types::property_tests::stable`

---------

Co-authored-by: Carl Meyer <carl@astral.sh>
This commit is contained in:
Alex Waygood 2025-01-16 23:48:52 +00:00 • committed by GitHub
parent e84c82424d
commit 3950b00ee4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
3 changed files with 63 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

57
crates/red_knot_python_semantic/src/types.rs
View file

@ -1278,14 +1278,17 @@ impl<'db> Type<'db> {
(Type::SubclassOf(_), Type::SubclassOf(_)) => false,
(Type::SubclassOf(_), Type::Instance(instance))
| (Type::Instance(instance), Type::SubclassOf(_)) => {
// TODO this should be `true` if the instance is of a final type which is not a
// subclass of type. (With non-final types, we never know whether a subclass might
// multiply-inherit `type` or a subclass of it, and thus not be disjoint with
// `type[...]`.) Until we support finality, hardcode None, which is known to be
// final.
instance.class.is_known(db, KnownClass::NoneType)
(Type::SubclassOf(subclass_of_ty), instance @ Type::Instance(_))
| (instance @ Type::Instance(_), Type::SubclassOf(subclass_of_ty)) => {
// `type[T]` is disjoint from `S`, where `S` is an instance type,
// if `U` is disjoint from `S`,
// where `U` represents all instances of `T`'s metaclass
let metaclass_instance = subclass_of_ty
.subclass_of()
.into_class()
.map(|class| class.metaclass(db).to_instance(db))
.unwrap_or_else(|| KnownClass::Type.to_instance(db));
instance.is_disjoint_from(db, metaclass_instance)
}
(
@ -1339,24 +1342,6 @@ impl<'db> Type<'db> {
known_instance_ty.is_disjoint_from(db, KnownClass::Tuple.to_instance(db))
}
(
Type::Instance(InstanceType { class: class_none }),
Type::Instance(InstanceType { class: class_other }),
)
| (
Type::Instance(InstanceType { class: class_other }),
Type::Instance(InstanceType { class: class_none }),
) if class_none.is_known(db, KnownClass::NoneType) => {
!class_none.is_subclass_of(db, class_other)
}
(Type::Instance(InstanceType { class: class_none }), _)
| (_, Type::Instance(InstanceType { class: class_none }))
if class_none.is_known(db, KnownClass::NoneType) =>
{
true
}
(Type::BooleanLiteral(..), Type::Instance(InstanceType { class }))
| (Type::Instance(InstanceType { class }), Type::BooleanLiteral(..)) => {
// A `Type::BooleanLiteral()` must be an instance of exactly `bool`
@ -1430,15 +1415,12 @@ impl<'db> Type<'db> {
other.is_disjoint_from(db, KnownClass::ModuleType.to_instance(db))
}
(Type::Instance(..), Type::Instance(..)) => {
// TODO: once we have support for `final`, there might be some cases where
// we can determine that two types are disjoint. Once we do this, some cases
// above (e.g. NoneType) can be removed. For non-final classes, we return
// false (multiple inheritance).
// TODO: is there anything specific to do for instances of KnownClass::Type?
false
(
Type::Instance(InstanceType { class: left_class }),
Type::Instance(InstanceType { class: right_class }),
) => {
(left_class.is_final(db) && !left_class.is_subclass_of(db, right_class))
|| (right_class.is_final(db) && !right_class.is_subclass_of(db, left_class))
}
(Type::Tuple(tuple), Type::Tuple(other_tuple)) => {
@ -1451,7 +1433,8 @@ impl<'db> Type<'db> {
.any(|(e1, e2)| e1.is_disjoint_from(db, *e2))
}
(Type::Tuple(..), Type::Instance(..)) | (Type::Instance(..), Type::Tuple(..)) => {
(Type::Tuple(..), instance @ Type::Instance(_))
| (instance @ Type::Instance(_), Type::Tuple(..)) => {
// We cannot be sure if the tuple is disjoint from the instance because:
// - 'other' might be the homogeneous arbitrary-length tuple type
// tuple[T, ...] (which we don't have support for yet); if all of
@ -1460,7 +1443,7 @@ impl<'db> Type<'db> {
// over the same or compatible *Ts, would overlap with tuple.
//
// TODO: add checks for the above cases once we support them
false
instance.is_disjoint_from(db, KnownClass::Tuple.to_instance(db))
}
}
}