expr: &ast::Expr,

expr_type: ExprType,

context: &RewriteContext<'_>,

shape: Shape,

) -> Option<String> {

skip_out_of_file_lines_range!(context, expr.span);

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.kind {

ast::ExprKind::Array(ref expr_vec) => rewrite_array(

"",

expr_vec.iter(),

expr.span,

context,

shape,

choose_separator_tactic(context, expr.span),

None,

),

ast::ExprKind::Lit(ref l) => {

if let Some(expr_rw) = rewrite_literal(context, l, shape) {

Some(expr_rw)

} else {

if let LitKind::StrRaw(_) = l.token.kind {

Some(context.snippet(l.span).trim().into())

} else {

None

}

}

}

ast::ExprKind::Call(ref callee, ref args) => {

let inner_span = mk_sp(callee.span.hi(), expr.span.hi());

let callee_str = callee.rewrite(context, shape)?;

rewrite_call(context, &callee_str, args, inner_span, shape)

}

ast::ExprKind::Paren(ref subexpr) => rewrite_paren(context, subexpr, shape, expr.span),

ast::ExprKind::Binary(op, ref lhs, ref rhs) => {

// FIXME: format comments between operands and operator

rewrite_all_pairs(expr, shape, context).or_else(|| {

rewrite_pair(

&**lhs,

&**rhs,

PairParts::infix(&format!(" {} ", context.snippet(op.span))),

context,

shape,

context.config.binop_separator(),

)

})

}

ast::ExprKind::Unary(op, ref subexpr) => rewrite_unary_op(context, op, subexpr, shape),

ast::ExprKind::Struct(ref struct_expr) => {

let ast::StructExpr {

fields, path, rest, ..

} = &**struct_expr;

rewrite_struct_lit(context, path, fields, rest, &expr.attrs, expr.span, shape)

}

ast::ExprKind::Tup(ref items) => {

rewrite_tuple(context, items.iter(), expr.span, shape, items.len() == 1)

}

ast::ExprKind::Let(..) => None,

ast::ExprKind::If(..)

| ast::ExprKind::ForLoop(..)

| ast::ExprKind::Loop(..)

| ast::ExprKind::While(..) => to_control_flow(expr, expr_type)

.and_then(|control_flow| control_flow.rewrite(context, shape)),

ast::ExprKind::ConstBlock(ref anon_const) => {

Some(format!("const {}", anon_const.rewrite(context, shape)?))

}

ast::ExprKind::Block(ref block, opt_label) => {

match expr_type {

ExprType::Statement => {

if is_unsafe_block(block) {

rewrite_block(block, Some(&expr.attrs), opt_label, context, shape)

} else if let rw @ Some(_) =

rewrite_empty_block(context, block, Some(&expr.attrs), opt_label, "", shape)

{

// Rewrite block without trying to put it in a single line.

rw

} else {

let prefix = block_prefix(context, block, shape)?;

rewrite_block_with_visitor(

context,

&prefix,

block,

Some(&expr.attrs),

opt_label,

shape,

true,

)

}

}

ExprType::SubExpression => {

rewrite_block(block, Some(&expr.attrs), opt_label, context, shape)

}

}

}

ast::ExprKind::Match(ref cond, ref arms) => {

rewrite_match(context, cond, arms, shape, expr.span, &expr.attrs)

}

ast::ExprKind::Path(ref qself, ref path) => {

rewrite_path(context, PathContext::Expr, qself.as_ref(), path, shape)

}

ast::ExprKind::Assign(ref lhs, ref rhs, _) => {

rewrite_assignment(context, lhs, rhs, None, shape)

}

ast::ExprKind::AssignOp(ref op, ref lhs, ref rhs) => {

rewrite_assignment(context, lhs, rhs, Some(op), shape)

}

ast::ExprKind::Continue(ref opt_label) => {

let id_str = match *opt_label {

Some(label) => format!(" {}", label.ident),

None => String::new(),

};

Some(format!("continue{}", id_str))

}

ast::ExprKind::Break(ref opt_label, ref opt_expr) => {

let id_str = match *opt_label {

Some(label) => format!(" {}", label.ident),

None => String::new(),

};

if let Some(ref expr) = *opt_expr {

rewrite_unary_prefix(context, &format!("break{} ", id_str), &**expr, shape)

} else {

Some(format!("break{}", id_str))

}

}

ast::ExprKind::Yield(ref opt_expr) => {

if let Some(ref expr) = *opt_expr {

rewrite_unary_prefix(context, "yield ", &**expr, shape)

} else {

Some("yield".to_string())

}

}

ast::ExprKind::Closure(capture, ref is_async, movability, ref fn_decl, ref body, _) => {

closures::rewrite_closure(

capture, is_async, movability, fn_decl, body, expr.span, context, shape,

)

}

ast::ExprKind::Try(..) | ast::ExprKind::Field(..) | ast::ExprKind::MethodCall(..) => {

rewrite_chain(expr, context, shape)

}

ast::ExprKind::MacCall(ref mac) => {

rewrite_macro(mac, None, context, shape, MacroPosition::Expression).or_else(|| {

wrap_str(

context.snippet(expr.span).to_owned(),

context.config.max_width(),

shape,

)

})

}

ast::ExprKind::Ret(None) => Some("return".to_owned()),

ast::ExprKind::Ret(Some(ref expr)) => {

rewrite_unary_prefix(context, "return ", &**expr, shape)

}

ast::ExprKind::Box(ref expr) => rewrite_unary_prefix(context, "box ", &**expr, shape),

ast::ExprKind::AddrOf(borrow_kind, mutability, ref expr) => {

rewrite_expr_addrof(context, borrow_kind, mutability, expr, shape)

}

ast::ExprKind::Cast(ref expr, ref ty) => rewrite_pair(

&**expr,

&**ty,

PairParts::infix(" as "),

context,

shape,

SeparatorPlace::Front,

),

ast::ExprKind::Type(ref expr, ref ty) => rewrite_pair(

&**expr,

&**ty,

PairParts::infix(": "),

context,

shape,

SeparatorPlace::Back,

),

ast::ExprKind::Index(ref expr, ref index) => {

rewrite_index(&**expr, &**index, context, shape)

}

ast::ExprKind::Repeat(ref expr, ref repeats) => rewrite_pair(

&**expr,

&*repeats.value,

PairParts::new("[", "; ", "]"),

context,

shape,

SeparatorPlace::Back,

),

ast::ExprKind::Range(ref lhs, ref rhs, limits) => {

let delim = match limits {

ast::RangeLimits::HalfOpen => "..",

ast::RangeLimits::Closed => "..=",

};

fn needs_space_before_range(context: &RewriteContext<'_>, lhs: &ast::Expr) -> bool {

match lhs.kind {

ast::ExprKind::Lit(ref lit) => match lit.kind {

ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) => {

context.snippet(lit.span).ends_with('.')

}

_ => false,

},

ast::ExprKind::Unary(_, ref expr) => needs_space_before_range(context, &expr),

_ => false,

}

}

fn needs_space_after_range(rhs: &ast::Expr) -> bool {

// Don't format `.. ..` into `....`, which is invalid.

//

// This check is unnecessary for `lhs`, because a range

// starting from another range needs parentheses as `(x ..) ..`

// (`x .. ..` is a range from `x` to `..`).

matches!(rhs.kind, ast::ExprKind::Range(None, _, _))

}

let default_sp_delim = |lhs: Option<&ast::Expr>, rhs: Option<&ast::Expr>| {

let space_if = |b: bool| if b { " " } else { "" };

format!(

"{}{}{}",

lhs.map_or("", |lhs| space_if(needs_space_before_range(context, lhs))),

delim,

rhs.map_or("", |rhs| space_if(needs_space_after_range(rhs))),

)

};

match (lhs.as_ref().map(|x| &**x), rhs.as_ref().map(|x| &**x)) {

(Some(lhs), Some(rhs)) => {

let sp_delim = if context.config.spaces_around_ranges() {

format!(" {} ", delim)

} else {

default_sp_delim(Some(lhs), Some(rhs))

};

rewrite_pair(

&*lhs,

&*rhs,

PairParts::infix(&sp_delim),

context,

shape,

context.config.binop_separator(),

)

}

(None, Some(rhs)) => {

let sp_delim = if context.config.spaces_around_ranges() {

format!("{} ", delim)

} else {

default_sp_delim(None, Some(rhs))

};

rewrite_unary_prefix(context, &sp_delim, &*rhs, shape)

}

(Some(lhs), None) => {

let sp_delim = if context.config.spaces_around_ranges() {

format!(" {}", delim)

} else {

default_sp_delim(Some(lhs), None)

};

rewrite_unary_suffix(context, &sp_delim, &*lhs, shape)

}

(None, None) => Some(delim.to_owned()),

}

}

// We do not format these expressions yet, but they should still

// satisfy our width restrictions.

// Style Guide RFC for InlineAsm variant pending

// https://github.com/rust-dev-tools/fmt-rfcs/issues/152

ast::ExprKind::LlvmInlineAsm(..) | ast::ExprKind::InlineAsm(..) => {

Some(context.snippet(expr.span).to_owned())

}

ast::ExprKind::TryBlock(ref block) => {

if let rw @ Some(_) =

rewrite_single_line_block(context, "try ", block, Some(&expr.attrs), None, shape)

{

rw

} else {

// 9 = `try `

let budget = shape.width.saturating_sub(9);

Some(format!(

"{}{}",

"try ",

rewrite_block(

block,

Some(&expr.attrs),

None,

context,

Shape::legacy(budget, shape.indent)

)?

))

}

}

ast::ExprKind::Async(capture_by, _node_id, ref block) => {

let mover = if capture_by == ast::CaptureBy::Value {

"move "

} else {

""

};

if let rw @ Some(_) = rewrite_single_line_block(

context,

format!("{}{}", "async ", mover).as_str(),

block,

Some(&expr.attrs),

None,

shape,

) {

rw

} else {

// 6 = `async `

let budget = shape.width.saturating_sub(6);

Some(format!(

"{}{}{}",

"async ",

mover,

rewrite_block(

block,

Some(&expr.attrs),

None,

context,

Shape::legacy(budget, shape.indent)

)?

))

}

}

ast::ExprKind::Await(_) => rewrite_chain(expr, context, shape),

ast::ExprKind::Underscore => Some("_".to_owned()),

ast::ExprKind::Err => None,

};

