rustdoc: implement and use print_plain

Author: jsha

src/librustdoc/html/format.rs

@@ -1169,6 +1169,14 @@ impl clean::Type {
     ) -> impl fmt::Display + 'b + Captures<'tcx> {
         display_fn(move |f| fmt_type(self, f, false, cx))
     }
+
+    /// Emit this type in plain text form (no HTML).
+    pub(crate) fn print_plain<'b, 'a: 'b, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'b + Captures<'tcx> {
+        Plain(self.print(cx))
+    }
 }
 
 impl clean::Path {
@@ -1178,6 +1186,14 @@ impl clean::Path {
     ) -> impl fmt::Display + 'b + Captures<'tcx> {
         display_fn(move |f| resolved_path(f, self.def_id(), self, false, false, cx))
     }
+
+    /// Emit this type in plain text form (no HTML).
+    pub(crate) fn print_plain<'b, 'a: 'b, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'b + Captures<'tcx> {
+        Plain(self.print(cx))
+    }
 }
 
 impl clean::Impl {
@@ -1325,15 +1341,20 @@ impl clean::BareFunctionDecl {
 ///  - HTML attributes are quoted with double quotes.
 ///  - The only HTML entities used are `&lt;`, `&gt;`, `&amp;`, `&quot`, and `&#39;`
 #[derive(Debug, Clone)]
-struct HtmlRemover<W: fmt::Write> {
+pub(super) struct HtmlRemover<W: fmt::Write> {
     inner: W,
     state: HtmlTextCounterState,
 }
 
 impl<W: fmt::Write> HtmlRemover<W> {
-    fn new(w: W) -> Self {
+    pub(super) fn new(w: W) -> Self {
         HtmlRemover { inner: w, state: HtmlTextCounterState::Text }
     }
+
+    #[cfg(test)]
+    pub(super) fn into_inner(self) -> W {
+        self.inner
+    }
 }
 
 // A state machine that tracks our progress through the HTML.
@@ -1389,7 +1410,7 @@ impl<W: fmt::Write> fmt::Write for HtmlRemover<W> {
 }
 
 /// This generates the plain text form of a marked-up HTML input, using HtmlRemover.
-struct Plain<D: fmt::Display>(D);
+pub(super) struct Plain<D: fmt::Display>(pub(super) D);
 
 impl<D: fmt::Display> fmt::Display for Plain<D> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1801,37 +1822,3 @@ pub(crate) fn display_fn(
 
     WithFormatter(Cell::new(Some(f)))
 }
-
-#[test]
-fn test_html_remover() {
-    use std::fmt::Write;
-
-    fn assert_removed_eq(input: &str, output: &str) {
-        let mut remover = HtmlRemover::new(String::new());
-        write!(&mut remover, "{}", input).unwrap();
-        assert_eq!(&remover.inner, output);
-    }
-
-    assert_removed_eq("a<a href='https://example.com'>b", "ab");
-    assert_removed_eq("alpha &lt;bet&gt;", "alpha <bet>");
-    assert_removed_eq("<a href=\"&quot;\">", "");
-    assert_removed_eq("<tag>&gt;</tag>text&lt;<tag>", ">text<");
-
-    let mut remover = HtmlRemover::new(String::new());
-    assert!(write!(&mut remover, "&ent;").is_err());
-
-    let mut remover = HtmlRemover::new(String::new());
-    assert!(write!(&mut remover, "&entity").is_err());
-
-    let mut remover = HtmlRemover::new(String::new());
-    assert!(write!(&mut remover, "&&").is_err());
-
-    let mut remover = HtmlRemover::new(String::new());
-    assert!(write!(&mut remover, "<open <tag").is_err());
-}
-
-#[test]
-fn test_plain() {
-    let d = Plain::new("<strong>alpha</strong> &lt;bet&gt;");
-    assert_eq!(&d.to_string(), "alpha <bet>");
-}

src/librustdoc/html/render/mod.rs

@@ -1141,8 +1141,10 @@ fn render_assoc_items_inner(
                 (RenderMode::Normal, "implementations-list".to_owned())
             }
             AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => {
-                let id =
-                    cx.derive_id(small_url_encode(format!("deref-methods-{:#}", type_.print(cx))));
+                let id = cx.derive_id(small_url_encode(format!(
+                    "deref-methods-{}",
+                    type_.print_plain(cx)
+                )));
                 if let Some(def_id) = type_.def_id(cx.cache()) {
                     cx.deref_id_map.insert(def_id, id.clone());
                 }
@@ -1314,7 +1316,7 @@ pub(crate) fn notable_traits_button(ty: &clean::Type, cx: &mut Context<'_>) -> O
         cx.types_with_notable_traits.insert(ty.clone());
         Some(format!(
             " <a href=\"#\" class=\"tooltip\" data-notable-ty=\"{ty}\">ⓘ</a>",
-            ty = Escape(&format!("{:#}", ty.print(cx))),
+            ty = Escape(&ty.print_plain(cx).to_string()),
         ))
     } else {
         None
@@ -1379,7 +1381,7 @@ fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
         write!(&mut out, "</code></pre>",);
     }
 
-    (format!("{:#}", ty.print(cx)), out.into_inner())
+    (ty.print_plain(cx).to_string(), out.into_inner())
 }
 
 pub(crate) fn notable_traits_json<'a>(
@@ -1947,20 +1949,18 @@ pub(crate) fn small_url_encode(s: String) -> String {
 
 fn get_id_for_impl(for_: &clean::Type, trait_: Option<&clean::Path>, cx: &Context<'_>) -> String {
     match trait_ {
-        Some(t) => small_url_encode(format!("impl-{:#}-for-{:#}", t.print(cx), for_.print(cx))),
-        None => small_url_encode(format!("impl-{:#}", for_.print(cx))),
+        Some(t) => {
+            small_url_encode(format!("impl-{}-for-{}", t.print_plain(cx), for_.print_plain(cx)))
+        }
+        None => small_url_encode(format!("impl-{}", for_.print_plain(cx))),
     }
 }
 
 fn extract_for_impl_name(item: &clean::Item, cx: &Context<'_>) -> Option<(String, String)> {
     match *item.kind {
-        clean::ItemKind::ImplItem(ref i) => {
-            i.trait_.as_ref().map(|trait_| {
-                // Alternative format produces no URLs,
-                // so this parameter does nothing.
-                (format!("{:#}", i.for_.print(cx)), get_id_for_impl(&i.for_, Some(trait_), cx))
-            })
-        }
+        clean::ItemKind::ImplItem(ref i) => i.trait_.as_ref().map(|trait_| {
+            (i.for_.print_plain(cx).to_string(), get_id_for_impl(&i.for_, Some(trait_), cx))
+        }),
         _ => None,
     }
 }

src/librustdoc/html/render/sidebar.rs

@@ -378,9 +378,9 @@ fn sidebar_deref_methods<'a>(
                     Cow::Borrowed("deref-methods")
                 };
                 let title = format!(
-                    "Methods from {:#}<Target={:#}>",
-                    impl_.inner_impl().trait_.as_ref().unwrap().print(cx),
-                    real_target.print(cx),
+                    "Methods from {}<Target={}>",
+                    impl_.inner_impl().trait_.as_ref().unwrap().print_plain(cx),
+                    real_target.print_plain(cx),
                 );
                 // We want links' order to be reproducible so we don't use unstable sort.
                 ret.sort();
@@ -487,7 +487,7 @@ fn sidebar_render_assoc_items(
                     ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => "",
                     ty::ImplPolarity::Negative => "!",
                 };
-                let generated = Link::new(encoded, format!("{prefix}{:#}", trait_.print(cx)));
+                let generated = Link::new(encoded, format!("{prefix}{}", trait_.print_plain(cx)));
                 if links.insert(generated.clone()) { Some(generated) } else { None }
             })
             .collect::<Vec<Link<'static>>>();