1 // Format list-like macro invocations. These are invocations whose token trees
2 // can be interpreted as expressions and separated by commas.
3 // Note that these token trees do not actually have to be interpreted as
4 // expressions by the compiler. An example of an invocation we would reformat is
5 // foo!( x, y, z ). The token x may represent an identifier in the code, but we
6 // interpreted as an expression.
7 // Macro uses which are not-list like, such as bar!(key => val), will not be
9 // List-like invocations with parentheses will be formatted as function calls,
10 // and those with brackets will be formatted as array literals.
12 use std::collections::HashMap;
13 use std::panic::{catch_unwind, AssertUnwindSafe};
15 use rustc_ast::token::{BinOpToken, Delimiter, Token, TokenKind};
16 use rustc_ast::tokenstream::{TokenStream, TokenTree, TokenTreeCursor};
17 use rustc_ast::{ast, ptr};
18 use rustc_ast_pretty::pprust;
21 BytePos, Span, Symbol, DUMMY_SP,
25 contains_comment, CharClasses, FindUncommented, FullCodeCharKind, LineClasses,
27 use crate::config::lists::*;
28 use crate::expr::{rewrite_array, rewrite_assign_rhs, RhsAssignKind};
29 use crate::lists::{itemize_list, write_list, ListFormatting};
31 use crate::parse::macros::lazy_static::parse_lazy_static;
32 use crate::parse::macros::{parse_expr, parse_macro_args, ParsedMacroArgs};
33 use crate::rewrite::{Rewrite, RewriteContext};
34 use crate::shape::{Indent, Shape};
35 use crate::source_map::SpanUtils;
36 use crate::spanned::Spanned;
38 filtered_str_fits, format_visibility, indent_next_line, is_empty_line, mk_sp,
39 remove_trailing_white_spaces, rewrite_ident, trim_left_preserve_layout, NodeIdExt,
41 use crate::visitor::FmtVisitor;
43 const FORCED_BRACKET_MACROS: &[&str] = &["vec!"];
45 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
46 pub(crate) enum MacroPosition {
54 pub(crate) enum MacroArg {
55 Expr(ptr::P<ast::Expr>),
57 Pat(ptr::P<ast::Pat>),
58 Item(ptr::P<ast::Item>),
59 Keyword(symbol::Ident, Span),
63 pub(crate) fn is_item(&self) -> bool {
65 MacroArg::Item(..) => true,
71 impl Rewrite for ast::Item {
72 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
73 let mut visitor = crate::visitor::FmtVisitor::from_context(context);
74 visitor.block_indent = shape.indent;
75 visitor.last_pos = self.span().lo();
76 visitor.visit_item(self);
77 Some(visitor.buffer.to_owned())
81 impl Rewrite for MacroArg {
82 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
84 MacroArg::Expr(ref expr) => expr.rewrite(context, shape),
85 MacroArg::Ty(ref ty) => ty.rewrite(context, shape),
86 MacroArg::Pat(ref pat) => pat.rewrite(context, shape),
87 MacroArg::Item(ref item) => item.rewrite(context, shape),
88 MacroArg::Keyword(ident, _) => Some(ident.name.to_string()),
93 /// Rewrite macro name without using pretty-printer if possible.
94 fn rewrite_macro_name(
95 context: &RewriteContext<'_>,
97 extra_ident: Option<symbol::Ident>,
99 let name = if path.segments.len() == 1 {
100 // Avoid using pretty-printer in the common case.
101 format!("{}!", rewrite_ident(context, path.segments[0].ident))
103 format!("{}!", pprust::path_to_string(path))
106 Some(ident) if ident.name != kw::Empty => format!("{} {}", name, ident),
111 // Use this on failing to format the macro call.
112 fn return_macro_parse_failure_fallback(
113 context: &RewriteContext<'_>,
115 position: MacroPosition,
117 ) -> Option<String> {
118 // Mark this as a failure however we format it
119 context.macro_rewrite_failure.replace(true);
121 // Heuristically determine whether the last line of the macro uses "Block" style
122 // rather than using "Visual" style, or another indentation style.
123 let is_like_block_indent_style = context
127 .map(|closing_line| {
131 .all(|ch| matches!(ch, '}' | ')' | ']'))
134 if is_like_block_indent_style {
135 return trim_left_preserve_layout(context.snippet(span), indent, context.config);
138 context.skipped_range.borrow_mut().push((
139 context.parse_sess.line_of_byte_pos(span.lo()),
140 context.parse_sess.line_of_byte_pos(span.hi()),
143 // Return the snippet unmodified if the macro is not block-like
144 let mut snippet = context.snippet(span).to_owned();
145 if position == MacroPosition::Item {
151 pub(crate) fn rewrite_macro(
153 extra_ident: Option<symbol::Ident>,
154 context: &RewriteContext<'_>,
156 position: MacroPosition,
157 ) -> Option<String> {
158 let should_skip = context
161 .skip(context.snippet(mac.path.span));
165 let guard = context.enter_macro();
166 let result = catch_unwind(AssertUnwindSafe(|| {
177 Err(..) | Ok(None) => {
178 context.macro_rewrite_failure.replace(true);
186 fn rewrite_macro_inner(
188 extra_ident: Option<symbol::Ident>,
189 context: &RewriteContext<'_>,
191 position: MacroPosition,
192 is_nested_macro: bool,
193 ) -> Option<String> {
194 if context.config.use_try_shorthand() {
195 if let Some(expr) = convert_try_mac(mac, context) {
196 context.leave_macro();
197 return expr.rewrite(context, shape);
201 let original_style = macro_style(mac, context);
203 let macro_name = rewrite_macro_name(context, &mac.path, extra_ident);
204 let is_forced_bracket = FORCED_BRACKET_MACROS.contains(&¯o_name[..]);
206 let style = if is_forced_bracket && !is_nested_macro {
212 let ts = mac.args.tokens.clone();
213 let has_comment = contains_comment(context.snippet(mac.span()));
214 if ts.is_empty() && !has_comment {
216 Delimiter::Parenthesis if position == MacroPosition::Item => {
217 Some(format!("{}();", macro_name))
219 Delimiter::Bracket if position == MacroPosition::Item => {
220 Some(format!("{}[];", macro_name))
222 Delimiter::Parenthesis => Some(format!("{}()", macro_name)),
223 Delimiter::Bracket => Some(format!("{}[]", macro_name)),
224 Delimiter::Brace => Some(format!("{} {{}}", macro_name)),
228 // Format well-known macros which cannot be parsed as a valid AST.
229 if macro_name == "lazy_static!" && !has_comment {
230 if let success @ Some(..) = format_lazy_static(context, shape, ts.clone()) {
235 let ParsedMacroArgs {
239 } = match parse_macro_args(context, ts, style, is_forced_bracket) {
242 return return_macro_parse_failure_fallback(
251 if !arg_vec.is_empty() && arg_vec.iter().all(MacroArg::is_item) {
252 return rewrite_macro_with_items(
264 Delimiter::Parenthesis => {
265 // Handle special case: `vec!(expr; expr)`
267 handle_vec_semi(context, shape, arg_vec, macro_name, style)
269 // Format macro invocation as function call, preserve the trailing
270 // comma because not all macros support them.
271 overflow::rewrite_with_parens(
277 context.config.fn_call_width(),
279 Some(SeparatorTactic::Always)
281 Some(SeparatorTactic::Never)
284 .map(|rw| match position {
285 MacroPosition::Item => format!("{};", rw),
290 Delimiter::Bracket => {
291 // Handle special case: `vec![expr; expr]`
293 handle_vec_semi(context, shape, arg_vec, macro_name, style)
295 // If we are rewriting `vec!` macro or other special macros,
296 // then we can rewrite this as a usual array literal.
297 // Otherwise, we must preserve the original existence of trailing comma.
298 let macro_name = ¯o_name.as_str();
299 let mut force_trailing_comma = if trailing_comma {
300 Some(SeparatorTactic::Always)
302 Some(SeparatorTactic::Never)
304 if FORCED_BRACKET_MACROS.contains(macro_name) && !is_nested_macro {
305 context.leave_macro();
306 if context.use_block_indent() {
307 force_trailing_comma = Some(SeparatorTactic::Vertical);
310 let rewrite = rewrite_array(
316 force_trailing_comma,
317 Some(original_style),
319 let comma = match position {
320 MacroPosition::Item => ";",
324 Some(format!("{}{}", rewrite, comma))
327 Delimiter::Brace => {
328 // For macro invocations with braces, always put a space between
329 // the `macro_name!` and `{ /* macro_body */ }` but skip modifying
330 // anything in between the braces (for now).
331 let snippet = context.snippet(mac.span()).trim_start_matches(|c| c != '{');
332 match trim_left_preserve_layout(snippet, shape.indent, context.config) {
333 Some(macro_body) => Some(format!("{} {}", macro_name, macro_body)),
334 None => Some(format!("{} {}", macro_name, snippet)),
342 context: &RewriteContext<'_>,
344 arg_vec: Vec<MacroArg>,
346 delim_token: Delimiter,
347 ) -> Option<String> {
348 let (left, right) = match delim_token {
349 Delimiter::Parenthesis => ("(", ")"),
350 Delimiter::Bracket => ("[", "]"),
354 let mac_shape = shape.offset_left(macro_name.len())?;
355 // 8 = `vec![]` + `; ` or `vec!()` + `; `
356 let total_overhead = 8;
357 let nested_shape = mac_shape.block_indent(context.config.tab_spaces());
358 let lhs = arg_vec[0].rewrite(context, nested_shape)?;
359 let rhs = arg_vec[1].rewrite(context, nested_shape)?;
360 if !lhs.contains('\n')
361 && !rhs.contains('\n')
362 && lhs.len() + rhs.len() + total_overhead <= shape.width
364 // macro_name(lhs; rhs) or macro_name[lhs; rhs]
365 Some(format!("{}{}{}; {}{}", macro_name, left, lhs, rhs, right))
367 // macro_name(\nlhs;\nrhs\n) or macro_name[\nlhs;\nrhs\n]
372 nested_shape.indent.to_string_with_newline(context.config),
374 nested_shape.indent.to_string_with_newline(context.config),
376 shape.indent.to_string_with_newline(context.config),
382 pub(crate) fn rewrite_macro_def(
383 context: &RewriteContext<'_>,
387 ident: symbol::Ident,
388 vis: &ast::Visibility,
390 ) -> Option<String> {
391 let snippet = Some(remove_trailing_white_spaces(context.snippet(span)));
392 if snippet.as_ref().map_or(true, |s| s.ends_with(';')) {
396 let ts = def.body.tokens.clone();
397 let mut parser = MacroParser::new(ts.into_trees());
398 let parsed_def = match parser.parse() {
400 None => return snippet,
403 let mut result = if def.macro_rules {
404 String::from("macro_rules!")
406 format!("{}macro", format_visibility(context, vis))
410 result += rewrite_ident(context, ident);
412 let multi_branch_style = def.macro_rules || parsed_def.branches.len() != 1;
414 let arm_shape = if multi_branch_style {
416 .block_indent(context.config.tab_spaces())
417 .with_max_width(context.config)
422 let branch_items = itemize_list(
423 context.snippet_provider,
424 parsed_def.branches.iter(),
427 |branch| branch.span.lo(),
428 |branch| branch.span.hi(),
429 |branch| match branch.rewrite(context, arm_shape, multi_branch_style) {
431 // if the rewrite returned None because a macro could not be rewritten, then return the
433 None if context.macro_rewrite_failure.get() => {
434 Some(context.snippet(branch.body).trim().to_string())
438 context.snippet_provider.span_after(span, "{"),
442 .collect::<Vec<_>>();
444 let fmt = ListFormatting::new(arm_shape, context.config)
445 .separator(if def.macro_rules { ";" } else { "" })
446 .trailing_separator(SeparatorTactic::Always)
447 .preserve_newline(true);
449 if multi_branch_style {
451 result += &arm_shape.indent.to_string_with_newline(context.config);
454 match write_list(&branch_items, &fmt) {
455 Some(ref s) => result += s,
456 None => return snippet,
459 if multi_branch_style {
460 result += &indent.to_string_with_newline(context.config);
467 fn register_metavariable(
468 map: &mut HashMap<String, String>,
473 let mut new_name = "$".repeat(dollar_count - 1);
474 let mut old_name = "$".repeat(dollar_count);
477 new_name.push_str(name);
478 old_name.push_str(name);
480 result.push_str(&new_name);
481 map.insert(old_name, new_name);
484 // Replaces `$foo` with `zfoo`. We must check for name overlap to ensure we
485 // aren't causing problems.
486 // This should also work for escaped `$` variables, where we leave earlier `$`s.
487 fn replace_names(input: &str) -> Option<(String, HashMap<String, String>)> {
488 // Each substitution will require five or six extra bytes.
489 let mut result = String::with_capacity(input.len() + 64);
490 let mut substs = HashMap::new();
491 let mut dollar_count = 0;
492 let mut cur_name = String::new();
494 for (kind, c) in CharClasses::new(input.chars()) {
495 if kind != FullCodeCharKind::Normal {
499 } else if dollar_count == 0 {
501 } else if !c.is_alphanumeric() && !cur_name.is_empty() {
502 // Terminates a name following one or more dollars.
503 register_metavariable(&mut substs, &mut result, &cur_name, dollar_count);
508 } else if c == '(' && cur_name.is_empty() {
509 // FIXME: Support macro def with repeat.
511 } else if c.is_alphanumeric() || c == '_' {
516 if !cur_name.is_empty() {
517 register_metavariable(&mut substs, &mut result, &cur_name, dollar_count);
520 debug!("replace_names `{}` {:?}", result, substs);
522 Some((result, substs))
525 #[derive(Debug, Clone)]
527 /// e.g., `$x: expr`.
528 MetaVariable(Symbol, String),
529 /// e.g., `$($foo: expr),*`
531 /// `()`, `[]` or `{}`.
533 /// Inner arguments inside delimiters.
535 /// Something after the closing delimiter and the repeat token, if available.
536 Option<Box<ParsedMacroArg>>,
537 /// The repeat token. This could be one of `*`, `+` or `?`.
540 /// e.g., `[derive(Debug)]`
541 Delimited(Delimiter, Vec<ParsedMacroArg>),
542 /// A possible separator. e.g., `,` or `;`.
543 Separator(String, String),
544 /// Other random stuff that does not fit to other kinds.
545 /// e.g., `== foo` in `($x: expr == foo)`.
546 Other(String, String),
549 fn delim_token_to_str(
550 context: &RewriteContext<'_>,
551 delim_token: Delimiter,
553 use_multiple_lines: bool,
554 inner_is_empty: bool,
555 ) -> (String, String) {
556 let (lhs, rhs) = match delim_token {
557 Delimiter::Parenthesis => ("(", ")"),
558 Delimiter::Bracket => ("[", "]"),
559 Delimiter::Brace => {
560 if inner_is_empty || use_multiple_lines {
566 Delimiter::Invisible => unreachable!(),
568 if use_multiple_lines {
569 let indent_str = shape.indent.to_string_with_newline(context.config);
570 let nested_indent_str = shape
572 .block_indent(context.config)
573 .to_string_with_newline(context.config);
575 format!("{}{}", lhs, nested_indent_str),
576 format!("{}{}", indent_str, rhs),
579 (lhs.to_owned(), rhs.to_owned())
584 fn starts_with_brace(&self) -> bool {
587 MacroArgKind::Repeat(Delimiter::Brace, _, _, _)
588 | MacroArgKind::Delimited(Delimiter::Brace, _)
592 fn starts_with_dollar(&self) -> bool {
595 MacroArgKind::Repeat(..) | MacroArgKind::MetaVariable(..)
599 fn ends_with_space(&self) -> bool {
600 matches!(*self, MacroArgKind::Separator(..))
603 fn has_meta_var(&self) -> bool {
605 MacroArgKind::MetaVariable(..) => true,
606 MacroArgKind::Repeat(_, ref args, _, _) => args.iter().any(|a| a.kind.has_meta_var()),
613 context: &RewriteContext<'_>,
615 use_multiple_lines: bool,
616 ) -> Option<String> {
617 let rewrite_delimited_inner = |delim_tok, args| -> Option<(String, String, String)> {
618 let inner = wrap_macro_args(context, args, shape)?;
619 let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, false, inner.is_empty());
620 if lhs.len() + inner.len() + rhs.len() <= shape.width {
621 return Some((lhs, inner, rhs));
624 let (lhs, rhs) = delim_token_to_str(context, delim_tok, shape, true, false);
625 let nested_shape = shape
626 .block_indent(context.config.tab_spaces())
627 .with_max_width(context.config);
628 let inner = wrap_macro_args(context, args, nested_shape)?;
629 Some((lhs, inner, rhs))
633 MacroArgKind::MetaVariable(ty, ref name) => Some(format!("${}:{}", name, ty)),
634 MacroArgKind::Repeat(delim_tok, ref args, ref another, ref tok) => {
635 let (lhs, inner, rhs) = rewrite_delimited_inner(delim_tok, args)?;
636 let another = another
638 .and_then(|a| a.rewrite(context, shape, use_multiple_lines))
639 .unwrap_or_else(|| "".to_owned());
640 let repeat_tok = pprust::token_to_string(tok);
642 Some(format!("${}{}{}{}{}", lhs, inner, rhs, another, repeat_tok))
644 MacroArgKind::Delimited(delim_tok, ref args) => {
645 rewrite_delimited_inner(delim_tok, args)
646 .map(|(lhs, inner, rhs)| format!("{}{}{}", lhs, inner, rhs))
648 MacroArgKind::Separator(ref sep, ref prefix) => Some(format!("{}{} ", prefix, sep)),
649 MacroArgKind::Other(ref inner, ref prefix) => Some(format!("{}{}", prefix, inner)),
654 #[derive(Debug, Clone)]
655 struct ParsedMacroArg {
659 impl ParsedMacroArg {
662 context: &RewriteContext<'_>,
664 use_multiple_lines: bool,
665 ) -> Option<String> {
666 self.kind.rewrite(context, shape, use_multiple_lines)
670 /// Parses macro arguments on macro def.
671 struct MacroArgParser {
672 /// Either a name of the next metavariable, a separator, or junk.
674 /// The first token of the current buffer.
676 /// `true` if we are parsing a metavariable or a repeat.
678 /// The last token parsed.
680 /// Holds the parsed arguments.
681 result: Vec<ParsedMacroArg>,
684 fn last_tok(tt: &TokenTree) -> Token {
686 TokenTree::Token(ref t, _) => t.clone(),
687 TokenTree::Delimited(delim_span, delim, _) => Token {
688 kind: TokenKind::CloseDelim(delim),
689 span: delim_span.close,
694 impl MacroArgParser {
695 fn new() -> MacroArgParser {
700 kind: TokenKind::Eof,
704 kind: TokenKind::Eof,
711 fn set_last_tok(&mut self, tok: &TokenTree) {
712 self.last_tok = last_tok(tok);
715 fn add_separator(&mut self) {
716 let prefix = if self.need_space_prefix() {
721 self.result.push(ParsedMacroArg {
722 kind: MacroArgKind::Separator(self.buf.clone(), prefix),
727 fn add_other(&mut self) {
728 let prefix = if self.need_space_prefix() {
733 self.result.push(ParsedMacroArg {
734 kind: MacroArgKind::Other(self.buf.clone(), prefix),
739 fn add_meta_variable(&mut self, iter: &mut TokenTreeCursor) -> Option<()> {
741 Some(TokenTree::Token(
743 kind: TokenKind::Ident(name, _),
748 self.result.push(ParsedMacroArg {
749 kind: MacroArgKind::MetaVariable(name, self.buf.clone()),
753 self.is_meta_var = false;
760 fn add_delimited(&mut self, inner: Vec<ParsedMacroArg>, delim: Delimiter) {
761 self.result.push(ParsedMacroArg {
762 kind: MacroArgKind::Delimited(delim, inner),
769 inner: Vec<ParsedMacroArg>,
771 iter: &mut TokenTreeCursor,
773 let mut buffer = String::new();
774 let mut first = true;
776 // Parse '*', '+' or '?.
778 self.set_last_tok(&tok);
786 kind: TokenKind::BinOp(BinOpToken::Plus),
793 kind: TokenKind::Question,
800 kind: TokenKind::BinOp(BinOpToken::Star),
807 TokenTree::Token(ref t, _) => {
808 buffer.push_str(&pprust::token_to_string(t));
814 // There could be some random stuff between ')' and '*', '+' or '?'.
815 let another = if buffer.trim().is_empty() {
818 Some(Box::new(ParsedMacroArg {
819 kind: MacroArgKind::Other(buffer, "".to_owned()),
823 self.result.push(ParsedMacroArg {
824 kind: MacroArgKind::Repeat(delim, inner, another, self.last_tok.clone()),
829 fn update_buffer(&mut self, t: &Token) {
830 if self.buf.is_empty() {
831 self.start_tok = t.clone();
833 let needs_space = match next_space(&self.last_tok.kind) {
834 SpaceState::Ident => ident_like(t),
835 SpaceState::Punctuation => !ident_like(t),
836 SpaceState::Always => true,
837 SpaceState::Never => false,
839 if force_space_before(&t.kind) || needs_space {
844 self.buf.push_str(&pprust::token_to_string(t));
847 fn need_space_prefix(&self) -> bool {
848 if self.result.is_empty() {
852 let last_arg = self.result.last().unwrap();
853 if let MacroArgKind::MetaVariable(..) = last_arg.kind {
854 if ident_like(&self.start_tok) {
857 if self.start_tok.kind == TokenKind::Colon {
862 if force_space_before(&self.start_tok.kind) {
869 /// Returns a collection of parsed macro def's arguments.
870 fn parse(mut self, tokens: TokenStream) -> Option<Vec<ParsedMacroArg>> {
871 let mut iter = tokens.into_trees();
873 while let Some(tok) = iter.next() {
877 kind: TokenKind::Dollar,
882 // We always want to add a separator before meta variables.
883 if !self.buf.is_empty() {
884 self.add_separator();
887 // Start keeping the name of this metavariable in the buffer.
888 self.is_meta_var = true;
889 self.start_tok = Token {
890 kind: TokenKind::Dollar,
896 kind: TokenKind::Colon,
900 ) if self.is_meta_var => {
901 self.add_meta_variable(&mut iter)?;
903 TokenTree::Token(ref t, _) => self.update_buffer(t),
904 TokenTree::Delimited(_delimited_span, delimited, ref tts) => {
905 if !self.buf.is_empty() {
906 if next_space(&self.last_tok.kind) == SpaceState::Always {
907 self.add_separator();
913 // Parse the stuff inside delimiters.
914 let parser = MacroArgParser::new();
915 let delimited_arg = parser.parse(tts.clone())?;
917 if self.is_meta_var {
918 self.add_repeat(delimited_arg, delimited, &mut iter)?;
919 self.is_meta_var = false;
921 self.add_delimited(delimited_arg, delimited);
926 self.set_last_tok(&tok);
929 // We are left with some stuff in the buffer. Since there is nothing
930 // left to separate, add this as `Other`.
931 if !self.buf.is_empty() {
940 context: &RewriteContext<'_>,
941 args: &[ParsedMacroArg],
943 ) -> Option<String> {
944 wrap_macro_args_inner(context, args, shape, false)
945 .or_else(|| wrap_macro_args_inner(context, args, shape, true))
948 fn wrap_macro_args_inner(
949 context: &RewriteContext<'_>,
950 args: &[ParsedMacroArg],
952 use_multiple_lines: bool,
953 ) -> Option<String> {
954 let mut result = String::with_capacity(128);
955 let mut iter = args.iter().peekable();
956 let indent_str = shape.indent.to_string_with_newline(context.config);
958 while let Some(arg) = iter.next() {
959 result.push_str(&arg.rewrite(context, shape, use_multiple_lines)?);
961 if use_multiple_lines
962 && (arg.kind.ends_with_space() || iter.peek().map_or(false, |a| a.kind.has_meta_var()))
964 if arg.kind.ends_with_space() {
967 result.push_str(&indent_str);
968 } else if let Some(next_arg) = iter.peek() {
969 let space_before_dollar =
970 !arg.kind.ends_with_space() && next_arg.kind.starts_with_dollar();
971 let space_before_brace = next_arg.kind.starts_with_brace();
972 if space_before_dollar || space_before_brace {
978 if !use_multiple_lines && result.len() >= shape.width {
985 // This is a bit sketchy. The token rules probably need tweaking, but it works
986 // for some common cases. I hope the basic logic is sufficient. Note that the
987 // meaning of some tokens is a bit different here from usual Rust, e.g., `*`
988 // and `(`/`)` have special meaning.
990 // We always try and format on one line.
991 // FIXME: Use multi-line when every thing does not fit on one line.
992 fn format_macro_args(
993 context: &RewriteContext<'_>,
994 token_stream: TokenStream,
996 ) -> Option<String> {
997 if !context.config.format_macro_matchers() {
998 let span = span_for_token_stream(&token_stream);
999 return Some(match span {
1000 Some(span) => context.snippet(span).to_owned(),
1001 None => String::new(),
1004 let parsed_args = MacroArgParser::new().parse(token_stream)?;
1005 wrap_macro_args(context, &parsed_args, shape)
1008 fn span_for_token_stream(token_stream: &TokenStream) -> Option<Span> {
1009 token_stream.trees().next().map(|tt| tt.span())
1012 // We should insert a space if the next token is a:
1013 #[derive(Copy, Clone, PartialEq)]
1017 Ident, // Or ident/literal-like thing.
1021 fn force_space_before(tok: &TokenKind) -> bool {
1022 debug!("tok: force_space_before {:?}", tok);
1036 | TokenKind::BinOpEq(_)
1040 | TokenKind::FatArrow
1041 | TokenKind::BinOp(_)
1043 | TokenKind::Dollar => true,
1048 fn ident_like(tok: &Token) -> bool {
1051 TokenKind::Ident(..) | TokenKind::Literal(..) | TokenKind::Lifetime(_)
1055 fn next_space(tok: &TokenKind) -> SpaceState {
1056 debug!("next_space: {:?}", tok);
1060 | TokenKind::BinOp(BinOpToken::And)
1066 | TokenKind::DotDotDot
1067 | TokenKind::DotDotEq
1068 | TokenKind::Question => SpaceState::Punctuation,
1073 | TokenKind::OpenDelim(_)
1074 | TokenKind::CloseDelim(_) => SpaceState::Never,
1076 TokenKind::Literal(..) | TokenKind::Ident(..) | TokenKind::Lifetime(_) => SpaceState::Ident,
1078 _ => SpaceState::Always,
1082 /// Tries to convert a macro use into a short hand try expression. Returns `None`
1083 /// when the macro is not an instance of `try!` (or parsing the inner expression
1085 pub(crate) fn convert_try_mac(
1087 context: &RewriteContext<'_>,
1088 ) -> Option<ast::Expr> {
1089 let path = &pprust::path_to_string(&mac.path);
1090 if path == "try" || path == "r#try" {
1091 let ts = mac.args.tokens.clone();
1094 id: ast::NodeId::root(), // dummy value
1095 kind: ast::ExprKind::Try(parse_expr(context, ts)?),
1096 span: mac.span(), // incorrect span, but shouldn't matter too much
1097 attrs: ast::AttrVec::new(),
1105 pub(crate) fn macro_style(mac: &ast::MacCall, context: &RewriteContext<'_>) -> Delimiter {
1106 let snippet = context.snippet(mac.span());
1107 let paren_pos = snippet.find_uncommented("(").unwrap_or(usize::max_value());
1108 let bracket_pos = snippet.find_uncommented("[").unwrap_or(usize::max_value());
1109 let brace_pos = snippet.find_uncommented("{").unwrap_or(usize::max_value());
1111 if paren_pos < bracket_pos && paren_pos < brace_pos {
1112 Delimiter::Parenthesis
1113 } else if bracket_pos < brace_pos {
1120 // A very simple parser that just parses a macros 2.0 definition into its branches.
1121 // Currently we do not attempt to parse any further than that.
1123 struct MacroParser {
1124 toks: TokenTreeCursor,
1128 // (`(` ... `)` `=>` `{` ... `}`)*
1129 fn parse(&mut self) -> Option<Macro> {
1130 let mut branches = vec![];
1131 while self.toks.look_ahead(1).is_some() {
1132 branches.push(self.parse_branch()?);
1135 Some(Macro { branches })
1138 // `(` ... `)` `=>` `{` ... `}`
1139 fn parse_branch(&mut self) -> Option<MacroBranch> {
1140 let tok = self.toks.next()?;
1141 let (lo, args_paren_kind) = match tok {
1142 TokenTree::Token(..) => return None,
1143 TokenTree::Delimited(delimited_span, d, _) => (delimited_span.open.lo(), d),
1145 let args = TokenStream::new(vec![tok]);
1146 match self.toks.next()? {
1149 kind: TokenKind::FatArrow,
1156 let (mut hi, body, whole_body) = match self.toks.next()? {
1157 TokenTree::Token(..) => return None,
1158 TokenTree::Delimited(delimited_span, ..) => {
1159 let data = delimited_span.entire().data();
1163 data.lo + BytePos(1),
1164 data.hi - BytePos(1),
1168 delimited_span.entire(),
1172 if let Some(TokenTree::Token(
1174 kind: TokenKind::Semi,
1178 )) = self.toks.look_ahead(0)
1184 span: mk_sp(lo, hi),
1193 // A parsed macros 2.0 macro definition.
1195 branches: Vec<MacroBranch>,
1198 // FIXME: it would be more efficient to use references to the token streams
1199 // rather than clone them, if we can make the borrowing work out.
1200 struct MacroBranch {
1202 args_paren_kind: Delimiter,
1211 context: &RewriteContext<'_>,
1213 multi_branch_style: bool,
1214 ) -> Option<String> {
1215 // Only attempt to format function-like macros.
1216 if self.args_paren_kind != Delimiter::Parenthesis {
1217 // FIXME(#1539): implement for non-sugared macros.
1222 let mut result = format_macro_args(context, self.args.clone(), shape.sub_width(5)?)?;
1224 if multi_branch_style {
1228 if !context.config.format_macro_bodies() {
1230 result += context.snippet(self.whole_body);
1231 return Some(result);
1234 // The macro body is the most interesting part. It might end up as various
1235 // AST nodes, but also has special variables (e.g, `$foo`) which can't be
1236 // parsed as regular Rust code (and note that these can be escaped using
1237 // `$$`). We'll try and format like an AST node, but we'll substitute
1238 // variables for new names with the same length first.
1240 let old_body = context.snippet(self.body).trim();
1241 let (body_str, substs) = replace_names(old_body)?;
1242 let has_block_body = old_body.starts_with('{');
1244 let mut config = context.config.clone();
1245 config.set().hide_parse_errors(true);
1249 let body_indent = if has_block_body {
1252 shape.indent.block_indent(&config)
1254 let new_width = config.max_width() - body_indent.width();
1255 config.set().max_width(new_width);
1257 // First try to format as items, then as statements.
1258 let new_body_snippet = match crate::format_snippet(&body_str, &config, true) {
1259 Some(new_body) => new_body,
1261 let new_width = new_width + config.tab_spaces();
1262 config.set().max_width(new_width);
1263 match crate::format_code_block(&body_str, &config, true) {
1264 Some(new_body) => new_body,
1265 None => return None,
1270 if !filtered_str_fits(&new_body_snippet.snippet, config.max_width(), shape) {
1274 // Indent the body since it is in a block.
1275 let indent_str = body_indent.to_string(&config);
1276 let mut new_body = LineClasses::new(new_body_snippet.snippet.trim_end())
1279 (String::new(), true),
1280 |(mut s, need_indent), (i, (kind, ref l))| {
1281 if !is_empty_line(l)
1283 && !new_body_snippet.is_line_non_formatted(i + 1)
1287 (s + l + "\n", indent_next_line(kind, l, &config))
1292 // Undo our replacement of macro variables.
1293 // FIXME: this could be *much* more efficient.
1294 for (old, new) in &substs {
1295 if old_body.contains(new) {
1296 debug!("rewrite_macro_def: bailing matching variable: `{}`", new);
1299 new_body = new_body.replace(new, old);
1303 result += new_body.trim();
1304 } else if !new_body.is_empty() {
1306 result += &new_body;
1307 result += &shape.indent.to_string(&config);
1316 /// Format `lazy_static!` from <https://crates.io/crates/lazy_static>.
1318 /// # Expected syntax
1322 /// [pub] static ref NAME_1: TYPE_1 = EXPR_1;
1323 /// [pub] static ref NAME_2: TYPE_2 = EXPR_2;
1325 /// [pub] static ref NAME_N: TYPE_N = EXPR_N;
1328 fn format_lazy_static(
1329 context: &RewriteContext<'_>,
1332 ) -> Option<String> {
1333 let mut result = String::with_capacity(1024);
1334 let nested_shape = shape
1335 .block_indent(context.config.tab_spaces())
1336 .with_max_width(context.config);
1338 result.push_str("lazy_static! {");
1339 result.push_str(&nested_shape.indent.to_string_with_newline(context.config));
1341 let parsed_elems = parse_lazy_static(context, ts)?;
1342 let last = parsed_elems.len() - 1;
1343 for (i, (vis, id, ty, expr)) in parsed_elems.iter().enumerate() {
1344 // Rewrite as a static item.
1345 let vis = crate::utils::format_visibility(context, vis);
1346 let mut stmt = String::with_capacity(128);
1347 stmt.push_str(&format!(
1348 "{}static ref {}: {} =",
1351 ty.rewrite(context, nested_shape)?
1353 result.push_str(&rewrite_assign_rhs(
1357 &RhsAssignKind::Expr(&expr.kind, expr.span),
1358 nested_shape.sub_width(1)?,
1362 result.push_str(&nested_shape.indent.to_string_with_newline(context.config));
1366 result.push_str(&shape.indent.to_string_with_newline(context.config));
1372 fn rewrite_macro_with_items(
1373 context: &RewriteContext<'_>,
1378 position: MacroPosition,
1380 ) -> Option<String> {
1381 let (opener, closer) = match style {
1382 Delimiter::Parenthesis => ("(", ")"),
1383 Delimiter::Bracket => ("[", "]"),
1384 Delimiter::Brace => (" {", "}"),
1387 let trailing_semicolon = match style {
1388 Delimiter::Parenthesis | Delimiter::Bracket if position == MacroPosition::Item => ";",
1392 let mut visitor = FmtVisitor::from_context(context);
1393 visitor.block_indent = shape.indent.block_indent(context.config);
1394 visitor.last_pos = context.snippet_provider.span_after(span, opener.trim());
1396 let item = match item {
1397 MacroArg::Item(item) => item,
1400 visitor.visit_item(item);
1403 let mut result = String::with_capacity(256);
1404 result.push_str(macro_name);
1405 result.push_str(opener);
1406 result.push_str(&visitor.block_indent.to_string_with_newline(context.config));
1407 result.push_str(visitor.buffer.trim());
1408 result.push_str(&shape.indent.to_string_with_newline(context.config));
1409 result.push_str(closer);
1410 result.push_str(trailing_semicolon);