Fixup formatting

[rust.git] / src / macros.rs

diff --git a/src/macros.rs b/src/macros.rs
index e68a725e15fe5b303d98b9eac484b9b471738f09..49f4a03ee1db8a7afecdf7f05e8eb8186b6817df 100644 (file)
--- 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<ast::Item>),
 }
 
+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<String> {
         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,
+            &macro_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,
                 &macro_name,
-                &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>(),
+                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::<Vec<_>>();
                 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::<Vec<_>>();
+    )
+    .collect::<Vec<_>>();
 
     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::<Vec<_>>()
-            .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::<Vec<_>>()
+                .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<String> {
+    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(&macro_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);
+}