Update HIR pretty printing

Author: CoCo-Japan-pan

compiler/rustc_ast_lowering/src/item.rs

@@ -573,10 +573,10 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                     },
                 );
                 hir::ItemKind::Trait(
+                    impl_restriction,
                     constness,
                     *is_auto,
                     safety,
-                    impl_restriction,
                     ident,
                     generics,
                     bounds,

compiler/rustc_hir/src/hir.rs

@@ -4323,17 +4323,17 @@ impl<'hir> Item<'hir> {
 
         expect_trait,
             (
+                &'hir ImplRestriction<'hir>,
                 Constness,
                 IsAuto,
                 Safety,
-                &'hir ImplRestriction<'hir>,
                 Ident,
                 &'hir Generics<'hir>,
                 GenericBounds<'hir>,
                 &'hir [TraitItemId]
             ),
-            ItemKind::Trait(constness, is_auto, safety, impl_restriction, ident, generics, bounds, items),
-            (*constness, *is_auto, *safety, impl_restriction, *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>),
             ItemKind::TraitAlias(constness, ident, generics, bounds), (*constness, *ident, generics, bounds);
@@ -4525,10 +4525,10 @@ pub enum ItemKind<'hir> {
     Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
     /// A trait definition.
     Trait(
+        &'hir ImplRestriction<'hir>,
         Constness,
         IsAuto,
         Safety,
-        &'hir ImplRestriction<'hir>,
         Ident,
         &'hir Generics<'hir>,
         GenericBounds<'hir>,

compiler/rustc_hir/src/intravisit.rs

@@ -619,10 +619,10 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_variant_data(struct_definition));
         }
         ItemKind::Trait(
+            ref impl_restriction,
             _constness,
             _is_auto,
             _safety,
-            ref impl_restriction,
             ident,
             ref generics,
             bounds,

compiler/rustc_hir_analysis/src/collect.rs

@@ -894,7 +894,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(constness, is_auto, safety, impl_restriction, ..) => (
+        hir::ItemKind::Trait(impl_restriction, constness, is_auto, safety, ..) => (
             constness,
             false,
             is_auto == hir::IsAuto::Yes,
@@ -958,9 +958,9 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
 
     ty::TraitDef {
         def_id: def_id.to_def_id(),
+        impl_restriction,
         safety,
         constness,
-        impl_restriction,
         paren_sugar,
         has_auto_impl: is_auto,
         is_marker,

compiler/rustc_hir_pretty/src/lib.rs

@@ -758,20 +758,20 @@ impl<'a> State<'a> {
                 self.bclose(item.span, cb);
             }
             hir::ItemKind::Trait(
+                impl_restriction,
                 constness,
                 is_auto,
                 safety,
-                impl_restriction,
                 ident,
                 generics,
                 bounds,
                 trait_items,
             ) => {
                 let (cb, ib) = self.head("");
+                self.print_impl_restriction(impl_restriction);
                 self.print_constness(constness);
                 self.print_is_auto(is_auto);
                 self.print_safety(safety);
-                self.print_impl_restriction(impl_restriction);
                 self.word_nbsp("trait");
                 self.print_ident(ident);
                 self.print_generic_params(generics.params);

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1886,7 +1886,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     entry.1.insert((self_ty.span, String::new()));
                 }
                 Some(Node::Item(hir::Item {
-                    kind: hir::ItemKind::Trait(_, rustc_ast::ast::IsAuto::Yes, ..),
+                    kind: hir::ItemKind::Trait(_, _, rustc_ast::ast::IsAuto::Yes, ..),
                     span: item_span,
                     ..
                 })) => {

compiler/rustc_middle/src/ty/trait_def.rs

@@ -20,14 +20,14 @@ use crate::ty::{Ident, Ty, TyCtxt};
 pub struct TraitDef {
     pub def_id: DefId,
 
+    /// Restrictions on trait implementations.
+    pub impl_restriction: ImplRestrictionKind,
+
     pub safety: hir::Safety,
 
     /// Whether this trait is `const`.
     pub constness: hir::Constness,
 
-    /// Restrictions on trait implementations.
-    pub impl_restriction: ImplRestrictionKind,
-
     /// If `true`, then this trait had the `#[rustc_paren_sugar]`
     /// attribute, indicating that it should be used with `Foo()`
     /// sugar. This is a temporary thing -- eventually any trait will

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -3888,7 +3888,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 let mut is_auto_trait = false;
                 match tcx.hir_get_if_local(data.impl_or_alias_def_id) {
                     Some(Node::Item(hir::Item {
-                        kind: hir::ItemKind::Trait(_, is_auto, _, _, ident, _, _, _),
+                        kind: hir::ItemKind::Trait(_, _, is_auto, _, ident, _, _, _),
                         ..
                     })) => {
                         // FIXME: we should do something else so that it works even on crate foreign

src/librustdoc/clean/mod.rs

@@ -2915,7 +2915,7 @@ fn clean_maybe_renamed_item<'tcx>(
                 clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx)
             }
             // FIXME: rustdoc will need to handle `impl` restrictions at some point
-            ItemKind::Trait(_, _, _, _impl_restriction, _, generics, bounds, item_ids) => {
+            ItemKind::Trait(_impl_restriction, _, _, _, _, generics, bounds, item_ids) => {
                 let items = item_ids
                     .iter()
                     .map(|&ti| clean_trait_item(cx.tcx.hir_trait_item(ti), cx))

src/tools/clippy/clippy_lints/src/arbitrary_source_item_ordering.rs

@@ -306,9 +306,16 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     cur_f = Some(field);
                 }
             },
-            ItemKind::Trait(_constness, is_auto, _safety, _impl_restriction, _ident, _generics, _generic_bounds, item_ref)
-                if self.enable_ordering_for_trait && *is_auto == IsAuto::No =>
-            {
+            ItemKind::Trait(
+                _impl_restriction,
+                _constness,
+                is_auto,
+                _safety,
+                _ident,
+                _generics,
+                _generic_bounds,
+                item_ref,
+            ) if self.enable_ordering_for_trait && *is_auto == IsAuto::No => {
                 let mut cur_t: Option<(TraitItemId, Ident)> = None;
 
                 for &item in *item_ref {