use std::borrow::Cow;
use std::cmp::min;
-use config::lists::*;
use syntax::parse::token::DelimToken;
use syntax::source_map::{BytePos, SourceMap, Span};
use syntax::{ast, ptr};
-use chains::rewrite_chain;
-use closures;
-use comment::{
+use crate::chains::rewrite_chain;
+use crate::closures;
+use crate::comment::{
combine_strs_with_missing_comments, contains_comment, recover_comment_removed, rewrite_comment,
rewrite_missing_comment, CharClasses, FindUncommented,
};
-use config::{Config, ControlBraceStyle, IndentStyle};
-use lists::{
+use crate::config::lists::*;
+use crate::config::{Config, ControlBraceStyle, IndentStyle, Version};
+use crate::lists::{
definitive_tactic, itemize_list, shape_for_tactic, struct_lit_formatting, struct_lit_shape,
struct_lit_tactic, write_list, ListFormatting, ListItem, Separator,
};
-use macros::{rewrite_macro, MacroPosition};
-use matches::rewrite_match;
-use overflow::{self, IntoOverflowableItem, OverflowableItem};
-use pairs::{rewrite_all_pairs, rewrite_pair, PairParts};
-use patterns::is_short_pattern;
-use rewrite::{Rewrite, RewriteContext};
-use shape::{Indent, Shape};
-use source_map::{LineRangeUtils, SpanUtils};
-use spanned::Spanned;
-use string::{rewrite_string, StringFormat};
-use types::{rewrite_path, PathContext};
-use utils::{
- colon_spaces, contains_skip, count_newlines, first_line_ends_with, first_line_width,
- inner_attributes, last_line_extendable, last_line_width, mk_sp, outer_attributes,
- ptr_vec_to_ref_vec, semicolon_for_stmt, wrap_str,
+use crate::macros::{rewrite_macro, MacroPosition};
+use crate::matches::rewrite_match;
+use crate::overflow::{self, IntoOverflowableItem, OverflowableItem};
+use crate::pairs::{rewrite_all_pairs, rewrite_pair, PairParts};
+use crate::patterns::is_short_pattern;
+use crate::rewrite::{Rewrite, RewriteContext};
+use crate::shape::{Indent, Shape};
+use crate::source_map::{LineRangeUtils, SpanUtils};
+use crate::spanned::Spanned;
+use crate::string::{rewrite_string, StringFormat};
+use crate::types::{rewrite_path, PathContext};
+use crate::utils::{
+ colon_spaces, contains_skip, count_newlines, first_line_ends_with, inner_attributes,
+ last_line_extendable, last_line_width, mk_sp, outer_attributes, ptr_vec_to_ref_vec,
+ semicolon_for_expr, semicolon_for_stmt, wrap_str,
};
-use vertical::rewrite_with_alignment;
-use visitor::FmtVisitor;
+use crate::vertical::rewrite_with_alignment;
+use crate::visitor::FmtVisitor;
impl Rewrite for ast::Expr {
fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
if contains_skip(&*expr.attrs) {
return Some(context.snippet(expr.span()).to_owned());
}
+ let shape = if expr_type == ExprType::Statement && semicolon_for_expr(context, expr) {
+ shape.sub_width(1)?
+ } else {
+ shape
+ };
let expr_rw = match expr.node {
ast::ExprKind::Array(ref expr_vec) => rewrite_array(
format!(
"{}{}{}",
- lhs.map(|lhs| space_if(needs_space_before_range(context, lhs)))
- .unwrap_or(""),
+ lhs.map_or("", |lhs| space_if(needs_space_before_range(context, lhs))),
delim,
- rhs.map(|rhs| space_if(needs_space_after_range(rhs)))
- .unwrap_or(""),
+ rhs.map_or("", |rhs| space_if(needs_space_after_range(rhs))),
)
};
prefix: &str,
shape: Shape,
) -> Option<String> {
+ if !block.stmts.is_empty() {
+ return None;
+ }
+
let label_str = rewrite_label(label);
if attrs.map_or(false, |a| !inner_attributes(a).is_empty()) {
return None;
}
- if block.stmts.is_empty()
- && !block_contains_comment(block, context.source_map)
- && shape.width >= 2
- {
+ if !block_contains_comment(block, context.source_map) && shape.width >= 2 {
return Some(format!("{}{}{{}}", prefix, label_str));
}
let mut visitor = FmtVisitor::from_context(context);
visitor.block_indent = shape.indent;
visitor.is_if_else_block = context.is_if_else_block();
- match block.rules {
- ast::BlockCheckMode::Unsafe(..) => {
+ match (block.rules, label) {
+ (ast::BlockCheckMode::Unsafe(..), _) | (ast::BlockCheckMode::Default, Some(_)) => {
let snippet = context.snippet(block.span);
let open_pos = snippet.find_uncommented("{")?;
visitor.last_pos = block.span.lo() + BytePos(open_pos as u32)
}
- ast::BlockCheckMode::Default => visitor.last_pos = block.span.lo(),
+ (ast::BlockCheckMode::Default, None) => visitor.last_pos = block.span.lo(),
}
let inner_attrs = attrs.map(inner_attributes);
}
}
+/// Returns true if the last line of pat_str has leading whitespace and it is wider than the
+/// shape's indent.
+fn last_line_offsetted(start_column: usize, pat_str: &str) -> bool {
+ let mut leading_whitespaces = 0;
+ for c in pat_str.chars().rev() {
+ match c {
+ '\n' => break,
+ _ if c.is_whitespace() => leading_whitespaces += 1,
+ _ => leading_whitespaces = 0,
+ }
+ }
+ leading_whitespaces > start_column
+}
+
impl<'a> ControlFlow<'a> {
fn rewrite_pat_expr(
&self,
.saturating_sub(constr_shape.used_width() + offset + brace_overhead);
let force_newline_brace = (pat_expr_string.contains('\n')
|| pat_expr_string.len() > one_line_budget)
- && !last_line_extendable(&pat_expr_string);
+ && (!last_line_extendable(&pat_expr_string)
+ || last_line_offsetted(shape.used_width(), &pat_expr_string));
// Try to format if-else on single line.
if self.allow_single_line
let trial = self.rewrite_single_line(&pat_expr_string, context, shape.width);
if let Some(cond_str) = trial {
- if cond_str.len() <= context
- .config
- .width_heuristics()
- .single_line_if_else_max_width
+ if cond_str.len()
+ <= context
+ .config
+ .width_heuristics()
+ .single_line_if_else_max_width
{
return Some((cond_str, 0));
}
format!(
"{}{}",
new_indent.to_string(context.config),
- line.trim_left()
+ line.trim_start()
)
})
.collect::<Vec<_>>()
.join("\n")
- .trim_left(),
+ .trim_start(),
);
- return wrap_str(indented_string_lit, context.config.max_width(), shape);
+ return if context.config.version() == Version::Two {
+ Some(indented_string_lit)
+ } else {
+ wrap_str(indented_string_lit, context.config.max_width(), shape)
+ };
} else {
return wrap_str(string_lit.to_owned(), context.config.max_width(), shape);
}
rewrite_string(
str_lit,
&StringFormat::new(shape.visual_indent(0), context.config),
+ shape.width.saturating_sub(2),
)
}
| ast::ExprKind::WhileLet(..) => {
context.config.combine_control_expr() && context.use_block_indent() && args_len == 1
}
- ast::ExprKind::Block(..) | ast::ExprKind::Closure(..) => {
- context.use_block_indent()
- || context.config.indent_style() == IndentStyle::Visual && args_len > 1
+
+ // Handle always block-like expressions
+ ast::ExprKind::Block(..) | ast::ExprKind::Closure(..) => true,
+
+ // Handle `[]` and `{}`-like expressions
+ ast::ExprKind::Array(..) | ast::ExprKind::Struct(..) => {
+ context.config.overflow_delimited_expr()
+ || (context.use_block_indent() && args_len == 1)
+ }
+ ast::ExprKind::Mac(ref macro_) => {
+ match (macro_.node.delim, context.config.overflow_delimited_expr()) {
+ (ast::MacDelimiter::Bracket, true) | (ast::MacDelimiter::Brace, true) => true,
+ _ => context.use_block_indent() && args_len == 1,
+ }
+ }
+
+ // Handle parenthetical expressions
+ ast::ExprKind::Call(..) | ast::ExprKind::MethodCall(..) | ast::ExprKind::Tup(..) => {
+ context.use_block_indent() && args_len == 1
}
- ast::ExprKind::Array(..)
- | ast::ExprKind::Call(..)
- | ast::ExprKind::Mac(..)
- | ast::ExprKind::MethodCall(..)
- | ast::ExprKind::Struct(..)
- | ast::ExprKind::Tup(..) => context.use_block_indent() && args_len == 1,
+
+ // Handle unary-like expressions
ast::ExprKind::AddrOf(_, ref expr)
| ast::ExprKind::Box(ref expr)
| ast::ExprKind::Try(ref expr)
debug!("rewrite_paren, shape: {:?}", shape);
// Extract comments within parens.
+ let mut pre_span;
+ let mut post_span;
let mut pre_comment;
let mut post_comment;
let remove_nested_parens = context.config.remove_nested_parens();
loop {
// 1 = "(" or ")"
- let pre_span = mk_sp(span.lo() + BytePos(1), subexpr.span.lo());
- let post_span = mk_sp(subexpr.span.hi(), span.hi() - BytePos(1));
+ pre_span = mk_sp(span.lo() + BytePos(1), subexpr.span.lo());
+ post_span = mk_sp(subexpr.span.hi(), span.hi() - BytePos(1));
pre_comment = rewrite_missing_comment(pre_span, shape, context)?;
post_comment = rewrite_missing_comment(post_span, shape, context)?;
break;
}
- // 1 `(`
- let sub_shape = shape.offset_left(1).and_then(|s| s.sub_width(1))?;
-
+ // 1 = `(` and `)`
+ let sub_shape = shape.offset_left(1)?.sub_width(1)?;
let subexpr_str = subexpr.rewrite(context, sub_shape)?;
- debug!("rewrite_paren, subexpr_str: `{:?}`", subexpr_str);
-
- // 2 = `()`
- if subexpr_str.contains('\n') || first_line_width(&subexpr_str) + 2 <= shape.width {
+ let fits_single_line = !pre_comment.contains("//") && !post_comment.contains("//");
+ if fits_single_line {
Some(format!("({}{}{})", pre_comment, &subexpr_str, post_comment))
} else {
- None
+ rewrite_paren_in_multi_line(context, subexpr, shape, pre_span, post_span)
}
}
+fn rewrite_paren_in_multi_line(
+ context: &RewriteContext,
+ subexpr: &ast::Expr,
+ shape: Shape,
+ pre_span: Span,
+ post_span: Span,
+) -> Option<String> {
+ let nested_indent = shape.indent.block_indent(context.config);
+ let nested_shape = Shape::indented(nested_indent, context.config);
+ let pre_comment = rewrite_missing_comment(pre_span, nested_shape, context)?;
+ let post_comment = rewrite_missing_comment(post_span, nested_shape, context)?;
+ let subexpr_str = subexpr.rewrite(context, nested_shape)?;
+
+ let mut result = String::with_capacity(subexpr_str.len() * 2);
+ result.push('(');
+ if !pre_comment.is_empty() {
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&pre_comment);
+ }
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&subexpr_str);
+ if !post_comment.is_empty() {
+ result.push_str(&nested_indent.to_string_with_newline(context.config));
+ result.push_str(&post_comment);
+ }
+ result.push_str(&shape.indent.to_string_with_newline(context.config));
+ result.push(')');
+
+ Some(result)
+}
+
fn rewrite_index(
expr: &ast::Expr,
index: &ast::Expr,
rewrite_with_alignment(
fields,
context,
- shape,
+ v_shape,
mk_sp(body_lo, span.hi()),
one_line_width,
)?
} else {
let field_iter = fields
- .into_iter()
+ .iter()
.map(StructLitField::Regular)
.chain(base.into_iter().map(StructLitField::Base));
nested_shape,
tactic,
context,
- force_no_trailing_comma || base.is_some(),
+ force_no_trailing_comma || base.is_some() || !context.use_block_indent(),
);
write_list(&item_vec, &fmt)?
shape: Shape,
) -> Option<String> {
// For some reason, an UnOp is not spanned like BinOp!
- let operator_str = match op {
- ast::UnOp::Deref => "*",
- ast::UnOp::Not => "!",
- ast::UnOp::Neg => "-",
- };
- rewrite_unary_prefix(context, operator_str, expr, shape)
+ rewrite_unary_prefix(context, ast::UnOp::to_string(op), expr, shape)
}
fn rewrite_assignment(
rhs_tactic: RhsTactics,
) -> Option<Shape> {
match rhs_tactic {
- RhsTactics::ForceNextLineWithoutIndent => Some(shape.with_max_width(context.config)),
+ RhsTactics::ForceNextLineWithoutIndent => shape
+ .with_max_width(context.config)
+ .sub_width(shape.indent.width()),
RhsTactics::Default => {
Shape::indented(shape.indent.block_indent(context.config), context.config)
.sub_width(shape.rhs_overhead(context.config))
_ => false,
}
}
+
+#[cfg(test)]
+mod test {
+ use super::last_line_offsetted;
+
+ #[test]
+ fn test_last_line_offsetted() {
+ let lines = "one\n two";
+ assert_eq!(last_line_offsetted(2, lines), true);
+ assert_eq!(last_line_offsetted(4, lines), false);
+ assert_eq!(last_line_offsetted(6, lines), false);
+
+ let lines = "one two";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ assert_eq!(last_line_offsetted(0, lines), false);
+
+ let lines = "\ntwo";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ assert_eq!(last_line_offsetted(0, lines), false);
+
+ let lines = "one\n two three";
+ assert_eq!(last_line_offsetted(2, lines), true);
+ let lines = "one\n two three";
+ assert_eq!(last_line_offsetted(2, lines), false);
+ }
+}
projects / rust.git / blobdiff