use std::cmp;
+use config::lists::*;
use syntax::ast;
-use syntax::codemap::{BytePos, Span};
+use syntax::source_map::{BytePos, Span};
-use {Indent, Shape, Spanned};
-use codemap::SpanUtils;
use comment::{combine_strs_with_missing_comments, contains_comment};
use expr::rewrite_field;
use items::{rewrite_struct_field, rewrite_struct_field_prefix};
-use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, ListTactic, Separator};
+use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
use rewrite::{Rewrite, RewriteContext};
-use utils::{contains_skip, is_attributes_extendable, mk_sp};
+use shape::{Indent, Shape};
+use source_map::SpanUtils;
+use spanned::Spanned;
+use utils::{contains_skip, is_attributes_extendable, mk_sp, rewrite_ident};
pub trait AlignedItem {
fn skip(&self) -> bool;
}
fn rewrite_prefix(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
- let attrs_str = try_opt!(self.attrs.rewrite(context, shape));
+ let attrs_str = self.attrs.rewrite(context, shape)?;
let missing_span = if self.attrs.is_empty() {
- mk_sp(self.span.lo, self.span.lo)
+ mk_sp(self.span.lo(), self.span.lo())
} else {
- mk_sp(self.attrs.last().unwrap().span.hi, self.span.lo)
+ mk_sp(self.attrs.last().unwrap().span.hi(), self.span.lo())
};
+ let attrs_extendable = self.ident.is_none() && is_attributes_extendable(&attrs_str);
rewrite_struct_field_prefix(context, self).and_then(|field_str| {
combine_strs_with_missing_comments(
context,
&field_str,
missing_span,
shape,
- is_attributes_extendable(&attrs_str),
+ attrs_extendable,
)
})
}
}
fn rewrite_prefix(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
- let attrs_str = try_opt!(self.attrs.rewrite(context, shape));
- let name = &self.ident.node.to_string();
+ let attrs_str = self.attrs.rewrite(context, shape)?;
+ let name = rewrite_ident(context, self.ident);
let missing_span = if self.attrs.is_empty() {
- mk_sp(self.span.lo, self.span.lo)
+ mk_sp(self.span.lo(), self.span.lo())
} else {
- mk_sp(self.attrs.last().unwrap().span.hi, self.span.lo)
+ mk_sp(self.attrs.last().unwrap().span.hi(), self.span.lo())
};
combine_strs_with_missing_comments(
context,
} else {
("", fields.len() - 1)
};
- let init = &fields[0..group_index + 1];
+ let init = &fields[0..=group_index];
let rest = &fields[group_index + 1..];
let init_last_pos = if rest.is_empty() {
- span.hi
+ span.hi()
} else {
// Decide whether the missing comments should stick to init or rest.
- let init_hi = init[init.len() - 1].get_span().hi;
- let rest_lo = rest[0].get_span().lo;
+ let init_hi = init[init.len() - 1].get_span().hi();
+ let rest_lo = rest[0].get_span().lo();
let missing_span = mk_sp(init_hi, rest_lo);
let missing_span = mk_sp(
- context.codemap.span_after(missing_span, ","),
- missing_span.hi,
+ context.snippet_provider.span_after(missing_span, ","),
+ missing_span.hi(),
);
let snippet = context.snippet(missing_span);
init_hi + BytePos(offset as u32 + 2)
} else {
- missing_span.lo
+ missing_span.lo()
}
};
- let init_span = mk_sp(span.lo, init_last_pos);
+ let init_span = mk_sp(span.lo(), init_last_pos);
let one_line_width = if rest.is_empty() { one_line_width } else { 0 };
- let result = try_opt!(rewrite_aligned_items_inner(
- context,
- init,
- init_span,
- shape.indent,
- one_line_width,
- ));
+ let result =
+ rewrite_aligned_items_inner(context, init, init_span, shape.indent, one_line_width)?;
if rest.is_empty() {
Some(result + spaces)
} else {
- let rest_span = mk_sp(init_last_pos, span.hi);
- let rest_str = try_opt!(rewrite_with_alignment(
- rest,
- context,
- shape,
- rest_span,
- one_line_width,
- ));
+ let rest_span = mk_sp(init_last_pos, span.hi());
+ let rest_str = rewrite_with_alignment(rest, context, shape, rest_span, one_line_width)?;
Some(
- result + spaces + "\n" +
- &shape
+ result
+ + spaces
+ + "\n"
+ + &shape
.indent
.block_indent(context.config)
- .to_string(context.config) + &rest_str,
+ .to_string(context.config)
+ + &rest_str,
)
}
}
-fn struct_field_preix_max_min_width<T: AlignedItem>(
+fn struct_field_prefix_max_min_width<T: AlignedItem>(
context: &RewriteContext,
fields: &[T],
shape: Shape,
fields
.iter()
.map(|field| {
- field
- .rewrite_prefix(context, shape)
- .and_then(|field_str| if field_str.contains('\n') {
+ field.rewrite_prefix(context, shape).and_then(|field_str| {
+ if field_str.contains('\n') {
None
} else {
Some(field_str.len())
- })
- })
- .fold(Some((0, ::std::usize::MAX)), |acc, len| match (acc, len) {
+ }
+ })
+ }).fold(Some((0, ::std::usize::MAX)), |acc, len| match (acc, len) {
(Some((max_len, min_len)), Some(len)) => {
Some((cmp::max(max_len, len), cmp::min(min_len, len)))
}
_ => None,
- })
- .unwrap_or((0, 0))
+ }).unwrap_or((0, 0))
}
fn rewrite_aligned_items_inner<T: AlignedItem>(
) -> Option<String> {
let item_indent = offset.block_indent(context.config);
// 1 = ","
- let item_shape = try_opt!(Shape::indented(item_indent, context.config).sub_width(1));
+ let item_shape = Shape::indented(item_indent, context.config).sub_width(1)?;
let (mut field_prefix_max_width, field_prefix_min_width) =
- struct_field_preix_max_min_width(context, fields, item_shape);
- let max_diff = field_prefix_max_width
- .checked_sub(field_prefix_min_width)
- .unwrap_or(0);
+ struct_field_prefix_max_min_width(context, fields, item_shape);
+ let max_diff = field_prefix_max_width.saturating_sub(field_prefix_min_width);
if max_diff > context.config.struct_field_align_threshold() {
field_prefix_max_width = 0;
}
let items = itemize_list(
- context.codemap,
+ context.snippet_provider,
fields.iter(),
"}",
- |field| field.get_span().lo,
- |field| field.get_span().hi,
+ ",",
+ |field| field.get_span().lo(),
+ |field| field.get_span().hi(),
|field| field.rewrite_aligned_item(context, item_shape, field_prefix_max_width),
- span.lo,
- span.hi,
+ span.lo(),
+ span.hi(),
false,
).collect::<Vec<_>>();
one_line_width,
);
- let fmt = ListFormatting {
- tactic: tactic,
- separator: ",",
- trailing_separator: context.config.trailing_comma(),
- shape: item_shape,
- ends_with_newline: true,
- preserve_newline: true,
- config: context.config,
- };
+ let fmt = ListFormatting::new(item_shape, context.config)
+ .tactic(tactic)
+ .trailing_separator(context.config.trailing_comma())
+ .preserve_newline(true);
write_list(&items, &fmt)
}
return ("", index);
}
// See if there are comments or empty lines between fields.
- let span = mk_sp(fields[i].get_span().hi, fields[i + 1].get_span().lo);
+ let span = mk_sp(fields[i].get_span().hi(), fields[i + 1].get_span().lo());
let snippet = context
.snippet(span)
.lines()
.skip(1)
.collect::<Vec<_>>()
.join("\n");
- let spacings = if snippet
- .lines()
- .rev()
- .skip(1)
- .find(|l| l.trim().is_empty())
- .is_some()
- {
+ let spacings = if snippet.lines().rev().skip(1).any(|l| l.trim().is_empty()) {
"\n"
} else {
""
projects / rust.git / blobdiff