expr_rw

.and_then(|expr_str| recover_comment_removed(expr_str, expr.span, context))

.and_then(|expr_str| {

let attrs = outer_attributes(&expr.attrs);

let attrs_str = attrs.rewrite(context, shape)?;

let span = mk_sp(

attrs.last().map_or(expr.span.lo(), |attr| attr.span.hi()),

expr.span.lo(),

);

combine_strs_with_missing_comments(context, &attrs_str, &expr_str, span, shape, false)

})

name: &'a str,

exprs: impl Iterator<Item = &'a T>,

span: Span,

context: &'a RewriteContext<'_>,

shape: Shape,

force_separator_tactic: Option<SeparatorTactic>,

delim_token: Option<DelimToken>,

) -> Option<String> {

overflow::rewrite_with_square_brackets(

context,

name,

exprs,

shape,

span,

force_separator_tactic,

delim_token,

)

context: &RewriteContext<'_>,

block: &ast::Block,

attrs: Option<&[ast::Attribute]>,

label: Option<ast::Label>,

prefix: &str,

shape: Shape,

) -> Option<String> {

if block_has_statements(&block) {

return None;

}

let label_str = rewrite_label(label);

if attrs.map_or(false, |a| !inner_attributes(a).is_empty()) {

return None;

}

if !block_contains_comment(context, block) && shape.width >= 2 {

return Some(format!("{}{}{{}}", prefix, label_str));

}

// If a block contains only a single-line comment, then leave it on one line.

let user_str = context.snippet(block.span);

let user_str = user_str.trim();

if user_str.starts_with('{') && user_str.ends_with('}') {

let comment_str = user_str[1..user_str.len() - 1].trim();

if block.stmts.is_empty()

&& !comment_str.contains('\n')

&& !comment_str.starts_with("//")

&& comment_str.len() + 4 <= shape.width

{

return Some(format!("{}{}{{ {} }}", prefix, label_str, comment_str));

}

}

None

Some(match block.rules {

ast::BlockCheckMode::Unsafe(..) => {

let snippet = context.snippet(block.span);

let open_pos = snippet.find_uncommented("{")?;

// Extract comment between unsafe and block start.

let trimmed = &snippet[6..open_pos].trim();

if !trimmed.is_empty() {

// 9 = "unsafe {".len(), 7 = "unsafe ".len()

let budget = shape.width.checked_sub(9)?;

format!(

"unsafe {} ",

rewrite_comment(

trimmed,

true,

Shape::legacy(budget, shape.indent + 7),

context.config,

)?

)

} else {

"unsafe ".to_owned()

}

}

ast::BlockCheckMode::Default => String::new(),

})

context: &RewriteContext<'_>,

prefix: &str,

block: &ast::Block,

attrs: Option<&[ast::Attribute]>,

label: Option<ast::Label>,

shape: Shape,

) -> Option<String> {

if is_simple_block(context, block, attrs) {

let expr_shape = shape.offset_left(last_line_width(prefix))?;

let expr_str = block.stmts[0].rewrite(context, expr_shape)?;

let label_str = rewrite_label(label);

let result = format!("{}{}{{ {} }}", prefix, label_str, expr_str);

if result.len() <= shape.width && !result.contains('\n') {

return Some(result);

}

}

None

context: &RewriteContext<'_>,

prefix: &str,

block: &ast::Block,

attrs: Option<&[ast::Attribute]>,

label: Option<ast::Label>,

shape: Shape,

has_braces: bool,

) -> Option<String> {

if let rw @ Some(_) = rewrite_empty_block(context, block, attrs, label, prefix, shape) {

return rw;

}

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, 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, None) => visitor.last_pos = block.span.lo(),

}

