mirror of
https://github.com/rust-lang/rust.git
synced 2024-12-03 20:23:59 +00:00
chains: factor into objects
This commit is contained in:
Nick Cameron
parent
86314bf09f
commit
a56ff9d02f
638
src/chains.rs
638
src/chains.rs
@ -111,7 +111,7 @@ struct Chain {
|
||||
|
||||
impl Chain {
|
||||
fn from_ast(expr: &ast::Expr, context: &RewriteContext) -> Chain {
|
||||
let mut subexpr_list = make_subexpr_list(expr, context);
|
||||
let mut subexpr_list = Self::make_subexpr_list(expr, context);
|
||||
|
||||
// Un-parse the expression tree into ChainItems
|
||||
let mut children = vec![];
|
||||
@ -139,10 +139,67 @@ impl Chain {
|
||||
children,
|
||||
}
|
||||
}
|
||||
|
||||
// Returns a Vec of the prefixes of the chain.
|
||||
// E.g., for input `a.b.c` we return [`a.b.c`, `a.b`, 'a']
|
||||
fn make_subexpr_list(expr: &ast::Expr, context: &RewriteContext) -> Vec<ast::Expr> {
|
||||
let mut subexpr_list = vec![expr.clone()];
|
||||
|
||||
while let Some(subexpr) = Self::pop_expr_chain(subexpr_list.last().unwrap(), context) {
|
||||
subexpr_list.push(subexpr.clone());
|
||||
}
|
||||
|
||||
subexpr_list
|
||||
}
|
||||
|
||||
// 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) => {
|
||||
Some(Self::convert_try(&expressions[0], context))
|
||||
}
|
||||
ast::ExprKind::Field(ref subexpr, _) | ast::ExprKind::Try(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() => {
|
||||
if let Some(subexpr) = convert_try_mac(mac, context) {
|
||||
subexpr
|
||||
} else {
|
||||
expr.clone()
|
||||
}
|
||||
}
|
||||
_ => expr.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rewrite_chain_block(chain: Chain, context: &RewriteContext, shape: Shape) -> Option<String> {
|
||||
debug!("rewrite_chain_block {:?} {:?}", chain, shape);
|
||||
// TODO comments
|
||||
struct ChainFormatterBlock<'a> {
|
||||
children: &'a[ChainItem],
|
||||
rewrites: Vec<String>,
|
||||
root_ends_with_block: bool,
|
||||
is_block_like: Vec<bool>,
|
||||
fits_single_line: bool,
|
||||
}
|
||||
|
||||
impl <'a> ChainFormatterBlock<'a> {
|
||||
fn new(chain: &'a Chain) -> ChainFormatterBlock<'a> {
|
||||
ChainFormatterBlock {
|
||||
children: &chain.children,
|
||||
root_ends_with_block: false,
|
||||
rewrites: Vec::with_capacity(chain.children.len() + 1),
|
||||
is_block_like: Vec::with_capacity(chain.children.len() + 1),
|
||||
fits_single_line: false,
|
||||
}
|
||||
}
|
||||
|
||||
// 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.,
|
||||
@ -151,73 +208,53 @@ fn rewrite_chain_block(chain: Chain, context: &RewriteContext, shape: Shape) ->
|
||||
// .baz()
|
||||
// ```
|
||||
// If `bar` were not part of the root, then baz would be orphaned and 'float'.
|
||||
let mut root_rewrite = chain.parent.expr
|
||||
.rewrite(context, shape)
|
||||
.map(|parent_rw| parent_rw + &"?".repeat(chain.parent.tries))?;
|
||||
fn format_root(&mut self, parent: &ChainItem, context: &RewriteContext, shape: Shape) -> Option<()> {
|
||||
let mut root_rewrite: String = parent.expr
|
||||
.rewrite(context, shape)
|
||||
.map(|parent_rw| parent_rw + &"?".repeat(parent.tries))?;
|
||||
|
||||
let mut children: &[_] = &chain.children;
|
||||
let mut root_ends_with_block = is_block_expr(context, &chain.parent.expr, &root_rewrite);
|
||||
let tab_width = context.config.tab_spaces().saturating_sub(shape.offset);
|
||||
self.root_ends_with_block = is_block_expr(context, &parent.expr, &root_rewrite);
|
||||
let tab_width = context.config.tab_spaces().saturating_sub(shape.offset);
|
||||
|
||||
while root_rewrite.len() <= tab_width && !root_rewrite.contains('\n') {
|
||||
let item = &children[0];
|
||||
let shape = shape.offset_left(root_rewrite.len())?;
|
||||
match rewrite_chain_subexpr(&item.expr, context, shape) {
|
||||
Some(rewrite) => {
|
||||
root_rewrite.push_str(&rewrite);
|
||||
root_rewrite.push_str(&"?".repeat(item.tries));
|
||||
while root_rewrite.len() <= tab_width && !root_rewrite.contains('\n') {
|
||||
let item = &self.children[0];
|
||||
let shape = shape.offset_left(root_rewrite.len())?;
|
||||
match rewrite_chain_subexpr(&item.expr, context, shape) {
|
||||
Some(rewrite) => {
|
||||
root_rewrite.push_str(&rewrite);
|
||||
root_rewrite.push_str(&"?".repeat(item.tries));
|
||||
}
|
||||
None => break,
|
||||
}
|
||||
None => break,
|
||||
}
|
||||
|
||||
root_ends_with_block = is_block_expr(context, &item.expr, &root_rewrite);
|
||||
self.root_ends_with_block = is_block_expr(context, &item.expr, &root_rewrite);
|
||||
|
||||
children = &children[1..];
|
||||
if children.is_empty() {
|
||||
return Some(root_rewrite);
|
||||
self.children = &self.children[1..];
|
||||
if self.children.is_empty() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
self.rewrites.push(root_rewrite);
|
||||
Some(())
|
||||
}
|
||||
|
||||
// Separate out the last item in the chain for special treatment below.
|
||||
let last = &children[children.len() - 1];
|
||||
children = &children[..children.len() - 1];
|
||||
|
||||
// Decide how to layout the rest of the chain.
|
||||
let child_shape = if root_ends_with_block {
|
||||
shape
|
||||
} else {
|
||||
shape.block_indent(context.config.tab_spaces())
|
||||
}.with_max_width(context.config);
|
||||
|
||||
let mut rewrites: Vec<String> = Vec::with_capacity(children.len() + 2);
|
||||
rewrites.push(root_rewrite);
|
||||
let mut is_block_like = Vec::with_capacity(children.len() + 2);
|
||||
is_block_like.push(root_ends_with_block);
|
||||
for item in children {
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, child_shape)?;
|
||||
is_block_like.push(is_block_expr(context, &item.expr, &rewrite));
|
||||
rewrites.push(format!("{}{}", rewrite, "?".repeat(item.tries)));
|
||||
fn child_shape(&self, context: &RewriteContext, shape: Shape) -> Shape {
|
||||
if self.root_ends_with_block {
|
||||
shape
|
||||
} else {
|
||||
shape.block_indent(context.config.tab_spaces())
|
||||
}.with_max_width(context.config)
|
||||
}
|
||||
|
||||
// Total of all items excluding the last.
|
||||
let extend_last_subexpr = last_line_extendable(&rewrites[rewrites.len() - 1]);
|
||||
let almost_total = if extend_last_subexpr {
|
||||
last_line_width(&rewrites[rewrites.len() - 1])
|
||||
} else {
|
||||
rewrites.iter().fold(0, |a, b| a + b.len())
|
||||
} + last.tries;
|
||||
let one_line_budget = if rewrites.len() == 1 {
|
||||
shape.width
|
||||
} else {
|
||||
min(shape.width, context.config.width_heuristics().chain_width)
|
||||
};
|
||||
let all_in_one_line = rewrites.iter().all(|s| !s.contains('\n'))
|
||||
&& almost_total < one_line_budget;
|
||||
let last_shape = if all_in_one_line {
|
||||
shape.sub_width(last.tries)?
|
||||
} else {
|
||||
child_shape.sub_width(shape.rhs_overhead(context.config) + last.tries)?
|
||||
};
|
||||
fn format_children(&mut self, context: &RewriteContext, child_shape: Shape) -> Option<()> {
|
||||
self.is_block_like.push(self.root_ends_with_block);
|
||||
for item in &self.children[..self.children.len()] {
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, child_shape)?;
|
||||
self.is_block_like.push(is_block_expr(context, &item.expr, &rewrite));
|
||||
self.rewrites.push(format!("{}{}", rewrite, "?".repeat(item.tries)));
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
// 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:
|
||||
@ -251,239 +288,279 @@ fn rewrite_chain_block(chain: Chain, context: &RewriteContext, shape: Shape) ->
|
||||
// result
|
||||
// })
|
||||
// ```
|
||||
fn format_last_child(&mut self, context: &RewriteContext, shape: Shape, child_shape: Shape) -> Option<()> {
|
||||
let last = &self.children[self.children.len() - 1];
|
||||
let extendable = last_line_extendable(&self.rewrites[self.rewrites.len() - 1]);
|
||||
// Total of all items excluding the last.
|
||||
let almost_total = if extendable {
|
||||
last_line_width(&self.rewrites[self.rewrites.len() - 1])
|
||||
} else {
|
||||
self.rewrites.iter().fold(0, |a, b| a + b.len())
|
||||
} + last.tries;
|
||||
let one_line_budget = if self.rewrites.len() == 1 {
|
||||
shape.width
|
||||
} else {
|
||||
min(shape.width, context.config.width_heuristics().chain_width)
|
||||
}.saturating_sub(almost_total);
|
||||
|
||||
let mut last_subexpr_str = None;
|
||||
let mut fits_single_line = false;
|
||||
if all_in_one_line || extend_last_subexpr {
|
||||
// First we try to 'overflow' the last child and see if it looks better than using
|
||||
// vertical layout.
|
||||
if let Some(shape) = last_shape.offset_left(almost_total) {
|
||||
if let Some(rw) = rewrite_chain_subexpr(&last.expr, context, shape) {
|
||||
// We allow overflowing here only if both of the following conditions match:
|
||||
// 1. The entire chain fits in a single line except the last child.
|
||||
// 2. `last_child_str.lines().count() >= 5`.
|
||||
let line_count = rw.lines().count();
|
||||
let could_fit_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
|
||||
if fits_single_line && line_count >= 5 {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = 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_chain_subexpr(&last.expr, context, last_shape) {
|
||||
Some(ref new_rw) if !could_fit_single_line => {
|
||||
last_subexpr_str = Some(new_rw.clone());
|
||||
}
|
||||
Some(ref new_rw) if new_rw.lines().count() >= line_count => {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = could_fit_single_line;
|
||||
}
|
||||
new_rw @ Some(..) => {
|
||||
last_subexpr_str = new_rw;
|
||||
}
|
||||
_ => {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = could_fit_single_line;
|
||||
let all_in_one_line = self.rewrites.iter().all(|s| !s.contains('\n')) && one_line_budget > 0;
|
||||
let last_shape = if all_in_one_line {
|
||||
shape.sub_width(last.tries)?
|
||||
} else {
|
||||
child_shape.sub_width(shape.rhs_overhead(context.config) + last.tries)?
|
||||
};
|
||||
|
||||
let mut last_subexpr_str = None;
|
||||
if all_in_one_line || extendable {
|
||||
// First we try to 'overflow' the last child and see if it looks better than using
|
||||
// vertical layout.
|
||||
if let Some(shape) = last_shape.offset_left(almost_total) {
|
||||
if let Some(rw) = rewrite_chain_subexpr(&last.expr, context, shape) {
|
||||
// We allow overflowing here only if both of the following conditions match:
|
||||
// 1. The entire chain fits in a single line except the last child.
|
||||
// 2. `last_child_str.lines().count() >= 5`.
|
||||
let line_count = rw.lines().count();
|
||||
let could_fit_single_line = first_line_width(&rw) <= one_line_budget;
|
||||
if could_fit_single_line && line_count >= 5 {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = all_in_one_line;
|
||||
} 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_chain_subexpr(&last.expr, context, last_shape) {
|
||||
Some(ref new_rw) if !could_fit_single_line => {
|
||||
last_subexpr_str = Some(new_rw.clone());
|
||||
}
|
||||
Some(ref new_rw) if new_rw.lines().count() >= line_count => {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = could_fit_single_line && all_in_one_line;
|
||||
}
|
||||
new_rw @ Some(..) => {
|
||||
last_subexpr_str = new_rw;
|
||||
}
|
||||
_ => {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = could_fit_single_line && all_in_one_line;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
last_subexpr_str = last_subexpr_str.or_else(|| rewrite_chain_subexpr(&last.expr, context, last_shape));
|
||||
self.rewrites.push(format!("{}{}", last_subexpr_str?, "?".repeat(last.tries)));
|
||||
Some(())
|
||||
}
|
||||
|
||||
last_subexpr_str = last_subexpr_str.or_else(|| rewrite_chain_subexpr(&last.expr, context, last_shape));
|
||||
rewrites.push(format!("{}{}", last_subexpr_str?, "?".repeat(last.tries)));
|
||||
|
||||
// We should never look at this, since we only look at the block-ness of the
|
||||
// previous item in the chain.
|
||||
is_block_like.push(false);
|
||||
fn join_rewrites(&self, context: &RewriteContext, child_shape: Shape) -> Option<String> {
|
||||
let connector = if self.fits_single_line {
|
||||
// Yay, we can put everything on one line.
|
||||
Cow::from("")
|
||||
} else {
|
||||
// Use new lines.
|
||||
if *context.force_one_line_chain.borrow() {
|
||||
return None;
|
||||
}
|
||||
child_shape.indent.to_string_with_newline(context.config)
|
||||
};
|
||||
|
||||
let connector = if fits_single_line && all_in_one_line {
|
||||
// Yay, we can put everything on one line.
|
||||
Cow::from("")
|
||||
} else {
|
||||
// Use new lines.
|
||||
if *context.force_one_line_chain.borrow() {
|
||||
return None;
|
||||
let mut rewrite_iter = self.rewrites.iter();
|
||||
let mut result = rewrite_iter.next().unwrap().clone();
|
||||
|
||||
for (rewrite, prev_is_block_like) in rewrite_iter.zip(self.is_block_like.iter()) {
|
||||
if rewrite != "?" && !prev_is_block_like {
|
||||
result.push_str(&connector);
|
||||
}
|
||||
result.push_str(&rewrite);
|
||||
}
|
||||
child_shape.indent.to_string_with_newline(context.config)
|
||||
};
|
||||
|
||||
let result = join_rewrites(&rewrites, &is_block_like, &connector);
|
||||
Some(result)
|
||||
}
|
||||
}
|
||||
|
||||
fn rewrite_chain_block(chain: Chain, context: &RewriteContext, shape: Shape) -> Option<String> {
|
||||
debug!("rewrite_chain_block {:?} {:?}", chain, shape);
|
||||
|
||||
let mut formatter = ChainFormatterBlock::new(&chain);
|
||||
|
||||
formatter.format_root(&chain.parent, context, shape)?;
|
||||
if formatter.children.is_empty() {
|
||||
assert_eq!(formatter.rewrites.len(), 1);
|
||||
return Some(formatter.rewrites.pop().unwrap());
|
||||
}
|
||||
|
||||
// Decide how to layout the rest of the chain.
|
||||
let child_shape = formatter.child_shape(context, shape);
|
||||
formatter.format_children(context, child_shape)?;
|
||||
|
||||
formatter.format_last_child(context, shape, child_shape)?;
|
||||
|
||||
let result = formatter.join_rewrites(context, child_shape)?;
|
||||
Some(result)
|
||||
}
|
||||
|
||||
fn rewrite_chain_visual(chain: Chain, context: &RewriteContext, shape: Shape) -> Option<String> {
|
||||
// Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
|
||||
let parent_shape = if is_block_expr(context, &chain.parent.expr, "\n") {
|
||||
shape.visual_indent(0)
|
||||
} else {
|
||||
shape
|
||||
};
|
||||
let mut children: &[_] = &chain.children;
|
||||
let mut root_rewrite = chain.parent.expr
|
||||
.rewrite(context, parent_shape)
|
||||
.map(|parent_rw| parent_rw + &"?".repeat(chain.parent.tries))?;
|
||||
struct ChainFormatterVisual<'a> {
|
||||
children: &'a[ChainItem],
|
||||
rewrites: Vec<String>,
|
||||
fits_single_line: bool,
|
||||
}
|
||||
|
||||
if !root_rewrite.contains('\n') && is_continuable(&chain.parent.expr) {
|
||||
let item = &children[0];
|
||||
let overhead = last_line_width(&root_rewrite);
|
||||
let shape = parent_shape.offset_left(overhead)?;
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, shape)?;
|
||||
root_rewrite.push_str(&rewrite);
|
||||
root_rewrite.push_str(&"?".repeat(item.tries));
|
||||
children = &children[1..];
|
||||
if children.is_empty() {
|
||||
return Some(root_rewrite);
|
||||
impl<'a> ChainFormatterVisual<'a> {
|
||||
fn new(chain: &'a Chain) -> ChainFormatterVisual<'a> {
|
||||
ChainFormatterVisual {
|
||||
children: &chain.children,
|
||||
rewrites: Vec::with_capacity(chain.children.len() + 1),
|
||||
fits_single_line: false,
|
||||
}
|
||||
}
|
||||
|
||||
let last = &children[children.len() - 1];
|
||||
children = &children[..children.len() - 1];
|
||||
fn format_root(&mut self, parent: &ChainItem, context: &RewriteContext, shape: Shape) -> Option<()> {
|
||||
// Parent is the first item in the chain, e.g., `foo` in `foo.bar.baz()`.
|
||||
let parent_shape = if is_block_expr(context, &parent.expr, "\n") {
|
||||
shape.visual_indent(0)
|
||||
} else {
|
||||
shape
|
||||
};
|
||||
let mut root_rewrite = parent.expr
|
||||
.rewrite(context, parent_shape)
|
||||
.map(|parent_rw| parent_rw + &"?".repeat(parent.tries))?;
|
||||
|
||||
let child_shape = shape.visual_indent(0).with_max_width(context.config);
|
||||
if !root_rewrite.contains('\n') && Self::is_continuable(&parent.expr) {
|
||||
let item = &self.children[0];
|
||||
let overhead = last_line_width(&root_rewrite);
|
||||
let shape = parent_shape.offset_left(overhead)?;
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, shape)?;
|
||||
root_rewrite.push_str(&rewrite);
|
||||
root_rewrite.push_str(&"?".repeat(item.tries));
|
||||
|
||||
let mut rewrites: Vec<String> = Vec::with_capacity(children.len() + 2);
|
||||
rewrites.push(root_rewrite);
|
||||
for item in chain.children.iter() {
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, child_shape)?;
|
||||
rewrites.push(format!("{}{}", rewrite, "?".repeat(item.tries)));
|
||||
self.children = &self.children[1..];
|
||||
}
|
||||
|
||||
self.rewrites.push(root_rewrite);
|
||||
Some(())
|
||||
}
|
||||
|
||||
// Total of all items excluding the last.
|
||||
let almost_total = rewrites.iter().fold(0, |a, b| a + b.len()) + last.tries;
|
||||
let one_line_budget = if rewrites.len() == 1 {
|
||||
shape.width
|
||||
} else {
|
||||
min(shape.width, context.config.width_heuristics().chain_width)
|
||||
};
|
||||
let all_in_one_line = rewrites.iter().all(|s| !s.contains('\n'))
|
||||
&& almost_total < one_line_budget;
|
||||
let last_shape = child_shape.sub_width(shape.rhs_overhead(context.config) + last.tries)?;
|
||||
// Determines if we can continue formatting a given expression on the same line.
|
||||
fn is_continuable(expr: &ast::Expr) -> bool {
|
||||
match expr.node {
|
||||
ast::ExprKind::Path(..) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
// 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.child2.last_child(|a, b, c| {
|
||||
// let x = foo(a, b, c);
|
||||
// let y = bar(a, b, c);
|
||||
//
|
||||
// // ...
|
||||
//
|
||||
// result
|
||||
// })
|
||||
// ```
|
||||
fn format_children(&mut self, context: &RewriteContext, child_shape: Shape) -> Option<()> {
|
||||
for item in &self.children[..self.children.len() - 1] {
|
||||
let rewrite = rewrite_chain_subexpr(&item.expr, context, child_shape)?;
|
||||
self.rewrites.push(format!("{}{}", rewrite, "?".repeat(item.tries)));
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
let mut last_subexpr_str = None;
|
||||
let mut fits_single_line = false;
|
||||
if all_in_one_line {
|
||||
// First we try to 'overflow' the last child and see if it looks better than using
|
||||
// vertical layout.
|
||||
if let Some(shape) = parent_shape.offset_left(almost_total) {
|
||||
if let Some(rw) = rewrite_chain_subexpr(&last.expr, context, shape) {
|
||||
// We allow overflowing here only if both of the following conditions match:
|
||||
// 1. The entire chain fits in a single line except the last child.
|
||||
// 2. `last_child_str.lines().count() >= 5`.
|
||||
let line_count = rw.lines().count();
|
||||
let could_fit_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
|
||||
if could_fit_single_line && line_count >= 5 {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = 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_chain_subexpr(&last.expr, context, last_shape) {
|
||||
Some(ref new_rw) if !could_fit_single_line => {
|
||||
last_subexpr_str = Some(new_rw.clone());
|
||||
}
|
||||
Some(ref new_rw) if new_rw.lines().count() >= line_count => {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = could_fit_single_line;
|
||||
}
|
||||
new_rw @ Some(..) => {
|
||||
last_subexpr_str = new_rw;
|
||||
}
|
||||
_ => {
|
||||
last_subexpr_str = Some(rw);
|
||||
fits_single_line = could_fit_single_line;
|
||||
fn format_last_child(&mut self, context: &RewriteContext, shape: Shape, child_shape: Shape) -> Option<()> {
|
||||
let last = &self.children[self.children.len() - 1];
|
||||
|
||||
// Total of all items excluding the last.
|
||||
let almost_total = self.rewrites.iter().fold(0, |a, b| a + b.len()) + last.tries;
|
||||
let one_line_budget = if self.rewrites.len() == 1 {
|
||||
shape.width
|
||||
} else {
|
||||
min(shape.width, context.config.width_heuristics().chain_width)
|
||||
};
|
||||
let all_in_one_line = self.rewrites.iter().all(|s| !s.contains('\n'))
|
||||
&& almost_total < one_line_budget;
|
||||
let last_shape = child_shape.sub_width(shape.rhs_overhead(context.config) + last.tries)?;
|
||||
|
||||
|
||||
let mut last_subexpr_str = None;
|
||||
if all_in_one_line {
|
||||
// First we try to 'overflow' the last child and see if it looks better than using
|
||||
// vertical layout.
|
||||
if let Some(shape) = shape.offset_left(almost_total) {
|
||||
if let Some(rw) = rewrite_chain_subexpr(&last.expr, context, shape) {
|
||||
// We allow overflowing here only if both of the following conditions match:
|
||||
// 1. The entire chain fits in a single line except the last child.
|
||||
// 2. `last_child_str.lines().count() >= 5`.
|
||||
let line_count = rw.lines().count();
|
||||
let could_fit_single_line = almost_total + first_line_width(&rw) <= one_line_budget;
|
||||
if could_fit_single_line && line_count >= 5 {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = all_in_one_line;
|
||||
} 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_chain_subexpr(&last.expr, context, last_shape) {
|
||||
Some(ref new_rw) if !could_fit_single_line => {
|
||||
last_subexpr_str = Some(new_rw.clone());
|
||||
}
|
||||
Some(ref new_rw) if new_rw.lines().count() >= line_count => {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = could_fit_single_line && all_in_one_line;
|
||||
}
|
||||
new_rw @ Some(..) => {
|
||||
last_subexpr_str = new_rw;
|
||||
}
|
||||
_ => {
|
||||
last_subexpr_str = Some(rw);
|
||||
self.fits_single_line = could_fit_single_line && all_in_one_line;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let last_subexpr_str = last_subexpr_str.or_else(|| rewrite_chain_subexpr(&last.expr, context, last_shape));
|
||||
self.rewrites.push(format!("{}{}", last_subexpr_str?, "?".repeat(last.tries)));
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn join_rewrites(&self, context: &RewriteContext, child_shape: Shape) -> Option<String> {
|
||||
let connector = if self.fits_single_line {
|
||||
// Yay, we can put everything on one line.
|
||||
Cow::from("")
|
||||
} else {
|
||||
// Use new lines.
|
||||
if *context.force_one_line_chain.borrow() {
|
||||
return None;
|
||||
}
|
||||
child_shape.indent.to_string_with_newline(context.config)
|
||||
};
|
||||
|
||||
let mut rewrite_iter = self.rewrites.iter();
|
||||
let mut result = rewrite_iter.next().unwrap().clone();
|
||||
|
||||
for rewrite in rewrite_iter {
|
||||
result.push_str(&connector);
|
||||
result.push_str(&rewrite);
|
||||
}
|
||||
}
|
||||
|
||||
last_subexpr_str = last_subexpr_str.or_else(|| rewrite_chain_subexpr(&last.expr, context, last_shape));
|
||||
rewrites.push(last_subexpr_str?);
|
||||
Some(result)
|
||||
}
|
||||
}
|
||||
|
||||
let connector = if fits_single_line && all_in_one_line {
|
||||
// Yay, we can put everything on one line.
|
||||
Cow::from("")
|
||||
} else {
|
||||
// Use new lines.
|
||||
if *context.force_one_line_chain.borrow() {
|
||||
return None;
|
||||
}
|
||||
child_shape.indent.to_string_with_newline(context.config)
|
||||
};
|
||||
fn rewrite_chain_visual(chain: Chain, context: &RewriteContext, shape: Shape) -> Option<String> {
|
||||
let mut formatter = ChainFormatterVisual::new(&chain);
|
||||
|
||||
let result = format!("{}{}",
|
||||
join_rewrites_vis(&rewrites, &connector),
|
||||
"?".repeat(last.tries),
|
||||
);
|
||||
formatter.format_root(&chain.parent, context, shape)?;
|
||||
|
||||
if formatter.children.is_empty() {
|
||||
assert_eq!(formatter.rewrites.len(), 1);
|
||||
return Some(formatter.rewrites.pop().unwrap());
|
||||
}
|
||||
|
||||
let child_shape = shape.visual_indent(0).with_max_width(context.config);
|
||||
|
||||
formatter.format_children(context, child_shape)?;
|
||||
formatter.format_last_child(context, shape, child_shape)?;
|
||||
|
||||
let result = formatter.join_rewrites(context, child_shape)?;
|
||||
wrap_str(result, context.config.max_width(), shape)
|
||||
}
|
||||
|
||||
fn join_rewrites(rewrites: &[String], is_block_like: &[bool], connector: &str) -> String {
|
||||
let mut rewrite_iter = rewrites.iter();
|
||||
let mut result = rewrite_iter.next().unwrap().clone();
|
||||
|
||||
for (rewrite, prev_is_block_like) in rewrite_iter.zip(is_block_like.iter()) {
|
||||
if rewrite != "?" && !prev_is_block_like {
|
||||
result.push_str(connector);
|
||||
}
|
||||
result.push_str(&rewrite);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
fn join_rewrites_vis(rewrites: &[String], connector: &str) -> String {
|
||||
let mut rewrite_iter = rewrites.iter();
|
||||
let mut result = rewrite_iter.next().unwrap().clone();
|
||||
|
||||
for rewrite in rewrite_iter {
|
||||
if rewrite != "?" {
|
||||
result.push_str(connector);
|
||||
}
|
||||
result.push_str(&rewrite);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
// States whether an expression's last line exclusively consists of closing
|
||||
// parens, braces, and brackets in its idiomatic formatting.
|
||||
fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool {
|
||||
@ -513,45 +590,6 @@ fn is_block_expr(context: &RewriteContext, expr: &ast::Expr, repr: &str) -> bool
|
||||
}
|
||||
}
|
||||
|
||||
// Returns a Vec of the prefixes of the chain.
|
||||
// E.g., for input `a.b.c` we return [`a.b.c`, `a.b`, 'a']
|
||||
fn make_subexpr_list(expr: &ast::Expr, context: &RewriteContext) -> Vec<ast::Expr> {
|
||||
let mut subexpr_list = vec![expr.clone()];
|
||||
|
||||
while let Some(subexpr) = pop_expr_chain(subexpr_list.last().unwrap(), context) {
|
||||
subexpr_list.push(subexpr.clone());
|
||||
}
|
||||
|
||||
subexpr_list
|
||||
}
|
||||
|
||||
// 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) => {
|
||||
Some(convert_try(&expressions[0], context))
|
||||
}
|
||||
ast::ExprKind::Field(ref subexpr, _) | ast::ExprKind::Try(ref subexpr) => {
|
||||
Some(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() => {
|
||||
if let Some(subexpr) = convert_try_mac(mac, context) {
|
||||
subexpr
|
||||
} else {
|
||||
expr.clone()
|
||||
}
|
||||
}
|
||||
_ => expr.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
// Rewrite the last element in the chain `expr`. E.g., given `a.b.c` we rewrite
|
||||
// `.c`.
|
||||
fn rewrite_chain_subexpr(
|
||||
@ -600,14 +638,6 @@ fn is_tup_field_access(expr: &ast::Expr) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
// Determines if we can continue formatting a given expression on the same line.
|
||||
fn is_continuable(expr: &ast::Expr) -> bool {
|
||||
match expr.node {
|
||||
ast::ExprKind::Path(..) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
fn rewrite_method_call(
|
||||
method_name: ast::Ident,
|
||||
types: &[ast::GenericArg],
|
||||
|
||||
Loading…
Reference in New Issue
Block a user