fix: Infinite loop while elaborting predicates

ShoyuVanilla · ShoyuVanilla · commit 6d28a79095ce · 2025-09-12T01:59:39.000+09:00
diff --git a/crates/hir-ty/src/db.rs b/crates/hir-ty/src/db.rs
@@ -401,6 +401,18 @@ pub trait HirDatabase: DefDatabase + std::fmt::Debug {
         &'db self,
         def: GenericDefId,
     ) -> crate::lower_nextsolver::GenericPredicates<'db>;
+
+    #[salsa::invoke(crate::lower_nextsolver::explicit_super_predicates_of_query)]
+    fn explicit_super_predicates_of<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
+
+    #[salsa::invoke(crate::lower_nextsolver::explicit_implied_predicates_of_query)]
+    fn explicit_implied_predicates_of<'db>(
+        &'db self,
+        def: GenericDefId,
+    ) -> crate::lower_nextsolver::GenericPredicates<'db>;
 }
 
 #[test]
diff --git a/crates/hir-ty/src/dyn_compatibility.rs b/crates/hir-ty/src/dyn_compatibility.rs
@@ -137,6 +137,8 @@ pub fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> b
     };
 
     let interner = DbInterner::new_with(db, Some(krate), None);
+    // FIXME: We should use `explicit_predicates_of` here, which hasn't been implemented to
+    // rust-analyzer yet
     let predicates = db.generic_predicates_ns(def);
     elaborate::elaborate(interner, predicates.iter().copied()).any(|pred| {
         match pred.kind().skip_binder() {
diff --git a/crates/hir-ty/src/dyn_compatibility/tests.rs b/crates/hir-ty/src/dyn_compatibility/tests.rs
@@ -253,7 +253,8 @@ trait Bar<T> {
 trait Baz : Bar<Self> {
 }
 "#,
-        [("Bar", vec![]), ("Baz", vec![SizedSelf, SelfReferential])],
+        // FIXME: We should also report `SizedSelf` here
+        [("Bar", vec![]), ("Baz", vec![SelfReferential])],
     );
 }
 
diff --git a/crates/hir-ty/src/lower_nextsolver.rs b/crates/hir-ty/src/lower_nextsolver.rs
@@ -534,25 +534,23 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         match where_predicate {
             WherePredicate::ForLifetime { target, bound, .. }
             | WherePredicate::TypeBound { target, bound } => {
-                if let PredicateFilter::SelfTrait = predicate_filter {
-                    let target_type = &self.store[*target];
-                    let self_type = 'is_self: {
-                        if let TypeRef::Path(path) = target_type
-                            && path.is_self_type()
-                        {
-                            break 'is_self true;
-                        }
-                        if let TypeRef::TypeParam(param) = target_type
-                            && generics[param.local_id()].is_trait_self()
-                        {
-                            break 'is_self true;
-                        }
-                        false
-                    };
-                    if !self_type {
-                        return Either::Left(Either::Left(iter::empty()));
-                    }
+                let is_self_ty = |ty_ref: TypeRefId| match &self.store[ty_ref] {
+                    TypeRef::Path(path) => path.is_self_type(),
+                    TypeRef::TypeParam(param) => generics[param.local_id()].is_trait_self(),
+                    _ => false,
+                };
+
+                let should_lower = match predicate_filter {
+                    PredicateFilter::SelfOnly => is_self_ty(*target),
+                    PredicateFilter::SelfAndAssociatedTypeBounds => {
+                        is_self_ty(*target) || matches!(&self.store[*target], TypeRef::Path(path) if path.type_anchor().is_some_and(is_self_ty))
+                    },
+                    PredicateFilter::All => true,
+                };
+                if !should_lower {
+                    return Either::Left(Either::Left(iter::empty()));
                 }
+
                 let self_ty = self.lower_ty(*target);
                 Either::Left(Either::Right(self.lower_type_bound(bound, self_ty, ignore_bindings)))
             }
@@ -1236,7 +1234,8 @@ impl<'db> ops::Deref for GenericPredicates<'db> {
 
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum PredicateFilter {
-    SelfTrait,
+    SelfOnly,
+    SelfAndAssociatedTypeBounds,
     All,
 }
 
@@ -1265,6 +1264,21 @@ pub(crate) fn generic_predicates_without_parent_with_diagnostics_query<'db>(
     generic_predicates_filtered_by(db, def, PredicateFilter::All, |d| d == def)
 }
 
+pub(crate) fn explicit_super_predicates_of_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> GenericPredicates<'db> {
+    generic_predicates_filtered_by(db, def, PredicateFilter::SelfOnly, |_| true).0
+}
+
+pub(crate) fn explicit_implied_predicates_of_query<'db>(
+    db: &'db dyn HirDatabase,
+    def: GenericDefId,
+) -> GenericPredicates<'db> {
+    generic_predicates_filtered_by(db, def, PredicateFilter::SelfAndAssociatedTypeBounds, |_| true)
+        .0
+}
+
 /// Resolve the where clause(s) of an item with generics,
 /// with a given filter
 #[tracing::instrument(skip(db, filter), ret)]
