Update rustc-ap-* crates to 606.0.0 (#3835)

[rust.git] / src / chains.rs

diff --git a/src/chains.rs b/src/chains.rs
index 5ea3953a2c7516dc31f7213ead035c0a438a7edc..ff8d7214c5480b5fec73ea0087666130e7422f4e 100644 (file)
--- a/src/chains.rs
+++ b/src/chains.rs
@@ -16,7 +16,7 @@
 //! following values of `chain_indent`:
 //! Block:
 //!
-//! ```ignore
+//! ```text
 //! let foo = {
 //!     aaaa;
 //!     bbb;
@@ -27,7 +27,7 @@
 //!
 //! Visual:
 //!
-//! ```ignore
+//! ```text
 //! let foo = {
 //!               aaaa;
 //!               bbb;
@@ -41,7 +41,7 @@
 //! the braces.
 //! Block:
 //!
-//! ```ignore
+//! ```text
 //! let a = foo.bar
 //!     .baz()
 //!     .qux
@@ -49,7 +49,7 @@
 //!
 //! Visual:
 //!
-//! ```ignore
+//! ```text
 //! let a = foo.bar
 //!            .baz()
 //!            .qux
@@ -74,7 +74,7 @@
     trimmed_last_line_width, wrap_str,
 };
 
-pub fn rewrite_chain(
+pub(crate) fn rewrite_chain(
     expr: &ast::Expr,
     context: &RewriteContext<'_>,
     shape: Shape,
@@ -118,6 +118,7 @@ enum ChainItemKind {
     ),
     StructField(ast::Ident),
     TupleField(ast::Ident, bool),
+    Await,
     Comment(String, CommentPosition),
 }
 
@@ -128,12 +129,13 @@ fn is_block_like(&self, context: &RewriteContext<'_>, reps: &str) -> bool {
             ChainItemKind::MethodCall(..)
             | ChainItemKind::StructField(..)
             | ChainItemKind::TupleField(..)
+            | ChainItemKind::Await
             | ChainItemKind::Comment(..) => false,
         }
     }
 
     fn is_tup_field_access(expr: &ast::Expr) -> bool {
-        match expr.node {
+        match expr.kind {
             ast::ExprKind::Field(_, ref field) => {
                 field.name.to_string().chars().all(|c| c.is_digit(10))
             }
@@ -142,7 +144,7 @@ fn is_tup_field_access(expr: &ast::Expr) -> bool {
     }
 
     fn from_ast(context: &RewriteContext<'_>, expr: &ast::Expr) -> (ChainItemKind, Span) {
-        let (kind, span) = match expr.node {
+        let (kind, span) = match expr.kind {
             ast::ExprKind::MethodCall(ref segment, ref expressions) => {
                 let types = if let Some(ref generic_args) = segment.args {
                     if let ast::GenericArgs::AngleBracketed(ref data) = **generic_args {
@@ -166,6 +168,10 @@ fn from_ast(context: &RewriteContext<'_>, expr: &ast::Expr) -> (ChainItemKind, S
                 let span = mk_sp(nested.span.hi(), field.span.hi());
                 (kind, span)
             }
+            ast::ExprKind::Await(ref nested) => {
+                let span = mk_sp(nested.span.hi(), expr.span.hi());
+                (ChainItemKind::Await, span)
+            }
             _ => return (ChainItemKind::Parent(expr.clone()), expr.span),
         };
 
@@ -189,6 +195,7 @@ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String>
                 if nested { " " } else { "" },
                 rewrite_ident(context, ident)
             ),
+            ChainItemKind::Await => ".await".to_owned(),
             ChainItemKind::Comment(ref comment, _) => {
                 rewrite_comment(comment, false, shape, context.config)?
             }
@@ -255,7 +262,7 @@ fn from_ast(expr: &ast::Expr, context: &RewriteContext<'_>) -> Chain {
         let mut rev_children = vec![];
         let mut sub_tries = 0;
         for subexpr in &subexpr_list {
-            match subexpr.node {
+            match subexpr.kind {
                 ast::ExprKind::Try(_) => sub_tries += 1,
                 _ => {
                     rev_children.push(ChainItem::new(context, subexpr, sub_tries));
@@ -383,19 +390,19 @@ fn make_subexpr_list(expr: &ast::Expr, context: &RewriteContext<'_>) -> Vec<ast:
     // Returns the expression's subexpression, if it exists. When the subexpr
     // is a try! macro, we'll convert it to shorthand when the option is set.
     fn pop_expr_chain(expr: &ast::Expr, context: &RewriteContext<'_>) -> Option<ast::Expr> {
-        match expr.node {
+        match expr.kind {
             ast::ExprKind::MethodCall(_, ref expressions) => {
                 Some(Self::convert_try(&expressions[0], context))
             }
-            ast::ExprKind::Field(ref subexpr, _) | ast::ExprKind::Try(ref subexpr) => {
-                Some(Self::convert_try(subexpr, context))
-            }
+            ast::ExprKind::Field(ref subexpr, _)
+            | ast::ExprKind::Try(ref subexpr)
+            | ast::ExprKind::Await(ref subexpr) => Some(Self::convert_try(subexpr, context)),
             _ => None,
         }
     }
 
     fn convert_try(expr: &ast::Expr, context: &RewriteContext<'_>) -> ast::Expr {
-        match expr.node {
+        match expr.kind {
             ast::ExprKind::Mac(ref mac) if context.config.use_try_shorthand() => {
                 if let Some(subexpr) = convert_try_mac(mac, context) {
                     subexpr
@@ -445,7 +452,7 @@ trait ChainFormatter {
     // Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
     // Root is the parent plus any other chain items placed on the first line to
     // avoid an orphan. E.g.,
-    // ```ignore
+    // ```text
     // foo.bar
     //     .baz()
     // ```
@@ -507,7 +514,7 @@ fn pure_root(&mut self) -> Option<String> {
     // know whether 'overflowing' the last child make a better formatting:
     //
     // A chain with overflowing the last child:
-    // ```ignore
+    // ```text
     // parent.child1.child2.last_child(
     //     a,
     //     b,
@@ -516,7 +523,7 @@ fn pure_root(&mut self) -> Option<String> {
     // ```
     //
     // A chain without overflowing the last child (in vertical layout):
-    // ```ignore
+    // ```text
     // parent
     //     .child1
     //     .child2
@@ -525,7 +532,7 @@ fn pure_root(&mut self) -> Option<String> {
     //
     // In particular, overflowing is effective when the last child is a method with a multi-lined
     // block-like argument (e.g., closure):
-    // ```ignore
+    // ```text
     // parent.child1.child2.last_child(|a, b, c| {
     //     let x = foo(a, b, c);
     //     let y = bar(a, b, c);
@@ -550,7 +557,10 @@ fn format_last_child(
         let almost_total = if extendable {
             prev_last_line_width
         } else {
-            self.rewrites.iter().map(String::len).sum()
+            self.rewrites
+                .iter()
+                .map(|rw| utils::unicode_str_width(&rw))
+                .sum()
         } + last.tries;
         let one_line_budget = if self.child_count == 1 {
             shape.width
@@ -637,7 +647,7 @@ fn join_rewrites(&self, context: &RewriteContext<'_>, child_shape: Shape) -> Opt
             Cow::from("")
         } else {
             // Use new lines.
-            if *context.force_one_line_chain.borrow() {
+            if context.force_one_line_chain.get() {
                 return None;
             }
             child_shape.to_string_with_newline(context.config)