dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Stop pretty-printing HIR visibility.

This commit is contained in:
Camille GILLOT 2022-02-13 15:48:01 +01:00
parent 10d10efb21
commit 4e8046f67a
3 changed files with 29 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
compiler/rustc_hir_pretty/src/lib.rs
View File

@ -8,12 +8,11 @@ use rustc_ast_pretty::pprust::{Comments, PrintState};
use rustc_hir as hir;
use rustc_hir::{GenericArg, GenericParam, GenericParamKind, Node, Term};
use rustc_hir::{GenericBound, PatKind, RangeEnd, TraitBoundModifier};
use rustc_span::source_map::{SourceMap, Spanned};
use rustc_span::source_map::SourceMap;
use rustc_span::symbol::{kw, Ident, IdentPrinter, Symbol};
use rustc_span::{self, FileName};
use rustc_target::spec::abi::Abi;
use std::borrow::Cow;
use std::cell::Cell;
use std::vec;
@ -190,13 +189,6 @@ where
printer.s.eof()
}
pub fn visibility_qualified<S: Into<Cow<'static, str>>>(vis: &hir::Visibility<'_>, w: S) -> String {
to_string(NO_ANN, |s| {
s.print_visibility(vis);
s.word(w)
})
}
pub fn generic_params_to_string(generic_params: &[GenericParam<'_>]) -> String {
to_string(NO_ANN, |s| s.print_generic_params(generic_params))
}
@ -222,11 +214,10 @@ pub fn fn_to_string(
header: hir::FnHeader,
name: Option<Symbol>,
generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident],
body_id: Option<hir::BodyId>,
) -> String {
to_string(NO_ANN, |s| s.print_fn(decl, header, name, generics, vis, arg_names, body_id))
to_string(NO_ANN, |s| s.print_fn(decl, header, name, generics, arg_names, body_id))
}
pub fn enum_def_to_string(
@ -234,9 +225,8 @@ pub fn enum_def_to_string(
generics: &hir::Generics<'_>,
name: Symbol,
span: rustc_span::Span,
visibility: &hir::Visibility<'_>,
) -> String {
to_string(NO_ANN, |s| s.print_enum_def(enum_definition, generics, name, span, visibility))
to_string(NO_ANN, |s| s.print_enum_def(enum_definition, generics, name, span))
}
impl<'a> State<'a> {
@ -394,7 +384,6 @@ impl<'a> State<'a> {
},
Some(item.ident.name),
generics,
&item.vis,
arg_names,
None,
);
@ -403,7 +392,7 @@ impl<'a> State<'a> {
self.end() // end the outer fn box
}
hir::ForeignItemKind::Static(ref t, m) => {
self.head(visibility_qualified(&item.vis, "static"));
self.head("static");
if m == hir::Mutability::Mut {
self.word_space("mut");
}
@ -415,7 +404,7 @@ impl<'a> State<'a> {
self.end() // end the outer cbox
}
hir::ForeignItemKind::Type => {
self.head(visibility_qualified(&item.vis, "type"));
self.head("type");
self.print_ident(item.ident);
self.word(";");
self.end(); // end the head-ibox
@ -429,9 +418,8 @@ impl<'a> State<'a> {
ident: Ident,
ty: &hir::Ty<'_>,
default: Option<hir::BodyId>,
vis: &hir::Visibility<'_>,
) {
self.word(visibility_qualified(vis, ""));
self.head("");
self.word_space("const");
self.print_ident(ident);
self.word_space(":");
@ -472,7 +460,7 @@ impl<'a> State<'a> {
generics: &hir::Generics<'_>,
inner: impl Fn(&mut Self),
) {
self.head(visibility_qualified(&item.vis, "type"));
self.head("type");
self.print_ident(item.ident);
self.print_generic_params(&generics.params);
self.end(); // end the inner ibox
@ -493,7 +481,7 @@ impl<'a> State<'a> {
self.ann.pre(self, AnnNode::Item(item));
match item.kind {
hir::ItemKind::ExternCrate(orig_name) => {
self.head(visibility_qualified(&item.vis, "extern crate"));
self.head("extern crate");
if let Some(orig_name) = orig_name {
self.print_name(orig_name);
self.space();
@ -506,7 +494,7 @@ impl<'a> State<'a> {
self.end(); // end outer head-block
}
hir::ItemKind::Use(ref path, kind) => {
self.head(visibility_qualified(&item.vis, "use"));
self.head("use");
self.print_path(path, false);
match kind {
@ -525,7 +513,7 @@ impl<'a> State<'a> {
self.end(); // end outer head-block
}
hir::ItemKind::Static(ref ty, m, expr) => {
self.head(visibility_qualified(&item.vis, "static"));
self.head("static");
if m == hir::Mutability::Mut {
self.word_space("mut");
}
@ -541,7 +529,7 @@ impl<'a> State<'a> {
self.end(); // end the outer cbox
}
hir::ItemKind::Const(ref ty, expr) => {
self.head(visibility_qualified(&item.vis, "const"));
self.head("const");
self.print_ident(item.ident);
self.word_space(":");
self.print_type(&ty);
@ -560,7 +548,6 @@ impl<'a> State<'a> {
sig.header,
Some(item.ident.name),
param_names,
&item.vis,
&[],
Some(body),
);
@ -570,12 +557,10 @@ impl<'a> State<'a> {
self.ann.nested(self, Nested::Body(body));
}
hir::ItemKind::Macro(ref macro_def, _) => {
self.print_mac_def(macro_def, &item.ident, item.span, |state| {
state.print_visibility(&item.vis)
});
self.print_mac_def(macro_def, &item.ident, item.span, |_| {});
}
hir::ItemKind::Mod(ref _mod) => {
self.head(visibility_qualified(&item.vis, "mod"));
self.head("mod");
self.print_ident(item.ident);
self.nbsp();
self.bopen();
@ -593,7 +578,7 @@ impl<'a> State<'a> {
self.bclose(item.span);
}
hir::ItemKind::GlobalAsm(ref asm) => {
self.head(visibility_qualified(&item.vis, "global_asm!"));
self.head("global_asm!");
self.print_inline_asm(asm);
self.end()
}
@ -619,14 +604,14 @@ impl<'a> State<'a> {
});
}
hir::ItemKind::Enum(ref enum_definition, ref params) => {
self.print_enum_def(enum_definition, params, item.ident.name, item.span, &item.vis);
self.print_enum_def(enum_definition, params, item.ident.name, item.span);
}
hir::ItemKind::Struct(ref struct_def, ref generics) => {
self.head(visibility_qualified(&item.vis, "struct"));
self.head("struct");
self.print_struct(struct_def, generics, item.ident.name, item.span, true);
}
hir::ItemKind::Union(ref struct_def, ref generics) => {
self.head(visibility_qualified(&item.vis, "union"));
self.head("union");
self.print_struct(struct_def, generics, item.ident.name, item.span, true);
}
hir::ItemKind::Impl(hir::Impl {
@ -641,7 +626,6 @@ impl<'a> State<'a> {
items,
}) => {
self.head("");
self.print_visibility(&item.vis);
self.print_defaultness(defaultness);
self.print_unsafety(unsafety);
self.word_nbsp("impl");
@ -678,7 +662,6 @@ impl<'a> State<'a> {
}
hir::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, trait_items) => {
self.head("");
self.print_visibility(&item.vis);
self.print_is_auto(is_auto);
self.print_unsafety(unsafety);
self.word_nbsp("trait");
@ -704,7 +687,7 @@ impl<'a> State<'a> {
self.bclose(item.span);
}
hir::ItemKind::TraitAlias(ref generics, ref bounds) => {
self.head(visibility_qualified(&item.vis, "trait"));
self.head("trait");
self.print_ident(item.ident);
self.print_generic_params(&generics.params);
let mut real_bounds = Vec::with_capacity(bounds.len());
@ -752,9 +735,8 @@ impl<'a> State<'a> {
generics: &hir::Generics<'_>,
name: Symbol,
span: rustc_span::Span,
visibility: &hir::Visibility<'_>,
) {
self.head(visibility_qualified(visibility, "enum"));
self.head("enum");
self.print_name(name);
self.print_generic_params(&generics.params);
self.print_where_clause(&generics.where_clause);
@ -777,27 +759,6 @@ impl<'a> State<'a> {
self.bclose(span)
}
pub fn print_visibility(&mut self, vis: &hir::Visibility<'_>) {
match vis.node {
hir::VisibilityKind::Public => self.word_nbsp("pub"),
hir::VisibilityKind::Crate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate"),
hir::VisibilityKind::Crate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)"),
hir::VisibilityKind::Restricted { ref path, .. } => {
self.word("pub(");
if path.segments.len() == 1 && path.segments[0].ident.name == kw::Super {
// Special case: `super` can print like `pub(super)`.
self.word("super");
} else {
// Everything else requires `in` at present.
self.word_nbsp("in");
self.print_path(path, false);
}
self.word_nbsp(")");
}
hir::VisibilityKind::Inherited => (),
}
}
pub fn print_defaultness(&mut self, defaultness: hir::Defaultness) {
match defaultness {
hir::Defaultness::Default { .. } => self.word_nbsp("default"),
@ -822,7 +783,6 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, struct_def.fields(), |s, field| {
s.maybe_print_comment(field.span.lo());
s.print_outer_attributes(s.attrs(field.hir_id));
s.print_visibility(&field.vis);
s.print_type(&field.ty)
});
self.pclose();
@ -844,7 +804,6 @@ impl<'a> State<'a> {
self.hardbreak_if_not_bol();
self.maybe_print_comment(field.span.lo());
self.print_outer_attributes(self.attrs(field.hir_id));
self.print_visibility(&field.vis);
self.print_ident(field.ident);
self.word_nbsp(":");
self.print_type(&field.ty);
@ -871,11 +830,10 @@ impl<'a> State<'a> {
ident: Ident,
m: &hir::FnSig<'_>,
generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident],
body_id: Option<hir::BodyId>,
) {
self.print_fn(&m.decl, m.header, Some(ident.name), generics, vis, arg_names, body_id)
self.print_fn(&m.decl, m.header, Some(ident.name), generics, arg_names, body_id)
}
pub fn print_trait_item(&mut self, ti: &hir::TraitItem<'_>) {
@ -885,21 +843,15 @@ impl<'a> State<'a> {
self.print_outer_attributes(self.attrs(ti.hir_id()));
match ti.kind {
hir::TraitItemKind::Const(ref ty, default) => {
let vis =
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.print_associated_const(ti.ident, &ty, default, &vis);
self.print_associated_const(ti.ident, &ty, default);
}
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(ref arg_names)) => {
let vis =
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.print_method_sig(ti.ident, sig, &ti.generics, &vis, arg_names, None);
self.print_method_sig(ti.ident, sig, &ti.generics, arg_names, None);
self.word(";");
}
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
let vis =
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.head("");
self.print_method_sig(ti.ident, sig, &ti.generics, &vis, &[], Some(body));
self.print_method_sig(ti.ident, sig, &ti.generics, &[], Some(body));
self.nbsp();
self.end(); // need to close a box
self.end(); // need to close a box
@ -925,11 +877,11 @@ impl<'a> State<'a> {
match ii.kind {
hir::ImplItemKind::Const(ref ty, expr) => {
self.print_associated_const(ii.ident, &ty, Some(expr), &ii.vis);
self.print_associated_const(ii.ident, &ty, Some(expr));
}
hir::ImplItemKind::Fn(ref sig, body) => {
self.head("");
self.print_method_sig(ii.ident, sig, &ii.generics, &ii.vis, &[], Some(body));
self.print_method_sig(ii.ident, sig, &ii.generics, &[], Some(body));
self.nbsp();
self.end(); // need to close a box
self.end(); // need to close a box
@ -2007,11 +1959,10 @@ impl<'a> State<'a> {
header: hir::FnHeader,
name: Option<Symbol>,
generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident],
body_id: Option<hir::BodyId>,
) {
self.print_fn_header_info(header, vis);
self.print_fn_header_info(header);
if let Some(name) = name {
self.nbsp();
@ -2300,16 +2251,13 @@ impl<'a> State<'a> {
},
name,
&generics,
&Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited },
arg_names,
None,
);
self.end();
}
pub fn print_fn_header_info(&mut self, header: hir::FnHeader, vis: &hir::Visibility<'_>) {
self.word(visibility_qualified(vis, ""));
pub fn print_fn_header_info(&mut self, header: hir::FnHeader) {
match header.constness {
hir::Constness::NotConst => {}
hir::Constness::Const => self.word_nbsp("const"),

2
compiler/rustc_save_analysis/src/dump_visitor.rs
View File

@ -272,7 +272,7 @@ impl<'tcx> DumpVisitor<'tcx> {
v.process_generic_params(&generics, &method_data.qualname, hir_id);
method_data.value =
fn_to_string(sig.decl, sig.header, Some(ident.name), generics, vis, &[], None);
fn_to_string(sig.decl, sig.header, Some(ident.name), generics, &[], None);
method_data.sig = sig::method_signature(hir_id, ident, generics, sig, &v.save_ctxt);
v.dumper.dump_def(&access_from_vis!(v.save_ctxt, vis, def_id), method_data);

4
compiler/rustc_save_analysis/src/lib.rs
View File

@ -164,7 +164,6 @@ impl<'tcx> SaveContext<'tcx> {
},
Some(item.ident.name),
generics,
&item.vis,
arg_names,
None,
),
@ -220,7 +219,6 @@ impl<'tcx> SaveContext<'tcx> {
sig.header,
Some(item.ident.name),
generics,
&item.vis,
&[],
None,
),
@ -309,7 +307,7 @@ impl<'tcx> SaveContext<'tcx> {
let qualname = format!("::{}", self.tcx.def_path_str(def_id));
filter!(self.span_utils, item.ident.span);
let value =
enum_def_to_string(def, generics, item.ident.name, item.span, &item.vis);
enum_def_to_string(def, generics, item.ident.name, item.span);
Some(Data::DefData(Def {
kind: DefKind::Enum,
id: id_from_def_id(def_id),