if let Some(ref ty) = self.ty {
let separator = type_annotation_separator(context.config);
- let indent = shape.indent + last_line_width(&result) + separator.len();
- // 1 = ;
- let budget = shape.width.checked_sub(indent.width() + 1)?;
- let rewrite = ty.rewrite(context, Shape::legacy(budget, indent))?;
+ let ty_shape = if pat_str.contains('\n') {
+ shape.with_max_width(context.config)
+ } else {
+ shape
+ }
+ .offset_left(last_line_width(&result) + separator.len())?
+ // 2 = ` =`
+ .sub_width(2)?;
+
+ let rewrite = ty.rewrite(context, ty_shape)?;
infix.push_str(separator);
infix.push_str(&rewrite);
BracePos::Auto
},
self.block_indent,
- mk_sp(span.lo(), body_start),
+ // make a span that starts right after `enum Foo`
+ mk_sp(ident.span.hi(), body_start),
last_line_width(&enum_header),
)
.unwrap();
let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
result.push_str(&inner_indent_str);
- result.push_str(visitor.buffer.to_string().trim());
+ result.push_str(visitor.buffer.trim());
result.push_str(&outer_indent_str);
} else if need_newline || !context.config.empty_item_single_line() {
result.push_str(&sep);
let snippet = context.snippet(item.span);
let open_pos = snippet.find_uncommented("{")? + 1;
+ let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
if !trait_items.is_empty() || contains_comment(&snippet[open_pos..]) {
let mut visitor = FmtVisitor::from_context(context);
visitor.format_missing(item.span.hi() - BytePos(1));
let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
- let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
result.push_str(&inner_indent_str);
- result.push_str(visitor.buffer.to_string().trim());
+ result.push_str(visitor.buffer.trim());
result.push_str(&outer_indent_str);
} else if result.contains('\n') {
- result.push('\n');
+ result.push_str(&outer_indent_str);
}
result.push('}');
context.config.brace_style(),
BracePos::None,
offset,
- mk_sp(generics.span.lo(), hi),
+ // make a span that starts right after `struct Foo`
+ mk_sp(p.ident.span.hi(), hi),
last_line_width(&header_str),
)?
} else {
let header_str = struct_parts.format_header(context);
result.push_str(&header_str);
- let header_hi = span.lo() + BytePos(header_str.len() as u32);
+ let header_hi = struct_parts.ident.span.hi();
let body_lo = context.snippet_provider.span_after(span, "{");
let generics_str = match struct_parts.generics {
BracePos::Auto
},
offset,
+ // make a span that starts right after `struct Foo`
mk_sp(header_hi, body_lo),
last_line_width(&result),
)?,
{
result.push('\n');
result.push_str(&offset.to_string(context.config));
- result.push_str(generics_str.trim_left());
+ result.push_str(generics_str.trim_start());
} else {
result.push_str(&generics_str);
}
let items_str = rewrite_with_alignment(
fields,
context,
- Shape::indented(offset, context.config).sub_width(1)?,
+ Shape::indented(offset.block_indent(context.config), context.config).sub_width(1)?,
mk_sp(body_lo, span.hi()),
one_line_budget,
)?;
result.push_str(suffix);
} else {
result.push_str(&indent.to_string_with_newline(context.config));
- result.push_str(suffix.trim_left());
+ result.push_str(suffix.trim_start());
}
// 1 = ";"
rewrite_ident(context, name),
type_annotation_spacing.0
),
- None => format!("{}", vis),
+ None => vis.to_string(),
})
}
for _ in 0..lhs_offset {
spacing.push(' ');
}
- // In this extreme case we will be missing a space betweeen an attribute and a field.
+ // In this extreme case we will be missing a space between an attribute and a field.
if prefix.is_empty() && !attrs_str.is_empty() && attrs_extendable && spacing.is_empty() {
spacing.push(' ');
}
let field_str = rewrite_assign_rhs(context, prefix, &*field.ty, shape)?;
// Remove a leading white-space from `rewrite_assign_rhs()` when rewriting a tuple struct.
let field_str = if is_prefix_empty {
- field_str.trim_left()
+ field_str.trim_start()
} else {
&field_str
};
}
}
-fn is_empty_infer(context: &RewriteContext, ty: &ast::Ty) -> bool {
+fn is_empty_infer(ty: &ast::Ty, pat_span: Span) -> bool {
match ty.node {
- ast::TyKind::Infer => {
- let original = context.snippet(ty.span);
- original != "_"
- }
+ ast::TyKind::Infer => ty.span.hi() == pat_span.hi(),
_ => false,
}
}
.pat
.rewrite(context, Shape::legacy(shape.width, shape.indent))?;
- if !is_empty_infer(context, &*self.ty) {
+ if !is_empty_infer(&*self.ty, self.pat.span) {
if context.config.space_before_colon() {
result.push_str(" ");
}
let snuggle_angle_bracket = generics_str
.lines()
.last()
- .map_or(false, |l| l.trim_left().len() == 1);
+ .map_or(false, |l| l.trim_start().len() == 1);
// Note that the width and indent don't really matter, we'll re-layout the
// return type later anyway.
one_line_budget, multi_line_budget, arg_indent
);
+ result.push('(');
// Check if vertical layout was forced.
- if one_line_budget == 0 {
- if snuggle_angle_bracket {
- result.push('(');
- } else {
- result.push_str("(");
- if context.config.indent_style() == IndentStyle::Visual {
- result.push_str(&arg_indent.to_string_with_newline(context.config));
- }
- }
- } else {
- result.push('(');
+ if one_line_budget == 0
+ && !snuggle_angle_bracket
+ && context.config.indent_style() == IndentStyle::Visual
+ {
+ result.push_str(&arg_indent.to_string_with_newline(context.config));
}
// Skip `pub(crate)`.