deps: bump to rustc v647

Author: calebcartwright

Cargo.lock

@@ -64,35 +64,35 @@ rustc-workspace-hack = "1.0.0"
 
 [dependencies.rustc_ast_pretty]
 package = "rustc-ap-rustc_ast_pretty"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_data_structures]
 package = "rustc-ap-rustc_data_structures"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_errors]
 package = "rustc-ap-rustc_errors"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_parse]
 package = "rustc-ap-rustc_parse"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_session]
 package = "rustc-ap-rustc_session"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_span]
 package = "rustc-ap-rustc_span"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.rustc_target]
 package = "rustc-ap-rustc_target"
-version = "644.0.0"
+version = "647.0.0"
 
 [dependencies.syntax]
-package = "rustc-ap-syntax"
-version = "644.0.0"
+package = "rustc-ap-rustc_ast"
+version = "647.0.0"
 
 [dev-dependencies]
 lazy_static = "1.0.0"

Cargo.toml

@@ -18,12 +18,13 @@ use crate::utils::{count_newlines, mk_sp};
 mod doc_comment;
 
 /// Returns attributes on the given statement.
-pub(crate) fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
+pub(crate) fn get_attrs_from_stmt(stmt: &ast::Stmt) -> Option<&[ast::Attribute]> {
     match stmt.kind {
-        ast::StmtKind::Local(ref local) => &local.attrs,
-        ast::StmtKind::Item(ref item) => &item.attrs,
-        ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => &expr.attrs,
-        ast::StmtKind::Mac(ref mac) => &mac.2,
+        ast::StmtKind::Local(ref local) => Some(&local.attrs),
+        ast::StmtKind::Item(ref item) => Some(&item.attrs),
+        ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => Some(&expr.attrs),
+        ast::StmtKind::Mac(ref mac) => Some(&mac.2),
+        ast::StmtKind::Empty => None,
     }
 }
 
@@ -36,6 +37,7 @@ pub(crate) fn get_span_without_attrs(stmt: &ast::Stmt) -> Span {
             let (ref mac, _, _) = **mac;
             mac.span()
         }
+        ast::StmtKind::Empty => stmt.span,
     }
 }
 

src/attr.rs

