Box the Generics in ItemKind::{Enum,Struct,Union,TraitAlias}.

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -2849,23 +2849,23 @@ pub enum ItemKind {
     /// An enum definition (`enum`).
     ///
     /// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
-    Enum(EnumDef, Generics),
+    Enum(EnumDef, Box<Generics>),
     /// A struct definition (`struct`).
     ///
     /// E.g., `struct Foo<A> { x: A }`.
-    Struct(VariantData, Generics),
+    Struct(VariantData, Box<Generics>),
     /// A union definition (`union`).
     ///
     /// E.g., `union Foo<A, B> { x: A, y: B }`.
-    Union(VariantData, Generics),
+    Union(VariantData, Box<Generics>),
     /// A trait declaration (`trait`).
     ///
     /// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`.
     Trait(Box<Trait>),
     /// Trait alias
     ///
     /// E.g., `trait Foo = Bar + Quux;`.
-    TraitAlias(Generics, GenericBounds),
+    TraitAlias(Box<Generics>, GenericBounds),
     /// An implementation.
     ///
     /// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
@@ -2915,11 +2915,11 @@ impl ItemKind {
         match self {
             Self::Fn(box Fn { generics, .. })
             | Self::TyAlias(box TyAlias { generics, .. })
-            | Self::Enum(_, generics)
-            | Self::Struct(_, generics)
-            | Self::Union(_, generics)
+            | Self::Enum(_, box generics)
+            | Self::Struct(_, box generics)
+            | Self::Union(_, box generics)
             | Self::Trait(box Trait { generics, .. })
-            | Self::TraitAlias(generics, _)
+            | Self::TraitAlias(box generics, _)
             | Self::Impl(box Impl { generics, .. }) => Some(generics),
             _ => None,
         }
@@ -3043,8 +3043,8 @@ mod size_asserts {
     static_assert_size!(GenericBound, 88);
     static_assert_size!(Generics, 72);
     static_assert_size!(Impl, 200);
-    static_assert_size!(Item, 200);
-    static_assert_size!(ItemKind, 112);
+    static_assert_size!(Item, 176);
+    static_assert_size!(ItemKind, 88);
     static_assert_size!(Lit, 48);
     static_assert_size!(Pat, 120);
     static_assert_size!(Path, 40);

compiler/rustc_builtin_macros/src/deriving/clone.rs

@@ -33,8 +33,8 @@ pub fn expand_deriving_clone(
     let is_simple;
     match *item {
         Annotatable::Item(ref annitem) => match annitem.kind {
-            ItemKind::Struct(_, Generics { ref params, .. })
-            | ItemKind::Enum(_, Generics { ref params, .. }) => {
+            ItemKind::Struct(_, box Generics { ref params, .. })
+            | ItemKind::Enum(_, box Generics { ref params, .. }) => {
                 let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
                 let has_derive_copy = cx.resolver.has_derive_copy(container_id);
                 if has_derive_copy

compiler/rustc_builtin_macros/src/deriving/mod.rs

@@ -184,7 +184,7 @@ fn inject_impl_of_structural_trait(
             polarity: ast::ImplPolarity::Positive,
             defaultness: ast::Defaultness::Final,
             constness: ast::Const::No,
-            generics,
+            generics: *generics,
             of_trait: Some(trait_ref),
             self_ty: self_type,
             items: Vec::new(),

compiler/rustc_parse/src/parser/item.rs

@@ -782,7 +782,7 @@ impl<'a> Parser<'a> {
 
             self.sess.gated_spans.gate(sym::trait_alias, whole_span);
 
-            Ok((ident, ItemKind::TraitAlias(generics, bounds)))
+            Ok((ident, ItemKind::TraitAlias(Box::new(generics), bounds)))
         } else {
             // It's a normal trait.
             generics.where_clause = self.parse_where_clause()?;
@@ -1258,7 +1258,7 @@ impl<'a> Parser<'a> {
             })?;
 
         let enum_definition = EnumDef { variants: variants.into_iter().flatten().collect() };
-        Ok((id, ItemKind::Enum(enum_definition, generics)))
+        Ok((id, ItemKind::Enum(enum_definition, Box::new(generics))))
     }
 
     fn parse_enum_variant(&mut self) -> PResult<'a, Option<Variant>> {
@@ -1359,7 +1359,7 @@ impl<'a> Parser<'a> {
             return Err(err);
         };
 
-        Ok((class_name, ItemKind::Struct(vdata, generics)))
+        Ok((class_name, ItemKind::Struct(vdata, Box::new(generics))))
     }
 
     /// Parses `union Foo { ... }`.
@@ -1385,7 +1385,7 @@ impl<'a> Parser<'a> {
             return Err(err);
         };
 
-        Ok((class_name, ItemKind::Union(vdata, generics)))
+        Ok((class_name, ItemKind::Union(vdata, Box::new(generics))))
     }
 
     fn parse_record_struct_body(

compiler/rustc_resolve/src/late.rs

@@ -3943,12 +3943,12 @@ impl<'ast> Visitor<'ast> for LifetimeCountVisitor<'_, '_> {
         match &item.kind {
             ItemKind::TyAlias(box TyAlias { ref generics, .. })
             | ItemKind::Fn(box Fn { ref generics, .. })
-            | ItemKind::Enum(_, ref generics)
-            | ItemKind::Struct(_, ref generics)
-            | ItemKind::Union(_, ref generics)
+            | ItemKind::Enum(_, box ref generics)
+            | ItemKind::Struct(_, box ref generics)
+            | ItemKind::Union(_, box ref generics)
             | ItemKind::Impl(box Impl { ref generics, .. })
             | ItemKind::Trait(box Trait { ref generics, .. })
-            | ItemKind::TraitAlias(ref generics, _) => {
+            | ItemKind::TraitAlias(box ref generics, _) => {
                 let def_id = self.r.local_def_id(item.id);
                 let count = generics
                     .params