use std::borrow::Cow;
use std::cmp::min;
-use rustc_span::{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 from_ast(context: &RewriteContext<'_>, expr: &ast::Expr) -> (ChainItemKind, Span) {
let (kind, span) = match expr.kind {
- ast::ExprKind::MethodCall(ref segment, ref expressions) => {
+ 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![]
}
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,
// 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.kind {
- ast::ExprKind::MethodCall(_, ref expressions) => {
+ ast::ExprKind::MethodCall(_, ref expressions, _) => {
Some(Self::convert_try(&expressions[0], context))
}
ast::ExprKind::Field(ref subexpr, _)
fn convert_try(expr: &ast::Expr, context: &RewriteContext<'_>) -> ast::Expr {
match expr.kind {
- ast::ExprKind::Mac(ref mac) if context.config.use_try_shorthand() => {
+ 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);
ChainItemKind::Comment(_, CommentPosition::Top) => result.push_str(&connector),
_ => result.push_str(&connector),
}
- result.push_str(&rewrite);
+ result.push_str(rewrite);
}
Some(result)