[1.x] Bump rustc-ap crates

Cargo.toml

@@ -66,36 +66,36 @@ rustc-workspace-hack = "1.0.0"
 
 [dependencies.rustc_ast]
 package = "rustc-ap-rustc_ast"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_ast_pretty]
 package = "rustc-ap-rustc_ast_pretty"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_attr]
 package = "rustc-ap-rustc_attr"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_data_structures]
 package = "rustc-ap-rustc_data_structures"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_errors]
 package = "rustc-ap-rustc_errors"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_expand]
 package = "rustc-ap-rustc_expand"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_parse]
 package = "rustc-ap-rustc_parse"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_session]
 package = "rustc-ap-rustc_session"
-version = "686.0.0"
+version = "691.0.0"
 
 [dependencies.rustc_span]
 package = "rustc-ap-rustc_span"
-version = "686.0.0"
+version = "691.0.0"

src/expr.rs

@@ -106,11 +106,11 @@ pub(crate) fn format_expr(
             })
         }
         ast::ExprKind::Unary(op, ref subexpr) => rewrite_unary_op(context, op, subexpr, shape),
-        ast::ExprKind::Struct(ref path, ref fields, ref base) => rewrite_struct_lit(
+        ast::ExprKind::Struct(ref path, ref fields, ref struct_rest) => rewrite_struct_lit(
             context,
             path,
             fields,
-            base.as_ref().map(|e| &**e),
+            struct_rest,
             &expr.attrs,
             expr.span,
             shape,
@@ -384,6 +384,7 @@ pub(crate) fn format_expr(
             }
         }
         ast::ExprKind::Await(_) => rewrite_chain(expr, context, shape),
+        ast::ExprKind::Underscore => Some("_".to_owned()),
         ast::ExprKind::Err => None,
     };
 
@@ -1510,19 +1511,15 @@ fn rewrite_index(
     }
 }
 
