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;
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),
}
}
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(ast::AwaitOrigin::FieldLike, ref nested) => {
+ ast::ExprKind::Await(ref nested) => {
let span = mk_sp(nested.span.hi(), expr.span.hi());
(ChainItemKind::Await, 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(),
}
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)
- | ast::ExprKind::Await(ast::AwaitOrigin::FieldLike, ref subexpr) => {
- Some(Self::convert_try(subexpr, context))
- }
+ | 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 {
} else {
self.rewrites
.iter()
- .map(|rw| utils::unicode_str_width(&rw))
+ .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)