Auto merge of #67032 - cjgillot:hirene, r=Zoxc

Allocate HIR on an arena 4/4

This is the fourth and last PR in the series started by #66931, #66936 and #66942.

The last commits should compile on their own.
The difference with the previous PR is given by https://github.com/cjgillot/rust/compare/hirene-ty...hirene

A few more cleanups may be necessary, please tell me.

r? @EddyB like the other
cc @Zoxc

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);
 }
 

src/librustc/hir/lowering.rs

@@ -37,8 +37,6 @@
 use crate::hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
 use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
 use crate::hir::map::{DefKey, DefPathData, Definitions};
-use crate::hir::ptr::P;
-use crate::hir::HirVec;
 use crate::hir::{self, ParamName};
 use crate::hir::{ConstArg, GenericArg};
 use crate::lint;
@@ -75,12 +73,10 @@
 use rustc_error_codes::*;
 
 macro_rules! arena_vec {
-    () => (
-        &[]
-    );
-    ($this:expr; $($x:expr),*) => (
-        $this.arena.alloc_from_iter(vec![$($x),*])
-    );
+    ($this:expr; $($x:expr),*) => ({
+        let a = [$($x),*];
+        $this.arena.alloc_from_iter(std::array::IntoIter::new(a))
+    });
 }
 
 mod expr;
@@ -540,7 +536,7 @@ fn visit_ty(&mut self, t: &'tcx Ty) {
         visit::walk_crate(&mut item::ItemLowerer { lctx: &mut self }, c);
 
         let module = self.lower_mod(&c.module);
-        let attrs = self.arena.alloc_from_iter(self.lower_attrs(&c.attrs).into_iter());
+        let attrs = self.lower_attrs(&c.attrs);
         let body_ids = body_ids(&self.bodies);
 
         self.resolver.definitions().init_node_id_to_hir_id_mapping(self.node_id_to_hir_id);
@@ -893,7 +889,7 @@ fn add_in_band_defs<F, T>(
                     // 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 +910,7 @@ fn add_in_band_defs<F, T>(
 
         lowered_generics.params = lowered_params.into();
 
+        let lowered_generics = lowered_generics.into_generics(self.arena);
         (lowered_generics, res)
     }
 
@@ -957,14 +954,10 @@ fn def_key(&mut self, id: DefId) -> DefKey {
         }
     }
 
-    fn lower_attrs_arena(&mut self, attrs: &[Attribute]) -> &'hir [Attribute] {
+    fn lower_attrs(&mut self, attrs: &[Attribute]) -> &'hir [Attribute] {
         self.arena.alloc_from_iter(attrs.iter().map(|a| self.lower_attr(a)))
     }
 
-    fn lower_attrs(&mut self, attrs: &[Attribute]) -> hir::HirVec<Attribute> {
-        attrs.iter().map(|a| self.lower_attr(a)).collect::<Vec<_>>().into()
-    }
-
     fn lower_attr(&mut self, attr: &Attribute) -> Attribute {
         // Note that we explicitly do not walk the path. Since we don't really
         // lower attributes (we use the AST version) there is nowhere to keep
@@ -1226,24 +1219,17 @@ fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext<'_, 'hir>) ->
             }
             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(),
-                            ),
-                            unsafety: f.unsafety,
-                            abi: this.lower_extern(f.ext),
-                            decl: this.lower_fn_decl(&f.decl, None, false, None),
-                            param_names: this.arena.alloc_from_iter(
-                                this.lower_fn_params_to_names(&f.decl).into_iter(),
-                            ),
-                        }),
-                    )
+                    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),
+                        decl: this.lower_fn_decl(&f.decl, None, false, None),
+                        param_names: this.lower_fn_params_to_names(&f.decl),
+                    }))
                 })
             }),
             TyKind::Never => hir::TyKind::Never,
