use any_over_type again

Author: carljm

crates/ty_python_semantic/src/types.rs

@@ -65,6 +65,7 @@ use crate::types::signatures::{Parameter, ParameterForm, Parameters, walk_signat
 use crate::types::tuple::TupleSpec;
 pub(crate) use crate::types::typed_dict::{TypedDictParams, TypedDictType, walk_typed_dict_type};
 use crate::types::variance::{TypeVarVariance, VarianceInferable};
+use crate::types::visitor::any_over_type;
 use crate::unpack::EvaluationMode;
 pub use crate::util::diagnostics::add_inferred_python_version_hint_to_diagnostic;
 use crate::{Db, FxOrderSet, Module, Program};
@@ -221,10 +222,6 @@ pub(crate) struct TryBool;
 pub(crate) type NormalizedVisitor<'db> = TypeTransformer<'db, Normalized>;
 pub(crate) struct Normalized;
 
-/// A [`CycleDetector`] that is used in `has_divergent_type` methods.
-pub(crate) type HasDivergentTypeVisitor<'db> = CycleDetector<HasDivergentType, Type<'db>, bool>;
-pub(crate) struct HasDivergentType;
-
 /// How a generic type has been specialized.
 ///
 /// This matters only if there is at least one invariant type parameter.
@@ -591,19 +588,6 @@ impl<'db> PropertyInstanceType<'db> {
 
         getter_equivalence.and(db, setter_equivalence)
     }
-
-    fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        self.getter(db)
-            .is_some_and(|ty| ty.has_divergent_type_impl(db, div, visitor))
-            || self
-                .setter(db)
-                .is_some_and(|ty| ty.has_divergent_type_impl(db, div, visitor))
-    }
 }
 
 bitflags! {
@@ -6512,77 +6496,7 @@ impl<'db> Type<'db> {
     }
 
     pub(super) fn has_divergent_type(self, db: &'db dyn Db, div: Type<'db>) -> bool {
-        self.has_divergent_type_impl(db, div, &HasDivergentTypeVisitor::new(false))
-    }
-
-    pub(super) fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        // We don't use `any_over_type` here because we don't need/want to descend into lazy
-        // parts of types (typevar bounds/constraints, type alias values, etc) here. If it's a lazy
-        // aspect of the type, it won't cause a query cycle in type inference, and we shouldn't
-        // trigger unnecessary inference of it. (TODO: bounds/constraints of legacy typevars aren't
-        // yet lazy, but they should be.)
-        match self {
-            Type::Dynamic(DynamicType::Divergent(_)) => self == div,
-            Type::Union(union) => union.has_divergent_type_impl(db, div, visitor),
-            Type::Intersection(intersection) => {
-                intersection.has_divergent_type_impl(db, div, visitor)
-            }
-            Type::GenericAlias(alias) => visitor.visit(self, || {
-                alias
-                    .specialization(db)
-                    .has_divergent_type_impl(db, div, visitor)
-            }),
-            Type::NominalInstance(instance) => visitor.visit(self, || {
-                instance.class(db).has_divergent_type_impl(db, div, visitor)
-            }),
-            Type::Callable(callable) => {
-                visitor.visit(self, || callable.has_divergent_type_impl(db, div, visitor))
-            }
-            Type::ProtocolInstance(protocol) => {
-                visitor.visit(self, || protocol.has_divergent_type_impl(db, div, visitor))
-            }
-            Type::PropertyInstance(property) => property.has_divergent_type_impl(db, div, visitor),
-            Type::TypeIs(type_is) => type_is
-                .return_type(db)
-                .has_divergent_type_impl(db, div, visitor),
-            Type::SubclassOf(subclass_of) => visitor.visit(self, || {
-                subclass_of.has_divergent_type_impl(db, div, visitor)
-            }),
-            Type::TypedDict(typed_dict) => visitor.visit(self, || {
-                typed_dict
-                    .defining_class()
-                    .has_divergent_type_impl(db, div, visitor)
-            }),
-            Type::Never
-            | Type::AlwaysTruthy
-            | Type::AlwaysFalsy
-            | Type::WrapperDescriptor(_)
-            | Type::DataclassDecorator(_)
-            | Type::DataclassTransformer(_)
-            | Type::ModuleLiteral(_)
-            | Type::ClassLiteral(_)
-            | Type::IntLiteral(_)
-            | Type::BooleanLiteral(_)
-            | Type::LiteralString
-            | Type::StringLiteral(_)
-            | Type::BytesLiteral(_)
-            | Type::EnumLiteral(_)
-            | Type::BoundSuper(_)
-            | Type::SpecialForm(_)
-            | Type::KnownInstance(_)
-            | Type::NonInferableTypeVar(_)
-            | Type::TypeVar(_)
-            | Type::FunctionLiteral(_)
-            | Type::KnownBoundMethod(_)
-            | Type::BoundMethod(_)
-            | Type::Dynamic(_)
-            | Type::TypeAlias(_) => false,
-        }
+        any_over_type(db, self, &|ty| ty == div, false)
     }
 }
 
