bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Align dots in chained expressions

Browse source
This commit is contained in:
Marcus Klaas 2015-09-09 23:14:54 +02:00
parent 95ef9dedb4
commit a9814149c9
8 changed files with 134 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

99
src/chains.rs
View file

@ -20,61 +20,58 @@
// argument function argument strategy.
use rewrite::{Rewrite, RewriteContext};
use utils::{make_indent, extra_offset};
use utils::make_indent;
use expr::rewrite_call;
use syntax::{ast, ptr};
use syntax::codemap::{mk_sp, Span};
use syntax::print::pprust;
pub fn rewrite_chain(orig_expr: &ast::Expr,
pub fn rewrite_chain(mut expr: &ast::Expr,
context: &RewriteContext,
width: usize,
offset: usize)
-> Option<String> {
let mut expr = orig_expr;
let mut rewrites = Vec::new();
let indent = offset + context.config.tab_spaces;
let max_width = try_opt!(context.config.max_width.checked_sub(indent));
let total_span = expr.span;
let mut subexpr_list = vec![expr];
while let Some(pair) = pop_expr_chain(expr, orig_expr.span, context, max_width, indent) {
let (rewrite, parent_expr) = pair;
rewrites.push(try_opt!(rewrite));
expr = parent_expr;
while let Some(subexpr) = pop_expr_chain(expr) {
subexpr_list.push(subexpr);
expr = subexpr;
}
let parent = subexpr_list.pop().unwrap();
let parent_rewrite = try_opt!(expr.rewrite(context, width, offset));
let (extra_indent, extend) = if !parent_rewrite.contains('\n') && is_continuable(parent) ||
parent_rewrite.len() <= context.config.tab_spaces {
(parent_rewrite.len(), true)
} else {
(context.config.tab_spaces, false)
};
let indent = offset + extra_indent;
let max_width = try_opt!(width.checked_sub(extra_indent));
let rewrites = try_opt!(subexpr_list.into_iter()
.rev()
.map(|e| {
rewrite_chain_expr(e,
total_span,
context,
max_width,
indent)
})
.collect::<Option<Vec<_>>>());
let total_width = rewrites.iter().fold(0, |a, b| a + b.len()) + parent_rewrite.len();
let fits_single_line = total_width <= width && rewrites.iter().all(|s| !s.contains('\n'));
if rewrites.len() == 1 && !fits_single_line &&
(is_continuable(expr) || parent_rewrite.len() <= context.config.tab_spaces) {
let extra_offset = extra_offset(&parent_rewrite, offset);
let offset = offset + extra_offset;
let max_width = try_opt!(width.checked_sub(extra_offset));
let rerewrite = pop_expr_chain(orig_expr, orig_expr.span, context, max_width, offset)
.unwrap()
.0;
return Some(format!("{}{}", parent_rewrite, try_opt!(rerewrite)));
}
let connector = if fits_single_line {
String::new()
} else {
format!("\n{}", make_indent(indent))
};
// FIXME: don't do this. There's a more efficient way. VecDeque?
rewrites.reverse();
// Put the first link on the same line as parent, if it fits.
let first_connector = if parent_rewrite.len() + rewrites[0].len() <= width &&
is_continuable(expr) &&
!rewrites[0].contains('\n') ||
parent_rewrite.len() <= context.config.tab_spaces {
let first_connector = if extend {
""
} else {
&connector[..]
@ -83,32 +80,36 @@ pub fn rewrite_chain(orig_expr: &ast::Expr,
Some(format!("{}{}{}", parent_rewrite, first_connector, rewrites.join(&connector)))
}
// Returns None when the expression is not a chainable. Otherwise, rewrites the
// outermost chain element and returns the remaining chain.
fn pop_expr_chain<'a>(expr: &'a ast::Expr,
fn pop_expr_chain<'a>(expr: &'a ast::Expr) -> Option<&'a ast::Expr> {
match expr.node {
ast::Expr_::ExprMethodCall(_, _, ref expressions) => {
Some(&expressions[0])
}
ast::Expr_::ExprTupField(ref subexpr, _) |
ast::Expr_::ExprField(ref subexpr, _) => {
Some(subexpr)
}
_ => None,
}
}
fn rewrite_chain_expr(expr: &ast::Expr,
span: Span,
context: &RewriteContext,
width: usize,
offset: usize)
-> Option<(Option<String>, &'a ast::Expr)> {
-> Option<String> {
match expr.node {
ast::Expr_::ExprMethodCall(ref method_name, ref types, ref expressions) => {
Some((rewrite_method_call(method_name.node,
types,
expressions,
span,
context,
width,
offset),
&expressions[0]))
rewrite_method_call(method_name.node, types, expressions, span, context, width, offset)
}
ast::Expr_::ExprField(ref subexpr, ref field) => {
Some((Some(format!(".{}", field.node)), subexpr))
ast::Expr_::ExprField(_, ref field) => {
Some(format!(".{}", field.node))
}
ast::Expr_::ExprTupField(ref subexpr, ref field) => {
Some((Some(format!(".{}", field.node)), subexpr))
ast::Expr_::ExprTupField(_, ref field) => {
Some(format!(".{}", field.node))
}
_ => None,
_ => unreachable!(),
}
}

4
src/expr.rs
View file

@ -1104,8 +1104,8 @@ fn rewrite_field(context: &RewriteContext,
-> Option<String> {
let name = &field.ident.node.to_string();
let overhead = name.len() + 2;
let expr =
field.expr.rewrite(context, try_opt!(width.checked_sub(overhead)), offset + overhead);
let expr = field.expr
.rewrite(context, try_opt!(width.checked_sub(overhead)), offset + overhead);
expr.map(|s| format!("{}: {}", name, s))
}

9
src/items.rs
View file

@ -332,8 +332,9 @@ impl<'a> FmtVisitor<'a> {
// Account for sugary self.
// FIXME: the comment for the self argument is dropped. This is blocked
// on rust issue #27522.
let min_args = explicit_self
.and_then(|explicit_self| rewrite_explicit_self(explicit_self, args))
let min_args = explicit_self.and_then(|explicit_self| {
rewrite_explicit_self(explicit_self, args)
})
.map(|self_str| {
arg_item_strs[0] = self_str;
2
@ -762,7 +763,9 @@ impl<'a> FmtVisitor<'a> {
let indent = self.block_indent + self.config.tab_spaces;
let mut attr_str = field.node
.attrs
.rewrite(&self.get_context(), self.config.max_width - indent, indent)
.rewrite(&self.get_context(),
self.config.max_width - indent,
indent)
.unwrap();
if !attr_str.is_empty() {
attr_str.push('\n');

11
src/types.rs
View file

@ -279,7 +279,10 @@ impl Rewrite for ast::WherePredicate {
.. }) => {
if !bound_lifetimes.is_empty() {
let lifetime_str = bound_lifetimes.iter()
.map(|lt| lt.rewrite(context, width, offset).unwrap())
.map(|lt| {
lt.rewrite(context, width, offset)
.unwrap()
})
.collect::<Vec<_>>()
.join(", ");
let type_str = pprust::ty_to_string(bounded_ty);
@ -287,8 +290,7 @@ impl Rewrite for ast::WherePredicate {
let used_width = lifetime_str.len() + type_str.len() + 8;
let bounds_str = bounds.iter()
.map(|ty_bound| {
ty_bound
.rewrite(context,
ty_bound.rewrite(context,
width - used_width,
offset + used_width)
.unwrap()
@ -303,8 +305,7 @@ impl Rewrite for ast::WherePredicate {
let used_width = type_str.len() + 2;
let bounds_str = bounds.iter()
.map(|ty_bound| {
ty_bound
.rewrite(context,
ty_bound.rewrite(context,
width - used_width,
offset + used_width)
.unwrap()

3
src/visitor.rs
View file

@ -288,8 +288,7 @@ impl<'a> FmtVisitor<'a> {
if utils::contains_skip(attrs) {
true
} else {
let rewrite = attrs
.rewrite(&self.get_context(),
let rewrite = attrs.rewrite(&self.get_context(),
self.config.max_width - self.block_indent,
self.block_indent)
.unwrap();

6
tests/target/chains.rs
View file

@ -35,10 +35,10 @@ fn main() {
let suuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuum = xxxxxxx.map(|x| x + 5)
.map(|x| x / 2)
.fold(0, |acc, x| acc + x);
.fold(0,
|acc, x| acc + x);
aaaaaaaaaaaaaaaa
.map(|x| {
aaaaaaaaaaaaaaaa.map(|x| {
x += 1;
x
})