From 2a67e2e323d8b559f153f0cc95cb79ac2a60d5de Mon Sep 17 00:00:00 2001 From: LeSeulArtichaut Date: Sat, 6 Feb 2021 16:38:14 +0100 Subject: [PATCH 1/3] Revert "Get rid of custom pretty-printing in rustdoc" This reverts commit 31375d2074aeed0c6f173aa200f0bd3bf6d36756. --- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/clean/utils.rs | 70 +++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 331bb2a73f962..4d0d7e75aec62 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -961,7 +961,7 @@ impl<'a> Clean for (&'a [hir::Ty<'a>], hir::BodyId) { .iter() .enumerate() .map(|(i, ty)| Argument { - name: Symbol::intern(&rustc_hir_pretty::param_to_string(&body.params[i])), + name: name_from_pat(&body.params[i].pat), type_: ty.clean(cx), }) .collect(), diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 2c829c49953ff..ef59e13f8fb17 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -195,6 +195,25 @@ crate fn strip_path(path: &Path) -> Path { Path { global: path.global, res: path.res, segments } } +crate fn qpath_to_string(p: &hir::QPath<'_>) -> String { + let segments = match *p { + hir::QPath::Resolved(_, ref path) => &path.segments, + hir::QPath::TypeRelative(_, ref segment) => return segment.ident.to_string(), + hir::QPath::LangItem(lang_item, ..) => return lang_item.name().to_string(), + }; + + let mut s = String::new(); + for (i, seg) in segments.iter().enumerate() { + if i > 0 { + s.push_str("::"); + } + if seg.ident.name != kw::PathRoot { + s.push_str(&seg.ident.as_str()); + } + } + s +} + crate fn build_deref_target_impls(cx: &DocContext<'_>, items: &[Item], ret: &mut Vec) { let tcx = cx.tcx; @@ -232,6 +251,57 @@ impl ToSource for rustc_span::Span { } } +crate fn name_from_pat(p: &hir::Pat<'_>) -> Symbol { + use rustc_hir::*; + debug!("trying to get a name from pattern: {:?}", p); + + Symbol::intern(&match p.kind { + PatKind::Wild => return kw::Underscore, + PatKind::Binding(_, _, ident, _) => return ident.name, + PatKind::TupleStruct(ref p, ..) | PatKind::Path(ref p) => qpath_to_string(p), + PatKind::Struct(ref name, ref fields, etc) => format!( + "{} {{ {}{} }}", + qpath_to_string(name), + fields + .iter() + .map(|fp| format!("{}: {}", fp.ident, name_from_pat(&fp.pat))) + .collect::>() + .join(", "), + if etc { ", .." } else { "" } + ), + PatKind::Or(ref pats) => pats + .iter() + .map(|p| name_from_pat(&**p).to_string()) + .collect::>() + .join(" | "), + PatKind::Tuple(ref elts, _) => format!( + "({})", + elts.iter() + .map(|p| name_from_pat(&**p).to_string()) + .collect::>() + .join(", ") + ), + PatKind::Box(ref p) => return name_from_pat(&**p), + PatKind::Ref(ref p, _) => return name_from_pat(&**p), + PatKind::Lit(..) => { + warn!( + "tried to get argument name from PatKind::Lit, which is silly in function arguments" + ); + return Symbol::intern("()"); + } + PatKind::Range(..) => panic!( + "tried to get argument name from PatKind::Range, \ + which is not allowed in function arguments" + ), + PatKind::Slice(ref begin, ref mid, ref end) => { + let begin = begin.iter().map(|p| name_from_pat(&**p).to_string()); + let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter(); + let end = end.iter().map(|p| name_from_pat(&**p).to_string()); + format!("[{}]", begin.chain(mid).chain(end).collect::>().join(", ")) + } + }) +} + crate fn print_const(cx: &DocContext<'_>, n: &'tcx ty::Const<'_>) -> String { match n.val { ty::ConstKind::Unevaluated(def, _, promoted) => { From 793e88ad168a7ca63e9cd95faf8e7833fb5c341b Mon Sep 17 00:00:00 2001 From: LeSeulArtichaut Date: Sat, 6 Feb 2021 16:40:30 +0100 Subject: [PATCH 2/3] Add regression test for #81289 --- src/test/rustdoc/mut-params.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 src/test/rustdoc/mut-params.rs diff --git a/src/test/rustdoc/mut-params.rs b/src/test/rustdoc/mut-params.rs new file mode 100644 index 0000000000000..1ef7e304fa256 --- /dev/null +++ b/src/test/rustdoc/mut-params.rs @@ -0,0 +1,18 @@ +// Rustdoc shouldn't display `mut` in function arguments, which are +// implementation details. Regression test for #81289. + +#![crate_name = "foo"] + +pub struct Foo; + +// @count foo/struct.Foo.html '//*[@class="impl-items"]//*[@class="method"]' 2 +// @!has - '//*[@class="impl-items"]//*[@class="method"]' 'mut' +impl Foo { + pub fn foo(mut self) {} + + pub fn bar(mut bar: ()) {} +} + +// @count foo/fn.baz.html '//*[@class="rust fn"]' 1 +// @!has - '//*[@class="rust fn"]' 'mut' +pub fn baz(mut foo: Foo) {} From 089ee27dd0ef2a639647cddecb2ea332c8d02bac Mon Sep 17 00:00:00 2001 From: LeSeulArtichaut Date: Tue, 9 Feb 2021 00:20:44 +0100 Subject: [PATCH 3/3] Do not ICE on range patterns in function arguments --- src/librustdoc/clean/utils.rs | 5 +---- src/test/rustdoc/range-arg-pattern.rs | 2 +- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index ef59e13f8fb17..5b82954536cdd 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -289,10 +289,7 @@ crate fn name_from_pat(p: &hir::Pat<'_>) -> Symbol { ); return Symbol::intern("()"); } - PatKind::Range(..) => panic!( - "tried to get argument name from PatKind::Range, \ - which is not allowed in function arguments" - ), + PatKind::Range(..) => return kw::Underscore, PatKind::Slice(ref begin, ref mid, ref end) => { let begin = begin.iter().map(|p| name_from_pat(&**p).to_string()); let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter(); diff --git a/src/test/rustdoc/range-arg-pattern.rs b/src/test/rustdoc/range-arg-pattern.rs index f4cc36b1055ad..c08faaad0eccf 100644 --- a/src/test/rustdoc/range-arg-pattern.rs +++ b/src/test/rustdoc/range-arg-pattern.rs @@ -1,5 +1,5 @@ #![crate_name = "foo"] // @has foo/fn.f.html -// @has - '//*[@class="rust fn"]' 'pub fn f(0u8 ...255: u8)' +// @has - '//*[@class="rust fn"]' 'pub fn f(_: u8)' pub fn f(0u8...255: u8) {}