let inner_attrs = attrs.map(inner_attributes);

let label_str = rewrite_label(label);

visitor.visit_block(block, inner_attrs.as_deref(), has_braces);

let visitor_context = visitor.get_context();

context

.skipped_range

.borrow_mut()

.append(&mut visitor_context.skipped_range.borrow_mut());

Some(format!("{}{}{}", prefix, label_str, visitor.buffer))

block: &ast::Block,

attrs: Option<&[ast::Attribute]>,

label: Option<ast::Label>,

context: &RewriteContext<'_>,

shape: Shape,

) -> Option<String> {

let prefix = block_prefix(context, block, shape)?;

// shape.width is used only for the single line case: either the empty block `{}`,

// or an unsafe expression `unsafe { e }`.

if let rw @ Some(_) = rewrite_empty_block(context, block, attrs, label, &prefix, shape) {

return rw;

}

let result = rewrite_block_with_visitor(context, &prefix, block, attrs, label, shape, true);

if let Some(ref result_str) = result {

if result_str.lines().count() <= 3 {

if let rw @ Some(_) =

rewrite_single_line_block(context, &prefix, block, attrs, label, shape)

{

return rw;

}

}

}

result

context: &RewriteContext<'_>,

expr: &ast::Expr,

shape: Shape,

) -> Option<String> {

match expr.kind {

ast::ExprKind::Match(ref cond, _) => {

// `match `cond` {`

let cond_shape = match context.config.indent_style() {

IndentStyle::Visual => shape.shrink_left(6).and_then(|s| s.sub_width(2))?,

IndentStyle::Block => shape.offset_left(8)?,

};

cond.rewrite(context, cond_shape)

}

_ => to_control_flow(expr, ExprType::SubExpression).and_then(|control_flow| {

let alt_block_sep =

String::from("\n") + &shape.indent.block_only().to_string(context.config);

control_flow

.rewrite_cond(context, shape, &alt_block_sep)

.map(|rw| rw.0)

}),

}

cond: Option<&'a ast::Expr>,

block: &'a ast::Block,

else_block: Option<&'a ast::Expr>,

label: Option<ast::Label>,

pat: Option<&'a ast::Pat>,

keyword: &'a str,

matcher: &'a str,

connector: &'a str,

allow_single_line: bool,

// HACK: `true` if this is an `if` expression in an `else if`.

nested_if: bool,

span: Span,

match expr.kind {

ast::ExprKind::Let(ref pat, ref cond) => (Some(pat), cond),

_ => (None, expr),

}

match expr.kind {

ast::ExprKind::If(ref cond, ref if_block, ref else_block) => {

let (pat, cond) = extract_pats_and_cond(cond);

Some(ControlFlow::new_if(

cond,

pat,

if_block,

else_block.as_ref().map(|e| &**e),

expr_type == ExprType::SubExpression,

false,

expr.span,

))

}

ast::ExprKind::ForLoop(ref pat, ref cond, ref block, label) => {

Some(ControlFlow::new_for(pat, cond, block, label, expr.span))

}

ast::ExprKind::Loop(ref block, label) => {

Some(ControlFlow::new_loop(block, label, expr.span))

}

ast::ExprKind::While(ref cond, ref block, label) => {

let (pat, cond) = extract_pats_and_cond(cond);

Some(ControlFlow::new_while(pat, cond, block, label, expr.span))

}

_ => None,

}

fn new_if(

cond: &'a ast::Expr,

pat: Option<&'a ast::Pat>,

block: &'a ast::Block,

else_block: Option<&'a ast::Expr>,

allow_single_line: bool,

nested_if: bool,

span: Span,

) -> ControlFlow<'a> {

let matcher = choose_matcher(pat);

ControlFlow {

cond: Some(cond),

block,

else_block,

label: None,

pat,

keyword: "if",

matcher,

connector: " =",

allow_single_line,

nested_if,

span,

}

}