-fn struct_lit_can_be_aligned(fields: &[ast::Field], base: Option<&ast::Expr>) -> bool {
-    if base.is_some() {
-        return false;
-    }
-
-    fields.iter().all(|field| !field.is_shorthand)
+fn struct_lit_can_be_aligned(fields: &[ast::Field], has_base: bool) -> bool {
+    !has_base && fields.iter().all(|field| !field.is_shorthand)
 }
 
 fn rewrite_struct_lit<'a>(
     context: &RewriteContext<'_>,
     path: &ast::Path,
     fields: &'a [ast::Field],
-    base: Option<&'a ast::Expr>,
+    struct_rest: &ast::StructRest,
     attrs: &[ast::Attribute],
     span: Span,
     shape: Shape,
@@ -1532,22 +1529,28 @@ fn rewrite_struct_lit<'a>(
     enum StructLitField<'a> {
         Regular(&'a ast::Field),
         Base(&'a ast::Expr),
+        Rest(&'a Span),
     }
 
     // 2 = " {".len()
     let path_shape = shape.sub_width(2)?;
     let path_str = rewrite_path(context, PathContext::Expr, None, path, path_shape)?;
 
-    if fields.is_empty() && base.is_none() {
-        return Some(format!("{} {{}}", path_str));
-    }
+    let has_base = match struct_rest {
+        ast::StructRest::None if fields.is_empty() => return Some(format!("{} {{}}", path_str)),
+        ast::StructRest::Rest(_) if fields.is_empty() => {
+            return Some(format!("{} {{ .. }}", path_str));
+        }
+        ast::StructRest::Base(_) => true,
+        _ => false,
+    };
 
     // Foo { a: Foo } - indent is +3, width is -5.
     let (h_shape, v_shape) = struct_lit_shape(shape, context, path_str.len() + 3, 2)?;
 
     let one_line_width = h_shape.map_or(0, |shape| shape.width);
     let body_lo = context.snippet_provider.span_after(span, "{");
-    let fields_str = if struct_lit_can_be_aligned(fields, base)
+    let fields_str = if struct_lit_can_be_aligned(fields, has_base)
         && context.config.struct_field_align_threshold() > 0
     {
         rewrite_with_alignment(
@@ -1558,10 +1561,14 @@ fn rewrite_struct_lit<'a>(
             one_line_width,
         )?
     } else {
-        let field_iter = fields
-            .iter()
-            .map(StructLitField::Regular)
-            .chain(base.into_iter().map(StructLitField::Base));
+        let field_iter = fields.iter().map(StructLitField::Regular).chain(
+            match struct_rest {
+                ast::StructRest::Base(expr) => Some(StructLitField::Base(&**expr)),
+                ast::StructRest::Rest(span) => Some(StructLitField::Rest(span)),
+                ast::StructRest::None => None,
+            }
+            .into_iter(),
+        );
 
         let span_lo = |item: &StructLitField<'_>| match *item {
             StructLitField::Regular(field) => field.span().lo(),
@@ -1571,10 +1578,12 @@ fn rewrite_struct_lit<'a>(
                 let pos = snippet.find_uncommented("..").unwrap();
                 last_field_hi + BytePos(pos as u32)
             }
+            StructLitField::Rest(span) => span.lo(),
         };
         let span_hi = |item: &StructLitField<'_>| match *item {
             StructLitField::Regular(field) => field.span().hi(),
             StructLitField::Base(expr) => expr.span.hi(),
+            StructLitField::Rest(span) => span.hi(),
         };
         let rewrite = |item: &StructLitField<'_>| match *item {
             StructLitField::Regular(field) => {
@@ -1586,6 +1595,7 @@ fn rewrite_struct_lit<'a>(
                 expr.rewrite(context, v_shape.offset_left(2)?)
                     .map(|s| format!("..{}", s))
             }
+            StructLitField::Rest(_) => Some("..".to_owned()),
         };
 
         let items = itemize_list(
@@ -1612,7 +1622,7 @@ fn rewrite_struct_lit<'a>(
             nested_shape,
             tactic,
             context,
-            force_no_trailing_comma || base.is_some() || !context.use_block_indent(),
+            force_no_trailing_comma || has_base || !context.use_block_indent(),
         );
 
         write_list(&item_vec, &fmt)?

src/macros.rs

@@ -13,9 +13,7 @@ use std::collections::HashMap;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use rustc_ast::token::{BinOpToken, DelimToken, Token, TokenKind};
-use rustc_ast::tokenstream::{
-    Cursor, LazyTokenStream, LazyTokenStreamInner, TokenStream, TokenTree,
-};
+use rustc_ast::tokenstream::{Cursor, LazyTokenStream, TokenStream, TokenTree};
 use rustc_ast::{ast, ptr};
 use rustc_ast_pretty::pprust;
 use rustc_parse::parser::Parser;
