user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Do not distinguish between a single-child chain from others

Browse source 
`last_shape` is used when rewriting the last child on its own line.
This commit is contained in:
topecongiro 2017-10-18 21:55:45 +09:00
parent 51d230ead3
commit ad47a71012
1 changed files with 48 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

57
src/chains.rs
View file

@ -166,25 +166,64 @@ pub fn rewrite_chain(expr: &ast::Expr, context: &RewriteContext, shape: Shape) -
let all_in_one_line = !parent_rewrite_contains_newline
&& rewrites.iter().all(|s| !s.contains('\n'))
&& almost_total < one_line_budget;
let last_shape = if rewrites.is_empty() {
// We only have a single child.
first_child_shape
} else {
match context.config.chain_indent() {
IndentStyle::Visual => other_child_shape.sub_width(shape.rhs_overhead(context.config))?,
IndentStyle::Block => other_child_shape,
}
let last_shape = match context.config.chain_indent() {
IndentStyle::Visual => other_child_shape.sub_width(shape.rhs_overhead(context.config))?,
IndentStyle::Block => other_child_shape,
};
let last_shape = last_shape.sub_width(suffix_try_num)?;
// Rewrite the last child. The last child of a chain requires special treatment. We need to
// know whether 'overflowing' the last child make a better formatting:
//
// A chain with overflowing the last child:
// ```
// parent.child1.child2.last_child(
// a,
// b,
// c,
// )
// ```
//
// A chain without overflowing the last child (in vertical layout):
// ```
// parent
// .child1
// .child2
// .last_child(a, b, c)
// ```
//
// In particular, overflowing is effective when the last child is a method with a multi-lined
// block-like argument (e.g. closure):
// ```
// parent.child1.chlid2.last_child(|a, b, c| {
// let x = foo(a, b, c);
// let y = bar(a, b, c);
//
// // ...
//
// result
// })
// ```
// `rewrite_last` rewrites the last child on its own line. We use a closure here instead of
// directly calling `rewrite_chain_subexpr()` to avoid exponential blowup.
let rewrite_last = || rewrite_chain_subexpr(last_subexpr, total_span, context, last_shape);
let (last_subexpr_str, fits_single_line) = if all_in_one_line || extend_last_subexr {
// First we try to 'overflow' the last child and see if it looks better than using
// vertical layout.
parent_shape.offset_left(almost_total).map(|shape| {
if let Some(rw) = rewrite_chain_subexpr(last_subexpr, total_span, context, shape) {
// We allow overflowing here only if both of the following conditions match:
// 1. The entire chain fits in a single line expect the last child.
// 2. `last_chlid_str.lines().count() >= 5`.
let line_count = rw.lines().count();
let fits_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
if fits_single_line && (line_count >= 5 || extend_last_subexr) {
if fits_single_line && line_count >= 5 {
(Some(rw), true)
} else {
// We could not know whether overflowing is better than using vertical layout,
// just by looking at the overflowed rewrite. Now we rewrite the last child
// on its own line, and compare two rewrites to choose which is better.
match rewrite_last() {
Some(ref new_rw) if !fits_single_line => (Some(new_rw.clone()), false),
Some(ref new_rw) if new_rw.lines().count() >= line_count => {