fn new_loop(block: &'a ast::Block, label: Option<ast::Label>, span: Span) -> ControlFlow<'a> {

ControlFlow {

cond: None,

block,

else_block: None,

label,

pat: None,

keyword: "loop",

matcher: "",

connector: "",

allow_single_line: false,

nested_if: false,

span,

}

}

fn new_while(

pat: Option<&'a ast::Pat>,

cond: &'a ast::Expr,

block: &'a ast::Block,

label: Option<ast::Label>,

span: Span,

) -> ControlFlow<'a> {

let matcher = choose_matcher(pat);

ControlFlow {

cond: Some(cond),

block,

else_block: None,

label,

pat,

keyword: "while",

matcher,

connector: " =",

allow_single_line: false,

nested_if: false,

span,

}

}

fn new_for(

pat: &'a ast::Pat,

cond: &'a ast::Expr,

block: &'a ast::Block,

label: Option<ast::Label>,

span: Span,

) -> ControlFlow<'a> {

ControlFlow {

cond: Some(cond),

block,

else_block: None,

label,

pat: Some(pat),

keyword: "for",

matcher: "",

connector: " in",

allow_single_line: false,

nested_if: false,

span,

}

}

fn rewrite_single_line(

&self,

pat_expr_str: &str,

context: &RewriteContext<'_>,

width: usize,

) -> Option<String> {

assert!(self.allow_single_line);

let else_block = self.else_block?;

let fixed_cost = self.keyword.len() + " { } else { }".len();

if let ast::ExprKind::Block(ref else_node, _) = else_block.kind {

if !is_simple_block(context, self.block, None)

|| !is_simple_block(context, else_node, None)

|| pat_expr_str.contains('\n')

{

return None;

}

let new_width = width.checked_sub(pat_expr_str.len() + fixed_cost)?;

let expr = &self.block.stmts[0];

let if_str = expr.rewrite(context, Shape::legacy(new_width, Indent::empty()))?;

let new_width = new_width.checked_sub(if_str.len())?;

let else_expr = &else_node.stmts[0];

let else_str = else_expr.rewrite(context, Shape::legacy(new_width, Indent::empty()))?;

if if_str.contains('\n') || else_str.contains('\n') {

return None;

}

let result = format!(

"{} {} {{ {} }} else {{ {} }}",

self.keyword, pat_expr_str, if_str, else_str

);

if result.len() <= width {

return Some(result);

}

}

None

}

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

