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 {
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) {
}
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);
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 {
option.compress_where();
}
- let mut where_clause_str = rewrite_where_clause(
+ let where_clause_str = rewrite_where_clause(
context,
&generics.where_clause,
context.config.brace_style(),
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 {
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,
- rewrite_ident(context, item.ident),
- 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.
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, generic_bounds, shape.sub_width(1)?).map(|s| s + ";")
} 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())
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(context, 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,
- rewrite_ident(context, ident),
- 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) {
&**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_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>>,
- generic_bounds_opt: Option<&ast::GenericBounds>,
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, 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,
rewrite_ident(context, ident),
fn_sig.generics,
shape,
- g_span,
)?;
result.push_str(&generics_str);
) -> 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)
}
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,
- 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| {
&& 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,
- 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 == "{" {
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()));
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.
projects / rust.git / blobdiff