generics: &'a ast::Generics,
) -> FnSig<'a> {
FnSig {
- unsafety: method_sig.unsafety,
- constness: method_sig.constness.node,
+ unsafety: method_sig.header.unsafety,
+ 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,
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));
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);
)?,
ast::VariantData::Unit(..) => {
if let Some(ref expr) = field.node.disr_expr {
- let lhs = format!("{} =", field.node.ident.name);
+ 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()
}
}
};
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(),
{
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));
}
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 {
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 shape = Shape::indented(offset, context.config).offset_left(result.len())?;
let generics_str = rewrite_generics(
context,
- &item.ident.to_string(),
+ rewrite_ident(context, item.ident),
generics,
shape,
mk_sp(item.span.lo(), body_lo),
if !generic_bounds.is_empty() {
let ident_hi = context
.snippet_provider
- .span_after(item.span, &format!("{}", item.ident));
+ .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) {
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)?;
}
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 {
)?;
}
- 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(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, generics.span)?;
+ 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))
}
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) = generic_bounds_opt {
if bounds.is_empty() {
}
}
+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,
};
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,
+ g_span,
+ )?;
result.push_str(&generics_str);
let snuggle_angle_bracket = generics_str
&& 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 {
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)]
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)
}
/// 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
}