X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fvisitor.rs;h=fefeffac95c8fc416a510e215e7f6a2ff8664f65;hb=b7c38c9d50fcf48e40cf245b48ab9f36054f40d3;hp=3bd5af3112de3dda6a86975d2fd7f078c1ceeade;hpb=ce5cccc32c3897488d2c503fe9d2a9a429a9b0eb;p=rust.git diff --git a/src/visitor.rs b/src/visitor.rs index 3bd5af3112d..fefeffac95c 100644 --- a/src/visitor.rs +++ b/src/visitor.rs @@ -1,71 +1,92 @@ -use std::cell::RefCell; +use std::cell::{Cell, RefCell}; +use std::rc::Rc; -use syntax::parse::ParseSess; -use syntax::source_map::{self, BytePos, Pos, SourceMap, Span}; -use syntax::{ast, visit}; +use rustc_ast::{ast, attr::HasAttrs, token::DelimToken, visit}; +use rustc_span::{symbol, BytePos, Pos, Span, DUMMY_SP}; use crate::attr::*; -use crate::comment::{CodeCharKind, CommentCodeSlices, FindUncommented}; -use crate::config::{BraceStyle, Config, Version}; -use crate::expr::{format_expr, ExprType}; +use crate::comment::{contains_comment, rewrite_comment, CodeCharKind, CommentCodeSlices}; +use crate::config::Version; +use crate::config::{BraceStyle, Config}; +use crate::coverage::transform_missing_snippet; use crate::items::{ format_impl, format_trait, format_trait_alias, is_mod_decl, is_use_item, - rewrite_associated_impl_type, rewrite_associated_type, rewrite_existential_impl_type, - rewrite_existential_type, rewrite_extern_crate, rewrite_type_alias, FnSig, StaticParts, - StructParts, + rewrite_associated_impl_type, rewrite_extern_crate, rewrite_opaque_impl_type, + rewrite_opaque_type, rewrite_type_alias, FnBraceStyle, FnSig, StaticParts, StructParts, }; -use crate::macros::{rewrite_macro, rewrite_macro_def, MacroPosition}; +use crate::macros::{macro_style, rewrite_macro, rewrite_macro_def, MacroPosition}; +use crate::modules::Module; use crate::rewrite::{Rewrite, RewriteContext}; use crate::shape::{Indent, Shape}; +use crate::skip::{is_skip_attr, SkipContext}; use crate::source_map::{LineRangeUtils, SpanUtils}; use crate::spanned::Spanned; +use crate::stmt::Stmt; +use crate::syntux::session::ParseSess; use crate::utils::{ - self, contains_skip, count_newlines, inner_attributes, mk_sp, ptr_vec_to_ref_vec, - rewrite_ident, stmt_expr, DEPR_SKIP_ANNOTATION, + self, contains_skip, count_newlines, depr_skip_annotation, format_unsafety, inner_attributes, + last_line_width, mk_sp, ptr_vec_to_ref_vec, rewrite_ident, starts_with_newline, stmt_expr, }; use crate::{ErrorKind, FormatReport, FormattingError}; /// Creates a string slice corresponding to the specified span. -pub struct SnippetProvider<'a> { +pub(crate) struct SnippetProvider { /// A pointer to the content of the file we are formatting. - big_snippet: &'a str, + big_snippet: Rc, /// A position of the start of `big_snippet`, used as an offset. start_pos: usize, + /// A end position of the file that this snippet lives. + end_pos: usize, } -impl<'a> SnippetProvider<'a> { - pub fn span_to_snippet(&self, span: Span) -> Option<&str> { +impl SnippetProvider { + pub(crate) fn span_to_snippet(&self, span: Span) -> Option<&str> { let start_index = span.lo().to_usize().checked_sub(self.start_pos)?; let end_index = span.hi().to_usize().checked_sub(self.start_pos)?; Some(&self.big_snippet[start_index..end_index]) } - pub fn new(start_pos: BytePos, big_snippet: &'a str) -> Self { + pub(crate) fn new(start_pos: BytePos, end_pos: BytePos, big_snippet: Rc) -> Self { let start_pos = start_pos.to_usize(); + let end_pos = end_pos.to_usize(); SnippetProvider { big_snippet, start_pos, + end_pos, } } + + pub(crate) fn entire_snippet(&self) -> &str { + self.big_snippet.as_str() + } + + pub(crate) fn start_pos(&self) -> BytePos { + BytePos::from_usize(self.start_pos) + } + + pub(crate) fn end_pos(&self) -> BytePos { + BytePos::from_usize(self.end_pos) + } } -pub struct FmtVisitor<'a> { +pub(crate) struct FmtVisitor<'a> { parent_context: Option<&'a RewriteContext<'a>>, - pub parse_session: &'a ParseSess, - pub source_map: &'a SourceMap, - pub buffer: String, - pub last_pos: BytePos, + pub(crate) parse_sess: &'a ParseSess, + pub(crate) buffer: String, + pub(crate) last_pos: BytePos, // FIXME: use an RAII util or closure for indenting - pub block_indent: Indent, - pub config: &'a Config, - pub is_if_else_block: bool, - pub snippet_provider: &'a SnippetProvider<'a>, - pub line_number: usize, + pub(crate) block_indent: Indent, + pub(crate) config: &'a Config, + pub(crate) is_if_else_block: bool, + pub(crate) snippet_provider: &'a SnippetProvider, + pub(crate) line_number: usize, /// List of 1-based line ranges which were annotated with skip /// Both bounds are inclusifs. - pub skipped_range: Vec<(usize, usize)>, - pub macro_rewrite_failure: bool, + pub(crate) skipped_range: Rc>>, + pub(crate) macro_rewrite_failure: bool, pub(crate) report: FormatReport, + pub(crate) skip_context: SkipContext, + pub(crate) is_macro_def: bool, } impl<'a> Drop for FmtVisitor<'a> { @@ -83,70 +104,89 @@ fn set_parent_context(&mut self, context: &'a RewriteContext<'_>) { self.parent_context = Some(context); } - pub fn shape(&self) -> Shape { + pub(crate) fn shape(&self) -> Shape { Shape::indented(self.block_indent, self.config) } - fn visit_stmt(&mut self, stmt: &ast::Stmt) { + fn next_span(&self, hi: BytePos) -> Span { + mk_sp(self.last_pos, hi) + } + + fn visit_stmt(&mut self, stmt: &Stmt<'_>) { debug!( - "visit_stmt: {:?} {:?}", - self.source_map.lookup_char_pos(stmt.span.lo()), - self.source_map.lookup_char_pos(stmt.span.hi()) + "visit_stmt: {}", + self.parse_sess.span_to_debug_info(stmt.span()) ); - match stmt.node { + if stmt.is_empty() { + // If the statement is empty, just skip over it. Before that, make sure any comment + // snippet preceding the semicolon is picked up. + let snippet = self.snippet(mk_sp(self.last_pos, stmt.span().lo())); + let original_starts_with_newline = snippet + .find(|c| c != ' ') + .map_or(false, |i| starts_with_newline(&snippet[i..])); + let snippet = snippet.trim(); + if !snippet.is_empty() { + if original_starts_with_newline { + self.push_str("\n"); + } + self.push_str(&self.block_indent.to_string(self.config)); + self.push_str(snippet); + } + + self.last_pos = stmt.span().hi(); + return; + } + + match stmt.as_ast_node().kind { ast::StmtKind::Item(ref item) => { self.visit_item(item); // Handle potential `;` after the item. - self.format_missing(stmt.span.hi()); + self.format_missing(stmt.span().hi()); } ast::StmtKind::Local(..) | ast::StmtKind::Expr(..) | ast::StmtKind::Semi(..) => { - let attrs = get_attrs_from_stmt(stmt); + let attrs = get_attrs_from_stmt(stmt.as_ast_node()); if contains_skip(attrs) { - self.push_skipped_with_span(attrs, stmt.span(), get_span_without_attrs(stmt)); + self.push_skipped_with_span( + attrs, + stmt.span(), + get_span_without_attrs(stmt.as_ast_node()), + ); } else { let shape = self.shape(); let rewrite = self.with_context(|ctx| stmt.rewrite(&ctx, shape)); self.push_rewrite(stmt.span(), rewrite) } } - ast::StmtKind::Mac(ref mac) => { - let (ref mac, _macro_style, ref attrs) = **mac; - if self.visit_attrs(attrs, ast::AttrStyle::Outer) { - self.push_skipped_with_span(attrs, stmt.span(), get_span_without_attrs(stmt)); + ast::StmtKind::MacCall(ref mac_stmt) => { + if self.visit_attrs(&mac_stmt.attrs, ast::AttrStyle::Outer) { + self.push_skipped_with_span( + &mac_stmt.attrs, + stmt.span(), + get_span_without_attrs(stmt.as_ast_node()), + ); } else { - self.visit_mac(mac, None, MacroPosition::Statement); + self.visit_mac(&mac_stmt.mac, None, MacroPosition::Statement); } - self.format_missing(stmt.span.hi()); + self.format_missing(stmt.span().hi()); } + ast::StmtKind::Empty => (), } } - pub fn visit_block( + /// Remove spaces between the opening brace and the first statement or the inner attribute + /// of the block. + fn trim_spaces_after_opening_brace( &mut self, b: &ast::Block, inner_attrs: Option<&[ast::Attribute]>, - has_braces: bool, ) { - debug!( - "visit_block: {:?} {:?}", - self.source_map.lookup_char_pos(b.span.lo()), - self.source_map.lookup_char_pos(b.span.hi()) - ); - - // Check if this block has braces. - let brace_compensation = BytePos(if has_braces { 1 } else { 0 }); - - self.last_pos = self.last_pos + brace_compensation; - self.block_indent = self.block_indent.block_indent(self.config); - self.push_str("{"); - if let Some(first_stmt) = b.stmts.first() { let hi = inner_attrs .and_then(|attrs| inner_attributes(attrs).first().map(|attr| attr.span.lo())) - .unwrap_or(first_stmt.span().lo()); - - let snippet = self.snippet(mk_sp(self.last_pos, hi)); + .unwrap_or_else(|| first_stmt.span().lo()); + let missing_span = self.next_span(hi); + let snippet = self.snippet(missing_span); let len = CommentCodeSlices::new(snippet) .nth(0) .and_then(|(kind, _, s)| { @@ -160,19 +200,30 @@ pub fn visit_block( self.last_pos = self.last_pos + BytePos::from_usize(len); } } + } - // Format inner attributes if available. - let skip_rewrite = if let Some(attrs) = inner_attrs { - self.visit_attrs(attrs, ast::AttrStyle::Inner) - } else { - false - }; + pub(crate) fn visit_block( + &mut self, + b: &ast::Block, + inner_attrs: Option<&[ast::Attribute]>, + has_braces: bool, + ) { + debug!( + "visit_block: {}", + self.parse_sess.span_to_debug_info(b.span), + ); - if skip_rewrite { - self.push_rewrite(b.span, None); - self.close_block(false); - self.last_pos = source!(self, b.span).hi(); - return; + // Check if this block has braces. + let brace_compensation = BytePos(if has_braces { 1 } else { 0 }); + + self.last_pos = self.last_pos + brace_compensation; + self.block_indent = self.block_indent.block_indent(self.config); + self.push_str("{"); + self.trim_spaces_after_opening_brace(b, inner_attrs); + + // Format inner attributes if available. + if let Some(attrs) = inner_attrs { + self.visit_attrs(attrs, ast::AttrStyle::Inner); } self.walk_block_stmts(b); @@ -185,66 +236,141 @@ pub fn visit_block( } } - let mut remove_len = BytePos(0); - if let Some(stmt) = b.stmts.last() { - let snippet = self.snippet(mk_sp( - stmt.span.hi(), - source!(self, b.span).hi() - brace_compensation, - )); - let len = CommentCodeSlices::new(snippet) - .last() - .and_then(|(kind, _, s)| { - if kind == CodeCharKind::Normal && s.trim().is_empty() { - Some(s.len()) - } else { - None - } - }); - if let Some(len) = len { - remove_len = BytePos::from_usize(len); - } - } - - let unindent_comment = self.is_if_else_block && !b.stmts.is_empty() && { - let end_pos = source!(self, b.span).hi() - brace_compensation - remove_len; - let snippet = self.snippet(mk_sp(self.last_pos, end_pos)); - snippet.contains("//") || snippet.contains("/*") - }; - // FIXME: we should compress any newlines here to just one - if unindent_comment { + let rest_span = self.next_span(b.span.hi()); + if out_of_file_lines_range!(self, rest_span) { + self.push_str(self.snippet(rest_span)); self.block_indent = self.block_indent.block_unindent(self.config); + } else { + // Ignore the closing brace. + let missing_span = self.next_span(b.span.hi() - brace_compensation); + self.close_block(missing_span, self.unindent_comment_on_closing_brace(b)); } - self.format_missing_with_indent( - source!(self, b.span).hi() - brace_compensation - remove_len, - ); - if unindent_comment { - self.block_indent = self.block_indent.block_indent(self.config); - } - self.close_block(unindent_comment); self.last_pos = source!(self, b.span).hi(); } - // FIXME: this is a terrible hack to indent the comments between the last - // item in the block and the closing brace to the block's level. - // The closing brace itself, however, should be indented at a shallower - // level. - fn close_block(&mut self, unindent_comment: bool) { - let total_len = self.buffer.len(); - let chars_too_many = if unindent_comment { - 0 - } else if self.config.hard_tabs() { - 1 + fn close_block(&mut self, span: Span, unindent_comment: bool) { + let config = self.config; + + let mut last_hi = span.lo(); + let mut unindented = false; + let mut prev_ends_with_newline = false; + let mut extra_newline = false; + + let skip_normal = |s: &str| { + let trimmed = s.trim(); + trimmed.is_empty() || trimmed.chars().all(|c| c == ';') + }; + + let comment_snippet = self.snippet(span); + + let align_to_right = if unindent_comment && contains_comment(&comment_snippet) { + let first_lines = comment_snippet.splitn(2, '/').next().unwrap_or(""); + last_line_width(first_lines) > last_line_width(&comment_snippet) } else { - self.config.tab_spaces() + false }; - self.buffer.truncate(total_len - chars_too_many); - self.push_str("}"); + + for (kind, offset, sub_slice) in CommentCodeSlices::new(comment_snippet) { + let sub_slice = transform_missing_snippet(config, sub_slice); + + debug!("close_block: {:?} {:?} {:?}", kind, offset, sub_slice); + + match kind { + CodeCharKind::Comment => { + if !unindented && unindent_comment && !align_to_right { + unindented = true; + self.block_indent = self.block_indent.block_unindent(config); + } + let span_in_between = mk_sp(last_hi, span.lo() + BytePos::from_usize(offset)); + let snippet_in_between = self.snippet(span_in_between); + let mut comment_on_same_line = !snippet_in_between.contains("\n"); + + let mut comment_shape = + Shape::indented(self.block_indent, config).comment(config); + if self.config.version() == Version::Two && comment_on_same_line { + self.push_str(" "); + // put the first line of the comment on the same line as the + // block's last line + match sub_slice.find("\n") { + None => { + self.push_str(&sub_slice); + } + Some(offset) if offset + 1 == sub_slice.len() => { + self.push_str(&sub_slice[..offset]); + } + Some(offset) => { + let first_line = &sub_slice[..offset]; + self.push_str(first_line); + self.push_str(&self.block_indent.to_string_with_newline(config)); + + // put the other lines below it, shaping it as needed + let other_lines = &sub_slice[offset + 1..]; + let comment_str = + rewrite_comment(other_lines, false, comment_shape, config); + match comment_str { + Some(ref s) => self.push_str(s), + None => self.push_str(other_lines), + } + } + } + } else { + if comment_on_same_line { + // 1 = a space before `//` + let offset_len = 1 + last_line_width(&self.buffer) + .saturating_sub(self.block_indent.width()); + match comment_shape + .visual_indent(offset_len) + .sub_width(offset_len) + { + Some(shp) => comment_shape = shp, + None => comment_on_same_line = false, + } + }; + + if comment_on_same_line { + self.push_str(" "); + } else { + if count_newlines(snippet_in_between) >= 2 || extra_newline { + self.push_str("\n"); + } + self.push_str(&self.block_indent.to_string_with_newline(config)); + } + + let comment_str = rewrite_comment(&sub_slice, false, comment_shape, config); + match comment_str { + Some(ref s) => self.push_str(s), + None => self.push_str(&sub_slice), + } + } + } + CodeCharKind::Normal if skip_normal(&sub_slice) => { + extra_newline = prev_ends_with_newline && sub_slice.contains('\n'); + continue; + } + CodeCharKind::Normal => { + self.push_str(&self.block_indent.to_string_with_newline(config)); + self.push_str(sub_slice.trim()); + } + } + prev_ends_with_newline = sub_slice.ends_with('\n'); + extra_newline = false; + last_hi = span.lo() + BytePos::from_usize(offset + sub_slice.len()); + } + if unindented { + self.block_indent = self.block_indent.block_indent(self.config); + } self.block_indent = self.block_indent.block_unindent(self.config); + self.push_str(&self.block_indent.to_string_with_newline(config)); + self.push_str("}"); + } + + fn unindent_comment_on_closing_brace(&self, b: &ast::Block) -> bool { + self.is_if_else_block && !b.stmts.is_empty() } // Note that this only gets called for function definitions. Required methods // on traits do not get handled here. - fn visit_fn( + pub(crate) fn visit_fn( &mut self, fk: visit::FnKind<'_>, generics: &ast::Generics, @@ -256,38 +382,44 @@ fn visit_fn( let indent = self.block_indent; let block; let rewrite = match fk { - visit::FnKind::ItemFn(ident, _, _, b) | visit::FnKind::Method(ident, _, _, b) => { + visit::FnKind::Fn(_, ident, _, _, Some(ref b)) => { block = b; - self.rewrite_fn( + self.rewrite_fn_before_block( indent, ident, &FnSig::from_fn_kind(&fk, generics, fd, defaultness), mk_sp(s.lo(), b.span.lo()), - b, - inner_attrs, ) } - visit::FnKind::Closure(_) => unreachable!(), + _ => unreachable!(), }; - if let Some(fn_str) = rewrite { + if let Some((fn_str, fn_brace_style)) = rewrite { self.format_missing_with_indent(source!(self, s).lo()); + + if let Some(rw) = self.single_line_fn(&fn_str, block, inner_attrs) { + self.push_str(&rw); + self.last_pos = s.hi(); + return; + } + self.push_str(&fn_str); - if let Some(c) = fn_str.chars().last() { - if c == '}' { - self.last_pos = source!(self, block.span).hi(); - return; + match fn_brace_style { + FnBraceStyle::SameLine => self.push_str(" "), + FnBraceStyle::NextLine => { + self.push_str(&self.block_indent.to_string_with_newline(self.config)) } + _ => unreachable!(), } + self.last_pos = source!(self, block.span).lo(); } else { self.format_missing(source!(self, block.span).lo()); } - self.last_pos = source!(self, block.span).lo(); self.visit_block(block, inner_attrs, true) } - pub fn visit_item(&mut self, item: &ast::Item) { + pub(crate) fn visit_item(&mut self, item: &ast::Item) { skip_out_of_file_lines_range_visitor!(self, item.span); // This is where we bail out if there is a skip attribute. This is only @@ -296,25 +428,30 @@ pub fn visit_item(&mut self, item: &ast::Item) { // the AST lumps them all together. let filtered_attrs; let mut attrs = &item.attrs; - match item.node { - // For use items, skip rewriting attributes. Just check for a skip attribute. - ast::ItemKind::Use(..) => { + let skip_context_saved = self.skip_context.clone(); + self.skip_context.update_with_attrs(&attrs); + + let should_visit_node_again = match item.kind { + // For use/extern crate items, skip rewriting attributes but check for a skip attribute. + ast::ItemKind::Use(..) | ast::ItemKind::ExternCrate(_) => { if contains_skip(attrs) { self.push_skipped_with_span(attrs.as_slice(), item.span(), item.span()); - return; + false + } else { + true } } // Module is inline, in this case we treat it like any other item. _ if !is_mod_decl(item) => { if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) { self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span()); - return; + false + } else { + true } } // Module is not inline, but should be skipped. - ast::ItemKind::Mod(..) if contains_skip(&item.attrs) => { - return; - } + ast::ItemKind::Mod(..) if contains_skip(&item.attrs) => false, // Module is not inline and should not be skipped. We want // to process only the attributes in the current file. ast::ItemKind::Mod(..) => { @@ -323,124 +460,157 @@ pub fn visit_item(&mut self, item: &ast::Item) { // the above case. assert!(!self.visit_attrs(&filtered_attrs, ast::AttrStyle::Outer)); attrs = &filtered_attrs; + true } _ => { if self.visit_attrs(&item.attrs, ast::AttrStyle::Outer) { self.push_skipped_with_span(item.attrs.as_slice(), item.span(), item.span()); - return; + false + } else { + true } } - } + }; - match item.node { - ast::ItemKind::Use(ref tree) => self.format_import(item, tree), - ast::ItemKind::Impl(..) => { - let snippet = self.snippet(item.span); - let where_span_end = snippet - .find_uncommented("{") - .map(|x| BytePos(x as u32) + source!(self, item.span).lo()); - let block_indent = self.block_indent; - let rw = - self.with_context(|ctx| format_impl(&ctx, item, block_indent, where_span_end)); - self.push_rewrite(item.span, rw); - } - ast::ItemKind::Trait(..) => { - let block_indent = self.block_indent; - let rw = self.with_context(|ctx| format_trait(&ctx, item, block_indent)); - self.push_rewrite(item.span, rw); - } - ast::ItemKind::TraitAlias(ref generics, ref generic_bounds) => { - let shape = Shape::indented(self.block_indent, self.config); - let rw = format_trait_alias( - &self.get_context(), - item.ident, - &item.vis, - generics, - generic_bounds, - shape, - ); - self.push_rewrite(item.span, rw); - } - ast::ItemKind::ExternCrate(_) => { - let rw = rewrite_extern_crate(&self.get_context(), item); - self.push_rewrite(item.span, rw); - } - ast::ItemKind::Struct(..) | ast::ItemKind::Union(..) => { - self.visit_struct(&StructParts::from_item(item)); - } - ast::ItemKind::Enum(ref def, ref generics) => { - self.format_missing_with_indent(source!(self, item.span).lo()); - self.visit_enum(item.ident, &item.vis, def, generics, item.span); - self.last_pos = source!(self, item.span).hi(); - } - ast::ItemKind::Mod(ref module) => { - let is_inline = !is_mod_decl(item); - self.format_missing_with_indent(source!(self, item.span).lo()); - self.format_mod(module, &item.vis, item.span, item.ident, attrs, is_inline); - } - ast::ItemKind::Mac(ref mac) => { - self.visit_mac(mac, Some(item.ident), MacroPosition::Item); - } - ast::ItemKind::ForeignMod(ref foreign_mod) => { - self.format_missing_with_indent(source!(self, item.span).lo()); - self.format_foreign_mod(foreign_mod, item.span); - } - ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => { - self.visit_static(&StaticParts::from_item(item)); - } - ast::ItemKind::Fn(ref decl, ref fn_header, ref generics, ref body) => { - let inner_attrs = inner_attributes(&item.attrs); - self.visit_fn( - visit::FnKind::ItemFn(item.ident, fn_header, &item.vis, body), - generics, - decl, - item.span, - ast::Defaultness::Final, - Some(&inner_attrs), - ) - } - ast::ItemKind::Ty(ref ty, ref generics) => { - let rewrite = rewrite_type_alias( - &self.get_context(), - self.block_indent, - item.ident, - ty, - generics, - &item.vis, - ); - self.push_rewrite(item.span, rewrite); - } - ast::ItemKind::Existential(ref generic_bounds, ref generics) => { - let rewrite = rewrite_existential_type( - &self.get_context(), - self.block_indent, - item.ident, - generic_bounds, - generics, - &item.vis, - ); - self.push_rewrite(item.span, rewrite); - } - ast::ItemKind::GlobalAsm(..) => { - let snippet = Some(self.snippet(item.span).to_owned()); - self.push_rewrite(item.span, snippet); - } - ast::ItemKind::MacroDef(ref def) => { - let rewrite = rewrite_macro_def( - &self.get_context(), - self.shape(), - self.block_indent, - def, - item.ident, - &item.vis, - item.span, - ); - self.push_rewrite(item.span, rewrite); - } + if should_visit_node_again { + match item.kind { + ast::ItemKind::Use(ref tree) => self.format_import(item, tree), + ast::ItemKind::Impl { .. } => { + let block_indent = self.block_indent; + let rw = self.with_context(|ctx| format_impl(&ctx, item, block_indent)); + self.push_rewrite(item.span, rw); + } + ast::ItemKind::Trait(..) => { + let block_indent = self.block_indent; + let rw = self.with_context(|ctx| format_trait(&ctx, item, block_indent)); + self.push_rewrite(item.span, rw); + } + ast::ItemKind::TraitAlias(ref generics, ref generic_bounds) => { + let shape = Shape::indented(self.block_indent, self.config); + let rw = format_trait_alias( + &self.get_context(), + item.ident, + &item.vis, + generics, + generic_bounds, + shape, + ); + self.push_rewrite(item.span, rw); + } + ast::ItemKind::ExternCrate(_) => { + let rw = rewrite_extern_crate(&self.get_context(), item, self.shape()); + let span = if attrs.is_empty() { + item.span + } else { + mk_sp(attrs[0].span.lo(), item.span.hi()) + }; + self.push_rewrite(span, rw); + } + ast::ItemKind::Struct(..) | ast::ItemKind::Union(..) => { + self.visit_struct(&StructParts::from_item(item)); + } + ast::ItemKind::Enum(ref def, ref generics) => { + self.format_missing_with_indent(source!(self, item.span).lo()); + self.visit_enum(item.ident, &item.vis, def, generics, item.span); + self.last_pos = source!(self, item.span).hi(); + } + ast::ItemKind::Mod(ref module) => { + let is_inline = !is_mod_decl(item); + self.format_missing_with_indent(source!(self, item.span).lo()); + self.format_mod(module, &item.vis, item.span, item.ident, attrs, is_inline); + } + ast::ItemKind::MacCall(ref mac) => { + self.visit_mac(mac, Some(item.ident), MacroPosition::Item); + } + ast::ItemKind::ForeignMod(ref foreign_mod) => { + self.format_missing_with_indent(source!(self, item.span).lo()); + self.format_foreign_mod(foreign_mod, item.span); + } + ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => { + self.visit_static(&StaticParts::from_item(item)); + } + ast::ItemKind::Fn(defaultness, ref fn_signature, ref generics, Some(ref body)) => { + let inner_attrs = inner_attributes(&item.attrs); + let fn_ctxt = match fn_signature.header.ext { + ast::Extern::None => visit::FnCtxt::Free, + _ => visit::FnCtxt::Foreign, + }; + self.visit_fn( + visit::FnKind::Fn( + fn_ctxt, + item.ident, + &fn_signature, + &item.vis, + Some(body), + ), + generics, + &fn_signature.decl, + item.span, + defaultness, + Some(&inner_attrs), + ) + } + ast::ItemKind::Fn(_, ref fn_signature, ref generics, None) => { + let indent = self.block_indent; + let rewrite = self.rewrite_required_fn( + indent, + item.ident, + &fn_signature, + generics, + item.span, + ); + + self.push_rewrite(item.span, rewrite); + } + ast::ItemKind::TyAlias(_, ref generics, ref generic_bounds, ref ty) => match ty { + Some(ty) => { + let rewrite = rewrite_type_alias( + item.ident, + Some(&*ty), + generics, + Some(generic_bounds), + &self.get_context(), + self.block_indent, + &item.vis, + item.span, + ); + self.push_rewrite(item.span, rewrite); + } + None => { + let rewrite = rewrite_opaque_type( + &self.get_context(), + self.block_indent, + item.ident, + generic_bounds, + generics, + &item.vis, + item.span, + ); + self.push_rewrite(item.span, rewrite); + } + }, + ast::ItemKind::GlobalAsm(..) => { + let snippet = Some(self.snippet(item.span).to_owned()); + self.push_rewrite(item.span, snippet); + } + ast::ItemKind::MacroDef(ref def) => { + let rewrite = rewrite_macro_def( + &self.get_context(), + self.shape(), + self.block_indent, + def, + item.ident, + &item.vis, + item.span, + ); + self.push_rewrite(item.span, rewrite); + } + }; } + self.skip_context = skip_context_saved; } - pub fn visit_trait_item(&mut self, ti: &ast::TraitItem) { + pub(crate) fn visit_trait_item(&mut self, ti: &ast::AssocItem) { skip_out_of_file_lines_range_visitor!(self, ti.span); if self.visit_attrs(&ti.attrs, ast::AttrStyle::Outer) { @@ -448,100 +618,141 @@ pub fn visit_trait_item(&mut self, ti: &ast::TraitItem) { return; } - match ti.node { - ast::TraitItemKind::Const(..) => self.visit_static(&StaticParts::from_trait_item(ti)), - ast::TraitItemKind::Method(ref sig, None) => { + match ti.kind { + ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_trait_item(ti)), + ast::AssocItemKind::Fn(_, ref sig, ref generics, None) => { let indent = self.block_indent; - let rewrite = - self.rewrite_required_fn(indent, ti.ident, sig, &ti.generics, ti.span); + let rewrite = self.rewrite_required_fn(indent, ti.ident, sig, generics, ti.span); self.push_rewrite(ti.span, rewrite); } - ast::TraitItemKind::Method(ref sig, Some(ref body)) => { + ast::AssocItemKind::Fn(defaultness, ref sig, ref generics, Some(ref body)) => { let inner_attrs = inner_attributes(&ti.attrs); + let vis = ast::Visibility { + kind: ast::VisibilityKind::Inherited, + span: DUMMY_SP, + tokens: None, + }; + let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Trait); self.visit_fn( - visit::FnKind::Method(ti.ident, sig, None, body), - &ti.generics, + visit::FnKind::Fn(fn_ctxt, ti.ident, sig, &vis, Some(body)), + generics, &sig.decl, ti.span, - ast::Defaultness::Final, + defaultness, Some(&inner_attrs), ); } - ast::TraitItemKind::Type(ref generic_bounds, ref type_default) => { - let rewrite = rewrite_associated_type( + ast::AssocItemKind::TyAlias(_, ref generics, ref generic_bounds, ref type_default) => { + let rewrite = rewrite_type_alias( ti.ident, type_default.as_ref(), - &ti.generics, + generics, Some(generic_bounds), &self.get_context(), self.block_indent, + &ti.vis, + ti.span, ); self.push_rewrite(ti.span, rewrite); } - ast::TraitItemKind::Macro(ref mac) => { + ast::AssocItemKind::MacCall(ref mac) => { self.visit_mac(mac, Some(ti.ident), MacroPosition::Item); } } } - pub fn visit_impl_item(&mut self, ii: &ast::ImplItem) { + pub(crate) fn visit_impl_item(&mut self, ii: &ast::AssocItem) { skip_out_of_file_lines_range_visitor!(self, ii.span); if self.visit_attrs(&ii.attrs, ast::AttrStyle::Outer) { - self.push_skipped_with_span(ii.attrs.as_slice(), ii.span(), ii.span()); + self.push_skipped_with_span(ii.attrs.as_slice(), ii.span, ii.span); return; } - match ii.node { - ast::ImplItemKind::Method(ref sig, ref body) => { + match ii.kind { + ast::AssocItemKind::Fn(defaultness, ref sig, ref generics, Some(ref body)) => { let inner_attrs = inner_attributes(&ii.attrs); + let fn_ctxt = visit::FnCtxt::Assoc(visit::AssocCtxt::Impl); self.visit_fn( - visit::FnKind::Method(ii.ident, sig, Some(&ii.vis), body), - &ii.generics, + visit::FnKind::Fn(fn_ctxt, ii.ident, sig, &ii.vis, Some(body)), + generics, &sig.decl, ii.span, - ii.defaultness, + defaultness, Some(&inner_attrs), ); } - ast::ImplItemKind::Const(..) => self.visit_static(&StaticParts::from_impl_item(ii)), - ast::ImplItemKind::Type(ref ty) => { - let rewrite = rewrite_associated_impl_type( - ii.ident, - ii.defaultness, - Some(ty), - &ii.generics, - &self.get_context(), - self.block_indent, - ); + ast::AssocItemKind::Fn(_, ref sig, ref generics, None) => { + let indent = self.block_indent; + let rewrite = self.rewrite_required_fn(indent, ii.ident, sig, generics, ii.span); self.push_rewrite(ii.span, rewrite); } - ast::ImplItemKind::Existential(ref generic_bounds) => { - let rewrite = rewrite_existential_impl_type( - &self.get_context(), - ii.ident, - &ii.generics, - generic_bounds, - self.block_indent, - ); + ast::AssocItemKind::Const(..) => self.visit_static(&StaticParts::from_impl_item(ii)), + ast::AssocItemKind::TyAlias(defaultness, ref generics, _, ref ty) => { + let rewrite_associated = || { + rewrite_associated_impl_type( + ii.ident, + &ii.vis, + defaultness, + ty.as_ref(), + &generics, + &self.get_context(), + self.block_indent, + ii.span, + ) + }; + let rewrite = match ty { + None => rewrite_associated(), + Some(ty) => match ty.kind { + ast::TyKind::ImplTrait(_, ref bounds) => rewrite_opaque_impl_type( + &self.get_context(), + ii.ident, + generics, + bounds, + self.block_indent, + ), + _ => rewrite_associated(), + }, + }; self.push_rewrite(ii.span, rewrite); } - ast::ImplItemKind::Macro(ref mac) => { + ast::AssocItemKind::MacCall(ref mac) => { self.visit_mac(mac, Some(ii.ident), MacroPosition::Item); } } } - fn visit_mac(&mut self, mac: &ast::Mac, ident: Option, pos: MacroPosition) { - skip_out_of_file_lines_range_visitor!(self, mac.span); + fn visit_mac(&mut self, mac: &ast::MacCall, ident: Option, pos: MacroPosition) { + skip_out_of_file_lines_range_visitor!(self, mac.span()); // 1 = ; - let shape = self.shape().sub_width(1).unwrap(); + let shape = self.shape().saturating_sub_width(1); let rewrite = self.with_context(|ctx| rewrite_macro(mac, ident, ctx, shape, pos)); - self.push_rewrite(mac.span, rewrite); + // As of v638 of the rustc-ap-* crates, the associated span no longer includes + // the trailing semicolon. This determines the correct span to ensure scenarios + // with whitespace between the delimiters and trailing semi (i.e. `foo!(abc) ;`) + // are formatted correctly. + let (span, rewrite) = match macro_style(mac, &self.get_context()) { + DelimToken::Bracket | DelimToken::Paren if MacroPosition::Item == pos => { + let search_span = mk_sp(mac.span().hi(), self.snippet_provider.end_pos()); + let hi = self.snippet_provider.span_before(search_span, ";"); + let target_span = mk_sp(mac.span().lo(), hi + BytePos(1)); + let rewrite = rewrite.map(|rw| { + if !rw.ends_with(";") { + format!("{};", rw) + } else { + rw + } + }); + (target_span, rewrite) + } + _ => (mac.span(), rewrite), + }; + + self.push_rewrite(span, rewrite); } - pub fn push_str(&mut self, s: &str) { + pub(crate) fn push_str(&mut self, s: &str) { self.line_number += count_newlines(s); self.buffer.push_str(s); } @@ -552,17 +763,17 @@ fn push_rewrite_inner(&mut self, span: Span, rewrite: Option) { self.push_str(s); } else { let snippet = self.snippet(span); - self.push_str(snippet); + self.push_str(snippet.trim()); } self.last_pos = source!(self, span).hi(); } - pub fn push_rewrite(&mut self, span: Span, rewrite: Option) { + pub(crate) fn push_rewrite(&mut self, span: Span, rewrite: Option) { self.format_missing_with_indent(source!(self, span).lo()); self.push_rewrite_inner(span, rewrite); } - pub fn push_skipped_with_span( + pub(crate) fn push_skipped_with_span( &mut self, attrs: &[ast::Attribute], item_span: Span, @@ -572,40 +783,40 @@ pub fn push_skipped_with_span( // do not take into account the lines with attributes as part of the skipped range let attrs_end = attrs .iter() - .map(|attr| self.source_map.lookup_char_pos(attr.span().hi()).line) + .map(|attr| self.parse_sess.line_of_byte_pos(attr.span.hi())) .max() .unwrap_or(1); - let first_line = self.source_map.lookup_char_pos(main_span.lo()).line; + let first_line = self.parse_sess.line_of_byte_pos(main_span.lo()); // Statement can start after some newlines and/or spaces // or it can be on the same line as the last attribute. // So here we need to take a minimum between the two. let lo = std::cmp::min(attrs_end + 1, first_line); self.push_rewrite_inner(item_span, None); let hi = self.line_number + 1; - self.skipped_range.push((lo, hi)); + self.skipped_range.borrow_mut().push((lo, hi)); } - pub fn from_context(ctx: &'a RewriteContext<'_>) -> FmtVisitor<'a> { - let mut visitor = FmtVisitor::from_source_map( - ctx.parse_session, + pub(crate) fn from_context(ctx: &'a RewriteContext<'_>) -> FmtVisitor<'a> { + let mut visitor = FmtVisitor::from_parse_sess( + ctx.parse_sess, ctx.config, ctx.snippet_provider, ctx.report.clone(), ); + visitor.skip_context.update(ctx.skip_context.clone()); visitor.set_parent_context(ctx); visitor } - pub(crate) fn from_source_map( + pub(crate) fn from_parse_sess( parse_session: &'a ParseSess, config: &'a Config, - snippet_provider: &'a SnippetProvider<'_>, + snippet_provider: &'a SnippetProvider, report: FormatReport, ) -> FmtVisitor<'a> { FmtVisitor { parent_context: None, - parse_session, - source_map: parse_session.source_map(), + parse_sess: parse_session, buffer: String::with_capacity(snippet_provider.big_snippet.len() * 2), last_pos: BytePos(0), block_indent: Indent::empty(), @@ -613,46 +824,52 @@ pub(crate) fn from_source_map( is_if_else_block: false, snippet_provider, line_number: 0, - skipped_range: vec![], + skipped_range: Rc::new(RefCell::new(vec![])), + is_macro_def: false, macro_rewrite_failure: false, report, + skip_context: Default::default(), } } - pub fn opt_snippet(&'b self, span: Span) -> Option<&'a str> { + pub(crate) fn opt_snippet(&'b self, span: Span) -> Option<&'a str> { self.snippet_provider.span_to_snippet(span) } - pub fn snippet(&'b self, span: Span) -> &'a str { + pub(crate) fn snippet(&'b self, span: Span) -> &'a str { self.opt_snippet(span).unwrap() } // Returns true if we should skip the following item. - pub fn visit_attrs(&mut self, attrs: &[ast::Attribute], style: ast::AttrStyle) -> bool { + pub(crate) fn visit_attrs(&mut self, attrs: &[ast::Attribute], style: ast::AttrStyle) -> bool { for attr in attrs { - if attr.name() == DEPR_SKIP_ANNOTATION { - let file_name = self.source_map.span_to_filename(attr.span).into(); + if attr.has_name(depr_skip_annotation()) { + let file_name = self.parse_sess.span_to_filename(attr.span); self.report.append( file_name, vec![FormattingError::from_span( attr.span, - &self.source_map, + self.parse_sess, ErrorKind::DeprecatedAttr, )], ); - } else if attr.path.segments[0].ident.to_string() == "rustfmt" - && (attr.path.segments.len() == 1 - || attr.path.segments[1].ident.to_string() != "skip") - { - let file_name = self.source_map.span_to_filename(attr.span).into(); - self.report.append( - file_name, - vec![FormattingError::from_span( - attr.span, - &self.source_map, - ErrorKind::BadAttr, - )], - ); + } else { + match &attr.kind { + ast::AttrKind::Normal(ref attribute_item, _) + if self.is_unknown_rustfmt_attr(&attribute_item.path.segments) => + { + let file_name = self.parse_sess.span_to_filename(attr.span); + self.report.append( + file_name, + vec![FormattingError::from_span( + attr.span, + self.parse_sess, + ErrorKind::BadAttr, + )], + ); + } + _ => (), + } } } if contains_skip(attrs) { @@ -671,18 +888,18 @@ pub fn visit_attrs(&mut self, attrs: &[ast::Attribute], style: ast::AttrStyle) - false } + fn is_unknown_rustfmt_attr(&self, segments: &[ast::PathSegment]) -> bool { + if segments[0].ident.to_string() != "rustfmt" { + return false; + } + !is_skip_attr(segments) + } + fn walk_mod_items(&mut self, m: &ast::Mod) { self.visit_items_with_reordering(&ptr_vec_to_ref_vec(&m.items)); } - fn walk_stmts(&mut self, stmts: &[ast::Stmt]) { - fn to_stmt_item(stmt: &ast::Stmt) -> Option<&ast::Item> { - match stmt.node { - ast::StmtKind::Item(ref item) => Some(&**item), - _ => None, - } - } - + fn walk_stmts(&mut self, stmts: &[Stmt<'_>]) { if stmts.is_empty() { return; } @@ -690,27 +907,13 @@ fn to_stmt_item(stmt: &ast::Stmt) -> Option<&ast::Item> { // Extract leading `use ...;`. let items: Vec<_> = stmts .iter() - .take_while(|stmt| to_stmt_item(stmt).map_or(false, is_use_item)) - .filter_map(|stmt| to_stmt_item(stmt)) + .take_while(|stmt| stmt.to_item().map_or(false, is_use_item)) + .filter_map(|stmt| stmt.to_item()) .collect(); if items.is_empty() { - // The `if` expression at the end of the block should be formatted in a single - // line if possible. - if self.config.version() == Version::Two - && stmts.len() == 1 - && crate::expr::stmt_is_if(&stmts[0]) - && !contains_skip(get_attrs_from_stmt(&stmts[0])) - { - let shape = self.shape(); - let rewrite = self.with_context(|ctx| { - format_expr(stmt_expr(&stmts[0])?, ExprType::SubExpression, ctx, shape) - }); - self.push_rewrite(stmts[0].span(), rewrite); - } else { - self.visit_stmt(&stmts[0]); - self.walk_stmts(&stmts[1..]); - } + self.visit_stmt(&stmts[0]); + self.walk_stmts(&stmts[1..]); } else { self.visit_items_with_reordering(&items); self.walk_stmts(&stmts[items.len()..]); @@ -718,7 +921,7 @@ fn to_stmt_item(stmt: &ast::Stmt) -> Option<&ast::Item> { } fn walk_block_stmts(&mut self, b: &ast::Block) { - self.walk_stmts(&b.stmts) + self.walk_stmts(&Stmt::from_ast_nodes(b.stmts.iter())) } fn format_mod( @@ -726,12 +929,13 @@ fn format_mod( m: &ast::Mod, vis: &ast::Visibility, s: Span, - ident: ast::Ident, + ident: symbol::Ident, attrs: &[ast::Attribute], is_internal: bool, ) { let vis_str = utils::format_visibility(&self.get_context(), vis); self.push_str(&*vis_str); + self.push_str(format_unsafety(m.unsafety)); self.push_str("mod "); // Calling `to_owned()` to work around borrow checker. let ident_str = rewrite_ident(&self.get_context(), ident).to_owned(); @@ -758,8 +962,8 @@ fn format_mod( self.block_indent = self.block_indent.block_indent(self.config); self.visit_attrs(attrs, ast::AttrStyle::Inner); self.walk_mod_items(m); - self.format_missing_with_indent(source!(self, m.inner).hi() - BytePos(1)); - self.close_block(false); + let missing_span = self.next_span(m.inner.hi() - BytePos(1)); + self.close_block(missing_span, false); } self.last_pos = source!(self, m.inner).hi(); } else { @@ -768,18 +972,22 @@ fn format_mod( } } - pub fn format_separate_mod(&mut self, m: &ast::Mod, source_file: &source_map::SourceFile) { + pub(crate) fn format_separate_mod(&mut self, m: &Module<'_>, end_pos: BytePos) { self.block_indent = Indent::empty(); - self.walk_mod_items(m); - self.format_missing_with_indent(source_file.end_pos); + if self.visit_attrs(m.attrs(), ast::AttrStyle::Inner) { + self.push_skipped_with_span(m.attrs(), m.as_ref().inner, m.as_ref().inner); + } else { + self.walk_mod_items(m.as_ref()); + self.format_missing_with_indent(end_pos); + } } - pub fn skip_empty_lines(&mut self, end_pos: BytePos) { + pub(crate) fn skip_empty_lines(&mut self, end_pos: BytePos) { while let Some(pos) = self .snippet_provider - .opt_span_after(mk_sp(self.last_pos, end_pos), "\n") + .opt_span_after(self.next_span(end_pos), "\n") { - if let Some(snippet) = self.opt_snippet(mk_sp(self.last_pos, pos)) { + if let Some(snippet) = self.opt_snippet(self.next_span(pos)) { if snippet.trim().is_empty() { self.last_pos = pos; } else { @@ -789,34 +997,31 @@ pub fn skip_empty_lines(&mut self, end_pos: BytePos) { } } - pub fn with_context(&mut self, f: F) -> Option + pub(crate) fn with_context(&mut self, f: F) -> Option where F: Fn(&RewriteContext<'_>) -> Option, { - // FIXME borrow checker fighting - can be simplified a lot with NLL. - let (result, mrf) = { - let context = self.get_context(); - let result = f(&context); - let mrf = &context.macro_rewrite_failure.borrow(); - (result, *std::ops::Deref::deref(mrf)) - }; + let context = self.get_context(); + let result = f(&context); - self.macro_rewrite_failure |= mrf; + self.macro_rewrite_failure |= context.macro_rewrite_failure.get(); result } - pub fn get_context(&self) -> RewriteContext<'_> { + pub(crate) fn get_context(&self) -> RewriteContext<'_> { RewriteContext { - parse_session: self.parse_session, - source_map: self.source_map, + parse_sess: self.parse_sess, config: self.config, - inside_macro: RefCell::new(false), - use_block: RefCell::new(false), - is_if_else_block: RefCell::new(false), - force_one_line_chain: RefCell::new(false), + inside_macro: Rc::new(Cell::new(false)), + use_block: Cell::new(false), + is_if_else_block: Cell::new(false), + force_one_line_chain: Cell::new(false), snippet_provider: self.snippet_provider, - macro_rewrite_failure: RefCell::new(false), + macro_rewrite_failure: Cell::new(false), + is_macro_def: self.is_macro_def, report: self.report.clone(), + skip_context: self.skip_context.clone(), + skipped_range: self.skipped_range.clone(), } } }