src/tools/rustfmt/src/visitor.rs

   1 use std::cell::{Cell, RefCell};
   2 use std::rc::Rc;
   3
   4 use rustc_ast::{ast, token::DelimToken, visit, AstLike};
   5 use rustc_data_structures::sync::Lrc;
   6 use rustc_span::{symbol, BytePos, Pos, Span, DUMMY_SP};
   7
   8 use crate::attr::*;
   9 use crate::comment::{contains_comment, rewrite_comment, CodeCharKind, CommentCodeSlices};
  10 use crate::config::Version;
  11 use crate::config::{BraceStyle, Config};
  12 use crate::coverage::transform_missing_snippet;
  13 use crate::items::{
  14     format_impl, format_trait, format_trait_alias, is_mod_decl, is_use_item,
  15     rewrite_associated_impl_type, rewrite_extern_crate, rewrite_opaque_impl_type,
  16     rewrite_opaque_type, rewrite_type_alias, FnBraceStyle, FnSig, StaticParts, StructParts,
  17 };
  18 use crate::macros::{macro_style, rewrite_macro, rewrite_macro_def, MacroPosition};
  19 use crate::modules::Module;
  20 use crate::rewrite::{Rewrite, RewriteContext};
  21 use crate::shape::{Indent, Shape};
  22 use crate::skip::{is_skip_attr, SkipContext};
  23 use crate::source_map::{LineRangeUtils, SpanUtils};
  24 use crate::spanned::Spanned;
  25 use crate::stmt::Stmt;
  26 use crate::syntux::session::ParseSess;
  27 use crate::utils::{
  28     self, contains_skip, count_newlines, depr_skip_annotation, format_unsafety, inner_attributes,
  29     last_line_width, mk_sp, ptr_vec_to_ref_vec, rewrite_ident, starts_with_newline, stmt_expr,
  30 };
  31 use crate::{ErrorKind, FormatReport, FormattingError};
  32
  33 /// Creates a string slice corresponding to the specified span.
  34 pub(crate) struct SnippetProvider {
  35     /// A pointer to the content of the file we are formatting.
  36     big_snippet: Lrc<String>,
  37     /// A position of the start of `big_snippet`, used as an offset.
  38     start_pos: usize,
  39     /// An end position of the file that this snippet lives.
  40     end_pos: usize,
  41 }
  42
  43 impl SnippetProvider {
  44     pub(crate) fn span_to_snippet(&self, span: Span) -> Option<&str> {
  45         let start_index = span.lo().to_usize().checked_sub(self.start_pos)?;
  46         let end_index = span.hi().to_usize().checked_sub(self.start_pos)?;
  47         Some(&self.big_snippet[start_index..end_index])
  48     }
  49
  50     pub(crate) fn new(start_pos: BytePos, end_pos: BytePos, big_snippet: Lrc<String>) -> Self {
  51         let start_pos = start_pos.to_usize();
  52         let end_pos = end_pos.to_usize();
  53         SnippetProvider {
  54             big_snippet,
  55             start_pos,
  56             end_pos,
  57         }
  58     }
  59
  60     pub(crate) fn entire_snippet(&self) -> &str {
  61         self.big_snippet.as_str()
  62     }
  63
  64     pub(crate) fn start_pos(&self) -> BytePos {
  65         BytePos::from_usize(self.start_pos)
  66     }
  67
  68     pub(crate) fn end_pos(&self) -> BytePos {
  69         BytePos::from_usize(self.end_pos)
  70     }
  71 }
  72
  73 pub(crate) struct FmtVisitor<'a> {
  74     parent_context: Option<&'a RewriteContext<'a>>,
  75     pub(crate) parse_sess: &'a ParseSess,
  76     pub(crate) buffer: String,
  77     pub(crate) last_pos: BytePos,
  78     // FIXME: use an RAII util or closure for indenting
  79     pub(crate) block_indent: Indent,
  80     pub(crate) config: &'a Config,
  81     pub(crate) is_if_else_block: bool,
  82     pub(crate) snippet_provider: &'a SnippetProvider,
  83     pub(crate) line_number: usize,
  84     /// List of 1-based line ranges which were annotated with skip
  85     /// Both bounds are inclusifs.
  86     pub(crate) skipped_range: Rc<RefCell<Vec<(usize, usize)>>>,
  87     pub(crate) macro_rewrite_failure: bool,
  88     pub(crate) report: FormatReport,
  89     pub(crate) skip_context: SkipContext,
  90     pub(crate) is_macro_def: bool,
  91 }
  92
  93 impl<'a> Drop for FmtVisitor<'a> {
  94     fn drop(&mut self) {
  95         if let Some(ctx) = self.parent_context {
  96             if self.macro_rewrite_failure {
  97                 ctx.macro_rewrite_failure.replace(true);
  98             }
  99         }
 100     }
 101 }
 102
 103 impl<'b, 'a: 'b> FmtVisitor<'a> {
 104     fn set_parent_context(&mut self, context: &'a RewriteContext<'_>) {
 105         self.parent_context = Some(context);
 106     }
 107
 108     pub(crate) fn shape(&self) -> Shape {
 109         Shape::indented(self.block_indent, self.config)
 110     }
 111
 112     fn next_span(&self, hi: BytePos) -> Span {
 113         mk_sp(self.last_pos, hi)
 114     }
 115
 116     fn visit_stmt(&mut self, stmt: &Stmt<'_>, include_empty_semi: bool) {
 117         debug!(
 118             "visit_stmt: {}",
 119             self.parse_sess.span_to_debug_info(stmt.span())
 120         );
 121
 122         if stmt.is_empty() {
 123             // If the statement is empty, just skip over it. Before that, make sure any comment
 124             // snippet preceding the semicolon is picked up.
 125             let snippet = self.snippet(mk_sp(self.last_pos, stmt.span().lo()));
 126             let original_starts_with_newline = snippet
 127                 .find(|c| c != ' ')
 128                 .map_or(false, |i| starts_with_newline(&snippet[i..]));
 129             let snippet = snippet.trim();
 130             if !snippet.is_empty() {
 131                 // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
 132                 // formatting where rustfmt would preserve redundant semicolons on Items in a
 133                 // statement position.
 134                 // See comment within `walk_stmts` for more info
 135                 if include_empty_semi {
 136                     self.format_missing(stmt.span().hi());
 137                 } else {
 138                     if original_starts_with_newline {
 139                         self.push_str("\n");
 140                     }
 141
 142                     self.push_str(&self.block_indent.to_string(self.config));
 143                     self.push_str(snippet);
 144                 }
 145             } else if include_empty_semi {
 146                 self.push_str(";");
 147             }
 148             self.last_pos = stmt.span().hi();
 149             return;
 150         }
 151
 152         match stmt.as_ast_node().kind {
 153             ast::StmtKind::Item(ref item) => {
 154                 self.visit_item(item);
 155                 self.last_pos = stmt.span().hi();
 156             }
 157             ast::StmtKind::Local(..) | ast::StmtKind::Expr(..) | ast::StmtKind::Semi(..) => {
 158                 let attrs = get_attrs_from_stmt(stmt.as_ast_node());
 159                 if contains_skip(attrs) {
 160                     self.push_skipped_with_span(
 161                         attrs,
 162                         stmt.span(),
 163                         get_span_without_attrs(stmt.as_ast_node()),
 164                     );
 165                 } else {
 166                     let shape = self.shape();
 167                     let rewrite = self.with_context(|ctx| stmt.rewrite(&ctx, shape));
 168                     self.push_rewrite(stmt.span(), rewrite)
 169                 }
 170             }
 171             ast::StmtKind::MacCall(ref mac_stmt) => {
 172                 if self.visit_attrs(&mac_stmt.attrs, ast::AttrStyle::Outer) {
 173                     self.push_skipped_with_span(
 174                         &mac_stmt.attrs,
 175                         stmt.span(),
 176                         get_span_without_attrs(stmt.as_ast_node()),
 177                     );
 178                 } else {
 179                     self.visit_mac(&mac_stmt.mac, None, MacroPosition::Statement);
 180                 }
 181                 self.format_missing(stmt.span().hi());
 182             }
 183             ast::StmtKind::Empty => (),
 184         }
 185     }
 186
 187     /// Remove spaces between the opening brace and the first statement or the inner attribute
 188     /// of the block.
 189     fn trim_spaces_after_opening_brace(
 190         &mut self,
 191         b: &ast::Block,
 192         inner_attrs: Option<&[ast::Attribute]>,
 193     ) {
 194         if let Some(first_stmt) = b.stmts.first() {
 195             let hi = inner_attrs
 196                 .and_then(|attrs| inner_attributes(attrs).first().map(|attr| attr.span.lo()))
 197                 .unwrap_or_else(|| first_stmt.span().lo());
 198             let missing_span = self.next_span(hi);
 199             let snippet = self.snippet(missing_span);
 200             let len = CommentCodeSlices::new(snippet)
 201                 .next()
 202                 .and_then(|(kind, _, s)| {
 203                     if kind == CodeCharKind::Normal {
 204                         s.rfind('\n')
 205                     } else {
 206                         None
 207                     }
 208                 });
 209             if let Some(len) = len {
 210                 self.last_pos = self.last_pos + BytePos::from_usize(len);
 211             }
 212         }
 213     }
 214
 215     pub(crate) fn visit_block(
 216         &mut self,
 217         b: &ast::Block,
 218         inner_attrs: Option<&[ast::Attribute]>,
 219         has_braces: bool,
 220     ) {
 221         debug!(
 222             "visit_block: {}",
 223             self.parse_sess.span_to_debug_info(b.span),
 224         );
 225
 226         // Check if this block has braces.
 227         let brace_compensation = BytePos(if has_braces { 1 } else { 0 });
 228
 229         self.last_pos = self.last_pos + brace_compensation;
 230         self.block_indent = self.block_indent.block_indent(self.config);
 231         self.push_str("{");
 232         self.trim_spaces_after_opening_brace(b, inner_attrs);
 233
 234         // Format inner attributes if available.
 235         if let Some(attrs) = inner_attrs {
 236             self.visit_attrs(attrs, ast::AttrStyle::Inner);
 237         }
 238
 239         self.walk_block_stmts(b);
 240
 241         if !b.stmts.is_empty() {
 242             if let Some(expr) = stmt_expr(&b.stmts[b.stmts.len() - 1]) {
 243                 if utils::semicolon_for_expr(&self.get_context(), expr) {
 244                     self.push_str(";");
 245                 }
 246             }
 247         }
 248
 249         let rest_span = self.next_span(b.span.hi());
 250         if out_of_file_lines_range!(self, rest_span) {
 251             self.push_str(self.snippet(rest_span));
 252             self.block_indent = self.block_indent.block_unindent(self.config);
 253         } else {
 254             // Ignore the closing brace.
 255             let missing_span = self.next_span(b.span.hi() - brace_compensation);
 256             self.close_block(missing_span, self.unindent_comment_on_closing_brace(b));
 257         }
 258         self.last_pos = source!(self, b.span).hi();
 259     }
 260
 261     fn close_block(&mut self, span: Span, unindent_comment: bool) {
 262         let config = self.config;
 263
 264         let mut last_hi = span.lo();
 265         let mut unindented = false;
 266         let mut prev_ends_with_newline = false;
 267         let mut extra_newline = false;
 268
 269         let skip_normal = |s: &str| {
 270             let trimmed = s.trim();
 271             trimmed.is_empty() || trimmed.chars().all(|c| c == ';')
 272         };
 273
 274         let comment_snippet = self.snippet(span);
 275
 276         let align_to_right = if unindent_comment && contains_comment(&comment_snippet) {
 277             let first_lines = comment_snippet.splitn(2, '/').next().unwrap_or("");
 278             last_line_width(first_lines) > last_line_width(&comment_snippet)
 279         } else {
 280             false
 281         };
 282
 283         for (kind, offset, sub_slice) in CommentCodeSlices::new(comment_snippet) {
 284             let sub_slice = transform_missing_snippet(config, sub_slice);
 285
 286             debug!("close_block: {:?} {:?} {:?}", kind, offset, sub_slice);
 287
 288             match kind {
 289                 CodeCharKind::Comment => {
 290                     if !unindented && unindent_comment && !align_to_right {
 291                         unindented = true;
 292                         self.block_indent = self.block_indent.block_unindent(config);
 293                     }
 294                     let span_in_between = mk_sp(last_hi, span.lo() + BytePos::from_usize(offset));
 295                     let snippet_in_between = self.snippet(span_in_between);
 296                     let mut comment_on_same_line = !snippet_in_between.contains('\n');
 297
 298                     let mut comment_shape =
 299                         Shape::indented(self.block_indent, config).comment(config);
 300                     if self.config.version() == Version::Two && comment_on_same_line {
 301                         self.push_str(" ");
 302                         // put the first line of the comment on the same line as the
 303                         // block's last line
 304                         match sub_slice.find('\n') {
 305                             None => {
 306                                 self.push_str(&sub_slice);
 307                             }
 308                             Some(offset) if offset + 1 == sub_slice.len() => {
 309                                 self.push_str(&sub_slice[..offset]);
 310                             }
 311                             Some(offset) => {
 312                                 let first_line = &sub_slice[..offset];
 313                                 self.push_str(first_line);
 314                                 self.push_str(&self.block_indent.to_string_with_newline(config));
 315
 316                                 // put the other lines below it, shaping it as needed
 317                                 let other_lines = &sub_slice[offset + 1..];
 318                                 let comment_str =
 319                                     rewrite_comment(other_lines, false, comment_shape, config);
 320                                 match comment_str {
 321                                     Some(ref s) => self.push_str(s),
 322                                     None => self.push_str(other_lines),
 323                                 }
 324                             }
 325                         }
 326                     } else {
 327                         if comment_on_same_line {
 328                             // 1 = a space before `//`
 329                             let offset_len = 1 + last_line_width(&self.buffer)
 330                                 .saturating_sub(self.block_indent.width());
 331                             match comment_shape
 332                                 .visual_indent(offset_len)
 333                                 .sub_width(offset_len)
 334                             {
 335                                 Some(shp) => comment_shape = shp,
 336                                 None => comment_on_same_line = false,
 337                             }
 338                         };
 339
 340                         if comment_on_same_line {
 341                             self.push_str(" ");
 342                         } else {
 343                             if count_newlines(snippet_in_between) >= 2 || extra_newline {
 344                                 self.push_str("\n");
 345                             }
 346                             self.push_str(&self.block_indent.to_string_with_newline(config));
 347                         }
 348
 349                         let comment_str = rewrite_comment(&sub_slice, false, comment_shape, config);
 350                         match comment_str {
 351                             Some(ref s) => self.push_str(s),
 352                             None => self.push_str(&sub_slice),
 353                         }
 354                     }
 355                 }
 356                 CodeCharKind::Normal if skip_normal(&sub_slice) => {
 357                     extra_newline = prev_ends_with_newline && sub_slice.contains('\n');
 358                     continue;
 359                 }
 360                 CodeCharKind::Normal => {
 361                     self.push_str(&self.block_indent.to_string_with_newline(config));
 362                     self.push_str(sub_slice.trim());
 363                 }
 364             }
 365             prev_ends_with_newline = sub_slice.ends_with('\n');
 366             extra_newline = false;
 367             last_hi = span.lo() + BytePos::from_usize(offset + sub_slice.len());
 368         }
 369         if unindented {
 370             self.block_indent = self.block_indent.block_indent(self.config);
 371         }
 372         self.block_indent = self.block_indent.block_unindent(self.config);
 373         self.push_str(&self.block_indent.to_string_with_newline(config));
 374         self.push_str("}");
 375     }
 376
 377     fn unindent_comment_on_closing_brace(&self, b: &ast::Block) -> bool {
 378         self.is_if_else_block && !b.stmts.is_empty()
 379     }
 380
 381     // Note that this only gets called for function definitions. Required methods
 382     // on traits do not get handled here.
 383     pub(crate) fn visit_fn(
 384         &mut self,
 385         fk: visit::FnKind<'_>,
 386         generics: &ast::Generics,
 387         fd: &ast::FnDecl,
 388         s: Span,
 389         defaultness: ast::Defaultness,
 390         inner_attrs: Option<&[ast::Attribute]>,
 391     ) {
 392         let indent = self.block_indent;
 393         let block;
 394         let rewrite = match fk {
 395             visit::FnKind::Fn(_, ident, _, _, Some(ref b)) => {
 396                 block = b;
 397                 self.rewrite_fn_before_block(
 398                     indent,
 399                     ident,
 400                     &FnSig::from_fn_kind(&fk, generics, fd, defaultness),
 401                     mk_sp(s.lo(), b.span.lo()),
 402                 )
 403             }
 404             _ => unreachable!(),
 405         };
 406
 407         if let Some((fn_str, fn_brace_style)) = rewrite {
 408             self.format_missing_with_indent(source!(self, s).lo());
 409
 410             if let Some(rw) = self.single_line_fn(&fn_str, block, inner_attrs) {
 411                 self.push_str(&rw);
 412                 self.last_pos = s.hi();
 413                 return;
 414             }
 415
 416             self.push_str(&fn_str);
 417             match fn_brace_style {
 418                 FnBraceStyle::SameLine => self.push_str(" "),
 419                 FnBraceStyle::NextLine => {
 420                     self.push_str(&self.block_indent.to_string_with_newline(self.config))
 421                 }
 422                 _ => unreachable!(),
 423             }
 424             self.last_pos = source!(self, block.span).lo();
 425         } else {
 426             self.format_missing(source!(self, block.span).lo());
 427         }
 428
 429         self.visit_block(block, inner_attrs, true)
 430     }
 431
 432     pub(crate) fn visit_item(&mut self, item: &ast::Item) {
 433         skip_out_of_file_lines_range_visitor!(self, item.span);
 434
 435         // This is where we bail out if there is a skip attribute. This is only
 436         // complex in the module case. It is complex because the module could be
 437         // in a separate file and there might be attributes in both files, but
 438         // the AST lumps them all together.
 439         let filtered_attrs;
 440         let mut attrs = &item.attrs;
 441         let skip_context_saved = self.skip_context.clone();
 442         self.skip_context.update_with_attrs(&attrs);
 443
 444         let should_visit_node_again = match item.kind {
 445             // For use/extern crate items, skip rewriting attributes but check for a skip attribute.
 446             ast::ItemKind::Use(..) | ast::ItemKind::ExternCrate(_) => {
 447                 if contains_skip(attrs) {
 448                     self.push_skipped_with_span(attrs.as_slice(), item.span(), item.span());
 449                     false
 450                 } else {
 451                     true
 452                 }
 453             }
 454             // Module is inline, in this case we treat it like any other item.
 455             _ if !is_mod_decl(item) => {
 456                 if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) {
 457                     self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span());
 458                     false
 459                 } else {
 460                     true
 461                 }
 462             }
 463             // Module is not inline, but should be skipped.
 464             ast::ItemKind::Mod(..) if contains_skip(&item.attrs) => false,
 465             // Module is not inline and should not be skipped. We want
 466             // to process only the attributes in the current file.
 467             ast::ItemKind::Mod(..) => {
 468                 filtered_attrs = filter_inline_attrs(&item.attrs, item.span());
 469                 // Assert because if we should skip it should be caught by
 470                 // the above case.
 471                 assert!(!self.visit_attrs(&filtered_attrs, ast::AttrStyle::Outer));
 472                 attrs = &filtered_attrs;
 473                 true
 474             }
 475             _ => {
 476                 if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) {
 477                     self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span());
 478                     false
 479                 } else {
 480                     true
 481                 }
 482             }
 483         };
 484
 485         // TODO(calebcartwright): consider enabling box_patterns feature gate
 486         if should_visit_node_again {
 487             match item.kind {
 488                 ast::ItemKind::Use(ref tree) => self.format_import(item, tree),
 489                 ast::ItemKind::Impl { .. } => {
 490                     let block_indent = self.block_indent;
 491                     let rw = self.with_context(|ctx| format_impl(&ctx, item, block_indent));
 492                     self.push_rewrite(item.span, rw);
 493                 }
 494                 ast::ItemKind::Trait(..) => {
 495                     let block_indent = self.block_indent;
 496                     let rw = self.with_context(|ctx| format_trait(&ctx, item, block_indent));
 497                     self.push_rewrite(item.span, rw);
 498                 }
 499                 ast::ItemKind::TraitAlias(ref generics, ref generic_bounds) => {
 500                     let shape = Shape::indented(self.block_indent, self.config);
 501                     let rw = format_trait_alias(
 502                         &self.get_context(),
 503                         item.ident,
 504                         &item.vis,
 505                         generics,
 506                         generic_bounds,
 507                         shape,
 508                     );
 509                     self.push_rewrite(item.span, rw);
 510                 }
 511                 ast::ItemKind::ExternCrate(_) => {
 512                     let rw = rewrite_extern_crate(&self.get_context(), item, self.shape());
 513                     let span = if attrs.is_empty() {
 514                         item.span
 515                     } else {
 516                         mk_sp(attrs[0].span.lo(), item.span.hi())
 517                     };
 518                     self.push_rewrite(span, rw);
 519                 }
 520                 ast::ItemKind::Struct(..) | ast::ItemKind::Union(..) => {
 521                     self.visit_struct(&StructParts::from_item(item));
 522                 }
 523                 ast::ItemKind::Enum(ref def, ref generics) => {
 524                     self.format_missing_with_indent(source!(self, item.span).lo());
 525                     self.visit_enum(item.ident, &item.vis, def, generics, item.span);
 526                     self.last_pos = source!(self, item.span).hi();
 527                 }
 528                 ast::ItemKind::Mod(unsafety, ref mod_kind) => {
 529                     self.format_missing_with_indent(source!(self, item.span).lo());
 530                     self.format_mod(mod_kind, unsafety, &item.vis, item.span, item.ident, attrs);
 531                 }
 532                 ast::ItemKind::MacCall(ref mac) => {
 533                     self.visit_mac(mac, Some(item.ident), MacroPosition::Item);
 534                 }
 535                 ast::ItemKind::ForeignMod(ref foreign_mod) => {
 536                     self.format_missing_with_indent(source!(self, item.span).lo());
 537                     self.format_foreign_mod(foreign_mod, item.span);
 538                 }
 539                 ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => {
 540                     self.visit_static(&StaticParts::from_item(item));
 541                 }
 542                 ast::ItemKind::Fn(ref fn_kind) => {
 543                     let ast::FnKind(defaultness, ref fn_signature, ref generics, ref block) =
 544                         **fn_kind;
 545                     if let Some(ref body) = block {
 546                         let inner_attrs = inner_attributes(&item.attrs);
 547                         let fn_ctxt = match fn_signature.header.ext {
 548                             ast::Extern::None => visit::FnCtxt::Free,
 549                             _ => visit::FnCtxt::Foreign,
 550                         };
 551                         self.visit_fn(
 552                             visit::FnKind::Fn(
 553                                 fn_ctxt,
 554                                 item.ident,
 555                                 &fn_signature,
 556                                 &item.vis,
 557                                 Some(body),
 558                             ),
 559                             generics,
 560                             &fn_signature.decl,
 561                             item.span,
 562                             defaultness,
 563                             Some(&inner_attrs),
 564                         )
 565                     } else {
 566                         let indent = self.block_indent;
 567                         let rewrite = self.rewrite_required_fn(
 568                             indent,
 569                             item.ident,
 570                             &fn_signature,
 571                             generics,
 572                             item.span,
 573                         );
 574                         self.push_rewrite(item.span, rewrite);
 575                     }
 576                 }
 577                 ast::ItemKind::TyAlias(ref alias_kind) => {
 578                     let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref ty) =
 579                         **alias_kind;
 580                     match ty {
 581                         Some(ty) => {
 582                             let rewrite = rewrite_type_alias(
 583                                 item.ident,
 584                                 Some(&*ty),
 585                                 generics,
 586                                 Some(generic_bounds),
 587                                 &self.get_context(),
 588                                 self.block_indent,
 589                                 &item.vis,
 590                                 item.span,
 591                             );
 592                             self.push_rewrite(item.span, rewrite);
 593                         }
 594                         None => {
 595                             let rewrite = rewrite_opaque_type(
 596                                 &self.get_context(),
 597                                 self.block_indent,
 598                                 item.ident,
 599                                 generic_bounds,
 600                                 generics,
 601                                 &item.vis,
 602                                 item.span,
 603                             );
 604                             self.push_rewrite(item.span, rewrite);
 605                         }
 606                     }
 607                 }
 608                 ast::ItemKind::GlobalAsm(..) => {
 609                     let snippet = Some(self.snippet(item.span).to_owned());
 610                     self.push_rewrite(item.span, snippet);
 611                 }
 612                 ast::ItemKind::MacroDef(ref def) => {
 613                     let rewrite = rewrite_macro_def(
 614                         &self.get_context(),
 615                         self.shape(),
 616                         self.block_indent,
 617                         def,
 618                         item.ident,
 619                         &item.vis,
 620                         item.span,
 621                     );
 622                     self.push_rewrite(item.span, rewrite);
 623                 }
 624             };
 625         }
 626         self.skip_context = skip_context_saved;
 627     }
 628
 629     pub(crate) fn visit_trait_item(&mut self, ti: &ast::AssocItem) {
 630         skip_out_of_file_lines_range_visitor!(self, ti.span);
 631
 632         if self.visit_attrs(&ti.attrs, ast::AttrStyle::Outer) {
 633             self.push_skipped_with_span(ti.attrs.as_slice(), ti.span(), ti.span());
 634             return;
 635         }
 636
 637         // TODO(calebcartwright): consider enabling box_patterns feature gate
 638         match ti.kind {
 639             ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_trait_item(ti)),
 640             ast::AssocItemKind::Fn(ref fn_kind) => {
 641                 let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
 642                 if let Some(ref body) = block {
 643                     let inner_attrs = inner_attributes(&ti.attrs);
 644                     let vis = ast::Visibility {
 645                         kind: ast::VisibilityKind::Inherited,
 646                         span: DUMMY_SP,
 647                         tokens: None,
 648                     };
 649                     let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Trait);
 650                     self.visit_fn(
 651                         visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &vis, Some(body)),
 652                         generics,
 653                         &sig.decl,
 654                         ti.span,
 655                         defaultness,
 656                         Some(&inner_attrs),
 657                     );
 658                 } else {
 659                     let indent = self.block_indent;
 660                     let rewrite =
 661                         self.rewrite_required_fn(indent, ti.ident, sig, generics, ti.span);
 662                     self.push_rewrite(ti.span, rewrite);
 663                 }
 664             }
 665             ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
 666                 let ast::TyAliasKind(_, ref generics, ref generic_bounds, ref type_default) =
 667                     **ty_alias_kind;
 668                 let rewrite = rewrite_type_alias(
 669                     ti.ident,
 670                     type_default.as_ref(),
 671                     generics,
 672                     Some(generic_bounds),
 673                     &self.get_context(),
 674                     self.block_indent,
 675                     &ti.vis,
 676                     ti.span,
 677                 );
 678                 self.push_rewrite(ti.span, rewrite);
 679             }
 680             ast::AssocItemKind::MacCall(ref mac) => {
 681                 self.visit_mac(mac, Some(ti.ident), MacroPosition::Item);
 682             }
 683         }
 684     }
 685
 686     pub(crate) fn visit_impl_item(&mut self, ii: &ast::AssocItem) {
 687         skip_out_of_file_lines_range_visitor!(self, ii.span);
 688
 689         if self.visit_attrs(&ii.attrs, ast::AttrStyle::Outer) {
 690             self.push_skipped_with_span(ii.attrs.as_slice(), ii.span, ii.span);
 691             return;
 692         }
 693
 694         match ii.kind {
 695             ast::AssocItemKind::Fn(ref fn_kind) => {
 696                 let ast::FnKind(defaultness, ref sig, ref generics, ref block) = **fn_kind;
 697                 if let Some(ref body) = block {
 698                     let inner_attrs = inner_attributes(&ii.attrs);
 699                     let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Impl);
 700                     self.visit_fn(
 701                         visit::FnKind::Fn(fn_ctxt, ii.ident, sig, &ii.vis, Some(body)),
 702                         generics,
 703                         &sig.decl,
 704                         ii.span,
 705                         defaultness,
 706                         Some(&inner_attrs),
 707                     );
 708                 } else {
 709                     let indent = self.block_indent;
 710                     let rewrite =
 711                         self.rewrite_required_fn(indent, ii.ident, sig, generics, ii.span);
 712                     self.push_rewrite(ii.span, rewrite);
 713                 }
 714             }
 715             ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_impl_item(ii)),
 716             ast::AssocItemKind::TyAlias(ref ty_alias_kind) => {
 717                 let ast::TyAliasKind(defaultness, ref generics, _, ref ty) = **ty_alias_kind;
 718                 let rewrite_associated = || {
 719                     rewrite_associated_impl_type(
 720                         ii.ident,
 721                         &ii.vis,
 722                         defaultness,
 723                         ty.as_ref(),
 724                         &generics,
 725                         &self.get_context(),
 726                         self.block_indent,
 727                         ii.span,
 728                     )
 729                 };
 730                 let rewrite = match ty {
 731                     None => rewrite_associated(),
 732                     Some(ty) => match ty.kind {
 733                         ast::TyKind::ImplTrait(_, ref bounds) => rewrite_opaque_impl_type(
 734                             &self.get_context(),
 735                             ii.ident,
 736                             generics,
 737                             bounds,
 738                             self.block_indent,
 739                         ),
 740                         _ => rewrite_associated(),
 741                     },
 742                 };
 743                 self.push_rewrite(ii.span, rewrite);
 744             }
 745             ast::AssocItemKind::MacCall(ref mac) => {
 746                 self.visit_mac(mac, Some(ii.ident), MacroPosition::Item);
 747             }
 748         }
 749     }
 750
 751     fn visit_mac(&mut self, mac: &ast::MacCall, ident: Option<symbol::Ident>, pos: MacroPosition) {
 752         skip_out_of_file_lines_range_visitor!(self, mac.span());
 753
 754         // 1 = ;
 755         let shape = self.shape().saturating_sub_width(1);
 756         let rewrite = self.with_context(|ctx| rewrite_macro(mac, ident, ctx, shape, pos));
 757         // As of v638 of the rustc-ap-* crates, the associated span no longer includes
 758         // the trailing semicolon. This determines the correct span to ensure scenarios
 759         // with whitespace between the delimiters and trailing semi (i.e. `foo!(abc)     ;`)
 760         // are formatted correctly.
 761         let (span, rewrite) = match macro_style(mac, &self.get_context()) {
 762             DelimToken::Bracket | DelimToken::Paren if MacroPosition::Item == pos => {
 763                 let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos());
 764                 let hi = self.snippet_provider.span_before(search_span, ";");
 765                 let target_span = mk_sp(mac.span().lo(), hi + BytePos(1));
 766                 let rewrite = rewrite.map(|rw| {
 767                     if !rw.ends_with(';') {
 768                         format!("{};", rw)
 769                     } else {
 770                         rw
 771                     }
 772                 });
 773                 (target_span, rewrite)
 774             }
 775             _ => (mac.span(), rewrite),
 776         };
 777
 778         self.push_rewrite(span, rewrite);
 779     }
 780
 781     pub(crate) fn push_str(&mut self, s: &str) {
 782         self.line_number += count_newlines(s);
 783         self.buffer.push_str(s);
 784     }
 785
 786     #[allow(clippy::needless_pass_by_value)]
 787     fn push_rewrite_inner(&mut self, span: Span, rewrite: Option<String>) {
 788         if let Some(ref s) = rewrite {
 789             self.push_str(s);
 790         } else {
 791             let snippet = self.snippet(span);
 792             self.push_str(snippet.trim());
 793         }
 794         self.last_pos = source!(self, span).hi();
 795     }
 796
 797     pub(crate) fn push_rewrite(&mut self, span: Span, rewrite: Option<String>) {
 798         self.format_missing_with_indent(source!(self, span).lo());
 799         self.push_rewrite_inner(span, rewrite);
 800     }
 801
 802     pub(crate) fn push_skipped_with_span(
 803         &mut self,
 804         attrs: &[ast::Attribute],
 805         item_span: Span,
 806         main_span: Span,
 807     ) {
 808         self.format_missing_with_indent(source!(self, item_span).lo());
 809         // do not take into account the lines with attributes as part of the skipped range
 810         let attrs_end = attrs
 811             .iter()
 812             .map(|attr| self.parse_sess.line_of_byte_pos(attr.span.hi()))
 813             .max()
 814             .unwrap_or(1);
 815         let first_line = self.parse_sess.line_of_byte_pos(main_span.lo());
 816         // Statement can start after some newlines and/or spaces
 817         // or it can be on the same line as the last attribute.
 818         // So here we need to take a minimum between the two.
 819         let lo = std::cmp::min(attrs_end + 1, first_line);
 820         self.push_rewrite_inner(item_span, None);
 821         let hi = self.line_number + 1;
 822         self.skipped_range.borrow_mut().push((lo, hi));
 823     }
 824
 825     pub(crate) fn from_context(ctx: &'a RewriteContext<'_>) -> FmtVisitor<'a> {
 826         let mut visitor = FmtVisitor::from_parse_sess(
 827             ctx.parse_sess,
 828             ctx.config,
 829             ctx.snippet_provider,
 830             ctx.report.clone(),
 831         );
 832         visitor.skip_context.update(ctx.skip_context.clone());
 833         visitor.set_parent_context(ctx);
 834         visitor
 835     }
 836
 837     pub(crate) fn from_parse_sess(
 838         parse_session: &'a ParseSess,
 839         config: &'a Config,
 840         snippet_provider: &'a SnippetProvider,
 841         report: FormatReport,
 842     ) -> FmtVisitor<'a> {
 843         FmtVisitor {
 844             parent_context: None,
 845             parse_sess: parse_session,
 846             buffer: String::with_capacity(snippet_provider.big_snippet.len() * 2),
 847             last_pos: BytePos(0),
 848             block_indent: Indent::empty(),
 849             config,
 850             is_if_else_block: false,
 851             snippet_provider,
 852             line_number: 0,
 853             skipped_range: Rc::new(RefCell::new(vec![])),
 854             is_macro_def: false,
 855             macro_rewrite_failure: false,
 856             report,
 857             skip_context: Default::default(),
 858         }
 859     }
 860
 861     pub(crate) fn opt_snippet(&'b self, span: Span) -> Option<&'a str> {
 862         self.snippet_provider.span_to_snippet(span)
 863     }
 864
 865     pub(crate) fn snippet(&'b self, span: Span) -> &'a str {
 866         self.opt_snippet(span).unwrap()
 867     }
 868
 869     // Returns true if we should skip the following item.
 870     pub(crate) fn visit_attrs(&mut self, attrs: &[ast::Attribute], style: ast::AttrStyle) -> bool {
 871         for attr in attrs {
 872             if attr.has_name(depr_skip_annotation()) {
 873                 let file_name = self.parse_sess.span_to_filename(attr.span);
 874                 self.report.append(
 875                     file_name,
 876                     vec![FormattingError::from_span(
 877                         attr.span,
 878                         self.parse_sess,
 879                         ErrorKind::DeprecatedAttr,
 880                     )],
 881                 );
 882             } else {
 883                 match &attr.kind {
 884                     ast::AttrKind::Normal(ref attribute_item, _)
 885                         if self.is_unknown_rustfmt_attr(&attribute_item.path.segments) =>
 886                     {
 887                         let file_name = self.parse_sess.span_to_filename(attr.span);
 888                         self.report.append(
 889                             file_name,
 890                             vec![FormattingError::from_span(
 891                                 attr.span,
 892                                 self.parse_sess,
 893                                 ErrorKind::BadAttr,
 894                             )],
 895                         );
 896                     }
 897                     _ => (),
 898                 }
 899             }
 900         }
 901         if contains_skip(attrs) {
 902             return true;
 903         }
 904
 905         let attrs: Vec<_> = attrs.iter().filter(|a| a.style == style).cloned().collect();
 906         if attrs.is_empty() {
 907             return false;
 908         }
 909
 910         let rewrite = attrs.rewrite(&self.get_context(), self.shape());
 911         let span = mk_sp(attrs[0].span.lo(), attrs[attrs.len() - 1].span.hi());
 912         self.push_rewrite(span, rewrite);
 913
 914         false
 915     }
 916
 917     fn is_unknown_rustfmt_attr(&self, segments: &[ast::PathSegment]) -> bool {
 918         if segments[0].ident.to_string() != "rustfmt" {
 919             return false;
 920         }
 921         !is_skip_attr(segments)
 922     }
 923
 924     fn walk_mod_items(&mut self, items: &[rustc_ast::ptr::P<ast::Item>]) {
 925         self.visit_items_with_reordering(&ptr_vec_to_ref_vec(&items));
 926     }
 927
 928     fn walk_stmts(&mut self, stmts: &[Stmt<'_>], include_current_empty_semi: bool) {
 929         if stmts.is_empty() {
 930             return;
 931         }
 932
 933         // Extract leading `use ...;`.
 934         let items: Vec<_> = stmts
 935             .iter()
 936             .take_while(|stmt| stmt.to_item().map_or(false, is_use_item))
 937             .filter_map(|stmt| stmt.to_item())
 938             .collect();
 939
 940         if items.is_empty() {
 941             self.visit_stmt(&stmts[0], include_current_empty_semi);
 942
 943             // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
 944             // formatting where rustfmt would preserve redundant semicolons on Items in a
 945             // statement position.
 946             //
 947             // Starting in rustc-ap-* v692 (~2020-12-01) the rustc parser now parses this as
 948             // two separate statements (Item and Empty kinds), whereas before it was parsed as
 949             // a single statement with the statement's span including the redundant semicolon.
 950             //
 951             // rustfmt typically tosses unnecessary/redundant semicolons, and eventually we
 952             // should toss these as well, but doing so at this time would
 953             // break the Stability Guarantee
 954             // N.B. This could be updated to utilize the version gates.
 955             let include_next_empty = if stmts.len() > 1 {
 956                 matches!(
 957                     (&stmts[0].as_ast_node().kind, &stmts[1].as_ast_node().kind),
 958                     (ast::StmtKind::Item(_), ast::StmtKind::Empty)
 959                 )
 960             } else {
 961                 false
 962             };
 963
 964             self.walk_stmts(&stmts[1..], include_next_empty);
 965         } else {
 966             self.visit_items_with_reordering(&items);
 967             self.walk_stmts(&stmts[items.len()..], false);
 968         }
 969     }
 970
 971     fn walk_block_stmts(&mut self, b: &ast::Block) {
 972         self.walk_stmts(&Stmt::from_ast_nodes(b.stmts.iter()), false)
 973     }
 974
 975     fn format_mod(
 976         &mut self,
 977         mod_kind: &ast::ModKind,
 978         unsafety: ast::Unsafe,
 979         vis: &ast::Visibility,
 980         s: Span,
 981         ident: symbol::Ident,
 982         attrs: &[ast::Attribute],
 983     ) {
 984         let vis_str = utils::format_visibility(&self.get_context(), vis);
 985         self.push_str(&*vis_str);
 986         self.push_str(format_unsafety(unsafety));
 987         self.push_str("mod ");
 988         // Calling `to_owned()` to work around borrow checker.
 989         let ident_str = rewrite_ident(&self.get_context(), ident).to_owned();
 990         self.push_str(&ident_str);
 991
 992         if let ast::ModKind::Loaded(ref items, ast::Inline::Yes, inner_span) = mod_kind {
 993             match self.config.brace_style() {
 994                 BraceStyle::AlwaysNextLine => {
 995                     let indent_str = self.block_indent.to_string_with_newline(self.config);
 996                     self.push_str(&indent_str);
 997                     self.push_str("{");
 998                 }
 999                 _ => self.push_str(" {"),
1000             }
1001             // Hackery to account for the closing }.
1002             let mod_lo = self.snippet_provider.span_after(source!(self, s), "{");
1003             let body_snippet =
1004                 self.snippet(mk_sp(mod_lo, source!(self, inner_span).hi() - BytePos(1)));
1005             let body_snippet = body_snippet.trim();
1006             if body_snippet.is_empty() {
1007                 self.push_str("}");
1008             } else {
1009                 self.last_pos = mod_lo;
1010                 self.block_indent = self.block_indent.block_indent(self.config);
1011                 self.visit_attrs(attrs, ast::AttrStyle::Inner);
1012                 self.walk_mod_items(items);
1013                 let missing_span = self.next_span(inner_span.hi() - BytePos(1));
1014                 self.close_block(missing_span, false);
1015             }
1016             self.last_pos = source!(self, inner_span).hi();
1017         } else {
1018             self.push_str(";");
1019             self.last_pos = source!(self, s).hi();
1020         }
1021     }
1022
1023     pub(crate) fn format_separate_mod(&mut self, m: &Module<'_>, end_pos: BytePos) {
1024         self.block_indent = Indent::empty();
1025         if self.visit_attrs(m.attrs(), ast::AttrStyle::Inner) {
1026             self.push_skipped_with_span(m.attrs(), m.span, m.span);
1027         } else {
1028             self.walk_mod_items(&m.items);
1029             self.format_missing_with_indent(end_pos);
1030         }
1031     }
1032
1033     pub(crate) fn skip_empty_lines(&mut self, end_pos: BytePos) {
1034         while let Some(pos) = self
1035             .snippet_provider
1036             .opt_span_after(self.next_span(end_pos), "\n")
1037         {
1038             if let Some(snippet) = self.opt_snippet(self.next_span(pos)) {
1039                 if snippet.trim().is_empty() {
1040                     self.last_pos = pos;
1041                 } else {
1042                     return;
1043                 }
1044             }
1045         }
1046     }
1047
1048     pub(crate) fn with_context<F>(&mut self, f: F) -> Option<String>
1049     where
1050         F: Fn(&RewriteContext<'_>) -> Option<String>,
1051     {
1052         let context = self.get_context();
1053         let result = f(&context);
1054
1055         self.macro_rewrite_failure |= context.macro_rewrite_failure.get();
1056         result
1057     }
1058
1059     pub(crate) fn get_context(&self) -> RewriteContext<'_> {
1060         RewriteContext {
1061             parse_sess: self.parse_sess,
1062             config: self.config,
1063             inside_macro: Rc::new(Cell::new(false)),
1064             use_block: Cell::new(false),
1065             is_if_else_block: Cell::new(false),
1066             force_one_line_chain: Cell::new(false),
1067             snippet_provider: self.snippet_provider,
1068             macro_rewrite_failure: Cell::new(false),
1069             is_macro_def: self.is_macro_def,
1070             report: self.report.clone(),
1071             skip_context: self.skip_context.clone(),
1072             skipped_range: self.skipped_range.clone(),
1073         }
1074     }
1075 }