src/items.rs

   1 // Formatting top-level items - functions, structs, enums, traits, impls.
   2
   3 use std::borrow::Cow;
   4 use std::cmp::{max, min, Ordering};
   5
   6 use regex::Regex;
   7 use rustc_span::{source_map, symbol, BytePos, Span, DUMMY_SP};
   8 use syntax::visit;
   9 use syntax::{ast, ptr};
  10
  11 use crate::attr::filter_inline_attrs;
  12 use crate::comment::{
  13     combine_strs_with_missing_comments, contains_comment, is_last_comment_block,
  14     recover_comment_removed, recover_missing_comment_in_span, rewrite_missing_comment,
  15     FindUncommented,
  16 };
  17 use crate::config::lists::*;
  18 use crate::config::{BraceStyle, Config, IndentStyle, Version};
  19 use crate::expr::{
  20     is_empty_block, is_simple_block_stmt, rewrite_assign_rhs, rewrite_assign_rhs_with, RhsTactics,
  21 };
  22 use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
  23 use crate::macros::{rewrite_macro, MacroPosition};
  24 use crate::overflow;
  25 use crate::rewrite::{Rewrite, RewriteContext};
  26 use crate::shape::{Indent, Shape};
  27 use crate::source_map::{LineRangeUtils, SpanUtils};
  28 use crate::spanned::Spanned;
  29 use crate::stmt::Stmt;
  30 use crate::utils::*;
  31 use crate::vertical::rewrite_with_alignment;
  32 use crate::visitor::FmtVisitor;
  33
  34 const DEFAULT_VISIBILITY: ast::Visibility = source_map::Spanned {
  35     node: ast::VisibilityKind::Inherited,
  36     span: DUMMY_SP,
  37 };
  38
  39 fn type_annotation_separator(config: &Config) -> &str {
  40     colon_spaces(config)
  41 }
  42
  43 // Statements of the form
  44 // let pat: ty = init;
  45 impl Rewrite for ast::Local {
  46     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
  47         debug!(
  48             "Local::rewrite {:?} {} {:?}",
  49             self, shape.width, shape.indent
  50         );
  51
  52         skip_out_of_file_lines_range!(context, self.span);
  53
  54         if contains_skip(&self.attrs) {
  55             return None;
  56         }
  57
  58         let attrs_str = self.attrs.rewrite(context, shape)?;
  59         let mut result = if attrs_str.is_empty() {
  60             "let ".to_owned()
  61         } else {
  62             combine_strs_with_missing_comments(
  63                 context,
  64                 &attrs_str,
  65                 "let ",
  66                 mk_sp(
  67                     self.attrs.last().map(|a| a.span.hi()).unwrap(),
  68                     self.span.lo(),
  69                 ),
  70                 shape,
  71                 false,
  72             )?
  73         };
  74
  75         // 4 = "let ".len()
  76         let pat_shape = shape.offset_left(4)?;
  77         // 1 = ;
  78         let pat_shape = pat_shape.sub_width(1)?;
  79         let pat_str = self.pat.rewrite(context, pat_shape)?;
  80         result.push_str(&pat_str);
  81
  82         // String that is placed within the assignment pattern and expression.
  83         let infix = {
  84             let mut infix = String::with_capacity(32);
  85
  86             if let Some(ref ty) = self.ty {
  87                 let separator = type_annotation_separator(context.config);
  88                 let ty_shape = if pat_str.contains('\n') {
  89                     shape.with_max_width(context.config)
  90                 } else {
  91                     shape
  92                 }
  93                 .offset_left(last_line_width(&result) + separator.len())?
  94                 // 2 = ` =`
  95                 .sub_width(2)?;
  96
  97                 let rewrite = ty.rewrite(context, ty_shape)?;
  98
  99                 infix.push_str(separator);
 100                 infix.push_str(&rewrite);
 101             }
 102
 103             if self.init.is_some() {
 104                 infix.push_str(" =");
 105             }
 106
 107             infix
 108         };
 109
 110         result.push_str(&infix);
 111
 112         if let Some(ref ex) = self.init {
 113             // 1 = trailing semicolon;
 114             let nested_shape = shape.sub_width(1)?;
 115
 116             result = rewrite_assign_rhs(context, result, &**ex, nested_shape)?;
 117         }
 118
 119         result.push(';');
 120         Some(result)
 121     }
 122 }
 123
 124 // FIXME convert to using rewrite style rather than visitor
 125 // FIXME format modules in this style
 126 #[allow(dead_code)]
 127 struct Item<'a> {
 128     keyword: &'static str,
 129     abi: Cow<'static, str>,
 130     vis: Option<&'a ast::Visibility>,
 131     body: Vec<BodyElement<'a>>,
 132     span: Span,
 133 }
 134
 135 impl<'a> Item<'a> {
 136     fn from_foreign_mod(fm: &'a ast::ForeignMod, span: Span, config: &Config) -> Item<'a> {
 137         Item {
 138             keyword: "",
 139             abi: format_extern(
 140                 ast::Extern::from_abi(fm.abi),
 141                 config.force_explicit_abi(),
 142                 true,
 143             ),
 144             vis: None,
 145             body: fm
 146                 .items
 147                 .iter()
 148                 .map(|i| BodyElement::ForeignItem(i))
 149                 .collect(),
 150             span,
 151         }
 152     }
 153 }
 154
 155 enum BodyElement<'a> {
 156     // Stmt(&'a ast::Stmt),
 157     // Field(&'a ast::Field),
 158     // Variant(&'a ast::Variant),
 159     // Item(&'a ast::Item),
 160     ForeignItem(&'a ast::ForeignItem),
 161 }
 162
 163 /// Represents a fn's signature.
 164 pub(crate) struct FnSig<'a> {
 165     decl: &'a ast::FnDecl,
 166     generics: &'a ast::Generics,
 167     ext: ast::Extern,
 168     is_async: Cow<'a, ast::Async>,
 169     constness: ast::Const,
 170     defaultness: ast::Defaultness,
 171     unsafety: ast::Unsafe,
 172     visibility: ast::Visibility,
 173 }
 174
 175 impl<'a> FnSig<'a> {
 176     pub(crate) fn new(
 177         decl: &'a ast::FnDecl,
 178         generics: &'a ast::Generics,
 179         vis: ast::Visibility,
 180     ) -> FnSig<'a> {
 181         FnSig {
 182             decl,
 183             generics,
 184             ext: ast::Extern::None,
 185             is_async: Cow::Owned(ast::Async::No),
 186             constness: ast::Const::No,
 187             defaultness: ast::Defaultness::Final,
 188             unsafety: ast::Unsafe::No,
 189             visibility: vis,
 190         }
 191     }
 192
 193     pub(crate) fn from_method_sig(
 194         method_sig: &'a ast::FnSig,
 195         generics: &'a ast::Generics,
 196     ) -> FnSig<'a> {
 197         FnSig {
 198             unsafety: method_sig.header.unsafety,
 199             is_async: Cow::Borrowed(&method_sig.header.asyncness),
 200             constness: method_sig.header.constness,
 201             defaultness: ast::Defaultness::Final,
 202             ext: method_sig.header.ext,
 203             decl: &*method_sig.decl,
 204             generics,
 205             visibility: DEFAULT_VISIBILITY,
 206         }
 207     }
 208
 209     pub(crate) fn from_fn_kind(
 210         fn_kind: &'a visit::FnKind<'_>,
 211         generics: &'a ast::Generics,
 212         decl: &'a ast::FnDecl,
 213         defaultness: ast::Defaultness,
 214     ) -> FnSig<'a> {
 215         match *fn_kind {
 216             visit::FnKind::Fn(fn_ctxt, _, fn_sig, vis, _) => match fn_ctxt {
 217                 visit::FnCtxt::Assoc(..) => {
 218                     let mut fn_sig = FnSig::from_method_sig(fn_sig, generics);
 219                     fn_sig.defaultness = defaultness;
 220                     fn_sig.visibility = vis.clone();
 221                     fn_sig
 222                 }
 223                 _ => FnSig {
 224                     decl,
 225                     generics,
 226                     ext: fn_sig.header.ext,
 227                     constness: fn_sig.header.constness,
 228                     is_async: Cow::Borrowed(&fn_sig.header.asyncness),
 229                     defaultness,
 230                     unsafety: fn_sig.header.unsafety,
 231                     visibility: vis.clone(),
 232                 },
 233             },
 234             _ => unreachable!(),
 235         }
 236     }
 237
 238     fn to_str(&self, context: &RewriteContext<'_>) -> String {
 239         let mut result = String::with_capacity(128);
 240         // Vis defaultness constness unsafety abi.
 241         result.push_str(&*format_visibility(context, &self.visibility));
 242         result.push_str(format_defaultness(self.defaultness));
 243         result.push_str(format_constness(self.constness));
 244         result.push_str(format_async(&self.is_async));
 245         result.push_str(format_unsafety(self.unsafety));
 246         result.push_str(&format_extern(
 247             self.ext,
 248             context.config.force_explicit_abi(),
 249             false,
 250         ));
 251         result
 252     }
 253 }
 254
 255 impl<'a> FmtVisitor<'a> {
 256     fn format_item(&mut self, item: &Item<'_>) {
 257         self.buffer.push_str(&item.abi);
 258
 259         let snippet = self.snippet(item.span);
 260         let brace_pos = snippet.find_uncommented("{").unwrap();
 261
 262         self.push_str("{");
 263         if !item.body.is_empty() || contains_comment(&snippet[brace_pos..]) {
 264             // FIXME: this skips comments between the extern keyword and the opening
 265             // brace.
 266             self.last_pos = item.span.lo() + BytePos(brace_pos as u32 + 1);
 267             self.block_indent = self.block_indent.block_indent(self.config);
 268
 269             if item.body.is_empty() {
 270                 self.format_missing_no_indent(item.span.hi() - BytePos(1));
 271                 self.block_indent = self.block_indent.block_unindent(self.config);
 272                 let indent_str = self.block_indent.to_string(self.config);
 273                 self.push_str(&indent_str);
 274             } else {
 275                 for item in &item.body {
 276                     self.format_body_element(item);
 277                 }
 278
 279                 self.block_indent = self.block_indent.block_unindent(self.config);
 280                 self.format_missing_with_indent(item.span.hi() - BytePos(1));
 281             }
 282         }
 283
 284         self.push_str("}");
 285         self.last_pos = item.span.hi();
 286     }
 287
 288     fn format_body_element(&mut self, element: &BodyElement<'_>) {
 289         match *element {
 290             BodyElement::ForeignItem(item) => self.format_foreign_item(item),
 291         }
 292     }
 293
 294     pub(crate) fn format_foreign_mod(&mut self, fm: &ast::ForeignMod, span: Span) {
 295         let item = Item::from_foreign_mod(fm, span, self.config);
 296         self.format_item(&item);
 297     }
 298
 299     fn format_foreign_item(&mut self, item: &ast::ForeignItem) {
 300         let rewrite = item.rewrite(&self.get_context(), self.shape());
 301         self.push_rewrite(item.span, rewrite);
 302         self.last_pos = item.span.hi();
 303     }
 304
 305     pub(crate) fn rewrite_fn_before_block(
 306         &mut self,
 307         indent: Indent,
 308         ident: ast::Ident,
 309         fn_sig: &FnSig<'_>,
 310         span: Span,
 311     ) -> Option<(String, FnBraceStyle)> {
 312         let context = self.get_context();
 313
 314         let mut fn_brace_style = newline_for_brace(self.config, &fn_sig.generics.where_clause);
 315         let (result, force_newline_brace) =
 316             rewrite_fn_base(&context, indent, ident, fn_sig, span, fn_brace_style)?;
 317
 318         // 2 = ` {`
 319         if self.config.brace_style() == BraceStyle::AlwaysNextLine
 320             || force_newline_brace
 321             || last_line_width(&result) + 2 > self.shape().width
 322         {
 323             fn_brace_style = FnBraceStyle::NextLine
 324         }
 325
 326         Some((result, fn_brace_style))
 327     }
 328
 329     pub(crate) fn rewrite_required_fn(
 330         &mut self,
 331         indent: Indent,
 332         ident: ast::Ident,
 333         sig: &ast::FnSig,
 334         generics: &ast::Generics,
 335         span: Span,
 336     ) -> Option<String> {
 337         // Drop semicolon or it will be interpreted as comment.
 338         let span = mk_sp(span.lo(), span.hi() - BytePos(1));
 339         let context = self.get_context();
 340
 341         let (mut result, _) = rewrite_fn_base(
 342             &context,
 343             indent,
 344             ident,
 345             &FnSig::from_method_sig(sig, generics),
 346             span,
 347             FnBraceStyle::None,
 348         )?;
 349
 350         // Re-attach semicolon
 351         result.push(';');
 352
 353         Some(result)
 354     }
 355
 356     pub(crate) fn single_line_fn(
 357         &self,
 358         fn_str: &str,
 359         block: &ast::Block,
 360         inner_attrs: Option<&[ast::Attribute]>,
 361     ) -> Option<String> {
 362         if fn_str.contains('\n') || inner_attrs.map_or(false, |a| !a.is_empty()) {
 363             return None;
 364         }
 365
 366         let source_map = self.get_context().source_map;
 367
 368         if self.config.empty_item_single_line()
 369             && is_empty_block(block, None, source_map)
 370             && self.block_indent.width() + fn_str.len() + 3 <= self.config.max_width()
 371             && !last_line_contains_single_line_comment(fn_str)
 372         {
 373             return Some(format!("{} {{}}", fn_str));
 374         }
 375
 376         if !self.config.fn_single_line() || !is_simple_block_stmt(block, None, source_map) {
 377             return None;
 378         }
 379
 380         let res = Stmt::from_ast_node(block.stmts.first()?, true)
 381             .rewrite(&self.get_context(), self.shape())?;
 382
 383         let width = self.block_indent.width() + fn_str.len() + res.len() + 5;
 384         if !res.contains('\n') && width <= self.config.max_width() {
 385             Some(format!("{} {{ {} }}", fn_str, res))
 386         } else {
 387             None
 388         }
 389     }
 390
 391     pub(crate) fn visit_static(&mut self, static_parts: &StaticParts<'_>) {
 392         let rewrite = rewrite_static(&self.get_context(), static_parts, self.block_indent);
 393         self.push_rewrite(static_parts.span, rewrite);
 394     }
 395
 396     pub(crate) fn visit_struct(&mut self, struct_parts: &StructParts<'_>) {
 397         let is_tuple = match struct_parts.def {
 398             ast::VariantData::Tuple(..) => true,
 399             _ => false,
 400         };
 401         let rewrite = format_struct(&self.get_context(), struct_parts, self.block_indent, None)
 402             .map(|s| if is_tuple { s + ";" } else { s });
 403         self.push_rewrite(struct_parts.span, rewrite);
 404     }
 405
 406     pub(crate) fn visit_enum(
 407         &mut self,
 408         ident: ast::Ident,
 409         vis: &ast::Visibility,
 410         enum_def: &ast::EnumDef,
 411         generics: &ast::Generics,
 412         span: Span,
 413     ) {
 414         let enum_header = format_header(&self.get_context(), "enum ", ident, vis);
 415         self.push_str(&enum_header);
 416
 417         let enum_snippet = self.snippet(span);
 418         let brace_pos = enum_snippet.find_uncommented("{").unwrap();
 419         let body_start = span.lo() + BytePos(brace_pos as u32 + 1);
 420         let generics_str = format_generics(
 421             &self.get_context(),
 422             generics,
 423             self.config.brace_style(),
 424             if enum_def.variants.is_empty() {
 425                 BracePos::ForceSameLine
 426             } else {
 427                 BracePos::Auto
 428             },
 429             self.block_indent,
 430             // make a span that starts right after `enum Foo`
 431             mk_sp(ident.span.hi(), body_start),
 432             last_line_width(&enum_header),
 433         )
 434         .unwrap();
 435         self.push_str(&generics_str);
 436
 437         self.last_pos = body_start;
 438
 439         match self.format_variant_list(enum_def, body_start, span.hi()) {
 440             Some(ref s) if enum_def.variants.is_empty() => self.push_str(s),
 441             rw => {
 442                 self.push_rewrite(mk_sp(body_start, span.hi()), rw);
 443                 self.block_indent = self.block_indent.block_unindent(self.config);
 444             }
 445         }
 446     }
 447
 448     // Format the body of an enum definition
 449     fn format_variant_list(
 450         &mut self,
 451         enum_def: &ast::EnumDef,
 452         body_lo: BytePos,
 453         body_hi: BytePos,
 454     ) -> Option<String> {
 455         if enum_def.variants.is_empty() {
 456             let mut buffer = String::with_capacity(128);
 457             // 1 = "}"
 458             let span = mk_sp(body_lo, body_hi - BytePos(1));
 459             format_empty_struct_or_tuple(
 460                 &self.get_context(),
 461                 span,
 462                 self.block_indent,
 463                 &mut buffer,
 464                 "",
 465                 "}",
 466             );
 467             return Some(buffer);
 468         }
 469         let mut result = String::with_capacity(1024);
 470         let original_offset = self.block_indent;
 471         self.block_indent = self.block_indent.block_indent(self.config);
 472
 473         // If enum variants have discriminants, try to vertically align those,
 474         // provided the discrims are not shifted too much  to the right
 475         let align_threshold: usize = self.config.enum_discrim_align_threshold();
 476         let discr_ident_lens: Vec<usize> = enum_def
 477             .variants
 478             .iter()
 479             .filter(|var| var.disr_expr.is_some())
 480             .map(|var| rewrite_ident(&self.get_context(), var.ident).len())
 481             .collect();
 482         // cut the list at the point of longest discrim shorter than the threshold
 483         // All of the discrims under the threshold will get padded, and all above - left as is.
 484         let pad_discrim_ident_to = *discr_ident_lens
 485             .iter()
 486             .filter(|&l| *l <= align_threshold)
 487             .max()
 488             .unwrap_or(&0);
 489
 490         let itemize_list_with = |one_line_width: usize| {
 491             itemize_list(
 492                 self.snippet_provider,
 493                 enum_def.variants.iter(),
 494                 "}",
 495                 ",",
 496                 |f| {
 497                     if !f.attrs.is_empty() {
 498                         f.attrs[0].span.lo()
 499                     } else {
 500                         f.span.lo()
 501                     }
 502                 },
 503                 |f| f.span.hi(),
 504                 |f| self.format_variant(f, one_line_width, pad_discrim_ident_to),
 505                 body_lo,
 506                 body_hi,
 507                 false,
 508             )
 509             .collect()
 510         };
 511         let mut items: Vec<_> =
 512             itemize_list_with(self.config.width_heuristics().struct_variant_width);
 513         // If one of the variants use multiple lines, use multi-lined formatting for all variants.
 514         let has_multiline_variant = items.iter().any(|item| item.inner_as_ref().contains('\n'));
 515         let has_single_line_variant = items.iter().any(|item| !item.inner_as_ref().contains('\n'));
 516         if has_multiline_variant && has_single_line_variant {
 517             items = itemize_list_with(0);
 518         }
 519
 520         let shape = self.shape().sub_width(2)?;
 521         let fmt = ListFormatting::new(shape, self.config)
 522             .trailing_separator(self.config.trailing_comma())
 523             .preserve_newline(true);
 524
 525         let list = write_list(&items, &fmt)?;
 526         result.push_str(&list);
 527         result.push_str(&original_offset.to_string_with_newline(self.config));
 528         result.push('}');
 529         Some(result)
 530     }
 531
 532     // Variant of an enum.
 533     fn format_variant(
 534         &self,
 535         field: &ast::Variant,
 536         one_line_width: usize,
 537         pad_discrim_ident_to: usize,
 538     ) -> Option<String> {
 539         if contains_skip(&field.attrs) {
 540             let lo = field.attrs[0].span.lo();
 541             let span = mk_sp(lo, field.span.hi());
 542             return Some(self.snippet(span).to_owned());
 543         }
 544
 545         let context = self.get_context();
 546         // 1 = ','
 547         let shape = self.shape().sub_width(1)?;
 548         let attrs_str = field.attrs.rewrite(&context, shape)?;
 549         let lo = field
 550             .attrs
 551             .last()
 552             .map_or(field.span.lo(), |attr| attr.span.hi());
 553         let span = mk_sp(lo, field.span.lo());
 554
 555         let variant_body = match field.data {
 556             ast::VariantData::Tuple(..) | ast::VariantData::Struct(..) => format_struct(
 557                 &context,
 558                 &StructParts::from_variant(field),
 559                 self.block_indent,
 560                 Some(one_line_width),
 561             )?,
 562             ast::VariantData::Unit(..) => rewrite_ident(&context, field.ident).to_owned(),
 563         };
 564
 565         let variant_body = if let Some(ref expr) = field.disr_expr {
 566             let lhs = format!("{:1$} =", variant_body, pad_discrim_ident_to);
 567             rewrite_assign_rhs_with(
 568                 &context,
 569                 lhs,
 570                 &*expr.value,
 571                 shape,
 572                 RhsTactics::AllowOverflow,
 573             )?
 574         } else {
 575             variant_body
 576         };
 577
 578         combine_strs_with_missing_comments(&context, &attrs_str, &variant_body, span, shape, false)
 579     }
 580
 581     fn visit_impl_items(&mut self, items: &[ptr::P<ast::AssocItem>]) {
 582         if self.get_context().config.reorder_impl_items() {
 583             // Create visitor for each items, then reorder them.
 584             let mut buffer = vec![];
 585             for item in items {
 586                 self.visit_impl_item(item);
 587                 buffer.push((self.buffer.clone(), item.clone()));
 588                 self.buffer.clear();
 589             }
 590
 591             fn is_type(ty: &Option<syntax::ptr::P<ast::Ty>>) -> bool {
 592                 match ty {
 593                     None => true,
 594                     Some(lty) => match lty.kind.opaque_top_hack() {
 595                         None => true,
 596                         Some(_) => false,
 597                     },
 598                 }
 599             }
 600
 601             fn is_opaque(ty: &Option<syntax::ptr::P<ast::Ty>>) -> bool {
 602                 match ty {
 603                     None => false,
 604                     Some(lty) => match lty.kind.opaque_top_hack() {
 605                         None => false,
 606                         Some(_) => true,
 607                     },
 608                 }
 609             }
 610
 611             fn both_type(
 612                 a: &Option<syntax::ptr::P<ast::Ty>>,
 613                 b: &Option<syntax::ptr::P<ast::Ty>>,
 614             ) -> bool {
 615                 is_type(a) && is_type(b)
 616             }
 617
 618             fn both_opaque(
 619                 a: &Option<syntax::ptr::P<ast::Ty>>,
 620                 b: &Option<syntax::ptr::P<ast::Ty>>,
 621             ) -> bool {
 622                 is_opaque(a) && is_opaque(b)
 623             }
 624
 625             // In rustc-ap-v638 the `OpaqueTy` AssocItemKind variant was removed but
 626             // we still need to differentiate to maintain sorting order.
 627
 628             // type -> opaque -> const -> macro -> method
 629             use crate::ast::AssocItemKind::*;
 630             fn need_empty_line(a: &ast::AssocItemKind, b: &ast::AssocItemKind) -> bool {
 631                 match (a, b) {
 632                     (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
 633                         if both_type(lty, rty) || both_opaque(lty, rty) =>
 634                     {
 635                         false
 636                     }
 637                     (Const(..), Const(..)) => false,
 638                     _ => true,
 639                 }
 640             }
 641
 642             buffer.sort_by(|(_, a), (_, b)| match (&a.kind, &b.kind) {
 643                 (TyAlias(_, _, _, ref lty), TyAlias(_, _, _, ref rty))
 644                     if both_type(lty, rty) || both_opaque(lty, rty) =>
 645                 {
 646                     a.ident.as_str().cmp(&b.ident.as_str())
 647                 }
 648                 (Const(..), Const(..)) | (Macro(..), Macro(..)) => {
 649                     a.ident.as_str().cmp(&b.ident.as_str())
 650                 }
 651                 (Fn(..), Fn(..)) => a.span.lo().cmp(&b.span.lo()),
 652                 (TyAlias(_, _, _, ref ty), _) if is_type(ty) => Ordering::Less,
 653                 (_, TyAlias(_, _, _, ref ty)) if is_type(ty) => Ordering::Greater,
 654                 (TyAlias(..), _) => Ordering::Less,
 655                 (_, TyAlias(..)) => Ordering::Greater,
 656                 (Const(..), _) => Ordering::Less,
 657                 (_, Const(..)) => Ordering::Greater,
 658                 (Macro(..), _) => Ordering::Less,
 659                 (_, Macro(..)) => Ordering::Greater,
 660             });
 661             let mut prev_kind = None;
 662             for (buf, item) in buffer {
 663                 // Make sure that there are at least a single empty line between
 664                 // different impl items.
 665                 if prev_kind
 666                     .as_ref()
 667                     .map_or(false, |prev_kind| need_empty_line(prev_kind, &item.kind))
 668                 {
 669                     self.push_str("\n");
 670                 }
 671                 let indent_str = self.block_indent.to_string_with_newline(self.config);
 672                 self.push_str(&indent_str);
 673                 self.push_str(buf.trim());
 674                 prev_kind = Some(item.kind.clone());
 675             }
 676         } else {
 677             for item in items {
 678                 self.visit_impl_item(item);
 679             }
 680         }
 681     }
 682 }
 683
 684 pub(crate) fn format_impl(
 685     context: &RewriteContext<'_>,
 686     item: &ast::Item,
 687     offset: Indent,
 688 ) -> Option<String> {
 689     if let ast::ItemKind::Impl {
 690         ref generics,
 691         ref self_ty,
 692         ref items,
 693         ..
 694     } = item.kind
 695     {
 696         let mut result = String::with_capacity(128);
 697         let ref_and_type = format_impl_ref_and_type(context, item, offset)?;
 698         let sep = offset.to_string_with_newline(context.config);
 699         result.push_str(&ref_and_type);
 700
 701         let where_budget = if result.contains('\n') {
 702             context.config.max_width()
 703         } else {
 704             context.budget(last_line_width(&result))
 705         };
 706
 707         let mut option = WhereClauseOption::snuggled(&ref_and_type);
 708         let snippet = context.snippet(item.span);
 709         let open_pos = snippet.find_uncommented("{")? + 1;
 710         if !contains_comment(&snippet[open_pos..])
 711             && items.is_empty()
 712             && generics.where_clause.predicates.len() == 1
 713             && !result.contains('\n')
 714         {
 715             option.suppress_comma();
 716             option.snuggle();
 717             option.allow_single_line();
 718         }
 719
 720         let missing_span = mk_sp(self_ty.span.hi(), item.span.hi());
 721         let where_span_end = context.snippet_provider.opt_span_before(missing_span, "{");
 722         let where_clause_str = rewrite_where_clause(
 723             context,
 724             &generics.where_clause,
 725             context.config.brace_style(),
 726             Shape::legacy(where_budget, offset.block_only()),
 727             false,
 728             "{",
 729             where_span_end,
 730             self_ty.span.hi(),
 731             option,
 732         )?;
 733
 734         // If there is no where-clause, we may have missing comments between the trait name and
 735         // the opening brace.
 736         if generics.where_clause.predicates.is_empty() {
 737             if let Some(hi) = where_span_end {
 738                 match recover_missing_comment_in_span(
 739                     mk_sp(self_ty.span.hi(), hi),
 740                     Shape::indented(offset, context.config),
 741                     context,
 742                     last_line_width(&result),
 743                 ) {
 744                     Some(ref missing_comment) if !missing_comment.is_empty() => {
 745                         result.push_str(missing_comment);
 746                     }
 747                     _ => (),
 748                 }
 749             }
 750         }
 751
 752         if is_impl_single_line(context, items.as_slice(), &result, &where_clause_str, item)? {
 753             result.push_str(&where_clause_str);
 754             if where_clause_str.contains('\n') || last_line_contains_single_line_comment(&result) {
 755                 // if the where_clause contains extra comments AND
 756                 // there is only one where-clause predicate
 757                 // recover the suppressed comma in single line where_clause formatting
 758                 if generics.where_clause.predicates.len() == 1 {
 759                     result.push_str(",");
 760                 }
 761                 result.push_str(&format!("{}{{{}}}", sep, sep));
 762             } else {
 763                 result.push_str(" {}");
 764             }
 765             return Some(result);
 766         }
 767
 768         result.push_str(&where_clause_str);
 769
 770         let need_newline = last_line_contains_single_line_comment(&result) || result.contains('\n');
 771         match context.config.brace_style() {
 772             _ if need_newline => result.push_str(&sep),
 773             BraceStyle::AlwaysNextLine => result.push_str(&sep),
 774             BraceStyle::PreferSameLine => result.push(' '),
 775             BraceStyle::SameLineWhere => {
 776                 if !where_clause_str.is_empty() {
 777                     result.push_str(&sep);
 778                 } else {
 779                     result.push(' ');
 780                 }
 781             }
 782         }
 783
 784         result.push('{');
 785         // this is an impl body snippet(impl SampleImpl { /* here */ })
 786         let lo = max(self_ty.span.hi(), generics.where_clause.span.hi());
 787         let snippet = context.snippet(mk_sp(lo, item.span.hi()));
 788         let open_pos = snippet.find_uncommented("{")? + 1;
 789
 790         if !items.is_empty() || contains_comment(&snippet[open_pos..]) {
 791             let mut visitor = FmtVisitor::from_context(context);
 792             let item_indent = offset.block_only().block_indent(context.config);
 793             visitor.block_indent = item_indent;
 794             visitor.last_pos = lo + BytePos(open_pos as u32);
 795
 796             visitor.visit_attrs(&item.attrs, ast::AttrStyle::Inner);
 797             visitor.visit_impl_items(items);
 798
 799             visitor.format_missing(item.span.hi() - BytePos(1));
 800
 801             let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
 802             let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
 803
 804             result.push_str(&inner_indent_str);
 805             result.push_str(visitor.buffer.trim());
 806             result.push_str(&outer_indent_str);
 807         } else if need_newline || !context.config.empty_item_single_line() {
 808             result.push_str(&sep);
 809         }
 810
 811         result.push('}');
 812
 813         Some(result)
 814     } else {
 815         unreachable!();
 816     }
 817 }
 818
 819 fn is_impl_single_line(
 820     context: &RewriteContext<'_>,
 821     items: &[ptr::P<ast::AssocItem>],
 822     result: &str,
 823     where_clause_str: &str,
 824     item: &ast::Item,
 825 ) -> Option<bool> {
 826     let snippet = context.snippet(item.span);
 827     let open_pos = snippet.find_uncommented("{")? + 1;
 828
 829     Some(
 830         context.config.empty_item_single_line()
 831             && items.is_empty()
 832             && !result.contains('\n')
 833             && result.len() + where_clause_str.len() <= context.config.max_width()
 834             && !contains_comment(&snippet[open_pos..]),
 835     )
 836 }
 837
 838 fn format_impl_ref_and_type(
 839     context: &RewriteContext<'_>,
 840     item: &ast::Item,
 841     offset: Indent,
 842 ) -> Option<String> {
 843     if let ast::ItemKind::Impl {
 844         unsafety,
 845         polarity,
 846         defaultness,
 847         ref generics,
 848         of_trait: ref trait_ref,
 849         ref self_ty,
 850         ..
 851     } = item.kind
 852     {
 853         let mut result = String::with_capacity(128);
 854
 855         result.push_str(&format_visibility(context, &item.vis));
 856         result.push_str(format_defaultness(defaultness));
 857         result.push_str(format_unsafety(unsafety));
 858
 859         let shape = if context.config.version() == Version::Two {
 860             Shape::indented(offset + last_line_width(&result), context.config)
 861         } else {
 862             generics_shape_from_config(
 863                 context.config,
 864                 Shape::indented(offset + last_line_width(&result), context.config),
 865                 0,
 866             )?
 867         };
 868         let generics_str = rewrite_generics(context, "impl", generics, shape)?;
 869         result.push_str(&generics_str);
 870
 871         let polarity_str = if polarity == ast::ImplPolarity::Negative {
 872             "!"
 873         } else {
 874             ""
 875         };
 876
 877         if let Some(ref trait_ref) = *trait_ref {
 878             let result_len = last_line_width(&result);
 879             result.push_str(&rewrite_trait_ref(
 880                 context,
 881                 trait_ref,
 882                 offset,
 883                 polarity_str,
 884                 result_len,
 885             )?);
 886         }
 887
 888         // Try to put the self type in a single line.
 889         // ` for`
 890         let trait_ref_overhead = if trait_ref.is_some() { 4 } else { 0 };
 891         let curly_brace_overhead = if generics.where_clause.predicates.is_empty() {
 892             // If there is no where-clause adapt budget for type formatting to take space and curly
 893             // brace into account.
 894             match context.config.brace_style() {
 895                 BraceStyle::AlwaysNextLine => 0,
 896                 _ => 2,
 897             }
 898         } else {
 899             0
 900         };
 901         let used_space = last_line_width(&result) + trait_ref_overhead + curly_brace_overhead;
 902         // 1 = space before the type.
 903         let budget = context.budget(used_space + 1);
 904         if let Some(self_ty_str) = self_ty.rewrite(context, Shape::legacy(budget, offset)) {
 905             if !self_ty_str.contains('\n') {
 906                 if trait_ref.is_some() {
 907                     result.push_str(" for ");
 908                 } else {
 909                     result.push(' ');
 910                 }
 911                 result.push_str(&self_ty_str);
 912                 return Some(result);
 913             }
 914         }
 915
 916         // Couldn't fit the self type on a single line, put it on a new line.
 917         result.push('\n');
 918         // Add indentation of one additional tab.
 919         let new_line_offset = offset.block_indent(context.config);
 920         result.push_str(&new_line_offset.to_string(context.config));
 921         if trait_ref.is_some() {
 922             result.push_str("for ");
 923         }
 924         let budget = context.budget(last_line_width(&result));
 925         let type_offset = match context.config.indent_style() {
 926             IndentStyle::Visual => new_line_offset + trait_ref_overhead,
 927             IndentStyle::Block => new_line_offset,
 928         };
 929         result.push_str(&*self_ty.rewrite(context, Shape::legacy(budget, type_offset))?);
 930         Some(result)
 931     } else {
 932         unreachable!();
 933     }
 934 }
 935
 936 fn rewrite_trait_ref(
 937     context: &RewriteContext<'_>,
 938     trait_ref: &ast::TraitRef,
 939     offset: Indent,
 940     polarity_str: &str,
 941     result_len: usize,
 942 ) -> Option<String> {
 943     // 1 = space between generics and trait_ref
 944     let used_space = 1 + polarity_str.len() + result_len;
 945     let shape = Shape::indented(offset + used_space, context.config);
 946     if let Some(trait_ref_str) = trait_ref.rewrite(context, shape) {
 947         if !trait_ref_str.contains('\n') {
 948             return Some(format!(" {}{}", polarity_str, trait_ref_str));
 949         }
 950     }
 951     // We could not make enough space for trait_ref, so put it on new line.
 952     let offset = offset.block_indent(context.config);
 953     let shape = Shape::indented(offset, context.config);
 954     let trait_ref_str = trait_ref.rewrite(context, shape)?;
 955     Some(format!(
 956         "{}{}{}",
 957         offset.to_string_with_newline(context.config),
 958         polarity_str,
 959         trait_ref_str
 960     ))
 961 }
 962
 963 pub(crate) struct StructParts<'a> {
 964     prefix: &'a str,
 965     ident: ast::Ident,
 966     vis: &'a ast::Visibility,
 967     def: &'a ast::VariantData,
 968     generics: Option<&'a ast::Generics>,
 969     span: Span,
 970 }
 971
 972 impl<'a> StructParts<'a> {
 973     fn format_header(&self, context: &RewriteContext<'_>) -> String {
 974         format_header(context, self.prefix, self.ident, self.vis)
 975     }
 976
 977     fn from_variant(variant: &'a ast::Variant) -> Self {
 978         StructParts {
 979             prefix: "",
 980             ident: variant.ident,
 981             vis: &DEFAULT_VISIBILITY,
 982             def: &variant.data,
 983             generics: None,
 984             span: variant.span,
 985         }
 986     }
 987
 988     pub(crate) fn from_item(item: &'a ast::Item) -> Self {
 989         let (prefix, def, generics) = match item.kind {
 990             ast::ItemKind::Struct(ref def, ref generics) => ("struct ", def, generics),
 991             ast::ItemKind::Union(ref def, ref generics) => ("union ", def, generics),
 992             _ => unreachable!(),
 993         };
 994         StructParts {
 995             prefix,
 996             ident: item.ident,
 997             vis: &item.vis,
 998             def,
 999             generics: Some(generics),
1000             span: item.span,
1001         }
1002     }
1003 }
1004
1005 fn format_struct(
1006     context: &RewriteContext<'_>,
1007     struct_parts: &StructParts<'_>,
1008     offset: Indent,
1009     one_line_width: Option<usize>,
1010 ) -> Option<String> {
1011     match *struct_parts.def {
1012         ast::VariantData::Unit(..) => format_unit_struct(context, struct_parts, offset),
1013         ast::VariantData::Tuple(ref fields, _) => {
1014             format_tuple_struct(context, struct_parts, fields, offset)
1015         }
1016         ast::VariantData::Struct(ref fields, _) => {
1017             format_struct_struct(context, struct_parts, fields, offset, one_line_width)
1018         }
1019     }
1020 }
1021
1022 pub(crate) fn format_trait(
1023     context: &RewriteContext<'_>,
1024     item: &ast::Item,
1025     offset: Indent,
1026 ) -> Option<String> {
1027     if let ast::ItemKind::Trait(
1028         is_auto,
1029         unsafety,
1030         ref generics,
1031         ref generic_bounds,
1032         ref trait_items,
1033     ) = item.kind
1034     {
1035         let mut result = String::with_capacity(128);
1036         let header = format!(
1037             "{}{}{}trait ",
1038             format_visibility(context, &item.vis),
1039             format_unsafety(unsafety),
1040             format_auto(is_auto),
1041         );
1042         result.push_str(&header);
1043
1044         let body_lo = context.snippet_provider.span_after(item.span, "{");
1045
1046         let shape = Shape::indented(offset, context.config).offset_left(result.len())?;
1047         let generics_str =
1048             rewrite_generics(context, rewrite_ident(context, item.ident), generics, shape)?;
1049         result.push_str(&generics_str);
1050
1051         // FIXME(#2055): rustfmt fails to format when there are comments between trait bounds.
1052         if !generic_bounds.is_empty() {
1053             let ident_hi = context
1054                 .snippet_provider
1055                 .span_after(item.span, &item.ident.as_str());
1056             let bound_hi = generic_bounds.last().unwrap().span().hi();
1057             let snippet = context.snippet(mk_sp(ident_hi, bound_hi));
1058             if contains_comment(snippet) {
1059                 return None;
1060             }
1061
1062             result = rewrite_assign_rhs_with(
1063                 context,
1064                 result + ":",
1065                 generic_bounds,
1066                 shape,
1067                 RhsTactics::ForceNextLineWithoutIndent,
1068             )?;
1069         }
1070
1071         // Rewrite where-clause.
1072         if !generics.where_clause.predicates.is_empty() {
1073             let where_on_new_line = context.config.indent_style() != IndentStyle::Block;
1074
1075             let where_budget = context.budget(last_line_width(&result));
1076             let pos_before_where = if generic_bounds.is_empty() {
1077                 generics.where_clause.span.lo()
1078             } else {
1079                 generic_bounds[generic_bounds.len() - 1].span().hi()
1080             };
1081             let option = WhereClauseOption::snuggled(&generics_str);
1082             let where_clause_str = rewrite_where_clause(
1083                 context,
1084                 &generics.where_clause,
1085                 context.config.brace_style(),
1086                 Shape::legacy(where_budget, offset.block_only()),
1087                 where_on_new_line,
1088                 "{",
1089                 None,
1090                 pos_before_where,
1091                 option,
1092             )?;
1093             // If the where-clause cannot fit on the same line,
1094             // put the where-clause on a new line
1095             if !where_clause_str.contains('\n')
1096                 && last_line_width(&result) + where_clause_str.len() + offset.width()
1097                     > context.config.comment_width()
1098             {
1099                 let width = offset.block_indent + context.config.tab_spaces() - 1;
1100                 let where_indent = Indent::new(0, width);
1101                 result.push_str(&where_indent.to_string_with_newline(context.config));
1102             }
1103             result.push_str(&where_clause_str);
1104         } else {
1105             let item_snippet = context.snippet(item.span);
1106             if let Some(lo) = item_snippet.find('/') {
1107                 // 1 = `{`
1108                 let comment_hi = body_lo - BytePos(1);
1109                 let comment_lo = item.span.lo() + BytePos(lo as u32);
1110                 if comment_lo < comment_hi {
1111                     match recover_missing_comment_in_span(
1112                         mk_sp(comment_lo, comment_hi),
1113                         Shape::indented(offset, context.config),
1114                         context,
1115                         last_line_width(&result),
1116                     ) {
1117                         Some(ref missing_comment) if !missing_comment.is_empty() => {
1118                             result.push_str(missing_comment);
1119                         }
1120                         _ => (),
1121                     }
1122                 }
1123             }
1124         }
1125
1126         match context.config.brace_style() {
1127             _ if last_line_contains_single_line_comment(&result)
1128                 || last_line_width(&result) + 2 > context.budget(offset.width()) =>
1129             {
1130                 result.push_str(&offset.to_string_with_newline(context.config));
1131             }
1132             BraceStyle::AlwaysNextLine => {
1133                 result.push_str(&offset.to_string_with_newline(context.config));
1134             }
1135             BraceStyle::PreferSameLine => result.push(' '),
1136             BraceStyle::SameLineWhere => {
1137                 if result.contains('\n')
1138                     || (!generics.where_clause.predicates.is_empty() && !trait_items.is_empty())
1139                 {
1140                     result.push_str(&offset.to_string_with_newline(context.config));
1141                 } else {
1142                     result.push(' ');
1143                 }
1144             }
1145         }
1146         result.push('{');
1147
1148         let snippet = context.snippet(item.span);
1149         let open_pos = snippet.find_uncommented("{")? + 1;
1150         let outer_indent_str = offset.block_only().to_string_with_newline(context.config);
1151
1152         if !trait_items.is_empty() || contains_comment(&snippet[open_pos..]) {
1153             let mut visitor = FmtVisitor::from_context(context);
1154             visitor.block_indent = offset.block_only().block_indent(context.config);
1155             visitor.last_pos = item.span.lo() + BytePos(open_pos as u32);
1156
1157             for item in trait_items {
1158                 visitor.visit_trait_item(item);
1159             }
1160
1161             visitor.format_missing(item.span.hi() - BytePos(1));
1162
1163             let inner_indent_str = visitor.block_indent.to_string_with_newline(context.config);
1164
1165             result.push_str(&inner_indent_str);
1166             result.push_str(visitor.buffer.trim());
1167             result.push_str(&outer_indent_str);
1168         } else if result.contains('\n') {
1169             result.push_str(&outer_indent_str);
1170         }
1171
1172         result.push('}');
1173         Some(result)
1174     } else {
1175         unreachable!();
1176     }
1177 }
1178
1179 struct OpaqueTypeBounds<'a> {
1180     generic_bounds: &'a ast::GenericBounds,
1181 }
1182
1183 impl<'a> Rewrite for OpaqueTypeBounds<'a> {
1184     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1185         self.generic_bounds
1186             .rewrite(context, shape)
1187             .map(|s| format!("impl {}", s))
1188     }
1189 }
1190
1191 pub(crate) struct TraitAliasBounds<'a> {
1192     generic_bounds: &'a ast::GenericBounds,
1193     generics: &'a ast::Generics,
1194 }
1195
1196 impl<'a> Rewrite for TraitAliasBounds<'a> {
1197     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1198         let generic_bounds_str = self.generic_bounds.rewrite(context, shape)?;
1199
1200         let mut option = WhereClauseOption::new(true, WhereClauseSpace::None);
1201         option.allow_single_line();
1202
1203         let where_str = rewrite_where_clause(
1204             context,
1205             &self.generics.where_clause,
1206             context.config.brace_style(),
1207             shape,
1208             false,
1209             ";",
1210             None,
1211             self.generics.where_clause.span.lo(),
1212             option,
1213         )?;
1214
1215         let fits_single_line = !generic_bounds_str.contains('\n')
1216             && !where_str.contains('\n')
1217             && generic_bounds_str.len() + where_str.len() + 1 <= shape.width;
1218         let space = if generic_bounds_str.is_empty() || where_str.is_empty() {
1219             Cow::from("")
1220         } else if fits_single_line {
1221             Cow::from(" ")
1222         } else {
1223             shape.indent.to_string_with_newline(&context.config)
1224         };
1225
1226         Some(format!("{}{}{}", generic_bounds_str, space, where_str))
1227     }
1228 }
1229
1230 pub(crate) fn format_trait_alias(
1231     context: &RewriteContext<'_>,
1232     ident: ast::Ident,
1233     vis: &ast::Visibility,
1234     generics: &ast::Generics,
1235     generic_bounds: &ast::GenericBounds,
1236     shape: Shape,
1237 ) -> Option<String> {
1238     let alias = rewrite_ident(context, ident);
1239     // 6 = "trait ", 2 = " ="
1240     let g_shape = shape.offset_left(6)?.sub_width(2)?;
1241     let generics_str = rewrite_generics(context, &alias, generics, g_shape)?;
1242     let vis_str = format_visibility(context, vis);
1243     let lhs = format!("{}trait {} =", vis_str, generics_str);
1244     // 1 = ";"
1245     let trait_alias_bounds = TraitAliasBounds {
1246         generics,
1247         generic_bounds,
1248     };
1249     rewrite_assign_rhs(context, lhs, &trait_alias_bounds, shape.sub_width(1)?).map(|s| s + ";")
1250 }
1251
1252 fn format_unit_struct(
1253     context: &RewriteContext<'_>,
1254     p: &StructParts<'_>,
1255     offset: Indent,
1256 ) -> Option<String> {
1257     let header_str = format_header(context, p.prefix, p.ident, p.vis);
1258     let generics_str = if let Some(generics) = p.generics {
1259         let hi = context.snippet_provider.span_before(p.span, ";");
1260         format_generics(
1261             context,
1262             generics,
1263             context.config.brace_style(),
1264             BracePos::None,
1265             offset,
1266             // make a span that starts right after `struct Foo`
1267             mk_sp(p.ident.span.hi(), hi),
1268             last_line_width(&header_str),
1269         )?
1270     } else {
1271         String::new()
1272     };
1273     Some(format!("{}{};", header_str, generics_str))
1274 }
1275
1276 pub(crate) fn format_struct_struct(
1277     context: &RewriteContext<'_>,
1278     struct_parts: &StructParts<'_>,
1279     fields: &[ast::StructField],
1280     offset: Indent,
1281     one_line_width: Option<usize>,
1282 ) -> Option<String> {
1283     let mut result = String::with_capacity(1024);
1284     let span = struct_parts.span;
1285
1286     let header_str = struct_parts.format_header(context);
1287     result.push_str(&header_str);
1288
1289     let header_hi = struct_parts.ident.span.hi();
1290     let body_lo = context.snippet_provider.span_after(span, "{");
1291
1292     let generics_str = match struct_parts.generics {
1293         Some(g) => format_generics(
1294             context,
1295             g,
1296             context.config.brace_style(),
1297             if fields.is_empty() {
1298                 BracePos::ForceSameLine
1299             } else {
1300                 BracePos::Auto
1301             },
1302             offset,
1303             // make a span that starts right after `struct Foo`
1304             mk_sp(header_hi, body_lo),
1305             last_line_width(&result),
1306         )?,
1307         None => {
1308             // 3 = ` {}`, 2 = ` {`.
1309             let overhead = if fields.is_empty() { 3 } else { 2 };
1310             if (context.config.brace_style() == BraceStyle::AlwaysNextLine && !fields.is_empty())
1311                 || context.config.max_width() < overhead + result.len()
1312             {
1313                 format!("\n{}{{", offset.block_only().to_string(context.config))
1314             } else {
1315                 " {".to_owned()
1316             }
1317         }
1318     };
1319     // 1 = `}`
1320     let overhead = if fields.is_empty() { 1 } else { 0 };
1321     let total_width = result.len() + generics_str.len() + overhead;
1322     if !generics_str.is_empty()
1323         && !generics_str.contains('\n')
1324         && total_width > context.config.max_width()
1325     {
1326         result.push('\n');
1327         result.push_str(&offset.to_string(context.config));
1328         result.push_str(generics_str.trim_start());
1329     } else {
1330         result.push_str(&generics_str);
1331     }
1332
1333     if fields.is_empty() {
1334         let inner_span = mk_sp(body_lo, span.hi() - BytePos(1));
1335         format_empty_struct_or_tuple(context, inner_span, offset, &mut result, "", "}");
1336         return Some(result);
1337     }
1338
1339     // 3 = ` ` and ` }`
1340     let one_line_budget = context.budget(result.len() + 3 + offset.width());
1341     let one_line_budget =
1342         one_line_width.map_or(0, |one_line_width| min(one_line_width, one_line_budget));
1343
1344     let items_str = rewrite_with_alignment(
1345         fields,
1346         context,
1347         Shape::indented(offset.block_indent(context.config), context.config).sub_width(1)?,
1348         mk_sp(body_lo, span.hi()),
1349         one_line_budget,
1350     )?;
1351
1352     if !items_str.contains('\n')
1353         && !result.contains('\n')
1354         && items_str.len() <= one_line_budget
1355         && !last_line_contains_single_line_comment(&items_str)
1356     {
1357         Some(format!("{} {} }}", result, items_str))
1358     } else {
1359         Some(format!(
1360             "{}\n{}{}\n{}}}",
1361             result,
1362             offset
1363                 .block_indent(context.config)
1364                 .to_string(context.config),
1365             items_str,
1366             offset.to_string(context.config)
1367         ))
1368     }
1369 }
1370
1371 fn get_bytepos_after_visibility(vis: &ast::Visibility, default_span: Span) -> BytePos {
1372     match vis.node {
1373         ast::VisibilityKind::Crate(..) | ast::VisibilityKind::Restricted { .. } => vis.span.hi(),
1374         _ => default_span.lo(),
1375     }
1376 }
1377
1378 // Format tuple or struct without any fields. We need to make sure that the comments
1379 // inside the delimiters are preserved.
1380 fn format_empty_struct_or_tuple(
1381     context: &RewriteContext<'_>,
1382     span: Span,
1383     offset: Indent,
1384     result: &mut String,
1385     opener: &str,
1386     closer: &str,
1387 ) {
1388     // 3 = " {}" or "();"
1389     let used_width = last_line_used_width(&result, offset.width()) + 3;
1390     if used_width > context.config.max_width() {
1391         result.push_str(&offset.to_string_with_newline(context.config))
1392     }
1393     result.push_str(opener);
1394     match rewrite_missing_comment(span, Shape::indented(offset, context.config), context) {
1395         Some(ref s) if s.is_empty() => (),
1396         Some(ref s) => {
1397             if !is_single_line(s) || first_line_contains_single_line_comment(s) {
1398                 let nested_indent_str = offset
1399                     .block_indent(context.config)
1400                     .to_string_with_newline(context.config);
1401                 result.push_str(&nested_indent_str);
1402             }
1403             result.push_str(s);
1404             if last_line_contains_single_line_comment(s) {
1405                 result.push_str(&offset.to_string_with_newline(context.config));
1406             }
1407         }
1408         None => result.push_str(context.snippet(span)),
1409     }
1410     result.push_str(closer);
1411 }
1412
1413 fn format_tuple_struct(
1414     context: &RewriteContext<'_>,
1415     struct_parts: &StructParts<'_>,
1416     fields: &[ast::StructField],
1417     offset: Indent,
1418 ) -> Option<String> {
1419     let mut result = String::with_capacity(1024);
1420     let span = struct_parts.span;
1421
1422     let header_str = struct_parts.format_header(context);
1423     result.push_str(&header_str);
1424
1425     let body_lo = if fields.is_empty() {
1426         let lo = get_bytepos_after_visibility(struct_parts.vis, span);
1427         context
1428             .snippet_provider
1429             .span_after(mk_sp(lo, span.hi()), "(")
1430     } else {
1431         fields[0].span.lo()
1432     };
1433     let body_hi = if fields.is_empty() {
1434         context
1435             .snippet_provider
1436             .span_after(mk_sp(body_lo, span.hi()), ")")
1437     } else {
1438         // This is a dirty hack to work around a missing `)` from the span of the last field.
1439         let last_arg_span = fields[fields.len() - 1].span;
1440         context
1441             .snippet_provider
1442             .opt_span_after(mk_sp(last_arg_span.hi(), span.hi()), ")")
1443             .unwrap_or_else(|| last_arg_span.hi())
1444     };
1445
1446     let where_clause_str = match struct_parts.generics {
1447         Some(generics) => {
1448             let budget = context.budget(last_line_width(&header_str));
1449             let shape = Shape::legacy(budget, offset);
1450             let generics_str = rewrite_generics(context, "", generics, shape)?;
1451             result.push_str(&generics_str);
1452
1453             let where_budget = context.budget(last_line_width(&result));
1454             let option = WhereClauseOption::new(true, WhereClauseSpace::Newline);
1455             rewrite_where_clause(
1456                 context,
1457                 &generics.where_clause,
1458                 context.config.brace_style(),
1459                 Shape::legacy(where_budget, offset.block_only()),
1460                 false,
1461                 ";",
1462                 None,
1463                 body_hi,
1464                 option,
1465             )?
1466         }
1467         None => "".to_owned(),
1468     };
1469
1470     if fields.is_empty() {
1471         let body_hi = context
1472             .snippet_provider
1473             .span_before(mk_sp(body_lo, span.hi()), ")");
1474         let inner_span = mk_sp(body_lo, body_hi);
1475         format_empty_struct_or_tuple(context, inner_span, offset, &mut result, "(", ")");
1476     } else {
1477         let shape = Shape::indented(offset, context.config).sub_width(1)?;
1478         result = overflow::rewrite_with_parens(
1479             context,
1480             &result,
1481             fields.iter(),
1482             shape,
1483             span,
1484             context.config.width_heuristics().fn_call_width,
1485             None,
1486         )?;
1487     }
1488
1489     if !where_clause_str.is_empty()
1490         && !where_clause_str.contains('\n')
1491         && (result.contains('\n')
1492             || offset.block_indent + result.len() + where_clause_str.len() + 1
1493                 > context.config.max_width())
1494     {
1495         // We need to put the where-clause on a new line, but we didn't
1496         // know that earlier, so the where-clause will not be indented properly.
1497         result.push('\n');
1498         result.push_str(
1499             &(offset.block_only() + (context.config.tab_spaces() - 1)).to_string(context.config),
1500         );
1501     }
1502     result.push_str(&where_clause_str);
1503
1504     Some(result)
1505 }
1506
1507 fn rewrite_type_prefix(
1508     context: &RewriteContext<'_>,
1509     indent: Indent,
1510     prefix: &str,
1511     ident: ast::Ident,
1512     generics: &ast::Generics,
1513 ) -> Option<String> {
1514     let mut result = String::with_capacity(128);
1515     result.push_str(prefix);
1516     let ident_str = rewrite_ident(context, ident);
1517
1518     // 2 = `= `
1519     if generics.params.is_empty() {
1520         result.push_str(ident_str)
1521     } else {
1522         let g_shape = Shape::indented(indent, context.config)
1523             .offset_left(result.len())?
1524             .sub_width(2)?;
1525         let generics_str = rewrite_generics(context, ident_str, generics, g_shape)?;
1526         result.push_str(&generics_str);
1527     }
1528
1529     let where_budget = context.budget(last_line_width(&result));
1530     let option = WhereClauseOption::snuggled(&result);
1531     let where_clause_str = rewrite_where_clause(
1532         context,
1533         &generics.where_clause,
1534         context.config.brace_style(),
1535         Shape::legacy(where_budget, indent),
1536         false,
1537         "=",
1538         None,
1539         generics.span.hi(),
1540         option,
1541     )?;
1542     result.push_str(&where_clause_str);
1543
1544     Some(result)
1545 }
1546
1547 fn rewrite_type_item<R: Rewrite>(
1548     context: &RewriteContext<'_>,
1549     indent: Indent,
1550     prefix: &str,
1551     suffix: &str,
1552     ident: ast::Ident,
1553     rhs: &R,
1554     generics: &ast::Generics,
1555     vis: &ast::Visibility,
1556 ) -> Option<String> {
1557     let mut result = String::with_capacity(128);
1558     result.push_str(&rewrite_type_prefix(
1559         context,
1560         indent,
1561         &format!("{}{} ", format_visibility(context, vis), prefix),
1562         ident,
1563         generics,
1564     )?);
1565
1566     if generics.where_clause.predicates.is_empty() {
1567         result.push_str(suffix);
1568     } else {
1569         result.push_str(&indent.to_string_with_newline(context.config));
1570         result.push_str(suffix.trim_start());
1571     }
1572
1573     // 1 = ";"
1574     let rhs_shape = Shape::indented(indent, context.config).sub_width(1)?;
1575     rewrite_assign_rhs(context, result, rhs, rhs_shape).map(|s| s + ";")
1576 }
1577
1578 pub(crate) fn rewrite_type_alias(
1579     context: &RewriteContext<'_>,
1580     indent: Indent,
1581     ident: ast::Ident,
1582     ty: &ast::Ty,
1583     generics: &ast::Generics,
1584     vis: &ast::Visibility,
1585 ) -> Option<String> {
1586     rewrite_type_item(context, indent, "type", " =", ident, ty, generics, vis)
1587 }
1588
1589 pub(crate) fn rewrite_opaque_type(
1590     context: &RewriteContext<'_>,
1591     indent: Indent,
1592     ident: ast::Ident,
1593     generic_bounds: &ast::GenericBounds,
1594     generics: &ast::Generics,
1595     vis: &ast::Visibility,
1596 ) -> Option<String> {
1597     let opaque_type_bounds = OpaqueTypeBounds { generic_bounds };
1598     rewrite_type_item(
1599         context,
1600         indent,
1601         "type",
1602         " =",
1603         ident,
1604         &opaque_type_bounds,
1605         generics,
1606         vis,
1607     )
1608 }
1609
1610 fn type_annotation_spacing(config: &Config) -> (&str, &str) {
1611     (
1612         if config.space_before_colon() { " " } else { "" },
1613         if config.space_after_colon() { " " } else { "" },
1614     )
1615 }
1616
1617 pub(crate) fn rewrite_struct_field_prefix(
1618     context: &RewriteContext<'_>,
1619     field: &ast::StructField,
1620 ) -> Option<String> {
1621     let vis = format_visibility(context, &field.vis);
1622     let type_annotation_spacing = type_annotation_spacing(context.config);
1623     Some(match field.ident {
1624         Some(name) => format!(
1625             "{}{}{}:",
1626             vis,
1627             rewrite_ident(context, name),
1628             type_annotation_spacing.0
1629         ),
1630         None => vis.to_string(),
1631     })
1632 }
1633
1634 impl Rewrite for ast::StructField {
1635     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1636         rewrite_struct_field(context, self, shape, 0)
1637     }
1638 }
1639
1640 pub(crate) fn rewrite_struct_field(
1641     context: &RewriteContext<'_>,
1642     field: &ast::StructField,
1643     shape: Shape,
1644     lhs_max_width: usize,
1645 ) -> Option<String> {
1646     if contains_skip(&field.attrs) {
1647         return Some(context.snippet(field.span()).to_owned());
1648     }
1649
1650     let type_annotation_spacing = type_annotation_spacing(context.config);
1651     let prefix = rewrite_struct_field_prefix(context, field)?;
1652
1653     let attrs_str = field.attrs.rewrite(context, shape)?;
1654     let attrs_extendable = field.ident.is_none() && is_attributes_extendable(&attrs_str);
1655     let missing_span = if field.attrs.is_empty() {
1656         mk_sp(field.span.lo(), field.span.lo())
1657     } else {
1658         mk_sp(field.attrs.last().unwrap().span.hi(), field.span.lo())
1659     };
1660     let mut spacing = String::from(if field.ident.is_some() {
1661         type_annotation_spacing.1
1662     } else {
1663         ""
1664     });
1665     // Try to put everything on a single line.
1666     let attr_prefix = combine_strs_with_missing_comments(
1667         context,
1668         &attrs_str,
1669         &prefix,
1670         missing_span,
1671         shape,
1672         attrs_extendable,
1673     )?;
1674     let overhead = trimmed_last_line_width(&attr_prefix);
1675     let lhs_offset = lhs_max_width.saturating_sub(overhead);
1676     for _ in 0..lhs_offset {
1677         spacing.push(' ');
1678     }
1679     // In this extreme case we will be missing a space between an attribute and a field.
1680     if prefix.is_empty() && !attrs_str.is_empty() && attrs_extendable && spacing.is_empty() {
1681         spacing.push(' ');
1682     }
1683     let orig_ty = shape
1684         .offset_left(overhead + spacing.len())
1685         .and_then(|ty_shape| field.ty.rewrite(context, ty_shape));
1686     if let Some(ref ty) = orig_ty {
1687         if !ty.contains('\n') {
1688             return Some(attr_prefix + &spacing + ty);
1689         }
1690     }
1691
1692     let is_prefix_empty = prefix.is_empty();
1693     // We must use multiline. We are going to put attributes and a field on different lines.
1694     let field_str = rewrite_assign_rhs(context, prefix, &*field.ty, shape)?;
1695     // Remove a leading white-space from `rewrite_assign_rhs()` when rewriting a tuple struct.
1696     let field_str = if is_prefix_empty {
1697         field_str.trim_start()
1698     } else {
1699         &field_str
1700     };
1701     combine_strs_with_missing_comments(context, &attrs_str, field_str, missing_span, shape, false)
1702 }
1703
1704 pub(crate) struct StaticParts<'a> {
1705     prefix: &'a str,
1706     vis: &'a ast::Visibility,
1707     ident: ast::Ident,
1708     ty: &'a ast::Ty,
1709     mutability: ast::Mutability,
1710     expr_opt: Option<&'a ptr::P<ast::Expr>>,
1711     defaultness: Option<ast::Defaultness>,
1712     span: Span,
1713 }
1714
1715 impl<'a> StaticParts<'a> {
1716     pub(crate) fn from_item(item: &'a ast::Item) -> Self {
1717         let (defaultness, prefix, ty, mutability, expr) = match item.kind {
1718             ast::ItemKind::Static(ref ty, mutability, ref expr) => {
1719                 (None, "static", ty, mutability, expr)
1720             }
1721             ast::ItemKind::Const(defaultness, ref ty, ref expr) => {
1722                 (Some(defaultness), "const", ty, ast::Mutability::Not, expr)
1723             }
1724             _ => unreachable!(),
1725         };
1726         StaticParts {
1727             prefix,
1728             vis: &item.vis,
1729             ident: item.ident,
1730             ty,
1731             mutability,
1732             expr_opt: expr.as_ref(),
1733             defaultness: defaultness,
1734             span: item.span,
1735         }
1736     }
1737
1738     pub(crate) fn from_trait_item(ti: &'a ast::AssocItem) -> Self {
1739         let (defaultness, ty, expr_opt) = match ti.kind {
1740             ast::AssocItemKind::Const(defaultness, ref ty, ref expr_opt) => {
1741                 (defaultness, ty, expr_opt)
1742             }
1743             _ => unreachable!(),
1744         };
1745         StaticParts {
1746             prefix: "const",
1747             vis: &DEFAULT_VISIBILITY,
1748             ident: ti.ident,
1749             ty,
1750             mutability: ast::Mutability::Not,
1751             expr_opt: expr_opt.as_ref(),
1752             defaultness: Some(defaultness),
1753             span: ti.span,
1754         }
1755     }
1756
1757     pub(crate) fn from_impl_item(ii: &'a ast::AssocItem) -> Self {
1758         let (defaultness, ty, expr) = match ii.kind {
1759             ast::AssocItemKind::Const(defaultness, ref ty, ref expr) => (defaultness, ty, expr),
1760             _ => unreachable!(),
1761         };
1762         StaticParts {
1763             prefix: "const",
1764             vis: &ii.vis,
1765             ident: ii.ident,
1766             ty,
1767             mutability: ast::Mutability::Not,
1768             expr_opt: expr.as_ref(),
1769             defaultness: Some(defaultness),
1770             span: ii.span,
1771         }
1772     }
1773 }
1774
1775 fn rewrite_static(
1776     context: &RewriteContext<'_>,
1777     static_parts: &StaticParts<'_>,
1778     offset: Indent,
1779 ) -> Option<String> {
1780     let colon = colon_spaces(context.config);
1781     let mut prefix = format!(
1782         "{}{}{} {}{}{}",
1783         format_visibility(context, static_parts.vis),
1784         static_parts.defaultness.map_or("", format_defaultness),
1785         static_parts.prefix,
1786         format_mutability(static_parts.mutability),
1787         rewrite_ident(context, static_parts.ident),
1788         colon,
1789     );
1790     // 2 = " =".len()
1791     let ty_shape =
1792         Shape::indented(offset.block_only(), context.config).offset_left(prefix.len() + 2)?;
1793     let ty_str = match static_parts.ty.rewrite(context, ty_shape) {
1794         Some(ty_str) => ty_str,
1795         None => {
1796             if prefix.ends_with(' ') {
1797                 prefix.pop();
1798             }
1799             let nested_indent = offset.block_indent(context.config);
1800             let nested_shape = Shape::indented(nested_indent, context.config);
1801             let ty_str = static_parts.ty.rewrite(context, nested_shape)?;
1802             format!(
1803                 "{}{}",
1804                 nested_indent.to_string_with_newline(context.config),
1805                 ty_str
1806             )
1807         }
1808     };
1809
1810     if let Some(expr) = static_parts.expr_opt {
1811         let lhs = format!("{}{} =", prefix, ty_str);
1812         // 1 = ;
1813         let remaining_width = context.budget(offset.block_indent + 1);
1814         rewrite_assign_rhs(
1815             context,
1816             lhs,
1817             &**expr,
1818             Shape::legacy(remaining_width, offset.block_only()),
1819         )
1820         .and_then(|res| recover_comment_removed(res, static_parts.span, context))
1821         .map(|s| if s.ends_with(';') { s } else { s + ";" })
1822     } else {
1823         Some(format!("{}{};", prefix, ty_str))
1824     }
1825 }
1826
1827 pub(crate) fn rewrite_associated_type(
1828     ident: ast::Ident,
1829     ty_opt: Option<&ptr::P<ast::Ty>>,
1830     generics: &ast::Generics,
1831     generic_bounds_opt: Option<&ast::GenericBounds>,
1832     context: &RewriteContext<'_>,
1833     indent: Indent,
1834 ) -> Option<String> {
1835     let ident_str = rewrite_ident(context, ident);
1836     // 5 = "type "
1837     let generics_shape = Shape::indented(indent, context.config).offset_left(5)?;
1838     let generics_str = rewrite_generics(context, ident_str, generics, generics_shape)?;
1839     let prefix = format!("type {}", generics_str);
1840
1841     let type_bounds_str = if let Some(bounds) = generic_bounds_opt {
1842         if bounds.is_empty() {
1843             String::new()
1844         } else {
1845             // 2 = ": ".len()
1846             let shape = Shape::indented(indent, context.config).offset_left(prefix.len() + 2)?;
1847             bounds.rewrite(context, shape).map(|s| format!(": {}", s))?
1848         }
1849     } else {
1850         String::new()
1851     };
1852
1853     if let Some(ty) = ty_opt {
1854         // 1 = `;`
1855         let shape = Shape::indented(indent, context.config).sub_width(1)?;
1856         let lhs = format!("{}{} =", prefix, type_bounds_str);
1857         rewrite_assign_rhs(context, lhs, &**ty, shape).map(|s| s + ";")
1858     } else {
1859         Some(format!("{}{};", prefix, type_bounds_str))
1860     }
1861 }
1862
1863 struct OpaqueType<'a> {
1864     bounds: &'a ast::GenericBounds,
1865 }
1866
1867 impl<'a> Rewrite for OpaqueType<'a> {
1868     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1869         let shape = shape.offset_left(5)?; // `impl `
1870         self.bounds
1871             .rewrite(context, shape)
1872             .map(|s| format!("impl {}", s))
1873     }
1874 }
1875
1876 pub(crate) fn rewrite_opaque_impl_type(
1877     context: &RewriteContext<'_>,
1878     ident: ast::Ident,
1879     generics: &ast::Generics,
1880     generic_bounds: &ast::GenericBounds,
1881     indent: Indent,
1882 ) -> Option<String> {
1883     let ident_str = rewrite_ident(context, ident);
1884     // 5 = "type "
1885     let generics_shape = Shape::indented(indent, context.config).offset_left(5)?;
1886     let generics_str = rewrite_generics(context, ident_str, generics, generics_shape)?;
1887     let prefix = format!("type {} =", generics_str);
1888     let rhs = OpaqueType {
1889         bounds: generic_bounds,
1890     };
1891
1892     rewrite_assign_rhs(
1893         context,
1894         &prefix,
1895         &rhs,
1896         Shape::indented(indent, context.config).sub_width(1)?,
1897     )
1898     .map(|s| s + ";")
1899 }
1900
1901 pub(crate) fn rewrite_associated_impl_type(
1902     ident: ast::Ident,
1903     defaultness: ast::Defaultness,
1904     ty_opt: Option<&ptr::P<ast::Ty>>,
1905     generics: &ast::Generics,
1906     context: &RewriteContext<'_>,
1907     indent: Indent,
1908 ) -> Option<String> {
1909     let result = rewrite_associated_type(ident, ty_opt, generics, None, context, indent)?;
1910
1911     match defaultness {
1912         ast::Defaultness::Default(..) => Some(format!("default {}", result)),
1913         _ => Some(result),
1914     }
1915 }
1916
1917 impl Rewrite for ast::FnRetTy {
1918     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1919         match *self {
1920             ast::FnRetTy::Default(_) => Some(String::new()),
1921             ast::FnRetTy::Ty(ref ty) => {
1922                 if context.config.version() == Version::One
1923                     || context.config.indent_style() == IndentStyle::Visual
1924                 {
1925                     let inner_width = shape.width.checked_sub(3)?;
1926                     return ty
1927                         .rewrite(context, Shape::legacy(inner_width, shape.indent + 3))
1928                         .map(|r| format!("-> {}", r));
1929                 }
1930
1931                 ty.rewrite(context, shape.offset_left(3)?)
1932                     .map(|s| format!("-> {}", s))
1933             }
1934         }
1935     }
1936 }
1937
1938 fn is_empty_infer(ty: &ast::Ty, pat_span: Span) -> bool {
1939     match ty.kind {
1940         ast::TyKind::Infer => ty.span.hi() == pat_span.hi(),
1941         _ => false,
1942     }
1943 }
1944
1945 /// Recover any missing comments between the param and the type.
1946 ///
1947 /// # Returns
1948 ///
1949 /// A 2-len tuple with the comment before the colon in first position, and the comment after the
1950 /// colon in second position.
1951 fn get_missing_param_comments(
1952     context: &RewriteContext<'_>,
1953     pat_span: Span,
1954     ty_span: Span,
1955     shape: Shape,
1956 ) -> (String, String) {
1957     let missing_comment_span = mk_sp(pat_span.hi(), ty_span.lo());
1958
1959     let span_before_colon = {
1960         let missing_comment_span_hi = context
1961             .snippet_provider
1962             .span_before(missing_comment_span, ":");
1963         mk_sp(pat_span.hi(), missing_comment_span_hi)
1964     };
1965     let span_after_colon = {
1966         let missing_comment_span_lo = context
1967             .snippet_provider
1968             .span_after(missing_comment_span, ":");
1969         mk_sp(missing_comment_span_lo, ty_span.lo())
1970     };
1971
1972     let comment_before_colon = rewrite_missing_comment(span_before_colon, shape, context)
1973         .filter(|comment| !comment.is_empty())
1974         .map_or(String::new(), |comment| format!(" {}", comment));
1975     let comment_after_colon = rewrite_missing_comment(span_after_colon, shape, context)
1976         .filter(|comment| !comment.is_empty())
1977         .map_or(String::new(), |comment| format!("{} ", comment));
1978     (comment_before_colon, comment_after_colon)
1979 }
1980
1981 impl Rewrite for ast::Param {
1982     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
1983         let param_attrs_result = self
1984             .attrs
1985             .rewrite(context, Shape::legacy(shape.width, shape.indent))?;
1986         let (span, has_multiple_attr_lines) = if !self.attrs.is_empty() {
1987             let num_attrs = self.attrs.len();
1988             (
1989                 mk_sp(self.attrs[num_attrs - 1].span.hi(), self.pat.span.lo()),
1990                 param_attrs_result.contains("\n"),
1991             )
1992         } else {
1993             (mk_sp(self.span.lo(), self.span.lo()), false)
1994         };
1995
1996         if let Some(ref explicit_self) = self.to_self() {
1997             rewrite_explicit_self(
1998                 context,
1999                 explicit_self,
2000                 &param_attrs_result,
2001                 span,
2002                 shape,
2003                 has_multiple_attr_lines,
2004             )
2005         } else if is_named_param(self) {
2006             let mut result = combine_strs_with_missing_comments(
2007                 context,
2008                 &param_attrs_result,
2009                 &self
2010                     .pat
2011                     .rewrite(context, Shape::legacy(shape.width, shape.indent))?,
2012                 span,
2013                 shape,
2014                 !has_multiple_attr_lines,
2015             )?;
2016
2017             if !is_empty_infer(&*self.ty, self.pat.span) {
2018                 let (before_comment, after_comment) =
2019                     get_missing_param_comments(context, self.pat.span, self.ty.span, shape);
2020                 result.push_str(&before_comment);
2021                 result.push_str(colon_spaces(context.config));
2022                 result.push_str(&after_comment);
2023                 let overhead = last_line_width(&result);
2024                 let max_width = shape.width.checked_sub(overhead)?;
2025                 let ty_str = self
2026                     .ty
2027                     .rewrite(context, Shape::legacy(max_width, shape.indent))?;
2028                 result.push_str(&ty_str);
2029             }
2030
2031             Some(result)
2032         } else {
2033             self.ty.rewrite(context, shape)
2034         }
2035     }
2036 }
2037
2038 fn rewrite_explicit_self(
2039     context: &RewriteContext<'_>,
2040     explicit_self: &ast::ExplicitSelf,
2041     param_attrs: &str,
2042     span: Span,
2043     shape: Shape,
2044     has_multiple_attr_lines: bool,
2045 ) -> Option<String> {
2046     match explicit_self.node {
2047         ast::SelfKind::Region(lt, m) => {
2048             let mut_str = format_mutability(m);
2049             match lt {
2050                 Some(ref l) => {
2051                     let lifetime_str = l.rewrite(
2052                         context,
2053                         Shape::legacy(context.config.max_width(), Indent::empty()),
2054                     )?;
2055                     Some(combine_strs_with_missing_comments(
2056                         context,
2057                         &param_attrs,
2058                         &format!("&{} {}self", lifetime_str, mut_str),
2059                         span,
2060                         shape,
2061                         !has_multiple_attr_lines,
2062                     )?)
2063                 }
2064                 None => Some(combine_strs_with_missing_comments(
2065                     context,
2066                     &param_attrs,
2067                     &format!("&{}self", mut_str),
2068                     span,
2069                     shape,
2070                     !has_multiple_attr_lines,
2071                 )?),
2072             }
2073         }
2074         ast::SelfKind::Explicit(ref ty, mutability) => {
2075             let type_str = ty.rewrite(
2076                 context,
2077                 Shape::legacy(context.config.max_width(), Indent::empty()),
2078             )?;
2079
2080             Some(combine_strs_with_missing_comments(
2081                 context,
2082                 &param_attrs,
2083                 &format!("{}self: {}", format_mutability(mutability), type_str),
2084                 span,
2085                 shape,
2086                 !has_multiple_attr_lines,
2087             )?)
2088         }
2089         ast::SelfKind::Value(mutability) => Some(combine_strs_with_missing_comments(
2090             context,
2091             &param_attrs,
2092             &format!("{}self", format_mutability(mutability)),
2093             span,
2094             shape,
2095             !has_multiple_attr_lines,
2096         )?),
2097     }
2098 }
2099
2100 pub(crate) fn span_lo_for_param(param: &ast::Param) -> BytePos {
2101     if param.attrs.is_empty() {
2102         if is_named_param(param) {
2103             param.pat.span.lo()
2104         } else {
2105             param.ty.span.lo()
2106         }
2107     } else {
2108         param.attrs[0].span.lo()
2109     }
2110 }
2111
2112 pub(crate) fn span_hi_for_param(context: &RewriteContext<'_>, param: &ast::Param) -> BytePos {
2113     match param.ty.kind {
2114         ast::TyKind::Infer if context.snippet(param.ty.span) == "_" => param.ty.span.hi(),
2115         ast::TyKind::Infer if is_named_param(param) => param.pat.span.hi(),
2116         _ => param.ty.span.hi(),
2117     }
2118 }
2119
2120 pub(crate) fn is_named_param(param: &ast::Param) -> bool {
2121     if let ast::PatKind::Ident(_, ident, _) = param.pat.kind {
2122         ident.name != symbol::kw::Invalid
2123     } else {
2124         true
2125     }
2126 }
2127
2128 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
2129 pub(crate) enum FnBraceStyle {
2130     SameLine,
2131     NextLine,
2132     None,
2133 }
2134
2135 // Return type is (result, force_new_line_for_brace)
2136 fn rewrite_fn_base(
2137     context: &RewriteContext<'_>,
2138     indent: Indent,
2139     ident: ast::Ident,
2140     fn_sig: &FnSig<'_>,
2141     span: Span,
2142     fn_brace_style: FnBraceStyle,
2143 ) -> Option<(String, bool)> {
2144     let mut force_new_line_for_brace = false;
2145
2146     let where_clause = &fn_sig.generics.where_clause;
2147
2148     let mut result = String::with_capacity(1024);
2149     result.push_str(&fn_sig.to_str(context));
2150
2151     // fn foo
2152     result.push_str("fn ");
2153
2154     // Generics.
2155     let overhead = if let FnBraceStyle::SameLine = fn_brace_style {
2156         // 4 = `() {`
2157         4
2158     } else {
2159         // 2 = `()`
2160         2
2161     };
2162     let used_width = last_line_used_width(&result, indent.width());
2163     let one_line_budget = context.budget(used_width + overhead);
2164     let shape = Shape {
2165         width: one_line_budget,
2166         indent,
2167         offset: used_width,
2168     };
2169     let fd = fn_sig.decl;
2170     let generics_str = rewrite_generics(
2171         context,
2172         rewrite_ident(context, ident),
2173         fn_sig.generics,
2174         shape,
2175     )?;
2176     result.push_str(&generics_str);
2177
2178     let snuggle_angle_bracket = generics_str
2179         .lines()
2180         .last()
2181         .map_or(false, |l| l.trim_start().len() == 1);
2182
2183     // Note that the width and indent don't really matter, we'll re-layout the
2184     // return type later anyway.
2185     let ret_str = fd
2186         .output
2187         .rewrite(context, Shape::indented(indent, context.config))?;
2188
2189     let multi_line_ret_str = ret_str.contains('\n');
2190     let ret_str_len = if multi_line_ret_str { 0 } else { ret_str.len() };
2191
2192     // Params.
2193     let (one_line_budget, multi_line_budget, mut param_indent) = compute_budgets_for_params(
2194         context,
2195         &result,
2196         indent,
2197         ret_str_len,
2198         fn_brace_style,
2199         multi_line_ret_str,
2200     )?;
2201
2202     debug!(
2203         "rewrite_fn_base: one_line_budget: {}, multi_line_budget: {}, param_indent: {:?}",
2204         one_line_budget, multi_line_budget, param_indent
2205     );
2206
2207     result.push('(');
2208     // Check if vertical layout was forced.
2209     if one_line_budget == 0
2210         && !snuggle_angle_bracket
2211         && context.config.indent_style() == IndentStyle::Visual
2212     {
2213         result.push_str(&param_indent.to_string_with_newline(context.config));
2214     }
2215
2216     // Skip `pub(crate)`.
2217     let lo_after_visibility = get_bytepos_after_visibility(&fn_sig.visibility, span);
2218     // A conservative estimation, to goal is to be over all parens in generics
2219     let params_start = fn_sig
2220         .generics
2221         .params
2222         .iter()
2223         .last()
2224         .map_or(lo_after_visibility, |param| param.span().hi());
2225     let params_end = if fd.inputs.is_empty() {
2226         context
2227             .snippet_provider
2228             .span_after(mk_sp(params_start, span.hi()), ")")
2229     } else {
2230         let last_span = mk_sp(fd.inputs[fd.inputs.len() - 1].span().hi(), span.hi());
2231         context.snippet_provider.span_after(last_span, ")")
2232     };
2233     let params_span = mk_sp(
2234         context
2235             .snippet_provider
2236             .span_after(mk_sp(params_start, span.hi()), "("),
2237         params_end,
2238     );
2239     let param_str = rewrite_params(
2240         context,
2241         &fd.inputs,
2242         one_line_budget,
2243         multi_line_budget,
2244         indent,
2245         param_indent,
2246         params_span,
2247         fd.c_variadic(),
2248     )?;
2249
2250     let put_params_in_block = match context.config.indent_style() {
2251         IndentStyle::Block => param_str.contains('\n') || param_str.len() > one_line_budget,
2252         _ => false,
2253     } && !fd.inputs.is_empty();
2254
2255     let mut params_last_line_contains_comment = false;
2256     let mut no_params_and_over_max_width = false;
2257
2258     if put_params_in_block {
2259         param_indent = indent.block_indent(context.config);
2260         result.push_str(&param_indent.to_string_with_newline(context.config));
2261         result.push_str(&param_str);
2262         result.push_str(&indent.to_string_with_newline(context.config));
2263         result.push(')');
2264     } else {
2265         result.push_str(&param_str);
2266         let used_width = last_line_used_width(&result, indent.width()) + first_line_width(&ret_str);
2267         // Put the closing brace on the next line if it overflows the max width.
2268         // 1 = `)`
2269         let closing_paren_overflow_max_width =
2270             fd.inputs.is_empty() && used_width + 1 > context.config.max_width();
2271         // If the last line of params contains comment, we cannot put the closing paren
2272         // on the same line.
2273         params_last_line_contains_comment = param_str
2274             .lines()
2275             .last()
2276             .map_or(false, |last_line| last_line.contains("//"));
2277
2278         if context.config.version() == Version::Two {
2279             if closing_paren_overflow_max_width {
2280                 result.push(')');
2281                 result.push_str(&indent.to_string_with_newline(context.config));
2282                 no_params_and_over_max_width = true;
2283             } else if params_last_line_contains_comment {
2284                 result.push_str(&indent.to_string_with_newline(context.config));
2285                 result.push(')');
2286                 no_params_and_over_max_width = true;
2287             } else {
2288                 result.push(')');
2289             }
2290         } else {
2291             if closing_paren_overflow_max_width || params_last_line_contains_comment {
2292                 result.push_str(&indent.to_string_with_newline(context.config));
2293             }
2294             result.push(')');
2295         }
2296     }
2297
2298     // Return type.
2299     if let ast::FnRetTy::Ty(..) = fd.output {
2300         let ret_should_indent = match context.config.indent_style() {
2301             // If our params are block layout then we surely must have space.
2302             IndentStyle::Block if put_params_in_block || fd.inputs.is_empty() => false,
2303             _ if params_last_line_contains_comment => false,
2304             _ if result.contains('\n') || multi_line_ret_str => true,
2305             _ => {
2306                 // If the return type would push over the max width, then put the return type on
2307                 // a new line. With the +1 for the signature length an additional space between
2308                 // the closing parenthesis of the param and the arrow '->' is considered.
2309                 let mut sig_length = result.len() + indent.width() + ret_str_len + 1;
2310
2311                 // If there is no where-clause, take into account the space after the return type
2312                 // and the brace.
2313                 if where_clause.predicates.is_empty() {
2314                     sig_length += 2;
2315                 }
2316
2317                 sig_length > context.config.max_width()
2318             }
2319         };
2320         let ret_shape = if ret_should_indent {
2321             if context.config.version() == Version::One
2322                 || context.config.indent_style() == IndentStyle::Visual
2323             {
2324                 let indent = if param_str.is_empty() {
2325                     // Aligning with non-existent params looks silly.
2326                     force_new_line_for_brace = true;
2327                     indent + 4
2328                 } else {
2329                     // FIXME: we might want to check that using the param indent
2330                     // doesn't blow our budget, and if it does, then fallback to
2331                     // the where-clause indent.
2332                     param_indent
2333                 };
2334
2335                 result.push_str(&indent.to_string_with_newline(context.config));
2336                 Shape::indented(indent, context.config)
2337             } else {
2338                 let mut ret_shape = Shape::indented(indent, context.config);
2339                 if param_str.is_empty() {
2340                     // Aligning with non-existent params looks silly.
2341                     force_new_line_for_brace = true;
2342                     ret_shape = if context.use_block_indent() {
2343                         ret_shape.offset_left(4).unwrap_or(ret_shape)
2344                     } else {
2345                         ret_shape.indent = ret_shape.indent + 4;
2346                         ret_shape
2347                     };
2348                 }
2349
2350                 result.push_str(&ret_shape.indent.to_string_with_newline(context.config));
2351                 ret_shape
2352             }
2353         } else {
2354             if context.config.version() == Version::Two {
2355                 if !param_str.is_empty() || !no_params_and_over_max_width {
2356                     result.push(' ');
2357                 }
2358             } else {
2359                 result.push(' ');
2360             }
2361
2362             let ret_shape = Shape::indented(indent, context.config);
2363             ret_shape
2364                 .offset_left(last_line_width(&result))
2365                 .unwrap_or(ret_shape)
2366         };
2367
2368         if multi_line_ret_str || ret_should_indent {
2369             // Now that we know the proper indent and width, we need to
2370             // re-layout the return type.
2371             let ret_str = fd.output.rewrite(context, ret_shape)?;
2372             result.push_str(&ret_str);
2373         } else {
2374             result.push_str(&ret_str);
2375         }
2376
2377         // Comment between return type and the end of the decl.
2378         let snippet_lo = fd.output.span().hi();
2379         if where_clause.predicates.is_empty() {
2380             let snippet_hi = span.hi();
2381             let snippet = context.snippet(mk_sp(snippet_lo, snippet_hi));
2382             // Try to preserve the layout of the original snippet.
2383             let original_starts_with_newline = snippet
2384                 .find(|c| c != ' ')
2385                 .map_or(false, |i| starts_with_newline(&snippet[i..]));
2386             let original_ends_with_newline = snippet
2387                 .rfind(|c| c != ' ')
2388                 .map_or(false, |i| snippet[i..].ends_with('\n'));
2389             let snippet = snippet.trim();
2390             if !snippet.is_empty() {
2391                 result.push(if original_starts_with_newline {
2392                     '\n'
2393                 } else {
2394                     ' '
2395                 });
2396                 result.push_str(snippet);
2397                 if original_ends_with_newline {
2398                     force_new_line_for_brace = true;
2399                 }
2400             }
2401         }
2402     }
2403
2404     let pos_before_where = match fd.output {
2405         ast::FnRetTy::Default(..) => params_span.hi(),
2406         ast::FnRetTy::Ty(ref ty) => ty.span.hi(),
2407     };
2408
2409     let is_params_multi_lined = param_str.contains('\n');
2410
2411     let space = if put_params_in_block && ret_str.is_empty() {
2412         WhereClauseSpace::Space
2413     } else {
2414         WhereClauseSpace::Newline
2415     };
2416     let mut option = WhereClauseOption::new(fn_brace_style == FnBraceStyle::None, space);
2417     if is_params_multi_lined {
2418         option.veto_single_line();
2419     }
2420     let where_clause_str = rewrite_where_clause(
2421         context,
2422         where_clause,
2423         context.config.brace_style(),
2424         Shape::indented(indent, context.config),
2425         true,
2426         "{",
2427         Some(span.hi()),
2428         pos_before_where,
2429         option,
2430     )?;
2431     // If there are neither where-clause nor return type, we may be missing comments between
2432     // params and `{`.
2433     if where_clause_str.is_empty() {
2434         if let ast::FnRetTy::Default(ret_span) = fd.output {
2435             match recover_missing_comment_in_span(
2436                 mk_sp(params_span.hi(), ret_span.hi()),
2437                 shape,
2438                 context,
2439                 last_line_width(&result),
2440             ) {
2441                 Some(ref missing_comment) if !missing_comment.is_empty() => {
2442                     result.push_str(missing_comment);
2443                     force_new_line_for_brace = true;
2444                 }
2445                 _ => (),
2446             }
2447         }
2448     }
2449
2450     result.push_str(&where_clause_str);
2451
2452     force_new_line_for_brace |= last_line_contains_single_line_comment(&result);
2453     force_new_line_for_brace |= is_params_multi_lined && context.config.where_single_line();
2454     Some((result, force_new_line_for_brace))
2455 }
2456
2457 /// Kind of spaces to put before `where`.
2458 #[derive(Copy, Clone)]
2459 enum WhereClauseSpace {
2460     /// A single space.
2461     Space,
2462     /// A new line.
2463     Newline,
2464     /// Nothing.
2465     None,
2466 }
2467
2468 #[derive(Copy, Clone)]
2469 struct WhereClauseOption {
2470     suppress_comma: bool, // Force no trailing comma
2471     snuggle: WhereClauseSpace,
2472     allow_single_line: bool, // Try single line where-clause instead of vertical layout
2473     veto_single_line: bool,  // Disallow a single-line where-clause.
2474 }
2475
2476 impl WhereClauseOption {
2477     fn new(suppress_comma: bool, snuggle: WhereClauseSpace) -> WhereClauseOption {
2478         WhereClauseOption {
2479             suppress_comma,
2480             snuggle,
2481             allow_single_line: false,
2482             veto_single_line: false,
2483         }
2484     }
2485
2486     fn snuggled(current: &str) -> WhereClauseOption {
2487         WhereClauseOption {
2488             suppress_comma: false,
2489             snuggle: if last_line_width(current) == 1 {
2490                 WhereClauseSpace::Space
2491             } else {
2492                 WhereClauseSpace::Newline
2493             },
2494             allow_single_line: false,
2495             veto_single_line: false,
2496         }
2497     }
2498
2499     fn suppress_comma(&mut self) {
2500         self.suppress_comma = true
2501     }
2502
2503     fn allow_single_line(&mut self) {
2504         self.allow_single_line = true
2505     }
2506
2507     fn snuggle(&mut self) {
2508         self.snuggle = WhereClauseSpace::Space
2509     }
2510
2511     fn veto_single_line(&mut self) {
2512         self.veto_single_line = true;
2513     }
2514 }
2515
2516 fn rewrite_params(
2517     context: &RewriteContext<'_>,
2518     params: &[ast::Param],
2519     one_line_budget: usize,
2520     multi_line_budget: usize,
2521     indent: Indent,
2522     param_indent: Indent,
2523     span: Span,
2524     variadic: bool,
2525 ) -> Option<String> {
2526     if params.is_empty() {
2527         let comment = context
2528             .snippet(mk_sp(
2529                 span.lo(),
2530                 // to remove ')'
2531                 span.hi() - BytePos(1),
2532             ))
2533             .trim();
2534         return Some(comment.to_owned());
2535     }
2536     let param_items: Vec<_> = itemize_list(
2537         context.snippet_provider,
2538         params.iter(),
2539         ")",
2540         ",",
2541         |param| span_lo_for_param(param),
2542         |param| param.ty.span.hi(),
2543         |param| {
2544             param
2545                 .rewrite(context, Shape::legacy(multi_line_budget, param_indent))
2546                 .or_else(|| Some(context.snippet(param.span()).to_owned()))
2547         },
2548         span.lo(),
2549         span.hi(),
2550         false,
2551     )
2552     .collect();
2553
2554     let tactic = definitive_tactic(
2555         &param_items,
2556         context
2557             .config
2558             .fn_args_layout()
2559             .to_list_tactic(param_items.len()),
2560         Separator::Comma,
2561         one_line_budget,
2562     );
2563     let budget = match tactic {
2564         DefinitiveListTactic::Horizontal => one_line_budget,
2565         _ => multi_line_budget,
2566     };
2567     let indent = match context.config.indent_style() {
2568         IndentStyle::Block => indent.block_indent(context.config),
2569         IndentStyle::Visual => param_indent,
2570     };
2571     let trailing_separator = if variadic {
2572         SeparatorTactic::Never
2573     } else {
2574         match context.config.indent_style() {
2575             IndentStyle::Block => context.config.trailing_comma(),
2576             IndentStyle::Visual => SeparatorTactic::Never,
2577         }
2578     };
2579     let fmt = ListFormatting::new(Shape::legacy(budget, indent), context.config)
2580         .tactic(tactic)
2581         .trailing_separator(trailing_separator)
2582         .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
2583         .preserve_newline(true);
2584     write_list(&param_items, &fmt)
2585 }
2586
2587 fn compute_budgets_for_params(
2588     context: &RewriteContext<'_>,
2589     result: &str,
2590     indent: Indent,
2591     ret_str_len: usize,
2592     fn_brace_style: FnBraceStyle,
2593     force_vertical_layout: bool,
2594 ) -> Option<(usize, usize, Indent)> {
2595     debug!(
2596         "compute_budgets_for_params {} {:?}, {}, {:?}",
2597         result.len(),
2598         indent,
2599         ret_str_len,
2600         fn_brace_style,
2601     );
2602     // Try keeping everything on the same line.
2603     if !result.contains('\n') && !force_vertical_layout {
2604         // 2 = `()`, 3 = `() `, space is before ret_string.
2605         let overhead = if ret_str_len == 0 { 2 } else { 3 };
2606         let mut used_space = indent.width() + result.len() + ret_str_len + overhead;
2607         match fn_brace_style {
2608             FnBraceStyle::None => used_space += 1,     // 1 = `;`
2609             FnBraceStyle::SameLine => used_space += 2, // 2 = `{}`
2610             FnBraceStyle::NextLine => (),
2611         }
2612         let one_line_budget = context.budget(used_space);
2613
2614         if one_line_budget > 0 {
2615             // 4 = "() {".len()
2616             let (indent, multi_line_budget) = match context.config.indent_style() {
2617                 IndentStyle::Block => {
2618                     let indent = indent.block_indent(context.config);
2619                     (indent, context.budget(indent.width() + 1))
2620                 }
2621                 IndentStyle::Visual => {
2622                     let indent = indent + result.len() + 1;
2623                     let multi_line_overhead = match fn_brace_style {
2624                         FnBraceStyle::SameLine => 4,
2625                         _ => 2,
2626                     } + indent.width();
2627                     (indent, context.budget(multi_line_overhead))
2628                 }
2629             };
2630
2631             return Some((one_line_budget, multi_line_budget, indent));
2632         }
2633     }
2634
2635     // Didn't work. we must force vertical layout and put params on a newline.
2636     let new_indent = indent.block_indent(context.config);
2637     let used_space = match context.config.indent_style() {
2638         // 1 = `,`
2639         IndentStyle::Block => new_indent.width() + 1,
2640         // Account for `)` and possibly ` {`.
2641         IndentStyle::Visual => new_indent.width() + if ret_str_len == 0 { 1 } else { 3 },
2642     };
2643     Some((0, context.budget(used_space), new_indent))
2644 }
2645
2646 fn newline_for_brace(config: &Config, where_clause: &ast::WhereClause) -> FnBraceStyle {
2647     let predicate_count = where_clause.predicates.len();
2648
2649     if config.where_single_line() && predicate_count == 1 {
2650         return FnBraceStyle::SameLine;
2651     }
2652     let brace_style = config.brace_style();
2653
2654     let use_next_line = brace_style == BraceStyle::AlwaysNextLine
2655         || (brace_style == BraceStyle::SameLineWhere && predicate_count > 0);
2656     if use_next_line {
2657         FnBraceStyle::NextLine
2658     } else {
2659         FnBraceStyle::SameLine
2660     }
2661 }
2662
2663 fn rewrite_generics(
2664     context: &RewriteContext<'_>,
2665     ident: &str,
2666     generics: &ast::Generics,
2667     shape: Shape,
2668 ) -> Option<String> {
2669     // FIXME: convert bounds to where-clauses where they get too big or if
2670     // there is a where-clause at all.
2671
2672     if generics.params.is_empty() {
2673         return Some(ident.to_owned());
2674     }
2675
2676     let params = generics.params.iter();
2677     overflow::rewrite_with_angle_brackets(context, ident, params, shape, generics.span)
2678 }
2679
2680 fn generics_shape_from_config(config: &Config, shape: Shape, offset: usize) -> Option<Shape> {
2681     match config.indent_style() {
2682         IndentStyle::Visual => shape.visual_indent(1 + offset).sub_width(offset + 2),
2683         IndentStyle::Block => {
2684             // 1 = ","
2685             shape
2686                 .block()
2687                 .block_indent(config.tab_spaces())
2688                 .with_max_width(config)
2689                 .sub_width(1)
2690         }
2691     }
2692 }
2693
2694 fn rewrite_where_clause_rfc_style(
2695     context: &RewriteContext<'_>,
2696     where_clause: &ast::WhereClause,
2697     shape: Shape,
2698     terminator: &str,
2699     span_end: Option<BytePos>,
2700     span_end_before_where: BytePos,
2701     where_clause_option: WhereClauseOption,
2702 ) -> Option<String> {
2703     let (where_keyword, allow_single_line) = rewrite_where_keyword(
2704         context,
2705         where_clause,
2706         shape,
2707         span_end_before_where,
2708         where_clause_option,
2709     )?;
2710
2711     // 1 = `,`
2712     let clause_shape = shape
2713         .block()
2714         .with_max_width(context.config)
2715         .block_left(context.config.tab_spaces())?
2716         .sub_width(1)?;
2717     let force_single_line = context.config.where_single_line()
2718         && where_clause.predicates.len() == 1
2719         && !where_clause_option.veto_single_line;
2720
2721     let preds_str = rewrite_bounds_on_where_clause(
2722         context,
2723         where_clause,
2724         clause_shape,
2725         terminator,
2726         span_end,
2727         where_clause_option,
2728         force_single_line,
2729     )?;
2730
2731     // 6 = `where `
2732     let clause_sep =
2733         if allow_single_line && !preds_str.contains('\n') && 6 + preds_str.len() <= shape.width
2734             || force_single_line
2735         {
2736             Cow::from(" ")
2737         } else {
2738             clause_shape.indent.to_string_with_newline(context.config)
2739         };
2740
2741     Some(format!("{}{}{}", where_keyword, clause_sep, preds_str))
2742 }
2743
2744 /// Rewrite `where` and comment around it.
2745 fn rewrite_where_keyword(
2746     context: &RewriteContext<'_>,
2747     where_clause: &ast::WhereClause,
2748     shape: Shape,
2749     span_end_before_where: BytePos,
2750     where_clause_option: WhereClauseOption,
2751 ) -> Option<(String, bool)> {
2752     let block_shape = shape.block().with_max_width(context.config);
2753     // 1 = `,`
2754     let clause_shape = block_shape
2755         .block_left(context.config.tab_spaces())?
2756         .sub_width(1)?;
2757
2758     let comment_separator = |comment: &str, shape: Shape| {
2759         if comment.is_empty() {
2760             Cow::from("")
2761         } else {
2762             shape.indent.to_string_with_newline(context.config)
2763         }
2764     };
2765
2766     let (span_before, span_after) =
2767         missing_span_before_after_where(span_end_before_where, where_clause);
2768     let (comment_before, comment_after) =
2769         rewrite_comments_before_after_where(context, span_before, span_after, shape)?;
2770
2771     let starting_newline = match where_clause_option.snuggle {
2772         WhereClauseSpace::Space if comment_before.is_empty() => Cow::from(" "),
2773         WhereClauseSpace::None => Cow::from(""),
2774         _ => block_shape.indent.to_string_with_newline(context.config),
2775     };
2776
2777     let newline_before_where = comment_separator(&comment_before, shape);
2778     let newline_after_where = comment_separator(&comment_after, clause_shape);
2779     let result = format!(
2780         "{}{}{}where{}{}",
2781         starting_newline, comment_before, newline_before_where, newline_after_where, comment_after
2782     );
2783     let allow_single_line = where_clause_option.allow_single_line
2784         && comment_before.is_empty()
2785         && comment_after.is_empty();
2786
2787     Some((result, allow_single_line))
2788 }
2789
2790 /// Rewrite bounds on a where clause.
2791 fn rewrite_bounds_on_where_clause(
2792     context: &RewriteContext<'_>,
2793     where_clause: &ast::WhereClause,
2794     shape: Shape,
2795     terminator: &str,
2796     span_end: Option<BytePos>,
2797     where_clause_option: WhereClauseOption,
2798     force_single_line: bool,
2799 ) -> Option<String> {
2800     let span_start = where_clause.predicates[0].span().lo();
2801     // If we don't have the start of the next span, then use the end of the
2802     // predicates, but that means we miss comments.
2803     let len = where_clause.predicates.len();
2804     let end_of_preds = where_clause.predicates[len - 1].span().hi();
2805     let span_end = span_end.unwrap_or(end_of_preds);
2806     let items = itemize_list(
2807         context.snippet_provider,
2808         where_clause.predicates.iter(),
2809         terminator,
2810         ",",
2811         |pred| pred.span().lo(),
2812         |pred| pred.span().hi(),
2813         |pred| pred.rewrite(context, shape),
2814         span_start,
2815         span_end,
2816         false,
2817     );
2818     let comma_tactic = if where_clause_option.suppress_comma || force_single_line {
2819         SeparatorTactic::Never
2820     } else {
2821         context.config.trailing_comma()
2822     };
2823
2824     // shape should be vertical only and only if we have `force_single_line` option enabled
2825     // and the number of items of the where-clause is equal to 1
2826     let shape_tactic = if force_single_line {
2827         DefinitiveListTactic::Horizontal
2828     } else {
2829         DefinitiveListTactic::Vertical
2830     };
2831
2832     let fmt = ListFormatting::new(shape, context.config)
2833         .tactic(shape_tactic)
2834         .trailing_separator(comma_tactic)
2835         .preserve_newline(true);
2836     write_list(&items.collect::<Vec<_>>(), &fmt)
2837 }
2838
2839 fn rewrite_where_clause(
2840     context: &RewriteContext<'_>,
2841     where_clause: &ast::WhereClause,
2842     brace_style: BraceStyle,
2843     shape: Shape,
2844     on_new_line: bool,
2845     terminator: &str,
2846     span_end: Option<BytePos>,
2847     span_end_before_where: BytePos,
2848     where_clause_option: WhereClauseOption,
2849 ) -> Option<String> {
2850     if where_clause.predicates.is_empty() {
2851         return Some(String::new());
2852     }
2853
2854     if context.config.indent_style() == IndentStyle::Block {
2855         return rewrite_where_clause_rfc_style(
2856             context,
2857             where_clause,
2858             shape,
2859             terminator,
2860             span_end,
2861             span_end_before_where,
2862             where_clause_option,
2863         );
2864     }
2865
2866     let extra_indent = Indent::new(context.config.tab_spaces(), 0);
2867
2868     let offset = match context.config.indent_style() {
2869         IndentStyle::Block => shape.indent + extra_indent.block_indent(context.config),
2870         // 6 = "where ".len()
2871         IndentStyle::Visual => shape.indent + extra_indent + 6,
2872     };
2873     // FIXME: if indent_style != Visual, then the budgets below might
2874     // be out by a char or two.
2875
2876     let budget = context.config.max_width() - offset.width();
2877     let span_start = where_clause.predicates[0].span().lo();
2878     // If we don't have the start of the next span, then use the end of the
2879     // predicates, but that means we miss comments.
2880     let len = where_clause.predicates.len();
2881     let end_of_preds = where_clause.predicates[len - 1].span().hi();
2882     let span_end = span_end.unwrap_or(end_of_preds);
2883     let items = itemize_list(
2884         context.snippet_provider,
2885         where_clause.predicates.iter(),
2886         terminator,
2887         ",",
2888         |pred| pred.span().lo(),
2889         |pred| pred.span().hi(),
2890         |pred| pred.rewrite(context, Shape::legacy(budget, offset)),
2891         span_start,
2892         span_end,
2893         false,
2894     );
2895     let item_vec = items.collect::<Vec<_>>();
2896     // FIXME: we don't need to collect here
2897     let tactic = definitive_tactic(&item_vec, ListTactic::Vertical, Separator::Comma, budget);
2898
2899     let mut comma_tactic = context.config.trailing_comma();
2900     // Kind of a hack because we don't usually have trailing commas in where-clauses.
2901     if comma_tactic == SeparatorTactic::Vertical || where_clause_option.suppress_comma {
2902         comma_tactic = SeparatorTactic::Never;
2903     }
2904
2905     let fmt = ListFormatting::new(Shape::legacy(budget, offset), context.config)
2906         .tactic(tactic)
2907         .trailing_separator(comma_tactic)
2908         .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
2909         .preserve_newline(true);
2910     let preds_str = write_list(&item_vec, &fmt)?;
2911
2912     let end_length = if terminator == "{" {
2913         // If the brace is on the next line we don't need to count it otherwise it needs two
2914         // characters " {"
2915         match brace_style {
2916             BraceStyle::AlwaysNextLine | BraceStyle::SameLineWhere => 0,
2917             BraceStyle::PreferSameLine => 2,
2918         }
2919     } else if terminator == "=" {
2920         2
2921     } else {
2922         terminator.len()
2923     };
2924     if on_new_line
2925         || preds_str.contains('\n')
2926         || shape.indent.width() + " where ".len() + preds_str.len() + end_length > shape.width
2927     {
2928         Some(format!(
2929             "\n{}where {}",
2930             (shape.indent + extra_indent).to_string(context.config),
2931             preds_str
2932         ))
2933     } else {
2934         Some(format!(" where {}", preds_str))
2935     }
2936 }
2937
2938 fn missing_span_before_after_where(
2939     before_item_span_end: BytePos,
2940     where_clause: &ast::WhereClause,
2941 ) -> (Span, Span) {
2942     let missing_span_before = mk_sp(before_item_span_end, where_clause.span.lo());
2943     // 5 = `where`
2944     let pos_after_where = where_clause.span.lo() + BytePos(5);
2945     let missing_span_after = mk_sp(pos_after_where, where_clause.predicates[0].span().lo());
2946     (missing_span_before, missing_span_after)
2947 }
2948
2949 fn rewrite_comments_before_after_where(
2950     context: &RewriteContext<'_>,
2951     span_before_where: Span,
2952     span_after_where: Span,
2953     shape: Shape,
2954 ) -> Option<(String, String)> {
2955     let before_comment = rewrite_missing_comment(span_before_where, shape, context)?;
2956     let after_comment = rewrite_missing_comment(
2957         span_after_where,
2958         shape.block_indent(context.config.tab_spaces()),
2959         context,
2960     )?;
2961     Some((before_comment, after_comment))
2962 }
2963
2964 fn format_header(
2965     context: &RewriteContext<'_>,
2966     item_name: &str,
2967     ident: ast::Ident,
2968     vis: &ast::Visibility,
2969 ) -> String {
2970     format!(
2971         "{}{}{}",
2972         format_visibility(context, vis),
2973         item_name,
2974         rewrite_ident(context, ident)
2975     )
2976 }
2977
2978 #[derive(PartialEq, Eq, Clone, Copy)]
2979 enum BracePos {
2980     None,
2981     Auto,
2982     ForceSameLine,
2983 }
2984
2985 fn format_generics(
2986     context: &RewriteContext<'_>,
2987     generics: &ast::Generics,
2988     brace_style: BraceStyle,
2989     brace_pos: BracePos,
2990     offset: Indent,
2991     span: Span,
2992     used_width: usize,
2993 ) -> Option<String> {
2994     let shape = Shape::legacy(context.budget(used_width + offset.width()), offset);
2995     let mut result = rewrite_generics(context, "", generics, shape)?;
2996
2997     // If the generics are not parameterized then generics.span.hi() == 0,
2998     // so we use span.lo(), which is the position after `struct Foo`.
2999     let span_end_before_where = if !generics.params.is_empty() {
3000         generics.span.hi()
3001     } else {
3002         span.lo()
3003     };
3004     let (same_line_brace, missed_comments) = if !generics.where_clause.predicates.is_empty() {
3005         let budget = context.budget(last_line_used_width(&result, offset.width()));
3006         let mut option = WhereClauseOption::snuggled(&result);
3007         if brace_pos == BracePos::None {
3008             option.suppress_comma = true;
3009         }
3010         let where_clause_str = rewrite_where_clause(
3011             context,
3012             &generics.where_clause,
3013             brace_style,
3014             Shape::legacy(budget, offset.block_only()),
3015             true,
3016             "{",
3017             Some(span.hi()),
3018             span_end_before_where,
3019             option,
3020         )?;
3021         result.push_str(&where_clause_str);
3022         (
3023             brace_pos == BracePos::ForceSameLine || brace_style == BraceStyle::PreferSameLine,
3024             // missed comments are taken care of in #rewrite_where_clause
3025             None,
3026         )
3027     } else {
3028         (
3029             brace_pos == BracePos::ForceSameLine
3030                 || (result.contains('\n') && brace_style == BraceStyle::PreferSameLine
3031                     || brace_style != BraceStyle::AlwaysNextLine)
3032                 || trimmed_last_line_width(&result) == 1,
3033             rewrite_missing_comment(
3034                 mk_sp(
3035                     span_end_before_where,
3036                     if brace_pos == BracePos::None {
3037                         span.hi()
3038                     } else {
3039                         context.snippet_provider.span_before(span, "{")
3040                     },
3041                 ),
3042                 shape,
3043                 context,
3044             ),
3045         )
3046     };
3047     // add missing comments
3048     let missed_line_comments = missed_comments
3049         .filter(|missed_comments| !missed_comments.is_empty())
3050         .map_or(false, |missed_comments| {
3051             let is_block = is_last_comment_block(&missed_comments);
3052             let sep = if is_block { " " } else { "\n" };
3053             result.push_str(sep);
3054             result.push_str(&missed_comments);
3055             !is_block
3056         });
3057     if brace_pos == BracePos::None {
3058         return Some(result);
3059     }
3060     let total_used_width = last_line_used_width(&result, used_width);
3061     let remaining_budget = context.budget(total_used_width);
3062     // If the same line brace if forced, it indicates that we are rewriting an item with empty body,
3063     // and hence we take the closer into account as well for one line budget.
3064     // We assume that the closer has the same length as the opener.
3065     let overhead = if brace_pos == BracePos::ForceSameLine {
3066         // 3 = ` {}`
3067         3
3068     } else {
3069         // 2 = ` {`
3070         2
3071     };
3072     let forbid_same_line_brace = missed_line_comments || overhead > remaining_budget;
3073     if !forbid_same_line_brace && same_line_brace {
3074         result.push(' ');
3075     } else {
3076         result.push('\n');
3077         result.push_str(&offset.block_only().to_string(context.config));
3078     }
3079     result.push('{');
3080
3081     Some(result)
3082 }
3083
3084 impl Rewrite for ast::ForeignItem {
3085     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
3086         let attrs_str = self.attrs.rewrite(context, shape)?;
3087         // Drop semicolon or it will be interpreted as comment.
3088         // FIXME: this may be a faulty span from libsyntax.
3089         let span = mk_sp(self.span.lo(), self.span.hi() - BytePos(1));
3090
3091         let item_str = match self.kind {
3092             ast::ForeignItemKind::Fn(_, ref fn_sig, ref generics, _) => rewrite_fn_base(
3093                 context,
3094                 shape.indent,
3095                 self.ident,
3096                 &FnSig::new(&fn_sig.decl, generics, self.vis.clone()),
3097                 span,
3098                 FnBraceStyle::None,
3099             )
3100             .map(|(s, _)| format!("{};", s)),
3101             ast::ForeignItemKind::Static(ref ty, mutability, _) => {
3102                 // FIXME(#21): we're dropping potential comments in between the
3103                 // function kw here.
3104                 let vis = format_visibility(context, &self.vis);
3105                 let mut_str = format_mutability(mutability);
3106                 let prefix = format!(
3107                     "{}static {}{}:",
3108                     vis,
3109                     mut_str,
3110                     rewrite_ident(context, self.ident)
3111                 );
3112                 // 1 = ;
3113                 rewrite_assign_rhs(context, prefix, &**ty, shape.sub_width(1)?).map(|s| s + ";")
3114             }
3115             ast::ForeignItemKind::TyAlias(..) => {
3116                 let vis = format_visibility(context, &self.vis);
3117                 Some(format!(
3118                     "{}type {};",
3119                     vis,
3120                     rewrite_ident(context, self.ident)
3121                 ))
3122             }
3123             ast::ForeignItemKind::Macro(ref mac) => {
3124                 rewrite_macro(mac, None, context, shape, MacroPosition::Item)
3125             }
3126         }?;
3127
3128         let missing_span = if self.attrs.is_empty() {
3129             mk_sp(self.span.lo(), self.span.lo())
3130         } else {
3131             mk_sp(self.attrs[self.attrs.len() - 1].span.hi(), self.span.lo())
3132         };
3133         combine_strs_with_missing_comments(
3134             context,
3135             &attrs_str,
3136             &item_str,
3137             missing_span,
3138             shape,
3139             false,
3140         )
3141     }
3142 }
3143
3144 /// Rewrite the attributes of an item.
3145 fn rewrite_attrs(
3146     context: &RewriteContext<'_>,
3147     item: &ast::Item,
3148     item_str: &str,
3149     shape: Shape,
3150 ) -> Option<String> {
3151     let attrs = filter_inline_attrs(&item.attrs, item.span());
3152     let attrs_str = attrs.rewrite(context, shape)?;
3153
3154     let missed_span = if attrs.is_empty() {
3155         mk_sp(item.span.lo(), item.span.lo())
3156     } else {
3157         mk_sp(attrs[attrs.len() - 1].span.hi(), item.span.lo())
3158     };
3159
3160     let allow_extend = if attrs.len() == 1 {
3161         let line_len = attrs_str.len() + 1 + item_str.len();
3162         !attrs.first().unwrap().is_doc_comment()
3163             && context.config.inline_attribute_width() >= line_len
3164     } else {
3165         false
3166     };
3167
3168     combine_strs_with_missing_comments(
3169         context,
3170         &attrs_str,
3171         &item_str,
3172         missed_span,
3173         shape,
3174         allow_extend,
3175     )
3176 }
3177
3178 /// Rewrite an inline mod.
3179 /// The given shape is used to format the mod's attributes.
3180 pub(crate) fn rewrite_mod(
3181     context: &RewriteContext<'_>,
3182     item: &ast::Item,
3183     attrs_shape: Shape,
3184 ) -> Option<String> {
3185     let mut result = String::with_capacity(32);
3186     result.push_str(&*format_visibility(context, &item.vis));
3187     result.push_str("mod ");
3188     result.push_str(rewrite_ident(context, item.ident));
3189     result.push(';');
3190     rewrite_attrs(context, item, &result, attrs_shape)
3191 }
3192
3193 /// Rewrite `extern crate foo;`.
3194 /// The given shape is used to format the extern crate's attributes.
3195 pub(crate) fn rewrite_extern_crate(
3196     context: &RewriteContext<'_>,
3197     item: &ast::Item,
3198     attrs_shape: Shape,
3199 ) -> Option<String> {
3200     assert!(is_extern_crate(item));
3201     let new_str = context.snippet(item.span);
3202     let item_str = if contains_comment(new_str) {
3203         new_str.to_owned()
3204     } else {
3205         let no_whitespace = &new_str.split_whitespace().collect::<Vec<&str>>().join(" ");
3206         String::from(&*Regex::new(r"\s;").unwrap().replace(no_whitespace, ";"))
3207     };
3208     rewrite_attrs(context, item, &item_str, attrs_shape)
3209 }
3210
3211 /// Returns `true` for `mod foo;`, false for `mod foo { .. }`.
3212 pub(crate) fn is_mod_decl(item: &ast::Item) -> bool {
3213     match item.kind {
3214         ast::ItemKind::Mod(ref m) => m.inner.hi() != item.span.hi(),
3215         _ => false,
3216     }
3217 }
3218
3219 pub(crate) fn is_use_item(item: &ast::Item) -> bool {
3220     match item.kind {
3221         ast::ItemKind::Use(_) => true,
3222         _ => false,
3223     }
3224 }
3225
3226 pub(crate) fn is_extern_crate(item: &ast::Item) -> bool {
3227     match item.kind {
3228         ast::ItemKind::ExternCrate(..) => true,
3229         _ => false,
3230     }
3231 }