Box ItemKind::Impl

This brings the size of ItemKind down from 128 to 88 bytes.
Hopefully this will have perf improvements.

Author: jyn514

compiler/rustc_ast_lowering/src/item.rs

@@ -134,7 +134,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let old_len = self.in_scope_lifetimes.len();
 
         let parent_generics = match self.items.get(&parent_hir_id).unwrap().kind {
-            hir::ItemKind::Impl(hir::Impl { ref generics, .. })
+            hir::ItemKind::Impl(box hir::Impl { ref generics, .. })
             | hir::ItemKind::Trait(_, _, ref generics, ..) => &generics.params[..],
             _ => &[],
         };
@@ -431,7 +431,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // to not cause an assertion failure inside the `lower_defaultness` function.
                 let has_val = true;
                 let (defaultness, defaultness_span) = self.lower_defaultness(defaultness, has_val);
-                hir::ItemKind::Impl(hir::Impl {
+                hir::ItemKind::Impl(box hir::Impl {
                     unsafety: self.lower_unsafety(unsafety),
                     polarity,
                     defaultness,

compiler/rustc_ast_lowering/src/lib.rs

@@ -31,6 +31,8 @@
 //! in the HIR, especially for multiple identifiers.
 
 #![feature(array_value_iter)]
+#![feature(box_patterns)]
+#![feature(box_syntax)]
 #![feature(crate_visibility_modifier)]
 #![feature(or_patterns)]
 #![recursion_limit = "256"]

compiler/rustc_hir/src/hir.rs

@@ -2562,9 +2562,12 @@ pub enum ItemKind<'hir> {
     TraitAlias(Generics<'hir>, GenericBounds<'hir>),
 
     /// An implementation, e.g., `impl<A> Trait for Foo { .. }`.
-    Impl(Impl<'hir>),
+    Impl(Box<Impl<'hir>>),
 }
 
+#[cfg(target_arch = "x86_64")]
+static_assert_size!(ItemKind<'_>, 88);
+
 #[derive(Debug, HashStable_Generic)]
 pub struct Impl<'hir> {
     pub unsafety: Unsafety,
@@ -2593,7 +2596,7 @@ impl ItemKind<'_> {
             | ItemKind::Struct(_, ref generics)
             | ItemKind::Union(_, ref generics)
             | ItemKind::Trait(_, _, ref generics, _, _)
-            | ItemKind::Impl(Impl { ref generics, .. }) => generics,
+            | ItemKind::Impl(box Impl { ref generics, .. }) => generics,
             _ => return None,
         })
     }

compiler/rustc_hir/src/intravisit.rs

@@ -611,7 +611,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
             // `visit_enum_def()` takes care of visiting the `Item`'s `HirId`.
             visitor.visit_enum_def(enum_definition, generics, item.hir_id, item.span)
         }
-        ItemKind::Impl(Impl {
+        ItemKind::Impl(box Impl {
             unsafety: _,
             defaultness: _,
             polarity: _,

compiler/rustc_hir/src/lib.rs

@@ -3,6 +3,7 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 
 #![feature(array_value_iter)]
+#![feature(box_patterns)]
 #![feature(crate_visibility_modifier)]
 #![feature(const_fn)] // For the unsizing cast on `&[]`
 #![feature(const_panic)]

compiler/rustc_hir_pretty/src/lib.rs

@@ -1,3 +1,4 @@
+#![feature(box_patterns)]
 #![feature(or_patterns)]
 #![recursion_limit = "256"]
 
@@ -684,7 +685,7 @@ impl<'a> State<'a> {
                 self.head(visibility_qualified(&item.vis, "union"));
                 self.print_struct(struct_def, generics, item.ident.name, item.span, true);
             }
-            hir::ItemKind::Impl(hir::Impl {
+            hir::ItemKind::Impl(box hir::Impl {
                 unsafety,
                 polarity,
                 defaultness,

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -346,7 +346,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
             Some(Node::ImplItem(ImplItem { ident, hir_id, .. })) => {
                 match tcx.hir().find(tcx.hir().get_parent_item(*hir_id)) {
                     Some(Node::Item(Item {
-                        kind: ItemKind::Impl(hir::Impl { self_ty, .. }),
+                        kind: ItemKind::Impl(box hir::Impl { self_ty, .. }),
                         ..
                     })) => Some((*ident, self_ty)),
                     _ => None,
@@ -368,7 +368,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                                 let impl_did = tcx.hir().local_def_id(*impl_node);
                                 match tcx.hir().get_if_local(impl_did.to_def_id()) {
                                     Some(Node::Item(Item {
-                                        kind: ItemKind::Impl(hir::Impl { self_ty, .. }),
+                                        kind: ItemKind::Impl(box hir::Impl { self_ty, .. }),
                                         ..
                                     })) if trait_objects.iter().all(|did| {
                                         // FIXME: we should check `self_ty` against the receiver

compiler/rustc_lint/src/builtin.rs

@@ -542,7 +542,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
                     return;
                 }
             }
-            hir::ItemKind::Impl(hir::Impl { of_trait: Some(ref trait_ref), items, .. }) => {
+            hir::ItemKind::Impl(box hir::Impl { of_trait: Some(ref trait_ref), items, .. }) => {
                 // If the trait is private, add the impl items to `private_traits` so they don't get
                 // reported for missing docs.
                 let real_trait = trait_ref.path.res.def_id();

compiler/rustc_lint/src/lib.rs

@@ -29,6 +29,7 @@
 #![cfg_attr(test, feature(test))]
 #![feature(array_windows)]
 #![feature(bool_to_option)]
+#![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(crate_visibility_modifier)]
 #![feature(iter_order_by)]

compiler/rustc_metadata/src/lib.rs

@@ -1,4 +1,5 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
+#![feature(box_patterns)]
 #![feature(core_intrinsics)]
 #![feature(crate_visibility_modifier)]
 #![feature(drain_filter)]