//! following values of `chain_indent`:
//! Block:
//!
-//! ```ignore
+//! ```text
//! let foo = {
//! aaaa;
//! bbb;
//!
//! Visual:
//!
-//! ```ignore
+//! ```text
//! let foo = {
//! aaaa;
//! bbb;
//! the braces.
//! Block:
//!
-//! ```ignore
+//! ```text
//! let a = foo.bar
//! .baz()
//! .qux
//!
//! Visual:
//!
-//! ```ignore
+//! ```text
//! let a = foo.bar
//! .baz()
//! .qux
trimmed_last_line_width, wrap_str,
};
-pub fn rewrite_chain(
+pub(crate) fn rewrite_chain(
expr: &ast::Expr,
context: &RewriteContext<'_>,
shape: Shape,
),
StructField(ast::Ident),
TupleField(ast::Ident, bool),
+ Await,
Comment(String, CommentPosition),
}
ChainItemKind::MethodCall(..)
| ChainItemKind::StructField(..)
| ChainItemKind::TupleField(..)
+ | ChainItemKind::Await
| ChainItemKind::Comment(..) => false,
}
}
let span = mk_sp(nested.span.hi(), field.span.hi());
(kind, span)
}
+ ast::ExprKind::Await(ast::AwaitOrigin::FieldLike, ref nested) => {
+ let span = mk_sp(nested.span.hi(), expr.span.hi());
+ (ChainItemKind::Await, span)
+ }
_ => return (ChainItemKind::Parent(expr.clone()), expr.span),
};
if nested { " " } else { "" },
rewrite_ident(context, ident)
),
+ ChainItemKind::Await => ".await".to_owned(),
ChainItemKind::Comment(ref comment, _) => {
rewrite_comment(comment, false, shape, context.config)?
}
ast::ExprKind::MethodCall(_, ref expressions) => {
Some(Self::convert_try(&expressions[0], context))
}
- ast::ExprKind::Field(ref subexpr, _) | ast::ExprKind::Try(ref subexpr) => {
+ ast::ExprKind::Field(ref subexpr, _)
+ | ast::ExprKind::Try(ref subexpr)
+ | ast::ExprKind::Await(ast::AwaitOrigin::FieldLike, ref subexpr) => {
Some(Self::convert_try(subexpr, context))
}
_ => None,
// 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()
// ```
// 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,
// ```
//
// A chain without overflowing the last child (in vertical layout):
- // ```ignore
+ // ```text
// parent
// .child1
// .child2
//
// 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);
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