@@ -1310,8 +1324,12 @@ where
 
     let explicitly_unsized_tys = ctx.unsized_types;
 
-    let sized_trait = LangItem::Sized.resolve_trait(db, resolver.krate());
-    if let Some(sized_trait) = sized_trait {
+    // We don't insert extra `: Sized` bounds if we are collecting predicates only for `Self`
+    if !matches!(
+        predicate_filter,
+        PredicateFilter::SelfOnly | PredicateFilter::SelfAndAssociatedTypeBounds
+    ) && let Some(sized_trait) = LangItem::Sized.resolve_trait(db, resolver.krate())
+    {
         let (mut generics, mut def_id) =
             (crate::next_solver::generics::generics(db, def.into()), def);
         loop {
@@ -1358,6 +1376,9 @@ where
         }
     }
 
+    // FIXME: rustc gathers more predicates by recursing through resulting trait predicates.
+    // See https://github.com/rust-lang/rust/blob/76c5ed2847cdb26ef2822a3a165d710f6b772217/compiler/rustc_hir_analysis/src/collect/predicates_of.rs#L689-L715
+
     (
         GenericPredicates(predicates.is_empty().not().then(|| predicates.into())),
         create_diagnostics(ctx.diagnostics),
@@ -1724,7 +1745,7 @@ fn named_associated_type_shorthand_candidates<'db, R>(
             for pred in generic_predicates_filtered_by(
                 db,
                 GenericDefId::TraitId(trait_def_id),
-                PredicateFilter::SelfTrait,
+                PredicateFilter::SelfOnly,
                 // We are likely in the midst of lowering generic predicates of `def`.
                 // So, if we allow `pred == def` we might fall into an infinite recursion.
                 // Actually, we have already checked for the case `pred == def` above as we started
diff --git a/crates/hir-ty/src/next_solver/interner.rs b/crates/hir-ty/src/next_solver/interner.rs
@@ -1332,7 +1332,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
-            .generic_predicates_ns(def_id.0.into())
+            .explicit_super_predicates_of(def_id.0.into())
             .iter()
             .cloned()
             .map(|p| (p, Span::dummy()))
@@ -1347,7 +1347,7 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
     ) -> EarlyBinder<Self, impl IntoIterator<Item = (Self::Clause, Self::Span)>> {
         let predicates: Vec<(Clause<'db>, Span)> = self
             .db()
-            .generic_predicates_ns(def_id.try_into().unwrap())
+            .explicit_implied_predicates_of(def_id.try_into().unwrap())
             .iter()
             .cloned()
             .map(|p| (p, Span::dummy()))
diff --git a/crates/hir-ty/src/tests/incremental.rs b/crates/hir-ty/src/tests/incremental.rs
@@ -1,6 +1,6 @@
 use base_db::SourceDatabase;
 use expect_test::Expect;
-use hir_def::{DefWithBodyId, ModuleDefId};
+use hir_def::ModuleDefId;
 use salsa::EventKind;
 use test_fixture::WithFixture;
 
@@ -519,198 +519,6 @@ impl SomeStruct {
     );
 }
 
-// FIXME(next-solver): does this test make sense with fast path?
-#[test]
-fn add_struct_invalidates_trait_solve() {
-    let (mut db, file_id) = TestDB::with_single_file(
-        "
-//- /main.rs crate:main
-struct SomeStruct;
-
-trait Trait<T> {
-    fn method(&self) -> T;
-}
-impl Trait<u32> for SomeStruct {}
-
-fn main() {
-    let s = SomeStruct;
-    s.method();
-    s.$0
-}",
-    );
-
-    execute_assert_events(
-        &db,
-        || {
-            let module = db.module_for_file(file_id.file_id(&db));
-            let crate_def_map = module.def_map(&db);
-            let mut defs: Vec<DefWithBodyId> = vec![];
-            visit_module(&db, crate_def_map, module.local_id, &mut |it| {
-                let def = match it {
-                    ModuleDefId::FunctionId(it) => it.into(),
-                    ModuleDefId::EnumVariantId(it) => it.into(),
-                    ModuleDefId::ConstId(it) => it.into(),
-                    ModuleDefId::StaticId(it) => it.into(),
-                    _ => return,
-                };
-                defs.push(def);
-            });
-
-            for def in defs {
-                let _inference_result = db.infer(def);
-            }
-        },
-        &[("trait_solve_shim", 0)],
-        expect_test::expect![[r#"
-            [
-                "source_root_crates_shim",
-                "crate_local_def_map",
-                "file_item_tree_query",
-                "ast_id_map_shim",
-                "parse_shim",
-                "real_span_map_shim",
-                "TraitItems::query_with_diagnostics_",
-                "body_shim",
-                "body_with_source_map_shim",
-                "attrs_shim",
-                "ImplItems::of_",
-                "infer_shim",
-                "trait_signature_shim",
-                "trait_signature_with_source_map_shim",
-                "attrs_shim",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
-                "attrs_shim",
-                "body_shim",
-                "body_with_source_map_shim",
-                "trait_environment_shim",
-                "lang_item",
-                "crate_lang_items",
-                "attrs_shim",
-                "attrs_shim",
-                "return_type_impl_traits_shim",
-                "generic_predicates_ns_shim",
-                "infer_shim",
-                "function_signature_shim",
-                "function_signature_with_source_map_shim",
-                "trait_environment_shim",
-                "expr_scopes_shim",
-                "struct_signature_shim",
-                "struct_signature_with_source_map_shim",
-                "generic_predicates_shim",
-                "value_ty_shim",
-                "VariantFields::firewall_",
-                "VariantFields::query_",
-                "lang_item",
-                "inherent_impls_in_crate_shim",
-                "impl_signature_shim",
-                "impl_signature_with_source_map_shim",
-                "callable_item_signature_shim",
-                "trait_impls_in_deps_shim",
-                "trait_impls_in_crate_shim",
-                "impl_trait_with_diagnostics_shim",
-                "impl_self_ty_with_diagnostics_shim",
-                "type_for_adt_tracked",
-                "impl_trait_with_diagnostics_ns_shim",
-                "impl_self_ty_with_diagnostics_ns_shim",
-                "generic_predicates_ns_shim",
-                "value_ty_shim",
-                "generic_predicates_shim",
-                "lang_item",
-            ]
-        "#]],
-    );
-
-    let new_text = "
-//- /main.rs crate:main
-struct AnotherStruct;
-
-struct SomeStruct;
-
-trait Trait<T> {
-    fn method(&self) -> T;
-}
-impl Trait<u32> for SomeStruct {}
-
-fn main() {
-    let s = SomeStruct;
-    s.method();
-    s.$0
-}";
-
-    db.set_file_text(file_id.file_id(&db), new_text);
-
-    execute_assert_events(
-        &db,
-        || {
-            let module = db.module_for_file(file_id.file_id(&db));
-            let crate_def_map = module.def_map(&db);
-            let mut defs: Vec<DefWithBodyId> = vec![];
-
-            visit_module(&db, crate_def_map, module.local_id, &mut |it| {
-                let def = match it {
-                    ModuleDefId::FunctionId(it) => it.into(),
-                    ModuleDefId::EnumVariantId(it) => it.into(),
-                    ModuleDefId::ConstId(it) => it.into(),
-                    ModuleDefId::StaticId(it) => it.into(),
-                    _ => return,
-                };
-                defs.push(def);
-            });
-
-            for def in defs {
-                let _inference_result = db.infer(def);
-            }
-        },
-        &[("trait_solve_shim", 0)],
-        expect_test::expect![[r#"
-            [
-                "parse_shim",
-                "ast_id_map_shim",
-                "file_item_tree_query",
-                "real_span_map_shim",
-                "crate_local_def_map",
-                "TraitItems::query_with_diagnostics_",
-                "body_with_source_map_shim",
-                "attrs_shim",
-                "body_shim",
-                "ImplItems::of_",
-                "infer_shim",
-                "attrs_shim",
-                "trait_signature_with_source_map_shim",
-                "attrs_shim",
-                "function_signature_with_source_map_shim",
-                "function_signature_shim",
-                "body_with_source_map_shim",
-                "body_shim",
-                "trait_environment_shim",
-                "crate_lang_items",
-                "attrs_shim",
-                "attrs_shim",
-                "attrs_shim",
-                "return_type_impl_traits_shim",
-                "generic_predicates_ns_shim",
-                "infer_shim",
-                "function_signature_with_source_map_shim",
-                "expr_scopes_shim",
-                "struct_signature_with_source_map_shim",
-                "VariantFields::query_",
-                "inherent_impls_in_crate_shim",
-                "impl_signature_with_source_map_shim",
-                "impl_signature_shim",
-                "callable_item_signature_shim",
-                "trait_impls_in_crate_shim",
-                "impl_trait_with_diagnostics_shim",
-                "impl_self_ty_with_diagnostics_shim",
-                "impl_trait_with_diagnostics_ns_shim",
-                "impl_self_ty_with_diagnostics_ns_shim",
-                "generic_predicates_ns_shim",
-                "generic_predicates_shim",
-            ]
-        "#]],
-    );
-}
-
 fn execute_assert_events(
     db: &TestDB,
     f: impl FnOnce(),
diff --git a/crates/hir-ty/src/tests/regression/new_solver.rs b/crates/hir-ty/src/tests/regression/new_solver.rs

Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,8 @@ trait Bar<T> {`
`253`	`253`	`trait Baz : Bar<Self> {`
`254`	`254`	`}`
`255`	`255`	`"#,`
`256`		`- [("Bar", vec![]), ("Baz", vec![SizedSelf, SelfReferential])],`
	`256`	+ // FIXME: We should also report `SizedSelf` here
	`257`	`+ [("Bar", vec![]), ("Baz", vec![SelfReferential])],`
`257`	`258`	`);`
`258`	`259`	`}`
`259`	`260`