@@ -1214,7 +1212,7 @@ pub(crate) fn convert_try_mac(
             kind: ast::ExprKind::Try(parser.parse_expr().ok()?),
             span: mac.span(), // incorrect span, but shouldn't matter too much
             attrs: ast::AttrVec::new(),
-            tokens: Some(LazyTokenStream::new(LazyTokenStreamInner::Ready(ts))),
+            tokens: Some(LazyTokenStream::new(ts)),
         })
     } else {
         None

src/modules/visitor.rs

@@ -30,7 +30,7 @@ impl<'a> CfgIfVisitor<'a> {
 }
 
 impl<'a, 'ast: 'a> Visitor<'ast> for CfgIfVisitor<'a> {
-    fn visit_mac(&mut self, mac: &'ast ast::MacCall) {
+    fn visit_mac_call(&mut self, mac: &'ast ast::MacCall) {
         match self.visit_mac_inner(mac) {
             Ok(()) => (),
             Err(e) => debug!("{}", e),

src/skip.rs

@@ -58,7 +58,7 @@ fn get_skip_names(kind: &str, attrs: &[ast::Attribute]) -> Vec<String> {
     for attr in attrs {
         // rustc_ast::ast::Path is implemented partialEq
         // but it is designed for segments.len() == 1
-        if let ast::AttrKind::Normal(attr_item) = &attr.kind {
+        if let ast::AttrKind::Normal(attr_item, _) = &attr.kind {
             if pprust::path_to_string(&attr_item.path) != path {
                 continue;
             }

src/syntux/parser.rs

@@ -227,8 +227,16 @@ impl<'a> Parser<'a> {
                 if !parser.eat_keyword(kw::If) {
                     return Err("Expected `if`");
                 }
+                // Inner attributes are not actually syntactically permitted here, but we don't
+                // care about inner vs outer attributes in this position. Our purpose with this
+                // special case parsing of cfg_if macros is to ensure we can correctly resolve
+                // imported modules that may have a custom `path` defined.
+                //
+                // As such, we just need to advance the parser past the attribute and up to
+                // to the opening brace.
+                // See also https://github.com/rust-lang/rust/pull/79433
                 parser
-                    .parse_attribute(false)
+                    .parse_attribute(rustc_parse::parser::attr::InnerAttrPolicy::Permitted)
                     .map_err(|_| "Failed to parse attributes")?;
             }
 

src/utils.rs

@@ -504,7 +504,8 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Ret(..)
         | ast::ExprKind::Tup(..)
         | ast::ExprKind::Type(..)
-        | ast::ExprKind::Yield(None) => false,
+        | ast::ExprKind::Yield(None)
+        | ast::ExprKind::Underscore => false,
     }
 }
 

src/visitor.rs

@@ -851,7 +851,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
                 );
             } else {
                 match &attr.kind {
-                    ast::AttrKind::Normal(ref attribute_item)
+                    ast::AttrKind::Normal(ref attribute_item, _)
                         if self.is_unknown_rustfmt_attr(&attribute_item.path.segments) =>
                     {
                         let file_name = self.parse_sess.span_to_filename(attr.span);

tests/source/expr.rs

@@ -567,3 +567,13 @@ fn foo() {
     }
         .await;
 }
+
+fn underscore() {
+        _= 1;
+        _;
+        [  _,a,_  ] = [1, 2, 3];
+    (a,   _) = (8, 9);
+    TupleStruct(  _, a) = TupleStruct(2, 2);
+
+    let _  : usize = foo(_, _);
+}

tests/source/structs.rs

@@ -15,6 +15,17 @@ pub struct Foo {
     pub i: TypeForPublicField
 }
 
+// Destructuring
+fn foo() {
+    S { x: 5,
+        ..};
+        Struct {..} = Struct { a: 1, b: 4 };
+        Struct {      a,     .. } = Struct { a: 1, b: 2, c: 3};
+        TupleStruct(a,..,   b) = TupleStruct(1, 2);
+        TupleStruct(  ..) = TupleStruct(3, 4);
+        TupleStruct(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, .., bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) = TupleStruct(1, 2);
+}
+
 // #1095
 struct S<T: /* comment */> {
     t: T,

tests/target/expr.rs

@@ -659,3 +659,13 @@ fn foo() {
     }
     .await;
 }
+
+fn underscore() {
+    _ = 1;
+    _;
+    [_, a, _] = [1, 2, 3];
+    (a, _) = (8, 9);
+    TupleStruct(_, a) = TupleStruct(2, 2);
+
+    let _: usize = foo(_, _);
+}

tests/target/structs.rs

@@ -15,6 +15,20 @@ pub struct Foo {
     pub i: TypeForPublicField,
 }
 
+// Destructuring
+fn foo() {
+    S { x: 5, .. };
+    Struct { .. } = Struct { a: 1, b: 4 };
+    Struct { a, .. } = Struct { a: 1, b: 2, c: 3 };
+    TupleStruct(a, .., b) = TupleStruct(1, 2);
+    TupleStruct(..) = TupleStruct(3, 4);
+    TupleStruct(
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+        ..,
+        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+    ) = TupleStruct(1, 2);
+}
+
 // #1095
 struct S<T /* comment */> {
     t: T,