Merge pull request #3035 from topecongiro/issue-3006

[rust.git] / src / attr.rs

diff --git a/src/attr.rs b/src/attr.rs
index 2ec47d305728bb15125c1b731f93e816f4a9c2f4..f8f6cd1c376043339729e27334c4279b50e6ca68 100644 (file)
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -10,7 +10,7 @@
 
 //! Format attributes and meta items.
 
-use comment::{contains_comment, rewrite_doc_comment};
+use comment::{contains_comment, rewrite_doc_comment, CommentStyle};
 use config::lists::*;
 use config::IndentStyle;
 use expr::rewrite_literal;
@@ -22,7 +22,7 @@
 
 use std::borrow::Cow;
 use syntax::ast;
-use syntax::codemap::{BytePos, Span, DUMMY_SP};
+use syntax::source_map::{BytePos, Span, DUMMY_SP};
 
 /// Returns attributes on the given statement.
 pub fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
@@ -48,7 +48,7 @@ fn is_derive(attr: &ast::Attribute) -> bool {
 }
 
 /// Returns the arguments of `#[derive(...)]`.
-fn get_derive_spans<'a>(attr: &ast::Attribute) -> Option<Vec<Span>> {
+fn get_derive_spans(attr: &ast::Attribute) -> Option<Vec<Span>> {
     attr.meta_item_list().map(|meta_item_list| {
         meta_item_list
             .iter()
@@ -61,15 +61,22 @@ fn get_derive_spans<'a>(attr: &ast::Attribute) -> Option<Vec<Span>> {
 fn argument_shape(
     left: usize,
     right: usize,
+    combine: bool,
     shape: Shape,
     context: &RewriteContext,
 ) -> Option<Shape> {
     match context.config.indent_style() {
-        IndentStyle::Block => Some(
-            shape
-                .block_indent(context.config.tab_spaces())
-                .with_max_width(context.config),
-        ),
+        IndentStyle::Block => {
+            if combine {
+                shape.offset_left(left)
+            } else {
+                Some(
+                    shape
+                        .block_indent(context.config.tab_spaces())
+                        .with_max_width(context.config),
+                )
+            }
+        }
         IndentStyle::Visual => shape
             .visual_indent(0)
             .shrink_left(left)
@@ -87,7 +94,7 @@ fn format_derive(
     result.push_str(prefix);
     result.push_str("[derive(");
 
-    let argument_shape = argument_shape(10 + prefix.len(), 2, shape, context)?;
+    let argument_shape = argument_shape(10 + prefix.len(), 2, false, shape, context)?;
     let item_str = format_arg_list(
         derive_args.iter(),
         |_| DUMMY_SP.lo(),
@@ -99,6 +106,7 @@ fn format_derive(
         // 10 = "[derive()]", 3 = "()" and "]"
         shape.offset_left(10 + prefix.len())?.sub_width(3)?,
         None,
+        false,
     )?;
 
     result.push_str(&item_str);
@@ -209,14 +217,31 @@ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
             ast::MetaItemKind::List(ref list) => {
                 let path = rewrite_path(context, PathContext::Type, None, &self.ident, shape)?;
 
-                let snippet = context.snippet(self.span);
-                // 2 = )] (this might go wrong if there is whitespace between the brackets, but
-                // it's close enough).
-                let snippet = snippet[..snippet.len() - 2].trim();
-                let trailing_comma = if snippet.ends_with(',') { "," } else { "" };
+                let has_comma = ::expr::span_ends_with_comma(context, self.span);
+                let trailing_comma = if has_comma { "," } else { "" };
+                let combine = list.len() == 1 && match list[0].node {
+                    ast::NestedMetaItemKind::Literal(..) => false,
+                    ast::NestedMetaItemKind::MetaItem(ref inner_meta_item) => {
+                        match inner_meta_item.node {
+                            ast::MetaItemKind::List(..) => rewrite_path(
+                                context,
+                                PathContext::Type,
+                                None,
+                                &inner_meta_item.ident,
+                                shape,
+                            ).map_or(false, |s| s.len() + path.len() + 2 <= shape.width),
+                            _ => false,
+                        }
+                    }
+                };
 
-                let argument_shape =
-                    argument_shape(path.len() + 1, 2 + trailing_comma.len(), shape, context)?;
+                let argument_shape = argument_shape(
+                    path.len() + 1,
+                    2 + trailing_comma.len(),
+                    combine,
+                    shape,
+                    context,
+                )?;
                 let item_str = format_arg_list(
                     list.iter(),
                     |nested_meta_item| nested_meta_item.span.lo(),
@@ -230,6 +255,7 @@ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
                         .offset_left(path.len())?
                         .sub_width(3 + trailing_comma.len())?,
                     Some(context.config.width_heuristics().fn_call_width),
+                    combine,
                 )?;
 
                 let indent = if item_str.starts_with('\n') {
@@ -268,6 +294,7 @@ fn format_arg_list<I, T, F1, F2, F3>(
     shape: Shape,
     one_line_shape: Shape,
     one_line_limit: Option<usize>,
+    combine: bool,
 ) -> Option<String>
 where
     I: Iterator<Item = T>,
@@ -302,6 +329,7 @@ fn format_arg_list<I, T, F1, F2, F3>(
 
     let one_line_budget = one_line_shape.width;
     if context.config.indent_style() == IndentStyle::Visual
+        || combine
         || (!item_str.contains('\n') && item_str.len() <= one_line_budget)
     {
         Some(item_str)
@@ -322,13 +350,34 @@ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
             if contains_comment(snippet) {
                 return Some(snippet.to_owned());
             }
-            // 1 = `[`
-            let shape = shape.offset_left(prefix.len() + 1)?;
-            Some(
-                self.meta()
-                    .and_then(|meta| meta.rewrite(context, shape))
-                    .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
-            )
+
+            if let Some(ref meta) = self.meta() {
+                // This attribute is possibly a doc attribute needing normalization to a doc comment
+                if context.config.normalize_doc_attributes() && meta.check_name("doc") {
+                    if let Some(ref literal) = meta.value_str() {
+                        let comment_style = match self.style {
+                            ast::AttrStyle::Inner => CommentStyle::Doc,
+                            ast::AttrStyle::Outer => CommentStyle::TripleSlash,
+                        };
+
+                        let doc_comment = format!("{}{}", comment_style.opener(), literal);
+                        return rewrite_doc_comment(
+                            &doc_comment,
+                            shape.comment(context.config),
+                            context.config,
+                        );
+                    }
+                }
+
+                // 1 = `[`
+                let shape = shape.offset_left(prefix.len() + 1)?;
+                Some(
+                    meta.rewrite(context, shape)
+                        .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
+                )
+            } else {
+                Some(snippet.to_owned())
+            }
         }
     }
 }