Unrolled build for #155702

Rollup merge of #155702 - mejrs:itemkind_trait-fields, r=petrochenkov

Change `ItemKind::Trait` to a field variant.

This changes `ItemKind::Trait` from an octuple(!!) to an enum variant with fields. Their names were chosen to match up with existing usage and minimize renaming.

I'm leaning towards renaming `ident` to `name` as well; let me know if that's desired.

Author: rust-timer

compiler/rustc_ast_lowering/src/item.rs

@@ -569,16 +569,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (safety, items, bounds)
                     },
                 );
-                hir::ItemKind::Trait(
+                hir::ItemKind::Trait {
                     impl_restriction,
                     constness,
-                    *is_auto,
+                    is_auto: *is_auto,
                     safety,
                     ident,
                     generics,
                     bounds,
                     items,
-                )
+                }
             }
             ItemKind::TraitAlias(box TraitAlias { constness, ident, generics, bounds }) => {
                 let constness = self.lower_constness(*constness);

compiler/rustc_hir/src/hir.rs

@@ -4467,7 +4467,7 @@ impl<'hir> Item<'hir> {
                 GenericBounds<'hir>,
                 &'hir [TraitItemId]
             ),
-            ItemKind::Trait(impl_restriction, constness, is_auto, safety, ident, generics, bounds, items),
+            ItemKind::Trait { impl_restriction, constness, is_auto, safety, ident, generics, bounds, items },
             (impl_restriction, *constness, *is_auto, *safety, *ident, generics, bounds, items);
 
         expect_trait_alias, (Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
@@ -4659,16 +4659,16 @@ pub enum ItemKind<'hir> {
     /// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
     Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
     /// A trait definition.
-    Trait(
-        &'hir ImplRestriction<'hir>,
-        Constness,
-        IsAuto,
-        Safety,
-        Ident,
-        &'hir Generics<'hir>,
-        GenericBounds<'hir>,
-        &'hir [TraitItemId],
-    ),
+    Trait {
+        impl_restriction: &'hir ImplRestriction<'hir>,
+        constness: Constness,
+        is_auto: IsAuto,
+        safety: Safety,
+        ident: Ident,
+        generics: &'hir Generics<'hir>,
+        bounds: GenericBounds<'hir>,
+        items: &'hir [TraitItemId],
+    },
     /// A trait alias.
     TraitAlias(Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
@@ -4714,7 +4714,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(ident, ..)
             | ItemKind::Struct(ident, ..)
             | ItemKind::Union(ident, ..)
-            | ItemKind::Trait(_, _, _, _, ident, ..)
+            | ItemKind::Trait { ident, .. }
             | ItemKind::TraitAlias(_, ident, ..) => Some(ident),
 
             ItemKind::Use(_, UseKind::Glob | UseKind::ListStem)
@@ -4732,7 +4732,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(_, generics, _)
             | ItemKind::Struct(_, generics, _)
             | ItemKind::Union(_, generics, _)
-            | ItemKind::Trait(_, _, _, _, _, generics, _, _)
+            | ItemKind::Trait { generics, .. }
             | ItemKind::TraitAlias(_, _, generics, _)
             | ItemKind::Impl(Impl { generics, .. }) => generics,
             _ => return None,

compiler/rustc_hir/src/intravisit.rs

@@ -618,16 +618,16 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_variant_data(struct_definition));
         }
-        ItemKind::Trait(
-            ref impl_restriction,
-            _constness,
-            _is_auto,
-            _safety,
+        ItemKind::Trait {
+            impl_restriction,
+            constness: _,
+            is_auto: _,
+            safety: _,
             ident,
-            ref generics,
+            generics,
             bounds,
-            trait_item_refs,
-        ) => {
+            items: trait_item_refs,
+        } => {
             if let RestrictionKind::Restricted(path) = &impl_restriction.kind {
                 walk_list!(visitor, visit_path_segment, path.segments);
             }

compiler/rustc_hir/src/target.rs

@@ -132,7 +132,7 @@ impl Target {
             ItemKind::Enum(..) => Target::Enum,
             ItemKind::Struct(..) => Target::Struct,
             ItemKind::Union(..) => Target::Union,
-            ItemKind::Trait(..) => Target::Trait,
+            ItemKind::Trait { .. } => Target::Trait,
             ItemKind::TraitAlias(..) => Target::TraitAlias,
             ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
         }

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -326,7 +326,7 @@ pub(super) fn check_item<'tcx>(
         hir::ItemKind::Struct(..) => check_type_defn(tcx, item, false),
         hir::ItemKind::Union(..) => check_type_defn(tcx, item, true),
         hir::ItemKind::Enum(..) => check_type_defn(tcx, item, true),
-        hir::ItemKind::Trait(..) => check_trait(tcx, item),
+        hir::ItemKind::Trait { .. } => check_trait(tcx, item),
         hir::ItemKind::TraitAlias(..) => check_trait(tcx, item),
         _ => Ok(()),
     }
@@ -1188,7 +1188,7 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) -> Result<(), ErrorGuarant
     });
 
     // Only check traits, don't check trait aliases