fn rewrite_pat_expr(

&self,

context: &RewriteContext<'_>,

expr: &ast::Expr,

shape: Shape,

offset: usize,

) -> Option<String> {

debug!("rewrite_pat_expr {:?} {:?} {:?}", shape, self.pat, expr);

let cond_shape = shape.offset_left(offset)?;

if let Some(pat) = self.pat {

let matcher = if self.matcher.is_empty() {

self.matcher.to_owned()

} else {

format!("{} ", self.matcher)

};

let pat_shape = cond_shape

.offset_left(matcher.len())?

.sub_width(self.connector.len())?;

let pat_string = pat.rewrite(context, pat_shape)?;

let comments_lo = context

.snippet_provider

.span_after(self.span, self.connector.trim());

let comments_span = mk_sp(comments_lo, expr.span.lo());

return rewrite_assign_rhs_with_comments(

context,

&format!("{}{}{}", matcher, pat_string, self.connector),

expr,

cond_shape,

RhsTactics::Default,

comments_span,

true,

);

}

let expr_rw = expr.rewrite(context, cond_shape);

// The expression may (partially) fit on the current line.

// We do not allow splitting between `if` and condition.

if self.keyword == "if" || expr_rw.is_some() {

return expr_rw;

}

// The expression won't fit on the current line, jump to next.

let nested_shape = shape

.block_indent(context.config.tab_spaces())

.with_max_width(context.config);

let nested_indent_str = nested_shape.indent.to_string_with_newline(context.config);

expr.rewrite(context, nested_shape)

.map(|expr_rw| format!("{}{}", nested_indent_str, expr_rw))

}

