Skip to content

Commit 46ccde4

Browse files
kadiwa4kadiwa4
committedJul 3, 2022
clean up the borrowing in rustc_hir_pretty
a lot of the `&`s and `ref`s were redundant
·
1.86.01.64.0
1 parent b04bfb4 commit 46ccde4

File tree

1 file changed

+264
-281
lines changed
  • compiler/rustc_hir_pretty/src

1 file changed

+264
-281
lines changed
 

‎compiler/rustc_hir_pretty/src/lib.rs

+264-281
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ impl PpAnn for &dyn rustc_hir::intravisit::Map<'_> {
5959
Nested::ImplItem(id) => state.print_impl_item(self.impl_item(id)),
6060
Nested::ForeignItem(id) => state.print_foreign_item(self.foreign_item(id)),
6161
Nested::Body(id) => state.print_expr(&self.body(id).value),
62-
Nested::BodyParamPat(id, i) => state.print_pat(&self.body(id).params[i].pat),
62+
Nested::BodyParamPat(id, i) => state.print_pat(self.body(id).params[i].pat),
6363
}
6464
}
6565
}
@@ -74,37 +74,37 @@ pub struct State<'a> {
7474
impl<'a> State<'a> {
7575
pub fn print_node(&mut self, node: Node<'_>) {
7676
match node {
77-
Node::Param(a) => self.print_param(&a),
78-
Node::Item(a) => self.print_item(&a),
79-
Node::ForeignItem(a) => self.print_foreign_item(&a),
77+
Node::Param(a) => self.print_param(a),
78+
Node::Item(a) => self.print_item(a),
79+
Node::ForeignItem(a) => self.print_foreign_item(a),
8080
Node::TraitItem(a) => self.print_trait_item(a),
8181
Node::ImplItem(a) => self.print_impl_item(a),
82-
Node::Variant(a) => self.print_variant(&a),
83-
Node::AnonConst(a) => self.print_anon_const(&a),
84-
Node::Expr(a) => self.print_expr(&a),
85-
Node::Stmt(a) => self.print_stmt(&a),
86-
Node::PathSegment(a) => self.print_path_segment(&a),
87-
Node::Ty(a) => self.print_type(&a),
88-
Node::TypeBinding(a) => self.print_type_binding(&a),
89-
Node::TraitRef(a) => self.print_trait_ref(&a),
90-
Node::Pat(a) => self.print_pat(&a),
91-
Node::Arm(a) => self.print_arm(&a),
82+
Node::Variant(a) => self.print_variant(a),
83+
Node::AnonConst(a) => self.print_anon_const(a),
84+
Node::Expr(a) => self.print_expr(a),
85+
Node::Stmt(a) => self.print_stmt(a),
86+
Node::PathSegment(a) => self.print_path_segment(a),
87+
Node::Ty(a) => self.print_type(a),
88+
Node::TypeBinding(a) => self.print_type_binding(a),
89+
Node::TraitRef(a) => self.print_trait_ref(a),
90+
Node::Pat(a) => self.print_pat(a),
91+
Node::Arm(a) => self.print_arm(a),
9292
Node::Infer(_) => self.word("_"),
9393
Node::Block(a) => {
9494
// Containing cbox, will be closed by print-block at `}`.
9595
self.cbox(INDENT_UNIT);
9696
// Head-ibox, will be closed by print-block after `{`.
9797
self.ibox(0);
98-
self.print_block(&a)
98+
self.print_block(a);
9999
}
100-
Node::Lifetime(a) => self.print_lifetime(&a),
100+
Node::Lifetime(a) => self.print_lifetime(a),
101101
Node::GenericParam(_) => panic!("cannot print Node::GenericParam"),
102102
Node::Field(_) => panic!("cannot print Node::Field"),
103103
// These cases do not carry enough information in the
104104
// `hir_map` to reconstruct their full structure for pretty
105105
// printing.
106106
Node::Ctor(..) => panic!("cannot print isolated Ctor"),
107-
Node::Local(a) => self.print_local_decl(&a),
107+
Node::Local(a) => self.print_local_decl(a),
108108
Node::Crate(..) => panic!("cannot print Crate"),
109109
}
110110
}
@@ -266,7 +266,7 @@ impl<'a> State<'a> {
266266
}
267267

268268
pub fn commasep_exprs(&mut self, b: Breaks, exprs: &[hir::Expr<'_>]) {
269-
self.commasep_cmnt(b, exprs, |s, e| s.print_expr(&e), |e| e.span)
269+
self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span);
270270
}
271271

272272
pub fn print_mod(&mut self, _mod: &hir::Mod<'_>, attrs: &[ast::Attribute]) {
@@ -287,9 +287,9 @@ impl<'a> State<'a> {
287287
self.maybe_print_comment(ty.span.lo());
288288
self.ibox(0);
289289
match ty.kind {
290-
hir::TyKind::Slice(ref ty) => {
290+
hir::TyKind::Slice(ty) => {
291291
self.word("[");
292-
self.print_type(&ty);
292+
self.print_type(ty);
293293
self.word("]");
294294
}
295295
hir::TyKind::Ptr(ref mt) => {
@@ -304,23 +304,16 @@ impl<'a> State<'a> {
304304
hir::TyKind::Never => {
305305
self.word("!");
306306
}
307-
hir::TyKind::Tup(ref elts) => {
307+
hir::TyKind::Tup(elts) => {
308308
self.popen();
309-
self.commasep(Inconsistent, &elts, |s, ty| s.print_type(&ty));
309+
self.commasep(Inconsistent, elts, |s, ty| s.print_type(ty));
310310
if elts.len() == 1 {
311311
self.word(",");
312312
}
313313
self.pclose();
314314
}
315-
hir::TyKind::BareFn(ref f) => {
316-
self.print_ty_fn(
317-
f.abi,
318-
f.unsafety,
319-
&f.decl,
320-
None,
321-
&f.generic_params,
322-
f.param_names,
323-
);
315+
hir::TyKind::BareFn(f) => {
316+
self.print_ty_fn(f.abi, f.unsafety, f.decl, None, f.generic_params, f.param_names);
324317
}
325318
hir::TyKind::OpaqueDef(..) => self.word("/*impl Trait*/"),
326319
hir::TyKind::Path(ref qpath) => self.print_qpath(qpath, false),
@@ -344,9 +337,9 @@ impl<'a> State<'a> {
344337
self.print_lifetime(lifetime);
345338
}
346339
}
347-
hir::TyKind::Array(ref ty, ref length) => {
340+
hir::TyKind::Array(ty, ref length) => {
348341
self.word("[");
349-
self.print_type(&ty);
342+
self.print_type(ty);
350343
self.word("; ");
351344
self.print_array_length(length);
352345
self.word("]");
@@ -373,7 +366,7 @@ impl<'a> State<'a> {
373366
self.maybe_print_comment(item.span.lo());
374367
self.print_outer_attributes(self.attrs(item.hir_id()));
375368
match item.kind {
376-
hir::ForeignItemKind::Fn(ref decl, ref arg_names, ref generics) => {
369+
hir::ForeignItemKind::Fn(decl, arg_names, generics) => {
377370
self.head("");
378371
self.print_fn(
379372
decl,
@@ -392,14 +385,14 @@ impl<'a> State<'a> {
392385
self.word(";");
393386
self.end() // end the outer fn box
394387
}
395-
hir::ForeignItemKind::Static(ref t, m) => {
388+
hir::ForeignItemKind::Static(t, m) => {
396389
self.head("static");
397390
if m == hir::Mutability::Mut {
398391
self.word_space("mut");
399392
}
400393
self.print_ident(item.ident);
401394
self.word_space(":");
402-
self.print_type(&t);
395+
self.print_type(t);
403396
self.word(";");
404397
self.end(); // end the head-ibox
405398
self.end() // end the outer cbox
@@ -442,7 +435,7 @@ impl<'a> State<'a> {
442435
) {
443436
self.word_space("type");
444437
self.print_ident(ident);
445-
self.print_generic_params(&generics.params);
438+
self.print_generic_params(generics.params);
446439
if let Some(bounds) = bounds {
447440
self.print_bounds(":", bounds);
448441
}
@@ -463,7 +456,7 @@ impl<'a> State<'a> {
463456
) {
464457
self.head("type");
465458
self.print_ident(item.ident);
466-
self.print_generic_params(&generics.params);
459+
self.print_generic_params(generics.params);
467460
self.end(); // end the inner ibox
468461

469462
self.print_where_clause(generics);
@@ -494,7 +487,7 @@ impl<'a> State<'a> {
494487
self.end(); // end inner head-block
495488
self.end(); // end outer head-block
496489
}
497-
hir::ItemKind::Use(ref path, kind) => {
490+
hir::ItemKind::Use(path, kind) => {
498491
self.head("use");
499492
self.print_path(path, false);
500493

@@ -513,14 +506,14 @@ impl<'a> State<'a> {
513506
self.end(); // end inner head-block
514507
self.end(); // end outer head-block
515508
}
516-
hir::ItemKind::Static(ref ty, m, expr) => {
509+
hir::ItemKind::Static(ty, m, expr) => {
517510
self.head("static");
518511
if m == hir::Mutability::Mut {
519512
self.word_space("mut");
520513
}
521514
self.print_ident(item.ident);
522515
self.word_space(":");
523-
self.print_type(&ty);
516+
self.print_type(ty);
524517
self.space();
525518
self.end(); // end the head-ibox
526519

@@ -529,11 +522,11 @@ impl<'a> State<'a> {
529522
self.word(";");
530523
self.end(); // end the outer cbox
531524
}
532-
hir::ItemKind::Const(ref ty, expr) => {
525+
hir::ItemKind::Const(ty, expr) => {
533526
self.head("const");
534527
self.print_ident(item.ident);
535528
self.word_space(":");
536-
self.print_type(&ty);
529+
self.print_type(ty);
537530
self.space();
538531
self.end(); // end the head-ibox
539532

@@ -542,10 +535,10 @@ impl<'a> State<'a> {
542535
self.word(";");
543536
self.end(); // end the outer cbox
544537
}
545-
hir::ItemKind::Fn(ref sig, ref param_names, body) => {
538+
hir::ItemKind::Fn(ref sig, param_names, body) => {
546539
self.head("");
547540
self.print_fn(
548-
&sig.decl,
541+
sig.decl,
549542
sig.header,
550543
Some(item.ident.name),
551544
param_names,
@@ -578,22 +571,22 @@ impl<'a> State<'a> {
578571
}
579572
self.bclose(item.span);
580573
}
581-
hir::ItemKind::GlobalAsm(ref asm) => {
574+
hir::ItemKind::GlobalAsm(asm) => {
582575
self.head("global_asm!");
583576
self.print_inline_asm(asm);
584577
self.end()
585578
}
586-
hir::ItemKind::TyAlias(ref ty, ref generics) => {
587-
self.print_item_type(item, &generics, |state| {
579+
hir::ItemKind::TyAlias(ty, generics) => {
580+
self.print_item_type(item, generics, |state| {
588581
state.word_space("=");
589-
state.print_type(&ty);
582+
state.print_type(ty);
590583
});
591584
}
592585
hir::ItemKind::OpaqueTy(ref opaque_ty) => {
593-
self.print_item_type(item, &opaque_ty.generics, |state| {
586+
self.print_item_type(item, opaque_ty.generics, |state| {
594587
let mut real_bounds = Vec::with_capacity(opaque_ty.bounds.len());
595-
for b in opaque_ty.bounds.iter() {
596-
if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b {
588+
for b in opaque_ty.bounds {
589+
if let GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = b {
597590
state.space();
598591
state.word_space("for ?");
599592
state.print_trait_ref(&ptr.trait_ref);
@@ -604,73 +597,73 @@ impl<'a> State<'a> {
604597
state.print_bounds("= impl", real_bounds);
605598
});
606599
}
607-
hir::ItemKind::Enum(ref enum_definition, ref params) => {
600+
hir::ItemKind::Enum(ref enum_definition, params) => {
608601
self.print_enum_def(enum_definition, params, item.ident.name, item.span);
609602
}
610-
hir::ItemKind::Struct(ref struct_def, ref generics) => {
603+
hir::ItemKind::Struct(ref struct_def, generics) => {
611604
self.head("struct");
612605
self.print_struct(struct_def, generics, item.ident.name, item.span, true);
613606
}
614-
hir::ItemKind::Union(ref struct_def, ref generics) => {
607+
hir::ItemKind::Union(ref struct_def, generics) => {
615608
self.head("union");
616609
self.print_struct(struct_def, generics, item.ident.name, item.span, true);
617610
}
618-
hir::ItemKind::Impl(hir::Impl {
611+
hir::ItemKind::Impl(&hir::Impl {
619612
unsafety,
620613
polarity,
621614
defaultness,
622615
constness,
623616
defaultness_span: _,
624-
ref generics,
617+
generics,
625618
ref of_trait,
626-
ref self_ty,
619+
self_ty,
627620
items,
628621
}) => {
629622
self.head("");
630-
self.print_defaultness(*defaultness);
631-
self.print_unsafety(*unsafety);
623+
self.print_defaultness(defaultness);
624+
self.print_unsafety(unsafety);
632625
self.word_nbsp("impl");
633626

634627
if !generics.params.is_empty() {
635-
self.print_generic_params(&generics.params);
628+
self.print_generic_params(generics.params);
636629
self.space();
637630
}
638631

639-
if *constness == hir::Constness::Const {
632+
if constness == hir::Constness::Const {
640633
self.word_nbsp("const");
641634
}
642635

643636
if let hir::ImplPolarity::Negative(_) = polarity {
644637
self.word("!");
645638
}
646639

647-
if let Some(ref t) = of_trait {
640+
if let Some(t) = of_trait {
648641
self.print_trait_ref(t);
649642
self.space();
650643
self.word_space("for");
651644
}
652645

653-
self.print_type(&self_ty);
646+
self.print_type(self_ty);
654647
self.print_where_clause(generics);
655648

656649
self.space();
657650
self.bopen();
658651
self.print_inner_attributes(attrs);
659-
for impl_item in *items {
652+
for impl_item in items {
660653
self.ann.nested(self, Nested::ImplItem(impl_item.id));
661654
}
662655
self.bclose(item.span);
663656
}
664-
hir::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, trait_items) => {
657+
hir::ItemKind::Trait(is_auto, unsafety, generics, bounds, trait_items) => {
665658
self.head("");
666659
self.print_is_auto(is_auto);
667660
self.print_unsafety(unsafety);
668661
self.word_nbsp("trait");
669662
self.print_ident(item.ident);
670-
self.print_generic_params(&generics.params);
663+
self.print_generic_params(generics.params);
671664
let mut real_bounds = Vec::with_capacity(bounds.len());
672-
for b in bounds.iter() {
673-
if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b {
665+
for b in bounds {
666+
if let GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = b {
674667
self.space();
675668
self.word_space("for ?");
676669
self.print_trait_ref(&ptr.trait_ref);
@@ -687,14 +680,14 @@ impl<'a> State<'a> {
687680
}
688681
self.bclose(item.span);
689682
}
690-
hir::ItemKind::TraitAlias(ref generics, ref bounds) => {
683+
hir::ItemKind::TraitAlias(generics, bounds) => {
691684
self.head("trait");
692685
self.print_ident(item.ident);
693-
self.print_generic_params(&generics.params);
686+
self.print_generic_params(generics.params);
694687
let mut real_bounds = Vec::with_capacity(bounds.len());
695688
// FIXME(durka) this seems to be some quite outdated syntax
696-
for b in bounds.iter() {
697-
if let GenericBound::Trait(ref ptr, hir::TraitBoundModifier::Maybe) = *b {
689+
for b in bounds {
690+
if let GenericBound::Trait(ptr, hir::TraitBoundModifier::Maybe) = b {
698691
self.space();
699692
self.word_space("for ?");
700693
self.print_trait_ref(&ptr.trait_ref);
@@ -714,7 +707,7 @@ impl<'a> State<'a> {
714707
}
715708

716709
pub fn print_trait_ref(&mut self, t: &hir::TraitRef<'_>) {
717-
self.print_path(&t.path, false)
710+
self.print_path(t.path, false);
718711
}
719712

720713
fn print_formal_generic_params(&mut self, generic_params: &[hir::GenericParam<'_>]) {
@@ -726,8 +719,8 @@ impl<'a> State<'a> {
726719
}
727720

728721
fn print_poly_trait_ref(&mut self, t: &hir::PolyTraitRef<'_>) {
729-
self.print_formal_generic_params(&t.bound_generic_params);
730-
self.print_trait_ref(&t.trait_ref)
722+
self.print_formal_generic_params(t.bound_generic_params);
723+
self.print_trait_ref(&t.trait_ref);
731724
}
732725

733726
pub fn print_enum_def(
@@ -739,10 +732,10 @@ impl<'a> State<'a> {
739732
) {
740733
self.head("enum");
741734
self.print_name(name);
742-
self.print_generic_params(&generics.params);
735+
self.print_generic_params(generics.params);
743736
self.print_where_clause(generics);
744737
self.space();
745-
self.print_variants(&enum_definition.variants, span)
738+
self.print_variants(enum_definition.variants, span);
746739
}
747740

748741
pub fn print_variants(&mut self, variants: &[hir::Variant<'_>], span: rustc_span::Span) {
@@ -776,15 +769,15 @@ impl<'a> State<'a> {
776769
print_finalizer: bool,
777770
) {
778771
self.print_name(name);
779-
self.print_generic_params(&generics.params);
772+
self.print_generic_params(generics.params);
780773
match struct_def {
781774
hir::VariantData::Tuple(..) | hir::VariantData::Unit(..) => {
782775
if let hir::VariantData::Tuple(..) = struct_def {
783776
self.popen();
784777
self.commasep(Inconsistent, struct_def.fields(), |s, field| {
785778
s.maybe_print_comment(field.span.lo());
786779
s.print_outer_attributes(s.attrs(field.hir_id));
787-
s.print_type(&field.ty)
780+
s.print_type(field.ty);
788781
});
789782
self.pclose();
790783
}
@@ -807,7 +800,7 @@ impl<'a> State<'a> {
807800
self.print_outer_attributes(self.attrs(field.hir_id));
808801
self.print_ident(field.ident);
809802
self.word_nbsp(":");
810-
self.print_type(&field.ty);
803+
self.print_type(field.ty);
811804
self.word(",");
812805
}
813806

@@ -819,7 +812,7 @@ impl<'a> State<'a> {
819812
pub fn print_variant(&mut self, v: &hir::Variant<'_>) {
820813
self.head("");
821814
let generics = hir::Generics::empty();
822-
self.print_struct(&v.data, &generics, v.ident.name, v.span, false);
815+
self.print_struct(&v.data, generics, v.ident.name, v.span, false);
823816
if let Some(ref d) = v.disr_expr {
824817
self.space();
825818
self.word_space("=");
@@ -834,7 +827,7 @@ impl<'a> State<'a> {
834827
arg_names: &[Ident],
835828
body_id: Option<hir::BodyId>,
836829
) {
837-
self.print_fn(&m.decl, m.header, Some(ident.name), generics, arg_names, body_id)
830+
self.print_fn(m.decl, m.header, Some(ident.name), generics, arg_names, body_id);
838831
}
839832

840833
pub fn print_trait_item(&mut self, ti: &hir::TraitItem<'_>) {
@@ -843,28 +836,23 @@ impl<'a> State<'a> {
843836
self.maybe_print_comment(ti.span.lo());
844837
self.print_outer_attributes(self.attrs(ti.hir_id()));
845838
match ti.kind {
846-
hir::TraitItemKind::Const(ref ty, default) => {
847-
self.print_associated_const(ti.ident, &ty, default);
839+
hir::TraitItemKind::Const(ty, default) => {
840+
self.print_associated_const(ti.ident, ty, default);
848841
}
849-
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(ref arg_names)) => {
850-
self.print_method_sig(ti.ident, sig, &ti.generics, arg_names, None);
842+
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(arg_names)) => {
843+
self.print_method_sig(ti.ident, sig, ti.generics, arg_names, None);
851844
self.word(";");
852845
}
853846
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
854847
self.head("");
855-
self.print_method_sig(ti.ident, sig, &ti.generics, &[], Some(body));
848+
self.print_method_sig(ti.ident, sig, ti.generics, &[], Some(body));
856849
self.nbsp();
857850
self.end(); // need to close a box
858851
self.end(); // need to close a box
859852
self.ann.nested(self, Nested::Body(body));
860853
}
861-
hir::TraitItemKind::Type(ref bounds, ref default) => {
862-
self.print_associated_type(
863-
ti.ident,
864-
&ti.generics,
865-
Some(bounds),
866-
default.as_ref().map(|ty| &**ty),
867-
);
854+
hir::TraitItemKind::Type(bounds, default) => {
855+
self.print_associated_type(ti.ident, ti.generics, Some(bounds), default);
868856
}
869857
}
870858
self.ann.post(self, AnnNode::SubItem(ti.hir_id()))
@@ -877,19 +865,19 @@ impl<'a> State<'a> {
877865
self.print_outer_attributes(self.attrs(ii.hir_id()));
878866

879867
match ii.kind {
880-
hir::ImplItemKind::Const(ref ty, expr) => {
881-
self.print_associated_const(ii.ident, &ty, Some(expr));
868+
hir::ImplItemKind::Const(ty, expr) => {
869+
self.print_associated_const(ii.ident, ty, Some(expr));
882870
}
883871
hir::ImplItemKind::Fn(ref sig, body) => {
884872
self.head("");
885-
self.print_method_sig(ii.ident, sig, &ii.generics, &[], Some(body));
873+
self.print_method_sig(ii.ident, sig, ii.generics, &[], Some(body));
886874
self.nbsp();
887875
self.end(); // need to close a box
888876
self.end(); // need to close a box
889877
self.ann.nested(self, Nested::Body(body));
890878
}
891-
hir::ImplItemKind::TyAlias(ref ty) => {
892-
self.print_associated_type(ii.ident, &ii.generics, None, Some(ty));
879+
hir::ImplItemKind::TyAlias(ty) => {
880+
self.print_associated_type(ii.ident, ii.generics, None, Some(ty));
893881
}
894882
}
895883
self.ann.post(self, AnnNode::SubItem(ii.hir_id()))
@@ -904,28 +892,28 @@ impl<'a> State<'a> {
904892
decl(self);
905893
self.end();
906894

907-
if let Some(ref init) = init {
895+
if let Some(init) = init {
908896
self.nbsp();
909897
self.word_space("=");
910-
self.print_expr(&init);
898+
self.print_expr(init);
911899
}
912900
self.end()
913901
}
914902

915903
pub fn print_stmt(&mut self, st: &hir::Stmt<'_>) {
916904
self.maybe_print_comment(st.span.lo());
917905
match st.kind {
918-
hir::StmtKind::Local(ref loc) => {
919-
self.print_local(loc.init, |this| this.print_local_decl(&loc));
906+
hir::StmtKind::Local(loc) => {
907+
self.print_local(loc.init, |this| this.print_local_decl(loc));
920908
}
921909
hir::StmtKind::Item(item) => self.ann.nested(self, Nested::Item(item)),
922-
hir::StmtKind::Expr(ref expr) => {
910+
hir::StmtKind::Expr(expr) => {
923911
self.space_if_not_bol();
924-
self.print_expr(&expr);
912+
self.print_expr(expr);
925913
}
926-
hir::StmtKind::Semi(ref expr) => {
914+
hir::StmtKind::Semi(expr) => {
927915
self.space_if_not_bol();
928-
self.print_expr(&expr);
916+
self.print_expr(expr);
929917
self.word(";");
930918
}
931919
}
@@ -966,9 +954,9 @@ impl<'a> State<'a> {
966954
for st in blk.stmts {
967955
self.print_stmt(st);
968956
}
969-
if let Some(ref expr) = blk.expr {
957+
if let Some(expr) = blk.expr {
970958
self.space_if_not_bol();
971-
self.print_expr(&expr);
959+
self.print_expr(expr);
972960
self.maybe_print_trailing_comment(expr.span, Some(blk.span.hi()));
973961
}
974962
self.bclose_maybe_open(blk.span, close_box);
@@ -979,21 +967,21 @@ impl<'a> State<'a> {
979967
if let Some(els_inner) = els {
980968
match els_inner.kind {
981969
// Another `else if` block.
982-
hir::ExprKind::If(ref i, ref then, ref e) => {
970+
hir::ExprKind::If(i, then, e) => {
983971
self.cbox(INDENT_UNIT - 1);
984972
self.ibox(0);
985973
self.word(" else if ");
986-
self.print_expr_as_cond(&i);
974+
self.print_expr_as_cond(i);
987975
self.space();
988-
self.print_expr(&then);
989-
self.print_else(e.as_ref().map(|e| &**e))
976+
self.print_expr(then);
977+
self.print_else(e);
990978
}
991979
// Final `else` block.
992-
hir::ExprKind::Block(ref b, _) => {
980+
hir::ExprKind::Block(b, _) => {
993981
self.cbox(INDENT_UNIT - 1);
994982
self.ibox(0);
995983
self.word(" else ");
996-
self.print_block(&b)
984+
self.print_block(b);
997985
}
998986
// Constraints would be great here!
999987
_ => {
@@ -1048,7 +1036,7 @@ impl<'a> State<'a> {
10481036
if needs_par {
10491037
self.popen();
10501038
}
1051-
if let hir::ExprKind::DropTemps(ref actual_expr) = expr.kind {
1039+
if let hir::ExprKind::DropTemps(actual_expr) = expr.kind {
10521040
self.print_expr(actual_expr);
10531041
} else {
10541042
self.print_expr(expr);
@@ -1114,7 +1102,7 @@ impl<'a> State<'a> {
11141102
&mut self,
11151103
qpath: &hir::QPath<'_>,
11161104
fields: &[hir::ExprField<'_>],
1117-
wth: &Option<&hir::Expr<'_>>,
1105+
wth: Option<&hir::Expr<'_>>,
11181106
) {
11191107
self.print_qpath(qpath, true);
11201108
self.word("{");
@@ -1127,28 +1115,24 @@ impl<'a> State<'a> {
11271115
s.print_ident(field.ident);
11281116
s.word_space(":");
11291117
}
1130-
s.print_expr(&field.expr);
1118+
s.print_expr(field.expr);
11311119
s.end()
11321120
},
11331121
|f| f.span,
11341122
);
1135-
match *wth {
1136-
Some(ref expr) => {
1137-
self.ibox(INDENT_UNIT);
1138-
if !fields.is_empty() {
1139-
self.word(",");
1140-
self.space();
1141-
}
1142-
self.word("..");
1143-
self.print_expr(&expr);
1144-
self.end();
1145-
}
1146-
_ => {
1147-
if !fields.is_empty() {
1148-
self.word(",")
1149-
}
1123+
if let Some(expr) = wth {
1124+
self.ibox(INDENT_UNIT);
1125+
if !fields.is_empty() {
1126+
self.word(",");
1127+
self.space();
11501128
}
1129+
self.word("..");
1130+
self.print_expr(expr);
1131+
self.end();
1132+
} else if !fields.is_empty() {
1133+
self.word(",");
11511134
}
1135+
11521136
self.word("}");
11531137
}
11541138

@@ -1249,27 +1233,26 @@ impl<'a> State<'a> {
12491233
Options(ast::InlineAsmOptions),
12501234
}
12511235

1252-
let mut args =
1253-
vec![AsmArg::Template(ast::InlineAsmTemplatePiece::to_string(&asm.template))];
1236+
let mut args = vec![AsmArg::Template(ast::InlineAsmTemplatePiece::to_string(asm.template))];
12541237
args.extend(asm.operands.iter().map(|(o, _)| AsmArg::Operand(o)));
12551238
if !asm.options.is_empty() {
12561239
args.push(AsmArg::Options(asm.options));
12571240
}
12581241

12591242
self.popen();
1260-
self.commasep(Consistent, &args, |s, arg| match arg {
1261-
AsmArg::Template(template) => s.print_string(&template, ast::StrStyle::Cooked),
1262-
AsmArg::Operand(op) => match op {
1263-
hir::InlineAsmOperand::In { reg, expr } => {
1243+
self.commasep(Consistent, &args, |s, arg| match *arg {
1244+
AsmArg::Template(ref template) => s.print_string(template, ast::StrStyle::Cooked),
1245+
AsmArg::Operand(op) => match *op {
1246+
hir::InlineAsmOperand::In { reg, ref expr } => {
12641247
s.word("in");
12651248
s.popen();
12661249
s.word(format!("{}", reg));
12671250
s.pclose();
12681251
s.space();
12691252
s.print_expr(expr);
12701253
}
1271-
hir::InlineAsmOperand::Out { reg, late, expr } => {
1272-
s.word(if *late { "lateout" } else { "out" });
1254+
hir::InlineAsmOperand::Out { reg, late, ref expr } => {
1255+
s.word(if late { "lateout" } else { "out" });
12731256
s.popen();
12741257
s.word(format!("{}", reg));
12751258
s.pclose();
@@ -1279,16 +1262,16 @@ impl<'a> State<'a> {
12791262
None => s.word("_"),
12801263
}
12811264
}
1282-
hir::InlineAsmOperand::InOut { reg, late, expr } => {
1283-
s.word(if *late { "inlateout" } else { "inout" });
1265+
hir::InlineAsmOperand::InOut { reg, late, ref expr } => {
1266+
s.word(if late { "inlateout" } else { "inout" });
12841267
s.popen();
12851268
s.word(format!("{}", reg));
12861269
s.pclose();
12871270
s.space();
12881271
s.print_expr(expr);
12891272
}
1290-
hir::InlineAsmOperand::SplitInOut { reg, late, in_expr, out_expr } => {
1291-
s.word(if *late { "inlateout" } else { "inout" });
1273+
hir::InlineAsmOperand::SplitInOut { reg, late, ref in_expr, ref out_expr } => {
1274+
s.word(if late { "inlateout" } else { "inout" });
12921275
s.popen();
12931276
s.word(format!("{}", reg));
12941277
s.pclose();
@@ -1301,17 +1284,17 @@ impl<'a> State<'a> {
13011284
None => s.word("_"),
13021285
}
13031286
}
1304-
hir::InlineAsmOperand::Const { anon_const } => {
1287+
hir::InlineAsmOperand::Const { ref anon_const } => {
13051288
s.word("const");
13061289
s.space();
13071290
s.print_anon_const(anon_const);
13081291
}
1309-
hir::InlineAsmOperand::SymFn { anon_const } => {
1292+
hir::InlineAsmOperand::SymFn { ref anon_const } => {
13101293
s.word("sym_fn");
13111294
s.space();
13121295
s.print_anon_const(anon_const);
13131296
}
1314-
hir::InlineAsmOperand::SymStatic { path, def_id: _ } => {
1297+
hir::InlineAsmOperand::SymStatic { ref path, def_id: _ } => {
13151298
s.word("sym_static");
13161299
s.space();
13171300
s.print_qpath(path, true);
@@ -1363,57 +1346,57 @@ impl<'a> State<'a> {
13631346
self.ibox(INDENT_UNIT);
13641347
self.ann.pre(self, AnnNode::Expr(expr));
13651348
match expr.kind {
1366-
hir::ExprKind::Box(ref expr) => {
1349+
hir::ExprKind::Box(expr) => {
13671350
self.word_space("box");
13681351
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
13691352
}
1370-
hir::ExprKind::Array(ref exprs) => {
1353+
hir::ExprKind::Array(exprs) => {
13711354
self.print_expr_vec(exprs);
13721355
}
13731356
hir::ExprKind::ConstBlock(ref anon_const) => {
13741357
self.print_expr_anon_const(anon_const);
13751358
}
1376-
hir::ExprKind::Repeat(ref element, ref count) => {
1377-
self.print_expr_repeat(&element, count);
1359+
hir::ExprKind::Repeat(element, ref count) => {
1360+
self.print_expr_repeat(element, count);
13781361
}
1379-
hir::ExprKind::Struct(ref qpath, fields, ref wth) => {
1362+
hir::ExprKind::Struct(qpath, fields, wth) => {
13801363
self.print_expr_struct(qpath, fields, wth);
13811364
}
1382-
hir::ExprKind::Tup(ref exprs) => {
1365+
hir::ExprKind::Tup(exprs) => {
13831366
self.print_expr_tup(exprs);
13841367
}
1385-
hir::ExprKind::Call(ref func, ref args) => {
1386-
self.print_expr_call(&func, args);
1368+
hir::ExprKind::Call(func, args) => {
1369+
self.print_expr_call(func, args);
13871370
}
1388-
hir::ExprKind::MethodCall(ref segment, ref args, _) => {
1371+
hir::ExprKind::MethodCall(segment, args, _) => {
13891372
self.print_expr_method_call(segment, args);
13901373
}
1391-
hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
1392-
self.print_expr_binary(op, &lhs, &rhs);
1374+
hir::ExprKind::Binary(op, lhs, rhs) => {
1375+
self.print_expr_binary(op, lhs, rhs);
13931376
}
1394-
hir::ExprKind::Unary(op, ref expr) => {
1395-
self.print_expr_unary(op, &expr);
1377+
hir::ExprKind::Unary(op, expr) => {
1378+
self.print_expr_unary(op, expr);
13961379
}
1397-
hir::ExprKind::AddrOf(k, m, ref expr) => {
1398-
self.print_expr_addr_of(k, m, &expr);
1380+
hir::ExprKind::AddrOf(k, m, expr) => {
1381+
self.print_expr_addr_of(k, m, expr);
13991382
}
14001383
hir::ExprKind::Lit(ref lit) => {
1401-
self.print_literal(&lit);
1384+
self.print_literal(lit);
14021385
}
1403-
hir::ExprKind::Cast(ref expr, ref ty) => {
1386+
hir::ExprKind::Cast(expr, ty) => {
14041387
let prec = AssocOp::As.precedence() as i8;
1405-
self.print_expr_maybe_paren(&expr, prec);
1388+
self.print_expr_maybe_paren(expr, prec);
14061389
self.space();
14071390
self.word_space("as");
1408-
self.print_type(&ty);
1391+
self.print_type(ty);
14091392
}
1410-
hir::ExprKind::Type(ref expr, ref ty) => {
1393+
hir::ExprKind::Type(expr, ty) => {
14111394
let prec = AssocOp::Colon.precedence() as i8;
1412-
self.print_expr_maybe_paren(&expr, prec);
1395+
self.print_expr_maybe_paren(expr, prec);
14131396
self.word_space(":");
1414-
self.print_type(&ty);
1397+
self.print_type(ty);
14151398
}
1416-
hir::ExprKind::DropTemps(ref init) => {
1399+
hir::ExprKind::DropTemps(init) => {
14171400
// Print `{`:
14181401
self.cbox(INDENT_UNIT);
14191402
self.ibox(0);
@@ -1431,25 +1414,25 @@ impl<'a> State<'a> {
14311414
// Print `}`:
14321415
self.bclose_maybe_open(expr.span, true);
14331416
}
1434-
hir::ExprKind::Let(hir::Let { pat, ty, init, .. }) => {
1435-
self.print_let(pat, *ty, init);
1417+
hir::ExprKind::Let(&hir::Let { pat, ty, init, .. }) => {
1418+
self.print_let(pat, ty, init);
14361419
}
1437-
hir::ExprKind::If(ref test, ref blk, ref elseopt) => {
1438-
self.print_if(&test, &blk, elseopt.as_ref().map(|e| &**e));
1420+
hir::ExprKind::If(test, blk, elseopt) => {
1421+
self.print_if(test, blk, elseopt);
14391422
}
1440-
hir::ExprKind::Loop(ref blk, opt_label, _, _) => {
1423+
hir::ExprKind::Loop(blk, opt_label, _, _) => {
14411424
if let Some(label) = opt_label {
14421425
self.print_ident(label.ident);
14431426
self.word_space(":");
14441427
}
14451428
self.head("loop");
1446-
self.print_block(&blk);
1429+
self.print_block(blk);
14471430
}
1448-
hir::ExprKind::Match(ref expr, arms, _) => {
1431+
hir::ExprKind::Match(expr, arms, _) => {
14491432
self.cbox(INDENT_UNIT);
14501433
self.ibox(INDENT_UNIT);
14511434
self.word_nbsp("match");
1452-
self.print_expr_as_cond(&expr);
1435+
self.print_expr_as_cond(expr);
14531436
self.space();
14541437
self.bopen();
14551438
for arm in arms {
@@ -1460,15 +1443,15 @@ impl<'a> State<'a> {
14601443
hir::ExprKind::Closure {
14611444
capture_clause,
14621445
bound_generic_params,
1463-
ref fn_decl,
1446+
fn_decl,
14641447
body,
14651448
fn_decl_span: _,
14661449
movability: _,
14671450
} => {
14681451
self.print_formal_generic_params(bound_generic_params);
14691452
self.print_capture_clause(capture_clause);
14701453

1471-
self.print_closure_params(&fn_decl, body);
1454+
self.print_closure_params(fn_decl, body);
14721455
self.space();
14731456

14741457
// This is a bare expression.
@@ -1480,7 +1463,7 @@ impl<'a> State<'a> {
14801463
// empty box to satisfy the close.
14811464
self.ibox(0);
14821465
}
1483-
hir::ExprKind::Block(ref blk, opt_label) => {
1466+
hir::ExprKind::Block(blk, opt_label) => {
14841467
if let Some(label) = opt_label {
14851468
self.print_ident(label.ident);
14861469
self.word_space(":");
@@ -1489,42 +1472,42 @@ impl<'a> State<'a> {
14891472
self.cbox(INDENT_UNIT);
14901473
// head-box, will be closed by print-block after `{`
14911474
self.ibox(0);
1492-
self.print_block(&blk);
1475+
self.print_block(blk);
14931476
}
1494-
hir::ExprKind::Assign(ref lhs, ref rhs, _) => {
1477+
hir::ExprKind::Assign(lhs, rhs, _) => {
14951478
let prec = AssocOp::Assign.precedence() as i8;
1496-
self.print_expr_maybe_paren(&lhs, prec + 1);
1479+
self.print_expr_maybe_paren(lhs, prec + 1);
14971480
self.space();
14981481
self.word_space("=");
1499-
self.print_expr_maybe_paren(&rhs, prec);
1482+
self.print_expr_maybe_paren(rhs, prec);
15001483
}
1501-
hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => {
1484+
hir::ExprKind::AssignOp(op, lhs, rhs) => {
15021485
let prec = AssocOp::Assign.precedence() as i8;
1503-
self.print_expr_maybe_paren(&lhs, prec + 1);
1486+
self.print_expr_maybe_paren(lhs, prec + 1);
15041487
self.space();
15051488
self.word(op.node.as_str());
15061489
self.word_space("=");
1507-
self.print_expr_maybe_paren(&rhs, prec);
1490+
self.print_expr_maybe_paren(rhs, prec);
15081491
}
1509-
hir::ExprKind::Field(ref expr, ident) => {
1492+
hir::ExprKind::Field(expr, ident) => {
15101493
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
15111494
self.word(".");
15121495
self.print_ident(ident);
15131496
}
1514-
hir::ExprKind::Index(ref expr, ref index) => {
1515-
self.print_expr_maybe_paren(&expr, parser::PREC_POSTFIX);
1497+
hir::ExprKind::Index(expr, index) => {
1498+
self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX);
15161499
self.word("[");
1517-
self.print_expr(&index);
1500+
self.print_expr(index);
15181501
self.word("]");
15191502
}
15201503
hir::ExprKind::Path(ref qpath) => self.print_qpath(qpath, true),
1521-
hir::ExprKind::Break(destination, ref opt_expr) => {
1504+
hir::ExprKind::Break(destination, opt_expr) => {
15221505
self.word("break");
15231506
if let Some(label) = destination.label {
15241507
self.space();
15251508
self.print_ident(label.ident);
15261509
}
1527-
if let Some(ref expr) = *opt_expr {
1510+
if let Some(expr) = opt_expr {
15281511
self.space();
15291512
self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
15301513
}
@@ -1536,20 +1519,20 @@ impl<'a> State<'a> {
15361519
self.print_ident(label.ident);
15371520
}
15381521
}
1539-
hir::ExprKind::Ret(ref result) => {
1522+
hir::ExprKind::Ret(result) => {
15401523
self.word("return");
1541-
if let Some(ref expr) = *result {
1524+
if let Some(expr) = result {
15421525
self.word(" ");
1543-
self.print_expr_maybe_paren(&expr, parser::PREC_JUMP);
1526+
self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
15441527
}
15451528
}
1546-
hir::ExprKind::InlineAsm(ref asm) => {
1529+
hir::ExprKind::InlineAsm(asm) => {
15471530
self.word("asm!");
15481531
self.print_inline_asm(asm);
15491532
}
1550-
hir::ExprKind::Yield(ref expr, _) => {
1533+
hir::ExprKind::Yield(expr, _) => {
15511534
self.word_space("yield");
1552-
self.print_expr_maybe_paren(&expr, parser::PREC_JUMP);
1535+
self.print_expr_maybe_paren(expr, parser::PREC_JUMP);
15531536
}
15541537
hir::ExprKind::Err => {
15551538
self.popen();
@@ -1562,10 +1545,10 @@ impl<'a> State<'a> {
15621545
}
15631546

15641547
pub fn print_local_decl(&mut self, loc: &hir::Local<'_>) {
1565-
self.print_pat(&loc.pat);
1566-
if let Some(ref ty) = loc.ty {
1548+
self.print_pat(loc.pat);
1549+
if let Some(ty) = loc.ty {
15671550
self.word_space(":");
1568-
self.print_type(&ty);
1551+
self.print_type(ty);
15691552
}
15701553
}
15711554

@@ -1596,8 +1579,8 @@ impl<'a> State<'a> {
15961579

15971580
pub fn print_qpath(&mut self, qpath: &hir::QPath<'_>, colons_before_params: bool) {
15981581
match *qpath {
1599-
hir::QPath::Resolved(None, ref path) => self.print_path(path, colons_before_params),
1600-
hir::QPath::Resolved(Some(ref qself), ref path) => {
1582+
hir::QPath::Resolved(None, path) => self.print_path(path, colons_before_params),
1583+
hir::QPath::Resolved(Some(qself), path) => {
16011584
self.word("<");
16021585
self.print_type(qself);
16031586
self.space();
@@ -1627,11 +1610,11 @@ impl<'a> State<'a> {
16271610
colons_before_params,
16281611
)
16291612
}
1630-
hir::QPath::TypeRelative(ref qself, ref item_segment) => {
1613+
hir::QPath::TypeRelative(qself, item_segment) => {
16311614
// If we've got a compound-qualified-path, let's push an additional pair of angle
16321615
// brackets, so that we pretty-print `<<A::B>::C>` as `<A::B>::C`, instead of just
16331616
// `A::B::C` (since the latter could be ambiguous to the user)
1634-
if let hir::TyKind::Path(hir::QPath::Resolved(None, _)) = &qself.kind {
1617+
if let hir::TyKind::Path(hir::QPath::Resolved(None, _)) = qself.kind {
16351618
self.print_type(qself);
16361619
} else {
16371620
self.word("<");
@@ -1663,7 +1646,7 @@ impl<'a> State<'a> {
16631646
) {
16641647
if generic_args.parenthesized {
16651648
self.word("(");
1666-
self.commasep(Inconsistent, generic_args.inputs(), |s, ty| s.print_type(&ty));
1649+
self.commasep(Inconsistent, generic_args.inputs(), |s, ty| s.print_type(ty));
16671650
self.word(")");
16681651

16691652
self.space_if_not_bol();
@@ -1694,7 +1677,7 @@ impl<'a> State<'a> {
16941677
start_or_comma(self);
16951678
self.commasep(
16961679
Inconsistent,
1697-
&generic_args.args,
1680+
generic_args.args,
16981681
|s, generic_arg| match generic_arg {
16991682
GenericArg::Lifetime(lt) if !elide_lifetimes => s.print_lifetime(lt),
17001683
GenericArg::Lifetime(_) => {}
@@ -1712,7 +1695,7 @@ impl<'a> State<'a> {
17121695
self.word("..");
17131696
}
17141697

1715-
for binding in generic_args.bindings.iter() {
1698+
for binding in generic_args.bindings {
17161699
start_or_comma(self);
17171700
self.print_type_binding(binding);
17181701
}
@@ -1731,7 +1714,7 @@ impl<'a> State<'a> {
17311714
hir::TypeBindingKind::Equality { ref term } => {
17321715
self.word_space("=");
17331716
match term {
1734-
Term::Ty(ref ty) => self.print_type(ty),
1717+
Term::Ty(ty) => self.print_type(ty),
17351718
Term::Const(ref c) => self.print_anon_const(c),
17361719
}
17371720
}
@@ -1748,7 +1731,7 @@ impl<'a> State<'a> {
17481731
// is that it doesn't matter
17491732
match pat.kind {
17501733
PatKind::Wild => self.word("_"),
1751-
PatKind::Binding(binding_mode, _, ident, ref sub) => {
1734+
PatKind::Binding(binding_mode, _, ident, sub) => {
17521735
match binding_mode {
17531736
hir::BindingAnnotation::Ref => {
17541737
self.word_nbsp("ref");
@@ -1764,33 +1747,33 @@ impl<'a> State<'a> {
17641747
}
17651748
}
17661749
self.print_ident(ident);
1767-
if let Some(ref p) = *sub {
1750+
if let Some(p) = sub {
17681751
self.word("@");
1769-
self.print_pat(&p);
1752+
self.print_pat(p);
17701753
}
17711754
}
1772-
PatKind::TupleStruct(ref qpath, ref elts, ddpos) => {
1755+
PatKind::TupleStruct(ref qpath, elts, ddpos) => {
17731756
self.print_qpath(qpath, true);
17741757
self.popen();
17751758
if let Some(ddpos) = ddpos {
1776-
self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p));
1759+
self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p));
17771760
if ddpos != 0 {
17781761
self.word_space(",");
17791762
}
17801763
self.word("..");
17811764
if ddpos != elts.len() {
17821765
self.word(",");
1783-
self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p));
1766+
self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p));
17841767
}
17851768
} else {
1786-
self.commasep(Inconsistent, &elts, |s, p| s.print_pat(&p));
1769+
self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
17871770
}
17881771
self.pclose();
17891772
}
17901773
PatKind::Path(ref qpath) => {
17911774
self.print_qpath(qpath, true);
17921775
}
1793-
PatKind::Struct(ref qpath, ref fields, etc) => {
1776+
PatKind::Struct(ref qpath, fields, etc) => {
17941777
self.print_qpath(qpath, true);
17951778
self.nbsp();
17961779
self.word("{");
@@ -1800,14 +1783,14 @@ impl<'a> State<'a> {
18001783
}
18011784
self.commasep_cmnt(
18021785
Consistent,
1803-
&fields,
1786+
fields,
18041787
|s, f| {
18051788
s.cbox(INDENT_UNIT);
18061789
if !f.is_shorthand {
18071790
s.print_ident(f.ident);
18081791
s.word_nbsp(":");
18091792
}
1810-
s.print_pat(&f.pat);
1793+
s.print_pat(f.pat);
18111794
s.end()
18121795
},
18131796
|f| f.pat.span,
@@ -1823,83 +1806,83 @@ impl<'a> State<'a> {
18231806
}
18241807
self.word("}");
18251808
}
1826-
PatKind::Or(ref pats) => {
1827-
self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(&p));
1809+
PatKind::Or(pats) => {
1810+
self.strsep("|", true, Inconsistent, pats, |s, p| s.print_pat(p));
18281811
}
1829-
PatKind::Tuple(ref elts, ddpos) => {
1812+
PatKind::Tuple(elts, ddpos) => {
18301813
self.popen();
18311814
if let Some(ddpos) = ddpos {
1832-
self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(&p));
1815+
self.commasep(Inconsistent, &elts[..ddpos], |s, p| s.print_pat(p));
18331816
if ddpos != 0 {
18341817
self.word_space(",");
18351818
}
18361819
self.word("..");
18371820
if ddpos != elts.len() {
18381821
self.word(",");
1839-
self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(&p));
1822+
self.commasep(Inconsistent, &elts[ddpos..], |s, p| s.print_pat(p));
18401823
}
18411824
} else {
1842-
self.commasep(Inconsistent, &elts[..], |s, p| s.print_pat(&p));
1825+
self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
18431826
if elts.len() == 1 {
18441827
self.word(",");
18451828
}
18461829
}
18471830
self.pclose();
18481831
}
1849-
PatKind::Box(ref inner) => {
1832+
PatKind::Box(inner) => {
18501833
let is_range_inner = matches!(inner.kind, PatKind::Range(..));
18511834
self.word("box ");
18521835
if is_range_inner {
18531836
self.popen();
18541837
}
1855-
self.print_pat(&inner);
1838+
self.print_pat(inner);
18561839
if is_range_inner {
18571840
self.pclose();
18581841
}
18591842
}
1860-
PatKind::Ref(ref inner, mutbl) => {
1843+
PatKind::Ref(inner, mutbl) => {
18611844
let is_range_inner = matches!(inner.kind, PatKind::Range(..));
18621845
self.word("&");
18631846
self.word(mutbl.prefix_str());
18641847
if is_range_inner {
18651848
self.popen();
18661849
}
1867-
self.print_pat(&inner);
1850+
self.print_pat(inner);
18681851
if is_range_inner {
18691852
self.pclose();
18701853
}
18711854
}
1872-
PatKind::Lit(ref e) => self.print_expr(&e),
1873-
PatKind::Range(ref begin, ref end, ref end_kind) => {
1855+
PatKind::Lit(e) => self.print_expr(e),
1856+
PatKind::Range(begin, end, end_kind) => {
18741857
if let Some(expr) = begin {
18751858
self.print_expr(expr);
18761859
}
1877-
match *end_kind {
1860+
match end_kind {
18781861
RangeEnd::Included => self.word("..."),
18791862
RangeEnd::Excluded => self.word(".."),
18801863
}
18811864
if let Some(expr) = end {
18821865
self.print_expr(expr);
18831866
}
18841867
}
1885-
PatKind::Slice(ref before, ref slice, ref after) => {
1868+
PatKind::Slice(before, slice, after) => {
18861869
self.word("[");
1887-
self.commasep(Inconsistent, &before, |s, p| s.print_pat(&p));
1888-
if let Some(ref p) = *slice {
1870+
self.commasep(Inconsistent, before, |s, p| s.print_pat(p));
1871+
if let Some(p) = slice {
18891872
if !before.is_empty() {
18901873
self.word_space(",");
18911874
}
18921875
if let PatKind::Wild = p.kind {
18931876
// Print nothing.
18941877
} else {
1895-
self.print_pat(&p);
1878+
self.print_pat(p);
18961879
}
18971880
self.word("..");
18981881
if !after.is_empty() {
18991882
self.word_space(",");
19001883
}
19011884
}
1902-
self.commasep(Inconsistent, &after, |s, p| s.print_pat(&p));
1885+
self.commasep(Inconsistent, after, |s, p| s.print_pat(p));
19031886
self.word("]");
19041887
}
19051888
}
@@ -1908,7 +1891,7 @@ impl<'a> State<'a> {
19081891

19091892
pub fn print_param(&mut self, arg: &hir::Param<'_>) {
19101893
self.print_outer_attributes(self.attrs(arg.hir_id));
1911-
self.print_pat(&arg.pat);
1894+
self.print_pat(arg.pat);
19121895
}
19131896

19141897
pub fn print_arm(&mut self, arm: &hir::Arm<'_>) {
@@ -1920,32 +1903,32 @@ impl<'a> State<'a> {
19201903
self.cbox(INDENT_UNIT);
19211904
self.ann.pre(self, AnnNode::Arm(arm));
19221905
self.ibox(0);
1923-
self.print_outer_attributes(&self.attrs(arm.hir_id));
1924-
self.print_pat(&arm.pat);
1906+
self.print_outer_attributes(self.attrs(arm.hir_id));
1907+
self.print_pat(arm.pat);
19251908
self.space();
19261909
if let Some(ref g) = arm.guard {
1927-
match g {
1910+
match *g {
19281911
hir::Guard::If(e) => {
19291912
self.word_space("if");
1930-
self.print_expr(&e);
1913+
self.print_expr(e);
19311914
self.space();
19321915
}
1933-
hir::Guard::IfLet(hir::Let { pat, ty, init, .. }) => {
1916+
hir::Guard::IfLet(&hir::Let { pat, ty, init, .. }) => {
19341917
self.word_nbsp("if");
1935-
self.print_let(pat, *ty, init);
1918+
self.print_let(pat, ty, init);
19361919
}
19371920
}
19381921
}
19391922
self.word_space("=>");
19401923

19411924
match arm.body.kind {
1942-
hir::ExprKind::Block(ref blk, opt_label) => {
1925+
hir::ExprKind::Block(blk, opt_label) => {
19431926
if let Some(label) = opt_label {
19441927
self.print_ident(label.ident);
19451928
self.word_space(":");
19461929
}
19471930
// the block will close the pattern's ibox
1948-
self.print_block_unclosed(&blk);
1931+
self.print_block_unclosed(blk);
19491932

19501933
// If it is a user-provided unsafe block, print a comma after it
19511934
if let hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::UserProvided) = blk.rules
@@ -1955,7 +1938,7 @@ impl<'a> State<'a> {
19551938
}
19561939
_ => {
19571940
self.end(); // close the ibox for the pattern
1958-
self.print_expr(&arm.body);
1941+
self.print_expr(arm.body);
19591942
self.word(",");
19601943
}
19611944
}
@@ -1978,13 +1961,13 @@ impl<'a> State<'a> {
19781961
self.nbsp();
19791962
self.print_name(name);
19801963
}
1981-
self.print_generic_params(&generics.params);
1964+
self.print_generic_params(generics.params);
19821965

19831966
self.popen();
19841967
let mut i = 0;
19851968
// Make sure we aren't supplied *both* `arg_names` and `body_id`.
19861969
assert!(arg_names.is_empty() || body_id.is_none());
1987-
self.commasep(Inconsistent, &decl.inputs, |s, ty| {
1970+
self.commasep(Inconsistent, decl.inputs, |s, ty| {
19881971
s.ibox(INDENT_UNIT);
19891972
if let Some(arg_name) = arg_names.get(i) {
19901973
s.word(arg_name.to_string());
@@ -2011,7 +1994,7 @@ impl<'a> State<'a> {
20111994
fn print_closure_params(&mut self, decl: &hir::FnDecl<'_>, body_id: hir::BodyId) {
20121995
self.word("|");
20131996
let mut i = 0;
2014-
self.commasep(Inconsistent, &decl.inputs, |s, ty| {
1997+
self.commasep(Inconsistent, decl.inputs, |s, ty| {
20151998
s.ibox(INDENT_UNIT);
20161999

20172000
s.ann.nested(s, Nested::BodyParamPat(body_id, i));
@@ -2035,8 +2018,8 @@ impl<'a> State<'a> {
20352018
self.space_if_not_bol();
20362019
self.word_space("->");
20372020
match decl.output {
2038-
hir::FnRetTy::Return(ref ty) => {
2039-
self.print_type(&ty);
2021+
hir::FnRetTy::Return(ty) => {
2022+
self.print_type(ty);
20402023
self.maybe_print_comment(ty.span.lo());
20412024
}
20422025
hir::FnRetTy::DefaultReturn(..) => unreachable!(),
@@ -2107,20 +2090,20 @@ impl<'a> State<'a> {
21072090

21082091
match param.kind {
21092092
GenericParamKind::Lifetime { .. } => {}
2110-
GenericParamKind::Type { ref default, .. } => {
2093+
GenericParamKind::Type { default, .. } => {
21112094
if let Some(default) = default {
21122095
self.space();
21132096
self.word_space("=");
2114-
self.print_type(&default)
2097+
self.print_type(default);
21152098
}
21162099
}
2117-
GenericParamKind::Const { ref ty, ref default } => {
2100+
GenericParamKind::Const { ty, ref default } => {
21182101
self.word_space(":");
21192102
self.print_type(ty);
2120-
if let Some(ref default) = default {
2103+
if let Some(default) = default {
21212104
self.space();
21222105
self.word_space("=");
2123-
self.print_anon_const(&default)
2106+
self.print_anon_const(default);
21242107
}
21252108
}
21262109
}
@@ -2143,19 +2126,19 @@ impl<'a> State<'a> {
21432126
self.word_space(",");
21442127
}
21452128

2146-
match predicate {
2129+
match *predicate {
21472130
hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
21482131
bound_generic_params,
21492132
bounded_ty,
21502133
bounds,
21512134
..
21522135
}) => {
21532136
self.print_formal_generic_params(bound_generic_params);
2154-
self.print_type(&bounded_ty);
2155-
self.print_bounds(":", *bounds);
2137+
self.print_type(bounded_ty);
2138+
self.print_bounds(":", bounds);
21562139
}
21572140
hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
2158-
lifetime,
2141+
ref lifetime,
21592142
bounds,
21602143
..
21612144
}) => {
@@ -2200,7 +2183,7 @@ impl<'a> State<'a> {
22002183

22012184
pub fn print_mt(&mut self, mt: &hir::MutTy<'_>, print_const: bool) {
22022185
self.print_mutability(mt.mutbl, print_const);
2203-
self.print_type(&mt.ty)
2186+
self.print_type(mt.ty);
22042187
}
22052188

22062189
pub fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) {
@@ -2213,11 +2196,11 @@ impl<'a> State<'a> {
22132196
self.word_space("->");
22142197
match decl.output {
22152198
hir::FnRetTy::DefaultReturn(..) => unreachable!(),
2216-
hir::FnRetTy::Return(ref ty) => self.print_type(&ty),
2199+
hir::FnRetTy::Return(ty) => self.print_type(ty),
22172200
}
22182201
self.end();
22192202

2220-
if let hir::FnRetTy::Return(ref output) = decl.output {
2203+
if let hir::FnRetTy::Return(output) = decl.output {
22212204
self.maybe_print_comment(output.span.lo());
22222205
}
22232206
}
@@ -2243,7 +2226,7 @@ impl<'a> State<'a> {
22432226
asyncness: hir::IsAsync::NotAsync,
22442227
},
22452228
name,
2246-
&generics,
2229+
generics,
22472230
arg_names,
22482231
None,
22492232
);
@@ -2312,7 +2295,7 @@ fn stmt_ends_with_semi(stmt: &hir::StmtKind<'_>) -> bool {
23122295
match *stmt {
23132296
hir::StmtKind::Local(_) => true,
23142297
hir::StmtKind::Item(_) => false,
2315-
hir::StmtKind::Expr(ref e) => expr_requires_semi_to_be_stmt(&e),
2298+
hir::StmtKind::Expr(e) => expr_requires_semi_to_be_stmt(e),
23162299
hir::StmtKind::Semi(..) => false,
23172300
}
23182301
}
@@ -2351,22 +2334,22 @@ fn contains_exterior_struct_lit(value: &hir::Expr<'_>) -> bool {
23512334
match value.kind {
23522335
hir::ExprKind::Struct(..) => true,
23532336

2354-
hir::ExprKind::Assign(ref lhs, ref rhs, _)
2355-
| hir::ExprKind::AssignOp(_, ref lhs, ref rhs)
2356-
| hir::ExprKind::Binary(_, ref lhs, ref rhs) => {
2337+
hir::ExprKind::Assign(lhs, rhs, _)
2338+
| hir::ExprKind::AssignOp(_, lhs, rhs)
2339+
| hir::ExprKind::Binary(_, lhs, rhs) => {
23572340
// `X { y: 1 } + X { y: 2 }`
2358-
contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs)
2341+
contains_exterior_struct_lit(lhs) || contains_exterior_struct_lit(rhs)
23592342
}
2360-
hir::ExprKind::Unary(_, ref x)
2361-
| hir::ExprKind::Cast(ref x, _)
2362-
| hir::ExprKind::Type(ref x, _)
2363-
| hir::ExprKind::Field(ref x, _)
2364-
| hir::ExprKind::Index(ref x, _) => {
2343+
hir::ExprKind::Unary(_, x)
2344+
| hir::ExprKind::Cast(x, _)
2345+
| hir::ExprKind::Type(x, _)
2346+
| hir::ExprKind::Field(x, _)
2347+
| hir::ExprKind::Index(x, _) => {
23652348
// `&X { y: 1 }, X { y: 1 }.y`
2366-
contains_exterior_struct_lit(&x)
2349+
contains_exterior_struct_lit(x)
23672350
}
23682351

2369-
hir::ExprKind::MethodCall(.., ref exprs, _) => {
2352+
hir::ExprKind::MethodCall(.., exprs, _) => {
23702353
// `X { y: 1 }.bar(...)`
23712354
contains_exterior_struct_lit(&exprs[0])
23722355
}

0 commit comments

Comments
 (0)
Please sign in to comment.