From 9ed75111e2e859fcc3511e58eb26416f436043a5 Mon Sep 17 00:00:00 2001 From: Caleb Cartwright Date: Sat, 6 Feb 2021 15:13:14 -0600 Subject: [PATCH] deps: apply rustc-ap v705 changes to itemkind variants --- src/items.rs | 140 +++++++++++++++++----------------- src/visitor.rs | 199 +++++++++++++++++++++++++++---------------------- 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(<y.3, &rty.3) || both_opaque(<y.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(<y.3, &rty.3) || both_opaque(<y.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 { - 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 { - 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 { - 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,