@@ -7528,10 +7442,27 @@ fn walk_type_var_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
     typevar: TypeVarInstance<'db>,
     visitor: &V,
 ) {
-    if let Some(bounds) = typevar.bound_or_constraints(db) {
-        walk_type_var_bounds(db, bounds, visitor);
+    if let Some(bound_or_constraints) = if visitor.should_visit_lazy_type_attributes() {
+        typevar.bound_or_constraints(db)
+    } else {
+        match typevar._bound_or_constraints(db) {
+            _ if visitor.should_visit_lazy_type_attributes() => typevar.bound_or_constraints(db),
+            Some(TypeVarBoundOrConstraintsEvaluation::Eager(bound_or_constraints)) => {
+                Some(bound_or_constraints)
+            }
+            _ => None,
+        }
+    } {
+        walk_type_var_bounds(db, bound_or_constraints, visitor);
     }
-    if let Some(default_type) = typevar.default_type(db) {
+    if let Some(default_type) = if visitor.should_visit_lazy_type_attributes() {
+        typevar.default_type(db)
+    } else {
+        match typevar._default(db) {
+            Some(TypeVarDefaultEvaluation::Eager(default_type)) => Some(default_type),
+            _ => None,
+        }
+    } {
         visitor.visit_type(db, default_type);
     }
 }
@@ -9314,16 +9245,6 @@ impl<'db> CallableType<'db> {
                 .is_equivalent_to_impl(db, other.signatures(db), visitor)
         })
     }
-
-    fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        self.signatures(db)
-            .has_divergent_type_impl(db, div, visitor)
-    }
 }
 
 /// Represents a specific instance of a bound method type for a builtin class.
@@ -9970,6 +9891,9 @@ fn walk_type_alias_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
     type_alias: TypeAliasType<'db>,
     visitor: &V,
 ) {
+    if !visitor.should_visit_lazy_type_attributes() {
+        return;
+    }
     match type_alias {
         TypeAliasType::PEP695(type_alias) => {
             walk_pep_695_type_alias(db, type_alias, visitor);
@@ -10298,17 +10222,6 @@ impl<'db> UnionType<'db> {
 
         ConstraintSet::from(sorted_self == other.normalized(db))
     }
-
-    fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        self.elements(db)
-            .iter()
-            .any(|ty| ty.has_divergent_type_impl(db, div, visitor))
-    }
 }
 
 #[salsa::interned(debug, heap_size=IntersectionType::heap_size)]
@@ -10524,21 +10437,6 @@ impl<'db> IntersectionType<'db> {
         ruff_memory_usage::order_set_heap_size(positive)
             + ruff_memory_usage::order_set_heap_size(negative)
     }
-
-    fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        self.positive(db)
-            .iter()
-            .any(|ty| ty.has_divergent_type_impl(db, div, visitor))
-            || self
-                .negative(db)
-                .iter()
-                .any(|ty| ty.has_divergent_type_impl(db, div, visitor))
-    }
 }
 
 /// # Ordering

crates/ty_python_semantic/src/types/class.rs

@@ -26,12 +26,12 @@ use crate::types::tuple::{TupleSpec, TupleType};
 use crate::types::typed_dict::typed_dict_params_from_class_def;
 use crate::types::{
     ApplyTypeMappingVisitor, Binding, BoundSuperError, BoundSuperType, CallableType,
-    DataclassParams, DeprecatedInstance, FindLegacyTypeVarsVisitor, HasDivergentTypeVisitor,
-    HasRelationToVisitor, IsEquivalentVisitor, KnownInstanceType, ManualPEP695TypeAliasType,
-    MaterializationKind, NormalizedVisitor, PropertyInstanceType, StringLiteralType, TypeAliasType,
-    TypeContext, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance,
-    TypeVarKind, TypedDictParams, UnionBuilder, VarianceInferable, declaration_type,
-    determine_upper_bound, infer_definition_types,
+    DataclassParams, DeprecatedInstance, FindLegacyTypeVarsVisitor, HasRelationToVisitor,
+    IsEquivalentVisitor, KnownInstanceType, ManualPEP695TypeAliasType, MaterializationKind,
+    NormalizedVisitor, PropertyInstanceType, StringLiteralType, TypeAliasType, TypeContext,
+    TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarKind,
+    TypedDictParams, UnionBuilder, VarianceInferable, declaration_type, determine_upper_bound,
+    infer_definition_types,
 };
 use crate::{
     Db, FxIndexMap, FxOrderSet, Program,
@@ -615,20 +615,6 @@ impl<'db> ClassType<'db> {
         }
     }
 
