mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stop pretty-printing HIR visibility.

Browse Source
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 as hir;
use rustc_hir::{GenericArg, GenericParam, GenericParamKind, Node, Term}; use rustc_hir::{GenericArg, GenericParam, GenericParamKind, Node, Term};
use rustc_hir::{GenericBound, PatKind, RangeEnd, TraitBoundModifier}; 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::symbol::{kw, Ident, IdentPrinter, Symbol};
use rustc_span::{self, FileName}; use rustc_span::{self, FileName};
use rustc_target::spec::abi::Abi; use rustc_target::spec::abi::Abi;
use std::borrow::Cow;
use std::cell::Cell; use std::cell::Cell;
use std::vec; use std::vec;
@ -190,13 +189,6 @@ where
printer.s.eof() 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 { pub fn generic_params_to_string(generic_params: &[GenericParam<'_>]) -> String {
to_string(NO_ANN, |s| s.print_generic_params(generic_params)) to_string(NO_ANN, |s| s.print_generic_params(generic_params))
} }
@ -222,11 +214,10 @@ pub fn fn_to_string(
header: hir::FnHeader, header: hir::FnHeader,
name: Option<Symbol>, name: Option<Symbol>,
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident], arg_names: &[Ident],
body_id: Option<hir::BodyId>, body_id: Option<hir::BodyId>,
) -> String { ) -> 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( pub fn enum_def_to_string(
@ -234,9 +225,8 @@ pub fn enum_def_to_string(
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
name: Symbol, name: Symbol,
span: rustc_span::Span, span: rustc_span::Span,
visibility: &hir::Visibility<'_>,
) -> String { ) -> 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> { impl<'a> State<'a> {
@ -394,7 +384,6 @@ impl<'a> State<'a> {
}, },
Some(item.ident.name), Some(item.ident.name),
generics, generics,
&item.vis,
arg_names, arg_names,
None, None,
); );
@ -403,7 +392,7 @@ impl<'a> State<'a> {
self.end() // end the outer fn box self.end() // end the outer fn box
} }
hir::ForeignItemKind::Static(ref t, m) => { hir::ForeignItemKind::Static(ref t, m) => {
self.head(visibility_qualified(&item.vis, "static")); self.head("static");
if m == hir::Mutability::Mut { if m == hir::Mutability::Mut {
self.word_space("mut"); self.word_space("mut");
} }
@ -415,7 +404,7 @@ impl<'a> State<'a> {
self.end() // end the outer cbox self.end() // end the outer cbox
} }
hir::ForeignItemKind::Type => { hir::ForeignItemKind::Type => {
self.head(visibility_qualified(&item.vis, "type")); self.head("type");
self.print_ident(item.ident); self.print_ident(item.ident);
self.word(";"); self.word(";");
self.end(); // end the head-ibox self.end(); // end the head-ibox
@ -429,9 +418,8 @@ impl<'a> State<'a> {
ident: Ident, ident: Ident,
ty: &hir::Ty<'_>, ty: &hir::Ty<'_>,
default: Option<hir::BodyId>, default: Option<hir::BodyId>,
vis: &hir::Visibility<'_>,
) { ) {
self.word(visibility_qualified(vis, "")); self.head("");
self.word_space("const"); self.word_space("const");
self.print_ident(ident); self.print_ident(ident);
self.word_space(":"); self.word_space(":");
@ -472,7 +460,7 @@ impl<'a> State<'a> {
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
inner: impl Fn(&mut Self), inner: impl Fn(&mut Self),
) { ) {
self.head(visibility_qualified(&item.vis, "type")); self.head("type");
self.print_ident(item.ident); self.print_ident(item.ident);
self.print_generic_params(&generics.params); self.print_generic_params(&generics.params);
self.end(); // end the inner ibox self.end(); // end the inner ibox
@ -493,7 +481,7 @@ impl<'a> State<'a> {
self.ann.pre(self, AnnNode::Item(item)); self.ann.pre(self, AnnNode::Item(item));
match item.kind { match item.kind {
hir::ItemKind::ExternCrate(orig_name) => { hir::ItemKind::ExternCrate(orig_name) => {
self.head(visibility_qualified(&item.vis, "extern crate")); self.head("extern crate");
if let Some(orig_name) = orig_name { if let Some(orig_name) = orig_name {
self.print_name(orig_name); self.print_name(orig_name);
self.space(); self.space();
@ -506,7 +494,7 @@ impl<'a> State<'a> {
self.end(); // end outer head-block self.end(); // end outer head-block
} }
hir::ItemKind::Use(ref path, kind) => { hir::ItemKind::Use(ref path, kind) => {
self.head(visibility_qualified(&item.vis, "use")); self.head("use");
self.print_path(path, false); self.print_path(path, false);
match kind { match kind {
@ -525,7 +513,7 @@ impl<'a> State<'a> {
self.end(); // end outer head-block self.end(); // end outer head-block
} }
hir::ItemKind::Static(ref ty, m, expr) => { hir::ItemKind::Static(ref ty, m, expr) => {
self.head(visibility_qualified(&item.vis, "static")); self.head("static");
if m == hir::Mutability::Mut { if m == hir::Mutability::Mut {
self.word_space("mut"); self.word_space("mut");
} }
@ -541,7 +529,7 @@ impl<'a> State<'a> {
self.end(); // end the outer cbox self.end(); // end the outer cbox
} }
hir::ItemKind::Const(ref ty, expr) => { hir::ItemKind::Const(ref ty, expr) => {
self.head(visibility_qualified(&item.vis, "const")); self.head("const");
self.print_ident(item.ident); self.print_ident(item.ident);
self.word_space(":"); self.word_space(":");
self.print_type(&ty); self.print_type(&ty);
@ -560,7 +548,6 @@ impl<'a> State<'a> {
sig.header, sig.header,
Some(item.ident.name), Some(item.ident.name),
param_names, param_names,
&item.vis,
&[], &[],
Some(body), Some(body),
); );
@ -570,12 +557,10 @@ impl<'a> State<'a> {
self.ann.nested(self, Nested::Body(body)); self.ann.nested(self, Nested::Body(body));
} }
hir::ItemKind::Macro(ref macro_def, _) => { hir::ItemKind::Macro(ref macro_def, _) => {
self.print_mac_def(macro_def, &item.ident, item.span, |state| { self.print_mac_def(macro_def, &item.ident, item.span, |_| {});
state.print_visibility(&item.vis)
});
} }
hir::ItemKind::Mod(ref _mod) => { hir::ItemKind::Mod(ref _mod) => {
self.head(visibility_qualified(&item.vis, "mod")); self.head("mod");
self.print_ident(item.ident); self.print_ident(item.ident);
self.nbsp(); self.nbsp();
self.bopen(); self.bopen();
@ -593,7 +578,7 @@ impl<'a> State<'a> {
self.bclose(item.span); self.bclose(item.span);
} }
hir::ItemKind::GlobalAsm(ref asm) => { hir::ItemKind::GlobalAsm(ref asm) => {
self.head(visibility_qualified(&item.vis, "global_asm!")); self.head("global_asm!");
self.print_inline_asm(asm); self.print_inline_asm(asm);
self.end() self.end()
} }
@ -619,14 +604,14 @@ impl<'a> State<'a> {
}); });
} }
hir::ItemKind::Enum(ref enum_definition, ref params) => { 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) => { 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); self.print_struct(struct_def, generics, item.ident.name, item.span, true);
} }
hir::ItemKind::Union(ref struct_def, ref generics) => { 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); self.print_struct(struct_def, generics, item.ident.name, item.span, true);
} }
hir::ItemKind::Impl(hir::Impl { hir::ItemKind::Impl(hir::Impl {
@ -641,7 +626,6 @@ impl<'a> State<'a> {
items, items,
}) => { }) => {
self.head(""); self.head("");
self.print_visibility(&item.vis);
self.print_defaultness(defaultness); self.print_defaultness(defaultness);
self.print_unsafety(unsafety); self.print_unsafety(unsafety);
self.word_nbsp("impl"); self.word_nbsp("impl");
@ -678,7 +662,6 @@ impl<'a> State<'a> {
} }
hir::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, trait_items) => { hir::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, trait_items) => {
self.head(""); self.head("");
self.print_visibility(&item.vis);
self.print_is_auto(is_auto); self.print_is_auto(is_auto);
self.print_unsafety(unsafety); self.print_unsafety(unsafety);
self.word_nbsp("trait"); self.word_nbsp("trait");
@ -704,7 +687,7 @@ impl<'a> State<'a> {
self.bclose(item.span); self.bclose(item.span);
} }
hir::ItemKind::TraitAlias(ref generics, ref bounds) => { hir::ItemKind::TraitAlias(ref generics, ref bounds) => {
self.head(visibility_qualified(&item.vis, "trait")); self.head("trait");
self.print_ident(item.ident); self.print_ident(item.ident);
self.print_generic_params(&generics.params); self.print_generic_params(&generics.params);
let mut real_bounds = Vec::with_capacity(bounds.len()); let mut real_bounds = Vec::with_capacity(bounds.len());
@ -752,9 +735,8 @@ impl<'a> State<'a> {
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
name: Symbol, name: Symbol,
span: rustc_span::Span, span: rustc_span::Span,
visibility: &hir::Visibility<'_>,
) { ) {
self.head(visibility_qualified(visibility, "enum")); self.head("enum");
self.print_name(name); self.print_name(name);
self.print_generic_params(&generics.params); self.print_generic_params(&generics.params);
self.print_where_clause(&generics.where_clause); self.print_where_clause(&generics.where_clause);
@ -777,27 +759,6 @@ impl<'a> State<'a> {
self.bclose(span) 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) { pub fn print_defaultness(&mut self, defaultness: hir::Defaultness) {
match defaultness { match defaultness {
hir::Defaultness::Default { .. } => self.word_nbsp("default"), hir::Defaultness::Default { .. } => self.word_nbsp("default"),
@ -822,7 +783,6 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, struct_def.fields(), |s, field| { self.commasep(Inconsistent, struct_def.fields(), |s, field| {
s.maybe_print_comment(field.span.lo()); s.maybe_print_comment(field.span.lo());
s.print_outer_attributes(s.attrs(field.hir_id)); s.print_outer_attributes(s.attrs(field.hir_id));
s.print_visibility(&field.vis);
s.print_type(&field.ty) s.print_type(&field.ty)
}); });
self.pclose(); self.pclose();
@ -844,7 +804,6 @@ impl<'a> State<'a> {
self.hardbreak_if_not_bol(); self.hardbreak_if_not_bol();
self.maybe_print_comment(field.span.lo()); self.maybe_print_comment(field.span.lo());
self.print_outer_attributes(self.attrs(field.hir_id)); self.print_outer_attributes(self.attrs(field.hir_id));
self.print_visibility(&field.vis);
self.print_ident(field.ident); self.print_ident(field.ident);
self.word_nbsp(":"); self.word_nbsp(":");
self.print_type(&field.ty); self.print_type(&field.ty);
@ -871,11 +830,10 @@ impl<'a> State<'a> {
ident: Ident, ident: Ident,
m: &hir::FnSig<'_>, m: &hir::FnSig<'_>,
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident], arg_names: &[Ident],
body_id: Option<hir::BodyId>, 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<'_>) { 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())); self.print_outer_attributes(self.attrs(ti.hir_id()));
match ti.kind { match ti.kind {
hir::TraitItemKind::Const(ref ty, default) => { hir::TraitItemKind::Const(ref ty, default) => {
let vis = self.print_associated_const(ti.ident, &ty, default);
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.print_associated_const(ti.ident, &ty, default, &vis);
} }
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(ref arg_names)) => { hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(ref arg_names)) => {
let vis = self.print_method_sig(ti.ident, sig, &ti.generics, arg_names, None);
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.print_method_sig(ti.ident, sig, &ti.generics, &vis, arg_names, None);
self.word(";"); self.word(";");
} }
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => { hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
let vis =
Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited };
self.head(""); 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.nbsp();
self.end(); // need to close a box self.end(); // need to close a box
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 { match ii.kind {
hir::ImplItemKind::Const(ref ty, expr) => { 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) => { hir::ImplItemKind::Fn(ref sig, body) => {
self.head(""); 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.nbsp();
self.end(); // need to close a box self.end(); // need to close a box
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, header: hir::FnHeader,
name: Option<Symbol>, name: Option<Symbol>,
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[Ident], arg_names: &[Ident],
body_id: Option<hir::BodyId>, body_id: Option<hir::BodyId>,
) { ) {
self.print_fn_header_info(header, vis); self.print_fn_header_info(header);
if let Some(name) = name { if let Some(name) = name {
self.nbsp(); self.nbsp();
@ -2300,16 +2251,13 @@ impl<'a> State<'a> {
}, },
name, name,
&generics, &generics,
&Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited },
arg_names, arg_names,
None, None,
); );
self.end(); self.end();
} }
pub fn print_fn_header_info(&mut self, header: hir::FnHeader, vis: &hir::Visibility<'_>) { pub fn print_fn_header_info(&mut self, header: hir::FnHeader) {
self.word(visibility_qualified(vis, ""));
match header.constness { match header.constness {
hir::Constness::NotConst => {} hir::Constness::NotConst => {}
hir::Constness::Const => self.word_nbsp("const"), 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); v.process_generic_params(&generics, &method_data.qualname, hir_id);
method_data.value = 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); 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); 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), Some(item.ident.name),
generics, generics,
&item.vis,
arg_names, arg_names,
None, None,
), ),
@ -220,7 +219,6 @@ impl<'tcx> SaveContext<'tcx> {
sig.header, sig.header,
Some(item.ident.name), Some(item.ident.name),
generics, generics,
&item.vis,
&[], &[],
None, None,
), ),
@ -309,7 +307,7 @@ impl<'tcx> SaveContext<'tcx> {
let qualname = format!("::{}", self.tcx.def_path_str(def_id)); let qualname = format!("::{}", self.tcx.def_path_str(def_id));
filter!(self.span_utils, item.ident.span); filter!(self.span_utils, item.ident.span);
let value = 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 { Some(Data::DefData(Def {
kind: DefKind::Enum, kind: DefKind::Enum,
id: id_from_def_id(def_id), id: id_from_def_id(def_id),