nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-02 07:22:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove DefPath from Visibility and calculate it on demand

Browse Source
This commit is contained in:
Joshua Nelson 2020-12-16 18:10:04 -05:00
parent d8d3ab96aa
commit a2fb4b95dd
5 changed files with 76 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/librustdoc/clean/mod.rs
View File

@ -1775,25 +1775,28 @@ impl Clean<Visibility> for hir::Visibility<'_> {
hir::VisibilityKind::Inherited => Visibility::Inherited,
hir::VisibilityKind::Crate(_) => {
let krate = DefId::local(CRATE_DEF_INDEX);
Visibility::Restricted(krate, cx.tcx.def_path(krate))
Visibility::Restricted(krate)
}
hir::VisibilityKind::Restricted { ref path, .. } => {
let path = path.clean(cx);
let did = register_res(cx, path.res);
Visibility::Restricted(did, cx.tcx.def_path(did))
Visibility::Restricted(did)
}
}
}
}
impl Clean<Visibility> for ty::Visibility {
fn clean(&self, cx: &DocContext<'_>) -> Visibility {
fn clean(&self, _cx: &DocContext<'_>) -> Visibility {
match *self {
ty::Visibility::Public => Visibility::Public,
// NOTE: this is not quite right: `ty` uses `Invisible` to mean 'private',
// while rustdoc really does mean inherited. That means that for enum variants, such as
// `pub enum E { V }`, `V` will be marked as `Public` by `ty`, but as `Inherited` by rustdoc.
// This is the main reason `impl Clean for hir::Visibility` still exists; various parts of clean
// override `tcx.visibility` explicitly to make sure this distinction is captured.
ty::Visibility::Invisible => Visibility::Inherited,
ty::Visibility::Restricted(module) => {
Visibility::Restricted(module, cx.tcx.def_path(module))
}
ty::Visibility::Restricted(module) => Visibility::Restricted(module),
}
}
}
@ -2303,14 +2306,14 @@ impl Clean<Item> for (&hir::MacroDef<'_>, Option<Symbol>) {
if matchers.len() <= 1 {
format!(
"{}macro {}{} {{\n ...\n}}",
vis.print_with_space(),
vis.print_with_space(cx.tcx),
name,
matchers.iter().map(|span| span.to_src(cx)).collect::<String>(),
)
} else {
format!(
"{}macro {} {{\n{}}}",
vis.print_with_space(),
vis.print_with_space(cx.tcx),
name,
matchers
.iter()

4
src/librustdoc/clean/types.rs
View File

@ -1569,11 +1569,11 @@ impl From<hir::PrimTy> for PrimitiveType {
}
}
#[derive(Clone, Debug)]
#[derive(Copy, Clone, Debug)]
crate enum Visibility {
Public,
Inherited,
Restricted(DefId, rustc_hir::definitions::DefPath),
Restricted(DefId),
}
impl Visibility {

11
src/librustdoc/html/format.rs
View File

@ -11,6 +11,7 @@ use std::fmt;
use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
use rustc_middle::ty::TyCtxt;
use rustc_span::def_id::{DefId, CRATE_DEF_INDEX};
use rustc_target::spec::abi::Abi;
@ -1084,18 +1085,18 @@ impl Function<'_> {
}
impl clean::Visibility {
crate fn print_with_space(&self) -> impl fmt::Display + '_ {
crate fn print_with_space<'tcx>(self, tcx: TyCtxt<'tcx>) -> impl fmt::Display + 'tcx {
use rustc_span::symbol::kw;
display_fn(move |f| match *self {
display_fn(move |f| match self {
clean::Public => f.write_str("pub "),
clean::Inherited => Ok(()),
// If this is `pub(crate)`, `path` will be empty.
clean::Visibility::Restricted(did, _) if did.index == CRATE_DEF_INDEX => {
clean::Visibility::Restricted(did) if did.index == CRATE_DEF_INDEX => {
write!(f, "pub(crate) ")
}
clean::Visibility::Restricted(did, ref path) => {
clean::Visibility::Restricted(did) => {
f.write_str("pub(")?;
let path = tcx.def_path(did);
debug!("path={:?}", path);
let first_name =
path.data[0].data.get_opt_name().expect("modules are always named");

74
src/librustdoc/html/render/mod.rs
View File

@ -164,7 +164,7 @@ crate struct SharedContext<'tcx> {
playground: Option<markdown::Playground>,
}
impl Context<'_> {
impl<'tcx> Context<'tcx> {
fn path(&self, filename: &str) -> PathBuf {
// We use splitn vs Path::extension here because we might get a filename
// like `style.min.css` and we want to process that into
@ -176,6 +176,10 @@ impl Context<'_> {
self.dst.join(&filename)
}
fn tcx(&self) -> TyCtxt<'tcx> {
self.shared.tcx
}
fn sess(&self) -> &Session {
&self.shared.tcx.sess
}
@ -2147,14 +2151,14 @@ 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(),
myitem.visibility.print_with_space(cx.tcx()),
anchor(myitem.def_id, &*src.as_str()),
name
),
None => write!(
w,
"<tr><td><code>{}extern crate {};",
myitem.visibility.print_with_space(),
myitem.visibility.print_with_space(cx.tcx()),
anchor(myitem.def_id, &*name.as_str())
),
}
@ -2165,7 +2169,7 @@ 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(),
myitem.visibility.print_with_space(cx.tcx()),
import.print()
);
}
@ -2379,7 +2383,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(),
vis = it.visibility.print_with_space(cx.tcx()),
name = it.name.as_ref().unwrap(),
typ = c.type_.print(),
);
@ -2413,7 +2417,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(),
vis = it.visibility.print_with_space(cx.tcx()),
mutability = s.mutability.print_with_space(),
name = it.name.as_ref().unwrap(),
typ = s.type_.print()
@ -2424,7 +2428,7 @@ fn item_static(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St
fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::Function) {
let header_len = format!(
"{}{}{}{}{:#}fn {}{:#}",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
f.header.constness.print_with_space(),
f.header.asyncness.print_with_space(),
f.header.unsafety.print_with_space(),
@ -2439,7 +2443,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(),
vis = it.visibility.print_with_space(cx.tcx()),
constness = f.header.constness.print_with_space(),
asyncness = f.header.asyncness.print_with_space(),
unsafety = f.header.unsafety.print_with_space(),
@ -2565,7 +2569,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
write!(
w,
"{}{}{}trait {}{}{}",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
t.unsafety.print_with_space(),
if t.is_auto { "auto " } else { "" },
it.name.as_ref().unwrap(),
@ -2585,21 +2589,21 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
// FIXME: we should be using a derived_id for the Anchors here
write!(w, "{{\n");
for t in &types {
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait);
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait, cx);
write!(w, ";\n");
}
if !types.is_empty() && !consts.is_empty() {
w.write_str("\n");
}
for t in &consts {
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait);
render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait, cx);
write!(w, ";\n");
}
if !consts.is_empty() && !required.is_empty() {
w.write_str("\n");
}
for (pos, m) in required.iter().enumerate() {
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait);
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait, cx);
write!(w, ";\n");
if pos < required.len() - 1 {
@ -2610,7 +2614,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
w.write_str("\n");
}
for (pos, m) in provided.iter().enumerate() {
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait);
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait, cx);
match m.kind {
clean::MethodItem(ref inner, _)
if !inner.generics.where_predicates.is_empty() =>
@ -2659,7 +2663,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
let item_type = m.type_();
let id = cx.derive_id(format!("{}.{}", item_type, name));
write!(w, "<h3 id=\"{id}\" class=\"method\"><code>", id = id,);
render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl);
render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl, cx);
write!(w, "</code>");
render_stability_since(w, m, t);
write_srclink(cx, m, w, cache);
@ -2877,12 +2881,13 @@ fn assoc_const(
_default: Option<&String>,
link: AssocItemLink<'_>,
extra: &str,
cx: &Context<'_>,
) {
write!(
w,
"{}{}const <a href=\"{}\" class=\"constant\"><b>{}</b></a>: {}",
extra,
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
naive_assoc_href(it, link),
it.name.as_ref().unwrap(),
ty.print()
@ -2965,6 +2970,7 @@ fn render_assoc_item(
item: &clean::Item,
link: AssocItemLink<'_>,
parent: ItemType,
cx: &Context<'_>,
) {
fn method(
w: &mut Buffer,
@ -2974,6 +2980,7 @@ fn render_assoc_item(
d: &clean::FnDecl,
link: AssocItemLink<'_>,
parent: ItemType,
cx: &Context<'_>,
) {
let name = meth.name.as_ref().unwrap();
let anchor = format!("#{}.{}", meth.type_(), name);
@ -2994,7 +3001,7 @@ fn render_assoc_item(
};
let mut header_len = format!(
"{}{}{}{}{}{:#}fn {}{:#}",
meth.visibility.print_with_space(),
meth.visibility.print_with_space(cx.tcx()),
header.constness.print_with_space(),
header.asyncness.print_with_space(),
header.unsafety.print_with_space(),
@ -3016,7 +3023,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(),
meth.visibility.print_with_space(cx.tcx()),
header.constness.print_with_space(),
header.asyncness.print_with_space(),
header.unsafety.print_with_space(),
@ -3032,9 +3039,11 @@ fn render_assoc_item(
}
match item.kind {
clean::StrippedItem(..) => {}
clean::TyMethodItem(ref m) => method(w, item, m.header, &m.generics, &m.decl, link, parent),
clean::TyMethodItem(ref m) => {
method(w, item, m.header, &m.generics, &m.decl, link, parent, cx)
}
clean::MethodItem(ref m, _) => {
method(w, item, m.header, &m.generics, &m.decl, link, parent)
method(w, item, m.header, &m.generics, &m.decl, link, parent, cx)
}
clean::AssocConstItem(ref ty, ref default) => assoc_const(
w,
@ -3043,6 +3052,7 @@ fn render_assoc_item(
default.as_ref(),
link,
if parent == ItemType::Trait { " " } else { "" },
cx,
),
clean::AssocTypeItem(ref bounds, ref default) => assoc_type(
w,
@ -3066,7 +3076,7 @@ fn item_struct(
wrap_into_docblock(w, |w| {
write!(w, "<pre class=\"rust struct\">");
render_attributes(w, it, true);
render_struct(w, it, Some(&s.generics), s.struct_type, &s.fields, "", true);
render_struct(w, it, Some(&s.generics), s.struct_type, &s.fields, "", true, cx);
write!(w, "</pre>")
});
@ -3116,7 +3126,7 @@ fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
wrap_into_docblock(w, |w| {
write!(w, "<pre class=\"rust union\">");
render_attributes(w, it, true);
render_union(w, it, Some(&s.generics), &s.fields, "", true);
render_union(w, it, Some(&s.generics), &s.fields, "", true, cx);
write!(w, "</pre>")
});
@ -3165,7 +3175,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
write!(
w,
"{}enum {}{}{}",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
it.name.as_ref().unwrap(),
e.generics.print(),
WhereClause { gens: &e.generics, indent: 0, end_newline: true }
@ -3191,7 +3201,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
write!(w, ")");
}
clean::VariantKind::Struct(ref s) => {
render_struct(w, v, None, s.struct_type, &s.fields, " ", false);
render_struct(w, v, None, s.struct_type, &s.fields, " ", false, cx);
}
},
_ => unreachable!(),
@ -3335,11 +3345,12 @@ fn render_struct(
fields: &[clean::Item],
tab: &str,
structhead: bool,
cx: &Context<'_>,
) {
write!(
w,
"{}{}{}",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
if structhead { "struct " } else { "" },
it.name.as_ref().unwrap()
);
@ -3359,7 +3370,7 @@ fn render_struct(
w,
"\n{} {}{}: {},",
tab,
field.visibility.print_with_space(),
field.visibility.print_with_space(cx.tcx()),
field.name.as_ref().unwrap(),
ty.print()
);
@ -3388,7 +3399,7 @@ fn render_struct(
match field.kind {
clean::StrippedItem(box clean::StructFieldItem(..)) => write!(w, "_"),
clean::StructFieldItem(ref ty) => {
write!(w, "{}{}", field.visibility.print_with_space(), ty.print())
write!(w, "{}{}", field.visibility.print_with_space(cx.tcx()), ty.print())
}
_ => unreachable!(),
}
@ -3416,11 +3427,12 @@ fn render_union(
fields: &[clean::Item],
tab: &str,
structhead: bool,
cx: &Context<'_>,
) {
write!(
w,
"{}{}{}",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
if structhead { "union " } else { "" },
it.name.as_ref().unwrap()
);
@ -3435,7 +3447,7 @@ fn render_union(
write!(
w,
" {}{}: {},\n{}",
field.visibility.print_with_space(),
field.visibility.print_with_space(cx.tcx()),
field.name.as_ref().unwrap(),
ty.print(),
tab
@ -3827,7 +3839,7 @@ fn render_impl(
let id = cx.derive_id(format!("{}.{}", item_type, name));
write!(w, "<h4 id=\"{}\" class=\"{}{}\">", id, item_type, extra_class);
write!(w, "<code>");
render_assoc_item(w, item, link.anchor(&id), ItemType::Impl);
render_assoc_item(w, item, link.anchor(&id), ItemType::Impl, cx);
write!(w, "</code>");
render_stability_since_raw(
w,
@ -3849,7 +3861,7 @@ fn render_impl(
clean::AssocConstItem(ref ty, ref default) => {
let id = cx.derive_id(format!("{}.{}", item_type, name));
write!(w, "<h4 id=\"{}\" class=\"{}{}\"><code>", id, item_type, extra_class);
assoc_const(w, item, ty, default.as_ref(), link.anchor(&id), "");
assoc_const(w, item, ty, default.as_ref(), link.anchor(&id), "", cx);
write!(w, "</code>");
render_stability_since_raw(
w,
@ -4074,7 +4086,7 @@ fn item_foreign_type(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, cache:
write!(
w,
" {}type {};\n}}</pre>",
it.visibility.print_with_space(),
it.visibility.print_with_space(cx.tcx()),
it.name.as_ref().unwrap(),
);

30
src/librustdoc/json/conversions.rs
View File

@ -35,7 +35,7 @@ impl JsonRenderer<'_> {
crate_id: def_id.krate.as_u32(),
name: name.map(|sym| sym.to_string()),
source: self.convert_span(source),
visibility: visibility.into(),
visibility: self.convert_visibility(visibility),
docs: attrs.collapsed_doc_value().unwrap_or_default(),
links: attrs
.links
@ -75,6 +75,19 @@ impl JsonRenderer<'_> {
_ => None,
}
}
fn convert_visibility(&self, v: clean::Visibility) -> Visibility {
use clean::Visibility::*;
match v {
Public => Visibility::Public,
Inherited => Visibility::Default,
Restricted(did) if did.index == CRATE_DEF_INDEX => Visibility::Crate,
Restricted(did) => Visibility::Restricted {
parent: did.into(),
path: self.tcx.def_path(did).to_string_no_crate_verbose(),
},
}
}
}
impl From<rustc_attr::Deprecation> for Deprecation {
@ -85,21 +98,6 @@ impl From<rustc_attr::Deprecation> for Deprecation {
}
}
impl From<clean::Visibility> for Visibility {
fn from(v: clean::Visibility) -> Self {
use clean::Visibility::*;
match v {
Public => Visibility::Public,
Inherited => Visibility::Default,
Restricted(did, _) if did.index == CRATE_DEF_INDEX => Visibility::Crate,
Restricted(did, path) => Visibility::Restricted {
parent: did.into(),
path: path.to_string_no_crate_verbose(),
},
}
}
}
impl From<clean::GenericArgs> for GenericArgs {
fn from(args: clean::GenericArgs) -> Self {
use clean::GenericArgs::*;