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.
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.
11 //! Format attributes and meta items.
14 use syntax::source_map::{BytePos, Span, DUMMY_SP};
16 use crate::comment::{contains_comment, rewrite_doc_comment, CommentStyle};
17 use crate::config::lists::*;
18 use crate::config::IndentStyle;
19 use crate::expr::rewrite_literal;
20 use crate::lists::{definitive_tactic, itemize_list, write_list, ListFormatting, Separator};
22 use crate::rewrite::{Rewrite, RewriteContext};
23 use crate::shape::Shape;
24 use crate::types::{rewrite_path, PathContext};
25 use crate::utils::{count_newlines, mk_sp};
27 /// Returns attributes on the given statement.
28 pub fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
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,
37 pub fn get_span_without_attrs(stmt: &ast::Stmt) -> Span {
39 ast::StmtKind::Local(ref local) => local.span,
40 ast::StmtKind::Item(ref item) => item.span,
41 ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => expr.span,
42 ast::StmtKind::Mac(ref mac) => {
43 let (ref mac, _, _) = **mac;
49 /// Returns attributes that are within `outer_span`.
50 pub fn filter_inline_attrs(attrs: &[ast::Attribute], outer_span: Span) -> Vec<ast::Attribute> {
53 .filter(|a| outer_span.lo() <= a.span.lo() && a.span.hi() <= outer_span.hi())
58 fn is_derive(attr: &ast::Attribute) -> bool {
59 attr.check_name("derive")
62 /// Returns the arguments of `#[derive(...)]`.
63 fn get_derive_spans(attr: &ast::Attribute) -> Option<Vec<Span>> {
64 attr.meta_item_list().map(|meta_item_list| {
67 .map(|nested_meta_item| nested_meta_item.span)
72 // The shape of the arguments to a function-like attribute.
78 context: &RewriteContext<'_>,
80 match context.config.indent_style() {
81 IndentStyle::Block => {
83 shape.offset_left(left)
87 .block_indent(context.config.tab_spaces())
88 .with_max_width(context.config),
92 IndentStyle::Visual => shape
95 .and_then(|s| s.sub_width(right)),
100 derive_args: &[Span],
103 context: &RewriteContext<'_>,
104 ) -> Option<String> {
105 let mut result = String::with_capacity(128);
106 result.push_str(prefix);
107 result.push_str("[derive(");
109 let argument_shape = argument_shape(10 + prefix.len(), 2, false, shape, context)?;
110 let item_str = format_arg_list(
114 |sp| Some(context.snippet(**sp).to_owned()),
118 // 10 = "[derive()]", 3 = "()" and "]"
119 shape.offset_left(10 + prefix.len())?.sub_width(3)?,
124 result.push_str(&item_str);
125 if item_str.starts_with('\n') {
127 result.push_str(&shape.indent.to_string_with_newline(context.config));
129 result.push_str(")]");
133 /// Returns the first group of attributes that fills the given predicate.
134 /// We consider two doc comments are in different group if they are separated by normal comments.
135 fn take_while_with_pred<'a, P>(
136 context: &RewriteContext<'_>,
137 attrs: &'a [ast::Attribute],
139 ) -> &'a [ast::Attribute]
141 P: Fn(&ast::Attribute) -> bool,
144 let mut iter = attrs.iter().peekable();
146 while let Some(attr) = iter.next() {
152 if let Some(next_attr) = iter.peek() {
153 // Extract comments between two attributes.
154 let span_between_attr = mk_sp(attr.span.hi(), next_attr.span.lo());
155 let snippet = context.snippet(span_between_attr);
156 if count_newlines(snippet) >= 2 || snippet.contains('/') {
165 /// Rewrite the any doc comments which come before any other attributes.
166 fn rewrite_initial_doc_comments(
167 context: &RewriteContext<'_>,
168 attrs: &[ast::Attribute],
170 ) -> Option<(usize, Option<String>)> {
171 if attrs.is_empty() {
172 return Some((0, None));
174 // Rewrite doc comments
175 let sugared_docs = take_while_with_pred(context, attrs, |a| a.is_sugared_doc);
176 if !sugared_docs.is_empty() {
177 let snippet = sugared_docs
179 .map(|a| context.snippet(a.span))
184 Some(rewrite_doc_comment(
186 shape.comment(context.config),
195 impl Rewrite for ast::NestedMetaItem {
196 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
198 ast::NestedMetaItemKind::MetaItem(ref meta_item) => meta_item.rewrite(context, shape),
199 ast::NestedMetaItemKind::Literal(ref l) => rewrite_literal(context, l, shape),
204 fn has_newlines_before_after_comment(comment: &str) -> (&str, &str) {
205 // Look at before and after comment and see if there are any empty lines.
206 let comment_begin = comment.find('/');
207 let len = comment_begin.unwrap_or_else(|| comment.len());
208 let mlb = count_newlines(&comment[..len]) > 1;
209 let mla = if comment_begin.is_none() {
215 .take_while(|c| c.is_whitespace())
216 .filter(|&c| c == '\n')
220 (if mlb { "\n" } else { "" }, if mla { "\n" } else { "" })
223 impl Rewrite for ast::MetaItem {
224 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
225 Some(match self.node {
226 ast::MetaItemKind::Word => {
227 rewrite_path(context, PathContext::Type, None, &self.ident, shape)?
229 ast::MetaItemKind::List(ref list) => {
230 let path = rewrite_path(context, PathContext::Type, None, &self.ident, shape)?;
231 let has_trailing_comma = crate::expr::span_ends_with_comma(context, self.span);
232 overflow::rewrite_with_parens(
239 context.config.width_heuristics().attr_fn_like_width,
240 Some(if has_trailing_comma {
241 SeparatorTactic::Always
243 SeparatorTactic::Never
247 ast::MetaItemKind::NameValue(ref literal) => {
248 let path = rewrite_path(context, PathContext::Type, None, &self.ident, shape)?;
250 let lit_shape = shape.shrink_left(path.len() + 3)?;
251 // `rewrite_literal` returns `None` when `literal` exceeds max
252 // width. Since a literal is basically unformattable unless it
253 // is a string literal (and only if `format_strings` is set),
254 // we might be better off ignoring the fact that the attribute
255 // is longer than the max width and contiue on formatting.
256 // See #2479 for example.
257 let value = rewrite_literal(context, literal, lit_shape)
258 .unwrap_or_else(|| context.snippet(literal.span).to_owned());
259 format!("{} = {}", path, value)
265 fn format_arg_list<I, T, F1, F2, F3>(
271 context: &RewriteContext<'_>,
273 one_line_shape: Shape,
274 one_line_limit: Option<usize>,
278 I: Iterator<Item = T>,
279 F1: Fn(&T) -> BytePos,
280 F2: Fn(&T) -> BytePos,
281 F3: Fn(&T) -> Option<String>,
283 let items = itemize_list(
284 context.snippet_provider,
295 let item_vec = items.collect::<Vec<_>>();
296 let tactic = if let Some(limit) = one_line_limit {
297 ListTactic::LimitedHorizontalVertical(limit)
299 ListTactic::HorizontalVertical
302 let tactic = definitive_tactic(&item_vec, tactic, Separator::Comma, shape.width);
303 let fmt = ListFormatting::new(shape, context.config)
305 .ends_with_newline(false);
306 let item_str = write_list(&item_vec, &fmt)?;
308 let one_line_budget = one_line_shape.width;
309 if context.config.indent_style() == IndentStyle::Visual
311 || (!item_str.contains('\n') && item_str.len() <= one_line_budget)
315 let nested_indent = shape.indent.to_string_with_newline(context.config);
316 Some(format!("{}{}", nested_indent, item_str))
320 impl Rewrite for ast::Attribute {
321 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
322 let snippet = context.snippet(self.span);
323 if self.is_sugared_doc {
324 rewrite_doc_comment(snippet, shape.comment(context.config), context.config)
326 let prefix = attr_prefix(self);
328 if contains_comment(snippet) {
329 return Some(snippet.to_owned());
332 if let Some(ref meta) = self.meta() {
333 // This attribute is possibly a doc attribute needing normalization to a doc comment
334 if context.config.normalize_doc_attributes() && meta.check_name("doc") {
335 if let Some(ref literal) = meta.value_str() {
336 let comment_style = match self.style {
337 ast::AttrStyle::Inner => CommentStyle::Doc,
338 ast::AttrStyle::Outer => CommentStyle::TripleSlash,
341 // Remove possible whitespace from the `CommentStyle::opener()` so that
342 // the literal itself has control over the comment's leading spaces.
343 let opener = comment_style.opener().trim_end();
345 let doc_comment = format!("{}{}", opener, literal);
346 return rewrite_doc_comment(
348 shape.comment(context.config),
355 let shape = shape.offset_left(prefix.len() + 1)?;
357 meta.rewrite(context, shape)
358 .map_or_else(|| snippet.to_owned(), |rw| format!("{}[{}]", prefix, rw)),
361 Some(snippet.to_owned())
367 impl<'a> Rewrite for [ast::Attribute] {
368 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
370 return Some(String::new());
373 // The current remaining attributes.
374 let mut attrs = self;
375 let mut result = String::new();
377 // This is not just a simple map because we need to handle doc comments
378 // (where we take as many doc comment attributes as possible) and possibly
379 // merging derives into a single attribute.
381 if attrs.is_empty() {
385 // Handle doc comments.
386 let (doc_comment_len, doc_comment_str) =
387 rewrite_initial_doc_comments(context, attrs, shape)?;
388 if doc_comment_len > 0 {
389 let doc_comment_str = doc_comment_str.expect("doc comments, but no result");
390 result.push_str(&doc_comment_str);
392 let missing_span = attrs
393 .get(doc_comment_len)
394 .map(|next| mk_sp(attrs[doc_comment_len - 1].span.hi(), next.span.lo()));
395 if let Some(missing_span) = missing_span {
396 let snippet = context.snippet(missing_span);
397 let (mla, mlb) = has_newlines_before_after_comment(snippet);
398 let comment = crate::comment::recover_missing_comment_in_span(
400 shape.with_max_width(context.config),
404 let comment = if comment.is_empty() {
407 format!("{}{}\n{}", mla, comment, mlb)
409 result.push_str(&comment);
410 result.push_str(&shape.indent.to_string(context.config));
413 attrs = &attrs[doc_comment_len..];
418 // Handle derives if we will merge them.
419 if context.config.merge_derives() && is_derive(&attrs[0]) {
420 let derives = take_while_with_pred(context, attrs, is_derive);
421 let mut derive_spans = vec![];
422 for derive in derives {
423 derive_spans.append(&mut get_derive_spans(derive)?);
426 format_derive(&derive_spans, attr_prefix(&attrs[0]), shape, context)?;
427 result.push_str(&derive_str);
429 let missing_span = attrs
431 .map(|next| mk_sp(attrs[derives.len() - 1].span.hi(), next.span.lo()));
432 if let Some(missing_span) = missing_span {
433 let comment = crate::comment::recover_missing_comment_in_span(
435 shape.with_max_width(context.config),
439 result.push_str(&comment);
440 if let Some(next) = attrs.get(derives.len()) {
441 if next.is_sugared_doc {
442 let snippet = context.snippet(missing_span);
443 let (_, mlb) = has_newlines_before_after_comment(snippet);
444 result.push_str(&mlb);
448 result.push_str(&shape.indent.to_string(context.config));
451 attrs = &attrs[derives.len()..];
456 // If we get here, then we have a regular attribute, just handle one
459 let formatted_attr = attrs[0].rewrite(context, shape)?;
460 result.push_str(&formatted_attr);
462 let missing_span = attrs
464 .map(|next| mk_sp(attrs[0].span.hi(), next.span.lo()));
465 if let Some(missing_span) = missing_span {
466 let comment = crate::comment::recover_missing_comment_in_span(
468 shape.with_max_width(context.config),
472 result.push_str(&comment);
473 if let Some(next) = attrs.get(1) {
474 if next.is_sugared_doc {
475 let snippet = context.snippet(missing_span);
476 let (_, mlb) = has_newlines_before_after_comment(snippet);
477 result.push_str(&mlb);
481 result.push_str(&shape.indent.to_string(context.config));
489 fn attr_prefix(attr: &ast::Attribute) -> &'static str {
491 ast::AttrStyle::Inner => "#!",
492 ast::AttrStyle::Outer => "#",