wip

Author: AlexWaygood

crates/ty_python_semantic/src/types.rs

@@ -3464,6 +3464,7 @@ impl<'db> Type<'db> {
             },
 
             Type::NominalInstance(instance) => match instance.class.known(db) {
+                Some(KnownClass::Tuple) => try_dunder_bool()?,
                 Some(known_class) => known_class.bool(),
                 None => try_dunder_bool()?,
             },

crates/ty_python_semantic/src/types/generics.rs

@@ -592,6 +592,16 @@ impl<'db> Specialization<'db> {
             }
         }
 
+        match (self.tuple_inner(db), other.tuple_inner(db)) {
+            (Some(_), None) | (None, Some(_)) => return false,
+            (None, None) => {}
+            (Some(self_tuple), Some(other_tuple)) => {
+                if !self_tuple.is_equivalent_to(db, other_tuple) {
+                    return false;
+                }
+            }
+        }
+
         true
     }
 

crates/ty_python_semantic/src/types/instance.rs

@@ -33,20 +33,10 @@ impl<'db> Type<'db> {
         let Some(tuple) = tuple else {
             return Type::Never;
         };
-        let Some(tuple_class) = KnownClass::Tuple.try_to_class_literal(db) else {
-            return Type::unknown();
-        };
-        let specialization = Specialization::new(
-            db,
-            GenericContext::new(db, FxOrderSet::default()),
-            Box::from([UnionType::from_elements(db, tuple.tuple(db).all_elements())]),
-            Some(tuple),
-        );
-        let alias = GenericAlias::new(db, tuple_class, specialization);
-        Type::NominalInstance(NominalInstanceType {
-            class: ClassType::Generic(alias),
-            _phantom: PhantomData,
-        })
+        tuple
+            .to_class_type(db)
+            .map(|class| Type::instance(db, class))
+            .unwrap_or_else(Type::unknown)
     }
 
     pub(crate) const fn into_nominal_instance(self) -> Option<NominalInstanceType<'db>> {