src/attr.rs

   1 // Copyright 2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Format attributes and meta items.
  12
  13 use comment::{contains_comment, rewrite_doc_comment};
  14 use config::lists::*;
  15 use config::IndentStyle;
  16 use expr::rewrite_literal;
  17 use lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
  18 use rewrite::{Rewrite, RewriteContext};
  19 use shape::Shape;
  20 use types::{rewrite_path, PathContext};
  21 use utils::{count_newlines, mk_sp};
  22
  23 use std::borrow::Cow;
  24 use syntax::ast;
  25 use syntax::source_map::{BytePos, Span, DUMMY_SP};
  26
  27 /// Returns attributes on the given statement.
  28 pub fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
  29     match stmt.node {
  30         ast::StmtKind::Local(ref local) => &local.attrs,
  31         ast::StmtKind::Item(ref item) => &item.attrs,
  32         ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => &expr.attrs,
  33         ast::StmtKind::Mac(ref mac) => &mac.2,
  34     }
  35 }
  36
  37 /// Returns attributes that are within `outer_span`.
  38 pub fn filter_inline_attrs(attrs: &[ast::Attribute], outer_span: Span) -> Vec<ast::Attribute> {
  39     attrs
  40         .iter()
  41         .filter(|a| outer_span.lo() <= a.span.lo() && a.span.hi() <= outer_span.hi())
  42         .cloned()
  43         .collect()
  44 }
  45
  46 fn is_derive(attr: &ast::Attribute) -> bool {
  47     attr.check_name("derive")
  48 }
  49
  50 /// Returns the arguments of `#[derive(...)]`.
  51 fn get_derive_spans(attr: &ast::Attribute) -> Option<Vec<Span>> {
  52     attr.meta_item_list().map(|meta_item_list| {
  53         meta_item_list
  54             .iter()
  55             .map(|nested_meta_item| nested_meta_item.span)
  56             .collect()
  57     })
  58 }
  59
  60 // The shape of the arguments to a function-like attribute.
  61 fn argument_shape(
  62     left: usize,
  63     right: usize,
  64     combine: bool,
  65     shape: Shape,
  66     context: &RewriteContext,
  67 ) -> Option<Shape> {
  68     match context.config.indent_style() {
  69         IndentStyle::Block => {
  70             if combine {
  71                 shape.offset_left(left)
  72             } else {
  73                 Some(
  74                     shape
  75                         .block_indent(context.config.tab_spaces())
  76                         .with_max_width(context.config),
  77                 )
  78             }
  79         }
  80         IndentStyle::Visual => shape
  81             .visual_indent(0)
  82             .shrink_left(left)
  83             .and_then(|s| s.sub_width(right)),
  84     }
  85 }
  86
  87 fn format_derive(
  88     derive_args: &[Span],
  89     prefix: &str,
  90     shape: Shape,
  91     context: &RewriteContext,
  92 ) -> Option<String> {
  93     let mut result = String::with_capacity(128);
  94     result.push_str(prefix);
  95     result.push_str("[derive(");
  96
  97     let argument_shape = argument_shape(10 + prefix.len(), 2, false, shape, context)?;
  98     let item_str = format_arg_list(
  99         derive_args.iter(),
 100         |_| DUMMY_SP.lo(),
 101         |_| DUMMY_SP.hi(),
 102         |sp| Some(context.snippet(**sp).to_owned()),
 103         DUMMY_SP,
 104         context,
 105         argument_shape,
 106         // 10 = "[derive()]", 3 = "()" and "]"
 107         shape.offset_left(10 + prefix.len())?.sub_width(3)?,
 108         None,
 109         false,
 110     )?;
 111
 112     result.push_str(&item_str);
 113     if item_str.starts_with('\n') {
 114         result.push(',');
 115         result.push_str(&shape.indent.to_string_with_newline(context.config));
 116     }
 117     result.push_str(")]");
 118     Some(result)
 119 }
 120
 121 /// Returns the first group of attributes that fills the given predicate.
 122 /// We consider two doc comments are in different group if they are separated by normal comments.
 123 fn take_while_with_pred<'a, P>(
 124     context: &RewriteContext,
 125     attrs: &'a [ast::Attribute],
 126     pred: P,
 127 ) -> &'a [ast::Attribute]
 128 where
 129     P: Fn(&ast::Attribute) -> bool,
 130 {
 131     let mut len = 0;
 132     let mut iter = attrs.iter().peekable();
 133
 134     while let Some(attr) = iter.next() {
 135         if pred(attr) {
 136             len += 1;
 137         } else {
 138             break;
 139         }
 140         if let Some(next_attr) = iter.peek() {
 141             // Extract comments between two attributes.
 142             let span_between_attr = mk_sp(attr.span.hi(), next_attr.span.lo());
 143             let snippet = context.snippet(span_between_attr);
 144             if count_newlines(snippet) >= 2 || snippet.contains('/') {
 145                 break;
 146             }
 147         }
 148     }
 149
 150     &attrs[..len]
 151 }
 152
 153 /// Rewrite the any doc comments which come before any other attributes.
 154 fn rewrite_initial_doc_comments(
 155     context: &RewriteContext,
 156     attrs: &[ast::Attribute],
 157     shape: Shape,
 158 ) -> Option<(usize, Option<String>)> {
 159     if attrs.is_empty() {
 160         return Some((0, None));
 161     }
 162     // Rewrite doc comments
 163     let sugared_docs = take_while_with_pred(context, attrs, |a| a.is_sugared_doc);
 164     if !sugared_docs.is_empty() {
 165         let snippet = sugared_docs
 166             .iter()
 167             .map(|a| context.snippet(a.span))
 168             .collect::<Vec<_>>()
 169             .join("\n");
 170         return Some((
 171             sugared_docs.len(),
 172             Some(rewrite_doc_comment(
 173                 &snippet,
 174                 shape.comment(context.config),
 175                 context.config,
 176             )?),
 177         ));
 178     }
 179
 180     Some((0, None))
 181 }
 182
 183 impl Rewrite for ast::NestedMetaItem {
 184     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
 185         match self.node {
 186             ast::NestedMetaItemKind::MetaItem(ref meta_item) => meta_item.rewrite(context, shape),
 187             ast::NestedMetaItemKind::Literal(ref l) => rewrite_literal(context, l, shape),
 188         }
 189     }
 190 }
 191
 192 fn has_newlines_before_after_comment(comment: &str) -> (&str, &str) {
 193     // Look at before and after comment and see if there are any empty lines.
 194     let comment_begin = comment.find('/');
 195     let len = comment_begin.unwrap_or_else(|| comment.len());
 196     let mlb = count_newlines(&comment[..len]) > 1;
 197     let mla = if comment_begin.is_none() {
 198         mlb
 199     } else {
 200         comment
 201             .chars()
 202             .rev()
 203             .take_while(|c| c.is_whitespace())
 204             .filter(|&c| c == '\n')
 205             .count()
 206             > 1
 207     };
 208     (if mlb { "\n" } else { "" }, if mla { "\n" } else { "" })
 209 }
 210
 211 impl Rewrite for ast::MetaItem {
 212     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
 213         Some(match self.node {
 214             ast::MetaItemKind::Word => {
 215                 rewrite_path(context, PathContext::Type, None, &self.ident, shape)?
 216             }
 217             ast::MetaItemKind::List(ref list) => {
 218                 let path = rewrite_path(context, PathContext::Type, None, &self.ident, shape)?;
 219
 220                 let has_comma = ::expr::span_ends_with_comma(context, self.span);
 221                 let trailing_comma = if has_comma { "," } else { "" };
 222                 let combine = list.len() == 1 && match list[0].node {
 223                     ast::NestedMetaItemKind::Literal(..) => false,
 224                     ast::NestedMetaItemKind::MetaItem(ref inner_meta_item) => {
 225                         match inner_meta_item.node {
 226                             ast::MetaItemKind::List(..) => rewrite_path(
 227                                 context,
 228                                 PathContext::Type,
 229                                 None,
 230                                 &inner_meta_item.ident,
 231                                 shape,
 232                             ).map_or(false, |s| s.len() + path.len() + 2 <= shape.width),
 233                             _ => false,
 234                         }
 235                     }
 236                 };
 237
 238                 let argument_shape = argument_shape(
 239                     path.len() + 1,
 240                     2 + trailing_comma.len(),
 241                     combine,
 242                     shape,
 243                     context,
 244                 )?;
 245                 let item_str = format_arg_list(
 246                     list.iter(),
 247                     |nested_meta_item| nested_meta_item.span.lo(),
 248                     |nested_meta_item| nested_meta_item.span.hi(),
 249                     |nested_meta_item| nested_meta_item.rewrite(context, argument_shape),
 250                     self.span,
 251                     context,
 252                     argument_shape,
 253                     // 3 = "()" and "]"
 254                     shape
 255                         .offset_left(path.len())?
 256                         .sub_width(3 + trailing_comma.len())?,
 257                     Some(context.config.width_heuristics().fn_call_width),
 258                     combine,
 259                 )?;
 260
 261                 let indent = if item_str.starts_with('\n') {
 262                     shape.indent.to_string_with_newline(context.config)
 263                 } else {
 264                     Cow::Borrowed("")
 265                 };
 266
 267                 format!("{}({}{}{})", path, item_str, trailing_comma, indent)
 268             }
 269             ast::MetaItemKind::NameValue(ref literal) => {
 270                 let path = rewrite_path(context, PathContext::Type, None, &self.ident, shape)?;
 271                 // 3 = ` = `
 272                 let lit_shape = shape.shrink_left(path.len() + 3)?;
 273                 // `rewrite_literal` returns `None` when `literal` exceeds max
 274                 // width. Since a literal is basically unformattable unless it
 275                 // is a string literal (and only if `format_strings` is set),
 276                 // we might be better off ignoring the fact that the attribute
 277                 // is longer than the max width and contiue on formatting.
 278                 // See #2479 for example.
 279                 let value = rewrite_literal(context, literal, lit_shape)
 280                     .unwrap_or_else(|| context.snippet(literal.span).to_owned());
 281                 format!("{} = {}", path, value)
 282             }
 283         })
 284     }
 285 }
 286
 287 fn format_arg_list<I, T, F1, F2, F3>(
 288     list: I,
 289     get_lo: F1,
 290     get_hi: F2,
 291     get_item_string: F3,
 292     span: Span,
 293     context: &RewriteContext,
 294     shape: Shape,
 295     one_line_shape: Shape,
 296     one_line_limit: Option<usize>,
 297     combine: bool,
 298 ) -> Option<String>
 299 where
 300     I: Iterator<Item = T>,
 301     F1: Fn(&T) -> BytePos,
 302     F2: Fn(&T) -> BytePos,
 303     F3: Fn(&T) -> Option<String>,
 304 {
 305     let items = itemize_list(
 306         context.snippet_provider,
 307         list,
 308         ")",
 309         ",",
 310         get_lo,
 311         get_hi,
 312         get_item_string,
 313         span.lo(),
 314         span.hi(),
 315         false,
 316     );
 317     let item_vec = items.collect::<Vec<_>>();
 318     let tactic = if let Some(limit) = one_line_limit {
 319         ListTactic::LimitedHorizontalVertical(limit)
 320     } else {
 321         ListTactic::HorizontalVertical
 322     };
 323
 324     let tactic = definitive_tactic(&item_vec, tactic, Separator::Comma, shape.width);
 325     let fmt = ListFormatting::new(shape, context.config)
 326         .tactic(tactic)
 327         .ends_with_newline(false);
 328     let item_str = write_list(&item_vec, &fmt)?;
 329
 330     let one_line_budget = one_line_shape.width;
 331     if context.config.indent_style() == IndentStyle::Visual
 332         || combine
 333         || (!item_str.contains('\n') && item_str.len() <= one_line_budget)
 334     {
 335         Some(item_str)
 336     } else {
 337         let nested_indent = shape.indent.to_string_with_newline(context.config);
 338         Some(format!("{}{}", nested_indent, item_str))
 339     }
 340 }
 341
 342 impl Rewrite for ast::Attribute {
 343     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
 344         let snippet = context.snippet(self.span);
 345         if self.is_sugared_doc {
 346             rewrite_doc_comment(snippet, shape.comment(context.config), context.config)
 347         } else {
 348             let prefix = attr_prefix(self);
 349
 350             if contains_comment(snippet) {
 351                 return Some(snippet.to_owned());
 352             }
 353             // 1 = `[`
 354             let shape = shape.offset_left(prefix.len() + 1)?;
 355             Some(
 356                 self.meta()
 357                     .and_then(|meta| meta.rewrite(context, shape))
 358                     .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
 359             )
 360         }
 361     }
 362 }
 363
 364 impl<'a> Rewrite for [ast::Attribute] {
 365     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
 366         if self.is_empty() {
 367             return Some(String::new());
 368         }
 369
 370         // The current remaining attributes.
 371         let mut attrs = self;
 372         let mut result = String::new();
 373
 374         // This is not just a simple map because we need to handle doc comments
 375         // (where we take as many doc comment attributes as possible) and possibly
 376         // merging derives into a single attribute.
 377         loop {
 378             if attrs.is_empty() {
 379                 return Some(result);
 380             }
 381
 382             // Handle doc comments.
 383             let (doc_comment_len, doc_comment_str) =
 384                 rewrite_initial_doc_comments(context, attrs, shape)?;
 385             if doc_comment_len > 0 {
 386                 let doc_comment_str = doc_comment_str.expect("doc comments, but no result");
 387                 result.push_str(&doc_comment_str);
 388
 389                 let missing_span = attrs
 390                     .get(doc_comment_len)
 391                     .map(|next| mk_sp(attrs[doc_comment_len - 1].span.hi(), next.span.lo()));
 392                 if let Some(missing_span) = missing_span {
 393                     let snippet = context.snippet(missing_span);
 394                     let (mla, mlb) = has_newlines_before_after_comment(snippet);
 395                     let comment = ::comment::recover_missing_comment_in_span(
 396                         missing_span,
 397                         shape.with_max_width(context.config),
 398                         context,
 399                         0,
 400                     )?;
 401                     let comment = if comment.is_empty() {
 402                         format!("\n{}", mlb)
 403                     } else {
 404                         format!("{}{}\n{}", mla, comment, mlb)
 405                     };
 406                     result.push_str(&comment);
 407                     result.push_str(&shape.indent.to_string(context.config));
 408                 }
 409
 410                 attrs = &attrs[doc_comment_len..];
 411
 412                 continue;
 413             }
 414
 415             // Handle derives if we will merge them.
 416             if context.config.merge_derives() && is_derive(&attrs[0]) {
 417                 let derives = take_while_with_pred(context, attrs, is_derive);
 418                 let mut derive_spans = vec![];
 419                 for derive in derives {
 420                     derive_spans.append(&mut get_derive_spans(derive)?);
 421                 }
 422                 let derive_str =
 423                     format_derive(&derive_spans, attr_prefix(&attrs[0]), shape, context)?;
 424                 result.push_str(&derive_str);
 425
 426                 let missing_span = attrs
 427                     .get(derives.len())
 428                     .map(|next| mk_sp(attrs[derives.len() - 1].span.hi(), next.span.lo()));
 429                 if let Some(missing_span) = missing_span {
 430                     let comment = ::comment::recover_missing_comment_in_span(
 431                         missing_span,
 432                         shape.with_max_width(context.config),
 433                         context,
 434                         0,
 435                     )?;
 436                     result.push_str(&comment);
 437                     if let Some(next) = attrs.get(derives.len()) {
 438                         if next.is_sugared_doc {
 439                             let snippet = context.snippet(missing_span);
 440                             let (_, mlb) = has_newlines_before_after_comment(snippet);
 441                             result.push_str(&mlb);
 442                         }
 443                     }
 444                     result.push('\n');
 445                     result.push_str(&shape.indent.to_string(context.config));
 446                 }
 447
 448                 attrs = &attrs[derives.len()..];
 449
 450                 continue;
 451             }
 452
 453             // If we get here, then we have a regular attribute, just handle one
 454             // at a time.
 455
 456             let formatted_attr = attrs[0].rewrite(context, shape)?;
 457             result.push_str(&formatted_attr);
 458
 459             let missing_span = attrs
 460                 .get(1)
 461                 .map(|next| mk_sp(attrs[0].span.hi(), next.span.lo()));
 462             if let Some(missing_span) = missing_span {
 463                 let comment = ::comment::recover_missing_comment_in_span(
 464                     missing_span,
 465                     shape.with_max_width(context.config),
 466                     context,
 467                     0,
 468                 )?;
 469                 result.push_str(&comment);
 470                 if let Some(next) = attrs.get(1) {
 471                     if next.is_sugared_doc {
 472                         let snippet = context.snippet(missing_span);
 473                         let (_, mlb) = has_newlines_before_after_comment(snippet);
 474                         result.push_str(&mlb);
 475                     }
 476                 }
 477                 result.push('\n');
 478                 result.push_str(&shape.indent.to_string(context.config));
 479             }
 480
 481             attrs = &attrs[1..];
 482         }
 483     }
 484 }
 485
 486 fn attr_prefix(attr: &ast::Attribute) -> &'static str {
 487     match attr.style {
 488         ast::AttrStyle::Inner => "#!",
 489         ast::AttrStyle::Outer => "#",
 490     }
 491 }