@@ -105,9 +105,13 @@ fn get_inner_expr<'a>(
 
 // Figure out if a block is necessary.
 fn needs_block(block: &ast::Block, prefix: &str, context: &RewriteContext<'_>) -> bool {
-    let has_attributes = block.stmts.first().map_or(false, |first_stmt| {
-        !get_attrs_from_stmt(first_stmt).is_empty()
-    });
+    let has_attributes = block
+        .stmts
+        .first()
+        .map_or(false, |first_stmt| match get_attrs_from_stmt(first_stmt) {
+            Some(attrs) => !attrs.is_empty(),
+            None => false,
+        });
 
     is_unsafe_block(block)
         || block.stmts.len() > 1

src/closures.rs

@@ -298,7 +298,7 @@ impl<'a> FmtVisitor<'a> {
 
     fn format_foreign_item(&mut self, item: &ast::ForeignItem) {
         let rewrite = item.rewrite(&self.get_context(), self.shape());
-        self.push_rewrite(item.span(), rewrite);
+        self.push_rewrite(item.span, rewrite);
         self.last_pos = item.span.hi();
     }
 
@@ -629,7 +629,7 @@ 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))
+                    (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
                         if both_type(lty, rty) || both_opaque(lty, rty) =>
                     {
                         false
@@ -640,7 +640,7 @@ impl<'a> FmtVisitor<'a> {
             }
 
             buffer.sort_by(|(_, a), (_, b)| match (&a.kind, &b.kind) {
-                (TyAlias(_, ref lty), TyAlias(_, ref rty))
+                (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
                     if both_type(lty, rty) || both_opaque(lty, rty) =>
                 {
                     a.ident.as_str().cmp(&b.ident.as_str())
@@ -649,8 +649,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(_, _, _, ref ty), _) if is_type(ty) => Ordering::Less,
+                (_, TyAlias(_, _, _, ref ty)) if is_type(ty) => Ordering::Greater,
                 (TyAlias(..), _) => Ordering::Less,
                 (_, TyAlias(..)) => Ordering::Greater,
                 (Const(..), _) => Ordering::Less,
@@ -1714,9 +1714,13 @@ pub(crate) struct StaticParts<'a> {
 
 impl<'a> StaticParts<'a> {
     pub(crate) fn from_item(item: &'a ast::Item) -> Self {
-        let (prefix, ty, mutability, expr) = match item.kind {
-            ast::ItemKind::Static(ref ty, mutability, ref expr) => ("static", ty, mutability, expr),
-            ast::ItemKind::Const(ref ty, ref expr) => ("const", ty, ast::Mutability::Not, expr),
+        let (defaultness, prefix, ty, mutability, expr) = match item.kind {
+            ast::ItemKind::Static(ref ty, mutability, ref expr) => {
+                (None, "static", ty, mutability, expr)
+            }
+            ast::ItemKind::Const(defaultness, ref ty, ref expr) => {
+                (Some(defaultness), "const", ty, ast::Mutability::Not, expr)
+            }
             _ => unreachable!(),
         };
         StaticParts {
@@ -1725,15 +1729,17 @@ impl<'a> StaticParts<'a> {
             ident: item.ident,
             ty,
             mutability,
-            expr_opt: Some(expr),
-            defaultness: None,
+            expr_opt: expr.as_ref(),
+            defaultness: defaultness,
             span: item.span,
         }
     }
 
     pub(crate) fn from_trait_item(ti: &'a ast::AssocItem) -> Self {
-        let (ty, expr_opt) = match ti.kind {
-            ast::AssocItemKind::Const(ref ty, ref expr_opt) => (ty, expr_opt),
+        let (defaultness, ty, expr_opt) = match ti.kind {
+            ast::AssocItemKind::Const(defaultness, ref ty, ref expr_opt) => {
+                (defaultness, ty, expr_opt)
+            }
             _ => unreachable!(),
         };
         StaticParts {
@@ -1743,14 +1749,14 @@ impl<'a> StaticParts<'a> {
             ty,
             mutability: ast::Mutability::Not,
             expr_opt: expr_opt.as_ref(),
-            defaultness: None,
+            defaultness: Some(defaultness),
             span: ti.span,
         }
     }
 
     pub(crate) fn from_impl_item(ii: &'a ast::AssocItem) -> Self {
-        let (ty, expr) = match ii.kind {
-            ast::AssocItemKind::Const(ref ty, ref expr) => (ty, expr),
+        let (defaultness, ty, expr) = match ii.kind {
+            ast::AssocItemKind::Const(defaultness, ref ty, ref expr) => (defaultness, ty, expr),
             _ => unreachable!(),
         };
         StaticParts {
@@ -1760,7 +1766,7 @@ impl<'a> StaticParts<'a> {
             ty,
             mutability: ast::Mutability::Not,
             expr_opt: expr.as_ref(),
-            defaultness: Some(ii.defaultness),
+            defaultness: Some(defaultness),
             span: ii.span,
         }
     }
@@ -1903,7 +1909,7 @@ pub(crate) fn rewrite_associated_impl_type(
     let result = rewrite_associated_type(ident, ty_opt, generics, None, context, indent)?;
 
     match defaultness {
-        ast::Defaultness::Default => Some(format!("default {}", result)),
+        ast::Defaultness::Default(..) => Some(format!("default {}", result)),
         _ => Some(result),
     }
 }
@@ -3083,7 +3089,7 @@ 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(ref fn_sig, ref generics, _) => rewrite_fn_base(
+            ast::ForeignItemKind::Fn(_, ref fn_sig, ref generics, _) => rewrite_fn_base(
                 context,
                 shape.indent,
                 self.ident,
@@ -3092,7 +3098,7 @@ impl Rewrite for ast::ForeignItem {
                 FnBraceStyle::None,
             )
             .map(|(s, _)| format!("{};", s)),
-            ast::ForeignItemKind::Static(ref ty, mutability) => {
+            ast::ForeignItemKind::Static(ref ty, mutability, _) => {
                 // FIXME(#21): we're dropping potential comments in between the
                 // function kw here.
                 let vis = format_visibility(context, &self.vis);
@@ -3106,7 +3112,7 @@ impl Rewrite for ast::ForeignItem {
                 // 1 = ;
                 rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
             }
-            ast::ForeignItemKind::Ty => {
+            ast::ForeignItemKind::TyAlias(..) => {
                 let vis = format_visibility(context, &self.vis);
                 Some(format!(
                     "{}type {};",

src/items.rs

@@ -231,7 +231,7 @@ fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
         {
             parser.bump();
             let macro_arg =
-                MacroArg::Keyword(ast::Ident::with_dummy_span(keyword), parser.prev_span);
+                MacroArg::Keyword(ast::Ident::with_dummy_span(keyword), parser.prev_token.span);
             return Some(macro_arg);
         }
     }

src/macros.rs

@@ -468,7 +468,7 @@ fn parse_mod_items<'a>(parser: &mut parser::Parser<'a>, inner_lo: Span) -> PResu
     let hi = if parser.token.span.is_dummy() {
         inner_lo
     } else {
-        parser.prev_span
+        parser.prev_token.span
     };
 
     Ok(ast::Mod {

src/modules.rs

@@ -74,6 +74,7 @@ impl Spanned for ast::Stmt {
                     mk_sp(attrs[0].span.lo(), self.span.hi())
                 }
             }
+            ast::StmtKind::Empty => self.span,
         }
     }
 }

src/spanned.rs

@@ -106,7 +106,7 @@ fn format_stmt(
             let shape = shape.sub_width(suffix.len())?;
             format_expr(ex, expr_type, context, shape).map(|s| s + suffix)
         }
-        ast::StmtKind::Mac(..) | ast::StmtKind::Item(..) => None,
+        ast::StmtKind::Mac(..) | ast::StmtKind::Item(..) | ast::StmtKind::Empty => None,
     };
     result.and_then(|res| recover_comment_removed(res, stmt.span(), context))
 }

src/stmt.rs

@@ -104,7 +104,7 @@ pub(crate) fn format_constness(constness: ast::Const) -> &'static str {
 #[inline]
 pub(crate) fn format_defaultness(defaultness: ast::Defaultness) -> &'static str {
     match defaultness {
-        ast::Defaultness::Default => "default ",
+        ast::Defaultness::Default(..) => "default ",
         ast::Defaultness::Final => "",
     }
 }