fn rewrite_cond(

&self,

context: &RewriteContext<'_>,

shape: Shape,

alt_block_sep: &str,

) -> Option<(String, usize)> {

// Do not take the rhs overhead from the upper expressions into account

// when rewriting pattern.

let new_width = context.budget(shape.used_width());

let fresh_shape = Shape {

width: new_width,

..shape

};

let constr_shape = if self.nested_if {

// We are part of an if-elseif-else chain. Our constraints are tightened.

// 7 = "} else " .len()

fresh_shape.offset_left(7)?

} else {

fresh_shape

};

let label_string = rewrite_label(self.label);

// 1 = space after keyword.

let offset = self.keyword.len() + label_string.len() + 1;

let pat_expr_string = match self.cond {

Some(cond) => self.rewrite_pat_expr(context, cond, constr_shape, offset)?,

None => String::new(),

};

let brace_overhead =

if context.config.control_brace_style() != ControlBraceStyle::AlwaysNextLine {

// 2 = ` {`

2

} else {

0

};

let one_line_budget = context

.config

.max_width()

.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_offsetted(shape.used_width(), &pat_expr_string));

// Try to format if-else on single line.

if self.allow_single_line && context.config.single_line_if_else_max_width() > 0 {

let trial = self.rewrite_single_line(&pat_expr_string, context, shape.width);

if let Some(cond_str) = trial {

if cond_str.len() <= context.config.single_line_if_else_max_width() {

return Some((cond_str, 0));

}

}

}

let cond_span = if let Some(cond) = self.cond {

cond.span

} else {

mk_sp(self.block.span.lo(), self.block.span.lo())

};

// `for event in event`

// Do not include label in the span.

let lo = self

.label

.map_or(self.span.lo(), |label| label.ident.span.hi());

let between_kwd_cond = mk_sp(

context

.snippet_provider

.span_after(mk_sp(lo, self.span.hi()), self.keyword.trim()),

if self.pat.is_none() {

cond_span.lo()

} else if self.matcher.is_empty() {

self.pat.unwrap().span.lo()

} else {

context

.snippet_provider

.span_before(self.span, self.matcher.trim())

},

);

let between_kwd_cond_comment = extract_comment(between_kwd_cond, context, shape);

let after_cond_comment =

extract_comment(mk_sp(cond_span.hi(), self.block.span.lo()), context, shape);

let block_sep = if self.cond.is_none() && between_kwd_cond_comment.is_some() {

""

} else if context.config.control_brace_style() == ControlBraceStyle::AlwaysNextLine

|| force_newline_brace

{

alt_block_sep

} else {

" "

};

let used_width = if pat_expr_string.contains('\n') {

last_line_width(&pat_expr_string)

} else {

// 2 = spaces after keyword and condition.

label_string.len() + self.keyword.len() + pat_expr_string.len() + 2

};

Some((

format!(

"{}{}{}{}{}",

label_string,

self.keyword,

between_kwd_cond_comment.as_ref().map_or(

if pat_expr_string.is_empty() || pat_expr_string.starts_with('\n') {

""

} else {

" "

},

|s| &**s,

),

pat_expr_string,

after_cond_comment.as_ref().map_or(block_sep, |s| &**s)

),

used_width,

))

}

fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {

debug!("ControlFlow::rewrite {:?} {:?}", self, shape);

let alt_block_sep = &shape.indent.to_string_with_newline(context.config);

let (cond_str, used_width) = self.rewrite_cond(context, shape, alt_block_sep)?;

// If `used_width` is 0, it indicates that whole control flow is written in a single line.

if used_width == 0 {

return Some(cond_str);

}

let block_width = shape.width.saturating_sub(used_width);

// This is used only for the empty block case: `{}`. So, we use 1 if we know

// we should avoid the single line case.

let block_width = if self.else_block.is_some() || self.nested_if {

min(1, block_width)

} else {

block_width

};

let block_shape = Shape {

width: block_width,