-    pub(super) fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        match self {
-            ClassType::NonGeneric(_) => false,
-            ClassType::Generic(generic) => generic
-                .specialization(db)
-                .has_divergent_type_impl(db, div, visitor),
-        }
-    }
-
     /// Return the metaclass of this class, or `type[Unknown]` if the metaclass cannot be inferred.
     pub(super) fn metaclass(self, db: &'db dyn Db) -> Type<'db> {
         let (class_literal, specialization) = self.class_literal(db);

crates/ty_python_semantic/src/types/function.rs

@@ -1499,8 +1499,8 @@ impl KnownFunction {
                 let contains_unknown_or_todo =
                     |ty| matches!(ty, Type::Dynamic(dynamic) if dynamic != DynamicType::Any);
                 if source_type.is_equivalent_to(db, *casted_type)
-                    && !any_over_type(db, *source_type, &contains_unknown_or_todo)
-                    && !any_over_type(db, *casted_type, &contains_unknown_or_todo)
+                    && !any_over_type(db, *source_type, &contains_unknown_or_todo, true)
+                    && !any_over_type(db, *casted_type, &contains_unknown_or_todo, true)
                 {
                     if let Some(builder) = context.report_lint(&REDUNDANT_CAST, call_expression) {
                         builder.into_diagnostic(format_args!(

crates/ty_python_semantic/src/types/generics.rs

@@ -16,11 +16,10 @@ use crate::types::instance::{Protocol, ProtocolInstanceType};
 use crate::types::signatures::{Parameter, Parameters, Signature};
 use crate::types::tuple::{TupleSpec, TupleType, walk_tuple_type};
 use crate::types::{
-    ApplyTypeMappingVisitor, BoundTypeVarInstance, FindLegacyTypeVarsVisitor,
-    HasDivergentTypeVisitor, HasRelationToVisitor, IsEquivalentVisitor, KnownClass,
-    KnownInstanceType, MaterializationKind, NormalizedVisitor, Type, TypeMapping, TypeRelation,
-    TypeVarBoundOrConstraints, TypeVarInstance, TypeVarVariance, UnionType, binding_type,
-    declaration_type,
+    ApplyTypeMappingVisitor, BoundTypeVarInstance, FindLegacyTypeVarsVisitor, HasRelationToVisitor,
+    IsEquivalentVisitor, KnownClass, KnownInstanceType, MaterializationKind, NormalizedVisitor,
+    Type, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarVariance,
+    UnionType, binding_type, declaration_type,
 };
 use crate::{Db, FxOrderSet};
 
@@ -927,20 +926,6 @@ impl<'db> Specialization<'db> {
         // A tuple's specialization will include all of its element types, so we don't need to also
         // look in `self.tuple`.
     }
-
-    pub(super) fn has_divergent_type_impl(
-        self,
-        db: &'db dyn Db,
-        div: Type<'db>,
-        visitor: &HasDivergentTypeVisitor<'db>,
-    ) -> bool {
-        self.types(db)
-            .iter()
-            .any(|ty| ty.has_divergent_type_impl(db, div, visitor))
-            || self
-                .tuple_inner(db)
-                .is_some_and(|tuple| tuple.has_divergent_type_impl(db, div, visitor))
-    }
 }
 
 /// A mapping between type variables and types.

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -8785,14 +8785,19 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                         *typevar,
                     )
                     .ok_or(GenericContextError::InvalidArgument)
-                } else if any_over_type(self.db(), *typevar, &|ty| match ty {
-                    Type::Dynamic(DynamicType::TodoUnpack) => true,
-                    Type::NominalInstance(nominal) => matches!(
-                        nominal.known_class(self.db()),
-                        Some(KnownClass::TypeVarTuple | KnownClass::ParamSpec)
-                    ),
-                    _ => false,
-                }) {
+                } else if any_over_type(
+                    self.db(),
+                    *typevar,
+                    &|ty| match ty {
+                        Type::Dynamic(DynamicType::TodoUnpack) => true,
+                        Type::NominalInstance(nominal) => matches!(
+                            nominal.known_class(self.db()),
+                            Some(KnownClass::TypeVarTuple | KnownClass::ParamSpec)
+                        ),
+                        _ => false,
+                    },
+                    true,
+                ) {
                     Err(GenericContextError::NotYetSupported)
                 } else {
                     if let Some(builder) =

crates/ty_python_semantic/src/types/infer/builder/type_expression.rs

@@ -1522,13 +1522,18 @@ impl<'db> TypeInferenceBuilder<'db, '_> {
                     // `Callable[]`.
                     return None;
                 }
-                if any_over_type(self.db(), self.infer_name_load(name), &|ty| match ty {
-                    Type::Dynamic(DynamicType::TodoPEP695ParamSpec) => true,
-                    Type::NominalInstance(nominal) => {
-                        nominal.has_known_class(self.db(), KnownClass::ParamSpec)
-                    }
-                    _ => false,
-                }) {
+                if any_over_type(
+                    self.db(),
+                    self.infer_name_load(name),
+                    &|ty| match ty {
+                        Type::Dynamic(DynamicType::TodoPEP695ParamSpec) => true,
+                        Type::NominalInstance(nominal) => {
+                            nominal.has_known_class(self.db(), KnownClass::ParamSpec)
+                        }
+                        _ => false,
+                    },
+                    true,
+                ) {
                     return Some(Parameters::todo());
                 }
             }