use config::lists::*;
use regex::Regex;
use rustc_target::spec::abi;
-use syntax::codemap::{self, BytePos, Span};
+use syntax::source_map::{self, BytePos, Span};
use syntax::visit;
use syntax::{ast, ptr, symbol};
-use codemap::{LineRangeUtils, SpanUtils};
use comment::{
combine_strs_with_missing_comments, contains_comment, recover_comment_removed,
recover_missing_comment_in_span, rewrite_missing_comment, FindUncommented,
use overflow;
use rewrite::{Rewrite, RewriteContext};
use shape::{Indent, Shape};
+use source_map::{LineRangeUtils, SpanUtils};
use spanned::Spanned;
use utils::*;
use vertical::rewrite_with_alignment;
use visitor::FmtVisitor;
-const DEFAULT_VISIBILITY: ast::Visibility = codemap::Spanned {
+const DEFAULT_VISIBILITY: ast::Visibility = source_map::Spanned {
node: ast::VisibilityKind::Inherited,
- span: codemap::DUMMY_SP,
+ span: source_map::DUMMY_SP,
};
fn type_annotation_separator(config: &Config) -> &str {
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);
decl: &'a ast::FnDecl,
generics: &'a ast::Generics,
abi: abi::Abi,
+ is_async: ast::IsAsync,
constness: ast::Constness,
defaultness: ast::Defaultness,
unsafety: ast::Unsafety,
decl,
generics,
abi: abi::Abi::Rust,
+ is_async: ast::IsAsync::NotAsync,
constness: ast::Constness::NotConst,
defaultness: ast::Defaultness::Final,
unsafety: ast::Unsafety::Normal,
) -> FnSig<'a> {
FnSig {
unsafety: method_sig.header.unsafety,
+ is_async: method_sig.header.asyncness,
constness: method_sig.header.constness.node,
defaultness: ast::Defaultness::Final,
abi: method_sig.header.abi,
generics,
abi: fn_header.abi,
constness: fn_header.constness.node,
+ is_async: fn_header.asyncness,
defaultness,
unsafety: fn_header.unsafety,
visibility: visibility.clone(),
result.push_str(format_defaultness(self.defaultness));
result.push_str(format_constness(self.constness));
result.push_str(format_unsafety(self.unsafety));
+ result.push_str(format_async(self.is_async));
result.push_str(&format_abi(
self.abi,
context.config.force_explicit_abi(),
return None;
}
- let codemap = self.get_context().codemap;
+ let source_map = self.get_context().source_map;
if self.config.empty_item_single_line()
- && is_empty_block(block, None, codemap)
+ && is_empty_block(block, None, source_map)
&& self.block_indent.width() + fn_str.len() + 2 <= self.config.max_width()
{
return Some(format!("{}{{}}", fn_str));
}
- if self.config.fn_single_line() && is_simple_block_stmt(block, None, codemap) {
+ if self.config.fn_single_line() && is_simple_block_stmt(block, None, source_map) {
let rewrite = {
if let Some(stmt) = block.stmts.first() {
match stmt_expr(stmt) {
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();
+ )
+ .unwrap();
self.push_str(&generics_str);
self.last_pos = body_start;
let original_offset = self.block_indent;
self.block_indent = self.block_indent.block_indent(self.config);
+ // If enum variants have discriminants, try to vertically align those,
+ // provided the discrims are not shifted too much to the right
+ let align_threshold: usize = self.config.enum_discrim_align_threshold();
+ let discr_ident_lens: Vec<usize> = enum_def
+ .variants
+ .iter()
+ .filter(|var| var.node.disr_expr.is_some())
+ .map(|var| rewrite_ident(&self.get_context(), var.node.ident).len())
+ .collect();
+ // cut the list at the point of longest discrim shorter than the threshold
+ // All of the discrims under the threshold will get padded, and all above - left as is.
+ let pad_discrim_ident_to = *discr_ident_lens
+ .iter()
+ .filter(|&l| *l <= align_threshold)
+ .max()
+ .unwrap_or(&0);
+
let itemize_list_with = |one_line_width: usize| {
itemize_list(
self.snippet_provider,
}
},
|f| f.span.hi(),
- |f| self.format_variant(f, one_line_width),
+ |f| self.format_variant(f, one_line_width, pad_discrim_ident_to),
body_lo,
body_hi,
false,
- ).collect()
+ )
+ .collect()
};
let mut items: Vec<_> =
itemize_list_with(self.config.width_heuristics().struct_variant_width);
}
let shape = self.shape().sub_width(2)?;
- let fmt = ListFormatting {
- tactic: DefinitiveListTactic::Vertical,
- separator: ",",
- trailing_separator: self.config.trailing_comma(),
- separator_place: SeparatorPlace::Back,
- shape,
- ends_with_newline: true,
- preserve_newline: true,
- nested: false,
- config: self.config,
- };
+ let fmt = ListFormatting::new(shape, self.config)
+ .trailing_separator(self.config.trailing_comma())
+ .preserve_newline(true);
let list = write_list(&items, &fmt)?;
result.push_str(&list);
}
// Variant of an enum.
- fn format_variant(&self, field: &ast::Variant, one_line_width: usize) -> Option<String> {
+ fn format_variant(
+ &self,
+ field: &ast::Variant,
+ one_line_width: usize,
+ pad_discrim_ident_to: usize,
+ ) -> Option<String> {
if contains_skip(&field.node.attrs) {
let lo = field.node.attrs[0].span.lo();
let span = mk_sp(lo, field.span.hi());
)?,
ast::VariantData::Unit(..) => {
if let Some(ref expr) = field.node.disr_expr {
- let lhs = format!("{} =", rewrite_ident(&context, field.node.ident));
+ let lhs = format!(
+ "{:1$} =",
+ rewrite_ident(&context, field.node.ident),
+ pad_discrim_ident_to
+ );
rewrite_assign_rhs(&context, lhs, &*expr.value, shape)?
} else {
rewrite_ident(&context, field.node.ident).to_owned()
buffer.push((self.buffer.clone(), item.clone()));
self.buffer.clear();
}
- // type -> const -> macro -> method
+ // type -> existential -> const -> macro -> method
use ast::ImplItemKind::*;
fn need_empty_line(a: &ast::ImplItemKind, b: &ast::ImplItemKind) -> bool {
match (a, b) {
- (Type(..), Type(..)) | (Const(..), Const(..)) => false,
+ (Type(..), Type(..))
+ | (Const(..), Const(..))
+ | (Existential(..), Existential(..)) => false,
_ => true,
}
}
buffer.sort_by(|(_, a), (_, b)| match (&a.node, &b.node) {
+ (Type(..), Type(..))
+ | (Const(..), Const(..))
+ | (Macro(..), Macro(..))
+ | (Existential(..), Existential(..)) => a.ident.as_str().cmp(&b.ident.as_str()),
+ (Method(..), Method(..)) => a.span.lo().cmp(&b.span.lo()),
(Type(..), _) => Ordering::Less,
(_, Type(..)) => Ordering::Greater,
+ (Existential(..), _) => Ordering::Less,
+ (_, Existential(..)) => Ordering::Greater,
(Const(..), _) => Ordering::Less,
(_, Const(..)) => Ordering::Greater,
(Macro(..), _) => Ordering::Less,
(_, Macro(..)) => Ordering::Greater,
- _ => a.span.lo().cmp(&b.span.lo()),
});
let mut prev_kind = None;
for (buf, item) in buffer {
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);
- }
-
- if result.ends_with('{') && !context.config.empty_item_single_line() {
+ } else if need_newline || !context.config.empty_item_single_line() {
result.push_str(&sep);
}
+
result.push('}');
Some(result)
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,
)?;
format_empty_struct_or_tuple(context, inner_span, offset, &mut result, "(", ")");
} else {
let shape = Shape::indented(offset, context.config).sub_width(1)?;
- let fields = &fields.iter().collect::<Vec<_>>();
result = overflow::rewrite_with_parens(
context,
&result,
- fields,
+ fields.iter(),
shape,
span,
context.config.width_heuristics().fn_call_width,
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
};
lhs,
&**expr,
Shape::legacy(remaining_width, offset.block_only()),
- ).and_then(|res| recover_comment_removed(res, static_parts.span, context))
+ )
+ .and_then(|res| recover_comment_removed(res, static_parts.span, context))
.map(|s| if s.ends_with(';') { s } else { s + ";" })
} else {
Some(format!("{}{};", prefix, ty_str))
pub fn rewrite_associated_type(
ident: ast::Ident,
ty_opt: Option<&ptr::P<ast::Ty>>,
+ generics: &ast::Generics,
generic_bounds_opt: Option<&ast::GenericBounds>,
context: &RewriteContext,
indent: Indent,
) -> Option<String> {
- let prefix = format!("type {}", rewrite_ident(context, ident));
+ let ident_str = rewrite_ident(context, ident);
+ // 5 = "type "
+ let generics_shape = Shape::indented(indent, context.config).offset_left(5)?;
+ let generics_str = rewrite_generics(context, ident_str, generics, generics_shape)?;
+ let prefix = format!("type {}", generics_str);
let type_bounds_str = if let Some(bounds) = generic_bounds_opt {
if bounds.is_empty() {
pub fn rewrite_existential_impl_type(
context: &RewriteContext,
ident: ast::Ident,
+ generics: &ast::Generics,
generic_bounds: &ast::GenericBounds,
indent: Indent,
) -> Option<String> {
- rewrite_associated_type(ident, None, Some(generic_bounds), context, indent)
+ rewrite_associated_type(ident, None, generics, Some(generic_bounds), context, indent)
.map(|s| format!("existential {}", s))
}
ident: ast::Ident,
defaultness: ast::Defaultness,
ty_opt: Option<&ptr::P<ast::Ty>>,
- generic_bounds_opt: Option<&ast::GenericBounds>,
+ generics: &ast::Generics,
context: &RewriteContext,
indent: Indent,
) -> Option<String> {
- let result = rewrite_associated_type(ident, ty_opt, generic_bounds_opt, context, indent)?;
+ let result = rewrite_associated_type(ident, ty_opt, generics, None, context, indent)?;
match defaultness {
ast::Defaultness::Default => Some(format!("default {}", result)),
}
}
-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)`.
let used_width = last_line_used_width(&result, indent.width()) + first_line_width(&ret_str);
// Put the closing brace on the next line if it overflows the max width.
// 1 = `)`
- if fd.inputs.is_empty() && used_width + 1 > context.config.max_width() {
- result.push('\n');
- }
+ let closing_paren_overflow_max_width =
+ fd.inputs.is_empty() && used_width + 1 > context.config.max_width();
// If the last line of args contains comment, we cannot put the closing paren
// on the same line.
- if arg_str
+ args_last_line_contains_comment = arg_str
.lines()
.last()
- .map_or(false, |last_line| last_line.contains("//"))
- {
- args_last_line_contains_comment = true;
- result.push_str(&arg_indent.to_string_with_newline(context.config));
+ .map_or(false, |last_line| last_line.contains("//"));
+ if closing_paren_overflow_max_width || args_last_line_contains_comment {
+ result.push_str(&indent.to_string_with_newline(context.config));
}
result.push(')');
}
) -> Option<String> {
let mut arg_item_strs = args
.iter()
- .map(|arg| arg.rewrite(context, Shape::legacy(multi_line_budget, arg_indent)))
- .collect::<Option<Vec<_>>>()?;
+ .map(|arg| {
+ arg.rewrite(context, Shape::legacy(multi_line_budget, arg_indent))
+ .unwrap_or_else(|| context.snippet(arg.span()).to_owned())
+ })
+ .collect::<Vec<_>>();
// Account for sugary self.
// FIXME: the comment for the self argument is dropped. This is blocked
debug!("rewrite_args: budget: {}, tactic: {:?}", budget, tactic);
- let fmt = ListFormatting {
- tactic,
- separator: ",",
- trailing_separator: if variadic {
- SeparatorTactic::Never
- } else {
- trailing_comma
- },
- separator_place: SeparatorPlace::Back,
- shape: Shape::legacy(budget, indent),
- ends_with_newline: tactic.ends_with_newline(context.config.indent_style()),
- preserve_newline: true,
- nested: false,
- config: context.config,
+ let trailing_separator = if variadic {
+ SeparatorTactic::Never
+ } else {
+ trailing_comma
};
-
+ let fmt = ListFormatting::new(Shape::legacy(budget, indent), context.config)
+ .tactic(tactic)
+ .trailing_separator(trailing_separator)
+ .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
+ .preserve_newline(true);
write_list(&arg_items, &fmt)
}
return Some(ident.to_owned());
}
- let params = &generics.params.iter().map(|e| &*e).collect::<Vec<_>>();
+ let params = generics.params.iter();
overflow::rewrite_with_angle_brackets(context, ident, params, shape, generics.span)
}
DefinitiveListTactic::Vertical
};
- let fmt = ListFormatting {
- tactic: shape_tactic,
- separator: ",",
- trailing_separator: comma_tactic,
- separator_place: SeparatorPlace::Back,
- shape: clause_shape,
- ends_with_newline: true,
- preserve_newline: true,
- nested: false,
- config: context.config,
- };
+ let fmt = ListFormatting::new(clause_shape, context.config)
+ .tactic(shape_tactic)
+ .trailing_separator(comma_tactic)
+ .preserve_newline(true);
let preds_str = write_list(&items.collect::<Vec<_>>(), &fmt)?;
let comment_separator = |comment: &str, shape: Shape| {
comma_tactic = SeparatorTactic::Never;
}
- let fmt = ListFormatting {
- tactic,
- separator: ",",
- trailing_separator: comma_tactic,
- separator_place: SeparatorPlace::Back,
- shape: Shape::legacy(budget, offset),
- ends_with_newline: tactic.ends_with_newline(context.config.indent_style()),
- preserve_newline: true,
- nested: false,
- config: context.config,
- };
+ let fmt = ListFormatting::new(Shape::legacy(budget, offset), context.config)
+ .tactic(tactic)
+ .trailing_separator(comma_tactic)
+ .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
+ .preserve_newline(true);
let preds_str = write_list(&item_vec, &fmt)?;
let end_length = if terminator == "{" {
span,
false,
false,
- ).map(|(s, _)| format!("{};", s)),
+ )
+ .map(|(s, _)| format!("{};", s)),
ast::ForeignItemKind::Static(ref ty, is_mutable) => {
// FIXME(#21): we're dropping potential comments in between the
// function keywords here.