use std::cmp::{max, min, Ordering};
use regex::Regex;
-use rustc_target::spec::abi;
-use syntax::source_map::{self, BytePos, Span};
-use syntax::visit;
-use syntax::{ast, ptr, symbol};
+use rustc_ast::visit;
+use rustc_ast::{ast, ptr};
+use rustc_span::{symbol, BytePos, Span, DUMMY_SP};
use crate::attr::filter_inline_attrs;
use crate::comment::{
use crate::vertical::rewrite_with_alignment;
use crate::visitor::FmtVisitor;
-const DEFAULT_VISIBILITY: ast::Visibility = source_map::Spanned {
- node: ast::VisibilityKind::Inherited,
- span: source_map::DUMMY_SP,
+const DEFAULT_VISIBILITY: ast::Visibility = ast::Visibility {
+ kind: ast::VisibilityKind::Inherited,
+ span: DUMMY_SP,
+ tokens: None,
};
fn type_annotation_separator(config: &Config) -> &str {
// FIXME format modules in this style
#[allow(dead_code)]
struct Item<'a> {
- keyword: &'static str,
+ unsafety: ast::Unsafe,
abi: Cow<'static, str>,
vis: Option<&'a ast::Visibility>,
body: Vec<BodyElement<'a>>,
impl<'a> Item<'a> {
fn from_foreign_mod(fm: &'a ast::ForeignMod, span: Span, config: &Config) -> Item<'a> {
Item {
- keyword: "",
- abi: format_abi(fm.abi, config.force_explicit_abi(), true),
+ unsafety: fm.unsafety,
+ abi: format_extern(
+ ast::Extern::from_abi(fm.abi),
+ config.force_explicit_abi(),
+ true,
+ ),
vis: None,
body: fm
.items
pub(crate) struct FnSig<'a> {
decl: &'a ast::FnDecl,
generics: &'a ast::Generics,
- abi: abi::Abi,
- is_async: Cow<'a, ast::IsAsync>,
- constness: ast::Constness,
+ ext: ast::Extern,
+ is_async: Cow<'a, ast::Async>,
+ constness: ast::Const,
defaultness: ast::Defaultness,
- unsafety: ast::Unsafety,
+ unsafety: ast::Unsafe,
visibility: ast::Visibility,
}
FnSig {
decl,
generics,
- abi: abi::Abi::Rust,
- is_async: Cow::Owned(ast::IsAsync::NotAsync),
- constness: ast::Constness::NotConst,
+ ext: ast::Extern::None,
+ is_async: Cow::Owned(ast::Async::No),
+ constness: ast::Const::No,
defaultness: ast::Defaultness::Final,
- unsafety: ast::Unsafety::Normal,
+ unsafety: ast::Unsafe::No,
visibility: vis,
}
}
pub(crate) fn from_method_sig(
- method_sig: &'a ast::MethodSig,
+ method_sig: &'a ast::FnSig,
generics: &'a ast::Generics,
) -> FnSig<'a> {
FnSig {
unsafety: method_sig.header.unsafety,
- is_async: Cow::Borrowed(&method_sig.header.asyncness.node),
- constness: method_sig.header.constness.node,
+ is_async: Cow::Borrowed(&method_sig.header.asyncness),
+ constness: method_sig.header.constness,
defaultness: ast::Defaultness::Final,
- abi: method_sig.header.abi,
+ ext: method_sig.header.ext,
decl: &*method_sig.decl,
generics,
visibility: DEFAULT_VISIBILITY,
defaultness: ast::Defaultness,
) -> FnSig<'a> {
match *fn_kind {
- visit::FnKind::ItemFn(_, fn_header, visibility, _) => FnSig {
- decl,
- generics,
- abi: fn_header.abi,
- constness: fn_header.constness.node,
- is_async: Cow::Borrowed(&fn_header.asyncness.node),
- defaultness,
- unsafety: fn_header.unsafety,
- visibility: visibility.clone(),
- },
- visit::FnKind::Method(_, method_sig, vis, _) => {
- let mut fn_sig = FnSig::from_method_sig(method_sig, generics);
- fn_sig.defaultness = defaultness;
- if let Some(vis) = vis {
+ visit::FnKind::Fn(fn_ctxt, _, fn_sig, vis, _) => match fn_ctxt {
+ visit::FnCtxt::Assoc(..) => {
+ let mut fn_sig = FnSig::from_method_sig(fn_sig, generics);
+ fn_sig.defaultness = defaultness;
fn_sig.visibility = vis.clone();
+ fn_sig
}
- fn_sig
- }
+ _ => FnSig {
+ decl,
+ generics,
+ ext: fn_sig.header.ext,
+ constness: fn_sig.header.constness,
+ is_async: Cow::Borrowed(&fn_sig.header.asyncness),
+ defaultness,
+ unsafety: fn_sig.header.unsafety,
+ visibility: vis.clone(),
+ },
+ },
_ => unreachable!(),
}
}
result.push_str(format_constness(self.constness));
result.push_str(format_async(&self.is_async));
result.push_str(format_unsafety(self.unsafety));
- result.push_str(&format_abi(
- self.abi,
+ result.push_str(&format_extern(
+ self.ext,
context.config.force_explicit_abi(),
false,
));
impl<'a> FmtVisitor<'a> {
fn format_item(&mut self, item: &Item<'_>) {
+ self.buffer.push_str(format_unsafety(item.unsafety));
self.buffer.push_str(&item.abi);
let snippet = self.snippet(item.span);
self.last_pos = item.span.lo() + BytePos(brace_pos as u32 + 1);
self.block_indent = self.block_indent.block_indent(self.config);
- if item.body.is_empty() {
- self.format_missing_no_indent(item.span.hi() - BytePos(1));
- self.block_indent = self.block_indent.block_unindent(self.config);
- let indent_str = self.block_indent.to_string(self.config);
- self.push_str(&indent_str);
- } else {
+ if !item.body.is_empty() {
for item in &item.body {
self.format_body_element(item);
}
-
- self.block_indent = self.block_indent.block_unindent(self.config);
- self.format_missing_with_indent(item.span.hi() - BytePos(1));
}
+
+ self.format_missing_no_indent(item.span.hi() - BytePos(1));
+ self.block_indent = self.block_indent.block_unindent(self.config);
+ let indent_str = self.block_indent.to_string(self.config);
+ self.push_str(&indent_str);
}
self.push_str("}");
fn format_foreign_item(&mut self, item: &ast::ForeignItem) {
let rewrite = item.rewrite(&self.get_context(), self.shape());
- self.push_rewrite(item.span(), rewrite);
- self.last_pos = item.span.hi();
+ let hi = item.span.hi();
+ let span = if item.attrs.is_empty() {
+ item.span
+ } else {
+ mk_sp(item.attrs[0].span.lo(), hi)
+ };
+ self.push_rewrite(span, rewrite);
+ self.last_pos = hi;
}
pub(crate) fn rewrite_fn_before_block(
&mut self,
indent: Indent,
- ident: ast::Ident,
+ ident: symbol::Ident,
fn_sig: &FnSig<'_>,
span: Span,
) -> Option<(String, FnBraceStyle)> {
pub(crate) fn rewrite_required_fn(
&mut self,
indent: Indent,
- ident: ast::Ident,
- sig: &ast::MethodSig,
+ ident: symbol::Ident,
+ sig: &ast::FnSig,
generics: &ast::Generics,
span: Span,
) -> Option<String> {
return None;
}
- let source_map = self.get_context().source_map;
+ let context = self.get_context();
if self.config.empty_item_single_line()
- && is_empty_block(block, None, source_map)
+ && is_empty_block(&context, block, None)
&& self.block_indent.width() + fn_str.len() + 3 <= self.config.max_width()
&& !last_line_contains_single_line_comment(fn_str)
{
return Some(format!("{} {{}}", fn_str));
}
- if !self.config.fn_single_line() || !is_simple_block_stmt(block, None, source_map) {
+ if !self.config.fn_single_line() || !is_simple_block_stmt(&context, block, None) {
return None;
}
pub(crate) fn visit_enum(
&mut self,
- ident: ast::Ident,
+ ident: symbol::Ident,
vis: &ast::Visibility,
enum_def: &ast::EnumDef,
generics: &ast::Generics,
combine_strs_with_missing_comments(&context, &attrs_str, &variant_body, span, shape, false)
}
- fn visit_impl_items(&mut self, items: &[ast::ImplItem]) {
+ fn visit_impl_items(&mut self, items: &[ptr::P<ast::AssocItem>]) {
if self.get_context().config.reorder_impl_items() {
// Create visitor for each items, then reorder them.
let mut buffer = vec![];
buffer.push((self.buffer.clone(), item.clone()));
self.buffer.clear();
}
+
+ fn is_type(ty: &Option<rustc_ast::ptr::P<ast::Ty>>) -> bool {
+ if let Some(lty) = ty {
+ if let ast::TyKind::ImplTrait(..) = lty.kind {
+ return false;
+ }
+ }
+ true
+ }
+
+ fn is_opaque(ty: &Option<rustc_ast::ptr::P<ast::Ty>>) -> bool {
+ !is_type(ty)
+ }
+
+ fn both_type(
+ a: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ b: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ ) -> bool {
+ is_type(a) && is_type(b)
+ }
+
+ fn both_opaque(
+ a: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ b: &Option<rustc_ast::ptr::P<ast::Ty>>,
+ ) -> bool {
+ is_opaque(a) && is_opaque(b)
+ }
+
+ // In rustc-ap-v638 the `OpaqueTy` AssocItemKind variant was removed but
+ // we still need to differentiate to maintain sorting order.
+
// type -> opaque -> const -> macro -> method
- use crate::ast::ImplItemKind::*;
- fn need_empty_line(a: &ast::ImplItemKind, b: &ast::ImplItemKind) -> bool {
+ use crate::ast::AssocItemKind::*;
+ fn need_empty_line(a: &ast::AssocItemKind, b: &ast::AssocItemKind) -> bool {
match (a, b) {
- (TyAlias(..), TyAlias(..))
- | (Const(..), Const(..))
- | (OpaqueTy(..), OpaqueTy(..)) => false,
+ (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
+ if both_type(lty, rty) || both_opaque(lty, rty) =>
+ {
+ false
+ }
+ (Const(..), Const(..)) => false,
_ => true,
}
}
- buffer.sort_by(|(_, a), (_, b)| match (&a.node, &b.node) {
- (TyAlias(..), TyAlias(..))
- | (Const(..), Const(..))
- | (Macro(..), Macro(..))
- | (OpaqueTy(..), OpaqueTy(..)) => a.ident.as_str().cmp(&b.ident.as_str()),
- (Method(..), Method(..)) => a.span.lo().cmp(&b.span.lo()),
+ buffer.sort_by(|(_, a), (_, b)| match (&a.kind, &b.kind) {
+ (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
+ if both_type(lty, rty) || both_opaque(lty, rty) =>
+ {
+ a.ident.as_str().cmp(&b.ident.as_str())
+ }
+ (Const(..), Const(..)) | (MacCall(..), MacCall(..)) => {
+ a.ident.as_str().cmp(&b.ident.as_str())
+ }
+ (Fn(..), Fn(..)) => a.span.lo().cmp(&b.span.lo()),
+ (TyAlias(_, _, _, ref ty), _) if is_type(ty) => Ordering::Less,
+ (_, TyAlias(_, _, _, ref ty)) if is_type(ty) => Ordering::Greater,
(TyAlias(..), _) => Ordering::Less,
(_, TyAlias(..)) => Ordering::Greater,
- (OpaqueTy(..), _) => Ordering::Less,
- (_, OpaqueTy(..)) => Ordering::Greater,
(Const(..), _) => Ordering::Less,
(_, Const(..)) => Ordering::Greater,
- (Macro(..), _) => Ordering::Less,
- (_, Macro(..)) => Ordering::Greater,
+ (MacCall(..), _) => Ordering::Less,
+ (_, MacCall(..)) => Ordering::Greater,
});
let mut prev_kind = None;
for (buf, item) in buffer {
// different impl items.
if prev_kind
.as_ref()
- .map_or(false, |prev_kind| need_empty_line(prev_kind, &item.node))
+ .map_or(false, |prev_kind| need_empty_line(prev_kind, &item.kind))
{
self.push_str("\n");
}
let indent_str = self.block_indent.to_string_with_newline(self.config);
self.push_str(&indent_str);
self.push_str(buf.trim());
- prev_kind = Some(item.node.clone());
+ prev_kind = Some(item.kind.clone());
}
} else {
for item in items {
item: &ast::Item,
offset: Indent,
) -> Option<String> {
- if let ast::ItemKind::Impl(_, _, _, ref generics, _, ref self_ty, ref items) = item.node {
+ if let ast::ItemKind::Impl {
+ ref generics,
+ ref self_ty,
+ ref items,
+ ..
+ } = item.kind
+ {
let mut result = String::with_capacity(128);
let ref_and_type = format_impl_ref_and_type(context, item, offset)?;
let sep = offset.to_string_with_newline(context.config);
}
}
- if is_impl_single_line(context, items, &result, &where_clause_str, item)? {
+ if is_impl_single_line(context, items.as_slice(), &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
fn is_impl_single_line(
context: &RewriteContext<'_>,
- items: &[ast::ImplItem],
+ items: &[ptr::P<ast::AssocItem>],
result: &str,
where_clause_str: &str,
item: &ast::Item,
item: &ast::Item,
offset: Indent,
) -> Option<String> {
- if let ast::ItemKind::Impl(
+ if let ast::ItemKind::Impl {
unsafety,
polarity,
defaultness,
ref generics,
- ref trait_ref,
+ of_trait: ref trait_ref,
ref self_ty,
- _,
- ) = item.node
+ ..
+ } = item.kind
{
let mut result = String::with_capacity(128);
result.push_str(format_defaultness(defaultness));
result.push_str(format_unsafety(unsafety));
- let shape = generics_shape_from_config(
- context.config,
- Shape::indented(offset + last_line_width(&result), context.config),
- 0,
- )?;
+ let shape = if context.config.version() == Version::Two {
+ Shape::indented(offset + last_line_width(&result), context.config)
+ } else {
+ 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)?;
result.push_str(&generics_str);
- let polarity_str = if polarity == ast::ImplPolarity::Negative {
- "!"
- } else {
- ""
+ let polarity_str = match polarity {
+ ast::ImplPolarity::Negative(_) => "!",
+ ast::ImplPolarity::Positive => "",
};
if let Some(ref trait_ref) = *trait_ref {
pub(crate) struct StructParts<'a> {
prefix: &'a str,
- ident: ast::Ident,
+ ident: symbol::Ident,
vis: &'a ast::Visibility,
def: &'a ast::VariantData,
generics: Option<&'a ast::Generics>,
}
pub(crate) fn from_item(item: &'a ast::Item) -> Self {
- let (prefix, def, generics) = match item.node {
+ let (prefix, def, generics) = match item.kind {
ast::ItemKind::Struct(ref def, ref generics) => ("struct ", def, generics),
ast::ItemKind::Union(ref def, ref generics) => ("union ", def, generics),
_ => unreachable!(),
ref generics,
ref generic_bounds,
ref trait_items,
- ) = item.node
+ ) = item.kind
{
let mut result = String::with_capacity(128);
let header = format!(
}
}
+struct OpaqueTypeBounds<'a> {
+ generic_bounds: &'a ast::GenericBounds,
+}
+
+impl<'a> Rewrite for OpaqueTypeBounds<'a> {
+ fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+ self.generic_bounds
+ .rewrite(context, shape)
+ .map(|s| format!("impl {}", s))
+ }
+}
+
pub(crate) struct TraitAliasBounds<'a> {
generic_bounds: &'a ast::GenericBounds,
generics: &'a ast::Generics,
pub(crate) fn format_trait_alias(
context: &RewriteContext<'_>,
- ident: ast::Ident,
+ ident: symbol::Ident,
vis: &ast::Visibility,
generics: &ast::Generics,
generic_bounds: &ast::GenericBounds,
}
fn get_bytepos_after_visibility(vis: &ast::Visibility, default_span: Span) -> BytePos {
- match vis.node {
+ match vis.kind {
ast::VisibilityKind::Crate(..) | ast::VisibilityKind::Restricted { .. } => vis.span.hi(),
_ => default_span.lo(),
}
Some(result)
}
-fn rewrite_type_prefix(
+fn rewrite_type<R: Rewrite>(
context: &RewriteContext<'_>,
indent: Indent,
- prefix: &str,
- ident: ast::Ident,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
generics: &ast::Generics,
+ generic_bounds_opt: Option<&ast::GenericBounds>,
+ rhs: Option<&R>,
) -> Option<String> {
let mut result = String::with_capacity(128);
- result.push_str(prefix);
+ result.push_str(&format!("{}type ", format_visibility(context, vis)));
let ident_str = rewrite_ident(context, ident);
- // 2 = `= `
if generics.params.is_empty() {
result.push_str(ident_str)
} else {
+ // 2 = `= `
let g_shape = Shape::indented(indent, context.config)
.offset_left(result.len())?
.sub_width(2)?;
result.push_str(&generics_str);
}
+ if let Some(bounds) = generic_bounds_opt {
+ if !bounds.is_empty() {
+ // 2 = `: `
+ let shape = Shape::indented(indent, context.config).offset_left(result.len() + 2)?;
+ let type_bounds = bounds.rewrite(context, shape).map(|s| format!(": {}", s))?;
+ result.push_str(&type_bounds);
+ }
+ }
+
let where_budget = context.budget(last_line_width(&result));
- let option = WhereClauseOption::snuggled(&result);
+ let mut option = WhereClauseOption::snuggled(&result);
+ if rhs.is_none() {
+ option.suppress_comma();
+ }
let where_clause_str = rewrite_where_clause(
context,
&generics.where_clause,
)?;
result.push_str(&where_clause_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 let Some(ty) = rhs {
+ // If there's a where clause, add a newline before the assignment. Otherwise just add a
+ // space.
+ if !generics.where_clause.predicates.is_empty() {
+ result.push_str(&indent.to_string_with_newline(context.config));
+ } else {
+ result.push(' ');
+ }
+ let lhs = format!("{}=", result);
- if generics.where_clause.predicates.is_empty() {
- result.push_str(suffix);
+ // 1 = `;`
+ let shape = Shape::indented(indent, context.config).sub_width(1)?;
+ rewrite_assign_rhs(context, lhs, &*ty, shape).map(|s| s + ";")
} else {
- result.push_str(&indent.to_string_with_newline(context.config));
- result.push_str(suffix.trim_start());
+ Some(format!("{};", result))
}
-
- // 1 = ";"
- let rhs_shape = Shape::indented(indent, context.config).sub_width(1)?;
- rewrite_assign_rhs(context, result, rhs, rhs_shape).map(|s| s + ";")
-}
-
-pub(crate) 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(crate) fn rewrite_opaque_type(
context: &RewriteContext<'_>,
indent: Indent,
- ident: ast::Ident,
+ ident: symbol::Ident,
generic_bounds: &ast::GenericBounds,
generics: &ast::Generics,
vis: &ast::Visibility,
) -> Option<String> {
- rewrite_type_item(
+ let opaque_type_bounds = OpaqueTypeBounds { generic_bounds };
+ rewrite_type(
context,
indent,
- "type",
- " =",
ident,
- generic_bounds,
- generics,
vis,
+ generics,
+ Some(generic_bounds),
+ Some(&opaque_type_bounds),
)
}
shape,
attrs_extendable,
)?;
- let overhead = last_line_width(&attr_prefix);
+ let overhead = trimmed_last_line_width(&attr_prefix);
let lhs_offset = lhs_max_width.saturating_sub(overhead);
for _ in 0..lhs_offset {
spacing.push(' ');
pub(crate) struct StaticParts<'a> {
prefix: &'a str,
vis: &'a ast::Visibility,
- ident: ast::Ident,
+ ident: symbol::Ident,
ty: &'a ast::Ty,
mutability: ast::Mutability,
expr_opt: Option<&'a ptr::P<ast::Expr>>,
impl<'a> StaticParts<'a> {
pub(crate) fn from_item(item: &'a ast::Item) -> Self {
- let (prefix, ty, mutability, expr) = match item.node {
- ast::ItemKind::Static(ref ty, mutability, ref expr) => ("static", ty, mutability, expr),
- ast::ItemKind::Const(ref ty, ref expr) => {
- ("const", ty, ast::Mutability::Immutable, expr)
+ let (defaultness, prefix, ty, mutability, expr) = match item.kind {
+ ast::ItemKind::Static(ref ty, mutability, ref expr) => {
+ (None, "static", ty, mutability, expr)
+ }
+ ast::ItemKind::Const(defaultness, ref ty, ref expr) => {
+ (Some(defaultness), "const", ty, ast::Mutability::Not, expr)
}
_ => unreachable!(),
};
ident: item.ident,
ty,
mutability,
- expr_opt: Some(expr),
- defaultness: None,
+ expr_opt: expr.as_ref(),
+ defaultness,
span: item.span,
}
}
- pub(crate) fn from_trait_item(ti: &'a ast::TraitItem) -> Self {
- let (ty, expr_opt) = match ti.node {
- ast::TraitItemKind::Const(ref ty, ref expr_opt) => (ty, expr_opt),
+ pub(crate) fn from_trait_item(ti: &'a ast::AssocItem) -> Self {
+ let (defaultness, ty, expr_opt) = match ti.kind {
+ ast::AssocItemKind::Const(defaultness, ref ty, ref expr_opt) => {
+ (defaultness, ty, expr_opt)
+ }
_ => unreachable!(),
};
StaticParts {
vis: &DEFAULT_VISIBILITY,
ident: ti.ident,
ty,
- mutability: ast::Mutability::Immutable,
+ mutability: ast::Mutability::Not,
expr_opt: expr_opt.as_ref(),
- defaultness: None,
+ defaultness: Some(defaultness),
span: ti.span,
}
}
- pub(crate) fn from_impl_item(ii: &'a ast::ImplItem) -> Self {
- let (ty, expr) = match ii.node {
- ast::ImplItemKind::Const(ref ty, ref expr) => (ty, expr),
+ pub(crate) fn from_impl_item(ii: &'a ast::AssocItem) -> Self {
+ let (defaultness, ty, expr) = match ii.kind {
+ ast::AssocItemKind::Const(defaultness, ref ty, ref expr) => (defaultness, ty, expr),
_ => unreachable!(),
};
StaticParts {
vis: &ii.vis,
ident: ii.ident,
ty,
- mutability: ast::Mutability::Immutable,
- expr_opt: Some(expr),
- defaultness: Some(ii.defaultness),
+ mutability: ast::Mutability::Not,
+ expr_opt: expr.as_ref(),
+ defaultness: Some(defaultness),
span: ii.span,
}
}
static_parts.defaultness.map_or("", format_defaultness),
static_parts.prefix,
format_mutability(static_parts.mutability),
- static_parts.ident,
+ rewrite_ident(context, static_parts.ident),
colon,
);
// 2 = " =".len()
}
}
-pub(crate) fn rewrite_associated_type(
- ident: ast::Ident,
+pub(crate) fn rewrite_type_alias(
+ ident: symbol::Ident,
ty_opt: Option<&ptr::P<ast::Ty>>,
generics: &ast::Generics,
generic_bounds_opt: Option<&ast::GenericBounds>,
context: &RewriteContext<'_>,
indent: Indent,
+ vis: &ast::Visibility,
) -> Option<String> {
- 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() {
- String::new()
- } else {
- // 2 = ": ".len()
- let shape = Shape::indented(indent, context.config).offset_left(prefix.len() + 2)?;
- bounds.rewrite(context, shape).map(|s| format!(": {}", s))?
- }
- } else {
- String::new()
- };
-
- if let Some(ty) = ty_opt {
- // 1 = `;`
- let shape = Shape::indented(indent, context.config).sub_width(1)?;
- let lhs = format!("{}{} =", prefix, type_bounds_str);
- rewrite_assign_rhs(context, lhs, &**ty, shape).map(|s| s + ";")
- } else {
- Some(format!("{}{};", prefix, type_bounds_str))
- }
+ rewrite_type(
+ context,
+ indent,
+ ident,
+ vis,
+ generics,
+ generic_bounds_opt,
+ ty_opt,
+ )
}
struct OpaqueType<'a> {
pub(crate) fn rewrite_opaque_impl_type(
context: &RewriteContext<'_>,
- ident: ast::Ident,
+ ident: symbol::Ident,
generics: &ast::Generics,
generic_bounds: &ast::GenericBounds,
indent: Indent,
}
pub(crate) fn rewrite_associated_impl_type(
- ident: ast::Ident,
+ ident: symbol::Ident,
+ vis: &ast::Visibility,
defaultness: ast::Defaultness,
ty_opt: Option<&ptr::P<ast::Ty>>,
generics: &ast::Generics,
context: &RewriteContext<'_>,
indent: Indent,
) -> Option<String> {
- let result = rewrite_associated_type(ident, ty_opt, generics, None, context, indent)?;
+ let result = rewrite_type_alias(ident, ty_opt, generics, None, context, indent, vis)?;
match defaultness {
- ast::Defaultness::Default => Some(format!("default {}", result)),
+ ast::Defaultness::Default(..) => Some(format!("default {}", result)),
_ => Some(result),
}
}
-impl Rewrite for ast::FunctionRetTy {
+impl Rewrite for ast::FnRetTy {
fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
match *self {
- ast::FunctionRetTy::Default(_) => Some(String::new()),
- ast::FunctionRetTy::Ty(ref ty) => {
+ ast::FnRetTy::Default(_) => Some(String::new()),
+ ast::FnRetTy::Ty(ref ty) => {
if context.config.version() == Version::One
|| context.config.indent_style() == IndentStyle::Visual
{
}
fn is_empty_infer(ty: &ast::Ty, pat_span: Span) -> bool {
- match ty.node {
+ match ty.kind {
ast::TyKind::Infer => ty.span.hi() == pat_span.hi(),
_ => false,
}
}
-/// Recover any missing comments between the argument and the type.
+/// Recover any missing comments between the param and the type.
///
/// # Returns
///
/// A 2-len tuple with the comment before the colon in first position, and the comment after the
/// colon in second position.
-fn get_missing_arg_comments(
+fn get_missing_param_comments(
context: &RewriteContext<'_>,
pat_span: Span,
ty_span: Span,
let num_attrs = self.attrs.len();
(
mk_sp(self.attrs[num_attrs - 1].span.hi(), self.pat.span.lo()),
- param_attrs_result.matches("\n").count() > 0,
+ param_attrs_result.contains("\n"),
)
} else {
(mk_sp(self.span.lo(), self.span.lo()), false)
shape,
has_multiple_attr_lines,
)
- } else if is_named_arg(self) {
+ } else if is_named_param(self) {
let mut result = combine_strs_with_missing_comments(
context,
¶m_attrs_result,
if !is_empty_infer(&*self.ty, self.pat.span) {
let (before_comment, after_comment) =
- get_missing_arg_comments(context, self.pat.span, self.ty.span, shape);
+ get_missing_param_comments(context, self.pat.span, self.ty.span, shape);
result.push_str(&before_comment);
result.push_str(colon_spaces(context.config));
result.push_str(&after_comment);
}
}
-pub(crate) fn span_lo_for_arg(arg: &ast::Param) -> BytePos {
- if arg.attrs.is_empty() {
- if is_named_arg(arg) {
- arg.pat.span.lo()
+pub(crate) fn span_lo_for_param(param: &ast::Param) -> BytePos {
+ if param.attrs.is_empty() {
+ if is_named_param(param) {
+ param.pat.span.lo()
} else {
- arg.ty.span.lo()
+ param.ty.span.lo()
}
} else {
- arg.attrs[0].span.lo()
+ param.attrs[0].span.lo()
}
}
-pub(crate) fn span_hi_for_arg(context: &RewriteContext<'_>, arg: &ast::Param) -> BytePos {
- match arg.ty.node {
- ast::TyKind::Infer if context.snippet(arg.ty.span) == "_" => arg.ty.span.hi(),
- ast::TyKind::Infer if is_named_arg(arg) => arg.pat.span.hi(),
- _ => arg.ty.span.hi(),
+pub(crate) fn span_hi_for_param(context: &RewriteContext<'_>, param: &ast::Param) -> BytePos {
+ match param.ty.kind {
+ ast::TyKind::Infer if context.snippet(param.ty.span) == "_" => param.ty.span.hi(),
+ ast::TyKind::Infer if is_named_param(param) => param.pat.span.hi(),
+ _ => param.ty.span.hi(),
}
}
-pub(crate) fn is_named_arg(arg: &ast::Param) -> bool {
- if let ast::PatKind::Ident(_, ident, _) = arg.pat.node {
+pub(crate) fn is_named_param(param: &ast::Param) -> bool {
+ if let ast::PatKind::Ident(_, ident, _) = param.pat.kind {
ident.name != symbol::kw::Invalid
} else {
true
fn rewrite_fn_base(
context: &RewriteContext<'_>,
indent: Indent,
- ident: ast::Ident,
+ ident: symbol::Ident,
fn_sig: &FnSig<'_>,
span: Span,
fn_brace_style: FnBraceStyle,
let multi_line_ret_str = ret_str.contains('\n');
let ret_str_len = if multi_line_ret_str { 0 } else { ret_str.len() };
- // Args.
- let (one_line_budget, multi_line_budget, mut arg_indent) = compute_budgets_for_args(
+ // Params.
+ let (one_line_budget, multi_line_budget, mut param_indent) = compute_budgets_for_params(
context,
&result,
indent,
)?;
debug!(
- "rewrite_fn_base: one_line_budget: {}, multi_line_budget: {}, arg_indent: {:?}",
- one_line_budget, multi_line_budget, arg_indent
+ "rewrite_fn_base: one_line_budget: {}, multi_line_budget: {}, param_indent: {:?}",
+ one_line_budget, multi_line_budget, param_indent
);
result.push('(');
&& !snuggle_angle_bracket
&& context.config.indent_style() == IndentStyle::Visual
{
- result.push_str(&arg_indent.to_string_with_newline(context.config));
+ result.push_str(¶m_indent.to_string_with_newline(context.config));
}
// Skip `pub(crate)`.
let lo_after_visibility = get_bytepos_after_visibility(&fn_sig.visibility, span);
// A conservative estimation, to goal is to be over all parens in generics
- let args_start = fn_sig
+ let params_start = fn_sig
.generics
.params
.iter()
.last()
.map_or(lo_after_visibility, |param| param.span().hi());
- let args_end = if fd.inputs.is_empty() {
+ let params_end = if fd.inputs.is_empty() {
context
.snippet_provider
- .span_after(mk_sp(args_start, span.hi()), ")")
+ .span_after(mk_sp(params_start, span.hi()), ")")
} else {
let last_span = mk_sp(fd.inputs[fd.inputs.len() - 1].span().hi(), span.hi());
context.snippet_provider.span_after(last_span, ")")
};
- let args_span = mk_sp(
+ let params_span = mk_sp(
context
.snippet_provider
- .span_after(mk_sp(args_start, span.hi()), "("),
- args_end,
+ .span_after(mk_sp(params_start, span.hi()), "("),
+ params_end,
);
- let arg_str = rewrite_args(
+ let param_str = rewrite_params(
context,
&fd.inputs,
one_line_budget,
multi_line_budget,
indent,
- arg_indent,
- args_span,
- fd.c_variadic,
+ param_indent,
+ params_span,
+ fd.c_variadic(),
)?;
- let put_args_in_block = match context.config.indent_style() {
- IndentStyle::Block => arg_str.contains('\n') || arg_str.len() > one_line_budget,
+ let put_params_in_block = match context.config.indent_style() {
+ IndentStyle::Block => param_str.contains('\n') || param_str.len() > one_line_budget,
_ => false,
} && !fd.inputs.is_empty();
- let mut args_last_line_contains_comment = false;
- let mut no_args_and_over_max_width = false;
+ let mut params_last_line_contains_comment = false;
+ let mut no_params_and_over_max_width = false;
- if put_args_in_block {
- arg_indent = indent.block_indent(context.config);
- result.push_str(&arg_indent.to_string_with_newline(context.config));
- result.push_str(&arg_str);
+ if put_params_in_block {
+ param_indent = indent.block_indent(context.config);
+ result.push_str(¶m_indent.to_string_with_newline(context.config));
+ result.push_str(¶m_str);
result.push_str(&indent.to_string_with_newline(context.config));
result.push(')');
} else {
- result.push_str(&arg_str);
+ result.push_str(¶m_str);
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 = `)`
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
+ // If the last line of params contains comment, we cannot put the closing paren
// on the same line.
- args_last_line_contains_comment = arg_str
+ params_last_line_contains_comment = param_str
.lines()
.last()
.map_or(false, |last_line| last_line.contains("//"));
if context.config.version() == Version::Two {
- result.push(')');
- if closing_paren_overflow_max_width || args_last_line_contains_comment {
+ if closing_paren_overflow_max_width {
+ result.push(')');
+ result.push_str(&indent.to_string_with_newline(context.config));
+ no_params_and_over_max_width = true;
+ } else if params_last_line_contains_comment {
result.push_str(&indent.to_string_with_newline(context.config));
- no_args_and_over_max_width = true;
+ result.push(')');
+ no_params_and_over_max_width = true;
+ } else {
+ result.push(')');
}
} else {
- if closing_paren_overflow_max_width || args_last_line_contains_comment {
+ if closing_paren_overflow_max_width || params_last_line_contains_comment {
result.push_str(&indent.to_string_with_newline(context.config));
}
result.push(')');
}
// Return type.
- if let ast::FunctionRetTy::Ty(..) = fd.output {
+ if let ast::FnRetTy::Ty(..) = fd.output {
let ret_should_indent = match context.config.indent_style() {
- // If our args are block layout then we surely must have space.
- IndentStyle::Block if put_args_in_block || fd.inputs.is_empty() => false,
- _ if args_last_line_contains_comment => false,
+ // If our params are block layout then we surely must have space.
+ IndentStyle::Block if put_params_in_block || fd.inputs.is_empty() => false,
+ _ if params_last_line_contains_comment => false,
_ if result.contains('\n') || multi_line_ret_str => true,
_ => {
// If the return type would push over the max width, then put the return type on
// a new line. With the +1 for the signature length an additional space between
- // the closing parenthesis of the argument and the arrow '->' is considered.
+ // the closing parenthesis of the param and the arrow '->' is considered.
let mut sig_length = result.len() + indent.width() + ret_str_len + 1;
// If there is no where-clause, take into account the space after the return type
if context.config.version() == Version::One
|| context.config.indent_style() == IndentStyle::Visual
{
- let indent = if arg_str.is_empty() {
- // Aligning with non-existent args looks silly.
+ let indent = if param_str.is_empty() {
+ // Aligning with non-existent params looks silly.
force_new_line_for_brace = true;
indent + 4
} else {
- // FIXME: we might want to check that using the arg indent
+ // FIXME: we might want to check that using the param indent
// doesn't blow our budget, and if it does, then fallback to
// the where-clause indent.
- arg_indent
+ param_indent
};
result.push_str(&indent.to_string_with_newline(context.config));
Shape::indented(indent, context.config)
} else {
let mut ret_shape = Shape::indented(indent, context.config);
- if arg_str.is_empty() {
- // Aligning with non-existent args looks silly.
+ if param_str.is_empty() {
+ // Aligning with non-existent params looks silly.
force_new_line_for_brace = true;
ret_shape = if context.use_block_indent() {
ret_shape.offset_left(4).unwrap_or(ret_shape)
}
} else {
if context.config.version() == Version::Two {
- if !arg_str.is_empty() || !no_args_and_over_max_width {
+ if !param_str.is_empty() || !no_params_and_over_max_width {
result.push(' ');
}
} else {
}
let pos_before_where = match fd.output {
- ast::FunctionRetTy::Default(..) => args_span.hi(),
- ast::FunctionRetTy::Ty(ref ty) => ty.span.hi(),
+ ast::FnRetTy::Default(..) => params_span.hi(),
+ ast::FnRetTy::Ty(ref ty) => ty.span.hi(),
};
- let is_args_multi_lined = arg_str.contains('\n');
+ let is_params_multi_lined = param_str.contains('\n');
- let space = if put_args_in_block && ret_str.is_empty() {
+ let space = if put_params_in_block && ret_str.is_empty() {
WhereClauseSpace::Space
} else {
WhereClauseSpace::Newline
};
let mut option = WhereClauseOption::new(fn_brace_style == FnBraceStyle::None, space);
- if is_args_multi_lined {
+ if is_params_multi_lined {
option.veto_single_line();
}
let where_clause_str = rewrite_where_clause(
option,
)?;
// If there are neither where-clause nor return type, we may be missing comments between
- // args and `{`.
+ // params and `{`.
if where_clause_str.is_empty() {
- if let ast::FunctionRetTy::Default(ret_span) = fd.output {
+ if let ast::FnRetTy::Default(ret_span) = fd.output {
match recover_missing_comment_in_span(
- mk_sp(args_span.hi(), ret_span.hi()),
+ mk_sp(params_span.hi(), ret_span.hi()),
shape,
context,
last_line_width(&result),
result.push_str(&where_clause_str);
force_new_line_for_brace |= last_line_contains_single_line_comment(&result);
- force_new_line_for_brace |= is_args_multi_lined && context.config.where_single_line();
+ force_new_line_for_brace |=
+ is_params_multi_lined && context.config.where_single_line() && !where_clause_str.is_empty();
Some((result, force_new_line_for_brace))
}
}
}
-fn rewrite_args(
+fn rewrite_params(
context: &RewriteContext<'_>,
- args: &[ast::Param],
+ params: &[ast::Param],
one_line_budget: usize,
multi_line_budget: usize,
indent: Indent,
- arg_indent: Indent,
+ param_indent: Indent,
span: Span,
variadic: bool,
) -> Option<String> {
- if args.is_empty() {
+ if params.is_empty() {
let comment = context
.snippet(mk_sp(
span.lo(),
.trim();
return Some(comment.to_owned());
}
- let arg_items: Vec<_> = itemize_list(
+ let param_items: Vec<_> = itemize_list(
context.snippet_provider,
- args.iter(),
+ params.iter(),
")",
",",
- |arg| span_lo_for_arg(arg),
- |arg| arg.ty.span.hi(),
- |arg| {
- arg.rewrite(context, Shape::legacy(multi_line_budget, arg_indent))
- .or_else(|| Some(context.snippet(arg.span()).to_owned()))
+ |param| span_lo_for_param(param),
+ |param| param.ty.span.hi(),
+ |param| {
+ param
+ .rewrite(context, Shape::legacy(multi_line_budget, param_indent))
+ .or_else(|| Some(context.snippet(param.span()).to_owned()))
},
span.lo(),
span.hi(),
.collect();
let tactic = definitive_tactic(
- &arg_items,
+ ¶m_items,
context
.config
.fn_args_layout()
- .to_list_tactic(arg_items.len()),
+ .to_list_tactic(param_items.len()),
Separator::Comma,
one_line_budget,
);
};
let indent = match context.config.indent_style() {
IndentStyle::Block => indent.block_indent(context.config),
- IndentStyle::Visual => arg_indent,
+ IndentStyle::Visual => param_indent,
};
let trailing_separator = if variadic {
SeparatorTactic::Never
.trailing_separator(trailing_separator)
.ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
.preserve_newline(true);
- write_list(&arg_items, &fmt)
+ write_list(¶m_items, &fmt)
}
-fn compute_budgets_for_args(
+fn compute_budgets_for_params(
context: &RewriteContext<'_>,
result: &str,
indent: Indent,
ret_str_len: usize,
fn_brace_style: FnBraceStyle,
force_vertical_layout: bool,
-) -> Option<((usize, usize, Indent))> {
+) -> Option<(usize, usize, Indent)> {
debug!(
- "compute_budgets_for_args {} {:?}, {}, {:?}",
+ "compute_budgets_for_params {} {:?}, {}, {:?}",
result.len(),
indent,
ret_str_len,
}
}
- // Didn't work. we must force vertical layout and put args on a newline.
+ // Didn't work. we must force vertical layout and put params on a newline.
let new_indent = indent.block_indent(context.config);
let used_space = match context.config.indent_style() {
// 1 = `,`
overflow::rewrite_with_angle_brackets(context, ident, params, shape, generics.span)
}
-pub(crate) fn generics_shape_from_config(
- config: &Config,
- shape: Shape,
- offset: usize,
-) -> Option<Shape> {
+fn generics_shape_from_config(config: &Config, shape: Shape, offset: usize) -> Option<Shape> {
match config.indent_style() {
IndentStyle::Visual => shape.visual_indent(1 + offset).sub_width(offset + 2),
IndentStyle::Block => {
fn format_header(
context: &RewriteContext<'_>,
item_name: &str,
- ident: ast::Ident,
+ ident: symbol::Ident,
vis: &ast::Visibility,
) -> String {
format!(
// FIXME: this may be a faulty span from libsyntax.
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(
+ let item_str = match self.kind {
+ ast::ForeignItemKind::Fn(_, ref fn_sig, ref generics, _) => rewrite_fn_base(
context,
shape.indent,
self.ident,
- &FnSig::new(fn_decl, generics, self.vis.clone()),
+ &FnSig::new(&fn_sig.decl, generics, self.vis.clone()),
span,
FnBraceStyle::None,
)
.map(|(s, _)| format!("{};", s)),
- ast::ForeignItemKind::Static(ref ty, mutability) => {
+ ast::ForeignItemKind::Static(ref ty, mutability, _) => {
// FIXME(#21): we're dropping potential comments in between the
// function kw here.
let vis = format_visibility(context, &self.vis);
// 1 = ;
rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
}
- ast::ForeignItemKind::Ty => {
- let vis = format_visibility(context, &self.vis);
- Some(format!(
- "{}type {};",
- vis,
- rewrite_ident(context, self.ident)
- ))
- }
- ast::ForeignItemKind::Macro(ref mac) => {
+ ast::ForeignItemKind::TyAlias(
+ _,
+ ref generics,
+ ref generic_bounds,
+ ref type_default,
+ ) => rewrite_type_alias(
+ self.ident,
+ type_default.as_ref(),
+ generics,
+ Some(generic_bounds),
+ &context,
+ shape.indent,
+ &self.vis,
+ ),
+ ast::ForeignItemKind::MacCall(ref mac) => {
rewrite_macro(mac, None, context, shape, MacroPosition::Item)
}
}?;
let allow_extend = if attrs.len() == 1 {
let line_len = attrs_str.len() + 1 + item_str.len();
- !attrs.first().unwrap().is_sugared_doc
+ !attrs.first().unwrap().is_doc_comment()
&& context.config.inline_attribute_width() >= line_len
} else {
false
/// Returns `true` for `mod foo;`, false for `mod foo { .. }`.
pub(crate) fn is_mod_decl(item: &ast::Item) -> bool {
- match item.node {
+ match item.kind {
ast::ItemKind::Mod(ref m) => m.inner.hi() != item.span.hi(),
_ => false,
}
}
pub(crate) fn is_use_item(item: &ast::Item) -> bool {
- match item.node {
+ match item.kind {
ast::ItemKind::Use(_) => true,
_ => false,
}
}
pub(crate) fn is_extern_crate(item: &ast::Item) -> bool {
- match item.node {
+ match item.kind {
ast::ItemKind::ExternCrate(..) => true,
_ => false,
}
projects / rust.git / blobdiff