Box TraitAliasKind

Author: bugadani

compiler/rustc_ast/src/ast.rs

@@ -2697,6 +2697,9 @@ pub struct StructUnionKind(pub VariantData, pub Generics);
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct EnumKind(pub EnumDef, pub Generics);
 
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct TraitAliasKind(pub Generics, pub GenericBounds);
+
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum ItemKind {
     /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
@@ -2752,7 +2755,7 @@ pub enum ItemKind {
     /// Trait alias
     ///
     /// E.g., `trait Foo = Bar + Quux;`.
-    TraitAlias(Generics, GenericBounds),
+    TraitAlias(Box<TraitAliasKind>),
     /// An implementation.
     ///
     /// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
@@ -2767,7 +2770,7 @@ pub enum ItemKind {
 }
 
 #[cfg(target_arch = "x86_64")]
-rustc_data_structures::static_assert_size!(ItemKind, 104);
+rustc_data_structures::static_assert_size!(ItemKind, 72);
 
 impl ItemKind {
     pub fn article(&self) -> &str {
@@ -2809,7 +2812,7 @@ impl ItemKind {
             | Self::Struct(box StructUnionKind(_, generics))
             | Self::Union(box StructUnionKind(_, generics))
             | Self::Trait(box TraitKind(_, _, generics, ..))
-            | Self::TraitAlias(generics, _)
+            | Self::TraitAlias(box TraitAliasKind(generics, _))
             | Self::Impl(box ImplKind { generics, .. }) => Some(generics),
             _ => None,
         }

compiler/rustc_ast/src/mut_visit.rs

@@ -955,7 +955,7 @@ pub fn noop_visit_item_kind<T: MutVisitor>(kind: &mut ItemKind, vis: &mut T) {
             visit_bounds(bounds, vis);
             items.flat_map_in_place(|item| vis.flat_map_trait_item(item));
         }
-        ItemKind::TraitAlias(generics, bounds) => {
+        ItemKind::TraitAlias(box TraitAliasKind(generics, bounds)) => {
             vis.visit_generics(generics);
             visit_bounds(bounds, vis);
         }

compiler/rustc_ast/src/visit.rs

@@ -337,7 +337,7 @@ pub fn walk_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a Item) {
             walk_list!(visitor, visit_param_bound, bounds);
             walk_list!(visitor, visit_assoc_item, items, AssocCtxt::Trait);
         }
-        ItemKind::TraitAlias(ref generics, ref bounds) => {
+        ItemKind::TraitAlias(box TraitAliasKind(ref generics, ref bounds)) => {
             visitor.visit_generics(generics);
             walk_list!(visitor, visit_param_bound, bounds);
         }

compiler/rustc_ast_lowering/src/item.rs

@@ -469,10 +469,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     items,
                 )
             }
-            ItemKind::TraitAlias(ref generics, ref bounds) => hir::ItemKind::TraitAlias(
-                self.lower_generics(generics, ImplTraitContext::disallowed()),
-                self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
-            ),
+            ItemKind::TraitAlias(box TraitAliasKind(ref generics, ref bounds)) => {
+                hir::ItemKind::TraitAlias(
+                    self.lower_generics(generics, ImplTraitContext::disallowed()),
+                    self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
+                )
+            }
             ItemKind::MacroDef(..) | ItemKind::MacCall(..) => {
                 panic!("`TyMac` should have been expanded by now")
             }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1267,7 +1267,7 @@ impl<'a> State<'a> {
                 }
                 self.bclose(item.span);
             }
-            ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
+            ast::ItemKind::TraitAlias(box ast::TraitAliasKind(ref generics, ref bounds)) => {
                 self.head("");
                 self.print_visibility(&item.vis);
                 self.word_nbsp("trait");

compiler/rustc_parse/src/parser/item.rs

@@ -713,7 +713,7 @@ impl<'a> Parser<'a> {
 
             self.sess.gated_spans.gate(sym::trait_alias, whole_span);
 
-            Ok((ident, ItemKind::TraitAlias(tps, bounds)))
+            Ok((ident, ItemKind::TraitAlias(box TraitAliasKind(tps, bounds))))
         } else {
             // It's a normal trait.
             tps.where_clause = self.parse_where_clause()?;

compiler/rustc_resolve/src/late.rs

@@ -1012,7 +1012,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
                 });
             }
 
-            ItemKind::TraitAlias(ref generics, ref bounds) => {
+            ItemKind::TraitAlias(box TraitAliasKind(ref generics, ref bounds)) => {
                 // Create a new rib for the trait-wide type parameters.
                 self.with_generic_param_rib(generics, ItemRibKind(HasGenericParams::Yes), |this| {
                     let local_def_id = this.r.local_def_id(item.id).to_def_id();

src/tools/clippy/clippy_lints/src/utils/ast_utils.rs

@@ -267,8 +267,10 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 && eq_generics(lg, rg)
                 && over(lb, rb, |l, r| eq_generic_bound(l, r))
                 && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
-        },
-        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r)),
+        }
+        (TraitAlias(box TraitAliasKind(lg, lb)), TraitAlias(box TraitAliasKind(rg, rb))) => {
+            eq_generics(lg, rg) && over(lb, rb, |l, r| eq_generic_bound(l, r))
+        }
         (
             Impl(box ImplKind {
                 unsafety: lu,