Fix lowering with supertrait predicates

Previously both valid and invalid Rust code could crash r-a due to a
cyclic query during lowering.

Author: Wilfred

crates/hir-def/src/hir/generics.rs

@@ -184,7 +184,7 @@ static EMPTY: LazyLock<Arc<GenericParams>> = LazyLock::new(|| {
 
 impl GenericParams {
     /// The index of the self param in the generic of the non-parent definition.
-    pub(crate) const SELF_PARAM_ID_IN_SELF: la_arena::Idx<TypeOrConstParamData> =
+    pub const SELF_PARAM_ID_IN_SELF: la_arena::Idx<TypeOrConstParamData> =
         LocalTypeOrConstParamId::from_raw(RawIdx::from_u32(0));
 
     pub fn new(db: &dyn DefDatabase, def: GenericDefId) -> Arc<GenericParams> {

crates/hir-ty/src/lower.rs

@@ -20,7 +20,8 @@ use hir_def::{
     builtin_type::BuiltinType,
     expr_store::{ExpressionStore, HygieneId, path::Path},
     hir::generics::{
-        GenericParamDataRef, TypeOrConstParamData, TypeParamProvenance, WherePredicate,
+        GenericParamDataRef, GenericParams, TypeOrConstParamData, TypeParamProvenance,
+        WherePredicate,
     },
     item_tree::FieldsShape,
     lang_item::LangItems,
@@ -1637,11 +1638,7 @@ pub(crate) fn generic_predicates_for_param<'db>(
                         return false;
                     };
 
-                    rustc_type_ir::elaborate::supertrait_def_ids(interner, tr.into()).any(|tr| {
-                        tr.0.trait_items(db).items.iter().any(|(name, item)| {
-                            matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name
-                        })
-                    })
+                    trait_or_supertrait_has_assoc_type(db, tr, assoc_name)
                 }
                 TypeBound::Use(_) | TypeBound::Lifetime(_) | TypeBound::Error => false,
             }
@@ -1691,6 +1688,50 @@ pub(crate) fn generic_predicates_for_param_cycle_result(
     StoredEarlyBinder::bind(Clauses::empty(DbInterner::new_no_crate(db)).store())
 }
 
+/// Check if a trait or any of its supertraits define an associated
+/// type with the given name.
+fn trait_or_supertrait_has_assoc_type(
+    db: &dyn HirDatabase,
+    tr: TraitId,
+    assoc_name: &Name,
+) -> bool {
+    let mut visited = FxHashSet::default();
+    let mut stack = vec![tr];
+
+    // Associated traits can form a cycle, so handle that case
+    // defensively.
+    while let Some(trait_id) = stack.pop() {
+        if !visited.insert(trait_id) {
+            continue;
+        }
+
+        // Check if this trait has the associated type.
+        if trait_id
+            .trait_items(db)
+            .items
+            .iter()
+            .any(|(name, item)| matches!(item, AssocItemId::TypeAliasId(_)) && name == assoc_name)
+        {
+            return true;
+        }
+
+        let self_param_id = TypeOrConstParamId {
+            parent: trait_id.into(),
+            local_id: GenericParams::SELF_PARAM_ID_IN_SELF,
+        };
+
+        // Walk supertraits.
+        let predicates = generic_predicates_for_param(db, trait_id.into(), self_param_id, None);
+        for pred in predicates.get().iter_identity() {
+            if let rustc_type_ir::ClauseKind::Trait(trait_pred) = pred.kind().skip_binder() {
+                stack.push(trait_pred.trait_ref.def_id.0);
+            }
+        }
+    }
+
+    false
+}
+
 #[inline]
 pub(crate) fn type_alias_bounds<'db>(
     db: &'db dyn HirDatabase,

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

@@ -2563,3 +2563,43 @@ fn main() {
         "#,
     );
 }
+
+#[test]
+fn issue_21006_generic_predicates_for_param_supertrait_cycle() {
+    check_no_mismatches(
+        r#"
+trait VCipherSuite {}
+
+trait CipherSuite
+where
+    OprfHash<Self>: Hash,
+{
+}
+
+type Bar<CS: CipherSuite> = <CS::Baz as VCipherSuite>::Hash;
+
+type OprfHash<CS: CipherSuite> = <CS::Baz as VCipherSuite>::Hash;
+
+impl<CS: CipherSuite> Foo<CS> {
+    fn seal() {}
+}
+        "#,
+    );
+}
+
+#[test]
+fn issue_21006_self_assoc_trait() {
+    check_no_mismatches(
+        r#"
+trait Foo {
+    type Assoc;
+}
+
+trait Bar: Foo
+where
+    Self::Assoc: Send,
+{
+}
+        "#,
+    );
+}