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 types::TraitTyParamBounds;
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 {
}
}
-// TODO convert to using rewrite style rather than visitor
-// TODO format modules in this style
+// FIXME convert to using rewrite style rather than visitor
+// FIXME format modules in this style
#[allow(dead_code)]
struct Item<'a> {
keyword: &'static str,
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,
generics: &'a ast::Generics,
) -> FnSig<'a> {
FnSig {
- unsafety: method_sig.unsafety,
- constness: method_sig.constness.node,
+ unsafety: method_sig.header.unsafety,
+ is_async: method_sig.header.asyncness,
+ constness: method_sig.header.constness.node,
defaultness: ast::Defaultness::Final,
- abi: method_sig.abi,
+ abi: method_sig.header.abi,
decl: &*method_sig.decl,
generics,
visibility: DEFAULT_VISIBILITY,
defaultness: ast::Defaultness,
) -> FnSig<'a> {
match *fn_kind {
- visit::FnKind::ItemFn(_, unsafety, constness, abi, visibility, _) => FnSig {
+ visit::FnKind::ItemFn(_, fn_header, visibility, _) => FnSig {
decl,
generics,
- abi,
- constness: constness.node,
+ abi: fn_header.abi,
+ constness: fn_header.constness.node,
+ is_async: fn_header.asyncness,
defaultness,
- unsafety,
+ unsafety: fn_header.unsafety,
visibility: visibility.clone(),
},
visit::FnKind::Method(_, method_sig, vis, _) => {
fn to_str(&self, context: &RewriteContext) -> String {
let mut result = String::with_capacity(128);
// Vis defaultness constness unsafety abi.
- result.push_str(&*format_visibility(&self.visibility));
+ result.push_str(&*format_visibility(context, &self.visibility));
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) {
generics: &ast::Generics,
span: Span,
) {
- let enum_header = format_header("enum ", ident, vis);
+ let enum_header = format_header(&self.get_context(), "enum ", ident, vis);
self.push_str(&enum_header);
let enum_snippet = self.snippet(span);
}
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,
- 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);
)?,
ast::VariantData::Unit(..) => {
if let Some(ref expr) = field.node.disr_expr {
- let lhs = format!("{} =", field.node.ident.name);
- rewrite_assign_rhs(&context, lhs, &**expr, shape)?
+ let lhs = format!("{} =", rewrite_ident(&context, field.node.ident));
+ rewrite_assign_rhs(&context, lhs, &*expr.value, shape)?
} else {
- field.node.ident.name.to_string()
+ 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 {
} else {
context.budget(last_line_width(&result))
};
- let option = WhereClauseOption::snuggled(&ref_and_type);
+
+ let mut option = WhereClauseOption::snuggled(&ref_and_type);
+ let snippet = context.snippet(item.span);
+ let open_pos = snippet.find_uncommented("{")? + 1;
+ if !contains_comment(&snippet[open_pos..])
+ && items.is_empty()
+ && generics.where_clause.predicates.len() == 1
+ && !result.contains('\n')
+ {
+ option.suppress_comma();
+ option.snuggle();
+ option.compress_where();
+ }
+
let where_clause_str = rewrite_where_clause(
context,
&generics.where_clause,
if is_impl_single_line(context, items, &result, &where_clause_str, item)? {
result.push_str(&where_clause_str);
if where_clause_str.contains('\n') || last_line_contains_single_line_comment(&result) {
+ // if the where_clause contains extra comments AND
+ // there is only one where clause predicate
+ // recover the suppressed comma in single line where_clause formatting
+ if generics.where_clause.predicates.len() == 1 {
+ result.push_str(",");
+ }
result.push_str(&format!("{}{{{}}}", &sep, &sep));
} else {
result.push_str(" {}");
return Some(result);
}
- if !where_clause_str.is_empty() && !where_clause_str.contains('\n') {
- let width = offset.block_indent + context.config.tab_spaces() - 1;
- let where_indent = Indent::new(0, width);
- result.push_str(&where_indent.to_string_with_newline(context.config));
- }
result.push_str(&where_clause_str);
let need_newline = last_line_contains_single_line_comment(&result) || result.contains('\n');
result.push_str(&outer_indent_str);
}
- if result.ends_with('{') {
+ if result.ends_with('{') && !context.config.empty_item_single_line() {
result.push_str(&sep);
}
result.push('}');
{
let mut result = String::with_capacity(128);
- result.push_str(&format_visibility(&item.vis));
+ result.push_str(&format_visibility(context, &item.vis));
result.push_str(format_defaultness(defaultness));
result.push_str(format_unsafety(unsafety));
- let lo = context.snippet_provider.span_after(item.span, "impl");
- let hi = match *trait_ref {
- Some(ref tr) => tr.path.span.lo(),
- None => self_ty.span.lo(),
- };
let shape = generics_shape_from_config(
context.config,
Shape::indented(offset + last_line_width(&result), context.config),
0,
)?;
- let generics_str = rewrite_generics(context, "impl", generics, shape, mk_sp(lo, hi))?;
+ let generics_str = rewrite_generics(context, "impl", generics, shape)?;
result.push_str(&generics_str);
let polarity_str = if polarity == ast::ImplPolarity::Negative {
}
impl<'a> StructParts<'a> {
- fn format_header(&self) -> String {
- format_header(self.prefix, self.ident, self.vis)
+ fn format_header(&self, context: &RewriteContext) -> String {
+ format_header(context, self.prefix, self.ident, self.vis)
}
fn from_variant(variant: &'a ast::Variant) -> Self {
is_auto,
unsafety,
ref generics,
- ref type_param_bounds,
+ ref generic_bounds,
ref trait_items,
) = item.node
{
let mut result = String::with_capacity(128);
let header = format!(
"{}{}{}trait ",
- format_visibility(&item.vis),
+ format_visibility(context, &item.vis),
format_unsafety(unsafety),
format_auto(is_auto),
);
let body_lo = context.snippet_provider.span_after(item.span, "{");
let shape = Shape::indented(offset, context.config).offset_left(result.len())?;
- let generics_str = rewrite_generics(
- context,
- &item.ident.to_string(),
- generics,
- shape,
- mk_sp(item.span.lo(), body_lo),
- )?;
+ let generics_str =
+ rewrite_generics(context, rewrite_ident(context, item.ident), generics, shape)?;
result.push_str(&generics_str);
// FIXME(#2055): rustfmt fails to format when there are comments between trait bounds.
- if !type_param_bounds.is_empty() {
+ if !generic_bounds.is_empty() {
let ident_hi = context
.snippet_provider
- .span_after(item.span, &format!("{}", item.ident));
- let bound_hi = type_param_bounds.last().unwrap().span().hi();
+ .span_after(item.span, &item.ident.as_str());
+ let bound_hi = generic_bounds.last().unwrap().span().hi();
let snippet = context.snippet(mk_sp(ident_hi, bound_hi));
if contains_comment(snippet) {
return None;
}
- }
- if !type_param_bounds.is_empty() {
+
result = rewrite_assign_rhs_with(
context,
result + ":",
- &TraitTyParamBounds::new(type_param_bounds),
+ generic_bounds,
shape,
- RhsTactics::ForceNextLine,
+ RhsTactics::ForceNextLineWithoutIndent,
)?;
}
};
let where_budget = context.budget(last_line_width(&result));
- let pos_before_where = if type_param_bounds.is_empty() {
+ let pos_before_where = if generic_bounds.is_empty() {
generics.where_clause.span.lo()
} else {
- type_param_bounds[type_param_bounds.len() - 1].span().hi()
+ generic_bounds[generic_bounds.len() - 1].span().hi()
};
let option = WhereClauseOption::snuggled(&generics_str);
let where_clause_str = rewrite_where_clause(
context: &RewriteContext,
ident: ast::Ident,
generics: &ast::Generics,
- ty_param_bounds: &ast::TyParamBounds,
+ generic_bounds: &ast::GenericBounds,
shape: Shape,
) -> Option<String> {
- let alias = ident.name.as_str();
+ let alias = rewrite_ident(context, ident);
// 6 = "trait ", 2 = " ="
let g_shape = shape.offset_left(6)?.sub_width(2)?;
- let generics_str = rewrite_generics(context, &alias, generics, g_shape, generics.span)?;
+ let generics_str = rewrite_generics(context, &alias, generics, g_shape)?;
let lhs = format!("trait {} =", generics_str);
// 1 = ";"
- rewrite_assign_rhs(context, lhs, ty_param_bounds, shape.sub_width(1)?).map(|s| s + ";")
+ rewrite_assign_rhs(context, lhs, generic_bounds, shape.sub_width(1)?).map(|s| s + ";")
}
fn format_unit_struct(context: &RewriteContext, p: &StructParts, offset: Indent) -> Option<String> {
- let header_str = format_header(p.prefix, p.ident, p.vis);
+ let header_str = format_header(context, p.prefix, p.ident, p.vis);
let generics_str = if let Some(generics) = p.generics {
let hi = if generics.where_clause.predicates.is_empty() {
generics.span.hi()
let mut result = String::with_capacity(1024);
let span = struct_parts.span;
- let header_str = struct_parts.format_header();
+ 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 mut result = String::with_capacity(1024);
let span = struct_parts.span;
- let header_str = struct_parts.format_header();
+ let header_str = struct_parts.format_header(context);
result.push_str(&header_str);
let body_lo = if fields.is_empty() {
} else {
// This is a dirty hack to work around a missing `)` from the span of the last field.
let last_arg_span = fields[fields.len() - 1].span;
- if context.snippet(last_arg_span).ends_with(')') {
- last_arg_span.hi()
- } else {
- context
- .snippet_provider
- .span_after(mk_sp(last_arg_span.hi(), span.hi()), ")")
- }
+ context
+ .snippet_provider
+ .opt_span_after(mk_sp(last_arg_span.hi(), span.hi()), ")")
+ .unwrap_or(last_arg_span.hi())
};
let where_clause_str = match struct_parts.generics {
Some(generics) => {
let budget = context.budget(last_line_width(&header_str));
let shape = Shape::legacy(budget, offset);
- let g_span = mk_sp(span.lo(), body_lo);
- let generics_str = rewrite_generics(context, "", generics, shape, g_span)?;
+ let generics_str = rewrite_generics(context, "", generics, shape)?;
result.push_str(&generics_str);
let where_budget = context.budget(last_line_width(&result));
)?;
}
- if !where_clause_str.is_empty() && !where_clause_str.contains('\n')
+ if !where_clause_str.is_empty()
+ && !where_clause_str.contains('\n')
&& (result.contains('\n')
|| offset.block_indent + result.len() + where_clause_str.len() + 1
> context.config.max_width())
// We need to put the where clause on a new line, but we didn't
// know that earlier, so the where clause will not be indented properly.
result.push('\n');
- result
- .push_str(&(offset.block_only() + (context.config.tab_spaces() - 1))
- .to_string(context.config));
+ result.push_str(
+ &(offset.block_only() + (context.config.tab_spaces() - 1)).to_string(context.config),
+ );
}
result.push_str(&where_clause_str);
Some(result)
}
-pub fn rewrite_type_alias(
+fn rewrite_type_prefix(
context: &RewriteContext,
indent: Indent,
+ prefix: &str,
ident: ast::Ident,
- ty: &ast::Ty,
generics: &ast::Generics,
- vis: &ast::Visibility,
- span: Span,
) -> Option<String> {
let mut result = String::with_capacity(128);
-
- result.push_str(&format_visibility(vis));
- result.push_str("type ");
+ result.push_str(prefix);
+ let ident_str = rewrite_ident(context, ident);
// 2 = `= `
- let g_shape = Shape::indented(indent, context.config)
- .offset_left(result.len())?
- .sub_width(2)?;
- let g_span = mk_sp(
- context.snippet_provider.span_after(span, "type"),
- ty.span.lo(),
- );
- let generics_str = rewrite_generics(context, &ident.to_string(), generics, g_shape, g_span)?;
- result.push_str(&generics_str);
+ if generics.params.is_empty() {
+ result.push_str(ident_str)
+ } else {
+ let g_shape = Shape::indented(indent, context.config)
+ .offset_left(result.len())?
+ .sub_width(2)?;
+ let generics_str = rewrite_generics(context, ident_str, generics, g_shape)?;
+ result.push_str(&generics_str);
+ }
let where_budget = context.budget(last_line_width(&result));
let option = WhereClauseOption::snuggled(&result);
Shape::legacy(where_budget, indent),
Density::Vertical,
"=",
- Some(span.hi()),
+ None,
generics.span.hi(),
option,
false,
)?;
result.push_str(&where_clause_str);
- if where_clause_str.is_empty() {
- result.push_str(" =");
+
+ Some(result)
+}
+
+fn rewrite_type_item<R: Rewrite>(
+ context: &RewriteContext,
+ indent: Indent,
+ prefix: &str,
+ suffix: &str,
+ ident: ast::Ident,
+ rhs: &R,
+ generics: &ast::Generics,
+ vis: &ast::Visibility,
+) -> Option<String> {
+ let mut result = String::with_capacity(128);
+ result.push_str(&rewrite_type_prefix(
+ context,
+ indent,
+ &format!("{}{} ", format_visibility(context, vis), prefix),
+ ident,
+ generics,
+ )?);
+
+ if generics.where_clause.predicates.is_empty() {
+ result.push_str(suffix);
} else {
- result.push_str(&format!(
- "{}=",
- indent.to_string_with_newline(context.config)
- ));
+ result.push_str(&indent.to_string_with_newline(context.config));
+ result.push_str(suffix.trim_left());
}
// 1 = ";"
- let ty_shape = Shape::indented(indent, context.config).sub_width(1)?;
- rewrite_assign_rhs(context, result, ty, ty_shape).map(|s| s + ";")
+ let rhs_shape = Shape::indented(indent, context.config).sub_width(1)?;
+ rewrite_assign_rhs(context, result, rhs, rhs_shape).map(|s| s + ";")
+}
+
+pub fn rewrite_type_alias(
+ context: &RewriteContext,
+ indent: Indent,
+ ident: ast::Ident,
+ ty: &ast::Ty,
+ generics: &ast::Generics,
+ vis: &ast::Visibility,
+) -> Option<String> {
+ rewrite_type_item(context, indent, "type", " =", ident, ty, generics, vis)
+}
+
+pub fn rewrite_existential_type(
+ context: &RewriteContext,
+ indent: Indent,
+ ident: ast::Ident,
+ generic_bounds: &ast::GenericBounds,
+ generics: &ast::Generics,
+ vis: &ast::Visibility,
+) -> Option<String> {
+ rewrite_type_item(
+ context,
+ indent,
+ "existential type",
+ ":",
+ ident,
+ generic_bounds,
+ generics,
+ vis,
+ )
}
fn type_annotation_spacing(config: &Config) -> (&str, &str) {
context: &RewriteContext,
field: &ast::StructField,
) -> Option<String> {
- let vis = format_visibility(&field.vis);
+ let vis = format_visibility(context, &field.vis);
let type_annotation_spacing = type_annotation_spacing(context.config);
Some(match field.ident {
- Some(name) => format!("{}{}{}:", vis, name, type_annotation_spacing.0),
+ Some(name) => format!(
+ "{}{}{}:",
+ vis,
+ rewrite_ident(context, name),
+ type_annotation_spacing.0
+ ),
None => format!("{}", vis),
})
}
);
let mut prefix = format!(
"{}{}{} {}{}{}",
- format_visibility(static_parts.vis),
+ format_visibility(context, static_parts.vis),
static_parts.defaultness.map_or("", format_defaultness),
static_parts.prefix,
format_mutability(static_parts.mutability),
&**expr,
Shape::legacy(remaining_width, offset.block_only()),
).and_then(|res| recover_comment_removed(res, static_parts.span, context))
- .map(|s| if s.ends_with(';') { s } else { s + ";" })
+ .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>>,
- ty_param_bounds_opt: Option<&ast::TyParamBounds>,
+ generic_bounds_opt: Option<&ast::GenericBounds>,
context: &RewriteContext,
indent: Indent,
) -> Option<String> {
- let prefix = format!("type {}", ident);
+ let prefix = format!("type {}", rewrite_ident(context, ident));
- let type_bounds_str = if let Some(bounds) = ty_param_bounds_opt {
+ let type_bounds_str = if let Some(bounds) = generic_bounds_opt {
if bounds.is_empty() {
String::new()
} else {
}
}
+pub fn rewrite_existential_impl_type(
+ context: &RewriteContext,
+ ident: ast::Ident,
+ generic_bounds: &ast::GenericBounds,
+ indent: Indent,
+) -> Option<String> {
+ rewrite_associated_type(ident, None, Some(generic_bounds), context, indent)
+ .map(|s| format!("existential {}", s))
+}
+
pub fn rewrite_associated_impl_type(
ident: ast::Ident,
defaultness: ast::Defaultness,
ty_opt: Option<&ptr::P<ast::Ty>>,
- ty_param_bounds_opt: Option<&ast::TyParamBounds>,
context: &RewriteContext,
indent: Indent,
) -> Option<String> {
- let result = rewrite_associated_type(ident, ty_opt, ty_param_bounds_opt, context, indent)?;
+ let result = rewrite_associated_type(ident, ty_opt, None, context, indent)?;
match defaultness {
ast::Defaultness::Default => Some(format!("default {}", result)),
offset: used_width,
};
let fd = fn_sig.decl;
- let g_span = mk_sp(span.lo(), fd.output.span().lo());
- let generics_str =
- rewrite_generics(context, &ident.to_string(), fn_sig.generics, shape, g_span)?;
+ let generics_str = rewrite_generics(
+ context,
+ rewrite_ident(context, ident),
+ fn_sig.generics,
+ shape,
+ )?;
result.push_str(&generics_str);
let snuggle_angle_bracket = generics_str
pub fn snuggled(current: &str) -> WhereClauseOption {
WhereClauseOption {
suppress_comma: false,
- snuggle: trimmed_last_line_width(current) == 1,
+ snuggle: last_line_width(current) == 1,
compress_where: false,
}
}
+
+ pub fn suppress_comma(&mut self) {
+ self.suppress_comma = true
+ }
+
+ pub fn compress_where(&mut self) {
+ self.compress_where = true
+ }
+
+ pub fn snuggle(&mut self) {
+ self.snuggle = true
+ }
}
fn rewrite_args(
) -> 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,
- 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)
}
ident: &str,
generics: &ast::Generics,
shape: Shape,
- span: Span,
) -> Option<String> {
// FIXME: convert bounds to where clauses where they get too big or if
// there is a where clause at all.
}
let params = &generics.params.iter().map(|e| &*e).collect::<Vec<_>>();
- overflow::rewrite_with_angle_brackets(context, ident, params, shape, span)
+ overflow::rewrite_with_angle_brackets(context, ident, params, shape, generics.span)
}
pub fn generics_shape_from_config(config: &Config, shape: Shape, offset: usize) -> Option<Shape> {
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,
- 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| {
&& comment_before.is_empty()
&& comment_after.is_empty()
&& !preds_str.contains('\n')
- && 6 + preds_str.len() <= shape.width || where_single_line
+ && 6 + preds_str.len() <= shape.width
+ || where_single_line
{
Cow::from(" ")
} else {
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,
- 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 == "{" {
Some((before_comment, after_comment))
}
-fn format_header(item_name: &str, ident: ast::Ident, vis: &ast::Visibility) -> String {
- format!("{}{}{}", format_visibility(vis), item_name, ident)
+fn format_header(
+ context: &RewriteContext,
+ item_name: &str,
+ ident: ast::Ident,
+ vis: &ast::Visibility,
+) -> String {
+ format!(
+ "{}{}{}",
+ format_visibility(context, vis),
+ item_name,
+ rewrite_ident(context, ident)
+ )
}
#[derive(PartialEq, Eq, Clone, Copy)]
used_width: usize,
) -> Option<String> {
let shape = Shape::legacy(context.budget(used_width + offset.width()), offset);
- let mut result = rewrite_generics(context, "", generics, shape, span)?;
+ let mut result = rewrite_generics(context, "", generics, shape)?;
let same_line_brace = if !generics.where_clause.predicates.is_empty() || result.contains('\n') {
let budget = context.budget(last_line_used_width(&result, offset.width()));
}
// If the generics are not parameterized then generics.span.hi() == 0,
// so we use span.lo(), which is the position after `struct Foo`.
- let span_end_before_where = if generics.is_parameterized() {
+ let span_end_before_where = if !generics.params.is_empty() {
generics.span.hi()
} else {
span.lo()
false,
)?;
result.push_str(&where_clause_str);
- brace_pos == BracePos::ForceSameLine || brace_style == BraceStyle::PreferSameLine
+ brace_pos == BracePos::ForceSameLine
+ || brace_style == BraceStyle::PreferSameLine
|| (generics.where_clause.predicates.is_empty()
&& trimmed_last_line_width(&result) == 1)
} else {
let span = mk_sp(self.span.lo(), self.span.hi() - BytePos(1));
let item_str = match self.node {
- ast::ForeignItemKind::Fn(ref fn_decl, ref generics) => {
- rewrite_fn_base(
- context,
- shape.indent,
- self.ident,
- &FnSig::new(fn_decl, generics, self.vis.clone()),
- span,
- false,
- false,
- ).map(|(s, _)| format!("{};", s))
- }
+ ast::ForeignItemKind::Fn(ref fn_decl, ref generics) => rewrite_fn_base(
+ context,
+ shape.indent,
+ self.ident,
+ &FnSig::new(fn_decl, generics, self.vis.clone()),
+ span,
+ false,
+ false,
+ ).map(|(s, _)| format!("{};", s)),
ast::ForeignItemKind::Static(ref ty, is_mutable) => {
// FIXME(#21): we're dropping potential comments in between the
// function keywords here.
- let vis = format_visibility(&self.vis);
+ let vis = format_visibility(context, &self.vis);
let mut_str = if is_mutable { "mut " } else { "" };
- let prefix = format!("{}static {}{}:", vis, mut_str, self.ident);
+ let prefix = format!(
+ "{}static {}{}:",
+ vis,
+ mut_str,
+ rewrite_ident(context, self.ident)
+ );
// 1 = ;
rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
}
ast::ForeignItemKind::Ty => {
- let vis = format_visibility(&self.vis);
- Some(format!("{}type {};", vis, self.ident))
+ let vis = format_visibility(context, &self.vis);
+ Some(format!(
+ "{}type {};",
+ vis,
+ rewrite_ident(context, self.ident)
+ ))
}
ast::ForeignItemKind::Macro(ref mac) => {
rewrite_macro(mac, None, context, shape, MacroPosition::Item)
}
}
-impl Rewrite for ast::GenericParam {
- fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
- match *self {
- ast::GenericParam::Lifetime(ref lifetime_def) => lifetime_def.rewrite(context, shape),
- ast::GenericParam::Type(ref ty) => ty.rewrite(context, shape),
- }
- }
-}
-
/// Rewrite an inline mod.
-pub fn rewrite_mod(item: &ast::Item) -> String {
+pub fn rewrite_mod(context: &RewriteContext, item: &ast::Item) -> String {
let mut result = String::with_capacity(32);
- result.push_str(&*format_visibility(&item.vis));
+ result.push_str(&*format_visibility(context, &item.vis));
result.push_str("mod ");
- result.push_str(&item.ident.to_string());
+ result.push_str(rewrite_ident(context, item.ident));
result.push(';');
result
}
projects / rust.git / blobdiff