fix disjointness checks on @final classes

Author: ibraheemdev

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

@@ -95,7 +95,7 @@ python-version = "3.12"
 ```
 
 ```py
-from typing import final
+from typing import Any, final
 from ty_extensions import static_assert, is_disjoint_from
 
 @final
@@ -106,10 +106,13 @@ class Foo[T]:
 class A: ...
 class B: ...
 
+static_assert(not is_disjoint_from(A, B))
 static_assert(not is_disjoint_from(Foo[A], Foo[B]))
+static_assert(not is_disjoint_from(Foo[A], Foo[Any]))
+static_assert(not is_disjoint_from(Foo[Any], Foo[B]))
 
-# TODO: `int` and `str` are disjoint bases, so these should be disjoint.
-static_assert(not is_disjoint_from(Foo[int], Foo[str]))
+# `int` and `str` are disjoint bases.
+static_assert(is_disjoint_from(Foo[int], Foo[str]))
 ```
 
 ## "Disjoint base" builtin types

crates/ty_python_semantic/src/types/class.rs

@@ -716,17 +716,34 @@ impl<'db> ClassType<'db> {
             return true;
         }
 
-        if self.is_final(db) {
-            return self
-                .iter_mro(db)
-                .filter_map(ClassBase::into_class)
-                .any(|class| class.class_literal(db).0 == other.class_literal(db).0);
-        }
-        if other.is_final(db) {
-            return other
+        if self.is_final(db) || other.is_final(db) {
+            let (this, other) = if self.is_final(db) {
+                (self, other)
+            } else {
+                (other, self)
+            };
+
+            return this
                 .iter_mro(db)
                 .filter_map(ClassBase::into_class)
-                .any(|class| class.class_literal(db).0 == self.class_literal(db).0);
+                .any(|class| match (class, other) {
+                    (ClassType::NonGeneric(this_class), ClassType::NonGeneric(other_class)) => {
+                        this_class == other_class
+                    }
+                    (ClassType::Generic(this_alias), ClassType::Generic(other_alias)) => {
+                        this_alias.origin(db) == other_alias.origin(db)
+                            && this_alias
+                                .specialization(db)
+                                .is_disjoint_from(
+                                    db,
+                                    other_alias.specialization(db),
+                                    InferableTypeVars::None,
+                                )
+                                .is_never_satisfied(db)
+                    }
+                    (ClassType::NonGeneric(_), ClassType::Generic(_))
+                    | (ClassType::Generic(_), ClassType::NonGeneric(_)) => false,
+                });
         }
 
         // Two disjoint bases can only coexist in an MRO if one is a subclass of the other.

crates/ty_python_semantic/src/types/generics.rs

@@ -1215,6 +1215,63 @@ impl<'db> Specialization<'db> {
         result
     }
 
+    pub(crate) fn is_disjoint_from(
+        self,
+        db: &'db dyn Db,
+        other: Self,
+        inferable: InferableTypeVars<'_, 'db>,
+    ) -> ConstraintSet<'db> {
+        self.is_disjoint_from_impl(
+            db,
+            other,
+            inferable,
+            &IsDisjointVisitor::default(),
+            &HasRelationToVisitor::default(),
+        )
+    }
+
+    pub(crate) fn is_disjoint_from_impl(
+        self,
+        db: &'db dyn Db,
+        other: Self,
+        inferable: InferableTypeVars<'_, 'db>,
+        disjointness_visitor: &IsDisjointVisitor<'db>,
+        relation_visitor: &HasRelationToVisitor<'db>,
+    ) -> ConstraintSet<'db> {
+        let generic_context = self.generic_context(db);
+        if generic_context != other.generic_context(db) {
+            return ConstraintSet::from(true);
+        }
+
+        if let (Some(self_tuple), Some(other_tuple)) = (self.tuple_inner(db), other.tuple_inner(db))
+        {
+            return self_tuple.is_disjoint_from_impl(
+                db,
+                other_tuple,
+                inferable,
+                disjointness_visitor,
+                relation_visitor,
+            );
+        }
+
+        let mut result = ConstraintSet::from(false);
+        for (self_type, other_type) in std::iter::zip(self.types(db), other.types(db)) {
+            let disjoint = self_type.is_disjoint_from_impl(
+                db,
+                *other_type,
+                inferable,
+                disjointness_visitor,
+                relation_visitor,
+            );
+
+            if result.union(db, disjoint).is_always_satisfied(db) {
+                return result;
+            }
+        }
+
+        result
+    }
+
     pub(crate) fn is_equivalent_to_impl(
         self,
         db: &'db dyn Db,

crates/ty_python_semantic/src/types/tuple.rs

@@ -287,6 +287,23 @@ impl<'db> TupleType<'db> {
         )
     }
 
+    pub(crate) fn is_disjoint_from_impl(
+        self,
+        db: &'db dyn Db,
+        other: Self,
+        inferable: InferableTypeVars<'_, 'db>,
+        disjointness_visitor: &IsDisjointVisitor<'db>,
+        relation_visitor: &HasRelationToVisitor<'db>,
+    ) -> ConstraintSet<'db> {
+        self.tuple(db).is_disjoint_from_impl(
+            db,
+            other.tuple(db),
+            inferable,
+            disjointness_visitor,
+            relation_visitor,
+        )
+    }
+
     pub(crate) fn is_equivalent_to_impl(
         self,
         db: &'db dyn Db,