src/macros.rs

   1 // Copyright 2015 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 list-like macro invocations. These are invocations whose token trees
  12 // can be interpreted as expressions and separated by commas.
  13 // Note that these token trees do not actually have to be interpreted as
  14 // expressions by the compiler. An example of an invocation we would reformat is
  15 // foo!( x, y, z ). The token x may represent an identifier in the code, but we
  16 // interpreted as an expression.
  17 // Macro uses which are not-list like, such as bar!(key => val), will not be
  18 // reformatted.
  19 // List-like invocations with parentheses will be formatted as function calls,
  20 // and those with brackets will be formatted as array literals.
  21
  22 use std::collections::HashMap;
  23 use syntax::ast;
  24 use syntax::codemap::{BytePos, Span};
  25 use syntax::parse::new_parser_from_tts;
  26 use syntax::parse::parser::Parser;
  27 use syntax::parse::token::{BinOpToken, DelimToken, Token};
  28 use syntax::print::pprust;
  29 use syntax::symbol;
  30 use syntax::tokenstream::{Cursor, ThinTokenStream, TokenStream, TokenTree};
  31 use syntax::util::ThinVec;
  32
  33 use codemap::SpanUtils;
  34 use comment::{contains_comment, remove_trailing_white_spaces, FindUncommented};
  35 use expr::{rewrite_array, rewrite_call_inner};
  36 use rewrite::{Rewrite, RewriteContext};
  37 use shape::{Indent, Shape};
  38 use utils::{format_visibility, mk_sp};
  39
  40 const FORCED_BRACKET_MACROS: &[&str] = &["vec!"];
  41
  42 // FIXME: use the enum from libsyntax?
  43 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
  44 enum MacroStyle {
  45     Parens,
  46     Brackets,
  47     Braces,
  48 }
  49
  50 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  51 pub enum MacroPosition {
  52     Item,
  53     Statement,
  54     Expression,
  55     Pat,
  56 }
  57
  58 impl MacroStyle {
  59     fn opener(&self) -> &'static str {
  60         match *self {
  61             MacroStyle::Parens => "(",
  62             MacroStyle::Brackets => "[",
  63             MacroStyle::Braces => "{",
  64         }
  65     }
  66 }
  67
  68 #[derive(Debug)]
  69 pub enum MacroArg {
  70     Expr(ast::Expr),
  71     Ty(ast::Ty),
  72     Pat(ast::Pat),
  73 }
  74
  75 impl Rewrite for MacroArg {
  76     fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
  77         match *self {
  78             MacroArg::Expr(ref expr) => expr.rewrite(context, shape),
  79             MacroArg::Ty(ref ty) => ty.rewrite(context, shape),
  80             MacroArg::Pat(ref pat) => pat.rewrite(context, shape),
  81         }
  82     }
  83 }
  84
  85 fn parse_macro_arg(parser: &mut Parser) -> Option<MacroArg> {
  86     macro_rules! parse_macro_arg {
  87         ($macro_arg: ident, $parser: ident) => {
  88             let mut cloned_parser = (*parser).clone();
  89             match cloned_parser.$parser() {
  90                 Ok(x) => {
  91                     if parser.sess.span_diagnostic.has_errors() {
  92                         parser.sess.span_diagnostic.reset_err_count();
  93                     } else {
  94                         // Parsing succeeded.
  95                         *parser = cloned_parser;
  96                         return Some(MacroArg::$macro_arg((*x).clone()));
  97                     }
  98                 }
  99                 Err(mut e) => {
 100                     e.cancel();
 101                     parser.sess.span_diagnostic.reset_err_count();
 102                 }
 103             }
 104         }
 105     }
 106
 107     parse_macro_arg!(Expr, parse_expr);
 108     parse_macro_arg!(Ty, parse_ty);
 109     parse_macro_arg!(Pat, parse_pat);
 110
 111     None
 112 }
 113
 114 pub fn rewrite_macro(
 115     mac: &ast::Mac,
 116     extra_ident: Option<ast::Ident>,
 117     context: &RewriteContext,
 118     shape: Shape,
 119     position: MacroPosition,
 120 ) -> Option<String> {
 121     let context = &mut context.clone();
 122     context.inside_macro = true;
 123     if context.config.use_try_shorthand() {
 124         if let Some(expr) = convert_try_mac(mac, context) {
 125             context.inside_macro = false;
 126             return expr.rewrite(context, shape);
 127         }
 128     }
 129
 130     let original_style = macro_style(mac, context);
 131
 132     let macro_name = match extra_ident {
 133         None => format!("{}!", mac.node.path),
 134         Some(ident) => {
 135             if ident == symbol::keywords::Invalid.ident() {
 136                 format!("{}!", mac.node.path)
 137             } else {
 138                 format!("{}! {}", mac.node.path, ident)
 139             }
 140         }
 141     };
 142
 143     let style = if FORCED_BRACKET_MACROS.contains(&&macro_name[..]) {
 144         MacroStyle::Brackets
 145     } else {
 146         original_style
 147     };
 148
 149     let ts: TokenStream = mac.node.stream();
 150     if ts.is_empty() && !contains_comment(context.snippet(mac.span)) {
 151         return match style {
 152             MacroStyle::Parens if position == MacroPosition::Item => {
 153                 Some(format!("{}();", macro_name))
 154             }
 155             MacroStyle::Parens => Some(format!("{}()", macro_name)),
 156             MacroStyle::Brackets => Some(format!("{}[]", macro_name)),
 157             MacroStyle::Braces => Some(format!("{}{{}}", macro_name)),
 158         };
 159     }
 160
 161     let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
 162     let mut arg_vec = Vec::new();
 163     let mut vec_with_semi = false;
 164     let mut trailing_comma = false;
 165
 166     if MacroStyle::Braces != style {
 167         loop {
 168             match parse_macro_arg(&mut parser) {
 169                 Some(arg) => arg_vec.push(arg),
 170                 None => return Some(context.snippet(mac.span).to_owned()),
 171             }
 172
 173             match parser.token {
 174                 Token::Eof => break,
 175                 Token::Comma => (),
 176                 Token::Semi => {
 177                     // Try to parse `vec![expr; expr]`
 178                     if FORCED_BRACKET_MACROS.contains(&&macro_name[..]) {
 179                         parser.bump();
 180                         if parser.token != Token::Eof {
 181                             match parse_macro_arg(&mut parser) {
 182                                 Some(arg) => {
 183                                     arg_vec.push(arg);
 184                                     parser.bump();
 185                                     if parser.token == Token::Eof && arg_vec.len() == 2 {
 186                                         vec_with_semi = true;
 187                                         break;
 188                                     }
 189                                 }
 190                                 None => return Some(context.snippet(mac.span).to_owned()),
 191                             }
 192                         }
 193                     }
 194                     return Some(context.snippet(mac.span).to_owned());
 195                 }
 196                 _ => return Some(context.snippet(mac.span).to_owned()),
 197             }
 198
 199             parser.bump();
 200
 201             if parser.token == Token::Eof {
 202                 trailing_comma = true;
 203                 break;
 204             }
 205         }
 206     }
 207
 208     match style {
 209         MacroStyle::Parens => {
 210             // Format macro invocation as function call, forcing no trailing
 211             // comma because not all macros support them.
 212             rewrite_call_inner(
 213                 context,
 214                 &macro_name,
 215                 &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>()[..],
 216                 mac.span,
 217                 shape,
 218                 context.config.width_heuristics().fn_call_width,
 219                 trailing_comma,
 220             ).map(|rw| match position {
 221                 MacroPosition::Item => format!("{};", rw),
 222                 _ => rw,
 223             })
 224         }
 225         MacroStyle::Brackets => {
 226             let mac_shape = shape.offset_left(macro_name.len())?;
 227             // Handle special case: `vec![expr; expr]`
 228             if vec_with_semi {
 229                 let (lbr, rbr) = if context.config.spaces_within_parens_and_brackets() {
 230                     ("[ ", " ]")
 231                 } else {
 232                     ("[", "]")
 233                 };
 234                 // 6 = `vec!` + `; `
 235                 let total_overhead = lbr.len() + rbr.len() + 6;
 236                 let nested_shape = mac_shape.block_indent(context.config.tab_spaces());
 237                 let lhs = arg_vec[0].rewrite(context, nested_shape)?;
 238                 let rhs = arg_vec[1].rewrite(context, nested_shape)?;
 239                 if !lhs.contains('\n') && !rhs.contains('\n')
 240                     && lhs.len() + rhs.len() + total_overhead <= shape.width
 241                 {
 242                     Some(format!("{}{}{}; {}{}", macro_name, lbr, lhs, rhs, rbr))
 243                 } else {
 244                     Some(format!(
 245                         "{}{}\n{}{};\n{}{}\n{}{}",
 246                         macro_name,
 247                         lbr,
 248                         nested_shape.indent.to_string(context.config),
 249                         lhs,
 250                         nested_shape.indent.to_string(context.config),
 251                         rhs,
 252                         shape.indent.to_string(context.config),
 253                         rbr
 254                     ))
 255                 }
 256             } else {
 257                 // If we are rewriting `vec!` macro or other special macros,
 258                 // then we can rewrite this as an usual array literal.
 259                 // Otherwise, we must preserve the original existence of trailing comma.
 260                 if FORCED_BRACKET_MACROS.contains(&macro_name.as_str()) {
 261                     context.inside_macro = false;
 262                     trailing_comma = false;
 263                 }
 264                 // Convert `MacroArg` into `ast::Expr`, as `rewrite_array` only accepts the latter.
 265                 let sp = mk_sp(
 266                     context
 267                         .codemap
 268                         .span_after(mac.span, original_style.opener()),
 269                     mac.span.hi() - BytePos(1),
 270                 );
 271                 let arg_vec = &arg_vec.iter().map(|e| &*e).collect::<Vec<_>>()[..];
 272                 let rewrite = rewrite_array(arg_vec, sp, context, mac_shape, trailing_comma)?;
 273
 274                 Some(format!("{}{}", macro_name, rewrite))
 275             }
 276         }
 277         MacroStyle::Braces => {
 278             // Skip macro invocations with braces, for now.
 279             indent_macro_snippet(context, context.snippet(mac.span), shape.indent)
 280         }
 281     }
 282 }
 283
 284 pub fn rewrite_macro_def(
 285     context: &RewriteContext,
 286     indent: Indent,
 287     def: &ast::MacroDef,
 288     ident: ast::Ident,
 289     vis: &ast::Visibility,
 290     span: Span,
 291 ) -> Option<String> {
 292     let snippet = Some(remove_trailing_white_spaces(context.snippet(span)));
 293
 294     let mut parser = MacroParser::new(def.stream().into_trees());
 295     let parsed_def = match parser.parse() {
 296         Some(def) => def,
 297         None => return snippet,
 298     };
 299
 300     let mut result = if def.legacy {
 301         String::from("macro_rules!")
 302     } else {
 303         format!("{}macro", format_visibility(vis))
 304     };
 305
 306     result += " ";
 307     result += &ident.name.as_str();
 308     result += " {";
 309
 310     let mac_indent = indent.block_indent(context.config);
 311     let mac_indent_str = mac_indent.to_string(context.config);
 312
 313     for branch in parsed_def.branches {
 314         // Only attempt to format function-like macros.
 315         if branch.args_paren_kind != DelimToken::Paren {
 316             // FIXME(#1539): implement for non-sugared macros.
 317             return snippet;
 318         }
 319
 320         result += "\n";
 321         result += &mac_indent_str;
 322         result += "(";
 323         result += &format_macro_args(branch.args)?;
 324         result += ") => {\n";
 325
 326         // The macro body is the most interesting part. It might end up as various
 327         // AST nodes, but also has special variables (e.g, `$foo`) which can't be
 328         // parsed as regular Rust code (and note that these can be escaped using
 329         // `$$`). We'll try and format like an AST node, but we'll substitute
 330         // variables for new names with the same length first.
 331
 332         let old_body = context.snippet(branch.body).trim();
 333         let (body_str, substs) = match replace_names(old_body) {
 334             Some(result) => result,
 335             None => return snippet,
 336         };
 337
 338         // We'll hack the indent below, take this into account when formatting,
 339         let mut config = context.config.clone();
 340         let body_indent = mac_indent.block_indent(&config);
 341         let new_width = config.max_width() - body_indent.width();
 342         config.set().max_width(new_width);
 343         config.set().hide_parse_errors(true);
 344
 345         // First try to format as items, then as statements.
 346         let new_body = match ::format_snippet(&body_str, &config) {
 347             Some(new_body) => new_body,
 348             None => match ::format_code_block(&body_str, &config) {
 349                 Some(new_body) => new_body,
 350                 None => return snippet,
 351             },
 352         };
 353
 354         // Indent the body since it is in a block.
 355         let indent_str = body_indent.to_string(&config);
 356         let mut new_body = new_body
 357             .trim_right()
 358             .lines()
 359             .fold(String::new(), |mut s, l| {
 360                 if !l.is_empty() {
 361                     s += &indent_str;
 362                 }
 363                 s + l + "\n"
 364             });
 365
 366         // Undo our replacement of macro variables.
 367         // FIXME: this could be *much* more efficient.
 368         for (old, new) in &substs {
 369             if old_body.find(new).is_some() {
 370                 debug!(
 371                     "rewrite_macro_def: bailing matching variable: `{}` in `{}`",
 372                     new, ident
 373                 );
 374                 return snippet;
 375             }
 376             new_body = new_body.replace(new, old);
 377         }
 378
 379         result += &new_body;
 380
 381         result += &mac_indent_str;
 382         result += "}";
 383         if def.legacy{
 384             result += ";";
 385         }
 386         result += "\n";
 387     }
 388
 389     result += &indent.to_string(context.config);
 390     result += "}";
 391
 392     Some(result)
 393 }
 394
 395 // Replaces `$foo` with `zfoo`. We must check for name overlap to ensure we
 396 // aren't causing problems.
 397 // This should also work for escaped `$` variables, where we leave earlier `$`s.
 398 fn replace_names(input: &str) -> Option<(String, HashMap<String, String>)> {
 399     // Each substitution will require five or six extra bytes.
 400     let mut result = String::with_capacity(input.len() + 64);
 401     let mut substs = HashMap::new();
 402     let mut dollar_count = 0;
 403     let mut cur_name = String::new();
 404
 405     for c in input.chars() {
 406         if c == '$' {
 407             dollar_count += 1;
 408         } else if dollar_count == 0 {
 409             result.push(c);
 410         } else if !c.is_alphanumeric() && !cur_name.is_empty() {
 411             // Terminates a name following one or more dollars.
 412             let mut new_name = String::new();
 413             let mut old_name = String::new();
 414             old_name.push('$');
 415             for _ in 0..(dollar_count - 1) {
 416                 new_name.push('$');
 417                 old_name.push('$');
 418             }
 419             new_name.push('z');
 420             new_name.push_str(&cur_name);
 421             old_name.push_str(&cur_name);
 422
 423             result.push_str(&new_name);
 424             substs.insert(old_name, new_name);
 425
 426             result.push(c);
 427
 428             dollar_count = 0;
 429             cur_name = String::new();
 430         } else if c == '(' && cur_name.is_empty() {
 431             // FIXME: Support macro def with repeat.
 432             return None;
 433         } else if c.is_alphanumeric() {
 434             cur_name.push(c);
 435         }
 436     }
 437
 438     // FIXME: duplicate code
 439     if !cur_name.is_empty() {
 440         let mut new_name = String::new();
 441         let mut old_name = String::new();
 442         old_name.push('$');
 443         for _ in 0..(dollar_count - 1) {
 444             new_name.push('$');
 445             old_name.push('$');
 446         }
 447         new_name.push('z');
 448         new_name.push_str(&cur_name);
 449         old_name.push_str(&cur_name);
 450
 451         result.push_str(&new_name);
 452         substs.insert(old_name, new_name);
 453     }
 454
 455     debug!("replace_names `{}` {:?}", result, substs);
 456
 457     Some((result, substs))
 458 }
 459
 460 // This is a bit sketchy. The token rules probably need tweaking, but it works
 461 // for some common cases. I hope the basic logic is sufficient. Note that the
 462 // meaning of some tokens is a bit different here from usual Rust, e.g., `*`
 463 // and `(`/`)` have special meaning.
 464 //
 465 // We always try and format on one line.
 466 fn format_macro_args(toks: ThinTokenStream) -> Option<String> {
 467     let mut result = String::with_capacity(128);
 468     let mut insert_space = SpaceState::Never;
 469
 470     for tok in (toks.into(): TokenStream).trees() {
 471         match tok {
 472             TokenTree::Token(_, t) => {
 473                 if !result.is_empty() && force_space_before(&t) {
 474                     insert_space = SpaceState::Always;
 475                 }
 476                 if force_no_space_before(&t) {
 477                     insert_space = SpaceState::Never;
 478                 }
 479                 match (insert_space, ident_like(&t)) {
 480                     (SpaceState::Always, _)
 481                     | (SpaceState::Punctuation, false)
 482                     | (SpaceState::Ident, true) => {
 483                         result.push(' ');
 484                     }
 485                     _ => {}
 486                 }
 487                 result.push_str(&pprust::token_to_string(&t));
 488                 insert_space = next_space(&t);
 489             }
 490             TokenTree::Delimited(_, d) => {
 491                 if let SpaceState::Always = insert_space {
 492                     result.push(' ');
 493                 }
 494                 let formatted = format_macro_args(d.tts)?;
 495                 match d.delim {
 496                     DelimToken::Paren => {
 497                         result.push_str(&format!("({})", formatted));
 498                         insert_space = SpaceState::Always;
 499                     }
 500                     DelimToken::Bracket => {
 501                         result.push_str(&format!("[{}]", formatted));
 502                         insert_space = SpaceState::Always;
 503                     }
 504                     DelimToken::Brace => {
 505                         result.push_str(&format!(" {{ {} }}", formatted));
 506                         insert_space = SpaceState::Always;
 507                     }
 508                     DelimToken::NoDelim => {
 509                         result.push_str(&format!("{}", formatted));
 510                         insert_space = SpaceState::Always;
 511                     }
 512                 }
 513             }
 514         }
 515     }
 516
 517     Some(result)
 518 }
 519
 520 // We should insert a space if the next token is a:
 521 #[derive(Copy, Clone)]
 522 enum SpaceState {
 523     Never,
 524     Punctuation,
 525     Ident, // Or ident/literal-like thing.
 526     Always,
 527 }
 528
 529 fn force_space_before(tok: &Token) -> bool {
 530     match *tok {
 531         Token::Eq
 532         | Token::Lt
 533         | Token::Le
 534         | Token::EqEq
 535         | Token::Ne
 536         | Token::Ge
 537         | Token::Gt
 538         | Token::AndAnd
 539         | Token::OrOr
 540         | Token::Not
 541         | Token::Tilde
 542         | Token::BinOpEq(_)
 543         | Token::At
 544         | Token::RArrow
 545         | Token::LArrow
 546         | Token::FatArrow
 547         | Token::Pound
 548         | Token::Dollar => true,
 549         Token::BinOp(bot) => bot != BinOpToken::Star,
 550         _ => false,
 551     }
 552 }
 553
 554 fn force_no_space_before(tok: &Token) -> bool {
 555     match *tok {
 556         Token::Semi | Token::Comma | Token::Dot => true,
 557         Token::BinOp(bot) => bot == BinOpToken::Star,
 558         _ => false,
 559     }
 560 }
 561 fn ident_like(tok: &Token) -> bool {
 562     match *tok {
 563         Token::Ident(_) | Token::Literal(..) | Token::Lifetime(_) => true,
 564         _ => false,
 565     }
 566 }
 567
 568 fn next_space(tok: &Token) -> SpaceState {
 569     match *tok {
 570         Token::Not
 571         | Token::Tilde
 572         | Token::At
 573         | Token::Comma
 574         | Token::Dot
 575         | Token::DotDot
 576         | Token::DotDotDot
 577         | Token::DotDotEq
 578         | Token::DotEq
 579         | Token::Question
 580         | Token::Underscore
 581         | Token::BinOp(_) => SpaceState::Punctuation,
 582
 583         Token::ModSep
 584         | Token::Pound
 585         | Token::Dollar
 586         | Token::OpenDelim(_)
 587         | Token::CloseDelim(_)
 588         | Token::Whitespace => SpaceState::Never,
 589
 590         Token::Literal(..) | Token::Ident(_) | Token::Lifetime(_) => SpaceState::Ident,
 591
 592         _ => SpaceState::Always,
 593     }
 594 }
 595
 596 /// Tries to convert a macro use into a short hand try expression. Returns None
 597 /// when the macro is not an instance of try! (or parsing the inner expression
 598 /// failed).
 599 pub fn convert_try_mac(mac: &ast::Mac, context: &RewriteContext) -> Option<ast::Expr> {
 600     if &format!("{}", mac.node.path)[..] == "try" {
 601         let ts: TokenStream = mac.node.tts.clone().into();
 602         let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
 603
 604         Some(ast::Expr {
 605             id: ast::NodeId::new(0), // dummy value
 606             node: ast::ExprKind::Try(parser.parse_expr().ok()?),
 607             span: mac.span, // incorrect span, but shouldn't matter too much
 608             attrs: ThinVec::new(),
 609         })
 610     } else {
 611         None
 612     }
 613 }
 614
 615 fn macro_style(mac: &ast::Mac, context: &RewriteContext) -> MacroStyle {
 616     let snippet = context.snippet(mac.span);
 617     let paren_pos = snippet.find_uncommented("(").unwrap_or(usize::max_value());
 618     let bracket_pos = snippet.find_uncommented("[").unwrap_or(usize::max_value());
 619     let brace_pos = snippet.find_uncommented("{").unwrap_or(usize::max_value());
 620
 621     if paren_pos < bracket_pos && paren_pos < brace_pos {
 622         MacroStyle::Parens
 623     } else if bracket_pos < brace_pos {
 624         MacroStyle::Brackets
 625     } else {
 626         MacroStyle::Braces
 627     }
 628 }
 629
 630 /// Indent each line according to the specified `indent`.
 631 /// e.g.
 632 /// ```rust
 633 /// foo!{
 634 /// x,
 635 /// y,
 636 /// foo(
 637 ///     a,
 638 ///     b,
 639 ///     c,
 640 /// ),
 641 /// }
 642 /// ```
 643 /// will become
 644 /// ```rust
 645 /// foo!{
 646 ///     x,
 647 ///     y,
 648 ///     foo(
 649 ///         a,
 650 ///         b,
 651 ///         c,
 652 //      ),
 653 /// }
 654 /// ```
 655 fn indent_macro_snippet(
 656     context: &RewriteContext,
 657     macro_str: &str,
 658     indent: Indent,
 659 ) -> Option<String> {
 660     let mut lines = macro_str.lines();
 661     let first_line = lines.next().map(|s| s.trim_right())?;
 662     let mut trimmed_lines = Vec::with_capacity(16);
 663
 664     let min_prefix_space_width = lines
 665         .filter_map(|line| {
 666             let prefix_space_width = if is_empty_line(line) {
 667                 None
 668             } else {
 669                 Some(get_prefix_space_width(context, line))
 670             };
 671             trimmed_lines.push((line.trim(), prefix_space_width));
 672             prefix_space_width
 673         })
 674         .min()?;
 675
 676     Some(
 677         String::from(first_line) + "\n"
 678             + &trimmed_lines
 679                 .iter()
 680                 .map(|&(line, prefix_space_width)| match prefix_space_width {
 681                     Some(original_indent_width) => {
 682                         let new_indent_width = indent.width()
 683                             + original_indent_width
 684                                 .checked_sub(min_prefix_space_width)
 685                                 .unwrap_or(0);
 686                         let new_indent = Indent::from_width(context.config, new_indent_width);
 687                         format!("{}{}", new_indent.to_string(context.config), line.trim())
 688                     }
 689                     None => String::new(),
 690                 })
 691                 .collect::<Vec<_>>()
 692                 .join("\n"),
 693     )
 694 }
 695
 696 fn get_prefix_space_width(context: &RewriteContext, s: &str) -> usize {
 697     let mut width = 0;
 698     for c in s.chars() {
 699         match c {
 700             ' ' => width += 1,
 701             '\t' => width += context.config.tab_spaces(),
 702             _ => return width,
 703         }
 704     }
 705     width
 706 }
 707
 708 fn is_empty_line(s: &str) -> bool {
 709     s.is_empty() || s.chars().all(char::is_whitespace)
 710 }
 711
 712 // A very simple parser that just parses a macros 2.0 definition into its branches.
 713 // Currently we do not attempt to parse any further than that.
 714 #[derive(new)]
 715 struct MacroParser {
 716     toks: Cursor,
 717 }
 718
 719 impl MacroParser {
 720     // (`(` ... `)` `=>` `{` ... `}`)*
 721     fn parse(&mut self) -> Option<Macro> {
 722         let mut branches = vec![];
 723         while self.toks.look_ahead(1).is_some() {
 724             branches.push(self.parse_branch()?);
 725         }
 726
 727         Some(Macro { branches })
 728     }
 729
 730     // `(` ... `)` `=>` `{` ... `}`
 731     fn parse_branch(&mut self) -> Option<MacroBranch> {
 732         let (args_paren_kind, args) = match self.toks.next()? {
 733             TokenTree::Token(..) => return None,
 734             TokenTree::Delimited(_, ref d) => (d.delim, d.tts.clone()),
 735         };
 736         match self.toks.next()? {
 737             TokenTree::Token(_, Token::FatArrow) => {}
 738             _ => return None,
 739         }
 740         let body = match self.toks.next()? {
 741             TokenTree::Token(..) => return None,
 742             TokenTree::Delimited(sp, _) => {
 743                 let data = sp.data();
 744                 Span::new(data.lo + BytePos(1), data.hi - BytePos(1), data.ctxt)
 745             }
 746         };
 747         if let Some(TokenTree::Token(_, Token::Semi)) = self.toks.look_ahead(0) {
 748             self.toks.next();
 749         }
 750         Some(MacroBranch {
 751             args,
 752             args_paren_kind,
 753             body,
 754         })
 755     }
 756 }
 757
 758 // A parsed macros 2.0 macro definition.
 759 struct Macro {
 760     branches: Vec<MacroBranch>,
 761 }
 762
 763 // FIXME: it would be more efficient to use references to the token streams
 764 // rather than clone them, if we can make the borrowing work out.
 765 struct MacroBranch {
 766     args: ThinTokenStream,
 767     args_paren_kind: DelimToken,
 768     body: Span,
 769 }
 770
 771 #[cfg(test)]
 772 mod test {
 773     use super::*;
 774     use syntax::parse::{parse_stream_from_source_str, ParseSess};
 775     use syntax::codemap::{FileName, FilePathMapping};
 776
 777     fn format_macro_args_str(s: &str) -> String {
 778         let input = parse_stream_from_source_str(
 779             FileName::Custom("stdin".to_owned()),
 780             s.to_owned(),
 781             &ParseSess::new(FilePathMapping::empty()),
 782             None,
 783         );
 784         format_macro_args(input.into()).unwrap()
 785     }
 786
 787     #[test]
 788     fn test_format_macro_args() {
 789         assert_eq!(format_macro_args_str(""), "".to_owned());
 790         assert_eq!(format_macro_args_str("$ x : ident"), "$x: ident".to_owned());
 791         assert_eq!(
 792             format_macro_args_str("$ m1 : ident , $ m2 : ident , $ x : ident"),
 793             "$m1: ident, $m2: ident, $x: ident".to_owned()
 794         );
 795         assert_eq!(
 796             format_macro_args_str("$($beginning:ident),*;$middle:ident;$($end:ident),*"),
 797             "$($beginning: ident),*; $middle: ident; $($end: ident),*".to_owned()
 798         );
 799         assert_eq!(
 800             format_macro_args_str(
 801                 "$ name : ident ( $ ( $ dol : tt $ var : ident ) * ) $ ( $ body : tt ) *"
 802             ),
 803             "$name: ident($($dol: tt $var: ident)*) $($body: tt)*".to_owned()
 804         );
 805     }
 806 }