Merging upstream version 1.67.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 284 insertions, 286 deletions

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index b87c6f78d..d3d8431c1 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -11,16 +11,15 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::util::classify;
 use rustc_ast::util::comments::{gather_comments, Comment, CommentStyle};
 use rustc_ast::util::parser;
-use rustc_ast::{self as ast, BlockCheckMode, Mutability, PatKind, RangeEnd, RangeSyntax};
-use rustc_ast::{attr, BindingAnnotation, ByRef, Term};
-use rustc_ast::{GenericArg, MacArgs, MacArgsEq};
-use rustc_ast::{GenericBound, SelfKind, TraitBoundModifier};
+use rustc_ast::{self as ast, AttrArgs, AttrArgsEq, BlockCheckMode, PatKind};
+use rustc_ast::{attr, BindingAnnotation, ByRef, DelimArgs, RangeEnd, RangeSyntax, Term};
+use rustc_ast::{GenericArg, GenericBound, SelfKind, TraitBoundModifier};
 use rustc_ast::{InlineAsmOperand, InlineAsmRegOrRegClass};
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_span::edition::Edition;
 use rustc_span::source_map::{SourceMap, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, IdentPrinter, Symbol};
-use rustc_span::{BytePos, FileName, Span};
+use rustc_span::{BytePos, FileName, Span, DUMMY_SP};
 
 use rustc_ast::attr::AttrIdGenerator;
 use std::borrow::Cow;
@@ -65,6 +64,7 @@ impl<'a> Comments<'a> {
         Comments { sm, comments, current: 0 }
     }
 
+    // FIXME: This shouldn't probably clone lmao
     pub fn next(&self) -> Option<Comment> {
         self.comments.get(self.current).cloned()
     }
@@ -120,17 +120,20 @@ pub fn print_crate<'a>(
         // of the feature gate, so we fake them up here.
 
         // `#![feature(prelude_import)]`
-        let pi_nested = attr::mk_nested_word_item(Ident::with_dummy_span(sym::prelude_import));
-        let list = attr::mk_list_item(Ident::with_dummy_span(sym::feature), vec![pi_nested]);
-        let fake_attr = attr::mk_attr_inner(g, list);
+        let fake_attr = attr::mk_attr_nested_word(
+            g,
+            ast::AttrStyle::Inner,
+            sym::feature,
+            sym::prelude_import,
+            DUMMY_SP,
+        );
         s.print_attribute(&fake_attr);
 
         // Currently, in Rust 2018 we don't have `extern crate std;` at the crate
         // root, so this is not needed, and actually breaks things.
         if edition == Edition::Edition2015 {
             // `#![no_std]`
-            let no_std_meta = attr::mk_word_item(Ident::with_dummy_span(sym::no_std));
-            let fake_attr = attr::mk_attr_inner(g, no_std_meta);
+            let fake_attr = attr::mk_attr_word(g, ast::AttrStyle::Inner, sym::no_std, DUMMY_SP);
             s.print_attribute(&fake_attr);
         }
     }
