rustdoc: fix delegated impl signatures

Author: cijiugechu

src/librustdoc/clean/mod.rs

@@ -1089,7 +1089,13 @@ fn clean_fn_or_proc_macro<'tcx>(
     match macro_kind {
         Some(kind) => clean_proc_macro(item, name, kind, cx.tcx),
         None => {
-            let mut func = clean_function(cx, sig, generics, ParamsSrc::Body(body_id));
+            let mut func = clean_function(
+                cx,
+                item.owner_id.to_def_id(),
+                sig,
+                generics,
+                ParamsSrc::Body(body_id),
+            );
             clean_fn_decl_legacy_const_generics(&mut func, attrs);
             FunctionItem(func)
         }
@@ -1124,10 +1130,15 @@ enum ParamsSrc<'tcx> {
 
 fn clean_function<'tcx>(
     cx: &mut DocContext<'tcx>,
+    def_id: DefId,
     sig: &hir::FnSig<'tcx>,
     generics: &hir::Generics<'tcx>,
     params: ParamsSrc<'tcx>,
 ) -> Box<Function> {
+    if sig.decl.opt_delegation_sig_id().is_some() {
+        return enter_impl_trait(cx, |cx| inline::build_function(cx, def_id));
+    }
+
     let (generics, decl) = enter_impl_trait(cx, |cx| {
         // NOTE: Generics must be cleaned before params.
         let generics = clean_generics(generics, cx);
@@ -1270,11 +1281,18 @@ fn clean_trait_item<'tcx>(trait_item: &hir::TraitItem<'tcx>, cx: &mut DocContext
                 RequiredAssocConstItem(generics, Box::new(clean_ty(ty, cx)))
             }
             hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
-                let m = clean_function(cx, sig, trait_item.generics, ParamsSrc::Body(body));
+                let m =
+                    clean_function(cx, local_did, sig, trait_item.generics, ParamsSrc::Body(body));
                 MethodItem(m, Defaultness::from_trait_item(trait_item.defaultness))
             }
             hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(idents)) => {
-                let m = clean_function(cx, sig, trait_item.generics, ParamsSrc::Idents(idents));
+                let m = clean_function(
+                    cx,
+                    local_did,
+                    sig,
+                    trait_item.generics,
+                    ParamsSrc::Idents(idents),
+                );
                 RequiredMethodItem(m, Defaultness::from_trait_item(trait_item.defaultness))
             }
             hir::TraitItemKind::Type(bounds, Some(default)) => {
@@ -1315,7 +1333,7 @@ pub(crate) fn clean_impl_item<'tcx>(
                 type_: clean_ty(ty, cx),
             })),
             hir::ImplItemKind::Fn(ref sig, body) => {
-                let m = clean_function(cx, sig, impl_.generics, ParamsSrc::Body(body));
+                let m = clean_function(cx, local_did, sig, impl_.generics, ParamsSrc::Body(body));
                 let defaultness = match impl_.impl_kind {
                     hir::ImplItemImplKind::Inherent { .. } => hir::Defaultness::Final,
                     hir::ImplItemImplKind::Trait { defaultness, .. } => defaultness,
@@ -3259,7 +3277,7 @@ fn clean_maybe_renamed_foreign_item<'tcx>(
     cx.with_param_env(def_id, |cx| {
         let kind = match item.kind {
             hir::ForeignItemKind::Fn(sig, idents, generics) => ForeignFunctionItem(
-                clean_function(cx, &sig, generics, ParamsSrc::Idents(idents)),
+                clean_function(cx, def_id, &sig, generics, ParamsSrc::Idents(idents)),
                 sig.header.safety(),
             ),
             hir::ForeignItemKind::Static(ty, mutability, safety) => ForeignStaticItem(

src/librustdoc/clean/simplify.rs

@@ -136,20 +136,25 @@ pub(crate) fn sized_bounds(cx: &mut DocContext<'_>, generics: &mut clean::Generi
     // Note that associated types also have an implicit `Sized` bound but we
     // don't actually know the set of associated types right here so that
     // should be handled when cleaning associated types.
-    generics.where_predicates.retain(|pred| {
-        let WP::BoundPredicate { ty: clean::Generic(param), bounds, .. } = pred else {
+    generics.where_predicates.retain_mut(|pred| {
+        let WP::BoundPredicate { ty, bounds, .. } = pred else {
             return true;
         };
 
+        // FIXME(sized-hierarchy): Always skip `MetaSized` bounds so that only `?Sized`
+        // is shown and none of the new sizedness traits leak into documentation.
+        bounds.retain(|b| !b.is_meta_sized_bound(cx.tcx));
+
+        let clean::Generic(param) = ty else {
+            return !bounds.is_empty();
+        };
+
         if bounds.iter().any(|b| b.is_sized_bound(cx.tcx)) {
             sized_params.insert(*param);
-            false
-        } else if bounds.iter().any(|b| b.is_meta_sized_bound(cx.tcx)) {
-            // FIXME(sized-hierarchy): Always skip `MetaSized` bounds so that only `?Sized`
-            // is shown and none of the new sizedness traits leak into documentation.
-            false
+            bounds.retain(|b| !b.is_sized_bound(cx.tcx));
+            !bounds.is_empty()
         } else {
-            true
+            !bounds.is_empty()
         }
     });
 

tests/rustdoc-html/auxiliary/fn-delegation-impl-trait-aux.rs

@@ -0,0 +1,8 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+pub fn external(_: impl FnOnce()) {}
+
+fn delegated_to(_: impl FnOnce()) {}
+
+pub reuse delegated_to as delegated;

tests/rustdoc-html/fn-delegation-impl-trait.rs

@@ -0,0 +1,48 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/155728>
+// Make sure delegating functions with `impl Trait` in argument position works correctly.
+//@ aux-crate:fn_delegation_impl_trait_aux=fn-delegation-impl-trait-aux.rs
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+extern crate fn_delegation_impl_trait_aux as aux;
+
+fn foo(_: impl FnOnce()) {}
+
+//@ has fn_delegation_impl_trait/fn.top_level.html '//pre[@class="rust item-decl"]' 'pub fn top_level(arg0: impl FnOnce())'
+pub reuse foo as top_level;
+
+pub struct S;
+
+//@ has fn_delegation_impl_trait/struct.S.html '//*[@id="method.method"]' 'pub fn method(arg0: impl FnOnce())'
+impl S {
+    pub reuse foo as method;
+}
+
+pub trait A {
+    fn f(&self, _: impl FnOnce()) {}
+}
+
+impl A for S {}
+
+//@ has fn_delegation_impl_trait/struct.S.html '//*[@id="method.f"]' 'pub fn f(self: &S, arg1: impl FnOnce())'
+//@ !has fn_delegation_impl_trait/struct.S.html '//*[@id="method.f"]' 'MetaSized'
+impl S {
+    pub reuse <S as A>::f;
+}
+
+//@ has fn_delegation_impl_trait/trait.T.html '//*[@id="method.provided"]' 'fn provided(arg0: impl FnOnce())'
+pub trait T {
+    reuse foo as provided;
+}
+
+//@ has fn_delegation_impl_trait/fn.cross_crate.html '//pre[@class="rust item-decl"]' 'pub fn cross_crate(arg0: impl FnOnce())'
+pub reuse aux::external as cross_crate;
+
+//@ has fn_delegation_impl_trait/fn.inlined_cross_crate_delegated.html '//pre[@class="rust item-decl"]' 'pub fn inlined_cross_crate_delegated(arg0: impl FnOnce())'
+#[doc(inline)]
+pub use aux::delegated as inlined_cross_crate_delegated;
+
+//@ has fn_delegation_impl_trait/fn.redelegated_cross_crate.html '//pre[@class="rust item-decl"]' 'pub fn redelegated_cross_crate(arg0: impl FnOnce())'
+pub reuse aux::delegated as redelegated_cross_crate;
+
+pub fn main() {}