[ty] no more diverging query cycles in type expressions

Author: carljm

crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md

@@ -0,0 +1,39 @@
+# Implicit type aliases
+
+Implicit type aliases are the earliest form of type alias, introduced in PEP 484. They have no
+special marker, just an ordinary assignment statement.
+
+## Basic
+
+We support simple type aliases with no extra effort, when the "value type" of the RHS is still a
+valid type for use in a type expression:
+
+```py
+MyInt = int
+
+def f(x: MyInt):
+    reveal_type(x)  # revealed: int
+
+f(1)
+```
+
+## Recursive
+
+### Old union syntax
+
+```py
+from typing import Union
+
+T = list[Union["T", None]]
+```
+
+### New union syntax
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+T = list["T" | None]
+```

crates/ty_python_semantic/src/types.rs

@@ -65,7 +65,6 @@ 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};
@@ -222,6 +221,10 @@ 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.
@@ -588,6 +591,19 @@ 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! {
@@ -6506,10 +6522,74 @@ impl<'db> Type<'db> {
     }
 
     pub(super) fn has_divergent_type(self, db: &'db dyn Db, div: Type<'db>) -> bool {
-        any_over_type(db, self, &|ty| match ty {
-            Type::Dynamic(DynamicType::Divergent(_)) => ty == div,
-            _ => false,
-        })
+        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.
+        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,
+        }
     }
 }
 
@@ -9155,6 +9235,16 @@ 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.
@@ -10129,6 +10219,17 @@ 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)]
@@ -10344,6 +10445,21 @@ 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,11 +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, HasRelationToVisitor,
-    IsEquivalentVisitor, KnownInstanceType, ManualPEP695TypeAliasType, MaterializationKind,
-    NormalizedVisitor, PropertyInstanceType, StringLiteralType, TypeAliasType, TypeContext,
-    TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarKind,
-    TypedDictParams, UnionBuilder, VarianceInferable, declaration_type, infer_definition_types,
+    DataclassParams, DeprecatedInstance, FindLegacyTypeVarsVisitor, HasDivergentTypeVisitor,
+    HasRelationToVisitor, IsEquivalentVisitor, KnownInstanceType, ManualPEP695TypeAliasType,
+    MaterializationKind, NormalizedVisitor, PropertyInstanceType, StringLiteralType, TypeAliasType,
+    TypeContext, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance,
+    TypeVarKind, TypedDictParams, UnionBuilder, VarianceInferable, declaration_type,
+    infer_definition_types,
 };
 use crate::{
     Db, FxIndexMap, FxOrderSet, Program,
@@ -614,6 +615,20 @@ 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/generics.rs

@@ -16,10 +16,11 @@ 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, HasRelationToVisitor,
-    IsEquivalentVisitor, KnownClass, KnownInstanceType, MaterializationKind, NormalizedVisitor,
-    Type, TypeMapping, TypeRelation, TypeVarBoundOrConstraints, TypeVarInstance, TypeVarVariance,
-    UnionType, binding_type, declaration_type,
+    ApplyTypeMappingVisitor, BoundTypeVarInstance, FindLegacyTypeVarsVisitor,
+    HasDivergentTypeVisitor, HasRelationToVisitor, IsEquivalentVisitor, KnownClass,
+    KnownInstanceType, MaterializationKind, NormalizedVisitor, Type, TypeMapping, TypeRelation,
+    TypeVarBoundOrConstraints, TypeVarInstance, TypeVarVariance, UnionType, binding_type,
+    declaration_type,
 };
 use crate::{Db, FxOrderSet};
 
@@ -926,6 +927,20 @@ 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.rs

@@ -111,12 +111,18 @@ pub(crate) fn infer_definition_types<'db>(
 }
 
 fn definition_cycle_recover<'db>(
-    _db: &'db dyn Db,
+    db: &'db dyn Db,
     _value: &DefinitionInference<'db>,
-    _count: u32,
-    _definition: Definition<'db>,
+    count: u32,
+    definition: Definition<'db>,
 ) -> salsa::CycleRecoveryAction<DefinitionInference<'db>> {
-    salsa::CycleRecoveryAction::Iterate
+    if count == ITERATIONS_BEFORE_FALLBACK {
+        salsa::CycleRecoveryAction::Fallback(DefinitionInference::cycle_fallback(
+            definition.scope(db),
+        ))
+    } else {
+        salsa::CycleRecoveryAction::Iterate
+    }
 }
 
 fn definition_cycle_initial<'db>(
@@ -151,6 +157,9 @@ pub(crate) fn infer_deferred_types<'db>(
         .finish_definition()
 }
 
+/// How many fixpoint iterations to allow before falling back to Divergent type.
+const ITERATIONS_BEFORE_FALLBACK: u32 = 10;
+
 fn deferred_cycle_recover<'db>(
     _db: &'db dyn Db,
     _value: &DefinitionInference<'db>,
@@ -207,9 +216,6 @@ fn infer_expression_types_impl<'db>(
     .finish_expression()
 }
 
-/// How many fixpoint iterations to allow before falling back to Divergent type.
-const ITERATIONS_BEFORE_FALLBACK: u32 = 10;
-
 fn expression_cycle_recover<'db>(
     db: &'db dyn Db,
     _value: &ExpressionInference<'db>,
@@ -623,6 +629,22 @@ impl<'db> DefinitionInference<'db> {
         }
     }
 
+    fn cycle_fallback(scope: ScopeId<'db>) -> Self {
+        let _ = scope;
+
+        Self {
+            expressions: FxHashMap::default(),
+            bindings: Box::default(),
+            declarations: Box::default(),
+            #[cfg(debug_assertions)]
+            scope,
+            extra: Some(Box::new(DefinitionInferenceExtra {
+                cycle_recovery: Some(CycleRecovery::Divergent(scope)),
+                ..DefinitionInferenceExtra::default()
+            })),
+        }
+    }
+
     pub(crate) fn expression_type(&self, expression: impl Into<ExpressionNodeKey>) -> Type<'db> {
         self.try_expression_type(expression)
             .unwrap_or_else(Type::unknown)