deps: apply rustc-ap v705 changes to itemkind variants

2 files changed, 177 insertions, 162 deletions

diff --git a/src/items.rs b/src/items.rs
index 18688fe3344..10654a2a5ac 100644
--- a/src/items.rs
+++ b/src/items.rs
@@ -618,8 +618,8 @@ impl<'a> FmtVisitor<'a> {
             use crate::ast::AssocItemKind::*;
             fn need_empty_line(a: &ast::AssocItemKind, b: &ast::AssocItemKind) -> bool {
                 match (a, b) {
-                    (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
-                        if both_type(lty, rty) || both_opaque(lty, rty) =>
+                    (TyAlias(lty), TyAlias(rty))
+                        if both_type(&lty.3, &rty.3) || both_opaque(&lty.3, &rty.3) =>
                     {
                         false
                     }
@@ -629,8 +629,8 @@ impl<'a> FmtVisitor<'a> {
             }
 
             buffer.sort_by(|(_, a), (_, b)| match (&a.kind, &b.kind) {
-                (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
-                    if both_type(lty, rty) || both_opaque(lty, rty) =>
+                (TyAlias(lty), TyAlias(rty))
+                    if both_type(&lty.3, &rty.3) || both_opaque(&lty.3, &rty.3) =>
                 {
                     a.ident.as_str().cmp(&b.ident.as_str())
                 }
@@ -638,8 +638,8 @@ impl<'a> FmtVisitor<'a> {
                     a.ident.as_str().cmp(&b.ident.as_str())
                 }
                 (Fn(..), Fn(..)) => a.span.lo().cmp(&b.span.lo()),
-                (TyAlias(_, _, _, ref ty), _) if is_type(ty) => Ordering::Less,
-                (_, TyAlias(_, _, _, ref ty)) if is_type(ty) => Ordering::Greater,
+                (TyAlias(ty), _) if is_type(&ty.3) => Ordering::Less,
+                (_, TyAlias(ty)) if is_type(&ty.3) => Ordering::Greater,
                 (TyAlias(..), _) => Ordering::Less,
                 (_, TyAlias(..)) => Ordering::Greater,
                 (Const(..), _) => Ordering::Less,
@@ -675,13 +675,13 @@ pub(crate) fn format_impl(
     item: &ast::Item,
     offset: Indent,
 ) -> Option<String> {
-    if let ast::ItemKind::Impl {
-        ref generics,
-        ref self_ty,
-        ref items,
-        ..
-    } = item.kind
-    {
+    if let ast::ItemKind::Impl(impl_kind) = &item.kind {
+        let ast::ImplKind {
+            ref generics,
+            ref self_ty,
+            ref items,
+            ..
+        } = **impl_kind;
         let mut result = String::with_capacity(128);
         let ref_and_type = format_impl_ref_and_type(context, item, offset)?;
         let sep = offset.to_string_with_newline(context.config);
@@ -829,17 +829,17 @@ fn format_impl_ref_and_type(
     item: &ast::Item,
     offset: Indent,
 ) -> Option<String> {
-    if let ast::ItemKind::Impl {
-        unsafety,
-        polarity,
-        defaultness,
-        constness,
-        ref generics,
-        of_trait: ref trait_ref,
-        ref self_ty,
-        ..
-    } = item.kind
-    {
+    if let ast::ItemKind::Impl(impl_kind) = &item.kind {
+        let ast::ImplKind {
+            unsafety,
+            polarity,
+            defaultness,
+            constness,
+            ref generics,
+            of_trait: ref trait_ref,
+            ref self_ty,
+            ..
+        } = **impl_kind;
         let mut result = String::with_capacity(128);
 
         result.push_str(&format_visibility(context, &item.vis));
@@ -1025,14 +1025,9 @@ pub(crate) fn format_trait(
     item: &ast::Item,
     offset: Indent,
 ) -> Option<String> {
-    if let ast::ItemKind::Trait(
-        is_auto,
-        unsafety,
-        ref generics,
-        ref generic_bounds,
-        ref trait_items,
-    ) = item.kind
-    {
+    if let ast::ItemKind::Trait(trait_kind) = &item.kind {
+        let ast::TraitKind(is_auto, unsafety, ref generics, ref generic_bounds, ref trait_items) =
+            **trait_kind;
         let mut result = String::with_capacity(128);
         let header = format!(
             "{}{}{}trait ",
@@ -3119,31 +3114,35 @@ impl Rewrite for ast::ForeignItem {
         let span = mk_sp(self.span.lo(), self.span.hi() - BytePos(1));
 
         let item_str = match self.kind {
-            ast::ForeignItemKind::Fn(defaultness, ref fn_sig, ref generics, Some(ref body)) => {
-                let mut visitor = FmtVisitor::from_context(context);
-                visitor.block_indent = shape.indent;
-                visitor.last_pos = self.span.lo();
-                let inner_attrs = inner_attributes(&self.attrs);
-                let fn_ctxt = visit::FnCtxt::Foreign;
-                visitor.visit_fn(
-                    visit::FnKind::Fn(fn_ctxt, self.ident, &fn_sig, &self.vis, Some(body)),
-                    generics,
-                    &fn_sig.decl,
-                    self.span,
-                    defaultness,
-                    Some(&inner_attrs),
-                );
-                Some(visitor.buffer.to_owned())
+            ast::ForeignItemKind::Fn(ref fn_kind) => {
+                let ast::FnKind(defaultness, ref fn_sig, ref generics, ref block) = **fn_kind;
+                if let Some(ref body) = block {
+                    let mut visitor = FmtVisitor::from_context(context);
+                    visitor.block_indent = shape.indent;
+                    visitor.last_pos = self.span.lo();
+                    let inner_attrs = inner_attributes(&self.attrs);
+                    let fn_ctxt = visit::FnCtxt::Foreign;
+                    visitor.visit_fn(
+                        visit::FnKind::Fn(fn_ctxt, self.ident, &fn_sig, &self.vis, Some(body)),
+                        generics,
+                        &fn_sig.decl,
+                        self.span,
+                        defaultness,
+                        Some(&inner_attrs),
+                    );
+                    Some(visitor.buffer.to_owned())
+                } else {
+                    rewrite_fn_base(
+                        context,
+                        shape.indent,
+                        self.ident,
+                        &FnSig::from_method_sig(&fn_sig, generics, self.vis.clone()),
+                        span,
+                        FnBraceStyle::None,
+                    )
+                    .map(|(s, _, _)| format!("{};", s))
+                }
             }
-            ast::ForeignItemKind::Fn(_, ref fn_sig, ref generics, None) => rewrite_fn_base(
-                context,
-                shape.indent,
-                self.ident,
-                &FnSig::from_method_sig(&fn_sig, generics, self.vis.clone()),
-                span,
-                FnBraceStyle::None,
-            )
-            .map(|(s, _, _)| format!("{};", s)),
             ast::ForeignItemKind::Static(ref ty, mutability, _) => {
                 // FIXME(#21): we're dropping potential comments in between the
                 // function kw here.
@@ -3158,21 +3157,20 @@ impl Rewrite for ast::ForeignItem {
                 // 1 = ;
                 rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
             }
-            ast::ForeignItemKind::TyAlias(
-                _,
-                ref generics,
-                ref generic_bounds,
-                ref type_default,
-            ) => rewrite_type_alias(
-                self.ident,
-                type_default.as_ref(),
-                generics,
-                Some(generic_bounds),
-                &context,
-                shape.indent,
-                &self.vis,
-                self.span,
-            ),
+            ast::ForeignItemKind::TyAlias(ref ty_alias_kind) => {
+                let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref type_default) =
+                    **ty_alias_kind;
+                rewrite_type_alias(
+                    self.ident,
+                    type_default.as_ref(),
+                    generics,
+                    Some(generic_bounds),
+                    &context,
+                    shape.indent,
+                    &self.vis,
+                    self.span,
+                )
+            }
             ast::ForeignItemKind::MacCall(ref mac) => {
                 rewrite_macro(mac, None, context, shape, MacroPosition::Item)
             }
diff --git a/src/visitor.rs b/src/visitor.rs
index 15055d46d30..34e8536b7ee 100644
--- a/src/visitor.rs
+++ b/src/visitor.rs
@@ -481,6 +481,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
             }
         };
 
+        // TODO(calebcartwright): consider enabling box_patterns feature gate
         if should_visit_node_again {
             match item.kind {
                 ast::ItemKind::Use(ref tree) => self.format_import(item, tree),
@@ -538,66 +539,72 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
                 ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
                     self.visit_static(&StaticParts::from_item(item));
                 }
-                ast::ItemKind::Fn(defaultness, ref fn_signature, ref generics, Some(ref body)) => {
-                    let inner_attrs = inner_attributes(&item.attrs);
-                    let fn_ctxt = match fn_signature.header.ext {
-                        ast::Extern::None => visit::FnCtxt::Free,
-                        _ => visit::FnCtxt::Foreign,
-                    };
-                    self.visit_fn(
-                        visit::FnKind::Fn(
-                            fn_ctxt,
-                            item.ident,
-                            &fn_signature,
-                            &item.vis,
-                            Some(body),
-                        ),
-                        generics,
-                        &fn_signature.decl,
-                        item.span,
-                        defaultness,
-                        Some(&inner_attrs),
-                    )
-                }
-                ast::ItemKind::Fn(_, ref fn_signature, ref generics, None) => {
-                    let indent = self.block_indent;
-                    let rewrite = self.rewrite_required_fn(
-                        indent,
-                        item.ident,
-                        &fn_signature,
-                        generics,
-                        item.span,
-                    );
-
-                    self.push_rewrite(item.span, rewrite);
-                }
-                ast::ItemKind::TyAlias(_, ref generics, ref generic_bounds, ref ty) => match ty {
-                    Some(ty) => {
-                        let rewrite = rewrite_type_alias(
-                            item.ident,
-                            Some(&*ty),
+                ast::ItemKind::Fn(ref fn_kind) => {
+                    let ast::FnKind(defaultness, ref fn_signature, ref generics, ref block) =
+                        **fn_kind;
+                    if let Some(ref body) = block {
+                        let inner_attrs = inner_attributes(&item.attrs);
+                        let fn_ctxt = match fn_signature.header.ext {
+                            ast::Extern::None => visit::FnCtxt::Free,
+                            _ => visit::FnCtxt::Foreign,
+                        };
+                        self.visit_fn(
+                            visit::FnKind::Fn(
+                                fn_ctxt,
+                                item.ident,
+                                &fn_signature,
+                                &item.vis,
+                                Some(body),
+                            ),
                             generics,
-                            Some(generic_bounds),
-                            &self.get_context(),
-                            self.block_indent,
-                            &item.vis,
+                            &fn_signature.decl,
                             item.span,
-                        );
-                        self.push_rewrite(item.span, rewrite);
-                    }
-                    None => {
-                        let rewrite = rewrite_opaque_type(
-                            &self.get_context(),
-                            self.block_indent,
+                            defaultness,
+                            Some(&inner_attrs),
+                        )
+                    } else {
+                        let indent = self.block_indent;
+                        let rewrite = self.rewrite_required_fn(
+                            indent,
                             item.ident,
-                            generic_bounds,
+                            &fn_signature,
                             generics,
-                            &item.vis,
                             item.span,
                         );
                         self.push_rewrite(item.span, rewrite);
                     }
-                },
+                }
+                ast::ItemKind::TyAlias(ref alias_kind) => {
+                    let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref ty) =
+                        **alias_kind;
+                    match ty {
+                        Some(ty) => {
+                            let rewrite = rewrite_type_alias(
+                                item.ident,
+                                Some(&*ty),
+                                generics,
+                                Some(generic_bounds),
+                                &self.get_context(),
+                                self.block_indent,
+                                &item.vis,
+                                item.span,
+                            );
+                            self.push_rewrite(item.span, rewrite);
+                        }
+                        None => {
+                            let rewrite = rewrite_opaque_type(
+                                &self.get_context(),
+                                self.block_indent,
+                                item.ident,
+                                generic_bounds,
+                                generics,
+                                &item.vis,
+                                item.span,
+                            );
+                            self.push_rewrite(item.span, rewrite);
+                        }
+                    }
+                }
                 ast::ItemKind::GlobalAsm(..) => {
                     let snippet = Some(self.snippet(item.span).to_owned());
                     self.push_rewrite(item.span, snippet);
@@ -627,31 +634,37 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
             return;
         }
 
+        // TODO(calebcartwright): consider enabling box_patterns feature gate
         match ti.kind {
             ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_trait_item(ti)),
-            ast::AssocItemKind::Fn(_, ref sig, ref generics, None) => {
-                let indent = self.block_indent;
-                let rewrite = self.rewrite_required_fn(indent, ti.ident, sig, generics, ti.span);
-                self.push_rewrite(ti.span, rewrite);
-            }
-            ast::AssocItemKind::Fn(defaultness, ref sig, ref generics, Some(ref body)) => {
-                let inner_attrs = inner_attributes(&ti.attrs);
-                let vis = ast::Visibility {
-                    kind: ast::VisibilityKind::Inherited,
-                    span: DUMMY_SP,
-                    tokens: None,
-                };
-                let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Trait);
-                self.visit_fn(
-                    visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &vis, Some(body)),
-                    generics,
-                    &sig.decl,
-                    ti.span,
-                    defaultness,
-                    Some(&inner_attrs),
-                );
+            ast::AssocItemKind::Fn(ref fn_kind) => {
+                let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
+                if let Some(ref body) = block {
+                    let inner_attrs = inner_attributes(&ti.attrs);
+                    let vis = ast::Visibility {
+                        kind: ast::VisibilityKind::Inherited,
+                        span: DUMMY_SP,
+                        tokens: None,
+                    };
+                    let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Trait);
+                    self.visit_fn(
+                        visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &vis, Some(body)),
+                        generics,
+                        &sig.decl,
+                        ti.span,
+                        defaultness,
+                        Some(&inner_attrs),
+                    );
+                } else {
+                    let indent = self.block_indent;
+                    let rewrite =
+                        self.rewrite_required_fn(indent, ti.ident, sig, generics, ti.span);
+                    self.push_rewrite(ti.span, rewrite);
+                }
             }
-            ast::AssocItemKind::TyAlias(_, ref generics, ref generic_bounds, ref type_default) => {
+            ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
+                let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref type_default) =
+                    **ty_alias_kind;
                 let rewrite = rewrite_type_alias(
                     ti.ident,
                     type_default.as_ref(),
@@ -679,25 +692,29 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
         }
 
         match ii.kind {
-            ast::AssocItemKind::Fn(defaultness, ref sig, ref generics, Some(ref body)) => {
-                let inner_attrs = inner_attributes(&ii.attrs);
-                let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Impl);
-                self.visit_fn(
-                    visit::FnKind::Fn(fn_ctxt, ii.ident, sig, &ii.vis, Some(body)),
-                    generics,
-                    &sig.decl,
-                    ii.span,
-                    defaultness,
-                    Some(&inner_attrs),
-                );
-            }
-            ast::AssocItemKind::Fn(_, ref sig, ref generics, None) => {
-                let indent = self.block_indent;
-                let rewrite = self.rewrite_required_fn(indent, ii.ident, sig, generics, ii.span);
-                self.push_rewrite(ii.span, rewrite);
+            ast::AssocItemKind::Fn(ref fn_kind) => {
+                let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
+                if let Some(ref body) = block {
+                    let inner_attrs = inner_attributes(&ii.attrs);
+                    let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Impl);
+                    self.visit_fn(
+                        visit::FnKind::Fn(fn_ctxt, ii.ident, sig, &ii.vis, Some(body)),
+                        generics,
+                        &sig.decl,
+                        ii.span,
+                        defaultness,
+                        Some(&inner_attrs),
+                    );
+                } else {
+                    let indent = self.block_indent;
+                    let rewrite =
+                        self.rewrite_required_fn(indent, ii.ident, sig, generics, ii.span);
+                    self.push_rewrite(ii.span, rewrite);
+                }
             }
             ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_impl_item(ii)),
-            ast::AssocItemKind::TyAlias(defaultness, ref generics, _, ref ty) => {
+            ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
+                let ast::TyAliasKind(defaultness, ref generics, _, ref ty) = **ty_alias_kind;
                 let rewrite_associated = || {
                     rewrite_associated_impl_type(
                         ii.ident,