diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
index c265b53b37d5..9ac63001bf34 100644
--- a/src/librustc/hir/intravisit.rs
+++ b/src/librustc/hir/intravisit.rs
@@ -672,7 +672,7 @@ pub fn walk_generic_args<'v, V: Visitor<'v>>(
     _path_span: Span,
     generic_args: &'v GenericArgs<'v>,
 ) {
-    walk_list!(visitor, visit_generic_arg, &generic_args.args);
+    walk_list!(visitor, visit_generic_arg, generic_args.args);
     walk_list!(visitor, visit_assoc_type_binding, generic_args.bindings);
 }
 
@@ -780,7 +780,7 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
 }
 
 pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {
-    walk_list!(visitor, visit_generic_param, &generics.params);
+    walk_list!(visitor, visit_generic_param, generics.params);
     walk_list!(visitor, visit_where_predicate, generics.where_clause.predicates);
 }
 
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index dda25c9ba18e..196f1044f594 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -893,7 +893,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     // in-band-lifetimes introduced by generics or where-clauses
                     // wouldn't have been added yet.
                     let generics =
-                        this.lower_generics(generics, ImplTraitContext::Universal(&mut params));
+                        this.lower_generics_mut(generics, ImplTraitContext::Universal(&mut params));
                     let res = f(this, &mut params);
                     (params, (generics, res))
                 })
@@ -914,6 +914,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         lowered_generics.params = lowered_params.into();
 
+        let lowered_generics = lowered_generics.into_generics(self.arena);
         (lowered_generics, res)
     }
 
@@ -1224,17 +1225,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 };
                 hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx))
             }
