Use a thread local

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md

@@ -501,6 +501,24 @@ def assign_recursive_alias_attribute(x: RecursiveAttributeAlias):
 def delete_recursive_alias_attribute(x: RecursiveAttributeAlias):
     del x.attr
 
+class RecursiveMissingAttribute: ...
+
+type RecursiveMissingAttributeAlias = RecursiveMissingAttribute | RecursiveMissingAttributeAlias
+
+def load_missing_recursive_alias_attribute(x: RecursiveMissingAttributeAlias):
+    # error: [unresolved-attribute] "Attribute `missing` is not defined on `RecursiveMissingAttribute` in union `RecursiveMissingAttributeAlias`"
+    reveal_type(x.missing)  # revealed: Divergent
+
+def delete_missing_recursive_alias_attribute(x: RecursiveMissingAttributeAlias):
+    # error: [unresolved-attribute] "Attribute `missing` is not defined on `RecursiveMissingAttribute` in union `RecursiveMissingAttributeAlias`"
+    del x.missing
+
+type RecursiveIntAttributeAlias = int | RecursiveIntAttributeAlias
+
+def load_missing_recursive_int_alias_attribute(x: RecursiveIntAttributeAlias):
+    # error: [unresolved-attribute] "Attribute `missing` is not defined on `int` in union `RecursiveIntAttributeAlias`"
+    reveal_type(x.missing)  # revealed: Divergent
+
 class RecursiveKwargs(TypedDict):
     kind: Literal["a"]
     a: int

crates/ty_python_semantic/src/types.rs

