rustdoc: assoc const bounds from supertraits

When documenting code with associated const equality bounds where
the const is defined in a supertrait, `rustdoc` would panic
with "called `Option::unwrap()` on a `None` value" because it
only searched for the associated item in the immediate trait.

This can be fixed by adding a recursive helper function that
searched through the traits supertrait hierarchy to find the
associated item.

Author: cachebag

src/librustdoc/clean/mod.rs

@@ -3147,6 +3147,31 @@ fn clean_maybe_renamed_foreign_item<'tcx>(
     })
 }
 
+fn find_assoc_item_in_trait<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    trait_did: DefId,
+    ident: Ident,
+    assoc_tag: ty::AssocTag,
+) -> Option<DefId> {
+    if let Some(item) =
+        tcx.associated_items(trait_did).find_by_ident_and_kind(tcx, ident, assoc_tag, trait_did)
+    {
+        return Some(item.def_id);
+    }
+
+    for (pred, _) in tcx.explicit_super_predicates_of(trait_did).iter_identity_copied() {
+        if let Some(trait_ref) = pred.as_trait_clause() {
+            if let Some(def_id) =
+                find_assoc_item_in_trait(tcx, trait_ref.def_id(), ident, assoc_tag)
+            {
+                return Some(def_id);
+            }
+        }
+    }
+
+    None
+}
+
 fn clean_assoc_item_constraint<'tcx>(
     trait_did: DefId,
     constraint: &hir::AssocItemConstraint<'tcx>,
@@ -3163,11 +3188,8 @@ fn clean_assoc_item_constraint<'tcx>(
                     hir::Term::Ty(_) => ty::AssocTag::Type,
                     hir::Term::Const(_) => ty::AssocTag::Const,
                 };
-                let assoc_item = cx
-                    .tcx
-                    .associated_items(trait_did)
-                    .find_by_ident_and_kind(cx.tcx, constraint.ident, assoc_tag, trait_did)
-                    .map(|item| item.def_id);
+                let assoc_item =
+                    find_assoc_item_in_trait(cx.tcx, trait_did, constraint.ident, assoc_tag);
                 AssocItemConstraintKind::Equality { term: clean_hir_term(assoc_item, term, cx) }
             }
             hir::AssocItemConstraintKind::Bound { bounds } => AssocItemConstraintKind::Bound {

tests/rustdoc-ui/assoc-const-bounds-supertrait.rs

@@ -0,0 +1,25 @@
+// Regression test for issue #151511.
+// Ensure that rustdoc doesn't ICE when encountering assoc const eq bounds
+// where the assoc const comes from a supertrait.
+
+#![feature(
+    min_generic_const_args,
+    adt_const_params,
+    unsized_const_params,
+    generic_const_parameter_types
+)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+trait Trait: SuperTrait {}
+trait SuperTrait: SuperSuperTrait<i32> {}
+trait SuperSuperTrait<T: ConstParamTy_> {
+    #[type_const]
+    const K: T;
+}
+
+fn take(_: impl Trait<K = 0>) {}
+//~^ ERROR anonymous constants referencing generics are not yet supported
+
+fn main() {}

tests/rustdoc-ui/assoc-const-bounds-supertrait.stderr

@@ -0,0 +1,8 @@
+error: anonymous constants referencing generics are not yet supported
+  --> $DIR/assoc-const-bounds-supertrait.rs:17:27
+   |
+LL | fn take(_: impl Trait<K = 0>) {}
+   |                           ^
+
+error: aborting due to 1 previous error
+