prepare v1.4.36 release

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [1.4.36] 2021-02-07
+
+### Changed
+
+- `rustc-ap-*` crates updated to v705.0.0
+
+### Install/Download Options
+- **crates.io package** - *pending*
+- **rustup (nightly)** - *pending*
+- **GitHub Release Binaries** - [Release v1.4.36](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.36)
+- **Build from source** - [Tag v1.4.36](https://github.com/rust-lang/rustfmt/tree/v1.4.36), see instructions for how to [install rustfmt from source][install-from-source]
+
 ## [1.4.35] 2021-02-03
 
 ### Changed
@@ -10,7 +22,7 @@
 
 ### Install/Download Options
 - **crates.io package** - *pending*
-- **rustup (nightly)** - *pending*
+- **rustup (nightly)** - *n/a (superseded by [v1.4.36](#1436-2021-02-07))
 - **GitHub Release Binaries** - [Release v1.4.35](https://github.com/rust-lang/rustfmt/releases/tag/v1.4.35)
 - **Build from source** - [Tag v1.4.35](https://github.com/rust-lang/rustfmt/tree/v1.4.35), see instructions for how to [install rustfmt from source][install-from-source]
 

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "rustfmt-nightly"
-version = "1.4.35"
+version = "1.4.36"
 authors = ["Nicholas Cameron <[email protected]>", "The Rustfmt developers"]
 description = "Tool to find and fix Rust formatting issues"
 repository = "https://github.com/rust-lang/rustfmt"
@@ -66,36 +66,36 @@ rustc-workspace-hack = "1.0.0"
 
 [dependencies.rustc_ast]
 package = "rustc-ap-rustc_ast"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_ast_pretty]
 package = "rustc-ap-rustc_ast_pretty"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_attr]
 package = "rustc-ap-rustc_attr"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_data_structures]
 package = "rustc-ap-rustc_data_structures"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_errors]
 package = "rustc-ap-rustc_errors"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_expand]
 package = "rustc-ap-rustc_expand"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_parse]
 package = "rustc-ap-rustc_parse"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_session]
 package = "rustc-ap-rustc_session"
-version = "702.0.0"
+version = "705.0.0"
 
 [dependencies.rustc_span]
 package = "rustc-ap-rustc_span"
-version = "702.0.0"
+version = "705.0.0"

rust-toolchain

@@ -1 +1 @@
-nightly-2021-02-03
+nightly-2021-02-06

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,17 +629,17 @@ 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())
                 }
                 (Const(..), Const(..)) | (MacCall(..), MacCall(..)) => {
                     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)
             }

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,