use CycleHeads to remove Divergent types

Author: mtshiba

Cargo.lock

@@ -146,7 +146,7 @@ regex-automata = { version = "0.4.9" }
 rustc-hash = { version = "2.0.0" }
 rustc-stable-hash = { version = "0.1.2" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "05a9af7f554b64b8aadc2eeb6f2caf73d0408d09", default-features = false, features = [
+salsa = { git = "https://github.com/mtshiba/salsa.git", rev = "11f2ec8629e46b391c41aef5d770de92760a4f01", default-features = false, features = [
     "compact_str",
     "macros",
     "salsa_unstable",

Cargo.toml

@@ -734,6 +734,8 @@ from typing_extensions import Generic, TypeVar
 
 T = TypeVar("T")
 
+# TODO: no error
+# error: [unsupported-base] "Unsupported class base with type `<class 'list[Derived[T@Derived]]'> | <class 'list[@Todo(specialized non-generic class)]'>`"
 class Derived(list[Derived[T]], Generic[T]): ...
 ```
 

crates/ty_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -710,6 +710,7 @@ fn place_cycle_initial<'db>(
 fn place_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_place: &PlaceAndQualifiers<'db>,
     place: PlaceAndQualifiers<'db>,
     _count: u32,
@@ -720,7 +721,13 @@ fn place_cycle_recover<'db>(
 ) -> PlaceAndQualifiers<'db> {
     let div = Type::divergent(id);
     PlaceAndQualifiers {
-        place: join_with_previous_cycle_place(db, &previous_place.place, &place.place, div),
+        place: join_with_previous_cycle_place(
+            db,
+            &previous_place.place,
+            &place.place,
+            div,
+            cycle_heads,
+        ),
         qualifiers: place.qualifiers,
     }
 }

crates/ty_python_semantic/src/place.rs

@@ -416,6 +416,7 @@ fn member_lookup_cycle_initial<'db>(
 fn member_lookup_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_member: &PlaceAndQualifiers<'db>,
     member: PlaceAndQualifiers<'db>,
     _count: u32,
@@ -424,7 +425,8 @@ fn member_lookup_cycle_recover<'db>(
     _policy: MemberLookupPolicy,
 ) -> PlaceAndQualifiers<'db> {
     let div = Type::divergent(id);
-    let place = join_with_previous_cycle_place(db, &previous_member.place, &member.place, div);
+    let place =
+        join_with_previous_cycle_place(db, &previous_member.place, &member.place, div, cycle_heads);
     PlaceAndQualifiers {
         place,
         qualifiers: member.qualifiers,
@@ -446,12 +448,13 @@ pub(crate) fn join_with_previous_cycle_place<'db>(
     previous_place: &Place<'db>,
     place: &Place<'db>,
     div: Type<'db>,
+    cycle_heads: &salsa::CycleHeads,
 ) -> Place<'db> {
     match (previous_place, place) {
         // In fixed-point iteration of type inference, the member type must be monotonically widened and not "oscillate".
         // Here, monotonicity is guaranteed by pre-unioning the type of the previous iteration into the current result.
         (Place::Defined(prev_ty, _, _), Place::Defined(ty, origin, definedness)) => Place::Defined(
-            ty.cycle_normalized(db, *prev_ty, div),
+            ty.cycle_normalized(db, *prev_ty, div, cycle_heads),
             *origin,
             *definedness,
         ),
@@ -466,6 +469,7 @@ pub(crate) fn join_with_previous_cycle_place<'db>(
 fn class_lookup_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_member: &PlaceAndQualifiers<'db>,
     member: PlaceAndQualifiers<'db>,
     _count: u32,
@@ -474,7 +478,8 @@ fn class_lookup_cycle_recover<'db>(
     _policy: MemberLookupPolicy,
 ) -> PlaceAndQualifiers<'db> {
     let div = Type::divergent(id);
-    let place = join_with_previous_cycle_place(db, &previous_member.place, &member.place, div);
+    let place =
+        join_with_previous_cycle_place(db, &previous_member.place, &member.place, div, cycle_heads);
     PlaceAndQualifiers {
         place,
         qualifiers: member.qualifiers,
@@ -920,9 +925,18 @@ impl<'db> Type<'db> {
         matches!(self, Type::Callable(..))
     }
 
-    pub(crate) fn cycle_normalized(self, db: &'db dyn Db, previous: Self, div: Self) -> Self {
-        UnionType::from_elements_cycle_recovery(db, [self, previous])
-            .recursive_type_normalized(db, div)
+    pub(crate) fn cycle_normalized(
+        self,
+        db: &'db dyn Db,
+        previous: Self,
+        div: Self,
+        cycle_heads: &salsa::CycleHeads,
+    ) -> Self {
+        let normalized = UnionType::from_elements_cycle_recovery(db, [self, previous])
+            .recursive_type_normalized(db, div);
+        cycle_heads.ids().fold(normalized, |ty, id| {
+            ty.recursive_type_normalized(db, Type::divergent(id))
+        })
     }
 
     fn is_none(&self, db: &'db dyn Db) -> bool {
@@ -7692,17 +7706,19 @@ fn is_redundant_with_cycle_initial<'db>(
     true
 }
 
+#[allow(clippy::too_many_arguments)]
 fn apply_specialization_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_value: &Type<'db>,
     value: Type<'db>,
     _count: u32,
     _self: Type<'db>,
     _specialization: Specialization<'db>,
 ) -> Type<'db> {
     let div = Type::divergent(id);
-    value.cycle_normalized(db, *previous_value, div)
+    value.cycle_normalized(db, *previous_value, div, cycle_heads)
 }
 
 fn apply_specialization_cycle_initial<'db>(
@@ -8909,14 +8925,15 @@ fn lazy_bound_or_constraints_cycle_initial<'db>(
 fn lazy_default_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_default: &Option<Type<'db>>,
     default: Option<Type<'db>>,
     _count: u32,
     _typevar: TypeVarInstance<'db>,
 ) -> Option<Type<'db>> {
     let div = Type::divergent(id);
     match (previous_default, default) {
-        (Some(prev), Some(default)) => Some(default.cycle_normalized(db, *prev, div)),
+        (Some(prev), Some(default)) => Some(default.cycle_normalized(db, *prev, div, cycle_heads)),
         (None, Some(default)) => Some(default.recursive_type_normalized(db, div)),
         (_, None) => None,
     }

crates/ty_python_semantic/src/types.rs

@@ -120,6 +120,7 @@ fn implicit_attribute_initial<'db>(
 fn implicit_attribute_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_member: &Member<'db>,
     member: Member<'db>,
     _count: u32,
@@ -128,8 +129,13 @@ fn implicit_attribute_cycle_recover<'db>(
     _target_method_decorator: MethodDecorator,
 ) -> Member<'db> {
     let div = Type::divergent(id);
-    let place =
-        join_with_previous_cycle_place(db, &previous_member.inner.place, &member.inner.place, div);
+    let place = join_with_previous_cycle_place(
+        db,
+        &previous_member.inner.place,
+        &member.inner.place,
+        div,
+        cycle_heads,
+    );
     Member {
         inner: PlaceAndQualifiers {
             place,

crates/ty_python_semantic/src/types/class.rs

@@ -85,6 +85,7 @@ pub(crate) fn infer_scope_types<'db>(db: &'db dyn Db, scope: ScopeId<'db>) -> Sc
 fn scope_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_inference: &ScopeInference<'db>,
     mut inference: ScopeInference<'db>,
     _count: u32,
@@ -93,7 +94,7 @@ fn scope_cycle_recover<'db>(
     let div = Type::divergent(id);
     for (expr, ty) in &mut inference.expressions {
         let previous_ty = previous_inference.expression_type(*expr);
-        *ty = ty.cycle_normalized(db, previous_ty, div);
+        *ty = ty.cycle_normalized(db, previous_ty, div, cycle_heads);
     }
 
     inference
@@ -134,32 +135,34 @@ pub(crate) fn infer_definition_types<'db>(
 fn definition_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_inference: &DefinitionInference<'db>,
     inference: DefinitionInference<'db>,
     _count: u32,
     _definition: Definition<'db>,
 ) -> DefinitionInference<'db> {
-    definition_cycle_recover_inner(db, id, previous_inference, inference)
+    definition_cycle_recover_inner(db, id, cycle_heads, previous_inference, inference)
 }
 
 fn definition_cycle_recover_inner<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_inference: &DefinitionInference<'db>,
     mut inference: DefinitionInference<'db>,
 ) -> DefinitionInference<'db> {
     let div = Type::divergent(id);
     for (expr, ty) in &mut inference.expressions {
         let previous_ty = previous_inference.expression_type(*expr);
-        *ty = ty.cycle_normalized(db, previous_ty, div);
+        *ty = ty.cycle_normalized(db, previous_ty, div, cycle_heads);
     }
     for (binding, binding_ty) in &mut inference.bindings {
         if let Some((_, previous_binding)) = previous_inference
             .bindings
             .iter()
             .find(|(previous_binding, _)| previous_binding == binding)
         {
-            *binding_ty = binding_ty.cycle_normalized(db, *previous_binding, div);
+            *binding_ty = binding_ty.cycle_normalized(db, *previous_binding, div, cycle_heads);
         } else {
             *binding_ty = binding_ty.recursive_type_normalized(db, div);
         }
@@ -171,7 +174,7 @@ fn definition_cycle_recover_inner<'db>(
             .find(|(previous_declaration, _)| previous_declaration == declaration)
         {
             *declaration_ty = declaration_ty.map_type(|decl_ty| {
-                decl_ty.cycle_normalized(db, previous_declaration.inner_type(), div)
+                decl_ty.cycle_normalized(db, previous_declaration.inner_type(), div, cycle_heads)
             });
         } else {
             *declaration_ty =
@@ -218,12 +221,13 @@ pub(crate) fn infer_deferred_types<'db>(
 fn deferred_cycle_recovery<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_inference: &DefinitionInference<'db>,
     inference: DefinitionInference<'db>,
     _count: u32,
     _definition: Definition<'db>,
 ) -> DefinitionInference<'db> {
-    definition_cycle_recover_inner(db, id, previous_inference, inference)
+    definition_cycle_recover_inner(db, id, cycle_heads, previous_inference, inference)
 }
 
 fn deferred_cycle_initial<'db>(
@@ -298,6 +302,7 @@ pub(crate) fn infer_isolated_expression<'db>(
 fn expression_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_inference: &ExpressionInference<'db>,
     mut inference: ExpressionInference<'db>,
     _count: u32,
@@ -314,7 +319,7 @@ fn expression_cycle_recover<'db>(
                         .find(|(previous_binding, _)| previous_binding == binding)
                 })
             {
-                *binding_ty = binding_ty.cycle_normalized(db, *previous_binding, div);
+                *binding_ty = binding_ty.cycle_normalized(db, *previous_binding, div, cycle_heads);
             } else {
                 *binding_ty = binding_ty.recursive_type_normalized(db, div);
             }
@@ -323,7 +328,7 @@ fn expression_cycle_recover<'db>(
 
     for (expr, ty) in &mut inference.expressions {
         let previous_ty = previous_inference.expression_type(*expr);
-        *ty = ty.cycle_normalized(db, previous_ty, div);
+        *ty = ty.cycle_normalized(db, previous_ty, div, cycle_heads);
     }
 
     inference
@@ -382,13 +387,14 @@ fn infer_expression_type_impl<'db>(db: &'db dyn Db, input: InferExpression<'db>)
 fn single_expression_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_cycle_value: &Type<'db>,
     result: Type<'db>,
     _count: u32,
     _input: InferExpression<'db>,
 ) -> Type<'db> {
     let div = Type::divergent(id);
-    result.cycle_normalized(db, *previous_cycle_value, div)
+    result.cycle_normalized(db, *previous_cycle_value, div, cycle_heads)
 }
 
 fn single_expression_cycle_initial<'db>(
@@ -540,6 +546,7 @@ fn unpack_cycle_initial<'db>(
 fn unpack_cycle_recover<'db>(
     db: &'db dyn Db,
     id: salsa::Id,
+    cycle_heads: &salsa::CycleHeads,
     previous_cycle_result: &UnpackResult<'db>,
     mut result: UnpackResult<'db>,
     _count: u32,
@@ -548,7 +555,7 @@ fn unpack_cycle_recover<'db>(
     let div = Type::divergent(id);
     for (expr, ty) in &mut result.targets {
         let previous_ty = previous_cycle_result.expression_type(*expr);
-        *ty = ty.cycle_normalized(db, previous_ty, div);
+        *ty = ty.cycle_normalized(db, previous_ty, div, cycle_heads);
     }
 
     result

crates/ty_python_semantic/src/types/infer.rs

@@ -30,7 +30,7 @@ ty_python_semantic = { path = "../crates/ty_python_semantic" }
 ty_vendored = { path = "../crates/ty_vendored" }
 
 libfuzzer-sys = { git = "https://github.com/rust-fuzz/libfuzzer", default-features = false }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "05a9af7f554b64b8aadc2eeb6f2caf73d0408d09", default-features = false, features = [
+salsa = { git = "https://github.com/mtshiba/salsa.git", rev = "11f2ec8629e46b391c41aef5d770de92760a4f01", default-features = false, features = [
     "compact_str",
     "macros",
     "salsa_unstable",