-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<String>,
/// 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<String>) -> 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<RefCell<Vec<(usize, usize)>>>,
+ 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> {
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<'_>, include_empty_semi: bool) {
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() {
+ // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
+ // formatting where rustfmt would preserve redundant semicolons on Items in a
+ // statement position.
+ // See comment within `walk_stmts` for more info
+ if include_empty_semi {
+ self.format_missing(stmt.span().hi());
+ } else {
+ if original_starts_with_newline {
+ self.push_str("\n");
+ }
+
+ self.push_str(&self.block_indent.to_string(self.config));
+ self.push_str(snippet);
+ }
+ } else if include_empty_semi {
+ self.push_str(";");
+ }
+ 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.last_pos = 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)| {
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);
}
}
- 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,
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
// 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(..) => {
// 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) {
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<ast::Ident>, pos: MacroPosition) {
- skip_out_of_file_lines_range_visitor!(self, mac.span);
+ fn visit_mac(&mut self, mac: &ast::MacCall, ident: Option<symbol::Ident>, 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);
}
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<String>) {
+ pub(crate) fn push_rewrite(&mut self, span: Span, rewrite: Option<String>) {
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,
// 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(),
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) {
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<'_>], include_current_empty_semi: bool) {
if stmts.is_empty() {
return;
}
// 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);
+ self.visit_stmt(&stmts[0], include_current_empty_semi);
+
+ // FIXME(calebcartwright 2021-01-03) - This exists strictly to maintain legacy
+ // formatting where rustfmt would preserve redundant semicolons on Items in a
+ // statement position.
+ //
+ // Starting in rustc-ap-* v692 (~2020-12-01) the rustc parser now parses this as
+ // two separate statements (Item and Empty kinds), whereas before it was parsed as
+ // a single statement with the statement's span including the redundant semicolon.
+ //
+ // rustfmt typically tosses unnecessary/redundant semicolons, and eventually we
+ // should toss these as well, but doing so at this time would
+ // break the Stability Guarantee
+ // N.B. This could be updated to utilize the version gates.
+ let include_next_empty = if stmts.len() > 1 {
+ match (&stmts[0].as_ast_node().kind, &stmts[1].as_ast_node().kind) {
+ (ast::StmtKind::Item(_), ast::StmtKind::Empty) => true,
+ _ => false,
+ }
} else {
- self.visit_stmt(&stmts[0]);
- self.walk_stmts(&stmts[1..]);
- }
+ false
+ };
+
+ self.walk_stmts(&stmts[1..], include_next_empty);
} else {
self.visit_items_with_reordering(&items);
- self.walk_stmts(&stmts[items.len()..]);
+ self.walk_stmts(&stmts[items.len()..], false);
}
}
fn walk_block_stmts(&mut self, b: &ast::Block) {
- self.walk_stmts(&b.stmts)
+ self.walk_stmts(&Stmt::from_ast_nodes(b.stmts.iter()), false)
}
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();
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 {
}
}
- 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 {
}
}
- pub fn with_context<F>(&mut self, f: F) -> Option<String>
+ pub(crate) fn with_context<F>(&mut self, f: F) -> Option<String>
where
F: Fn(&RewriteContext<'_>) -> Option<String>,
{
- // 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(),
}
}
}
projects / rust.git / blobdiff