X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmacros.rs;h=49f4a03ee1db8a7afecdf7f05e8eb8186b6817df;hb=cbd568083d87a90dfe5ab0e90f404454946c9f20;hp=e68a725e15fe5b303d98b9eac484b9b471738f09;hpb=c3edf6d3a1f72088a4343948f6aafe1fc74a3208;p=rust.git diff --git a/src/macros.rs b/src/macros.rs index e68a725e15f..49f4a03ee1d 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -44,6 +44,7 @@ use source_map::SpanUtils; use spanned::Spanned; use utils::{format_visibility, mk_sp, rewrite_ident, wrap_str}; +use visitor::FmtVisitor; const FORCED_BRACKET_MACROS: &[&str] = &["vec!"]; @@ -63,13 +64,22 @@ pub enum MacroArg { Item(ptr::P), } +impl MacroArg { + fn is_item(&self) -> bool { + match self { + MacroArg::Item(..) => true, + _ => false, + } + } +} + impl Rewrite for ast::Item { fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option { let mut visitor = ::visitor::FmtVisitor::from_context(context); visitor.block_indent = shape.indent; visitor.last_pos = self.span().lo(); visitor.visit_item(self); - Some(visitor.buffer) + Some(visitor.buffer.to_owned()) } } @@ -259,6 +269,7 @@ pub fn rewrite_macro_inner( } return return_original_snippet_with_failure_marked(context, mac.span); } + _ if arg_vec.last().map_or(false, MacroArg::is_item) => continue, _ => return return_original_snippet_with_failure_marked(context, mac.span), } @@ -271,6 +282,18 @@ pub fn rewrite_macro_inner( } } + if !arg_vec.is_empty() && arg_vec.iter().all(MacroArg::is_item) { + return rewrite_macro_with_items( + context, + &arg_vec, + ¯o_name, + shape, + style, + position, + mac.span, + ); + } + match style { DelimToken::Paren => { // Format macro invocation as function call, preserve the trailing @@ -278,7 +301,7 @@ pub fn rewrite_macro_inner( overflow::rewrite_with_parens( context, ¯o_name, - &arg_vec.iter().map(|e| &*e).collect::>(), + arg_vec.iter(), shape, mac.span, context.config.width_heuristics().fn_call_width, @@ -287,7 +310,8 @@ pub fn rewrite_macro_inner( } else { Some(SeparatorTactic::Never) }, - ).map(|rw| match position { + ) + .map(|rw| match position { MacroPosition::Item => format!("{};", rw), _ => rw, }) @@ -333,11 +357,9 @@ pub fn rewrite_macro_inner( force_trailing_comma = Some(SeparatorTactic::Vertical); }; } - // Convert `MacroArg` into `ast::Expr`, as `rewrite_array` only accepts the latter. - let arg_vec = &arg_vec.iter().map(|e| &*e).collect::>(); let rewrite = rewrite_array( macro_name, - arg_vec, + arg_vec.iter(), mac.span, context, shape, @@ -406,11 +428,20 @@ pub fn rewrite_macro_def( ";", |branch| branch.span.lo(), |branch| branch.span.hi(), - |branch| branch.rewrite(context, arm_shape, multi_branch_style), + |branch| match branch.rewrite(context, arm_shape, multi_branch_style) { + Some(v) => Some(v), + // if the rewrite returned None because a macro could not be rewritten, then return the + // original body + None if *context.macro_rewrite_failure.borrow() == true => { + Some(context.snippet(branch.body).trim().to_string()) + } + None => None, + }, context.snippet_provider.span_after(span, "{"), span.hi(), false, - ).collect::>(); + ) + .collect::>(); let fmt = ListFormatting::new(arm_shape, context.config) .separator(if def.legacy { ";" } else { "" }) @@ -1133,24 +1164,28 @@ fn indent_macro_snippet( FullCodeCharKind::InString | FullCodeCharKind::EndString => None, _ => prefix_space_width, } - }).min()?; + }) + .min()?; Some( - first_line + "\n" + &trimmed_lines - .iter() - .map( - |&(trimmed, ref line, prefix_space_width)| match prefix_space_width { - _ if !trimmed => line.to_owned(), - Some(original_indent_width) => { - let new_indent_width = indent.width() + original_indent_width - .saturating_sub(min_prefix_space_width); - let new_indent = Indent::from_width(context.config, new_indent_width); - format!("{}{}", new_indent.to_string(context.config), line) - } - None => String::new(), - }, - ).collect::>() - .join("\n"), + first_line + + "\n" + + &trimmed_lines + .iter() + .map( + |&(trimmed, ref line, prefix_space_width)| match prefix_space_width { + _ if !trimmed => line.to_owned(), + Some(original_indent_width) => { + let new_indent_width = indent.width() + + original_indent_width.saturating_sub(min_prefix_space_width); + let new_indent = Indent::from_width(context.config, new_indent_width); + format!("{}{}", new_indent.to_string(context.config), line) + } + None => String::new(), + }, + ) + .collect::>() + .join("\n"), ) } @@ -1314,7 +1349,8 @@ fn rewrite( } (s + l + "\n", !kind.is_string() || l.ends_with('\\')) }, - ).0; + ) + .0; // Undo our replacement of macro variables. // FIXME: this could be *much* more efficient. @@ -1417,3 +1453,45 @@ fn format_lazy_static(context: &RewriteContext, shape: Shape, ts: &TokenStream) Some(result) } + +fn rewrite_macro_with_items( + context: &RewriteContext, + items: &[MacroArg], + macro_name: &str, + shape: Shape, + style: DelimToken, + position: MacroPosition, + span: Span, +) -> Option { + let (opener, closer) = match style { + DelimToken::Paren => ("(", ")"), + DelimToken::Bracket => ("[", "]"), + DelimToken::Brace => (" {", "}"), + _ => return None, + }; + let trailing_semicolon = match style { + DelimToken::Paren | DelimToken::Bracket if position == MacroPosition::Item => ";", + _ => "", + }; + + let mut visitor = FmtVisitor::from_context(context); + visitor.block_indent = shape.indent.block_indent(context.config); + visitor.last_pos = context.snippet_provider.span_after(span, opener.trim()); + for item in items { + let item = match item { + MacroArg::Item(item) => item, + _ => return None, + }; + visitor.visit_item(&item); + } + + let mut result = String::with_capacity(256); + result.push_str(¯o_name); + result.push_str(opener); + result.push_str(&visitor.block_indent.to_string_with_newline(context.config)); + result.push_str(visitor.buffer.trim()); + result.push_str(&shape.indent.to_string_with_newline(context.config)); + result.push_str(closer); + result.push_str(trailing_semicolon); + return Some(result); +}