//! 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
use std::borrow::Cow;
use std::cmp::min;
-use syntax::source_map::{BytePos, Span};
-use syntax::{ast, ptr};
+use rustc_ast::{ast, ptr};
+use rustc_span::{symbol, BytePos, Span};
use crate::comment::{rewrite_comment, CharClasses, FullCodeCharKind, RichChar};
-use crate::config::IndentStyle;
+use crate::config::{IndentStyle, Version};
use crate::expr::rewrite_call;
use crate::lists::extract_pre_comment;
use crate::macros::convert_try_mac;
trimmed_last_line_width, wrap_str,
};
-pub fn rewrite_chain(
+pub(crate) fn rewrite_chain(
expr: &ast::Expr,
context: &RewriteContext<'_>,
shape: Shape,
Vec<ast::GenericArg>,
Vec<ptr::P<ast::Expr>>,
),
- StructField(ast::Ident),
- TupleField(ast::Ident, bool),
+ StructField(symbol::Ident),
+ TupleField(symbol::Ident, bool),
+ Await,
Comment(String, CommentPosition),
}
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))
}
}
fn from_ast(context: &RewriteContext<'_>, expr: &ast::Expr) -> (ChainItemKind, Span) {
- let (kind, span) = match expr.node {
- ast::ExprKind::MethodCall(ref segment, ref expressions) => {
+ 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 {
- data.args.clone()
+ data.args
+ .iter()
+ .filter_map(|x| match x {
+ ast::AngleBracketedArg::Arg(ref generic_arg) => {
+ Some(generic_arg.clone())
+ }
+ _ => None,
+ })
+ .collect::<Vec<_>>()
} else {
vec![]
}
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),
};
ChainItemKind::StructField(ident) => format!(".{}", rewrite_ident(context, ident)),
ChainItemKind::TupleField(ident, nested) => format!(
"{}.{}",
- if nested { " " } else { "" },
+ if nested && context.config.version() == Version::One {
+ " "
+ } else {
+ ""
+ },
rewrite_ident(context, ident)
),
+ ChainItemKind::Await => ".await".to_owned(),
ChainItemKind::Comment(ref comment, _) => {
rewrite_comment(comment, false, shape, context.config)?
}
}
fn is_comment(&self) -> bool {
- match self.kind {
- ChainItemKind::Comment(..) => true,
- _ => false,
- }
+ matches!(self.kind, ChainItemKind::Comment(..))
}
fn rewrite_method_call(
- method_name: ast::Ident,
+ method_name: symbol::Ident,
types: &[ast::GenericArg],
args: &[ptr::P<ast::Expr>],
span: Span,
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));
// 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 {
- ast::ExprKind::MethodCall(_, ref expressions) => {
+ 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 {
- ast::ExprKind::Mac(ref mac) if context.config.use_try_shorthand() => {
+ match expr.kind {
+ ast::ExprKind::MacCall(ref mac) if context.config.use_try_shorthand() => {
if let Some(subexpr) = convert_try_mac(mac, context) {
subexpr
} else {
// 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
} else {
- min(shape.width, context.config.width_heuristics().chain_width)
+ min(shape.width, context.config.chain_width())
}
.saturating_sub(almost_total);
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)
ChainItemKind::Comment(_, CommentPosition::Top) => result.push_str(&connector),
_ => result.push_str(&connector),
}
- result.push_str(&rewrite);
+ result.push_str(rewrite);
}
Some(result)