[ty] Make Any a subtype of Any

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md

@@ -59,7 +59,7 @@ static_assert(not is_subtype_of(C[A], C[Any]))
 static_assert(not is_subtype_of(C[B], C[Any]))
 static_assert(not is_subtype_of(C[Any], C[A]))
 static_assert(not is_subtype_of(C[Any], C[B]))
-static_assert(not is_subtype_of(C[Any], C[Any]))
+static_assert(is_subtype_of(C[Any], C[Any]))
 
 static_assert(is_subtype_of(D[B], C[A]))
 static_assert(not is_subtype_of(D[A], C[B]))

crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md

@@ -302,7 +302,7 @@ static_assert(not is_subtype_of(C[A], C[Any]))
 static_assert(not is_subtype_of(C[B], C[Any]))
 static_assert(not is_subtype_of(C[Any], C[A]))
 static_assert(not is_subtype_of(C[Any], C[B]))
-static_assert(not is_subtype_of(C[Any], C[Any]))
+static_assert(is_subtype_of(C[Any], C[Any]))
 
 static_assert(is_subtype_of(D[B], C[A]))
 static_assert(is_subtype_of(D[A], C[B]))

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

@@ -348,7 +348,7 @@ Its subtyping follows the general rule for subtyping of gradual types.
 from typing import Any, Never
 from ty_extensions import static_assert, is_subtype_of
 
-static_assert(not is_subtype_of(tuple[Any, ...], tuple[Any, ...]))
+static_assert(is_subtype_of(tuple[Any, ...], tuple[Any, ...]))
 static_assert(not is_subtype_of(tuple[Any, ...], tuple[Any]))
 static_assert(not is_subtype_of(tuple[Any, ...], tuple[Any, Any]))
 static_assert(not is_subtype_of(tuple[Any, ...], tuple[int, ...]))
@@ -361,7 +361,7 @@ static_assert(is_subtype_of(tuple[Never, ...], tuple[Any, ...]))
 Same applies when `tuple[Any, ...]` is unpacked into a mixed tuple.
 
 ```py
-static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[int, *tuple[Any, ...]]))
+static_assert(is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[int, *tuple[Any, ...]]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[Any, ...]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[Any]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[Any, Any]))
@@ -370,7 +370,7 @@ static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[int, ...]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[int]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...]], tuple[int, int]))
 
-static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[*tuple[Any, ...], int]))
+static_assert(is_subtype_of(tuple[*tuple[Any, ...], int], tuple[*tuple[Any, ...], int]))
 static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[Any, ...]))
 static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[Any]))
 static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[Any, Any]))
@@ -379,7 +379,7 @@ static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[int, ...]))
 static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[int]))
 static_assert(not is_subtype_of(tuple[*tuple[Any, ...], int], tuple[int, int]))
 
-static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...], int], tuple[int, *tuple[Any, ...], int]))
+static_assert(is_subtype_of(tuple[int, *tuple[Any, ...], int], tuple[int, *tuple[Any, ...], int]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...], int], tuple[Any, ...]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...], int], tuple[Any]))
 static_assert(not is_subtype_of(tuple[int, *tuple[Any, ...], int], tuple[Any, Any]))
@@ -647,10 +647,10 @@ from typing_extensions import TypeGuard, TypeIs
 # TODO: TypeGuard
 # static_assert(is_subtype_of(TypeGuard[int], TypeGuard[int]))
 # static_assert(is_subtype_of(TypeGuard[bool], TypeGuard[int]))
+# static_assert(not is_subtype_of(TypeGuard[int], TypeGuard[bool]))
 static_assert(is_subtype_of(TypeIs[int], TypeIs[int]))
 static_assert(is_subtype_of(TypeIs[int], TypeIs[int]))
 
-static_assert(not is_subtype_of(TypeGuard[int], TypeGuard[bool]))
 static_assert(not is_subtype_of(TypeIs[bool], TypeIs[int]))
 static_assert(not is_subtype_of(TypeIs[int], TypeIs[bool]))
 ```
@@ -821,7 +821,7 @@ represented by a materialization of the second type.
 from ty_extensions import Unknown, is_subtype_of, static_assert, Intersection
 from typing_extensions import Any
 
-static_assert(not is_subtype_of(Any, Any))
+static_assert(is_subtype_of(Any, Any))
 static_assert(not is_subtype_of(Any, int))
 static_assert(not is_subtype_of(int, Any))
 static_assert(is_subtype_of(Any, object))
@@ -835,7 +835,7 @@ static_assert(not is_subtype_of(tuple[int, int], tuple[int, Any]))
 The same for `Unknown`:
 
 ```py
-static_assert(not is_subtype_of(Unknown, Unknown))
+static_assert(is_subtype_of(Unknown, Unknown))
 static_assert(not is_subtype_of(Unknown, int))
 static_assert(not is_subtype_of(int, Unknown))
 static_assert(is_subtype_of(Unknown, object))
@@ -870,7 +870,7 @@ static_assert(is_subtype_of(InheritsAny, object))
 Similar for subclass-of types:
 
 ```py
