fix: Infinite loop while elaborting predicates

Author: ShoyuVanilla

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]

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() {

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])],
     );
 }
 

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

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()))

crates/hir-ty/src/tests/incremental.rs

@@ -589,7 +589,7 @@ fn main() {
                 "attrs_shim",
                 "attrs_shim",
                 "return_type_impl_traits_shim",
-                "generic_predicates_ns_shim",
+                "explicit_implied_predicates_of_shim",
                 "infer_shim",
                 "function_signature_shim",
                 "function_signature_with_source_map_shim",
@@ -689,7 +689,7 @@ fn main() {
                 "attrs_shim",
                 "attrs_shim",
                 "return_type_impl_traits_shim",
-                "generic_predicates_ns_shim",
+                "explicit_implied_predicates_of_shim",
                 "infer_shim",
                 "function_signature_with_source_map_shim",
                 "expr_scopes_shim",

crates/hir-ty/src/tests/regression/new_solver.rs

@@ -116,3 +116,34 @@ fn main() {
         "#]],
     );
 }
+
+#[test]
+fn no_infinite_loop_on_super_predicates_elaboration() {
+    check_infer(
+        r#"
+//- minicore: sized
+trait DimMax<Other: Dimension> {
+    type Output: Dimension;
+}
+
+trait Dimension: DimMax<<Self as Dimension>:: Smaller, Output = Self> {
+    type Smaller: Dimension;
+}
+
+fn test<T, U>(t: T)
+where
+    T: DimMax<U>,
+    U: Dimension,
+{
+    let t: <T as DimMax<U>>::Output = loop {};
+}
+"#,
+        expect![[r#"
+            182..183 't': T
+            230..280 '{     ... {}; }': ()
+            240..241 't': <T as DimMax<U>>::Output
+            270..277 'loop {}': !
+            275..277 '{}': ()
+        "#]],
+    )
+}