@@ -269,10 +272,10 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
 
     fn maybe_print_comment(&mut self, pos: BytePos) -> bool {
         let mut has_comment = false;
-        while let Some(ref cmnt) = self.next_comment() {
+        while let Some(cmnt) = self.next_comment() {
             if cmnt.pos < pos {
                 has_comment = true;
-                self.print_comment(cmnt);
+                self.print_comment(&cmnt);
             } else {
                 break;
             }
@@ -367,14 +370,18 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         if self.next_comment().is_none() {
             self.hardbreak();
         }
-        while let Some(ref cmnt) = self.next_comment() {
-            self.print_comment(cmnt)
+        while let Some(cmnt) = self.next_comment() {
+            self.print_comment(&cmnt)
         }
     }
 
-    fn print_literal(&mut self, lit: &ast::Lit) {
-        self.maybe_print_comment(lit.span.lo());
-        self.word(lit.token_lit.to_string())
+    fn print_meta_item_lit(&mut self, lit: &ast::MetaItemLit) {
+        self.print_token_literal(lit.token_lit, lit.span)
+    }
+
+    fn print_token_literal(&mut self, token_lit: token::Lit, span: Span) {
+        self.maybe_print_comment(span.lo());
+        self.word(token_lit.to_string())
     }
 
     fn print_string(&mut self, st: &str, style: ast::StrStyle) {
@@ -443,8 +450,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             self.hardbreak_if_not_bol();
         }
         self.maybe_print_comment(attr.span.lo());
-        match attr.kind {
-            ast::AttrKind::Normal(ref normal) => {
+        match &attr.kind {
+            ast::AttrKind::Normal(normal) => {
                 match attr.style {
                     ast::AttrStyle::Inner => self.word("#!["),
                     ast::AttrStyle::Outer => self.word("#["),
@@ -453,7 +460,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                 self.word("]");
             }
             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()
             }
         }
@@ -462,30 +469,30 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     fn print_attr_item(&mut self, item: &ast::AttrItem, span: Span) {
         self.ibox(0);
         match &item.args {
-            MacArgs::Delimited(_, delim, tokens) => self.print_mac_common(
+            AttrArgs::Delimited(DelimArgs { dspan: _, delim, tokens }) => self.print_mac_common(
                 Some(MacHeader::Path(&item.path)),
                 false,
                 None,
-                Some(delim.to_token()),
+                delim.to_token(),
                 tokens,
                 true,
                 span,
             ),
-            MacArgs::Empty => {
+            AttrArgs::Empty => {
                 self.print_path(&item.path, false, 0);
             }
-            MacArgs::Eq(_, MacArgsEq::Ast(expr)) => {
+            AttrArgs::Eq(_, AttrArgsEq::Ast(expr)) => {
                 self.print_path(&item.path, false, 0);
                 self.space();
                 self.word_space("=");
                 let token_str = self.expr_to_string(expr);
                 self.word(token_str);
             }
-            MacArgs::Eq(_, MacArgsEq::Hir(lit)) => {
+            AttrArgs::Eq(_, AttrArgsEq::Hir(lit)) => {
                 self.print_path(&item.path, false, 0);
                 self.space();
                 self.word_space("=");
-                let token_str = self.literal_to_string(lit);
+                let token_str = self.meta_item_lit_to_string(lit);
                 self.word(token_str);
             }
         }
@@ -494,25 +501,25 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
 
     fn print_meta_list_item(&mut self, item: &ast::NestedMetaItem) {
         match item {
-            ast::NestedMetaItem::MetaItem(ref mi) => self.print_meta_item(mi),
-            ast::NestedMetaItem::Literal(ref lit) => self.print_literal(lit),
+            ast::NestedMetaItem::MetaItem(mi) => self.print_meta_item(mi),
+            ast::NestedMetaItem::Lit(lit) => self.print_meta_item_lit(lit),
         }
     }
 
     fn print_meta_item(&mut self, item: &ast::MetaItem) {
         self.ibox(INDENT_UNIT);
-        match item.kind {
+        match &item.kind {
             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.space();
                 self.word_space("=");
-                self.print_literal(value);
+                self.print_meta_item_lit(value);
             }
-            ast::MetaItemKind::List(ref items) => {
+            ast::MetaItemKind::List(items) => {
                 self.print_path(&item.path, false, 0);
                 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));
                 self.pclose();
             }
         }
@@ -529,7 +536,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     fn print_tt(&mut self, tt: &TokenTree, convert_dollar_crate: bool) {
         match tt {
             TokenTree::Token(token, _) => {
-                let token_str = self.token_to_string_ext(&token, convert_dollar_crate);
+                let token_str = self.token_to_string_ext(token, convert_dollar_crate);
                 self.word(token_str);
                 if let token::DocComment(..) = token.kind {
                     self.hardbreak()
@@ -540,7 +547,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                     None,
                     false,
                     None,
-                    Some(*delim),
+                    *delim,
                     tts,
                     convert_dollar_crate,
                     dspan.entire(),
@@ -566,12 +573,12 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         header: Option<MacHeader<'_>>,
         has_bang: bool,
         ident: Option<Ident>,
-        delim: Option<Delimiter>,
+        delim: Delimiter,
         tts: &TokenStream,
         convert_dollar_crate: bool,
         span: Span,
     ) {
-        if delim == Some(Delimiter::Brace) {
+        if delim == Delimiter::Brace {
             self.cbox(INDENT_UNIT);
         }
         match header {
@@ -587,7 +594,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             self.print_ident(ident);
         }
         match delim {
-            Some(Delimiter::Brace) => {
+            Delimiter::Brace => {
                 if header.is_some() || has_bang || ident.is_some() {
                     self.nbsp();
                 }
@@ -601,7 +608,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                 let empty = tts.is_empty();
                 self.bclose(span, empty);
             }
-            Some(delim) => {
+            delim => {
                 let token_str = self.token_kind_to_string(&token::OpenDelim(delim));
                 self.word(token_str);
                 self.ibox(0);
@@ -610,11 +617,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                 let token_str = self.token_kind_to_string(&token::CloseDelim(delim));
                 self.word(token_str);
             }
-            None => {
-                self.ibox(0);
-                self.print_tts(tts, convert_dollar_crate);
-                self.end();
-            }
         }
     }
 
@@ -635,8 +637,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             Some(MacHeader::Keyword(kw)),
             has_bang,
             Some(*ident),
-            macro_def.body.delim(),
-            &macro_def.body.inner_tokens(),
+            macro_def.body.delim.to_token(),
+            &macro_def.body.tokens.clone(),
             true,
             sp,
         );
@@ -659,7 +661,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) {
         if segment.ident.name != kw::PathRoot {
             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);
             }
         }
@@ -714,19 +716,19 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     }
 
     fn nonterminal_to_string(&self, nt: &Nonterminal) -> String {
-        match *nt {
-            token::NtExpr(ref e) => self.expr_to_string(e),
-            token::NtMeta(ref e) => self.attr_item_to_string(e),
-            token::NtTy(ref e) => self.ty_to_string(e),
-            token::NtPath(ref e) => self.path_to_string(e),
-            token::NtItem(ref e) => self.item_to_string(e),
-            token::NtBlock(ref e) => self.block_to_string(e),
-            token::NtStmt(ref e) => self.stmt_to_string(e),
-            token::NtPat(ref e) => self.pat_to_string(e),
-            token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw).to_string(),
+        match nt {
+            token::NtExpr(e) => self.expr_to_string(e),
+            token::NtMeta(e) => self.attr_item_to_string(e),
+            token::NtTy(e) => self.ty_to_string(e),
+            token::NtPath(e) => self.path_to_string(e),
+            token::NtItem(e) => self.item_to_string(e),
+            token::NtBlock(e) => self.block_to_string(e),
+            token::NtStmt(e) => self.stmt_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::NtLifetime(e) => e.to_string(),
-            token::NtLiteral(ref e) => self.expr_to_string(e),
-            token::NtVis(ref e) => self.vis_to_string(e),
+            token::NtLiteral(e) => self.expr_to_string(e),
+            token::NtVis(e) => self.vis_to_string(e),
         }
     }
 
@@ -827,8 +829,8 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
         Self::to_string(|s| s.print_expr(e))
     }
 
-    fn literal_to_string(&self, lit: &ast::Lit) -> String {
-        Self::to_string(|s| s.print_literal(lit))
+    fn meta_item_lit_to_string(&self, lit: &ast::MetaItemLit) -> String {
+        Self::to_string(|s| s.print_meta_item_lit(lit))
     }
 
     fn tt_to_string(&self, tt: &TokenTree) -> String {
@@ -919,8 +921,8 @@ impl<'a> PrintState<'a> for State<'a> {
             self.word("::")
         }
 
-        match *args {
-            ast::GenericArgs::AngleBracketed(ref data) => {
+        match args {
+            ast::GenericArgs::AngleBracketed(data) => {
                 self.word("<");
                 self.commasep(Inconsistent, &data.args, |s, arg| match arg {
                     ast::AngleBracketedArg::Arg(a) => s.print_generic_arg(a),
@@ -929,7 +931,7 @@ impl<'a> PrintState<'a> for State<'a> {
                 self.word(">")
             }
 
-            ast::GenericArgs::Parenthesized(ref data) => {
+            ast::GenericArgs::Parenthesized(data) => {
                 self.word("(");
                 self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(ty));
                 self.word(")");
@@ -996,7 +998,7 @@ impl<'a> State<'a> {
             ast::AssocConstraintKind::Bound { bounds } => {
                 if !bounds.is_empty() {
                     self.word_nbsp(":");
-                    self.print_type_bounds(&bounds);
+                    self.print_type_bounds(bounds);
                 }
             }
         }
@@ -1013,17 +1015,17 @@ impl<'a> State<'a> {
     pub fn print_type(&mut self, ty: &ast::Ty) {
         self.maybe_print_comment(ty.span.lo());
         self.ibox(0);
-        match ty.kind {
-            ast::TyKind::Slice(ref ty) => {
+        match &ty.kind {
+            ast::TyKind::Slice(ty) => {
                 self.word("[");
                 self.print_type(ty);
                 self.word("]");
             }
-            ast::TyKind::Ptr(ref mt) => {
+            ast::TyKind::Ptr(mt) => {
                 self.word("*");
                 self.print_mt(mt, true);
             }
-            ast::TyKind::Rptr(ref lifetime, ref mt) => {
+            ast::TyKind::Rptr(lifetime, mt) => {
                 self.word("&");
                 self.print_opt_lifetime(lifetime);
                 self.print_mt(mt, false);
@@ -1031,44 +1033,44 @@ impl<'a> State<'a> {
             ast::TyKind::Never => {
                 self.word("!");
             }
-            ast::TyKind::Tup(ref elts) => {
+            ast::TyKind::Tup(elts) => {
                 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 {
                     self.word(",");
                 }
                 self.pclose();
             }
-            ast::TyKind::Paren(ref typ) => {
+            ast::TyKind::Paren(typ) => {
                 self.popen();
                 self.print_type(typ);
                 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);
             }
-            ast::TyKind::Path(None, ref path) => {
+            ast::TyKind::Path(None, path) => {
                 self.print_path(path, false, 0);
             }
-            ast::TyKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, false),
-            ast::TyKind::TraitObject(ref bounds, syntax) => {
-                if syntax == ast::TraitObjectSyntax::Dyn {
+            ast::TyKind::Path(Some(qself), path) => self.print_qpath(path, qself, false),
+            ast::TyKind::TraitObject(bounds, syntax) => {
+                if *syntax == ast::TraitObjectSyntax::Dyn {
                     self.word_nbsp("dyn");
                 }
                 self.print_type_bounds(bounds);
             }
-            ast::TyKind::ImplTrait(_, ref bounds) => {
+            ast::TyKind::ImplTrait(_, bounds) => {
                 self.word_nbsp("impl");
                 self.print_type_bounds(bounds);
             }
-            ast::TyKind::Array(ref ty, ref length) => {
+            ast::TyKind::Array(ty, length) => {
                 self.word("[");
                 self.print_type(ty);
                 self.word("; ");
                 self.print_expr(&length.value);
                 self.word("]");
             }
-            ast::TyKind::Typeof(ref e) => {
+            ast::TyKind::Typeof(e) => {
                 self.word("typeof(");
                 self.print_expr(&e.value);
                 self.word(")");
@@ -1084,7 +1086,7 @@ impl<'a> State<'a> {
             ast::TyKind::ImplicitSelf => {
                 self.word("Self");
             }
-            ast::TyKind::MacCall(ref m) => {
+            ast::TyKind::MacCall(m) => {
                 self.print_mac(m);
             }
             ast::TyKind::CVarArgs => {
@@ -1113,8 +1115,8 @@ impl<'a> State<'a> {
 
     pub(crate) fn print_stmt(&mut self, st: &ast::Stmt) {
         self.maybe_print_comment(st.span.lo());
-        match st.kind {
-            ast::StmtKind::Local(ref loc) => {
+        match &st.kind {
+            ast::StmtKind::Local(loc) => {
                 self.print_outer_attributes(&loc.attrs);
                 self.space_if_not_bol();
                 self.ibox(INDENT_UNIT);
@@ -1137,15 +1139,15 @@ impl<'a> State<'a> {
                 self.word(";");
                 self.end(); // `let` ibox
             }
-            ast::StmtKind::Item(ref item) => self.print_item(item),
-            ast::StmtKind::Expr(ref expr) => {
+            ast::StmtKind::Item(item) => self.print_item(item),
+            ast::StmtKind::Expr(expr) => {
                 self.space_if_not_bol();
                 self.print_expr_outer_attr_style(expr, false);
                 if classify::expr_requires_semi_to_be_stmt(expr) {
                     self.word(";");
                 }
             }
-            ast::StmtKind::Semi(ref expr) => {
+            ast::StmtKind::Semi(expr) => {
                 self.space_if_not_bol();
                 self.print_expr_outer_attr_style(expr, false);
                 self.word(";");
@@ -1154,7 +1156,7 @@ impl<'a> State<'a> {
                 self.space_if_not_bol();
                 self.word(";");
             }
-            ast::StmtKind::MacCall(ref mac) => {
+            ast::StmtKind::MacCall(mac) => {
                 self.space_if_not_bol();
                 self.print_outer_attributes(&mac.attrs);
                 self.print_mac(&mac.mac);
@@ -1195,8 +1197,8 @@ impl<'a> State<'a> {
         let has_attrs = self.print_inner_attributes(attrs);
 
         for (i, st) in blk.stmts.iter().enumerate() {
-            match st.kind {
-                ast::StmtKind::Expr(ref expr) if i == blk.stmts.len() - 1 => {
+            match &st.kind {
+                ast::StmtKind::Expr(expr) if i == blk.stmts.len() - 1 => {
                     self.maybe_print_comment(st.span.lo());
                     self.space_if_not_bol();
                     self.print_expr_outer_attr_style(expr, false);
@@ -1226,8 +1228,8 @@ impl<'a> State<'a> {
             Some(MacHeader::Path(&m.path)),
             true,
             None,
-            m.args.delim(),
-            &m.args.inner_tokens(),
+            m.args.delim.to_token(),
+            &m.args.tokens.clone(),
             true,
             m.span(),
         );
@@ -1252,7 +1254,7 @@ impl<'a> State<'a> {
 
         self.popen();
         self.commasep(Consistent, &args, |s, arg| match arg {
-            AsmArg::Template(template) => s.print_string(&template, ast::StrStyle::Cooked),
+            AsmArg::Template(template) => s.print_string(template, ast::StrStyle::Cooked),
             AsmArg::Operand(op) => {
                 let print_reg_or_class = |s: &mut Self, r: &InlineAsmRegOrRegClass| match r {
                     InlineAsmRegOrRegClass::Reg(r) => s.print_symbol(*r, ast::StrStyle::Cooked),
@@ -1364,7 +1366,7 @@ impl<'a> State<'a> {
 
     pub(crate) fn print_local_decl(&mut self, loc: &ast::Local) {
         self.print_pat(&loc.pat);
-        if let Some(ref ty) = loc.ty {
+        if let Some(ty) = &loc.ty {
             self.word_space(":");
             self.print_type(ty);
         }
@@ -1388,7 +1390,7 @@ impl<'a> State<'a> {
         for item_segment in &path.segments[qself.position..] {
             self.word("::");
             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)
             }
         }
@@ -1399,42 +1401,42 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::Pat(pat));
         /* Pat isn't normalized, but the beauty of it
         is that it doesn't matter */
-        match pat.kind {
+        match &pat.kind {
             PatKind::Wild => self.word("_"),
-            PatKind::Ident(BindingAnnotation(by_ref, mutbl), ident, ref sub) => {
-                if by_ref == ByRef::Yes {
+            PatKind::Ident(BindingAnnotation(by_ref, mutbl), ident, sub) => {
+                if *by_ref == ByRef::Yes {
                     self.word_nbsp("ref");
                 }
-                if mutbl == Mutability::Mut {
+                if mutbl.is_mut() {
                     self.word_nbsp("mut");
                 }
-                self.print_ident(ident);
-                if let Some(ref p) = *sub {
+                self.print_ident(*ident);
+                if let Some(p) = sub {
                     self.space();
                     self.word_space("@");
                     self.print_pat(p);
                 }
             }
-            PatKind::TupleStruct(ref qself, ref path, ref elts) => {
+            PatKind::TupleStruct(qself, path, elts) => {
                 if let Some(qself) = qself {
                     self.print_qpath(path, qself, true);
                 } else {
                     self.print_path(path, true, 0);
                 }
                 self.popen();
-                self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
+                self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
                 self.pclose();
             }
-            PatKind::Or(ref pats) => {
-                self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(p));
+            PatKind::Or(pats) => {
+                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);
             }
-            PatKind::Path(Some(ref qself), ref path) => {
+            PatKind::Path(Some(qself), path) => {
                 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 {
                     self.print_qpath(path, qself, true);
                 } else {
@@ -1448,7 +1450,7 @@ impl<'a> State<'a> {
                 }
                 self.commasep_cmnt(
                     Consistent,
-                    &fields,
+                    fields,
                     |s, f| {
                         s.cbox(INDENT_UNIT);
                         if !f.is_shorthand {
@@ -1460,7 +1462,7 @@ impl<'a> State<'a> {
                     },
                     |f| f.pat.span,
                 );
-                if etc {
+                if *etc {
                     if !fields.is_empty() {
                         self.word_space(",");
                     }
@@ -1471,21 +1473,21 @@ impl<'a> State<'a> {
                 }
                 self.word("}");
             }
-            PatKind::Tuple(ref elts) => {
+            PatKind::Tuple(elts) => {
                 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 {
                     self.word(",");
                 }
                 self.pclose();
             }
-            PatKind::Box(ref inner) => {
+            PatKind::Box(inner) => {
                 self.word("box ");
                 self.print_pat(inner);
             }
-            PatKind::Ref(ref inner, mutbl) => {
+            PatKind::Ref(inner, mutbl) => {
                 self.word("&");
-                if mutbl == Mutability::Mut {
+                if mutbl.is_mut() {
                     self.word("mut ");
                 }
                 if let PatKind::Ident(ast::BindingAnnotation::MUT, ..) = inner.kind {
@@ -1496,12 +1498,12 @@ impl<'a> State<'a> {
                     self.print_pat(inner);
                 }
             }
-            PatKind::Lit(ref e) => self.print_expr(&**e),
-            PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => {
+            PatKind::Lit(e) => self.print_expr(e),
+            PatKind::Range(begin, end, Spanned { node: end_kind, .. }) => {
                 if let Some(e) = begin {
                     self.print_expr(e);
                 }
-                match *end_kind {
+                match end_kind {
                     RangeEnd::Included(RangeSyntax::DotDotDot) => self.word("..."),
                     RangeEnd::Included(RangeSyntax::DotDotEq) => self.word("..="),
                     RangeEnd::Excluded => self.word(".."),
@@ -1510,36 +1512,36 @@ impl<'a> State<'a> {
                     self.print_expr(e);
                 }
             }
-            PatKind::Slice(ref elts) => {
+            PatKind::Slice(elts) => {
                 self.word("[");
-                self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
+                self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
                 self.word("]");
             }
             PatKind::Rest => self.word(".."),
-            PatKind::Paren(ref inner) => {
+            PatKind::Paren(inner) => {
                 self.popen();
                 self.print_pat(inner);
                 self.pclose();
             }
-            PatKind::MacCall(ref m) => self.print_mac(m),
+            PatKind::MacCall(m) => self.print_mac(m),
         }
         self.ann.post(self, AnnNode::Pat(pat))
     }
 
     fn print_explicit_self(&mut self, explicit_self: &ast::ExplicitSelf) {
-        match explicit_self.node {
+        match &explicit_self.node {
             SelfKind::Value(m) => {
-                self.print_mutability(m, false);
+                self.print_mutability(*m, false);
                 self.word("self")
             }
-            SelfKind::Region(ref lt, m) => {
+            SelfKind::Region(lt, m) => {
                 self.word("&");
                 self.print_opt_lifetime(lt);
-                self.print_mutability(m, false);
+                self.print_mutability(*m, false);
                 self.word("self")
             }
-            SelfKind::Explicit(ref typ, m) => {
-                self.print_mutability(m, false);
+            SelfKind::Explicit(typ, m) => {
+                self.print_mutability(*m, false);
                 self.word("self");
                 self.word_space(":");
                 self.print_type(typ)
@@ -1598,10 +1600,10 @@ impl<'a> State<'a> {
 
         self.word("<");
 
-        self.commasep(Inconsistent, &generic_params, |s, param| {
+        self.commasep(Inconsistent, generic_params, |s, param| {
             s.print_outer_attributes_inline(&param.attrs);
 
-            match param.kind {
+            match &param.kind {
                 ast::GenericParamKind::Lifetime => {
                     let lt = ast::Lifetime { id: param.id, ident: param.ident };
                     s.print_lifetime(lt);
@@ -1610,19 +1612,19 @@ impl<'a> State<'a> {
                         s.print_lifetime_bounds(&param.bounds)
                     }
                 }
-                ast::GenericParamKind::Type { ref default } => {
+                ast::GenericParamKind::Type { default } => {
                     s.print_ident(param.ident);
                     if !param.bounds.is_empty() {
                         s.word_nbsp(":");
                         s.print_type_bounds(&param.bounds);
                     }
-                    if let Some(ref default) = default {
+                    if let Some(default) = default {
                         s.space();
                         s.word_space("=");
                         s.print_type(default)
                     }
                 }
-                ast::GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
+                ast::GenericParamKind::Const { ty, default, .. } => {
                     s.word_space("const");
                     s.print_ident(param.ident);
                     s.space();
@@ -1632,7 +1634,7 @@ impl<'a> State<'a> {
                         s.word_nbsp(":");
                         s.print_type_bounds(&param.bounds);
                     }
-                    if let Some(ref default) = default {
+                    if let Some(default) = default {
                         s.space();
                         s.word_space("=");
                         s.print_expr(&default.value);
@@ -1714,9 +1716,9 @@ impl<'a> State<'a> {
             where_clause: ast::WhereClause {
                 has_where_token: false,
                 predicates: Vec::new(),
-                span: rustc_span::DUMMY_SP,
+                span: DUMMY_SP,
             },
-            span: rustc_span::DUMMY_SP,
+            span: DUMMY_SP,
         };
         let header = ast::FnHeader { unsafety, ext, ..ast::FnHeader::default() };
         self.print_fn(decl, header, name, &generics);
@@ -1735,7 +1737,7 @@ impl<'a> State<'a> {
             }
             ast::Extern::Explicit(abi, _) => {
                 self.word_nbsp("extern");
-                self.print_literal(&abi.as_lit());
+                self.print_token_literal(abi.as_token_lit(), abi.span);
                 self.nbsp();
             }
         }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index bcefa8ce0..4ed16e337 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -8,9 +8,9 @@ use rustc_ast::{self as ast, BlockCheckMode};
 impl<'a> State<'a> {
     fn print_else(&mut self, els: Option<&ast::Expr>) {
         if let Some(_else) = els {
-            match _else.kind {
+            match &_else.kind {
                 // 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.ibox(0);
                     self.word(" else if ");
@@ -20,7 +20,7 @@ impl<'a> State<'a> {
                     self.print_else(e.as_deref())
                 }
                 // Final `else` block.
-                ast::ExprKind::Block(ref b, _) => {
+                ast::ExprKind::Block(b, _) => {
                     self.cbox(INDENT_UNIT - 1);
                     self.ibox(0);
                     self.word(" else ");
@@ -58,10 +58,10 @@ impl<'a> State<'a> {
         self.print_expr_cond_paren(expr, Self::cond_needs_par(expr))
     }
 
-    // Does `expr` need parentheses when printed in a condition position?
-    //
-    // These cases need parens due to the parse error observed in #26461: `if return {}`
-    // parses as the erroneous construct `if (return {})`, not `if (return) {}`.
+    /// Does `expr` need parentheses when printed in a condition position?
+    ///
+    /// These cases need parens due to the parse error observed in #26461: `if return {}`
+    /// parses as the erroneous construct `if (return {})`, not `if (return) {}`.
     pub(super) fn cond_needs_par(expr: &ast::Expr) -> bool {
         match expr.kind {
             ast::ExprKind::Break(..)
@@ -121,7 +121,7 @@ impl<'a> State<'a> {
 
     fn print_expr_struct(
         &mut self,
-        qself: &Option<ast::QSelf>,
+        qself: &Option<P<ast::QSelf>>,
         path: &ast::Path,
         fields: &[ast::ExprField],
         rest: &ast::StructRest,
@@ -202,7 +202,7 @@ impl<'a> State<'a> {
         self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX);
         self.word(".");
         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_call_post(base_args)
@@ -284,64 +284,66 @@ impl<'a> State<'a> {
 
         self.ibox(INDENT_UNIT);
         self.ann.pre(self, AnnNode::Expr(expr));
-        match expr.kind {
-            ast::ExprKind::Box(ref expr) => {
+        match &expr.kind {
+            ast::ExprKind::Box(expr) => {
                 self.word_space("box");
                 self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
             }
-            ast::ExprKind::Array(ref exprs) => {
+            ast::ExprKind::Array(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);
             }
-            ast::ExprKind::Repeat(ref element, ref count) => {
+            ast::ExprKind::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);
             }
-            ast::ExprKind::Tup(ref exprs) => {
+            ast::ExprKind::Tup(exprs) => {
                 self.print_expr_tup(exprs);
             }
-            ast::ExprKind::Call(ref func, ref args) => {
-                self.print_expr_call(func, &args);
+            ast::ExprKind::Call(func, args) => {
+                self.print_expr_call(func, args);
+            }
+            ast::ExprKind::MethodCall(box ast::MethodCall { seg, receiver, args, .. }) => {
+                self.print_expr_method_call(seg, receiver, args);
             }
-            ast::ExprKind::MethodCall(ref segment, ref receiver, ref args, _) => {
-                self.print_expr_method_call(segment, &receiver, &args);
+            ast::ExprKind::Binary(op, lhs, rhs) => {
+                self.print_expr_binary(*op, lhs, rhs);
             }
-            ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
-                self.print_expr_binary(op, lhs, rhs);
+            ast::ExprKind::Unary(op, expr) => {
+                self.print_expr_unary(*op, expr);
             }
-            ast::ExprKind::Unary(op, ref expr) => {
-                self.print_expr_unary(op, expr);
+            ast::ExprKind::AddrOf(k, m, expr) => {
+                self.print_expr_addr_of(*k, *m, expr);
             }
-            ast::ExprKind::AddrOf(k, m, ref expr) => {
-                self.print_expr_addr_of(k, m, expr);
+            ast::ExprKind::Lit(token_lit) => {
+                self.print_token_literal(*token_lit, expr.span);
             }
-            ast::ExprKind::Lit(ref lit) => {
-                self.print_literal(lit);
+            ast::ExprKind::IncludedBytes(bytes) => {
+                let lit = ast::LitKind::ByteStr(bytes.clone()).to_token_lit();
+                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;
                 self.print_expr_maybe_paren(expr, prec);
                 self.space();
                 self.word_space("as");
                 self.print_type(ty);
             }
-            ast::ExprKind::Type(ref expr, ref ty) => {
+            ast::ExprKind::Type(expr, ty) => {
                 let prec = AssocOp::Colon.precedence() as i8;
                 self.print_expr_maybe_paren(expr, prec);
                 self.word_space(":");
                 self.print_type(ty);
             }
-            ast::ExprKind::Let(ref pat, ref scrutinee, _) => {
+            ast::ExprKind::Let(pat, scrutinee, _) => {
                 self.print_let(pat, scrutinee);
             }
-            ast::ExprKind::If(ref test, ref blk, ref elseopt) => {
-                self.print_if(test, blk, elseopt.as_deref())
-            }
-            ast::ExprKind::While(ref test, ref blk, opt_label) => {
+            ast::ExprKind::If(test, blk, elseopt) => self.print_if(test, blk, elseopt.as_deref()),
+            ast::ExprKind::While(test, blk, opt_label) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
                     self.word_space(":");
@@ -353,7 +355,7 @@ impl<'a> State<'a> {
                 self.space();
                 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 {
                     self.print_ident(label.ident);
                     self.word_space(":");
@@ -368,7 +370,7 @@ impl<'a> State<'a> {
                 self.space();
                 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 {
                     self.print_ident(label.ident);
                     self.word_space(":");
@@ -378,7 +380,7 @@ impl<'a> State<'a> {
                 self.word_nbsp("loop");
                 self.print_block_with_attrs(blk, attrs);
             }
-            ast::ExprKind::Match(ref expr, ref arms) => {
+            ast::ExprKind::Match(expr, arms) => {
                 self.cbox(0);
                 self.ibox(0);
                 self.word_nbsp("match");
@@ -392,21 +394,22 @@ impl<'a> State<'a> {
                 let empty = attrs.is_empty() && arms.is_empty();
                 self.bclose(expr.span, empty);
             }
-            ast::ExprKind::Closure(
-                ref binder,
+            ast::ExprKind::Closure(box ast::Closure {
+                binder,
                 capture_clause,
                 asyncness,
                 movability,
-                ref decl,
-                ref body,
-                _,
-            ) => {
+                fn_decl,
+                body,
+                fn_decl_span: _,
+                fn_arg_span: _,
+            }) => {
                 self.print_closure_binder(binder);
-                self.print_movability(movability);
-                self.print_asyncness(asyncness);
-                self.print_capture_clause(capture_clause);
+                self.print_movability(*movability);
+                self.print_asyncness(*asyncness);
+                self.print_capture_clause(*capture_clause);
 
-                self.print_fn_params_and_ret(decl, true);
+                self.print_fn_params_and_ret(fn_decl, true);
                 self.space();
                 self.print_expr(body);
                 self.end(); // need to close a box
@@ -416,7 +419,7 @@ impl<'a> State<'a> {
                 // empty box to satisfy the close.
                 self.ibox(0);
             }
-            ast::ExprKind::Block(ref blk, opt_label) => {
+            ast::ExprKind::Block(blk, opt_label) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
                     self.word_space(":");
@@ -427,26 +430,26 @@ impl<'a> State<'a> {
                 self.ibox(0);
                 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.print_capture_clause(capture_clause);
+                self.print_capture_clause(*capture_clause);
                 // cbox/ibox in analogy to the `ExprKind::Block` arm above
                 self.cbox(0);
                 self.ibox(0);
                 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.word(".await");
             }
-            ast::ExprKind::Assign(ref lhs, ref rhs, _) => {
+            ast::ExprKind::Assign(lhs, rhs, _) => {
                 let prec = AssocOp::Assign.precedence() as i8;
                 self.print_expr_maybe_paren(lhs, prec + 1);
                 self.space();
                 self.word_space("=");
                 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;
                 self.print_expr_maybe_paren(lhs, prec + 1);
                 self.space();
@@ -454,45 +457,44 @@ impl<'a> State<'a> {
                 self.word_space("=");
                 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.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.word("[");
                 self.print_expr(index);
                 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
                 // 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
                 // a "normal" binop gets parenthesized.  (`LOr` is the lowest-precedence binop.)
                 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);
                 }
-                if limits == ast::RangeLimits::HalfOpen {
-                    self.word("..");
-                } else {
-                    self.word("..=");
+                match limits {
+                    ast::RangeLimits::HalfOpen => self.word(".."),
+                    ast::RangeLimits::Closed => self.word("..="),
                 }
-                if let Some(ref e) = *end {
+                if let Some(e) = end {
                     self.print_expr_maybe_paren(e, fake_prec);
                 }
             }
             ast::ExprKind::Underscore => self.word("_"),
-            ast::ExprKind::Path(None, ref path) => self.print_path(path, true, 0),
-            ast::ExprKind::Path(Some(ref qself), ref path) => self.print_qpath(path, qself, true),
-            ast::ExprKind::Break(opt_label, ref opt_expr) => {
+            ast::ExprKind::Path(None, path) => self.print_path(path, true, 0),
+            ast::ExprKind::Path(Some(qself), path) => self.print_qpath(path, qself, true),
+            ast::ExprKind::Break(opt_label, opt_expr) => {
                 self.word("break");
                 if let Some(label) = opt_label {
                     self.space();
                     self.print_ident(label.ident);
                 }
-                if let Some(ref expr) = *opt_expr {
+                if let Some(expr) = opt_expr {
                     self.space();
                     self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
                 }
@@ -504,45 +506,45 @@ impl<'a> State<'a> {
                     self.print_ident(label.ident);
                 }
             }
-            ast::ExprKind::Ret(ref result) => {
+            ast::ExprKind::Ret(result) => {
                 self.word("return");
-                if let Some(ref expr) = *result {
+                if let Some(expr) = result {
                     self.word(" ");
                     self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
                 }
             }
-            ast::ExprKind::Yeet(ref result) => {
+            ast::ExprKind::Yeet(result) => {
                 self.word("do");
                 self.word(" ");
                 self.word("yeet");
-                if let Some(ref expr) = *result {
+                if let Some(expr) = result {
                     self.word(" ");
                     self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
                 }
             }
-            ast::ExprKind::InlineAsm(ref a) => {
+            ast::ExprKind::InlineAsm(a) => {
                 self.word("asm!");
                 self.print_inline_asm(a);
             }
-            ast::ExprKind::MacCall(ref m) => self.print_mac(m),
-            ast::ExprKind::Paren(ref e) => {
+            ast::ExprKind::MacCall(m) => self.print_mac(m),
+            ast::ExprKind::Paren(e) => {
                 self.popen();
                 self.print_expr(e);
                 self.pclose();
             }
-            ast::ExprKind::Yield(ref e) => {
+            ast::ExprKind::Yield(e) => {
                 self.word("yield");
 
-                if let Some(ref expr) = *e {
+                if let Some(expr) = e {
                     self.space();
                     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.word("?")
             }
-            ast::ExprKind::TryBlock(ref blk) => {
+            ast::ExprKind::TryBlock(blk) => {
                 self.cbox(0);
                 self.ibox(0);
                 self.word_nbsp("try");
@@ -569,15 +571,15 @@ impl<'a> State<'a> {
         self.print_outer_attributes(&arm.attrs);
         self.print_pat(&arm.pat);
         self.space();
-        if let Some(ref e) = arm.guard {
+        if let Some(e) = &arm.guard {
             self.word_space("if");
             self.print_expr(e);
             self.space();
         }
         self.word_space("=>");
 
-        match arm.body.kind {
-            ast::ExprKind::Block(ref blk, opt_label) => {
+        match &arm.body.kind {
+            ast::ExprKind::Block(blk, opt_label) => {
                 if let Some(label) = opt_label {
                     self.print_ident(label.ident);
                     self.word_space(":");
@@ -604,7 +606,7 @@ impl<'a> State<'a> {
         match binder {
             ast::ClosureBinder::NotPresent => {}
             ast::ClosureBinder::For { generic_params, .. } => {
-                self.print_formal_generic_params(&generic_params)
+                self.print_formal_generic_params(generic_params)
             }
         }
     }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
index 159853c9e..5b6a07721 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/item.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -136,10 +136,10 @@ impl<'a> State<'a> {
         self.maybe_print_comment(item.span.lo());
         self.print_outer_attributes(&item.attrs);
         self.ann.pre(self, AnnNode::Item(item));
-        match item.kind {
+        match &item.kind {
             ast::ItemKind::ExternCrate(orig_name) => {
                 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.space();
                     self.word("as");
@@ -150,35 +150,41 @@ impl<'a> State<'a> {
                 self.end(); // end inner head-block
                 self.end(); // end outer head-block
             }
-            ast::ItemKind::Use(ref tree) => {
+            ast::ItemKind::Use(tree) => {
                 self.print_visibility(&item.vis);
                 self.word_nbsp("use");
                 self.print_use_tree(tree);
                 self.word(";");
             }
-            ast::ItemKind::Static(ref ty, mutbl, ref body) => {
+            ast::ItemKind::Static(ty, mutbl, body) => {
                 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) => {
-                self.print_item_const(item.ident, None, ty, body.as_deref(), &item.vis, def);
+            ast::ItemKind::Const(def, ty, body) => {
+                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 }) => {
-                let body = body.as_deref();
+            ast::ItemKind::Fn(box ast::Fn { defaultness, sig, generics, body }) => {
                 self.print_fn_full(
                     sig,
                     item.ident,
                     generics,
                     &item.vis,
-                    defaultness,
-                    body,
+                    *defaultness,
+                    body.as_deref(),
                     &item.attrs,
                 );
             }
-            ast::ItemKind::Mod(unsafety, ref mod_kind) => {
+            ast::ItemKind::Mod(unsafety, mod_kind) => {
                 self.head(Self::to_string(|s| {
                     s.print_visibility(&item.vis);
-                    s.print_unsafety(unsafety);
+                    s.print_unsafety(*unsafety);
                     s.word("mod");
                 }));
                 self.print_ident(item.ident);
@@ -201,13 +207,13 @@ impl<'a> State<'a> {
                     }
                 }
             }
-            ast::ItemKind::ForeignMod(ref nmod) => {
+            ast::ItemKind::ForeignMod(nmod) => {
                 self.head(Self::to_string(|s| {
                     s.print_unsafety(nmod.unsafety);
                     s.word("extern");
                 }));
                 if let Some(abi) = nmod.abi {
-                    self.print_literal(&abi.as_lit());
+                    self.print_token_literal(abi.as_token_lit(), abi.span);
                     self.nbsp();
                 }
                 self.bopen();
@@ -215,7 +221,7 @@ impl<'a> State<'a> {
                 let empty = item.attrs.is_empty() && nmod.items.is_empty();
                 self.bclose(item.span, empty);
             }
-            ast::ItemKind::GlobalAsm(ref asm) => {
+            ast::ItemKind::GlobalAsm(asm) => {
                 self.head(visibility_qualified(&item.vis, "global_asm!"));
                 self.print_inline_asm(asm);
                 self.word(";");
@@ -224,32 +230,31 @@ impl<'a> State<'a> {
             }
             ast::ItemKind::TyAlias(box ast::TyAlias {
                 defaultness,
-                ref generics,
+                generics,
                 where_clauses,
                 where_predicates_split,
-                ref bounds,
-                ref ty,
+                bounds,
+                ty,
             }) => {
-                let ty = ty.as_deref();
                 self.print_associated_type(
                     item.ident,
                     generics,
-                    where_clauses,
-                    where_predicates_split,
+                    *where_clauses,
+                    *where_predicates_split,
                     bounds,
-                    ty,
+                    ty.as_deref(),
                     &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);
             }
-            ast::ItemKind::Struct(ref struct_def, ref generics) => {
+            ast::ItemKind::Struct(struct_def, generics) => {
                 self.head(visibility_qualified(&item.vis, "struct"));
                 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.print_struct(struct_def, generics, item.ident, item.span, true);
             }
@@ -258,15 +263,15 @@ impl<'a> State<'a> {
                 polarity,
                 defaultness,
                 constness,
-                ref generics,
-                ref of_trait,
-                ref self_ty,
-                ref items,
+                generics,
+                of_trait,
+                self_ty,
+                items,
             }) => {
                 self.head("");
                 self.print_visibility(&item.vis);
-                self.print_defaultness(defaultness);
-                self.print_unsafety(unsafety);
+                self.print_defaultness(*defaultness);
+                self.print_unsafety(*unsafety);
                 self.word("impl");
 
                 if generics.params.is_empty() {
@@ -276,13 +281,13 @@ impl<'a> State<'a> {
                     self.space();
                 }
 
-                self.print_constness(constness);
+                self.print_constness(*constness);
 
                 if let ast::ImplPolarity::Negative(_) = polarity {
                     self.word("!");
                 }
 
-                if let Some(ref t) = *of_trait {
+                if let Some(t) = of_trait {
                     self.print_trait_ref(t);
                     self.space();
                     self.word_space("for");
@@ -303,21 +308,21 @@ impl<'a> State<'a> {
             ast::ItemKind::Trait(box ast::Trait {
                 is_auto,
                 unsafety,
-                ref generics,
-                ref bounds,
-                ref items,
+                generics,
+                bounds,
+                items,
                 ..
             }) => {
                 self.head("");
                 self.print_visibility(&item.vis);
-                self.print_unsafety(unsafety);
-                self.print_is_auto(is_auto);
+                self.print_unsafety(*unsafety);
+                self.print_is_auto(*is_auto);
                 self.word_nbsp("trait");
                 self.print_ident(item.ident);
                 self.print_generic_params(&generics.params);
                 let mut real_bounds = Vec::with_capacity(bounds.len());
                 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.word_space("for ?");
                         self.print_trait_ref(&ptr.trait_ref);
@@ -339,38 +344,27 @@ impl<'a> State<'a> {
                 let empty = item.attrs.is_empty() && items.is_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.print_ident(item.ident);
                 self.print_generic_params(&generics.params);
-                let mut real_bounds = Vec::with_capacity(bounds.len());
-                // FIXME(durka) this seems to be some quite outdated syntax
-                for b in bounds.iter() {
-                    if let GenericBound::Trait(ref ptr, ast::TraitBoundModifier::Maybe) = *b {
-                        self.space();
-                        self.word_space("for ?");
-                        self.print_trait_ref(&ptr.trait_ref);
-                    } else {
-                        real_bounds.push(b.clone());
-                    }
-                }
                 self.nbsp();
-                if !real_bounds.is_empty() {
+                if !bounds.is_empty() {
                     self.word_nbsp("=");
-                    self.print_type_bounds(&real_bounds);
+                    self.print_type_bounds(&bounds);
                 }
                 self.print_where_clause(&generics.where_clause);
                 self.word(";");
                 self.end(); // end inner head-block
                 self.end(); // end outer head-block
             }
-            ast::ItemKind::MacCall(ref mac) => {
+            ast::ItemKind::MacCall(mac) => {
                 self.print_mac(mac);
                 if mac.args.need_semicolon() {
                     self.word(";");
                 }
             }
-            ast::ItemKind::MacroDef(ref macro_def) => {
+            ast::ItemKind::MacroDef(macro_def) => {
                 self.print_mac_def(macro_def, &item.ident, item.span, |state| {
                     state.print_visibility(&item.vis)
                 });
@@ -412,11 +406,11 @@ impl<'a> State<'a> {
     }
 
     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::Restricted { ref path, id: _, shorthand } => {
+            ast::VisibilityKind::Restricted { path, shorthand, .. } => {
                 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))
                 } else {
                     self.word_nbsp(format!("pub(in {})", path))
@@ -465,7 +459,7 @@ impl<'a> State<'a> {
     ) {
         self.print_ident(ident);
         self.print_generic_params(&generics.params);
-        match struct_def {
+        match &struct_def {
             ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
                 if let ast::VariantData::Tuple(..) = struct_def {
                     self.popen();
@@ -484,7 +478,7 @@ impl<'a> State<'a> {
                 self.end();
                 self.end(); // Close the outer-box.
             }
-            ast::VariantData::Struct(ref fields, ..) => {
+            ast::VariantData::Struct(fields, ..) => {
                 self.print_where_clause(&generics.where_clause);
                 self.print_record_struct_body(fields, span);
             }
@@ -496,7 +490,7 @@ impl<'a> State<'a> {
         self.print_visibility(&v.vis);
         let generics = ast::Generics::default();
         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.word_space("=");
             self.print_expr(&d.value)
@@ -657,10 +651,10 @@ impl<'a> State<'a> {
     }
 
     fn print_use_tree(&mut self, tree: &ast::UseTree) {
-        match tree.kind {
-            ast::UseTreeKind::Simple(rename, ..) => {
+        match &tree.kind {
+            ast::UseTreeKind::Simple(rename) => {
                 self.print_path(&tree.prefix, false, 0);
-                if let Some(rename) = rename {
+                if let &Some(rename) = rename {
                     self.nbsp();
                     self.word_nbsp("as");
                     self.print_ident(rename);
@@ -673,7 +667,7 @@ impl<'a> State<'a> {
                 }
                 self.word("*");
             }
-            ast::UseTreeKind::Nested(ref items) => {
+            ast::UseTreeKind::Nested(items) => {
                 if !tree.prefix.segments.is_empty() {
                     self.print_path(&tree.prefix, false, 0);
                     self.word("::");