Remove last uses of CURRENT_DEPTH in html/format.rs

Author: camelid

src/librustdoc/clean/mod.rs

@@ -2292,14 +2292,16 @@ impl Clean<Item> for (&hir::MacroDef<'_>, Option<Symbol>) {
             if matchers.len() <= 1 {
                 format!(
                     "{}macro {}{} {{\n    ...\n}}",
-                    vis.print_with_space(cx.tcx, def_id, &cx.cache),
+                    // FIXME(camelid): this might create broken links!
+                    vis.print_with_space(cx.tcx, def_id, &cx.cache, 0),
                     name,
                     matchers.iter().map(|span| span.to_src(cx)).collect::<String>(),
                 )
             } else {
                 format!(
                     "{}macro {} {{\n{}}}",
-                    vis.print_with_space(cx.tcx, def_id, &cx.cache),
+                    // FIXME(camelid): this might create broken links!
+                    vis.print_with_space(cx.tcx, def_id, &cx.cache, 0),
                     name,
                     matchers
                         .iter()

src/librustdoc/clean/types.rs

@@ -855,7 +855,7 @@ impl Attributes {
             .filter_map(|ItemLink { link: s, link_text, did, fragment }| {
                 match *did {
                     Some(did) => {
-                        if let Some((mut href, ..)) = href(did, cache) {
+                        if let Some((mut href, ..)) = href(did, cache, depth) {
                             if let Some(ref fragment) = *fragment {
                                 href.push('#');
                                 href.push_str(fragment);

src/librustdoc/html/format.rs

@@ -20,7 +20,6 @@ use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
 use crate::html::render::cache::ExternalLocation;
-use crate::html::render::CURRENT_DEPTH;
 
 crate trait Print {
     fn print(self, buffer: &mut Buffer);
@@ -489,12 +488,11 @@ impl clean::Path {
     }
 }
 
-crate fn href(did: DefId, cache: &Cache) -> Option<(String, ItemType, Vec<String>)> {
+crate fn href(did: DefId, cache: &Cache, depth: usize) -> Option<(String, ItemType, Vec<String>)> {
     if !did.is_local() && !cache.access_levels.is_public(did) && !cache.document_private {
         return None;
     }
 
-    let depth = CURRENT_DEPTH.with(|l| l.get());
     let (fqp, shortty, mut url) = match cache.paths.get(&did) {
         Some(&(ref fqp, shortty)) => (fqp, shortty, "../".repeat(depth)),
         None => {
@@ -551,17 +549,17 @@ fn resolved_path(
         write!(w, "{}{:#}", &last.name, last.args.print(cache, depth))?;
     } else {
         let path = if use_absolute {
-            if let Some((_, _, fqp)) = href(did, cache) {
+            if let Some((_, _, fqp)) = href(did, cache, depth) {
                 format!(
                     "{}::{}",
                     fqp[..fqp.len() - 1].join("::"),
-                    anchor(did, fqp.last().unwrap(), cache)
+                    anchor(did, fqp.last().unwrap(), cache, depth)
                 )
             } else {
                 last.name.to_string()
             }
         } else {
-            anchor(did, &*last.name.as_str(), cache).to_string()
+            anchor(did, &*last.name.as_str(), cache, depth).to_string()
         };
         write!(w, "{}{}", path, last.args.print(cache, depth))?;
     }
@@ -633,9 +631,14 @@ fn tybounds<'a>(
     })
 }
 
-crate fn anchor<'a>(did: DefId, text: &'a str, cache: &'a Cache) -> impl fmt::Display + 'a {
+crate fn anchor<'a>(
+    did: DefId,
+    text: &'a str,
+    cache: &'a Cache,
+    depth: usize,
+) -> impl fmt::Display + 'a {
     display_fn(move |f| {
-        if let Some((url, short_ty, fqp)) = href(did, cache) {
+        if let Some((url, short_ty, fqp)) = href(did, cache, depth) {
             write!(
                 f,
                 r#"<a class="{}" href="{}" title="{} {}">{}</a>"#,
@@ -884,7 +887,7 @@ fn fmt_type(
                 //        everything comes in as a fully resolved QPath (hard to
                 //        look at).
                 box clean::ResolvedPath { did, ref param_names, .. } => {
-                    match href(did, cache) {
+                    match href(did, cache, depth) {
                         Some((ref url, _, ref path)) if !f.alternate() => {
                             write!(
                                 f,
@@ -1143,6 +1146,7 @@ impl clean::Visibility {
         tcx: TyCtxt<'tcx>,
         item_did: DefId,
         cache: &Cache,
+        depth: usize,
     ) -> impl fmt::Display + 'tcx {
         use rustc_span::symbol::kw;
 
@@ -1174,7 +1178,7 @@ impl clean::Visibility {
                         path.data[0].data.get_opt_name().expect("modules are always named");
                     // modified from `resolved_path()` to work with `DefPathData`
                     let last_name = path.data.last().unwrap().data.get_opt_name().unwrap();
-                    let anchor = anchor(vis_did, &last_name.as_str(), cache).to_string();
+                    let anchor = anchor(vis_did, &last_name.as_str(), cache, depth).to_string();
 
                     let mut s = "pub(".to_owned();
                     if path.data.len() != 1

src/librustdoc/html/render/mod.rs

@@ -674,8 +674,10 @@ fn document_short(
             MarkdownSummaryLine(&s, &item.links(&cx.cache, cx.depth())).into_string();
 
         if s.contains('\n') {
-            let link =
-                format!(r#" <a href="{}">Read more</a>"#, naive_assoc_href(item, link, cx.cache()));
+            let link = format!(
+                r#" <a href="{}">Read more</a>"#,
+                naive_assoc_href(item, link, cx.cache(), cx.depth())
+            );
 
             if let Some(idx) = summary_html.rfind("</p>") {
                 summary_html.insert_str(idx, &link);
@@ -894,7 +896,12 @@ fn render_impls(
     w.write_str(&impls.join(""));
 }
 
-fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>, cache: &Cache) -> String {
+fn naive_assoc_href(
+    it: &clean::Item,
+    link: AssocItemLink<'_>,
+    cache: &Cache,
+    depth: usize,
+) -> String {
     use crate::formats::item_type::ItemType::*;
 
     let name = it.name.as_ref().unwrap();
@@ -908,7 +915,7 @@ fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>, cache: &Cache) ->
         AssocItemLink::Anchor(Some(ref id)) => format!("#{}", id),
         AssocItemLink::Anchor(None) => anchor,
         AssocItemLink::GotoSource(did, _) => {
-            href(did, cache).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
+            href(did, cache, depth).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
         }
     }
 }
@@ -926,8 +933,8 @@ fn assoc_const(
         w,
         "{}{}const <a href=\"{}\" class=\"constant\"><b>{}</b></a>: {}",
         extra,
-        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
-        naive_assoc_href(it, link, cx.cache()),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
+        naive_assoc_href(it, link, cx.cache(), cx.depth()),
         it.name.as_ref().unwrap(),
         ty.print(cx.cache(), cx.depth())
     );
@@ -947,7 +954,7 @@ fn assoc_type(
         w,
         "{}type <a href=\"{}\" class=\"type\">{}</a>",
         extra,
-        naive_assoc_href(it, link, cache),
+        naive_assoc_href(it, link, cache, depth),
         it.name.as_ref().unwrap()
     );
     if !bounds.is_empty() {
@@ -1018,12 +1025,14 @@ fn render_assoc_item(
                     ItemType::TyMethod
                 };
 
-                href(did, cx.cache()).map(|p| format!("{}#{}.{}", p.0, ty, name)).unwrap_or(anchor)
+                href(did, cx.cache(), cx.depth())
+                    .map(|p| format!("{}#{}.{}", p.0, ty, name))
+                    .unwrap_or(anchor)
             }
         };
         let mut header_len = format!(
             "{}{}{}{}{}{:#}fn {}{:#}",
-            meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache()),
+            meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache(), cx.depth()),
             header.constness.print_with_space(),
             header.asyncness.print_with_space(),
             header.unsafety.print_with_space(),
@@ -1045,7 +1054,7 @@ fn render_assoc_item(
             "{}{}{}{}{}{}{}fn <a href=\"{href}\" class=\"fnname\">{name}</a>\
              {generics}{decl}{spotlight}{where_clause}",
             if parent == ItemType::Trait { "    " } else { "" },
-            meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache()),
+            meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache(), cx.depth()),
             header.constness.print_with_space(),
             header.asyncness.print_with_space(),
             header.unsafety.print_with_space(),

src/librustdoc/html/render/print_item.rs

@@ -247,15 +247,30 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl
                     Some(ref src) => write!(
                         w,
                         "<tr><td><code>{}extern crate {} as {};",
-                        myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()),
-                        anchor(myitem.def_id, &*src.as_str(), cx.cache()),
+                        myitem.visibility.print_with_space(
+                            cx.tcx(),
+                            myitem.def_id,
+                            cx.cache(),
+                            cx.depth(),
+                        ),
+                        anchor(myitem.def_id, &*src.as_str(), cx.cache(), cx.depth()),
                         myitem.name.as_ref().unwrap(),
                     ),
                     None => write!(
                         w,
                         "<tr><td><code>{}extern crate {};",
-                        myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()),
-                        anchor(myitem.def_id, &*myitem.name.as_ref().unwrap().as_str(), cx.cache()),
+                        myitem.visibility.print_with_space(
+                            cx.tcx(),
+                            myitem.def_id,
+                            cx.cache(),
+                            cx.depth(),
+                        ),
+                        anchor(
+                            myitem.def_id,
+                            &*myitem.name.as_ref().unwrap().as_str(),
+                            cx.cache(),
+                            cx.depth(),
+                        ),
                     ),
                 }
                 w.write_str("</code></td></tr>");
@@ -265,7 +280,12 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl
                 write!(
                     w,
                     "<tr><td><code>{}{}</code></td></tr>",
-                    myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()),
+                    myitem.visibility.print_with_space(
+                        cx.tcx(),
+                        myitem.def_id,
+                        cx.cache(),
+                        cx.depth()
+                    ),
                     import.print(cx.cache(), cx.depth())
                 );
             }
@@ -367,7 +387,7 @@ fn extra_info_tags(item: &clean::Item, parent: &clean::Item, tcx: TyCtxt<'_>) ->
 fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::Function) {
     let header_len = format!(
         "{}{}{}{}{:#}fn {}{:#}",
-        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         f.header.constness.print_with_space(),
         f.header.asyncness.print_with_space(),
         f.header.unsafety.print_with_space(),
@@ -382,7 +402,7 @@ fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::
         w,
         "{vis}{constness}{asyncness}{unsafety}{abi}fn \
          {name}{generics}{decl}{spotlight}{where_clause}</pre>",
-        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         constness = f.header.constness.print_with_space(),
         asyncness = f.header.asyncness.print_with_space(),
         unsafety = f.header.unsafety.print_with_space(),
@@ -412,7 +432,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
         write!(
             w,
             "{}{}{}trait {}{}{}",
-            it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+            it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
             t.unsafety.print_with_space(),
             if t.is_auto { "auto " } else { "" },
             it.name.as_ref().unwrap(),
@@ -813,7 +833,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
         write!(
             w,
             "{}enum {}{}{}",
-            it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+            it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
             it.name.as_ref().unwrap(),
             e.generics.print(cx.cache(), cx.depth()),
             WhereClause { gens: &e.generics, indent: 0, end_newline: true }
@@ -988,7 +1008,7 @@ fn item_constant(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, c: &clean::
     write!(
         w,
         "{vis}const {name}: {typ}",
-        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         name = it.name.as_ref().unwrap(),
         typ = c.type_.print(cx.cache(), cx.depth()),
     );
@@ -1072,7 +1092,7 @@ fn item_static(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St
     write!(
         w,
         "{vis}static {mutability}{name}: {typ}</pre>",
-        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         mutability = s.mutability.print_with_space(),
         name = it.name.as_ref().unwrap(),
         typ = s.type_.print(cx.cache(), cx.depth())
@@ -1086,7 +1106,7 @@ fn item_foreign_type(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
     write!(
         w,
         "    {}type {};\n}}</pre>",
-        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         it.name.as_ref().unwrap(),
     );
 
@@ -1250,7 +1270,7 @@ fn render_union(
     write!(
         w,
         "{}{}{}",
-        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         if structhead { "union " } else { "" },
         it.name.as_ref().unwrap()
     );
@@ -1269,7 +1289,7 @@ fn render_union(
             write!(
                 w,
                 "    {}{}: {},\n{}",
-                field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
+                field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache(), cx.depth()),
                 field.name.as_ref().unwrap(),
                 ty.print(cx.cache(), cx.depth()),
                 tab
@@ -1296,7 +1316,7 @@ fn render_struct(
     write!(
         w,
         "{}{}{}",
-        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache(), cx.depth()),
         if structhead { "struct " } else { "" },
         it.name.as_ref().unwrap()
     );
@@ -1321,7 +1341,12 @@ fn render_struct(
                         w,
                         "\n{}    {}{}: {},",
                         tab,
-                        field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
+                        field.visibility.print_with_space(
+                            cx.tcx(),
+                            field.def_id,
+                            cx.cache(),
+                            cx.depth()
+                        ),
                         field.name.as_ref().unwrap(),
                         ty.print(cx.cache(), cx.depth())
                     );
@@ -1353,7 +1378,12 @@ fn render_struct(
                         write!(
                             w,
                             "{}{}",
-                            field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
+                            field.visibility.print_with_space(
+                                cx.tcx(),
+                                field.def_id,
+                                cx.cache(),
+                                cx.depth()
+                            ),
                             ty.print(cx.cache(), cx.depth())
                         )
                     }