1
Fork 0

rustc_ast_pretty: remove ref patterns

This commit is contained in:
Maybe Waffle 2022-11-29 08:08:26 +00:00
parent 07b86a94c7
commit 56ae9a1746
3 changed files with 214 additions and 216 deletions

View file

@ -11,7 +11,7 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
use rustc_ast::util::classify; use rustc_ast::util::classify;
use rustc_ast::util::comments::{gather_comments, Comment, CommentStyle}; use rustc_ast::util::comments::{gather_comments, Comment, CommentStyle};
use rustc_ast::util::parser; use rustc_ast::util::parser;
use rustc_ast::{self as ast, AttrArgs, AttrArgsEq, BlockCheckMode, Mutability, PatKind}; use rustc_ast::{self as ast, AttrArgs, AttrArgsEq, BlockCheckMode, PatKind};
use rustc_ast::{attr, BindingAnnotation, ByRef, DelimArgs, RangeEnd, RangeSyntax, Term}; use rustc_ast::{attr, BindingAnnotation, ByRef, DelimArgs, RangeEnd, RangeSyntax, Term};
use rustc_ast::{GenericArg, GenericBound, SelfKind, TraitBoundModifier}; use rustc_ast::{GenericArg, GenericBound, SelfKind, TraitBoundModifier};
use rustc_ast::{InlineAsmOperand, InlineAsmRegOrRegClass}; use rustc_ast::{InlineAsmOperand, InlineAsmRegOrRegClass};
@ -64,6 +64,7 @@ impl<'a> Comments<'a> {
Comments { sm, comments, current: 0 } Comments { sm, comments, current: 0 }
} }
// This shouldn't probably clone lmao
pub fn next(&self) -> Option<Comment> { pub fn next(&self) -> Option<Comment> {
self.comments.get(self.current).cloned() self.comments.get(self.current).cloned()
} }
@ -268,10 +269,10 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
fn maybe_print_comment(&mut self, pos: BytePos) -> bool { fn maybe_print_comment(&mut self, pos: BytePos) -> bool {
let mut has_comment = false; let mut has_comment = false;
while let Some(ref cmnt) = self.next_comment() { while let Some(cmnt) = self.next_comment() {
if cmnt.pos < pos { if cmnt.pos < pos {
has_comment = true; has_comment = true;
self.print_comment(cmnt); self.print_comment(&cmnt);
} else { } else {
break; break;
} }
@ -366,8 +367,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
if self.next_comment().is_none() { if self.next_comment().is_none() {
self.hardbreak(); self.hardbreak();
} }
while let Some(ref cmnt) = self.next_comment() { while let Some(cmnt) = self.next_comment() {
self.print_comment(cmnt) self.print_comment(&cmnt)
} }
} }
@ -446,8 +447,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
self.hardbreak_if_not_bol(); self.hardbreak_if_not_bol();
} }
self.maybe_print_comment(attr.span.lo()); self.maybe_print_comment(attr.span.lo());
match attr.kind { match &attr.kind {
ast::AttrKind::Normal(ref normal) => { ast::AttrKind::Normal(normal) => {
match attr.style { match attr.style {
ast::AttrStyle::Inner => self.word("#!["), ast::AttrStyle::Inner => self.word("#!["),
ast::AttrStyle::Outer => self.word("#["), ast::AttrStyle::Outer => self.word("#["),
@ -456,7 +457,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
self.word("]"); self.word("]");
} }
ast::AttrKind::DocComment(comment_kind, data) => { ast::AttrKind::DocComment(comment_kind, data) => {
self.word(doc_comment_to_string(comment_kind, attr.style, data)); self.word(doc_comment_to_string(*comment_kind, attr.style, *data));
self.hardbreak() self.hardbreak()
} }
} }
@ -497,22 +498,22 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) { fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) {
match item { match item {
ast::NestedMetaItem::MetaItem(ref mi) => self.print_meta_item(mi), ast::NestedMetaItem::MetaItem(mi) => self.print_meta_item(mi),
ast::NestedMetaItem::Lit(ref lit) => self.print_meta_item_lit(lit), ast::NestedMetaItem::Lit(lit) => self.print_meta_item_lit(lit),
} }
} }
fn print_meta_item(&mut self, item: &ast::MetaItem) { fn print_meta_item(&mut self, item: &ast::MetaItem) {
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);
match item.kind { match &item.kind {
ast::MetaItemKind::Word => self.print_path(&item.path, false, 0), ast::MetaItemKind::Word => self.print_path(&item.path, false, 0),
ast::MetaItemKind::NameValue(ref value) => { ast::MetaItemKind::NameValue(value) => {
self.print_path(&item.path, false, 0); self.print_path(&item.path, false, 0);
self.space(); self.space();
self.word_space("="); self.word_space("=");
self.print_meta_item_lit(value); self.print_meta_item_lit(value);
} }
ast::MetaItemKind::List(ref items) => { ast::MetaItemKind::List(items) => {
self.print_path(&item.path, false, 0); self.print_path(&item.path, false, 0);
self.popen(); self.popen();
self.commasep(Consistent, &items, |s, i| s.print_meta_list_item(i)); self.commasep(Consistent, &items, |s, i| s.print_meta_list_item(i));
@ -657,7 +658,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) { fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) {
if segment.ident.name != kw::PathRoot { if segment.ident.name != kw::PathRoot {
self.print_ident(segment.ident); self.print_ident(segment.ident);
if let Some(ref args) = segment.args { if let Some(args) = &segment.args {
self.print_generic_args(args, colons_before_params); self.print_generic_args(args, colons_before_params);
} }
} }
@ -712,19 +713,19 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
} }
fn nonterminal_to_string(&self, nt: &Nonterminal) -> String { fn nonterminal_to_string(&self, nt: &Nonterminal) -> String {
match *nt { match nt {
token::NtExpr(ref e) => self.expr_to_string(e), token::NtExpr(e) => self.expr_to_string(e),
token::NtMeta(ref e) => self.attr_item_to_string(e), token::NtMeta(e) => self.attr_item_to_string(e),
token::NtTy(ref e) => self.ty_to_string(e), token::NtTy(e) => self.ty_to_string(e),
token::NtPath(ref e) => self.path_to_string(e), token::NtPath(e) => self.path_to_string(e),
token::NtItem(ref e) => self.item_to_string(e), token::NtItem(e) => self.item_to_string(e),
token::NtBlock(ref e) => self.block_to_string(e), token::NtBlock(e) => self.block_to_string(e),
token::NtStmt(ref e) => self.stmt_to_string(e), token::NtStmt(e) => self.stmt_to_string(e),
token::NtPat(ref e) => self.pat_to_string(e), token::NtPat(e) => self.pat_to_string(e),
token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw).to_string(), token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(*e, *is_raw).to_string(),
token::NtLifetime(e) => e.to_string(), token::NtLifetime(e) => e.to_string(),
token::NtLiteral(ref e) => self.expr_to_string(e), token::NtLiteral(e) => self.expr_to_string(e),
token::NtVis(ref e) => self.vis_to_string(e), token::NtVis(e) => self.vis_to_string(e),
} }
} }
@ -917,8 +918,8 @@ impl<'a> PrintState<'a> for State<'a> {
self.word("::") self.word("::")
} }
match *args { match args {
ast::GenericArgs::AngleBracketed(ref data) => { ast::GenericArgs::AngleBracketed(data) => {
self.word("<"); self.word("<");
self.commasep(Inconsistent, &data.args, |s, arg| match arg { self.commasep(Inconsistent, &data.args, |s, arg| match arg {
ast::AngleBracketedArg::Arg(a) => s.print_generic_arg(a), ast::AngleBracketedArg::Arg(a) => s.print_generic_arg(a),
@ -927,7 +928,7 @@ impl<'a> PrintState<'a> for State<'a> {
self.word(">") self.word(">")
} }
ast::GenericArgs::Parenthesized(ref data) => { ast::GenericArgs::Parenthesized(data) => {
self.word("("); self.word("(");
self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(ty)); self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(ty));
self.word(")"); self.word(")");
@ -1011,17 +1012,17 @@ impl<'a> State<'a> {
pub fn print_type(&mut self, ty: &ast::Ty) { pub fn print_type(&mut self, ty: &ast::Ty) {
self.maybe_print_comment(ty.span.lo()); self.maybe_print_comment(ty.span.lo());
self.ibox(0); self.ibox(0);
match ty.kind { match &ty.kind {
ast::TyKind::Slice(ref ty) => { ast::TyKind::Slice(ty) => {
self.word("["); self.word("[");
self.print_type(ty); self.print_type(ty);
self.word("]"); self.word("]");
} }
ast::TyKind::Ptr(ref mt) => { ast::TyKind::Ptr(mt) => {
self.word("*"); self.word("*");
self.print_mt(mt, true); self.print_mt(mt, true);
} }
ast::TyKind::Rptr(ref lifetime, ref mt) => { ast::TyKind::Rptr(lifetime, mt) => {
self.word("&"); self.word("&");
self.print_opt_lifetime(lifetime); self.print_opt_lifetime(lifetime);
self.print_mt(mt, false); self.print_mt(mt, false);
@ -1029,7 +1030,7 @@ impl<'a> State<'a> {
ast::TyKind::Never => { ast::TyKind::Never => {
self.word("!"); self.word("!");
} }
ast::TyKind::Tup(ref elts) => { ast::TyKind::Tup(elts) => {
self.popen(); self.popen();
self.commasep(Inconsistent, &elts, |s, ty| s.print_type(ty)); self.commasep(Inconsistent, &elts, |s, ty| s.print_type(ty));
if elts.len() == 1 { if elts.len() == 1 {
@ -1037,36 +1038,36 @@ impl<'a> State<'a> {
} }
self.pclose(); self.pclose();
} }
ast::TyKind::Paren(ref typ) => { ast::TyKind::Paren(typ) => {
self.popen(); self.popen();
self.print_type(typ); self.print_type(typ);
self.pclose(); self.pclose();
} }
ast::TyKind::BareFn(ref f) => { ast::TyKind::BareFn(f) => {
self.print_ty_fn(f.ext, f.unsafety, &f.decl, None, &f.generic_params); self.print_ty_fn(f.ext, f.unsafety, &f.decl, None, &f.generic_params);
} }
ast::TyKind::Path(None, ref path) => { ast::TyKind::Path(None, path) => {
self.print_path(path, false, 0); self.print_path(path, false, 0);
} }
ast::TyKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, false), ast::TyKind::Path(Some(qself), path) => self.print_qpath(path, qself, false),
ast::TyKind::TraitObject(ref bounds, syntax) => { ast::TyKind::TraitObject(bounds, syntax) => {
if syntax == ast::TraitObjectSyntax::Dyn { if *syntax == ast::TraitObjectSyntax::Dyn {
self.word_nbsp("dyn"); self.word_nbsp("dyn");
} }
self.print_type_bounds(bounds); self.print_type_bounds(bounds);
} }
ast::TyKind::ImplTrait(_, ref bounds) => { ast::TyKind::ImplTrait(_, bounds) => {
self.word_nbsp("impl"); self.word_nbsp("impl");
self.print_type_bounds(bounds); self.print_type_bounds(bounds);
} }
ast::TyKind::Array(ref ty, ref length) => { ast::TyKind::Array(ty, length) => {
self.word("["); self.word("[");
self.print_type(ty); self.print_type(ty);
self.word("; "); self.word("; ");
self.print_expr(&length.value); self.print_expr(&length.value);
self.word("]"); self.word("]");
} }
ast::TyKind::Typeof(ref e) => { ast::TyKind::Typeof(e) => {
self.word("typeof("); self.word("typeof(");
self.print_expr(&e.value); self.print_expr(&e.value);
self.word(")"); self.word(")");
@ -1082,7 +1083,7 @@ impl<'a> State<'a> {
ast::TyKind::ImplicitSelf => { ast::TyKind::ImplicitSelf => {
self.word("Self"); self.word("Self");
} }
ast::TyKind::MacCall(ref m) => { ast::TyKind::MacCall(m) => {
self.print_mac(m); self.print_mac(m);
} }
ast::TyKind::CVarArgs => { ast::TyKind::CVarArgs => {
@ -1111,8 +1112,8 @@ impl<'a> State<'a> {
pub(crate) fn print_stmt(&mut self, st: &ast::Stmt) { pub(crate) fn print_stmt(&mut self, st: &ast::Stmt) {
self.maybe_print_comment(st.span.lo()); self.maybe_print_comment(st.span.lo());
match st.kind { match &st.kind {
ast::StmtKind::Local(ref loc) => { ast::StmtKind::Local(loc) => {
self.print_outer_attributes(&loc.attrs); self.print_outer_attributes(&loc.attrs);
self.space_if_not_bol(); self.space_if_not_bol();
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);
@ -1135,15 +1136,15 @@ impl<'a> State<'a> {
self.word(";"); self.word(";");
self.end(); // `let` ibox self.end(); // `let` ibox
} }
ast::StmtKind::Item(ref item) => self.print_item(item), ast::StmtKind::Item(item) => self.print_item(item),
ast::StmtKind::Expr(ref expr) => { ast::StmtKind::Expr(expr) => {
self.space_if_not_bol(); self.space_if_not_bol();
self.print_expr_outer_attr_style(expr, false); self.print_expr_outer_attr_style(expr, false);
if classify::expr_requires_semi_to_be_stmt(expr) { if classify::expr_requires_semi_to_be_stmt(expr) {
self.word(";"); self.word(";");
} }
} }
ast::StmtKind::Semi(ref expr) => { ast::StmtKind::Semi(expr) => {
self.space_if_not_bol(); self.space_if_not_bol();
self.print_expr_outer_attr_style(expr, false); self.print_expr_outer_attr_style(expr, false);
self.word(";"); self.word(";");
@ -1152,7 +1153,7 @@ impl<'a> State<'a> {
self.space_if_not_bol(); self.space_if_not_bol();
self.word(";"); self.word(";");
} }
ast::StmtKind::MacCall(ref mac) => { ast::StmtKind::MacCall(mac) => {
self.space_if_not_bol(); self.space_if_not_bol();
self.print_outer_attributes(&mac.attrs); self.print_outer_attributes(&mac.attrs);
self.print_mac(&mac.mac); self.print_mac(&mac.mac);
@ -1193,8 +1194,8 @@ impl<'a> State<'a> {
let has_attrs = self.print_inner_attributes(attrs); let has_attrs = self.print_inner_attributes(attrs);
for (i, st) in blk.stmts.iter().enumerate() { for (i, st) in blk.stmts.iter().enumerate() {
match st.kind { match &st.kind {
ast::StmtKind::Expr(ref expr) if i == blk.stmts.len() - 1 => { ast::StmtKind::Expr(expr) if i == blk.stmts.len() - 1 => {
self.maybe_print_comment(st.span.lo()); self.maybe_print_comment(st.span.lo());
self.space_if_not_bol(); self.space_if_not_bol();
self.print_expr_outer_attr_style(expr, false); self.print_expr_outer_attr_style(expr, false);
@ -1362,7 +1363,7 @@ impl<'a> State<'a> {
pub(crate) fn print_local_decl(&mut self, loc: &ast::Local) { pub(crate) fn print_local_decl(&mut self, loc: &ast::Local) {
self.print_pat(&loc.pat); self.print_pat(&loc.pat);
if let Some(ref ty) = loc.ty { if let Some(ty) = &loc.ty {
self.word_space(":"); self.word_space(":");
self.print_type(ty); self.print_type(ty);
} }
@ -1386,7 +1387,7 @@ impl<'a> State<'a> {
for item_segment in &path.segments[qself.position..] { for item_segment in &path.segments[qself.position..] {
self.word("::"); self.word("::");
self.print_ident(item_segment.ident); self.print_ident(item_segment.ident);
if let Some(ref args) = item_segment.args { if let Some(args) = &item_segment.args {
self.print_generic_args(args, colons_before_params) self.print_generic_args(args, colons_before_params)
} }
} }
@ -1397,23 +1398,23 @@ impl<'a> State<'a> {
self.ann.pre(self, AnnNode::Pat(pat)); self.ann.pre(self, AnnNode::Pat(pat));
/* Pat isn't normalized, but the beauty of it /* Pat isn't normalized, but the beauty of it
is that it doesn't matter */ is that it doesn't matter */
match pat.kind { match &pat.kind {
PatKind::Wild => self.word("_"), PatKind::Wild => self.word("_"),
PatKind::Ident(BindingAnnotation(by_ref, mutbl), ident, ref sub) => { PatKind::Ident(BindingAnnotation(by_ref, mutbl), ident, sub) => {
if by_ref == ByRef::Yes { if *by_ref == ByRef::Yes {
self.word_nbsp("ref"); self.word_nbsp("ref");
} }
if mutbl == Mutability::Mut { if mutbl.is_mut() {
self.word_nbsp("mut"); self.word_nbsp("mut");
} }
self.print_ident(ident); self.print_ident(*ident);
if let Some(ref p) = *sub { if let Some(p) = sub {
self.space(); self.space();
self.word_space("@"); self.word_space("@");
self.print_pat(p); self.print_pat(p);
} }
} }
PatKind::TupleStruct(ref qself, ref path, ref elts) => { PatKind::TupleStruct(qself, path, elts) => {
if let Some(qself) = qself { if let Some(qself) = qself {
self.print_qpath(path, qself, true); self.print_qpath(path, qself, true);
} else { } else {
@ -1423,16 +1424,16 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p)); self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
self.pclose(); self.pclose();
} }
PatKind::Or(ref pats) => { PatKind::Or(pats) => {
self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(p)); self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(p));
} }
PatKind::Path(None, ref path) => { PatKind::Path(None, path) => {
self.print_path(path, true, 0); self.print_path(path, true, 0);
} }
PatKind::Path(Some(ref qself), ref path) => { PatKind::Path(Some(qself), path) => {
self.print_qpath(path, qself, false); self.print_qpath(path, qself, false);
} }
PatKind::Struct(ref qself, ref path, ref fields, etc) => { PatKind::Struct(qself, path, fields, etc) => {
if let Some(qself) = qself { if let Some(qself) = qself {
self.print_qpath(path, qself, true); self.print_qpath(path, qself, true);
} else { } else {
@ -1458,7 +1459,7 @@ impl<'a> State<'a> {
}, },
|f| f.pat.span, |f| f.pat.span,
); );
if etc { if *etc {
if !fields.is_empty() { if !fields.is_empty() {
self.word_space(","); self.word_space(",");
} }
@ -1469,7 +1470,7 @@ impl<'a> State<'a> {
} }
self.word("}"); self.word("}");
} }
PatKind::Tuple(ref elts) => { PatKind::Tuple(elts) => {
self.popen(); self.popen();
self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p)); self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
if elts.len() == 1 { if elts.len() == 1 {
@ -1477,13 +1478,13 @@ impl<'a> State<'a> {
} }
self.pclose(); self.pclose();
} }
PatKind::Box(ref inner) => { PatKind::Box(inner) => {
self.word("box "); self.word("box ");
self.print_pat(inner); self.print_pat(inner);
} }
PatKind::Ref(ref inner, mutbl) => { PatKind::Ref(inner, mutbl) => {
self.word("&"); self.word("&");
if mutbl == Mutability::Mut { if mutbl.is_mut() {
self.word("mut "); self.word("mut ");
} }
if let PatKind::Ident(ast::BindingAnnotation::MUT, ..) = inner.kind { if let PatKind::Ident(ast::BindingAnnotation::MUT, ..) = inner.kind {
@ -1494,12 +1495,12 @@ impl<'a> State<'a> {
self.print_pat(inner); self.print_pat(inner);
} }
} }
PatKind::Lit(ref e) => self.print_expr(&**e), PatKind::Lit(e) => self.print_expr(&**e),
PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => { PatKind::Range(begin, end, Spanned { node: end_kind, .. }) => {
if let Some(e) = begin { if let Some(e) = begin {
self.print_expr(e); self.print_expr(e);
} }
match *end_kind { match end_kind {
RangeEnd::Included(RangeSyntax::DotDotDot) => self.word("..."), RangeEnd::Included(RangeSyntax::DotDotDot) => self.word("..."),
RangeEnd::Included(RangeSyntax::DotDotEq) => self.word("..="), RangeEnd::Included(RangeSyntax::DotDotEq) => self.word("..="),
RangeEnd::Excluded => self.word(".."), RangeEnd::Excluded => self.word(".."),
@ -1508,36 +1509,36 @@ impl<'a> State<'a> {
self.print_expr(e); self.print_expr(e);
} }
} }
PatKind::Slice(ref elts) => { PatKind::Slice(elts) => {
self.word("["); self.word("[");
self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p)); self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
self.word("]"); self.word("]");
} }
PatKind::Rest => self.word(".."), PatKind::Rest => self.word(".."),
PatKind::Paren(ref inner) => { PatKind::Paren(inner) => {
self.popen(); self.popen();
self.print_pat(inner); self.print_pat(inner);
self.pclose(); self.pclose();
} }
PatKind::MacCall(ref m) => self.print_mac(m), PatKind::MacCall(m) => self.print_mac(m),
} }
self.ann.post(self, AnnNode::Pat(pat)) self.ann.post(self, AnnNode::Pat(pat))
} }
fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) { fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) {
match explicit_self.node { match &explicit_self.node {
SelfKind::Value(m) => { SelfKind::Value(m) => {
self.print_mutability(m, false); self.print_mutability(*m, false);
self.word("self") self.word("self")
} }
SelfKind::Region(ref lt, m) => { SelfKind::Region(lt, m) => {
self.word("&"); self.word("&");
self.print_opt_lifetime(lt); self.print_opt_lifetime(lt);
self.print_mutability(m, false); self.print_mutability(*m, false);
self.word("self") self.word("self")
} }
SelfKind::Explicit(ref typ, m) => { SelfKind::Explicit(typ, m) => {
self.print_mutability(m, false); self.print_mutability(*m, false);
self.word("self"); self.word("self");
self.word_space(":"); self.word_space(":");
self.print_type(typ) self.print_type(typ)
@ -1599,7 +1600,7 @@ impl<'a> State<'a> {
self.commasep(Inconsistent, &generic_params, |s, param| { self.commasep(Inconsistent, &generic_params, |s, param| {
s.print_outer_attributes_inline(&param.attrs); s.print_outer_attributes_inline(&param.attrs);
match param.kind { match &param.kind {
ast::GenericParamKind::Lifetime => { ast::GenericParamKind::Lifetime => {
let lt = ast::Lifetime { id: param.id, ident: param.ident }; let lt = ast::Lifetime { id: param.id, ident: param.ident };
s.print_lifetime(lt); s.print_lifetime(lt);
@ -1608,19 +1609,19 @@ impl<'a> State<'a> {
s.print_lifetime_bounds(&param.bounds) s.print_lifetime_bounds(&param.bounds)
} }
} }
ast::GenericParamKind::Type { ref default } => { ast::GenericParamKind::Type { default } => {
s.print_ident(param.ident); s.print_ident(param.ident);
if !param.bounds.is_empty() { if !param.bounds.is_empty() {
s.word_nbsp(":"); s.word_nbsp(":");
s.print_type_bounds(&param.bounds); s.print_type_bounds(&param.bounds);
} }
if let Some(ref default) = default { if let Some(default) = default {
s.space(); s.space();
s.word_space("="); s.word_space("=");
s.print_type(default) s.print_type(default)
} }
} }
ast::GenericParamKind::Const { ref ty, kw_span: _, ref default } => { ast::GenericParamKind::Const { ty, default, .. } => {
s.word_space("const"); s.word_space("const");
s.print_ident(param.ident); s.print_ident(param.ident);
s.space(); s.space();
@ -1630,7 +1631,7 @@ impl<'a> State<'a> {
s.word_nbsp(":"); s.word_nbsp(":");
s.print_type_bounds(&param.bounds); s.print_type_bounds(&param.bounds);
} }
if let Some(ref default) = default { if let Some(default) = default {
s.space(); s.space();
s.word_space("="); s.word_space("=");
s.print_expr(&default.value); s.print_expr(&default.value);

View file

@ -8,9 +8,9 @@ use rustc_ast::{self as ast, BlockCheckMode};
impl<'a> State<'a> { impl<'a> State<'a> {
fn print_else(&mut self, els: Option<&ast::Expr>) { fn print_else(&mut self, els: Option<&ast::Expr>) {
if let Some(_else) = els { if let Some(_else) = els {
match _else.kind { match &_else.kind {
// Another `else if` block. // Another `else if` block.
ast::ExprKind::If(ref i, ref then, ref e) => { ast::ExprKind::If(i, then, e) => {
self.cbox(INDENT_UNIT - 1); self.cbox(INDENT_UNIT - 1);
self.ibox(0); self.ibox(0);
self.word(" else if "); self.word(" else if ");
@ -20,7 +20,7 @@ impl<'a> State<'a> {
self.print_else(e.as_deref()) self.print_else(e.as_deref())
} }
// Final `else` block. // Final `else` block.
ast::ExprKind::Block(ref b, _) => { ast::ExprKind::Block(b, _) => {
self.cbox(INDENT_UNIT - 1); self.cbox(INDENT_UNIT - 1);
self.ibox(0); self.ibox(0);
self.word(" else "); self.word(" else ");
@ -202,7 +202,7 @@ impl<'a> State<'a> {
self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX); self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX);
self.word("."); self.word(".");
self.print_ident(segment.ident); self.print_ident(segment.ident);
if let Some(ref args) = segment.args { if let Some(args) = &segment.args {
self.print_generic_args(args, true); self.print_generic_args(args, true);
} }
self.print_call_post(base_args) self.print_call_post(base_args)
@ -284,73 +284,66 @@ impl<'a> State<'a> {
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);
self.ann.pre(self, AnnNode::Expr(expr)); self.ann.pre(self, AnnNode::Expr(expr));
match expr.kind { match &expr.kind {
ast::ExprKind::Box(ref expr) => { ast::ExprKind::Box(expr) => {
self.word_space("box"); self.word_space("box");
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX); self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
} }
ast::ExprKind::Array(ref exprs) => { ast::ExprKind::Array(exprs) => {
self.print_expr_vec(exprs); self.print_expr_vec(exprs);
} }
ast::ExprKind::ConstBlock(ref anon_const) => { ast::ExprKind::ConstBlock(anon_const) => {
self.print_expr_anon_const(anon_const, attrs); self.print_expr_anon_const(anon_const, attrs);
} }
ast::ExprKind::Repeat(ref element, ref count) => { ast::ExprKind::Repeat(element, count) => {
self.print_expr_repeat(element, count); self.print_expr_repeat(element, count);
} }
ast::ExprKind::Struct(ref se) => { ast::ExprKind::Struct(se) => {
self.print_expr_struct(&se.qself, &se.path, &se.fields, &se.rest); self.print_expr_struct(&se.qself, &se.path, &se.fields, &se.rest);
} }
ast::ExprKind::Tup(ref exprs) => { ast::ExprKind::Tup(exprs) => {
self.print_expr_tup(exprs); self.print_expr_tup(exprs);
} }
ast::ExprKind::Call(ref func, ref args) => { ast::ExprKind::Call(func, args) => {
self.print_expr_call(func, &args); self.print_expr_call(func, &args);
} }
ast::ExprKind::MethodCall(box ast::MethodCall { ast::ExprKind::MethodCall(box ast::MethodCall { seg, receiver, args, .. }) => {
ref seg,
ref receiver,
ref args,
..
}) => {
self.print_expr_method_call(seg, &receiver, &args); self.print_expr_method_call(seg, &receiver, &args);
} }
ast::ExprKind::Binary(op, ref lhs, ref rhs) => { ast::ExprKind::Binary(op, lhs, rhs) => {
self.print_expr_binary(op, lhs, rhs); self.print_expr_binary(*op, lhs, rhs);
} }
ast::ExprKind::Unary(op, ref expr) => { ast::ExprKind::Unary(op, expr) => {
self.print_expr_unary(op, expr); self.print_expr_unary(*op, expr);
} }
ast::ExprKind::AddrOf(k, m, ref expr) => { ast::ExprKind::AddrOf(k, m, expr) => {
self.print_expr_addr_of(k, m, expr); self.print_expr_addr_of(*k, *m, expr);
} }
ast::ExprKind::Lit(token_lit) => { ast::ExprKind::Lit(token_lit) => {
self.print_token_literal(token_lit, expr.span); self.print_token_literal(*token_lit, expr.span);
} }
ast::ExprKind::IncludedBytes(ref bytes) => { ast::ExprKind::IncludedBytes(bytes) => {
let lit = ast::LitKind::ByteStr(bytes.clone()).to_token_lit(); let lit = ast::LitKind::ByteStr(bytes.clone()).to_token_lit();
self.print_token_literal(lit, expr.span) self.print_token_literal(lit, expr.span)
} }
ast::ExprKind::Cast(ref expr, ref ty) => { ast::ExprKind::Cast(expr, ty) => {
let prec = AssocOp::As.precedence() as i8; let prec = AssocOp::As.precedence() as i8;
self.print_expr_maybe_paren(expr, prec); self.print_expr_maybe_paren(expr, prec);
self.space(); self.space();
self.word_space("as"); self.word_space("as");
self.print_type(ty); self.print_type(ty);
} }
ast::ExprKind::Type(ref expr, ref ty) => { ast::ExprKind::Type(expr, ty) => {
let prec = AssocOp::Colon.precedence() as i8; let prec = AssocOp::Colon.precedence() as i8;
self.print_expr_maybe_paren(expr, prec); self.print_expr_maybe_paren(expr, prec);
self.word_space(":"); self.word_space(":");
self.print_type(ty); self.print_type(ty);
} }
ast::ExprKind::Let(ref pat, ref scrutinee, _) => { ast::ExprKind::Let(pat, scrutinee, _) => {
self.print_let(pat, scrutinee); self.print_let(pat, scrutinee);
} }
ast::ExprKind::If(ref test, ref blk, ref elseopt) => { ast::ExprKind::If(test, blk, elseopt) => self.print_if(test, blk, elseopt.as_deref()),
self.print_if(test, blk, elseopt.as_deref()) ast::ExprKind::While(test, blk, opt_label) => {
}
ast::ExprKind::While(ref test, ref blk, opt_label) => {
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.print_ident(label.ident); self.print_ident(label.ident);
self.word_space(":"); self.word_space(":");
@ -362,7 +355,7 @@ impl<'a> State<'a> {
self.space(); self.space();
self.print_block_with_attrs(blk, attrs); self.print_block_with_attrs(blk, attrs);
} }
ast::ExprKind::ForLoop(ref pat, ref iter, ref blk, opt_label) => { ast::ExprKind::ForLoop(pat, iter, blk, opt_label) => {
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.print_ident(label.ident); self.print_ident(label.ident);
self.word_space(":"); self.word_space(":");
@ -377,7 +370,7 @@ impl<'a> State<'a> {
self.space(); self.space();
self.print_block_with_attrs(blk, attrs); self.print_block_with_attrs(blk, attrs);
} }
ast::ExprKind::Loop(ref blk, opt_label, _) => { ast::ExprKind::Loop(blk, opt_label, _) => {
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.print_ident(label.ident); self.print_ident(label.ident);
self.word_space(":"); self.word_space(":");
@ -387,7 +380,7 @@ impl<'a> State<'a> {
self.word_nbsp("loop"); self.word_nbsp("loop");
self.print_block_with_attrs(blk, attrs); self.print_block_with_attrs(blk, attrs);
} }
ast::ExprKind::Match(ref expr, ref arms) => { ast::ExprKind::Match(expr, arms) => {
self.cbox(0); self.cbox(0);
self.ibox(0); self.ibox(0);
self.word_nbsp("match"); self.word_nbsp("match");
@ -402,18 +395,18 @@ impl<'a> State<'a> {
self.bclose(expr.span, empty); self.bclose(expr.span, empty);
} }
ast::ExprKind::Closure(box ast::Closure { ast::ExprKind::Closure(box ast::Closure {
ref binder, binder,
capture_clause, capture_clause,
asyncness, asyncness,
movability, movability,
ref fn_decl, fn_decl,
ref body, body,
fn_decl_span: _, fn_decl_span: _,
}) => { }) => {
self.print_closure_binder(binder); self.print_closure_binder(binder);
self.print_movability(movability); self.print_movability(*movability);
self.print_asyncness(asyncness); self.print_asyncness(*asyncness);
self.print_capture_clause(capture_clause); self.print_capture_clause(*capture_clause);
self.print_fn_params_and_ret(fn_decl, true); self.print_fn_params_and_ret(fn_decl, true);
self.space(); self.space();
@ -425,7 +418,7 @@ impl<'a> State<'a> {
// empty box to satisfy the close. // empty box to satisfy the close.
self.ibox(0); self.ibox(0);
} }
ast::ExprKind::Block(ref blk, opt_label) => { ast::ExprKind::Block(blk, opt_label) => {
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.print_ident(label.ident); self.print_ident(label.ident);
self.word_space(":"); self.word_space(":");
@ -436,26 +429,26 @@ impl<'a> State<'a> {
self.ibox(0); self.ibox(0);
self.print_block_with_attrs(blk, attrs); self.print_block_with_attrs(blk, attrs);
} }
ast::ExprKind::Async(capture_clause, _, ref blk) => { ast::ExprKind::Async(capture_clause, _, blk) => {
self.word_nbsp("async"); self.word_nbsp("async");
self.print_capture_clause(capture_clause); self.print_capture_clause(*capture_clause);
// cbox/ibox in analogy to the `ExprKind::Block` arm above // cbox/ibox in analogy to the `ExprKind::Block` arm above
self.cbox(0); self.cbox(0);
self.ibox(0); self.ibox(0);
self.print_block_with_attrs(blk, attrs); self.print_block_with_attrs(blk, attrs);
} }
ast::ExprKind::Await(ref expr) => { ast::ExprKind::Await(expr) => {
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
self.word(".await"); self.word(".await");
} }
ast::ExprKind::Assign(ref lhs, ref rhs, _) => { ast::ExprKind::Assign(lhs, rhs, _) => {
let prec = AssocOp::Assign.precedence() as i8; let prec = AssocOp::Assign.precedence() as i8;
self.print_expr_maybe_paren(lhs, prec + 1); self.print_expr_maybe_paren(lhs, prec + 1);
self.space(); self.space();
self.word_space("="); self.word_space("=");
self.print_expr_maybe_paren(rhs, prec); self.print_expr_maybe_paren(rhs, prec);
} }
ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => { ast::ExprKind::AssignOp(op, lhs, rhs) => {
let prec = AssocOp::Assign.precedence() as i8; let prec = AssocOp::Assign.precedence() as i8;
self.print_expr_maybe_paren(lhs, prec + 1); self.print_expr_maybe_paren(lhs, prec + 1);
self.space(); self.space();
@ -463,45 +456,44 @@ impl<'a> State<'a> {
self.word_space("="); self.word_space("=");
self.print_expr_maybe_paren(rhs, prec); self.print_expr_maybe_paren(rhs, prec);
} }
ast::ExprKind::Field(ref expr, ident) => { ast::ExprKind::Field(expr, ident) => {
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
self.word("."); self.word(".");
self.print_ident(ident); self.print_ident(*ident);
} }
ast::ExprKind::Index(ref expr, ref index) => { ast::ExprKind::Index(expr, index) => {
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
self.word("["); self.word("[");
self.print_expr(index); self.print_expr(index);
self.word("]"); self.word("]");
} }
ast::ExprKind::Range(ref start, ref end, limits) => { ast::ExprKind::Range(start, end, limits) => {
// Special case for `Range`. `AssocOp` claims that `Range` has higher precedence // Special case for `Range`. `AssocOp` claims that `Range` has higher precedence
// than `Assign`, but `x .. x = x` gives a parse error instead of `x .. (x = x)`. // than `Assign`, but `x .. x = x` gives a parse error instead of `x .. (x = x)`.
// Here we use a fake precedence value so that any child with lower precedence than // Here we use a fake precedence value so that any child with lower precedence than
// a "normal" binop gets parenthesized. (`LOr` is the lowest-precedence binop.) // a "normal" binop gets parenthesized. (`LOr` is the lowest-precedence binop.)
let fake_prec = AssocOp::LOr.precedence() as i8; let fake_prec = AssocOp::LOr.precedence() as i8;
if let Some(ref e) = *start { if let Some(e) = start {
self.print_expr_maybe_paren(e, fake_prec); self.print_expr_maybe_paren(e, fake_prec);
} }
if limits == ast::RangeLimits::HalfOpen { match limits {
self.word(".."); ast::RangeLimits::HalfOpen => self.word(".."),
} else { ast::RangeLimits::Closed => self.word("..="),
self.word("..=");
} }
if let Some(ref e) = *end { if let Some(e) = end {
self.print_expr_maybe_paren(e, fake_prec); self.print_expr_maybe_paren(e, fake_prec);
} }
} }
ast::ExprKind::Underscore => self.word("_"), ast::ExprKind::Underscore => self.word("_"),
ast::ExprKind::Path(None, ref path) => self.print_path(path, true, 0), ast::ExprKind::Path(None, path) => self.print_path(path, true, 0),
ast::ExprKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, true), ast::ExprKind::Path(Some(qself), path) => self.print_qpath(path, qself, true),
ast::ExprKind::Break(opt_label, ref opt_expr) => { ast::ExprKind::Break(opt_label, opt_expr) => {
self.word("break"); self.word("break");
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.space(); self.space();
self.print_ident(label.ident); self.print_ident(label.ident);
} }
if let Some(ref expr) = *opt_expr { if let Some(expr) = opt_expr {
self.space(); self.space();
self.print_expr_maybe_paren(expr, parser::PREC_JUMP); self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
} }
@ -513,45 +505,45 @@ impl<'a> State<'a> {
self.print_ident(label.ident); self.print_ident(label.ident);
} }
} }
ast::ExprKind::Ret(ref result) => { ast::ExprKind::Ret(result) => {
self.word("return"); self.word("return");
if let Some(ref expr) = *result { if let Some(expr) = result {
self.word(" "); self.word(" ");
self.print_expr_maybe_paren(expr, parser::PREC_JUMP); self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
} }
} }
ast::ExprKind::Yeet(ref result) => { ast::ExprKind::Yeet(result) => {
self.word("do"); self.word("do");
self.word(" "); self.word(" ");
self.word("yeet"); self.word("yeet");
if let Some(ref expr) = *result { if let Some(expr) = result {
self.word(" "); self.word(" ");
self.print_expr_maybe_paren(expr, parser::PREC_JUMP); self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
} }
} }
ast::ExprKind::InlineAsm(ref a) => { ast::ExprKind::InlineAsm(a) => {
self.word("asm!"); self.word("asm!");
self.print_inline_asm(a); self.print_inline_asm(a);
} }
ast::ExprKind::MacCall(ref m) => self.print_mac(m), ast::ExprKind::MacCall(m) => self.print_mac(m),
ast::ExprKind::Paren(ref e) => { ast::ExprKind::Paren(e) => {
self.popen(); self.popen();
self.print_expr(e); self.print_expr(e);
self.pclose(); self.pclose();
} }
ast::ExprKind::Yield(ref e) => { ast::ExprKind::Yield(e) => {
self.word("yield"); self.word("yield");
if let Some(ref expr) = *e { if let Some(expr) = e {
self.space(); self.space();
self.print_expr_maybe_paren(expr, parser::PREC_JUMP); self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
} }
} }
ast::ExprKind::Try(ref e) => { ast::ExprKind::Try(e) => {
self.print_expr_maybe_paren(e, parser::PREC_POSTFIX); self.print_expr_maybe_paren(e, parser::PREC_POSTFIX);
self.word("?") self.word("?")
} }
ast::ExprKind::TryBlock(ref blk) => { ast::ExprKind::TryBlock(blk) => {
self.cbox(0); self.cbox(0);
self.ibox(0); self.ibox(0);
self.word_nbsp("try"); self.word_nbsp("try");
@ -578,15 +570,15 @@ impl<'a> State<'a> {
self.print_outer_attributes(&arm.attrs); self.print_outer_attributes(&arm.attrs);
self.print_pat(&arm.pat); self.print_pat(&arm.pat);
self.space(); self.space();
if let Some(ref e) = arm.guard { if let Some(e) = &arm.guard {
self.word_space("if"); self.word_space("if");
self.print_expr(e); self.print_expr(e);
self.space(); self.space();
} }
self.word_space("=>"); self.word_space("=>");
match arm.body.kind { match &arm.body.kind {
ast::ExprKind::Block(ref blk, opt_label) => { ast::ExprKind::Block(blk, opt_label) => {
if let Some(label) = opt_label { if let Some(label) = opt_label {
self.print_ident(label.ident); self.print_ident(label.ident);
self.word_space(":"); self.word_space(":");

View file

@ -136,10 +136,10 @@ impl<'a> State<'a> {
self.maybe_print_comment(item.span.lo()); self.maybe_print_comment(item.span.lo());
self.print_outer_attributes(&item.attrs); self.print_outer_attributes(&item.attrs);
self.ann.pre(self, AnnNode::Item(item)); self.ann.pre(self, AnnNode::Item(item));
match item.kind { match &item.kind {
ast::ItemKind::ExternCrate(orig_name) => { ast::ItemKind::ExternCrate(orig_name) => {
self.head(visibility_qualified(&item.vis, "extern crate")); self.head(visibility_qualified(&item.vis, "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();
self.word("as"); self.word("as");
@ -150,35 +150,41 @@ impl<'a> State<'a> {
self.end(); // end inner head-block self.end(); // end inner head-block
self.end(); // end outer head-block self.end(); // end outer head-block
} }
ast::ItemKind::Use(ref tree) => { ast::ItemKind::Use(tree) => {
self.print_visibility(&item.vis); self.print_visibility(&item.vis);
self.word_nbsp("use"); self.word_nbsp("use");
self.print_use_tree(tree); self.print_use_tree(tree);
self.word(";"); self.word(";");
} }
ast::ItemKind::Static(ref ty, mutbl, ref body) => { ast::ItemKind::Static(ty, mutbl, body) => {
let def = ast::Defaultness::Final; let def = ast::Defaultness::Final;
self.print_item_const(item.ident, Some(mutbl), ty, body.as_deref(), &item.vis, def); self.print_item_const(
item.ident,
Some(*mutbl),
ty,
body.as_deref(),
&item.vis,
def,
);
} }
ast::ItemKind::Const(def, ref ty, ref body) => { ast::ItemKind::Const(def, ty, body) => {
self.print_item_const(item.ident, None, ty, body.as_deref(), &item.vis, def); self.print_item_const(item.ident, None, ty, body.as_deref(), &item.vis, *def);
} }
ast::ItemKind::Fn(box ast::Fn { defaultness, ref sig, ref generics, ref body }) => { ast::ItemKind::Fn(box ast::Fn { defaultness, sig, generics, body }) => {
let body = body.as_deref();
self.print_fn_full( self.print_fn_full(
sig, sig,
item.ident, item.ident,
generics, generics,
&item.vis, &item.vis,
defaultness, *defaultness,
body, body.as_deref(),
&item.attrs, &item.attrs,
); );
} }
ast::ItemKind::Mod(unsafety, ref mod_kind) => { ast::ItemKind::Mod(unsafety, mod_kind) => {
self.head(Self::to_string(|s| { self.head(Self::to_string(|s| {
s.print_visibility(&item.vis); s.print_visibility(&item.vis);
s.print_unsafety(unsafety); s.print_unsafety(*unsafety);
s.word("mod"); s.word("mod");
})); }));
self.print_ident(item.ident); self.print_ident(item.ident);
@ -201,7 +207,7 @@ impl<'a> State<'a> {
} }
} }
} }
ast::ItemKind::ForeignMod(ref nmod) => { ast::ItemKind::ForeignMod(nmod) => {
self.head(Self::to_string(|s| { self.head(Self::to_string(|s| {
s.print_unsafety(nmod.unsafety); s.print_unsafety(nmod.unsafety);
s.word("extern"); s.word("extern");
@ -215,7 +221,7 @@ impl<'a> State<'a> {
let empty = item.attrs.is_empty() && nmod.items.is_empty(); let empty = item.attrs.is_empty() && nmod.items.is_empty();
self.bclose(item.span, empty); self.bclose(item.span, empty);
} }
ast::ItemKind::GlobalAsm(ref asm) => { ast::ItemKind::GlobalAsm(asm) => {
self.head(visibility_qualified(&item.vis, "global_asm!")); self.head(visibility_qualified(&item.vis, "global_asm!"));
self.print_inline_asm(asm); self.print_inline_asm(asm);
self.word(";"); self.word(";");
@ -224,32 +230,31 @@ impl<'a> State<'a> {
} }
ast::ItemKind::TyAlias(box ast::TyAlias { ast::ItemKind::TyAlias(box ast::TyAlias {
defaultness, defaultness,
ref generics, generics,
where_clauses, where_clauses,
where_predicates_split, where_predicates_split,
ref bounds, bounds,
ref ty, ty,
}) => { }) => {
let ty = ty.as_deref();
self.print_associated_type( self.print_associated_type(
item.ident, item.ident,
generics, generics,
where_clauses, *where_clauses,
where_predicates_split, *where_predicates_split,
bounds, bounds,
ty, ty.as_deref(),
&item.vis, &item.vis,
defaultness, *defaultness,
); );
} }
ast::ItemKind::Enum(ref enum_definition, ref params) => { ast::ItemKind::Enum(enum_definition, params) => {
self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis); self.print_enum_def(enum_definition, params, item.ident, item.span, &item.vis);
} }
ast::ItemKind::Struct(ref struct_def, ref generics) => { ast::ItemKind::Struct(struct_def, generics) => {
self.head(visibility_qualified(&item.vis, "struct")); self.head(visibility_qualified(&item.vis, "struct"));
self.print_struct(struct_def, generics, item.ident, item.span, true); self.print_struct(struct_def, generics, item.ident, item.span, true);
} }
ast::ItemKind::Union(ref struct_def, ref generics) => { ast::ItemKind::Union(struct_def, generics) => {
self.head(visibility_qualified(&item.vis, "union")); self.head(visibility_qualified(&item.vis, "union"));
self.print_struct(struct_def, generics, item.ident, item.span, true); self.print_struct(struct_def, generics, item.ident, item.span, true);
} }
@ -258,15 +263,15 @@ impl<'a> State<'a> {
polarity, polarity,
defaultness, defaultness,
constness, constness,
ref generics, generics,
ref of_trait, of_trait,
ref self_ty, self_ty,
ref items, items,
}) => { }) => {
self.head(""); self.head("");
self.print_visibility(&item.vis); self.print_visibility(&item.vis);
self.print_defaultness(defaultness); self.print_defaultness(*defaultness);
self.print_unsafety(unsafety); self.print_unsafety(*unsafety);
self.word("impl"); self.word("impl");
if generics.params.is_empty() { if generics.params.is_empty() {
@ -276,13 +281,13 @@ impl<'a> State<'a> {
self.space(); self.space();
} }
self.print_constness(constness); self.print_constness(*constness);
if let ast::ImplPolarity::Negative(_) = polarity { if let ast::ImplPolarity::Negative(_) = polarity {
self.word("!"); self.word("!");
} }
if let Some(ref t) = *of_trait { if let Some(t) = of_trait {
self.print_trait_ref(t); self.print_trait_ref(t);
self.space(); self.space();
self.word_space("for"); self.word_space("for");
@ -303,21 +308,21 @@ impl<'a> State<'a> {
ast::ItemKind::Trait(box ast::Trait { ast::ItemKind::Trait(box ast::Trait {
is_auto, is_auto,
unsafety, unsafety,
ref generics, generics,
ref bounds, bounds,
ref items, items,
.. ..
}) => { }) => {
self.head(""); self.head("");
self.print_visibility(&item.vis); self.print_visibility(&item.vis);
self.print_unsafety(unsafety); self.print_unsafety(*unsafety);
self.print_is_auto(is_auto); self.print_is_auto(*is_auto);
self.word_nbsp("trait"); self.word_nbsp("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());
for b in bounds.iter() { for b in bounds.iter() {
if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b { if let GenericBound::Trait(ptr, ast::TraitBoundModifier::Maybe) = b {
self.space(); self.space();
self.word_space("for ?"); self.word_space("for ?");
self.print_trait_ref(&ptr.trait_ref); self.print_trait_ref(&ptr.trait_ref);
@ -339,14 +344,14 @@ impl<'a> State<'a> {
let empty = item.attrs.is_empty() && items.is_empty(); let empty = item.attrs.is_empty() && items.is_empty();
self.bclose(item.span, empty); self.bclose(item.span, empty);
} }
ast::ItemKind::TraitAlias(ref generics, ref bounds) => { ast::ItemKind::TraitAlias(generics, bounds) => {
self.head(visibility_qualified(&item.vis, "trait")); self.head(visibility_qualified(&item.vis, "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());
// FIXME(durka) this seems to be some quite outdated syntax // FIXME(durka) this seems to be some quite outdated syntax
for b in bounds.iter() { for b in bounds.iter() {
if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b { if let GenericBound::Trait(ptr, ast::TraitBoundModifier::Maybe) = b {
self.space(); self.space();
self.word_space("for ?"); self.word_space("for ?");
self.print_trait_ref(&ptr.trait_ref); self.print_trait_ref(&ptr.trait_ref);
@ -364,13 +369,13 @@ impl<'a> State<'a> {
self.end(); // end inner head-block self.end(); // end inner head-block
self.end(); // end outer head-block self.end(); // end outer head-block
} }
ast::ItemKind::MacCall(ref mac) => { ast::ItemKind::MacCall(mac) => {
self.print_mac(mac); self.print_mac(mac);
if mac.args.need_semicolon() { if mac.args.need_semicolon() {
self.word(";"); self.word(";");
} }
} }
ast::ItemKind::MacroDef(ref macro_def) => { ast::ItemKind::MacroDef(macro_def) => {
self.print_mac_def(macro_def, &item.ident, item.span, |state| { self.print_mac_def(macro_def, &item.ident, item.span, |state| {
state.print_visibility(&item.vis) state.print_visibility(&item.vis)
}); });
@ -412,11 +417,11 @@ impl<'a> State<'a> {
} }
pub(crate) fn print_visibility(&mut self, vis: &ast::Visibility) { pub(crate) fn print_visibility(&mut self, vis: &ast::Visibility) {
match vis.kind { match &vis.kind {
ast::VisibilityKind::Public => self.word_nbsp("pub"), ast::VisibilityKind::Public => self.word_nbsp("pub"),
ast::VisibilityKind::Restricted { ref path, id: _, shorthand } => { ast::VisibilityKind::Restricted { path, shorthand, .. } => {
let path = Self::to_string(|s| s.print_path(path, false, 0)); let path = Self::to_string(|s| s.print_path(path, false, 0));
if shorthand && (path == "crate" || path == "self" || path == "super") { if *shorthand && (path == "crate" || path == "self" || path == "super") {
self.word_nbsp(format!("pub({})", path)) self.word_nbsp(format!("pub({})", path))
} else { } else {
self.word_nbsp(format!("pub(in {})", path)) self.word_nbsp(format!("pub(in {})", path))
@ -465,7 +470,7 @@ impl<'a> State<'a> {
) { ) {
self.print_ident(ident); self.print_ident(ident);
self.print_generic_params(&generics.params); self.print_generic_params(&generics.params);
match struct_def { match &struct_def {
ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => { ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
if let ast::VariantData::Tuple(..) = struct_def { if let ast::VariantData::Tuple(..) = struct_def {
self.popen(); self.popen();
@ -484,7 +489,7 @@ impl<'a> State<'a> {
self.end(); self.end();
self.end(); // Close the outer-box. self.end(); // Close the outer-box.
} }
ast::VariantData::Struct(ref fields, ..) => { ast::VariantData::Struct(fields, ..) => {
self.print_where_clause(&generics.where_clause); self.print_where_clause(&generics.where_clause);
self.print_record_struct_body(fields, span); self.print_record_struct_body(fields, span);
} }
@ -496,7 +501,7 @@ impl<'a> State<'a> {
self.print_visibility(&v.vis); self.print_visibility(&v.vis);
let generics = ast::Generics::default(); let generics = ast::Generics::default();
self.print_struct(&v.data, &generics, v.ident, v.span, false); self.print_struct(&v.data, &generics, v.ident, v.span, false);
if let Some(ref d) = v.disr_expr { if let Some(d) = &v.disr_expr {
self.space(); self.space();
self.word_space("="); self.word_space("=");
self.print_expr(&d.value) self.print_expr(&d.value)
@ -657,10 +662,10 @@ impl<'a> State<'a> {
} }
fn print_use_tree(&mut self, tree: &ast::UseTree) { fn print_use_tree(&mut self, tree: &ast::UseTree) {
match tree.kind { match &tree.kind {
ast::UseTreeKind::Simple(rename, ..) => { ast::UseTreeKind::Simple(rename, ..) => {
self.print_path(&tree.prefix, false, 0); self.print_path(&tree.prefix, false, 0);
if let Some(rename) = rename { if let &Some(rename) = rename {
self.nbsp(); self.nbsp();
self.word_nbsp("as"); self.word_nbsp("as");
self.print_ident(rename); self.print_ident(rename);
@ -673,7 +678,7 @@ impl<'a> State<'a> {
} }
self.word("*"); self.word("*");
} }
ast::UseTreeKind::Nested(ref items) => { ast::UseTreeKind::Nested(items) => {
if !tree.prefix.segments.is_empty() { if !tree.prefix.segments.is_empty() {
self.print_path(&tree.prefix, false, 0); self.print_path(&tree.prefix, false, 0);
self.word("::"); self.word("::");