[red-knot] Fixup a few edge cases regarding type[Any]

Author: AlexWaygood

crates/red_knot_python_semantic/src/types.rs

@@ -654,14 +654,20 @@ impl<'db> Type<'db> {
                         },
                     )
             }
-            (Type::ClassLiteral(self_class), Type::SubclassOf(target_class)) => {
-                self_class.class.is_subclass_of_base(db, target_class.base)
-            }
+            (
+                Type::ClassLiteral(ClassLiteralType { class: self_class }),
+                Type::SubclassOf(SubclassOfType {
+                    base: ClassBase::Class(target_class),
+                }),
+            ) => self_class.is_subclass_of(db, target_class),
             (
                 Type::Instance(InstanceType { class: self_class }),
-                Type::SubclassOf(target_class),
-            ) if self_class.is_known(db, KnownClass::Type) => {
-                self_class.is_subclass_of_base(db, target_class.base)
+                Type::SubclassOf(SubclassOfType {
+                    base: ClassBase::Class(target_class),
+                }),
+            ) => {
+                self_class.is_known(db, KnownClass::Type)
+                    && target_class.is_known(db, KnownClass::Type)
             }
             (
                 Type::SubclassOf(SubclassOfType {
@@ -928,10 +934,18 @@ impl<'db> Type<'db> {
                 | Type::ClassLiteral(..)),
             ) => left != right,
 
-            (Type::SubclassOf(type_class), Type::ClassLiteral(class_literal))
-            | (Type::ClassLiteral(class_literal), Type::SubclassOf(type_class)) => {
-                !class_literal.class.is_subclass_of_base(db, type_class.base)
-            }
+            (
+                Type::SubclassOf(SubclassOfType {
+                    base: ClassBase::Class(class_a),
+                }),
+                Type::ClassLiteral(ClassLiteralType { class: class_b }),
+            )
+            | (
+                Type::ClassLiteral(ClassLiteralType { class: class_b }),
+                Type::SubclassOf(SubclassOfType {
+                    base: ClassBase::Class(class_a),
+                }),
+            ) => !class_b.is_subclass_of(db, class_a),
             (Type::SubclassOf(_), Type::SubclassOf(_)) => false,
             (Type::SubclassOf(_), Type::Instance(_)) | (Type::Instance(_), Type::SubclassOf(_)) => {
                 false
@@ -3146,6 +3160,7 @@ pub(crate) mod tests {
     #[test_case(Ty::BuiltinInstance("type"), Ty::SubclassOfAny)]
     #[test_case(Ty::BuiltinInstance("type"), Ty::SubclassOfBuiltinClass("object"))]
     #[test_case(Ty::BuiltinInstance("type"), Ty::BuiltinInstance("type"))]
+    #[test_case(Ty::BuiltinClassLiteral("str"), Ty::SubclassOfAny)]
     fn is_assignable_to(from: Ty, to: Ty) {
         let db = setup_db();
         assert!(from.into_type(&db).is_assignable_to(&db, to.into_type(&db)));
@@ -3242,6 +3257,8 @@ pub(crate) mod tests {
     #[test_case(Ty::BuiltinClassLiteral("int"), Ty::BuiltinClassLiteral("object"))]
     #[test_case(Ty::BuiltinInstance("int"), Ty::BuiltinClassLiteral("int"))]
     #[test_case(Ty::TypingInstance("_SpecialForm"), Ty::TypingLiteral)]
+    #[test_case(Ty::BuiltinInstance("type"), Ty::SubclassOfBuiltinClass("str"))]
+    #[test_case(Ty::BuiltinClassLiteral("str"), Ty::SubclassOfAny)]
     fn is_not_subtype_of(from: Ty, to: Ty) {
         let db = setup_db();
         assert!(!from.into_type(&db).is_subtype_of(&db, to.into_type(&db)));
@@ -3401,6 +3418,7 @@ pub(crate) mod tests {
     #[test_case(Ty::Intersection{pos: vec![Ty::BuiltinInstance("int"), Ty::IntLiteral(2)], neg: vec![]}, Ty::IntLiteral(2))]
     #[test_case(Ty::Tuple(vec![Ty::IntLiteral(1), Ty::IntLiteral(2)]), Ty::Tuple(vec![Ty::IntLiteral(1), Ty::BuiltinInstance("int")]))]
     #[test_case(Ty::BuiltinClassLiteral("str"), Ty::BuiltinInstance("type"))]
+    #[test_case(Ty::BuiltinClassLiteral("str"), Ty::SubclassOfAny)]
     fn is_not_disjoint_from(a: Ty, b: Ty) {
         let db = setup_db();
         let a = a.into_type(&db);