@@ -13,7 +13,6 @@ use crate::{
         SubclassOfType, Type, TypeVarBoundOrConstraints, UnionBuilder,
         constraints::ConstraintSet,
         context::InferContext,
-        cyclic::ActiveRecursionDetector,
         diagnostic::{INVALID_SUPER_ARGUMENT, UNAVAILABLE_IMPLICIT_SUPER_ARGUMENTS},
         relation::EquivalenceChecker,
         signatures::{Parameter, Parameters, Signature},
@@ -488,24 +487,8 @@ impl<'db> BoundSuperType<'db> {
         pivot_class_type: Type<'db>,
         owner_type: Type<'db>,
     ) -> Result<Type<'db>, BoundSuperError<'db>> {
-        let recursion_detector = ActiveRecursionDetector::default();
-        Self::build_impl(db, pivot_class_type, owner_type, &recursion_detector)
-    }
-
-    fn build_impl(
-        db: &'db dyn Db,
-        pivot_class_type: Type<'db>,
-        owner_type: Type<'db>,
-        recursion_detector: &ActiveRecursionDetector<Type<'db>>,
-    ) -> Result<Type<'db>, BoundSuperError<'db>> {
-        let delegate_to = |type_to_delegate_to| {
-            BoundSuperType::build_impl(
-                db,
-                pivot_class_type,
-                type_to_delegate_to,
-                recursion_detector,
-            )
-        };
+        let delegate_to =
+            |type_to_delegate_to| BoundSuperType::build(db, pivot_class_type, type_to_delegate_to);
 
         // Delegate but rewrite errors to preserve TypeVar context.
         let delegate_with_error_mapped =
@@ -756,12 +739,7 @@ impl<'db> BoundSuperType<'db> {
                 return Ok(builder.build());
             }
             Type::TypeAlias(_) => {
-                return owner_type.visit_type_alias_value(
-                    db,
-                    recursion_detector,
-                    || Ok(Type::unknown()),
-                    delegate_to,
-                );
+                return owner_type.visit_type_alias_value(db, || Ok(Type::unknown()), delegate_to);
             }
             Type::TypeVar(bound_typevar) => {
                 let typevar = bound_typevar.typevar(db);

crates/ty_python_semantic/src/types/bound_super.rs

@@ -6,7 +6,6 @@ use ruff_python_ast as ast;
 use rustc_hash::FxHashMap;
 
 use crate::Db;
-use crate::types::cyclic::ActiveRecursionDetector;
 use crate::types::enums::{enum_member_literals, enum_metadata};
 use crate::types::tuple::Tuple;
 use crate::types::typed_dict::extract_unpacked_typed_dict_keys_from_value_type;
@@ -496,32 +495,21 @@ impl<'a, 'db> FromIterator<(Argument<'a>, Option<Type<'db>>)> for CallArguments<
 ///
 /// In other words, it returns `true` if [`expand_type`] returns [`Some`] for the given type.
 pub(crate) fn is_expandable_type<'db>(db: &'db dyn Db, ty: Type<'db>) -> bool {
-    let recursion_detector = ActiveRecursionDetector::default();
-    is_expandable_type_impl(db, ty, &recursion_detector)
-}
-
-fn is_expandable_type_impl<'db>(
-    db: &'db dyn Db,
-    ty: Type<'db>,
-    recursion_detector: &ActiveRecursionDetector<Type<'db>>,
-) -> bool {
     match ty {
         Type::NominalInstance(instance) => {
             let class = instance.class(db);
             class.is_known(db, KnownClass::Bool)
                 || instance.tuple_spec(db).is_some_and(|spec| match &*spec {
                     Tuple::Fixed(fixed_length_tuple) => fixed_length_tuple
                         .iter_all_elements()
-                        .any(|element| is_expandable_type_impl(db, element, recursion_detector)),
+                        .any(|element| is_expandable_type(db, element)),
                     Tuple::Variable(_) => false,
                 })
                 || enum_metadata(db, class.class_literal(db)).is_some()
         }
         Type::Union(_) => true,
         Type::TypeAlias(_) => {
-            ty.visit_type_alias_value_or_default(db, recursion_detector, |value_ty| {
-                is_expandable_type_impl(db, value_ty, recursion_detector)
-            })
+            ty.visit_type_alias_value_or_default(db, |value_ty| is_expandable_type(db, value_ty))
         }
         _ => false,
     }
@@ -531,15 +519,6 @@ fn is_expandable_type_impl<'db>(
 ///
 /// Returns [`None`] if the type cannot be expanded.
 fn expand_type<'db>(db: &'db dyn Db, ty: Type<'db>) -> Option<Vec<Type<'db>>> {
-    let recursion_detector = ActiveRecursionDetector::default();
-    expand_type_impl(db, ty, &recursion_detector)
-}
-
-fn expand_type_impl<'db>(
-    db: &'db dyn Db,
-    ty: Type<'db>,
-    recursion_detector: &ActiveRecursionDetector<Type<'db>>,
-) -> Option<Vec<Type<'db>>> {
     // NOTE: Update `is_expandable_type` if this logic changes accordingly.
     match ty {
         Type::NominalInstance(instance) => {
@@ -560,8 +539,7 @@ fn expand_type_impl<'db>(
                         let per_element: Vec<_> = fixed_length_tuple
                             .iter_all_elements()
                             .map(|element| {
-                                expand_type_impl(db, element, recursion_detector)
-                                    .unwrap_or_else(|| vec![element])
+                                expand_type(db, element).unwrap_or_else(|| vec![element])
                             })
                             .collect();
 
@@ -594,9 +572,7 @@ fn expand_type_impl<'db>(
         Type::Union(union) => Some(union.elements(db).to_vec()),
         // For type aliases, expand the underlying value type.
         Type::TypeAlias(_) => {
-            ty.visit_type_alias_value_or_default(db, recursion_detector, |value_ty| {
-                expand_type_impl(db, value_ty, recursion_detector)
-            })
+            ty.visit_type_alias_value_or_default(db, |value_ty| expand_type(db, value_ty))
         }
         // We don't handle `type[A | B]` here because it's already stored in the expanded form
         // i.e., `type[A] | type[B]` which is handled by the `Type::Union` case.

crates/ty_python_semantic/src/types/call/arguments.rs

@@ -2,7 +2,6 @@ use super::{ArgumentForms, Binding, Bindings, CallableBinding, CallableItem};
 use crate::db::Db;
 use crate::types::call::arguments::CallArguments;
 use crate::types::constraints::ConstraintSetBuilder;
-use crate::types::cyclic::ActiveRecursionDetector;
 use crate::types::generics::Specialization;
 use crate::types::signatures::Parameter;
 use crate::types::{BoundTypeVarInstance, ClassLiteral, DynamicType, Type, TypeContext};
@@ -566,29 +565,18 @@ fn constructor_returns_instance<'db>(
     db: &'db dyn Db,
     class_literal: ClassLiteral<'db>,
     return_ty: Type<'db>,
-) -> bool {
-    let recursion_detector = ActiveRecursionDetector::default();
-    constructor_returns_instance_impl(db, class_literal, return_ty, &recursion_detector)
-}
-
-fn constructor_returns_instance_impl<'db>(
-    db: &'db dyn Db,
-    class_literal: ClassLiteral<'db>,
-    return_ty: Type<'db>,
-    recursion_detector: &ActiveRecursionDetector<Type<'db>>,
 ) -> bool {
     match return_ty {
-        Type::TypeAlias(_) => {
-            return_ty.visit_type_alias_value_or_assume_valid(db, recursion_detector, |value_ty| {
-                constructor_returns_instance_impl(db, class_literal, value_ty, recursion_detector)
-            })
-        }
-        Type::Union(union) => union.elements(db).iter().all(|element| {
-            constructor_returns_instance_impl(db, class_literal, *element, recursion_detector)
-        }),
-        Type::Intersection(intersection) => intersection.iter_positive(db).any(|element| {
-            constructor_returns_instance_impl(db, class_literal, element, recursion_detector)
+        Type::TypeAlias(_) => return_ty.visit_type_alias_value_or_assume_valid(db, |value_ty| {
+            constructor_returns_instance(db, class_literal, value_ty)
         }),
+        Type::Union(union) => union
+            .elements(db)
+            .iter()
+            .all(|element| constructor_returns_instance(db, class_literal, *element)),
+        Type::Intersection(intersection) => intersection
+            .iter_positive(db)
+            .any(|element| constructor_returns_instance(db, class_literal, element)),
         // Spec says an explicit `Any` return type should be considered non-instance.
         Type::Dynamic(DynamicType::Any) => false,
         // But a missing return annotation should be considered instance.

crates/ty_python_semantic/src/types/call/bind/constructor.rs

@@ -11,7 +11,6 @@ use crate::{
         Parameter, Parameters, Signature, SubclassOfInner, Type, TypeContext, TypeMapping,
         TypeVarBoundOrConstraints, UnionType,
         constraints::{ConstraintSet, IteratorConstraintsExtension},
-        cyclic::ActiveRecursionDetector,
         known_instance::FunctoolsPartialInstance,
         relation::{TypeRelation, TypeRelationChecker},
         signatures::{CallableSignature, PartialSignatureApplication},
@@ -50,23 +49,9 @@ impl<'db> Type<'db> {
         self,
         db: &'db dyn Db,
         policy: UpcastPolicy,
-    ) -> Option<CallableTypes<'db>> {
-        let recursion_detector = ActiveRecursionDetector::default();
-        self.try_upcast_to_callable_with_policy_impl(db, policy, &recursion_detector)
-    }
-
-    fn try_upcast_to_callable_with_policy_impl(
-        self,
-        db: &'db dyn Db,
-        policy: UpcastPolicy,
-        recursion_detector: &ActiveRecursionDetector<Type<'db>>,
     ) -> Option<CallableTypes<'db>> {
         if let Some(fallback) = self.materialized_divergent_fallback() {
-            return fallback.try_upcast_to_callable_with_policy_impl(
-                db,
-                policy,
-                recursion_detector,
-            );
+            return fallback.try_upcast_to_callable_with_policy(db, policy);
         }
 
         match self {
@@ -100,9 +85,7 @@ impl<'db> Type<'db> {
                 if let Place::Defined(place) = call_symbol
                     && place.is_definitely_defined()
                 {
-                    place
-                        .ty
-                        .try_upcast_to_callable_with_policy_impl(db, policy, recursion_detector)
+                    place.ty.try_upcast_to_callable_with_policy(db, policy)
                 } else {
                     None
                 }
@@ -115,7 +98,7 @@ impl<'db> Type<'db> {
 
             Type::NewTypeInstance(newtype) => newtype
                 .concrete_base_type(db)
-                .try_upcast_to_callable_with_policy_impl(db, policy, recursion_detector),
+                .try_upcast_to_callable_with_policy(db, policy),
 
             Type::SubclassOf(subclass_of_ty) if policy == UpcastPolicy::Sound => {
                 Some(CallableTypes::one(CallableType::function_like(
@@ -131,11 +114,7 @@ impl<'db> Type<'db> {
                     Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
                         let upcast_callables = bound
                             .to_meta_type(db)
-                            .try_upcast_to_callable_with_policy_impl(
-                                db,
-                                policy,
-                                recursion_detector,
-                            )?;
+                            .try_upcast_to_callable_with_policy(db, policy)?;
                         Some(upcast_callables.map(|callable| {
                             let signatures = callable
                                 .signatures(db)
@@ -153,11 +132,7 @@ impl<'db> Type<'db> {
                         for constraint in constraints.elements(db) {
                             let element_upcast = constraint
                                 .to_meta_type(db)
-                                .try_upcast_to_callable_with_policy_impl(
-                                    db,
-                                    policy,
-                                    recursion_detector,
-                                )?;
+                                .try_upcast_to_callable_with_policy(db, policy)?;
                             for callable in element_upcast.into_inner() {
                                 let signatures = callable
                                     .signatures(db)
@@ -186,11 +161,8 @@ impl<'db> Type<'db> {
             Type::Union(union) => {
                 let mut callables = SmallVec::new();
                 for element in union.elements(db) {
-                    let element_callable = element.try_upcast_to_callable_with_policy_impl(
-                        db,
-                        policy,
-                        recursion_detector,
-                    )?;
+                    let element_callable =
+                        element.try_upcast_to_callable_with_policy(db, policy)?;
                     callables.extend(element_callable.into_inner());
                 }
                 Some(CallableTypes::new(callables))
@@ -199,17 +171,14 @@ impl<'db> Type<'db> {
             Type::LiteralValue(literal) => match literal.kind() {
                 LiteralValueTypeKind::Enum(enum_literal) => enum_literal
                     .enum_class_instance(db)
-                    .try_upcast_to_callable_with_policy_impl(db, policy, recursion_detector),
+                    .try_upcast_to_callable_with_policy(db, policy),
                 _ => None,
             },
 
             Type::TypeAlias(_) => self.visit_type_alias_value(
                 db,
-                recursion_detector,
                 || Some(CallableTypes::one(CallableType::unknown(db))),
-                |value_ty| {
-                    value_ty.try_upcast_to_callable_with_policy_impl(db, policy, recursion_detector)
-                },
+                |value_ty| value_ty.try_upcast_to_callable_with_policy(db, policy),
             ),
 
             Type::KnownBoundMethod(method) => Some(CallableTypes::one(CallableType::new(

crates/ty_python_semantic/src/types/callable.rs

@@ -30,8 +30,13 @@ use crate::types::generics::{
 };
 use crate::types::known_instance::DeprecatedInstance;
 use crate::types::member::Member;
-use crate::types::relation::{RelationContext, TypeRelation, TypeRelationChecker};
-use crate::types::signatures::{CallableSignature, Parameter, Parameters, Signature};
+use crate::types::relation::{
+    HasRelationToVisitor, InvariantRelationVisitor, IsDisjointVisitor, TypeRelation,
+    TypeRelationChecker,
+};
+use crate::types::signatures::{
+    CallableSignature, Parameter, Parameters, Signature, SignatureRelationVisitor,
+};
 use crate::types::tuple::TupleSpec;
 use crate::types::{
     ApplyTypeMappingVisitor, CallableType, CallableTypes, DataclassParams,
@@ -1190,9 +1195,20 @@ impl<'db> ClassType<'db> {
     /// Return `true` if `other` is present in this class's MRO.
     pub(super) fn is_subclass_of(self, db: &'db dyn Db, target: ClassType<'db>) -> bool {
         let constraints = ConstraintSetBuilder::new();
-        let context = RelationContext::default(&constraints);
-        let checker =
-            TypeRelationChecker::subtyping(&constraints, InferableTypeVars::None, &context);
+        let relation_visitor = HasRelationToVisitor::default(&constraints);
+        let disjointness_visitor = IsDisjointVisitor::default(&constraints);
+        let signature_relation_visitor = SignatureRelationVisitor::default();
+        let invariant_relation_visitor = InvariantRelationVisitor::default();
+        let materialization_visitor = ApplyTypeMappingVisitor::default();
+        let checker = TypeRelationChecker::subtyping(
+            &constraints,
+            InferableTypeVars::None,
+            &relation_visitor,
+            &disjointness_visitor,
+            &signature_relation_visitor,
+            &invariant_relation_visitor,
+            &materialization_visitor,
+        );
         checker
             .check_class_pair(db, self, target)
             .is_always_satisfied(db)