-static_assert(not is_subtype_of(type[Any], type[Any]))
+static_assert(is_subtype_of(type[Any], type[Any]))
 static_assert(not is_subtype_of(type[object], type[Any]))
 static_assert(not is_subtype_of(type[Any], type[Arbitrary]))
 static_assert(is_subtype_of(type[Any], type[object]))

crates/ty_python_semantic/src/types.rs

@@ -1129,55 +1129,6 @@ impl<'db> Type<'db> {
         }
     }
 
-    /// Return `true` if subtyping is always reflexive for this type; `T <: T` is always true for
-    /// any `T` of this type.
-    ///
-    /// This is true for fully static types, but also for some types that may not be fully static.
-    /// For example, a `ClassLiteral` may inherit `Any`, but its subtyping is still reflexive.
-    ///
-    /// This method may have false negatives, but it should not have false positives. It should be
-    /// a cheap shallow check, not an exhaustive recursive check.
-    fn subtyping_is_always_reflexive(self) -> bool {
-        match self {
-            Type::Never
-            | Type::FunctionLiteral(..)
-            | Type::BoundMethod(_)
-            | Type::WrapperDescriptor(_)
-            | Type::MethodWrapper(_)
-            | Type::DataclassDecorator(_)
-            | Type::DataclassTransformer(_)
-            | Type::ModuleLiteral(..)
-            | Type::IntLiteral(_)
-            | Type::BooleanLiteral(_)
-            | Type::StringLiteral(_)
-            | Type::LiteralString
-            | Type::BytesLiteral(_)
-            | Type::EnumLiteral(_)
-            | Type::SpecialForm(_)
-            | Type::KnownInstance(_)
-            | Type::AlwaysFalsy
-            | Type::AlwaysTruthy
-            | Type::PropertyInstance(_)
-            // might inherit `Any`, but subtyping is still reflexive
-            | Type::ClassLiteral(_)
-             => true,
-            Type::Dynamic(_)
-            | Type::NominalInstance(_)
-            | Type::ProtocolInstance(_)
-            | Type::GenericAlias(_)
-            | Type::SubclassOf(_)
-            | Type::Union(_)
-            | Type::Intersection(_)
-            | Type::Callable(_)
-            | Type::NonInferableTypeVar(_)
-            | Type::TypeVar(_)
-            | Type::BoundSuper(_)
-            | Type::TypeIs(_)
-            | Type::TypedDict(_)
-            | Type::TypeAlias(_) => false,
-        }
-    }
-
     pub(crate) fn into_callable(self, db: &'db dyn Db) -> Option<Type<'db>> {
         match self {
             Type::Callable(_) => Some(self),
@@ -1334,27 +1285,26 @@ impl<'db> Type<'db> {
         relation: TypeRelation,
         visitor: &HasRelationToVisitor<'db, C>,
     ) -> C {
-        // Subtyping implies assignability, so if subtyping is reflexive and the two types are
-        // equal, it is both a subtype and assignable. Assignability is always reflexive.
-        //
         // Note that we could do a full equivalence check here, but that would be both expensive
         // and unnecessary. This early return is only an optimisation.
-        if (relation.is_assignability() || self.subtyping_is_always_reflexive()) && self == target {
+        if self == target {
             return C::always_satisfiable(db);
         }
 
         match (self, target) {
+            // `Never` is the bottom type, the empty set.
+            // It is a subtype of all other types.
+            (Type::Never, _) => C::always_satisfiable(db),
+
+            (Type::Dynamic(_), Type::Dynamic(_)) => C::always_satisfiable(db),
+
             // Everything is a subtype of `object`.
             (_, Type::NominalInstance(instance)) if instance.is_object(db) => {
                 C::always_satisfiable(db)
             }
 
-            // `Never` is the bottom type, the empty set.
-            // It is a subtype of all other types.
-            (Type::Never, _) => C::always_satisfiable(db),
-
-            // Dynamic is only a subtype of `object` and only a supertype of `Never`; both were
-            // handled above. It's always assignable, though.
+            // Dynamic is only a subtype of `object` and itself, and only a supertype of `Never` and itself;
+            // both were handled above. It's always assignable, though.
             (Type::Dynamic(_), _) | (_, Type::Dynamic(_)) => {
                 C::from_bool(db, relation.is_assignability())
             }

crates/ty_python_semantic/src/types/subclass_of.rs

@@ -137,9 +137,7 @@ impl<'db> SubclassOfType<'db> {
         visitor: &HasRelationToVisitor<'db, C>,
     ) -> C {
         match (self.subclass_of, other.subclass_of) {
-            (SubclassOfInner::Dynamic(_), SubclassOfInner::Dynamic(_)) => {
-                C::from_bool(db, relation.is_assignability())
-            }
+            (SubclassOfInner::Dynamic(_), SubclassOfInner::Dynamic(_)) => C::always_satisfiable(db),
             (SubclassOfInner::Dynamic(_), SubclassOfInner::Class(other_class)) => {
                 C::from_bool(db, other_class.is_object(db) || relation.is_assignability())
             }