-    if let hir::ItemKind::Trait(..) = item.kind {
+    if let hir::ItemKind::Trait { .. } = item.kind {
         check_gat_where_clauses(tcx, item.owner_id.def_id);
     }
     res

compiler/rustc_hir_analysis/src/collect.rs

@@ -895,7 +895,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir_expect_item(def_id);
 
     let (constness, is_alias, is_auto, safety, impl_restriction) = match item.kind {
-        hir::ItemKind::Trait(impl_restriction, constness, is_auto, safety, ..) => (
+        hir::ItemKind::Trait { impl_restriction, constness, is_auto, safety, .. } => (
             constness,
             false,
             is_auto == hir::IsAuto::Yes,

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -221,7 +221,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
 
     // Add in the self type parameter.
     let opt_self = if let Node::Item(item) = node
-        && let ItemKind::Trait(..) | ItemKind::TraitAlias(..) = item.kind
+        && let ItemKind::Trait { .. } | ItemKind::TraitAlias(..) = item.kind
     {
         // Something of a hack: We reuse the node ID of the trait for the self type parameter.
         Some(ty::GenericParamDef {
@@ -402,7 +402,7 @@ fn param_default_policy(node: Node<'_>) -> Option<ParamDefaultPolicy> {
 
     Some(match node {
         Node::Item(item) => match item.kind {
-            ItemKind::Trait(..)
+            ItemKind::Trait { .. }
             | ItemKind::TraitAlias(..)
             | ItemKind::TyAlias(..)
             | ItemKind::Enum(..)

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -172,7 +172,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     ));
                 }
             }
-            ItemKind::Trait(_, _, _, _, _, _, self_bounds, ..)
+            ItemKind::Trait { bounds: self_bounds, .. }
             | ItemKind::TraitAlias(_, _, _, self_bounds) => {
                 is_trait = Some((self_bounds, item.span));
             }
@@ -669,7 +669,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
     };
 
     let (generics, superbounds) = match item.kind {
-        hir::ItemKind::Trait(.., generics, supertraits, _) => (generics, supertraits),
+        hir::ItemKind::Trait { generics, bounds: supertraits, .. } => (generics, supertraits),
         hir::ItemKind::TraitAlias(_, _, generics, supertraits) => (generics, supertraits),
         _ => span_bug!(item.span, "super_predicates invoked on non-trait"),
     };
@@ -934,7 +934,7 @@ pub(super) fn type_param_predicates<'tcx>(
     };
 
     if let Node::Item(item) = hir_node
-        && let hir::ItemKind::Trait(..) = item.kind
+        && let hir::ItemKind::Trait { .. } = item.kind
         // Implied `Self: Trait` and supertrait bounds.
         && param_id == item_hir_id
     {
@@ -1073,7 +1073,7 @@ pub(super) fn const_conditions<'tcx>(
         Node::Item(item) => match item.kind {
             hir::ItemKind::Impl(impl_) => (impl_.generics, None, false),
             hir::ItemKind::Fn { generics, .. } => (generics, None, false),
-            hir::ItemKind::Trait(_, _, _, _, _, generics, supertraits, _) => {
+            hir::ItemKind::Trait { generics, bounds: supertraits, .. } => {
                 (generics, Some((Some(item.owner_id.def_id), supertraits)), false)
             }
             hir::ItemKind::TraitAlias(_, _, generics, supertraits) => {
@@ -1194,7 +1194,7 @@ pub(super) fn explicit_implied_const_bounds<'tcx>(
         }
         None => match tcx.hir_node_by_def_id(def_id) {
             Node::Item(hir::Item {
-                kind: hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..),
+                kind: hir::ItemKind::Trait { .. } | hir::ItemKind::TraitAlias(..),
                 ..
             }) => implied_predicates_with_filter(
                 tcx,

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -647,7 +647,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             | hir::ItemKind::Enum(_, generics, _)
             | hir::ItemKind::Struct(_, generics, _)
             | hir::ItemKind::Union(_, generics, _)
-            | hir::ItemKind::Trait(_, _, _, _, _, generics, ..)
+            | hir::ItemKind::Trait { generics, .. }
             | hir::ItemKind::TraitAlias(_, _, generics, ..)
             | hir::ItemKind::Impl(hir::Impl { generics, .. }) => {
                 // These kinds of items have only early-bound lifetime parameters.
@@ -2258,7 +2258,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                     // we already do that in `BoundVarContext::supertrait_hrtb_vars`.
                     if let Res::SelfTyParam { trait_: _ } = expected_res
                         && let hir::Node::Item(item) = node
-                        && let hir::ItemKind::Trait(..) = item.kind
+                        && let hir::ItemKind::Trait { .. } = item.kind
                     {
                         // Yield the trait's def id. Supertraits will be
                         // elaborated from that.

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -171,7 +171,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                 Ty::new_adt(tcx, def, args)
             }
             ItemKind::GlobalAsm { .. } => tcx.typeck(def_id).node_type(hir_id),
-            ItemKind::Trait(..)
+            ItemKind::Trait { .. }
             | ItemKind::TraitAlias(..)
             | ItemKind::Macro(..)
             | ItemKind::Mod(..)