@@ -1419,7 +1405,7 @@ fn lower_opaque_impl_trait(
 
         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,
@@ -1474,7 +1460,7 @@ fn lifetimes_from_impl_trait_bounds(
         opaque_ty_id: NodeId,
         parent_index: DefIndex,
         bounds: hir::GenericBounds<'hir>,
-    ) -> (&'hir [hir::GenericArg<'hir>], HirVec<hir::GenericParam<'hir>>) {
+    ) -> (&'hir [hir::GenericArg<'hir>], &'hir [hir::GenericParam<'hir>]) {
         debug!(
             "lifetimes_from_impl_trait_bounds(opaque_ty_id={:?}, \
              parent_index={:?}, \
@@ -1641,7 +1627,10 @@ fn visit_lifetime(&mut self, lifetime: &'v hir::Lifetime) {
         let ImplTraitLifetimeCollector { output_lifetimes, output_lifetime_params, .. } =
             lifetime_collector;
 
-        (self.arena.alloc_from_iter(output_lifetimes), output_lifetime_params.into())
+        (
+            self.arena.alloc_from_iter(output_lifetimes),
+            self.arena.alloc_from_iter(output_lifetime_params),
+        )
     }
 
     fn lower_qpath(
@@ -1809,8 +1798,8 @@ fn lower_path_extra(
         p: &Path,
         param_mode: ParamMode,
         explicit_owner: Option<NodeId>,
-    ) -> hir::Path<'hir> {
-        hir::Path {
+    ) -> &'hir hir::Path<'hir> {
+        self.arena.alloc(hir::Path {
             res,
             segments: self.arena.alloc_from_iter(p.segments.iter().map(|segment| {
                 self.lower_path_segment(
@@ -1824,10 +1813,10 @@ fn lower_path_extra(
                 )
             })),
             span: p.span,
-        }
+        })
     }
 
-    fn lower_path(&mut self, id: NodeId, p: &Path, param_mode: ParamMode) -> hir::Path<'hir> {
+    fn lower_path(&mut self, id: NodeId, p: &Path, param_mode: ParamMode) -> &'hir hir::Path<'hir> {
         let res = self.expect_full_res(id);
         let res = self.lower_res(res);
         self.lower_path_extra(res, p, param_mode, None)
@@ -1899,7 +1888,6 @@ fn lower_path_segment(
         if !generic_args.parenthesized && !has_lifetimes {
             generic_args.args = self
                 .elided_path_lifetimes(path_span, expected_lifetimes)
-                .into_iter()
                 .map(|lt| GenericArg::Lifetime(lt))
                 .chain(generic_args.args.into_iter())
                 .collect();
@@ -1978,7 +1966,11 @@ fn lower_path_segment(
             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 +1979,7 @@ fn lower_angle_bracketed_parameter_data(
         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 +1987,7 @@ fn lower_angle_bracketed_parameter_data(
             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 +2001,7 @@ fn lower_angle_bracketed_parameter_data(
     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 +2016,7 @@ fn lower_parenthesized_parameter_data(
                 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 = smallvec![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 +2024,7 @@ fn lower_parenthesized_parameter_data(
                 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,
             )
         })
@@ -2072,7 +2064,7 @@ fn lower_parenthesized_parameter_data(
         )
     }
 
-    fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> {
+    fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> &'hir [Ident] {
         // Skip the `...` (`CVarArgs`) trailing arguments from the AST,
         // as they are not explicit in HIR/Ty function signatures.
         // (instead, the `c_variadic` flag is set to `true`)
@@ -2080,13 +2072,10 @@ fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> hir::HirVec<Ident> {
         if decl.c_variadic() {
             inputs = &inputs[..inputs.len() - 1];
         }
-        inputs
-            .iter()
-            .map(|param| match param.pat.kind {
-                PatKind::Ident(_, ident, _) => ident,
-                _ => Ident::new(kw::Invalid, param.pat.span),
-            })
-            .collect()
+        self.arena.alloc_from_iter(inputs.iter().map(|param| match param.pat.kind {
+            PatKind::Ident(_, ident, _) => ident,
+            _ => Ident::new(kw::Invalid, param.pat.span),
+        }))
     }
 
     // Lowers a function declaration.
@@ -2310,12 +2299,10 @@ fn lower_async_fn_ret_ty(
             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 +2382,7 @@ fn lower_async_fn_output_type_to_future_bound(
 
         // "<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 },
@@ -2406,12 +2393,8 @@ fn lower_async_fn_output_type_to_future_bound(
         });
 
         // ::std::future::Future<future_params>
-        let future_path = self.arena.alloc(self.std_path(
-            span,
-            &[sym::future, sym::Future],
-            Some(future_params),
-            false,
-        ));
+        let future_path =
+            self.std_path(span, &[sym::future, sym::Future], Some(future_params), false);
 
         hir::GenericBound::Trait(
             hir::PolyTraitRef {
@@ -2474,16 +2457,24 @@ fn new_named_lifetime(
         hir::Lifetime { hir_id: self.lower_node_id(id), span, name }
     }
 
+    fn lower_generic_params_mut<'s>(
+        &'s mut self,
+        params: &'s [GenericParam],
+        add_bounds: &'s NodeMap<Vec<GenericBound>>,
+        mut itctx: ImplTraitContext<'s, 'hir>,
+    ) -> impl Iterator<Item = hir::GenericParam<'hir>> + Captures<'a> + Captures<'s> {
+        params
+            .iter()
+            .map(move |param| self.lower_generic_param(param, add_bounds, itctx.reborrow()))
+    }
+
     fn lower_generic_params(
         &mut self,
         params: &[GenericParam],
         add_bounds: &NodeMap<Vec<GenericBound>>,
-        mut itctx: ImplTraitContext<'_, 'hir>,
-    ) -> HirVec<hir::GenericParam<'hir>> {
-        params
-            .iter()
-            .map(|param| self.lower_generic_param(param, add_bounds, itctx.reborrow()))
-            .collect()
+        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(
@@ -2561,7 +2552,7 @@ fn lower_generic_param(
             name,
             span: param.ident.span,
             pure_wrt_drop: attr::contains_name(&param.attrs, sym::may_dangle),
-            attrs: self.lower_attrs_arena(&param.attrs),
+            attrs: self.lower_attrs(&param.attrs),
             bounds: self.arena.alloc_from_iter(bounds),
             kind,
         }
@@ -2593,11 +2584,7 @@ fn lower_poly_trait_ref(
             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> {
@@ -3053,7 +3040,7 @@ fn pat_std_enum(
         subpats: &'hir [&'hir hir::Pat<'hir>],
     ) -> &'hir hir::Pat<'hir> {
         let path = self.std_path(span, components, None, true);
-        let qpath = hir::QPath::Resolved(None, self.arena.alloc(path));
+        let qpath = hir::QPath::Resolved(None, path);
         let pt = if subpats.is_empty() {
             hir::PatKind::Path(qpath)
         } else {
@@ -3101,7 +3088,7 @@ fn std_path(
         components: &[Symbol],
         params: Option<&'hir hir::GenericArgs<'hir>>,
         is_value: bool,
-    ) -> hir::Path<'hir> {
+    ) -> &'hir hir::Path<'hir> {
         let ns = if is_value { Namespace::ValueNS } else { Namespace::TypeNS };
         let (path, res) = self.resolver.resolve_str_path(span, self.crate_root, components, ns);
 
@@ -3121,11 +3108,11 @@ fn std_path(
             .collect();
         segments.last_mut().unwrap().args = params;
 
-        hir::Path {
+        self.arena.alloc(hir::Path {
             span,
             res: res.map_id(|_| panic!("unexpected `NodeId`")),
             segments: self.arena.alloc_from_iter(segments),
-        }
+        })
     }
 
     fn ty_path(
@@ -3209,8 +3196,12 @@ fn new_error_lifetime(&mut self, id: Option<NodeId>, span: Span) -> hir::Lifetim
     /// `std::cell::Ref<T>`; note that implicit lifetimes in these
     /// sorts of cases are deprecated. This may therefore report a warning or an
     /// error, depending on the mode.
-    fn elided_path_lifetimes(&mut self, span: Span, count: usize) -> P<[hir::Lifetime]> {
-        (0..count).map(|_| self.elided_path_lifetime(span)).collect()
+    fn elided_path_lifetimes<'s>(
+        &'s mut self,
+        span: Span,
+        count: usize,
+    ) -> impl Iterator<Item = hir::Lifetime> + Captures<'a> + Captures<'s> + Captures<'hir> {
+        (0..count).map(move |_| self.elided_path_lifetime(span))
     }
 
     fn elided_path_lifetime(&mut self, span: Span) -> hir::Lifetime {
@@ -3304,3 +3295,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: SmallVec<[hir::GenericArg<'hir>; 4]>,
+    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,
+        }
+    }
+}

src/librustc/hir/lowering/expr.rs

@@ -464,7 +464,7 @@ fn wrap_in_try_constructor(
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
         hir::Arm {
             hir_id: self.next_id(),
-            attrs: self.lower_attrs_arena(&arm.attrs),
+            attrs: self.lower_attrs(&arm.attrs),
             pat: self.lower_pat(&arm.pat),
             guard: match arm.guard {
                 Some(ref x) => Some(hir::Guard::If(self.lower_expr(x))),
@@ -827,7 +827,7 @@ fn lower_expr_range(
         let is_unit = fields.is_empty();
         let struct_path = [sym::ops, path];
         let struct_path = self.std_path(span, &struct_path, None, is_unit);
-        let struct_path = hir::QPath::Resolved(None, self.arena.alloc(struct_path));
+        let struct_path = hir::QPath::Resolved(None, struct_path);
 
         if is_unit {
             hir::ExprKind::Path(struct_path)
@@ -1336,7 +1336,7 @@ fn expr_call_std_assoc_fn(
         assoc_fn_name: &str,
         args: &'hir [hir::Expr<'hir>],
     ) -> hir::ExprKind<'hir> {
-        let ty_path = self.arena.alloc(self.std_path(span, ty_path_components, None, false));
+        let ty_path = self.std_path(span, ty_path_components, None, false);
         let ty =
             self.arena.alloc(self.ty_path(ty_path_id, span, hir::QPath::Resolved(None, ty_path)));
         let fn_seg = self.arena.alloc(hir::PathSegment::from_ident(Ident::from_str(assoc_fn_name)));
@@ -1354,11 +1354,7 @@ fn expr_std_path(
         attrs: AttrVec,
     ) -> hir::Expr<'hir> {
         let path = self.std_path(span, components, params, true);
-        self.expr(
-            span,
-            hir::ExprKind::Path(hir::QPath::Resolved(None, self.arena.alloc(path))),
-            attrs,
-        )
+        self.expr(span, hir::ExprKind::Path(hir::QPath::Resolved(None, path)), attrs)
     }
 
     pub(super) fn expr_ident(

src/librustc/hir/lowering/item.rs

@@ -5,6 +5,7 @@
 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;
@@ -225,7 +226,7 @@ fn lower_item_id_use_tree(
     pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item<'hir>> {
         let mut ident = i.ident;
         let mut vis = self.lower_visibility(&i.vis, None);
-        let attrs = self.lower_attrs_arena(&i.attrs);
+        let attrs = self.lower_attrs(&i.attrs);
 
         if let ItemKind::MacroDef(ref def) = i.kind {
             if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) {
@@ -506,7 +507,7 @@ fn lower_use_tree(
                         let new_id = this.lower_node_id(new_node_id);
                         let res = this.lower_res(res);
                         let path = this.lower_path_extra(res, &path, ParamMode::Explicit, None);
-                        let kind = hir::ItemKind::Use(this.arena.alloc(path), hir::UseKind::Single);
+                        let kind = hir::ItemKind::Use(path, hir::UseKind::Single);
                         let vis = this.rebuild_vis(&vis);
 
                         this.insert_item(hir::Item {
@@ -521,15 +522,11 @@ fn lower_use_tree(
                 }
 
                 let path = self.lower_path_extra(ret_res, &path, ParamMode::Explicit, None);
-                let path = self.arena.alloc(path);
                 hir::ItemKind::Use(path, hir::UseKind::Single)
             }
             UseTreeKind::Glob => {
-                let path = self.arena.alloc(self.lower_path(
-                    id,
-                    &Path { segments, span: path.span },
-                    ParamMode::Explicit,
-                ));
+                let path =
+                    self.lower_path(id, &Path { segments, span: path.span }, ParamMode::Explicit);
                 hir::ItemKind::Use(path, hir::UseKind::Glob)
             }
             UseTreeKind::Nested(ref trees) => {
@@ -617,7 +614,6 @@ fn lower_use_tree(
                 let res = self.expect_full_res_from_use(id).next().unwrap_or(Res::Err);
                 let res = self.lower_res(res);
                 let path = self.lower_path_extra(res, &prefix, ParamMode::Explicit, None);
-                let path = self.arena.alloc(path);
                 hir::ItemKind::Use(path, hir::UseKind::ListStem)
             }
         }
@@ -626,7 +622,7 @@ fn lower_use_tree(
     /// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
     /// many times in the HIR tree; for each occurrence, we need to assign distinct
     /// `NodeId`s. (See, e.g., #56128.)
-    fn rebuild_use_path(&mut self, path: &hir::Path<'hir>) -> hir::Path<'hir> {
+    fn rebuild_use_path(&mut self, path: &hir::Path<'hir>) -> &'hir hir::Path<'hir> {
         debug!("rebuild_use_path(path = {:?})", path);
         let segments =
             self.arena.alloc_from_iter(path.segments.iter().map(|seg| hir::PathSegment {
@@ -636,7 +632,7 @@ fn rebuild_use_path(&mut self, path: &hir::Path<'hir>) -> hir::Path<'hir> {
                 args: None,
                 infer_args: seg.infer_args,
             }));
-        hir::Path { span: path.span, res: path.res, segments }
+        self.arena.alloc(hir::Path { span: path.span, res: path.res, segments })
     }
 
     fn rebuild_vis(&mut self, vis: &hir::Visibility<'hir>) -> hir::Visibility<'hir> {
@@ -646,7 +642,7 @@ fn rebuild_vis(&mut self, vis: &hir::Visibility<'hir>) -> hir::Visibility<'hir>
             hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
             hir::VisibilityKind::Restricted { ref path, hir_id: _ } => {
                 hir::VisibilityKind::Restricted {
-                    path: self.arena.alloc(self.rebuild_use_path(path)),
+                    path: self.rebuild_use_path(path),
                     hir_id: self.next_id(),
                 }
             }
@@ -659,7 +655,7 @@ fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem<'hir> {
         hir::ForeignItem {
             hir_id: self.lower_node_id(i.id),
             ident: i.ident,
-            attrs: self.lower_attrs_arena(&i.attrs),
+            attrs: self.lower_attrs(&i.attrs),
             kind: match i.kind {
                 ForeignItemKind::Fn(ref fdec, ref generics) => {
                     let (generics, (fn_dec, fn_args)) = self.add_in_band_defs(
@@ -674,7 +670,6 @@ fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem<'hir> {
                             )
                         },
                     );
-                    let fn_args = self.arena.alloc_from_iter(fn_args.into_iter());
 
                     hir::ForeignItemKind::Fn(fn_dec, fn_args, generics)
                 }
@@ -703,7 +698,7 @@ fn lower_global_asm(&mut self, ga: &GlobalAsm) -> &'hir hir::GlobalAsm {
 
     fn lower_variant(&mut self, v: &Variant) -> hir::Variant<'hir> {
         hir::Variant {
-            attrs: self.lower_attrs_arena(&v.attrs),
+            attrs: self.lower_attrs(&v.attrs),
             data: self.lower_variant_data(&v.data),
             disr_expr: v.disr_expr.as_ref().map(|e| self.lower_anon_const(e)),
             id: self.lower_node_id(v.id),
@@ -751,7 +746,7 @@ fn lower_struct_field(&mut self, (index, f): (usize, &StructField)) -> hir::Stru
             },
             vis: self.lower_visibility(&f.vis, None),
             ty,
-            attrs: self.lower_attrs_arena(&f.attrs),
+            attrs: self.lower_attrs(&f.attrs),
         }
     }
 
@@ -772,7 +767,6 @@ fn lower_trait_item(&mut self, i: &AssocItem) -> hir::TraitItem<'hir> {
             }
             AssocItemKind::Fn(ref sig, None) => {
                 let names = self.lower_fn_params_to_names(&sig.decl);
-                let names: &[Ident] = self.arena.alloc_from_iter(names.into_iter());
                 let (generics, sig) =
                     self.lower_method_sig(&i.generics, sig, trait_item_def_id, false, None);
                 (generics, hir::TraitItemKind::Method(sig, hir::TraitMethod::Required(names)))
@@ -799,7 +793,7 @@ fn lower_trait_item(&mut self, i: &AssocItem) -> hir::TraitItem<'hir> {
         hir::TraitItem {
             hir_id: self.lower_node_id(i.id),
             ident: i.ident,
-            attrs: self.lower_attrs_arena(&i.attrs),
+            attrs: self.lower_attrs(&i.attrs),
             generics,
             kind,
             span: i.span,
@@ -886,7 +880,7 @@ fn lower_impl_item(&mut self, i: &AssocItem) -> hir::ImplItem<'hir> {
         hir::ImplItem {
             hir_id: self.lower_node_id(i.id),
             ident: i.ident,
-            attrs: self.lower_attrs_arena(&i.attrs),
+            attrs: self.lower_attrs(&i.attrs),
             generics,
             vis: self.lower_visibility(&i.vis, None),
             defaultness: self.lower_defaultness(i.defaultness, true /* [1] */),
@@ -945,12 +939,7 @@ fn lower_visibility(
                 let res = self.expect_full_res(id);
                 let res = self.lower_res(res);
                 hir::VisibilityKind::Restricted {
-                    path: self.arena.alloc(self.lower_path_extra(
-                        res,
-                        path,
-                        ParamMode::Explicit,
-                        explicit_owner,
-                    )),
+                    path: self.lower_path_extra(res, path, ParamMode::Explicit, explicit_owner),
                     hir_id: lowered_id,
                 }
             }
@@ -993,7 +982,7 @@ fn lower_body(
 
     fn lower_param(&mut self, param: &Param) -> hir::Param<'hir> {
         hir::Param {
-            attrs: self.lower_attrs_arena(&param.attrs),
+            attrs: self.lower_attrs(&param.attrs),
             hir_id: self.lower_node_id(param.id),
             pat: self.lower_pat(&param.pat),
             span: param.span,
@@ -1133,7 +1122,7 @@ fn lower_maybe_async_body(
                     let stmt = this.stmt_let_pat(
                         stmt_attrs,
                         desugared_span,
-                        Some(this.arena.alloc(expr)),
+                        Some(expr),
                         parameter.pat,
                         hir::LocalSource::AsyncFn,
                     );
@@ -1163,7 +1152,7 @@ fn lower_maybe_async_body(
                     let move_stmt = this.stmt_let_pat(
                         AttrVec::new(),
                         desugared_span,
-                        Some(this.arena.alloc(move_expr)),
+                        Some(move_expr),
                         move_pat,
                         hir::LocalSource::AsyncFn,
                     );
@@ -1174,7 +1163,7 @@ fn lower_maybe_async_body(
                     let pattern_stmt = this.stmt_let_pat(
                         stmt_attrs,
                         desugared_span,
-                        Some(this.arena.alloc(pattern_expr)),
+                        Some(pattern_expr),
                         parameter.pat,
                         hir::LocalSource::AsyncFn,
                     );
@@ -1295,11 +1284,11 @@ fn lower_asyncness(&mut self, a: IsAsync) -> hir::IsAsync {
         }
     }
 
-    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 +1344,22 @@ pub(super) fn lower_generics(
             }
         }
 
-        hir::Generics {
-            params: self.lower_generic_params(&generics.params, &add_bounds, itctx),
+        GenericsCtor {
+            params: self.lower_generic_params_mut(&generics.params, &add_bounds, itctx).collect(),
             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 +1381,10 @@ fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicat
             }) => {
                 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 +1421,20 @@ fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicat
         }
     }
 }
+
+/// Helper struct for delayed construction of Generics.
+pub(super) struct GenericsCtor<'hir> {
+    pub(super) params: SmallVec<[hir::GenericParam<'hir>; 4]>,
+    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,
+        }
+    }
+}

src/librustc/hir/mod.rs

@@ -10,7 +10,6 @@
 
 use crate::hir::def::{DefKind, Res};
 use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
-use crate::hir::ptr::P;
 use crate::mir::mono::Linkage;
 use crate::ty::query::Providers;
 use crate::ty::AdtKind;
@@ -35,21 +34,6 @@
 use syntax_pos::symbol::{kw, sym, Symbol};
 use syntax_pos::{MultiSpan, Span, DUMMY_SP};
 
-/// HIR doesn't commit to a concrete storage type and has its own alias for a vector.
-/// It can be `Vec`, `P<[T]>` or potentially `Box<[T]>`, or some other container with similar
-/// behavior. Unlike AST, HIR is mostly a static structure, so we can use an owned slice instead
-/// 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;
@@ -59,7 +43,6 @@
 pub mod map;
 pub mod pat_util;
 pub mod print;
-pub mod ptr;
 pub mod upvars;
 
 /// Uniquely identifies a node in the HIR of the current crate. It is
@@ -415,7 +398,7 @@ pub fn is_const(&self) -> bool {
 #[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 +410,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 +419,7 @@ pub fn is_empty(&self) -> bool {
 
     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 +441,7 @@ pub fn own_counts(&self) -> GenericParamCount {
         // 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 +538,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 +546,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 +558,7 @@ pub fn own_counts(&self) -> GenericParamCount {
         // 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 +570,7 @@ pub fn own_counts(&self) -> GenericParamCount {
     }
 
     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 +2111,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,

src/librustc/hir/print.rs

@@ -10,7 +10,6 @@
 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 @@ pub fn print_ty_fn(
             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,
         };

src/librustc/hir/ptr.rs

-// HACK(eddyb) this is a copy of `syntax::ptr`, minus the mutation (the HIR is
-// frozen anyway). The only reason for doing this instead of replacing `P<T>`
-// with `Box<T>` in HIR, is that `&Box<[T]>` doesn't implement `IntoIterator`.
-
-use std::fmt::{self, Debug, Display};
-use std::iter::FromIterator;
-use std::ops::Deref;
-use std::{slice, vec};
-
-use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
-
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-/// An owned smart pointer.
-#[derive(PartialEq, Eq)]
-pub struct P<T: ?Sized> {
-    ptr: Box<T>,
-}
-
-/// Construct a `P<T>` from a `T` value.
-#[allow(non_snake_case)]
-pub fn P<T: 'static>(value: T) -> P<T> {
-    P { ptr: box value }
-}
-
-impl<T: ?Sized> Deref for P<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.ptr
-    }
-}
-
-impl<T: ?Sized + Debug> Debug for P<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Debug::fmt(&self.ptr, f)
-    }
-}
-
-impl<T: Display> Display for P<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&**self, f)
-    }
-}
-
-impl<T: 'static + Decodable> Decodable for P<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<P<T>, D::Error> {
-        Decodable::decode(d).map(P)
-    }
-}
-
-impl<T: Encodable> Encodable for P<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T> P<[T]> {
-    pub const fn new() -> P<[T]> {
-        // HACK(eddyb) bypass the lack of a `const fn` to create an empty `Box<[T]>`
-        // (as trait methods, `default` in this case, can't be `const fn` yet).
-        P {
-            ptr: unsafe {
-                use std::ptr::NonNull;
-                std::mem::transmute(NonNull::<[T; 0]>::dangling() as NonNull<[T]>)
-            },
-        }
-    }
-
-    #[inline(never)]
-    pub fn from_vec(v: Vec<T>) -> P<[T]> {
-        P { ptr: v.into_boxed_slice() }
-    }
-
-    // HACK(eddyb) used by HIR lowering in a few places still.
-    // NOTE: do not make this more public than `pub(super)`,
-    // and do not make this into an `IntoIterator` impl.
-    pub(super) fn into_iter(self) -> vec::IntoIter<T> {
-        self.ptr.into_vec().into_iter()
-    }
-}
-
-impl<T> Default for P<[T]> {
-    /// Creates an empty `P<[T]>`.
-    fn default() -> P<[T]> {
-        P::new()
-    }
-}
-
-impl<T> From<Vec<T>> for P<[T]> {
-    fn from(v: Vec<T>) -> Self {
-        P::from_vec(v)
-    }
-}
-
-impl<T> FromIterator<T> for P<[T]> {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> P<[T]> {
-        P::from_vec(iter.into_iter().collect())
-    }
-}
-
-impl<'a, T> IntoIterator for &'a P<[T]> {
-    type Item = &'a T;
-    type IntoIter = slice::Iter<'a, T>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.ptr.into_iter()
-    }
-}
-
-impl<T: Encodable> Encodable for P<[T]> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        Encodable::encode(&**self, s)
-    }
-}
-
-impl<T: Decodable> Decodable for P<[T]> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<P<[T]>, D::Error> {
-        Ok(P::from_vec(Decodable::decode(d)?))
-    }
-}
-
-impl<CTX, T> HashStable<CTX> for P<T>
-where
-    T: ?Sized + HashStable<CTX>,
-{
-    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        (**self).hash_stable(hcx, hasher);
-    }
-}

src/librustc/lib.rs

@@ -28,6 +28,7 @@
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
 #![feature(arbitrary_self_types)]
+#![feature(array_value_iter)]
 #![feature(bool_to_option)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]

src/librustc/middle/resolve_lifetime.rs

@@ -657,7 +657,7 @@ fn visit_ty(&mut self, ty: &'tcx hir::Ty<'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 @@ fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl<'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 @@ fn visit_segment_args(
         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 */ }
 

src/librustc_lint/builtin.rs

@@ -841,7 +841,7 @@ fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item<'_>) {
         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 @@ fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item<'_>)
             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 }
                 });

src/librustc_metadata/rmeta/encoder.rs

@@ -1569,7 +1569,7 @@ fn encode_fields(&mut self, adt_def_id: DefId) {
     }
 
     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,

src/librustc_mir/borrow_check/diagnostics/region_name.rs

@@ -619,7 +619,7 @@ fn try_match_adt_and_generic_args<'hir>(
         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 {

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 { .. } => {

src/librustc_privacy/lib.rs

@@ -1653,7 +1653,7 @@ fn visit_item(&mut self, item: &'tcx hir::Item<'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);
             }

src/librustc_typeck/astconv.rs

@@ -5,8 +5,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 +254,7 @@ pub fn check_generic_arg_count_for_call(
         seg: &hir::PathSegment<'_>,
         is_method_call: bool,
     ) -> bool {
-        let empty_args =
-            P(hir::GenericArgs { args: HirVec::new(), bindings: &[], parenthesized: false });
+        let empty_args = hir::GenericArgs::none();
         let suppress_mismatch = Self::check_impl_trait(tcx, seg, &def);
         Self::check_generic_arg_count(
             tcx,
@@ -2278,7 +2276,7 @@ pub fn prohibit_generics<'a, T: IntoIterator<Item = &'a hir::PathSegment<'a>>>(
         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 {

src/librustc_typeck/check/coercion.rs

@@ -54,7 +54,6 @@
 use errors::DiagnosticBuilder;
 use rustc::hir;
 use rustc::hir::def_id::DefId;
-use rustc::hir::ptr::P;
 use rustc::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc::infer::{Coercion, InferOk, InferResult};
 use rustc::traits::{self, ObligationCause, ObligationCauseCode};
@@ -1377,12 +1376,6 @@ fn as_coercion_site(&self) -> &hir::Expr<'_> {
     }
 }
 
-impl AsCoercionSite for P<hir::Expr<'_>> {
-    fn as_coercion_site(&self) -> &hir::Expr<'_> {
-        self
-    }
-}
-
 impl<'a, T> AsCoercionSite for &'a T
 where
     T: AsCoercionSite,

src/librustc_typeck/coherence/orphan.rs

@@ -83,7 +83,7 @@ fn visit_item(&mut self, item: &hir::Item<'_>) {
                 }
                 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;
                         }

src/librustc_typeck/collect.rs

@@ -117,7 +117,7 @@ fn visit_item(&mut self, item: &'tcx hir::Item<'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>(
             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 extend<I: IntoIterator<Item = (ty::Predicate<'tcx>, Span)>>(&mut self, iter:
 
     // 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);

src/librustdoc/clean/inline.rs

@@ -474,7 +474,7 @@ fn build_macro(cx: &DocContext<'_>, did: DefId, name: ast::Name) -> clean::ItemE
     let imported_from = cx.tcx.original_crate_name(did.krate);
     match cx.enter_resolver(|r| r.cstore().load_macro_untracked(did, cx.sess())) {
         LoadedMacro::MacroDef(def, _) => {
-            let matchers: hir::HirVec<Span> = if let ast::ItemKind::MacroDef(ref def) = def.kind {
+            let matchers: Vec<Span> = if let ast::ItemKind::MacroDef(ref def) = def.kind {
                 let tts: Vec<_> = def.body.inner_tokens().into_trees().collect();
                 tts.chunks(4).map(|arm| arm[0].span()).collect()
             } else {

src/librustdoc/clean/mod.rs

@@ -12,7 +12,6 @@
 use rustc::hir;
 use rustc::hir::def::{CtorKind, DefKind, Res};
 use rustc::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
-use rustc::hir::ptr::P;
 use rustc::infer::region_constraints::{Constraint, RegionConstraintData};
 use rustc::middle::lang_items;
 use rustc::middle::resolve_lifetime as rl;
@@ -74,12 +73,6 @@ fn clean(&self, cx: &DocContext<'_>) -> U {
     }
 }
 
-impl<T: Clean<U>, U> Clean<U> for P<T> {
-    fn clean(&self, cx: &DocContext<'_>) -> U {
-        (**self).clean(cx)
-    }
-}
-
 impl<T: Clean<U>, U> Clean<U> for Rc<T> {
     fn clean(&self, cx: &DocContext<'_>) -> U {
         (**self).clean(cx)
@@ -101,12 +94,6 @@ fn clean(&self, cx: &DocContext<'_>) -> U {
     }
 }
 
-impl<T: Clean<U>, U> Clean<Vec<U>> for P<[T]> {
-    fn clean(&self, cx: &DocContext<'_>) -> Vec<U> {
-        self.iter().map(|x| x.clean(cx)).collect()
-    }
-}
-
 impl Clean<ExternalCrate> for CrateNum {
     fn clean(&self, cx: &DocContext<'_>) -> ExternalCrate {
         let root = DefId { krate: *self, index: CRATE_DEF_INDEX };

src/librustdoc/doctree.rs

@@ -230,7 +230,7 @@ pub struct Macro<'hir> {
     pub def_id: hir::def_id::DefId,
     pub attrs: &'hir [ast::Attribute],
     pub whence: Span,
-    pub matchers: hir::HirVec<Span>,
+    pub matchers: Vec<Span>,
     pub imported_from: Option<Name>,
 }