-            TyKind::BareFn(ref f) => self.with_in_scope_lifetime_defs(&f.generic_params, |this| {
-                this.with_anonymous_lifetime_mode(AnonymousLifetimeMode::PassThrough, |this| {
-                    hir::TyKind::BareFn(
-                        this.arena.alloc(hir::BareFnTy {
-                            generic_params: this.arena.alloc_from_iter(
-                                this.lower_generic_params(
-                                    &f.generic_params,
-                                    &NodeMap::default(),
-                                    ImplTraitContext::disallowed(),
-                                )
-                                .into_iter(),
+            TyKind::BareFn(ref f) => {
+                self.with_in_scope_lifetime_defs(&f.generic_params, |this| {
+                    this.with_anonymous_lifetime_mode(AnonymousLifetimeMode::PassThrough, |this| {
+                        hir::TyKind::BareFn(this.arena.alloc(hir::BareFnTy {
+                            generic_params: this.lower_generic_params(
+                                &f.generic_params,
+                                &NodeMap::default(),
+                                ImplTraitContext::disallowed(),
                             ),
                             unsafety: f.unsafety,
                             abi: this.lower_extern(f.ext),
@@ -1242,10 +1240,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             param_names: this.arena.alloc_from_iter(
                                 this.lower_fn_params_to_names(&f.decl).into_iter(),
                             ),
-                        }),
-                    )
+                        }))
+                    })
                 })
-            }),
+            }
             TyKind::Never => hir::TyKind::Never,
             TyKind::Tup(ref tys) => {
                 hir::TyKind::Tup(self.arena.alloc_from_iter(
@@ -1414,12 +1412,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             opaque_ty_def_index,
             &hir_bounds,
         );
+        let lifetime_defs = self.arena.alloc_from_iter(lifetime_defs.into_iter());
 
         debug!("lower_opaque_impl_trait: lifetimes={:#?}", lifetimes,);
 
         debug!("lower_opaque_impl_trait: lifetime_defs={:#?}", lifetime_defs,);
 
-        self.with_hir_id_owner(opaque_ty_node_id, |lctx| {
+        self.with_hir_id_owner(opaque_ty_node_id, move |lctx| {
             let opaque_ty_item = hir::OpaqueTy {
                 generics: hir::Generics {
                     params: lifetime_defs,
@@ -1978,7 +1977,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id: Some(id),
             res: Some(self.lower_res(res)),
             infer_args,
-            args: if generic_args.is_empty() { None } else { Some(self.arena.alloc(generic_args)) },
+            args: if generic_args.is_empty() {
+                None
+            } else {
+                Some(self.arena.alloc(generic_args.into_generic_args(self.arena)))
+            },
         }
     }
 
@@ -1987,7 +1990,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         data: &AngleBracketedArgs,
         param_mode: ParamMode,
         mut itctx: ImplTraitContext<'_, 'hir>,
-    ) -> (hir::GenericArgs<'hir>, bool) {
+    ) -> (GenericArgsCtor<'hir>, bool) {
         let &AngleBracketedArgs { ref args, ref constraints, .. } = data;
         let has_non_lt_args = args.iter().any(|arg| match arg {
             ast::GenericArg::Lifetime(_) => false,
@@ -1995,7 +1998,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             ast::GenericArg::Const(_) => true,
         });
         (
-            hir::GenericArgs {
+            GenericArgsCtor {
                 args: args.iter().map(|a| self.lower_generic_arg(a, itctx.reborrow())).collect(),
                 bindings: self.arena.alloc_from_iter(
                     constraints.iter().map(|b| self.lower_assoc_ty_constraint(b, itctx.reborrow())),
@@ -2009,7 +2012,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_parenthesized_parameter_data(
         &mut self,
         data: &ParenthesizedArgs,
-    ) -> (hir::GenericArgs<'hir>, bool) {
+    ) -> (GenericArgsCtor<'hir>, bool) {
         // Switch to `PassThrough` mode for anonymous lifetimes; this
         // means that we permit things like `&Ref<T>`, where `Ref` has
         // a hidden lifetime parameter. This is needed for backwards
@@ -2024,7 +2027,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 FunctionRetTy::Ty(ty) => this.lower_ty(&ty, ImplTraitContext::disallowed()),
                 FunctionRetTy::Default(_) => this.arena.alloc(this.ty_tup(span, &[])),
             };
-            let args = hir_vec![GenericArg::Type(this.ty_tup(span, inputs))];
+            let args = vec![GenericArg::Type(this.ty_tup(span, inputs))];
             let binding = hir::TypeBinding {
                 hir_id: this.next_id(),
                 ident: Ident::with_dummy_span(FN_OUTPUT_NAME),
@@ -2032,7 +2035,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 kind: hir::TypeBindingKind::Equality { ty: output_ty },
             };
             (
-                hir::GenericArgs { args, bindings: arena_vec![this; binding], parenthesized: true },
+                GenericArgsCtor { args, bindings: arena_vec![this; binding], parenthesized: true },
                 false,
             )
         })
@@ -2310,12 +2313,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             debug!("lower_async_fn_ret_ty: lifetimes_to_define={:#?}", this.lifetimes_to_define);
             debug!("lower_async_fn_ret_ty: lifetime_params={:#?}", lifetime_params);
 
-            let generic_params = lifetime_params
-                .iter()
-                .map(|(span, hir_name)| {
+            let generic_params =
+                this.arena.alloc_from_iter(lifetime_params.iter().map(|(span, hir_name)| {
                     this.lifetime_to_generic_param(*span, *hir_name, opaque_ty_def_index)
-                })
-                .collect();
+                }));
 
             let opaque_ty_item = hir::OpaqueTy {
                 generics: hir::Generics {
@@ -2395,7 +2396,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         // "<Output = T>"
         let future_params = self.arena.alloc(hir::GenericArgs {
-            args: HirVec::new(),
+            args: &[],
             bindings: arena_vec![self; hir::TypeBinding {
                 ident: Ident::with_dummy_span(FN_OUTPUT_NAME),
                 kind: hir::TypeBindingKind::Equality { ty: output_ty },
@@ -2474,18 +2475,27 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::Lifetime { hir_id: self.lower_node_id(id), span, name }
     }
 
-    fn lower_generic_params(
+    fn lower_generic_params_mut(
         &mut self,
         params: &[GenericParam],
         add_bounds: &NodeMap<Vec<GenericBound>>,
         mut itctx: ImplTraitContext<'_, 'hir>,
-    ) -> HirVec<hir::GenericParam<'hir>> {
+    ) -> Vec<hir::GenericParam<'hir>> {
         params
             .iter()
             .map(|param| self.lower_generic_param(param, add_bounds, itctx.reborrow()))
             .collect()
     }
 
+    fn lower_generic_params(
+        &mut self,
+        params: &[GenericParam],
+        add_bounds: &NodeMap<Vec<GenericBound>>,
+        itctx: ImplTraitContext<'_, 'hir>,
+    ) -> &'hir [hir::GenericParam<'hir>] {
+        self.arena.alloc_from_iter(self.lower_generic_params_mut(params, add_bounds, itctx))
+    }
+
     fn lower_generic_param(
         &mut self,
         param: &GenericParam,
@@ -2593,11 +2603,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             this.lower_trait_ref(&p.trait_ref, itctx)
         });
 
-        hir::PolyTraitRef {
-            bound_generic_params: self.arena.alloc_from_iter(bound_generic_params.into_iter()),
-            trait_ref,
-            span: p.span,
-        }
+        hir::PolyTraitRef { bound_generic_params, trait_ref, span: p.span }
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_, 'hir>) -> hir::MutTy<'hir> {
@@ -3304,3 +3310,24 @@ fn body_ids(bodies: &BTreeMap<hir::BodyId, hir::Body<'hir>>) -> Vec<hir::BodyId>
     body_ids.sort_by_key(|b| bodies[b].value.span);
     body_ids
 }
+
+/// Helper struct for delayed construction of GenericArgs.
+struct GenericArgsCtor<'hir> {
+    args: Vec<hir::GenericArg<'hir>>,
+    bindings: &'hir [hir::TypeBinding<'hir>],
+    parenthesized: bool,
+}
+
+impl GenericArgsCtor<'hir> {
+    fn is_empty(&self) -> bool {
+        self.args.is_empty() && self.bindings.is_empty() && !self.parenthesized
+    }
+
+    fn into_generic_args(self, arena: &'hir Arena<'hir>) -> hir::GenericArgs<'hir> {
+        hir::GenericArgs {
+            args: arena.alloc_from_iter(self.args),
+            bindings: self.bindings,
+            parenthesized: self.parenthesized,
+        }
+    }
+}
diff --git a/src/librustc/hir/lowering/item.rs b/src/librustc/hir/lowering/item.rs
index 2fd59c4a1b11..c9dd0a23a7d1 100644
--- a/src/librustc/hir/lowering/item.rs
+++ b/src/librustc/hir/lowering/item.rs
@@ -5,6 +5,7 @@ use super::ImplTraitTypeIdVisitor;
 use super::LoweringContext;
 use super::ParamMode;
 
+use crate::arena::Arena;
 use crate::hir;
 use crate::hir::def::{DefKind, Res};
 use crate::hir::def_id::DefId;
@@ -1295,11 +1296,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    pub(super) fn lower_generics(
+    pub(super) fn lower_generics_mut(
         &mut self,
         generics: &Generics,
         itctx: ImplTraitContext<'_, 'hir>,
-    ) -> hir::Generics<'hir> {
+    ) -> GenericsCtor<'hir> {
         // Collect `?Trait` bounds in where clause and move them to parameter definitions.
         // FIXME: this could probably be done with less rightward drift. It also looks like two
         // control paths where `report_error` is called are the only paths that advance to after the
@@ -1355,13 +1356,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
         }
 
-        hir::Generics {
-            params: self.lower_generic_params(&generics.params, &add_bounds, itctx),
+        GenericsCtor {
+            params: self.lower_generic_params_mut(&generics.params, &add_bounds, itctx),
             where_clause: self.lower_where_clause(&generics.where_clause),
             span: generics.span,
         }
     }
 
+    pub(super) fn lower_generics(
+        &mut self,
+        generics: &Generics,
+        itctx: ImplTraitContext<'_, 'hir>,
+    ) -> hir::Generics<'hir> {
+        let generics_ctor = self.lower_generics_mut(generics, itctx);
+        generics_ctor.into_generics(self.arena)
+    }
+
     fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause<'hir> {
         self.with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| {
             hir::WhereClause {
@@ -1383,13 +1393,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }) => {
                 self.with_in_scope_lifetime_defs(&bound_generic_params, |this| {
                     hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
-                        bound_generic_params: this.arena.alloc_from_iter(
-                            this.lower_generic_params(
-                                bound_generic_params,
-                                &NodeMap::default(),
-                                ImplTraitContext::disallowed(),
-                            )
-                            .into_iter(),
+                        bound_generic_params: this.lower_generic_params(
+                            bound_generic_params,
+                            &NodeMap::default(),
+                            ImplTraitContext::disallowed(),
                         ),
                         bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
                         bounds: this.arena.alloc_from_iter(bounds.iter().filter_map(|bound| {
@@ -1426,3 +1433,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 }
+
+/// Helper struct for delayed construction of Generics.
+pub(super) struct GenericsCtor<'hir> {
+    pub(super) params: Vec<hir::GenericParam<'hir>>,
+    where_clause: hir::WhereClause<'hir>,
+    span: Span,
+}
+
+impl GenericsCtor<'hir> {
+    pub(super) fn into_generics(self, arena: &'hir Arena<'hir>) -> hir::Generics<'hir> {
+        hir::Generics {
+            params: arena.alloc_from_iter(self.params),
+            where_clause: self.where_clause,
+            span: self.span,
+        }
+    }
+}
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 13ae89e77b26..a66863ed77cc 100644
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -41,15 +41,6 @@ use syntax_pos::{MultiSpan, Span, DUMMY_SP};
 /// of `Vec` to avoid keeping extra capacity.
 pub type HirVec<T> = P<[T]>;
 
-macro_rules! hir_vec {
-    ($elem:expr; $n:expr) => (
-        $crate::hir::HirVec::from(vec![$elem; $n])
-    );
-    ($($x:expr),*) => (
-        $crate::hir::HirVec::from(vec![$($x),*])
-    );
-}
-
 pub mod check_attr;
 pub mod def;
 pub mod def_id;
@@ -415,7 +406,7 @@ impl GenericArg<'_> {
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
 pub struct GenericArgs<'hir> {
     /// The generic arguments for this path segment.
-    pub args: HirVec<GenericArg<'hir>>,
+    pub args: &'hir [GenericArg<'hir>],
     /// Bindings (equality constraints) on associated types, if present.
     /// E.g., `Foo<A = Bar>`.
     pub bindings: &'hir [TypeBinding<'hir>],
@@ -427,7 +418,7 @@ pub struct GenericArgs<'hir> {
 
 impl GenericArgs<'_> {
     pub const fn none() -> Self {
-        Self { args: HirVec::new(), bindings: &[], parenthesized: false }
+        Self { args: &[], bindings: &[], parenthesized: false }
     }
 
     pub fn is_empty(&self) -> bool {
@@ -436,7 +427,7 @@ impl GenericArgs<'_> {
 
     pub fn inputs(&self) -> &[Ty<'_>] {
         if self.parenthesized {
-            for arg in &self.args {
+            for arg in self.args {
                 match arg {
                     GenericArg::Lifetime(_) => {}
                     GenericArg::Type(ref ty) => {
@@ -458,7 +449,7 @@ impl GenericArgs<'_> {
         // presence of this method will be a constant reminder.
         let mut own_counts: GenericParamCount = Default::default();
 
-        for arg in &self.args {
+        for arg in self.args {
             match arg {
                 GenericArg::Lifetime(_) => own_counts.lifetimes += 1,
                 GenericArg::Type(_) => own_counts.types += 1,
@@ -555,7 +546,7 @@ pub struct GenericParamCount {
 /// of a function, enum, trait, etc.
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
 pub struct Generics<'hir> {
-    pub params: HirVec<GenericParam<'hir>>,
+    pub params: &'hir [GenericParam<'hir>],
     pub where_clause: WhereClause<'hir>,
     pub span: Span,
 }
@@ -563,7 +554,7 @@ pub struct Generics<'hir> {
 impl Generics<'hir> {
     pub const fn empty() -> Generics<'hir> {
         Generics {
-            params: HirVec::new(),
+            params: &[],
             where_clause: WhereClause { predicates: &[], span: DUMMY_SP },
             span: DUMMY_SP,
         }
@@ -575,7 +566,7 @@ impl Generics<'hir> {
         // presence of this method will be a constant reminder.
         let mut own_counts: GenericParamCount = Default::default();
 
-        for param in &self.params {
+        for param in self.params {
             match param.kind {
                 GenericParamKind::Lifetime { .. } => own_counts.lifetimes += 1,
                 GenericParamKind::Type { .. } => own_counts.types += 1,
@@ -587,7 +578,7 @@ impl Generics<'hir> {
     }
 
     pub fn get_named(&self, name: Symbol) -> Option<&GenericParam<'_>> {
-        for param in &self.params {
+        for param in self.params {
             if name == param.name.ident().name {
                 return Some(param);
             }
@@ -2128,7 +2119,7 @@ pub struct InlineAsmOutput {
 }
 
 // NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR,
-// it needs to be `Clone` and use plain `Vec<T>` instead of `HirVec<T>`.
+// it needs to be `Clone` and use plain `Vec<T>` instead of arena-allocated slice.
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable, PartialEq)]
 pub struct InlineAsmInner {
     pub asm: Symbol,
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index 61afdab3e1cf..ae760d22f751 100644
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -10,7 +10,6 @@ use syntax::util::parser::{self, AssocOp, Fixity};
 use syntax_pos::{self, BytePos, FileName};
 
 use crate::hir;
-use crate::hir::HirVec;
 use crate::hir::{GenericArg, GenericParam, GenericParamKind};
 use crate::hir::{GenericBound, PatKind, RangeEnd, TraitBoundModifier};
 
@@ -2097,7 +2096,7 @@ impl<'a> State<'a> {
             self.print_generic_params(generic_params);
         }
         let generics = hir::Generics {
-            params: HirVec::new(),
+            params: &[],
             where_clause: hir::WhereClause { predicates: &[], span: syntax_pos::DUMMY_SP },
             span: syntax_pos::DUMMY_SP,
         };
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index 29e3bcfe6a15..5f8a58636c08 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -657,7 +657,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
                 let mut elision = None;
                 let mut lifetimes = FxHashMap::default();
                 let mut non_lifetime_count = 0;
-                for param in &generics.params {
+                for param in generics.params {
                     match param.kind {
                         GenericParamKind::Lifetime { .. } => {
                             let (name, reg) = Region::early(&self.tcx.hir(), &mut index, &param);
@@ -899,7 +899,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
 
     fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
         check_mixed_explicit_and_in_band_defs(self.tcx, &generics.params);
-        for param in &generics.params {
+        for param in generics.params {
             match param.kind {
                 GenericParamKind::Lifetime { .. } => {}
                 GenericParamKind::Type { ref default, .. } => {
@@ -1996,7 +1996,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
         debug!("visit_segment_args: object_lifetime_defaults={:?}", object_lifetime_defaults);
 
         let mut i = 0;
-        for arg in &generic_args.args {
+        for arg in generic_args.args {
             match arg {
                 GenericArg::Lifetime(_) => {}
                 GenericArg::Type(ty) => {
@@ -2789,7 +2789,7 @@ fn insert_late_bound_lifetimes(
     let mut appears_in_where_clause = AllCollector::default();
     appears_in_where_clause.visit_generics(generics);
 
-    for param in &generics.params {
+    for param in generics.params {
         if let hir::GenericParamKind::Lifetime { .. } = param.kind {
             if !param.bounds.is_empty() {
                 // `'a: 'b` means both `'a` and `'b` are referenced
@@ -2809,7 +2809,7 @@ fn insert_late_bound_lifetimes(
     // - appear in the inputs
     // - do not appear in the where-clauses
     // - are not implicitly captured by `impl Trait`
-    for param in &generics.params {
+    for param in generics.params {
         match param.kind {
             hir::GenericParamKind::Lifetime { .. } => { /* fall through */ }
 
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index 0f7bdaaf582e..9cf49f8ab4b0 100644
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -841,7 +841,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
         match it.kind {
             hir::ItemKind::Fn(.., ref generics, _) => {
                 if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, sym::no_mangle) {
-                    for param in &generics.params {
+                    for param in generics.params {
                         match param.kind {
                             GenericParamKind::Lifetime { .. } => {}
                             GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
@@ -1663,7 +1663,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExplicitOutlivesRequirements {
             let mut bound_count = 0;
             let mut lint_spans = Vec::new();
 
-            for param in &hir_generics.params {
+            for param in hir_generics.params {
                 let has_lifetime_bounds = param.bounds.iter().any(|bound| {
                     if let hir::GenericBound::Outlives(_) = bound { true } else { false }
                 });
diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs
index 0fe53011d4f4..b14c9c0eb590 100644
--- a/src/librustc_metadata/rmeta/encoder.rs
+++ b/src/librustc_metadata/rmeta/encoder.rs
@@ -1569,7 +1569,7 @@ impl EncodeContext<'tcx> {
     }
 
     fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) {
-        for param in &generics.params {
+        for param in generics.params {
             let def_id = self.tcx.hir().local_def_id(param.hir_id);
             match param.kind {
                 GenericParamKind::Lifetime { .. } => continue,
diff --git a/src/librustc_mir/borrow_check/diagnostics/region_name.rs b/src/librustc_mir/borrow_check/diagnostics/region_name.rs
index 37e2b68692d5..f28539c74f44 100644
--- a/src/librustc_mir/borrow_check/diagnostics/region_name.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/region_name.rs
@@ -650,7 +650,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         args: &'hir hir::GenericArgs<'hir>,
         search_stack: &mut Vec<(Ty<'tcx>, &'hir hir::Ty<'hir>)>,
     ) -> Option<&'hir hir::Lifetime> {
-        for (kind, hir_arg) in substs.iter().zip(&args.args) {
+        for (kind, hir_arg) in substs.iter().zip(args.args) {
             match (kind.unpack(), hir_arg) {
                 (GenericArgKind::Lifetime(r), hir::GenericArg::Lifetime(lt)) => {
                     if r.to_region_vid() == needle_fr {
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index 0a783337ad15..844bebdf7b87 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -1132,7 +1132,7 @@ fn create_mono_items_for_default_impls<'tcx>(
 ) {
     match item.kind {
         hir::ItemKind::Impl(_, _, _, ref generics, .., ref impl_item_refs) => {
-            for param in &generics.params {
+            for param in generics.params {
                 match param.kind {
                     hir::GenericParamKind::Lifetime { .. } => {}
                     hir::GenericParamKind::Type { .. } | hir::GenericParamKind::Const { .. } => {
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index c00f5752e1be..d666c80b899e 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -1653,7 +1653,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
     }
 
     fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
-        for param in &generics.params {
+        for param in generics.params {
             for bound in param.bounds {
                 self.check_generic_bound(bound);
             }
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index f3ac159a3aa2..4cfa051adc18 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -6,7 +6,7 @@ use crate::hir::def::{CtorOf, DefKind, Res};
 use crate::hir::def_id::DefId;
 use crate::hir::print;
 use crate::hir::ptr::P;
-use crate::hir::{self, ExprKind, GenericArg, GenericArgs, HirVec};
+use crate::hir::{self, ExprKind, GenericArg, GenericArgs};
 use crate::lint;
 use crate::middle::lang_items::SizedTraitLangItem;
 use crate::middle::resolve_lifetime as rl;
@@ -255,8 +255,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         seg: &hir::PathSegment<'_>,
         is_method_call: bool,
     ) -> bool {
-        let empty_args =
-            P(hir::GenericArgs { args: HirVec::new(), bindings: &[], parenthesized: false });
+        let empty_args = P(hir::GenericArgs { args: &[], bindings: &[], parenthesized: false });
         let suppress_mismatch = Self::check_impl_trait(tcx, seg, &def);
         Self::check_generic_arg_count(
             tcx,
@@ -2278,7 +2277,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let mut has_err = false;
         for segment in segments {
             let (mut err_for_lt, mut err_for_ty, mut err_for_ct) = (false, false, false);
-            for arg in &segment.generic_args().args {
+            for arg in segment.generic_args().args {
                 let (span, kind) = match arg {
                     hir::GenericArg::Lifetime(lt) => {
                         if err_for_lt {
diff --git a/src/librustc_typeck/coherence/orphan.rs b/src/librustc_typeck/coherence/orphan.rs
index e1a78fffa901..b387a5d15201 100644
--- a/src/librustc_typeck/coherence/orphan.rs
+++ b/src/librustc_typeck/coherence/orphan.rs
@@ -83,7 +83,7 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> {
                 }
                 Err(traits::OrphanCheckErr::UncoveredTy(param_ty, local_type)) => {
                     let mut sp = sp;
-                    for param in &generics.params {
+                    for param in generics.params {
                         if param.name.ident().to_string() == param_ty.to_string() {
                             sp = param.span;
                         }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 9604a9ade929..1e3e6d77b926 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -117,7 +117,7 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
     }
 
     fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
-        for param in &generics.params {
+        for param in generics.params {
             match param.kind {
                 hir::GenericParamKind::Lifetime { .. } => {}
                 hir::GenericParamKind::Type { default: Some(_), .. } => {
@@ -860,7 +860,7 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<S
             outer_index: ty::INNERMOST,
             has_late_bound_regions: None,
         };
-        for param in &generics.params {
+        for param in generics.params {
             if let GenericParamKind::Lifetime { .. } = param.kind {
                 if tcx.is_late_bound(param.hir_id) {
                     return Some(param.span);
@@ -2102,7 +2102,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
 
     // Collect the predicates that were written inline by the user on each
     // type parameter (e.g., `<T: Foo>`).
-    for param in &ast_generics.params {
+    for param in ast_generics.params {
         if let GenericParamKind::Type { .. } = param.kind {
             let name = param.name.ident().name;
             let param_ty = ty::ParamTy::new(index, name).to_ty(tcx);