[ty] Fix TODO for meta-type of intersections

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/annotations/callable.md

@@ -496,7 +496,7 @@ def f_okay(c: Callable[[], None]):
 
         # TODO: should be `property`
         # (or complain that we don't know that `type(c)` has the attribute at all!)
-        reveal_type(type(c).__qualname__)  # revealed: @Todo(Intersection meta-type)
+        reveal_type(type(c).__qualname__)  # revealed: Unknown
 
         # `hasattr` only guarantees that an attribute is readable.
         #

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2301,6 +2301,7 @@ The type of `x.__class__` is the same as `x`'s meta-type. `x.__class__` is alway
 
 ```py
 import typing_extensions
+from ty_extensions import Intersection
 
 reveal_type(typing_extensions.__class__)  # revealed: <class 'ModuleType'>
 reveal_type(type(typing_extensions))  # revealed: <class 'ModuleType'>
@@ -2321,7 +2322,10 @@ reveal_type(d.__class__)  # revealed: <class 'bool'>
 e = (42, 42)
 reveal_type(e.__class__)  # revealed: type[tuple[Literal[42], Literal[42]]]
 
-def f(a: int, b: typing_extensions.LiteralString, c: int | str, d: type[str]):
+class A: ...
+class B: ...
+
+def f(a: int, b: typing_extensions.LiteralString, c: int | str, d: type[str], e: Intersection[A, B]):
     reveal_type(a.__class__)  # revealed: type[int]
     reveal_type(type(a))  # revealed: type[int]
 
@@ -2337,6 +2341,8 @@ def f(a: int, b: typing_extensions.LiteralString, c: int | str, d: type[str]):
     # All we know is that the metaclass must be a (non-strict) subclass of `type`.
     reveal_type(d.__class__)  # revealed: type[type]
 
+    reveal_type(e.__class__)  # revealed: type[A] & type[B]
+
 reveal_type(f.__class__)  # revealed: <class 'FunctionType'>
 
 class Foo: ...

crates/ty_python_semantic/resources/mdtest/named_tuple.md

@@ -1430,7 +1430,7 @@ def expects_named_tuple(x: typing.NamedTuple):
     reveal_type(x.__iter__)  # revealed: bound method tuple[object, ...].__iter__() -> Iterator[object]
 
 def _(y: type[typing.NamedTuple]):
-    reveal_type(y)  # revealed: @Todo(unsupported type[X] special form)
+    reveal_type(y)  # revealed: type[tuple[object, ...]] & type[NamedTupleLike]
 
 # error: [invalid-type-form] "Special form `typing.NamedTuple` expected no type parameter"
 def _(z: typing.NamedTuple[int]): ...

crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md

@@ -826,3 +826,13 @@ def f():
     else:
         reveal_type(x)  # revealed: str
 ```
+
+## Interaction of `isinstance()` narrowing and the meta-type of intersections
+
+```py
+def f(x: object):
+    if not isinstance(x, int):
+        reveal_type(x)  # revealed: ~int
+        reveal_type(x.__class__)  # revealed: type & ~type[int]
+        reveal_type(x.__class__.__name__)  # revealed: str
+```

crates/ty_python_semantic/src/types.rs

@@ -5480,11 +5480,8 @@ impl<'db> Type<'db> {
             Type::SubclassOf(subclass_of_ty) => subclass_of_ty.to_meta_type(db),
             Type::Dynamic(dynamic) => SubclassOfType::from(db, SubclassOfInner::Dynamic(dynamic)),
             Type::Divergent(_) => self,
-            // TODO intersections
-            Type::Intersection(_) => {
-                SubclassOfType::try_from_type(db, todo_type!("Intersection meta-type"))
-                    .expect("Type::Todo should be a valid `SubclassOfInner`")
-            }
+            Type::Intersection(_) => SubclassOfType::try_from_instance(db, self)
+                .unwrap_or_else(SubclassOfType::subclass_of_unknown),
             Type::AlwaysTruthy | Type::AlwaysFalsy => KnownClass::Type.to_instance(db),
             Type::BoundSuper(_) => KnownClass::Super.to_class_literal(db),
             Type::ProtocolInstance(protocol) => protocol.to_meta_type(db),

crates/ty_python_semantic/src/types/subclass_of.rs

@@ -6,9 +6,9 @@ use crate::types::relation::{DisjointnessChecker, TypeRelationChecker};
 use crate::types::variance::VarianceInferable;
 use crate::types::{
     ApplyTypeMappingVisitor, BoundTypeVarInstance, ClassLiteral, ClassType, DynamicType,
-    FindLegacyTypeVarsVisitor, KnownClass, MaterializationKind, MemberLookupPolicy,
-    SpecialFormType, Type, TypeContext, TypeMapping, TypeVarBoundOrConstraints, TypeVarVariance,
-    TypedDictType, UnionType, todo_type,
+    FindLegacyTypeVarsVisitor, IntersectionBuilder, KnownClass, MaterializationKind,
+    MemberLookupPolicy, SpecialFormType, Type, TypeContext, TypeMapping, TypeVarBoundOrConstraints,
+    TypeVarVariance, TypedDictType, UnionType, todo_type,
 };
 use crate::{Db, FxOrderSet};
 use ty_python_core::definition::Definition;
@@ -88,6 +88,21 @@ impl<'db> SubclassOfType<'db> {
                     .iter()
                     .map(|element| Self::try_from_instance(db, *element)),
             ),
+            Type::Intersection(intersection) => {
+                let mut builder = IntersectionBuilder::new(db);
+                let positive = intersection.positive(db);
+                if positive.is_empty() {
+                    builder = builder.add_positive(KnownClass::Type.to_instance(db));
+                } else {
+                    for &element in intersection.positive(db) {
+                        builder = builder.add_positive(Self::try_from_instance(db, element)?);
+                    }
+                }
+                for &element in intersection.negative(db) {
+                    builder = builder.add_negative(Self::try_from_instance(db, element)?);
+                }
+                Some(builder.build())
+            }
             Type::ProtocolInstance(protocol) => Some(protocol.to_meta_type(db)),
             _ => SubclassOfInner::try_from_instance(db, ty)
                 .map(|subclass_of| Self::from(db, subclass_of)),