src/libsyntax/ext/expand.rs

   1 // Copyright 2012-2014 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 use ast::{Block, Crate, DeclLocal, ExprMac, PatMac};
  12 use ast::{Local, Ident, Mac_, Name};
  13 use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtDecl, StmtMac};
  14 use ast::{StmtExpr, StmtSemi};
  15 use ast::TokenTree;
  16 use ast;
  17 use ext::mtwt;
  18 use ext::build::AstBuilder;
  19 use attr;
  20 use attr::{AttrMetaMethods, WithAttrs};
  21 use codemap;
  22 use codemap::{Span, Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute};
  23 use ext::base::*;
  24 use feature_gate::{self, Features, GatedCfgAttr};
  25 use fold;
  26 use fold::*;
  27 use util::move_map::MoveMap;
  28 use parse;
  29 use parse::token::{fresh_mark, fresh_name, intern};
  30 use ptr::P;
  31 use util::small_vector::SmallVector;
  32 use visit;
  33 use visit::Visitor;
  34 use std_inject;
  35
  36 use std::collections::HashSet;
  37
  38
  39 pub fn expand_expr(e: P<ast::Expr>, fld: &mut MacroExpander) -> P<ast::Expr> {
  40     let expr_span = e.span;
  41     return e.and_then(|ast::Expr {id, node, span, attrs}| match node {
  42
  43         // expr_mac should really be expr_ext or something; it's the
  44         // entry-point for all syntax extensions.
  45         ast::ExprMac(mac) => {
  46
  47             // Assert that we drop any macro attributes on the floor here
  48             drop(attrs);
  49
  50             let expanded_expr = match expand_mac_invoc(mac, span,
  51                                                        |r| r.make_expr(),
  52                                                        mark_expr, fld) {
  53                 Some(expr) => expr,
  54                 None => {
  55                     return DummyResult::raw_expr(span);
  56                 }
  57             };
  58
  59             // Keep going, outside-in.
  60             let fully_expanded = fld.fold_expr(expanded_expr);
  61             let span = fld.new_span(span);
  62             fld.cx.bt_pop();
  63
  64             fully_expanded.map(|e| ast::Expr {
  65                 id: ast::DUMMY_NODE_ID,
  66                 node: e.node,
  67                 span: span,
  68                 attrs: e.attrs,
  69             })
  70         }
  71
  72         ast::ExprInPlace(placer, value_expr) => {
  73             // Ensure feature-gate is enabled
  74             feature_gate::check_for_placement_in(
  75                 fld.cx.ecfg.features,
  76                 &fld.cx.parse_sess.span_diagnostic,
  77                 expr_span);
  78
  79             let placer = fld.fold_expr(placer);
  80             let value_expr = fld.fold_expr(value_expr);
  81             fld.cx.expr(span, ast::ExprInPlace(placer, value_expr))
  82                 .with_attrs(fold_thin_attrs(attrs, fld))
  83         }
  84
  85         ast::ExprWhile(cond, body, opt_ident) => {
  86             let cond = fld.fold_expr(cond);
  87             let (body, opt_ident) = expand_loop_block(body, opt_ident, fld);
  88             fld.cx.expr(span, ast::ExprWhile(cond, body, opt_ident))
  89                 .with_attrs(fold_thin_attrs(attrs, fld))
  90         }
  91
  92         ast::ExprWhileLet(pat, expr, body, opt_ident) => {
  93             let pat = fld.fold_pat(pat);
  94             let expr = fld.fold_expr(expr);
  95
  96             // Hygienic renaming of the body.
  97             let ((body, opt_ident), mut rewritten_pats) =
  98                 rename_in_scope(vec![pat],
  99                                 fld,
 100                                 (body, opt_ident),
 101                                 |rename_fld, fld, (body, opt_ident)| {
 102                 expand_loop_block(rename_fld.fold_block(body), opt_ident, fld)
 103             });
 104             assert!(rewritten_pats.len() == 1);
 105
 106             fld.cx.expr(span, ast::ExprWhileLet(rewritten_pats.remove(0), expr, body, opt_ident))
 107                 .with_attrs(fold_thin_attrs(attrs, fld))
 108         }
 109
 110         ast::ExprLoop(loop_block, opt_ident) => {
 111             let (loop_block, opt_ident) = expand_loop_block(loop_block, opt_ident, fld);
 112             fld.cx.expr(span, ast::ExprLoop(loop_block, opt_ident))
 113                 .with_attrs(fold_thin_attrs(attrs, fld))
 114         }
 115
 116         ast::ExprForLoop(pat, head, body, opt_ident) => {
 117             let pat = fld.fold_pat(pat);
 118
 119             // Hygienic renaming of the for loop body (for loop binds its pattern).
 120             let ((body, opt_ident), mut rewritten_pats) =
 121                 rename_in_scope(vec![pat],
 122                                 fld,
 123                                 (body, opt_ident),
 124                                 |rename_fld, fld, (body, opt_ident)| {
 125                 expand_loop_block(rename_fld.fold_block(body), opt_ident, fld)
 126             });
 127             assert!(rewritten_pats.len() == 1);
 128
 129             let head = fld.fold_expr(head);
 130             fld.cx.expr(span, ast::ExprForLoop(rewritten_pats.remove(0), head, body, opt_ident))
 131                 .with_attrs(fold_thin_attrs(attrs, fld))
 132         }
 133
 134         ast::ExprIfLet(pat, sub_expr, body, else_opt) => {
 135             let pat = fld.fold_pat(pat);
 136
 137             // Hygienic renaming of the body.
 138             let (body, mut rewritten_pats) =
 139                 rename_in_scope(vec![pat],
 140                                 fld,
 141                                 body,
 142                                 |rename_fld, fld, body| {
 143                 fld.fold_block(rename_fld.fold_block(body))
 144             });
 145             assert!(rewritten_pats.len() == 1);
 146
 147             let else_opt = else_opt.map(|else_opt| fld.fold_expr(else_opt));
 148             let sub_expr = fld.fold_expr(sub_expr);
 149             fld.cx.expr(span, ast::ExprIfLet(rewritten_pats.remove(0), sub_expr, body, else_opt))
 150                 .with_attrs(fold_thin_attrs(attrs, fld))
 151         }
 152
 153         ast::ExprClosure(capture_clause, fn_decl, block) => {
 154             let (rewritten_fn_decl, rewritten_block)
 155                 = expand_and_rename_fn_decl_and_block(fn_decl, block, fld);
 156             let new_node = ast::ExprClosure(capture_clause,
 157                                             rewritten_fn_decl,
 158                                             rewritten_block);
 159             P(ast::Expr{id:id, node: new_node, span: fld.new_span(span),
 160                         attrs: fold_thin_attrs(attrs, fld)})
 161         }
 162
 163         _ => {
 164             P(noop_fold_expr(ast::Expr {
 165                 id: id,
 166                 node: node,
 167                 span: span,
 168                 attrs: attrs
 169             }, fld))
 170         }
 171     });
 172 }
 173
 174 /// Expand a (not-ident-style) macro invocation. Returns the result
 175 /// of expansion and the mark which must be applied to the result.
 176 /// Our current interface doesn't allow us to apply the mark to the
 177 /// result until after calling make_expr, make_items, etc.
 178 fn expand_mac_invoc<T, F, G>(mac: ast::Mac,
 179                              span: codemap::Span,
 180                              parse_thunk: F,
 181                              mark_thunk: G,
 182                              fld: &mut MacroExpander)
 183                              -> Option<T> where
 184     F: for<'a> FnOnce(Box<MacResult+'a>) -> Option<T>,
 185     G: FnOnce(T, Mrk) -> T,
 186 {
 187     // it would almost certainly be cleaner to pass the whole
 188     // macro invocation in, rather than pulling it apart and
 189     // marking the tts and the ctxt separately. This also goes
 190     // for the other three macro invocation chunks of code
 191     // in this file.
 192
 193     let Mac_ { path: pth, tts, .. } = mac.node;
 194     if pth.segments.len() > 1 {
 195         fld.cx.span_err(pth.span,
 196                         "expected macro name without module \
 197                         separators");
 198         // let compilation continue
 199         return None;
 200     }
 201     let extname = pth.segments[0].identifier.name;
 202     match fld.cx.syntax_env.find(extname) {
 203         None => {
 204             fld.cx.span_err(
 205                 pth.span,
 206                 &format!("macro undefined: '{}!'",
 207                         &extname));
 208
 209             // let compilation continue
 210             None
 211         }
 212         Some(rc) => match *rc {
 213             NormalTT(ref expandfun, exp_span, allow_internal_unstable) => {
 214                 fld.cx.bt_push(ExpnInfo {
 215                         call_site: span,
 216                         callee: NameAndSpan {
 217                             format: MacroBang(extname),
 218                             span: exp_span,
 219                             allow_internal_unstable: allow_internal_unstable,
 220                         },
 221                     });
 222                 let fm = fresh_mark();
 223                 let marked_before = mark_tts(&tts[..], fm);
 224
 225                 // The span that we pass to the expanders we want to
 226                 // be the root of the call stack. That's the most
 227                 // relevant span and it's the actual invocation of
 228                 // the macro.
 229                 let mac_span = fld.cx.original_span();
 230
 231                 let opt_parsed = {
 232                     let expanded = expandfun.expand(fld.cx,
 233                                                     mac_span,
 234                                                     &marked_before[..]);
 235                     parse_thunk(expanded)
 236                 };
 237                 let parsed = match opt_parsed {
 238                     Some(e) => e,
 239                     None => {
 240                         fld.cx.span_err(
 241                             pth.span,
 242                             &format!("non-expression macro in expression position: {}",
 243                                     extname
 244                                     ));
 245                         return None;
 246                     }
 247                 };
 248                 Some(mark_thunk(parsed,fm))
 249             }
 250             _ => {
 251                 fld.cx.span_err(
 252                     pth.span,
 253                     &format!("'{}' is not a tt-style macro",
 254                             extname));
 255                 None
 256             }
 257         }
 258     }
 259 }
 260
 261 /// Rename loop label and expand its loop body
 262 ///
 263 /// The renaming procedure for loop is different in the sense that the loop
 264 /// body is in a block enclosed by loop head so the renaming of loop label
 265 /// must be propagated to the enclosed context.
 266 fn expand_loop_block(loop_block: P<Block>,
 267                      opt_ident: Option<Ident>,
 268                      fld: &mut MacroExpander) -> (P<Block>, Option<Ident>) {
 269     match opt_ident {
 270         Some(label) => {
 271             let new_label = fresh_name(label);
 272             let rename = (label, new_label);
 273
 274             // The rename *must not* be added to the pending list of current
 275             // syntax context otherwise an unrelated `break` or `continue` in
 276             // the same context will pick that up in the deferred renaming pass
 277             // and be renamed incorrectly.
 278             let mut rename_list = vec!(rename);
 279             let mut rename_fld = IdentRenamer{renames: &mut rename_list};
 280             let renamed_ident = rename_fld.fold_ident(label);
 281
 282             // The rename *must* be added to the enclosed syntax context for
 283             // `break` or `continue` to pick up because by definition they are
 284             // in a block enclosed by loop head.
 285             fld.cx.syntax_env.push_frame();
 286             fld.cx.syntax_env.info().pending_renames.push(rename);
 287             let expanded_block = expand_block_elts(loop_block, fld);
 288             fld.cx.syntax_env.pop_frame();
 289
 290             (expanded_block, Some(renamed_ident))
 291         }
 292         None => (fld.fold_block(loop_block), opt_ident)
 293     }
 294 }
 295
 296 // eval $e with a new exts frame.
 297 // must be a macro so that $e isn't evaluated too early.
 298 macro_rules! with_exts_frame {
 299     ($extsboxexpr:expr,$macros_escape:expr,$e:expr) =>
 300     ({$extsboxexpr.push_frame();
 301       $extsboxexpr.info().macros_escape = $macros_escape;
 302       let result = $e;
 303       $extsboxexpr.pop_frame();
 304       result
 305      })
 306 }
 307
 308 // When we enter a module, record it, for the sake of `module!`
 309 pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
 310                    -> SmallVector<P<ast::Item>> {
 311     let it = expand_item_multi_modifier(Annotatable::Item(it), fld);
 312
 313     expand_annotatable(it, fld)
 314         .into_iter().map(|i| i.expect_item()).collect()
 315 }
 316
 317 /// Expand item_underscore
 318 fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
 319     match item {
 320         ast::ItemFn(decl, unsafety, constness, abi, generics, body) => {
 321             let (rewritten_fn_decl, rewritten_body)
 322                 = expand_and_rename_fn_decl_and_block(decl, body, fld);
 323             let expanded_generics = fold::noop_fold_generics(generics,fld);
 324             ast::ItemFn(rewritten_fn_decl, unsafety, constness, abi,
 325                         expanded_generics, rewritten_body)
 326         }
 327         _ => noop_fold_item_underscore(item, fld)
 328     }
 329 }
 330
 331 // does this attribute list contain "macro_use" ?
 332 fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool {
 333     for attr in attrs {
 334         let mut is_use = attr.check_name("macro_use");
 335         if attr.check_name("macro_escape") {
 336             fld.cx.span_warn(attr.span, "macro_escape is a deprecated synonym for macro_use");
 337             is_use = true;
 338             if let ast::AttrStyle::Inner = attr.node.style {
 339                 fld.cx.fileline_help(attr.span, "consider an outer attribute, \
 340                                              #[macro_use] mod ...");
 341             }
 342         };
 343
 344         if is_use {
 345             match attr.node.value.node {
 346                 ast::MetaWord(..) => (),
 347                 _ => fld.cx.span_err(attr.span, "arguments to macro_use are not allowed here"),
 348             }
 349             return true;
 350         }
 351     }
 352     false
 353 }
 354
 355 // Support for item-position macro invocations, exactly the same
 356 // logic as for expression-position macro invocations.
 357 pub fn expand_item_mac(it: P<ast::Item>,
 358                        fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
 359     let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| match it.node {
 360         ItemMac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
 361             (path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
 362         _ => fld.cx.span_bug(it.span, "invalid item macro invocation")
 363     });
 364
 365     let fm = fresh_mark();
 366     let items = {
 367         let expanded = match fld.cx.syntax_env.find(extname) {
 368             None => {
 369                 fld.cx.span_err(path_span,
 370                                 &format!("macro undefined: '{}!'",
 371                                         extname));
 372                 // let compilation continue
 373                 return SmallVector::zero();
 374             }
 375
 376             Some(rc) => match *rc {
 377                 NormalTT(ref expander, tt_span, allow_internal_unstable) => {
 378                     if ident.name != parse::token::special_idents::invalid.name {
 379                         fld.cx
 380                             .span_err(path_span,
 381                                       &format!("macro {}! expects no ident argument, given '{}'",
 382                                                extname,
 383                                                ident));
 384                         return SmallVector::zero();
 385                     }
 386                     fld.cx.bt_push(ExpnInfo {
 387                         call_site: span,
 388                         callee: NameAndSpan {
 389                             format: MacroBang(extname),
 390                             span: tt_span,
 391                             allow_internal_unstable: allow_internal_unstable,
 392                         }
 393                     });
 394                     // mark before expansion:
 395                     let marked_before = mark_tts(&tts[..], fm);
 396                     expander.expand(fld.cx, span, &marked_before[..])
 397                 }
 398                 IdentTT(ref expander, tt_span, allow_internal_unstable) => {
 399                     if ident.name == parse::token::special_idents::invalid.name {
 400                         fld.cx.span_err(path_span,
 401                                         &format!("macro {}! expects an ident argument",
 402                                                 extname));
 403                         return SmallVector::zero();
 404                     }
 405                     fld.cx.bt_push(ExpnInfo {
 406                         call_site: span,
 407                         callee: NameAndSpan {
 408                             format: MacroBang(extname),
 409                             span: tt_span,
 410                             allow_internal_unstable: allow_internal_unstable,
 411                         }
 412                     });
 413                     // mark before expansion:
 414                     let marked_tts = mark_tts(&tts[..], fm);
 415                     expander.expand(fld.cx, span, ident, marked_tts)
 416                 }
 417                 MacroRulesTT => {
 418                     if ident.name == parse::token::special_idents::invalid.name {
 419                         fld.cx.span_err(path_span, "macro_rules! expects an ident argument");
 420                         return SmallVector::zero();
 421                     }
 422
 423                     fld.cx.bt_push(ExpnInfo {
 424                         call_site: span,
 425                         callee: NameAndSpan {
 426                             format: MacroBang(extname),
 427                             span: None,
 428                             // `macro_rules!` doesn't directly allow
 429                             // unstable (this is orthogonal to whether
 430                             // the macro it creates allows it)
 431                             allow_internal_unstable: false,
 432                         }
 433                     });
 434                     // DON'T mark before expansion.
 435
 436                     let allow_internal_unstable = attr::contains_name(&attrs,
 437                                                                       "allow_internal_unstable");
 438
 439                     // ensure any #[allow_internal_unstable]s are
 440                     // detected (including nested macro definitions
 441                     // etc.)
 442                     if allow_internal_unstable && !fld.cx.ecfg.enable_allow_internal_unstable() {
 443                         feature_gate::emit_feature_err(
 444                             &fld.cx.parse_sess.span_diagnostic,
 445                             "allow_internal_unstable",
 446                             span,
 447                             feature_gate::GateIssue::Language,
 448                             feature_gate::EXPLAIN_ALLOW_INTERNAL_UNSTABLE)
 449                     }
 450
 451                     let export = attr::contains_name(&attrs, "macro_export");
 452                     let def = ast::MacroDef {
 453                         ident: ident,
 454                         attrs: attrs,
 455                         id: ast::DUMMY_NODE_ID,
 456                         span: span,
 457                         imported_from: None,
 458                         export: export,
 459                         use_locally: true,
 460                         allow_internal_unstable: allow_internal_unstable,
 461                         body: tts,
 462                     };
 463                     fld.cx.insert_macro(def);
 464
 465                     // macro_rules! has a side effect but expands to nothing.
 466                     fld.cx.bt_pop();
 467                     return SmallVector::zero();
 468                 }
 469                 _ => {
 470                     fld.cx.span_err(span,
 471                                     &format!("{}! is not legal in item position",
 472                                             extname));
 473                     return SmallVector::zero();
 474                 }
 475             }
 476         };
 477
 478         expanded.make_items()
 479     };
 480
 481     let items = match items {
 482         Some(items) => {
 483             items.into_iter()
 484                 .map(|i| mark_item(i, fm))
 485                 .flat_map(|i| fld.fold_item(i).into_iter())
 486                 .collect()
 487         }
 488         None => {
 489             fld.cx.span_err(path_span,
 490                             &format!("non-item macro in item position: {}",
 491                                     extname));
 492             return SmallVector::zero();
 493         }
 494     };
 495
 496     fld.cx.bt_pop();
 497     items
 498 }
 499
 500 /// Expand a stmt
 501 fn expand_stmt(stmt: P<Stmt>, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
 502     let stmt = stmt.and_then(|stmt| stmt);
 503     let (mac, style, attrs) = match stmt.node {
 504         StmtMac(mac, style, attrs) => (mac, style, attrs),
 505         _ => return expand_non_macro_stmt(stmt, fld)
 506     };
 507
 508     // Assert that we drop any macro attributes on the floor here
 509     drop(attrs);
 510
 511     let maybe_new_items =
 512         expand_mac_invoc(mac.and_then(|m| m), stmt.span,
 513                          |r| r.make_stmts(),
 514                          |stmts, mark| stmts.move_map(|m| mark_stmt(m, mark)),
 515                          fld);
 516
 517     let mut fully_expanded = match maybe_new_items {
 518         Some(stmts) => {
 519             // Keep going, outside-in.
 520             let new_items = stmts.into_iter().flat_map(|s| {
 521                 fld.fold_stmt(s).into_iter()
 522             }).collect();
 523             fld.cx.bt_pop();
 524             new_items
 525         }
 526         None => SmallVector::zero()
 527     };
 528
 529     // If this is a macro invocation with a semicolon, then apply that
 530     // semicolon to the final statement produced by expansion.
 531     if style == MacStmtWithSemicolon {
 532         if let Some(stmt) = fully_expanded.pop() {
 533             let new_stmt = stmt.map(|Spanned {node, span}| {
 534                 Spanned {
 535                     node: match node {
 536                         StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
 537                         _ => node /* might already have a semi */
 538                     },
 539                     span: span
 540                 }
 541             });
 542             fully_expanded.push(new_stmt);
 543         }
 544     }
 545
 546     fully_expanded
 547 }
 548
 549 // expand a non-macro stmt. this is essentially the fallthrough for
 550 // expand_stmt, above.
 551 fn expand_non_macro_stmt(Spanned {node, span: stmt_span}: Stmt, fld: &mut MacroExpander)
 552                          -> SmallVector<P<Stmt>> {
 553     // is it a let?
 554     match node {
 555         StmtDecl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
 556             DeclLocal(local) => {
 557                 // take it apart:
 558                 let rewritten_local = local.map(|Local {id, pat, ty, init, span, attrs}| {
 559                     // expand the ty since TyFixedLengthVec contains an Expr
 560                     // and thus may have a macro use
 561                     let expanded_ty = ty.map(|t| fld.fold_ty(t));
 562                     // expand the pat (it might contain macro uses):
 563                     let expanded_pat = fld.fold_pat(pat);
 564                     // find the PatIdents in the pattern:
 565                     // oh dear heaven... this is going to include the enum
 566                     // names, as well... but that should be okay, as long as
 567                     // the new names are gensyms for the old ones.
 568                     // generate fresh names, push them to a new pending list
 569                     let idents = pattern_bindings(&expanded_pat);
 570                     let mut new_pending_renames =
 571                         idents.iter().map(|ident| (*ident, fresh_name(*ident))).collect();
 572                     // rewrite the pattern using the new names (the old
 573                     // ones have already been applied):
 574                     let rewritten_pat = {
 575                         // nested binding to allow borrow to expire:
 576                         let mut rename_fld = IdentRenamer{renames: &mut new_pending_renames};
 577                         rename_fld.fold_pat(expanded_pat)
 578                     };
 579                     // add them to the existing pending renames:
 580                     fld.cx.syntax_env.info().pending_renames
 581                           .extend(new_pending_renames);
 582                     Local {
 583                         id: id,
 584                         ty: expanded_ty,
 585                         pat: rewritten_pat,
 586                         // also, don't forget to expand the init:
 587                         init: init.map(|e| fld.fold_expr(e)),
 588                         span: span,
 589                         attrs: fold::fold_thin_attrs(attrs, fld),
 590                     }
 591                 });
 592                 SmallVector::one(P(Spanned {
 593                     node: StmtDecl(P(Spanned {
 594                             node: DeclLocal(rewritten_local),
 595                             span: span
 596                         }),
 597                         node_id),
 598                     span: stmt_span
 599                 }))
 600             }
 601             _ => {
 602                 noop_fold_stmt(Spanned {
 603                     node: StmtDecl(P(Spanned {
 604                             node: decl,
 605                             span: span
 606                         }),
 607                         node_id),
 608                     span: stmt_span
 609                 }, fld)
 610             }
 611         }),
 612         _ => {
 613             noop_fold_stmt(Spanned {
 614                 node: node,
 615                 span: stmt_span
 616             }, fld)
 617         }
 618     }
 619 }
 620
 621 // expand the arm of a 'match', renaming for macro hygiene
 622 fn expand_arm(arm: ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
 623     // expand pats... they might contain macro uses:
 624     let expanded_pats = arm.pats.move_map(|pat| fld.fold_pat(pat));
 625     if expanded_pats.is_empty() {
 626         panic!("encountered match arm with 0 patterns");
 627     }
 628
 629     // apply renaming and then expansion to the guard and the body:
 630     let ((rewritten_guard, rewritten_body), rewritten_pats) =
 631         rename_in_scope(expanded_pats,
 632                         fld,
 633                         (arm.guard, arm.body),
 634                         |rename_fld, fld, (ag, ab)|{
 635         let rewritten_guard = ag.map(|g| fld.fold_expr(rename_fld.fold_expr(g)));
 636         let rewritten_body = fld.fold_expr(rename_fld.fold_expr(ab));
 637         (rewritten_guard, rewritten_body)
 638     });
 639
 640     ast::Arm {
 641         attrs: fold::fold_attrs(arm.attrs, fld),
 642         pats: rewritten_pats,
 643         guard: rewritten_guard,
 644         body: rewritten_body,
 645     }
 646 }
 647
 648 fn rename_in_scope<X, F>(pats: Vec<P<ast::Pat>>,
 649                          fld: &mut MacroExpander,
 650                          x: X,
 651                          f: F)
 652                          -> (X, Vec<P<ast::Pat>>)
 653     where F: Fn(&mut IdentRenamer, &mut MacroExpander, X) -> X
 654 {
 655     // all of the pats must have the same set of bindings, so use the
 656     // first one to extract them and generate new names:
 657     let idents = pattern_bindings(&pats[0]);
 658     let new_renames = idents.into_iter().map(|id| (id, fresh_name(id))).collect();
 659     // apply the renaming, but only to the PatIdents:
 660     let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
 661     let rewritten_pats = pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
 662
 663     let mut rename_fld = IdentRenamer{ renames:&new_renames };
 664     (f(&mut rename_fld, fld, x), rewritten_pats)
 665 }
 666
 667 /// A visitor that extracts the PatIdent (binding) paths
 668 /// from a given thingy and puts them in a mutable
 669 /// array
 670 #[derive(Clone)]
 671 struct PatIdentFinder {
 672     ident_accumulator: Vec<ast::Ident>
 673 }
 674
 675 impl<'v> Visitor<'v> for PatIdentFinder {
 676     fn visit_pat(&mut self, pattern: &ast::Pat) {
 677         match *pattern {
 678             ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
 679                 self.ident_accumulator.push(path1.node);
 680                 // visit optional subpattern of PatIdent:
 681                 if let Some(ref subpat) = *inner {
 682                     self.visit_pat(subpat)
 683                 }
 684             }
 685             // use the default traversal for non-PatIdents
 686             _ => visit::walk_pat(self, pattern)
 687         }
 688     }
 689 }
 690
 691 /// find the PatIdent paths in a pattern
 692 fn pattern_bindings(pat: &ast::Pat) -> Vec<ast::Ident> {
 693     let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
 694     name_finder.visit_pat(pat);
 695     name_finder.ident_accumulator
 696 }
 697
 698 /// find the PatIdent paths in a
 699 fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec<ast::Ident> {
 700     let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()};
 701     for arg in &fn_decl.inputs {
 702         pat_idents.visit_pat(&arg.pat);
 703     }
 704     pat_idents.ident_accumulator
 705 }
 706
 707 // expand a block. pushes a new exts_frame, then calls expand_block_elts
 708 pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
 709     // see note below about treatment of exts table
 710     with_exts_frame!(fld.cx.syntax_env,false,
 711                      expand_block_elts(blk, fld))
 712 }
 713
 714 // expand the elements of a block.
 715 pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
 716     b.map(|Block {id, stmts, expr, rules, span}| {
 717         let new_stmts = stmts.into_iter().flat_map(|x| {
 718             // perform all pending renames
 719             let renamed_stmt = {
 720                 let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
 721                 let mut rename_fld = IdentRenamer{renames:pending_renames};
 722                 rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
 723             };
 724             // expand macros in the statement
 725             fld.fold_stmt(renamed_stmt).into_iter()
 726         }).collect();
 727         let new_expr = expr.map(|x| {
 728             let expr = {
 729                 let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
 730                 let mut rename_fld = IdentRenamer{renames:pending_renames};
 731                 rename_fld.fold_expr(x)
 732             };
 733             fld.fold_expr(expr)
 734         });
 735         Block {
 736             id: fld.new_id(id),
 737             stmts: new_stmts,
 738             expr: new_expr,
 739             rules: rules,
 740             span: span
 741         }
 742     })
 743 }
 744
 745 fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
 746     match p.node {
 747         PatMac(_) => {}
 748         _ => return noop_fold_pat(p, fld)
 749     }
 750     p.map(|ast::Pat {node, span, ..}| {
 751         let (pth, tts) = match node {
 752             PatMac(mac) => (mac.node.path, mac.node.tts),
 753             _ => unreachable!()
 754         };
 755         if pth.segments.len() > 1 {
 756             fld.cx.span_err(pth.span, "expected macro name without module separators");
 757             return DummyResult::raw_pat(span);
 758         }
 759         let extname = pth.segments[0].identifier.name;
 760         let marked_after = match fld.cx.syntax_env.find(extname) {
 761             None => {
 762                 fld.cx.span_err(pth.span,
 763                                 &format!("macro undefined: '{}!'",
 764                                         extname));
 765                 // let compilation continue
 766                 return DummyResult::raw_pat(span);
 767             }
 768
 769             Some(rc) => match *rc {
 770                 NormalTT(ref expander, tt_span, allow_internal_unstable) => {
 771                     fld.cx.bt_push(ExpnInfo {
 772                         call_site: span,
 773                         callee: NameAndSpan {
 774                             format: MacroBang(extname),
 775                             span: tt_span,
 776                             allow_internal_unstable: allow_internal_unstable,
 777                         }
 778                     });
 779
 780                     let fm = fresh_mark();
 781                     let marked_before = mark_tts(&tts[..], fm);
 782                     let mac_span = fld.cx.original_span();
 783                     let pat = expander.expand(fld.cx,
 784                                               mac_span,
 785                                               &marked_before[..]).make_pat();
 786                     let expanded = match pat {
 787                         Some(e) => e,
 788                         None => {
 789                             fld.cx.span_err(
 790                                 pth.span,
 791                                 &format!(
 792                                     "non-pattern macro in pattern position: {}",
 793                                     extname
 794                                     )
 795                             );
 796                             return DummyResult::raw_pat(span);
 797                         }
 798                     };
 799
 800                     // mark after:
 801                     mark_pat(expanded,fm)
 802                 }
 803                 _ => {
 804                     fld.cx.span_err(span,
 805                                     &format!("{}! is not legal in pattern position",
 806                                             extname));
 807                     return DummyResult::raw_pat(span);
 808                 }
 809             }
 810         };
 811
 812         let fully_expanded =
 813             fld.fold_pat(marked_after).node.clone();
 814         fld.cx.bt_pop();
 815
 816         ast::Pat {
 817             id: ast::DUMMY_NODE_ID,
 818             node: fully_expanded,
 819             span: span
 820         }
 821     })
 822 }
 823
 824 /// A tree-folder that applies every rename in its (mutable) list
 825 /// to every identifier, including both bindings and varrefs
 826 /// (and lots of things that will turn out to be neither)
 827 pub struct IdentRenamer<'a> {
 828     renames: &'a mtwt::RenameList,
 829 }
 830
 831 impl<'a> Folder for IdentRenamer<'a> {
 832     fn fold_ident(&mut self, id: Ident) -> Ident {
 833         Ident::new(id.name, mtwt::apply_renames(self.renames, id.ctxt))
 834     }
 835     fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
 836         fold::noop_fold_mac(mac, self)
 837     }
 838 }
 839
 840 /// A tree-folder that applies every rename in its list to
 841 /// the idents that are in PatIdent patterns. This is more narrowly
 842 /// focused than IdentRenamer, and is needed for FnDecl,
 843 /// where we want to rename the args but not the fn name or the generics etc.
 844 pub struct PatIdentRenamer<'a> {
 845     renames: &'a mtwt::RenameList,
 846 }
 847
 848 impl<'a> Folder for PatIdentRenamer<'a> {
 849     fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
 850         match pat.node {
 851             ast::PatIdent(..) => {},
 852             _ => return noop_fold_pat(pat, self)
 853         }
 854
 855         pat.map(|ast::Pat {id, node, span}| match node {
 856             ast::PatIdent(binding_mode, Spanned{span: sp, node: ident}, sub) => {
 857                 let new_ident = Ident::new(ident.name,
 858                                            mtwt::apply_renames(self.renames, ident.ctxt));
 859                 let new_node =
 860                     ast::PatIdent(binding_mode,
 861                                   Spanned{span: self.new_span(sp), node: new_ident},
 862                                   sub.map(|p| self.fold_pat(p)));
 863                 ast::Pat {
 864                     id: id,
 865                     node: new_node,
 866                     span: self.new_span(span)
 867                 }
 868             },
 869             _ => unreachable!()
 870         })
 871     }
 872     fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
 873         fold::noop_fold_mac(mac, self)
 874     }
 875 }
 876
 877 fn expand_annotatable(a: Annotatable,
 878                       fld: &mut MacroExpander)
 879                       -> SmallVector<Annotatable> {
 880     let a = expand_item_multi_modifier(a, fld);
 881
 882     let mut decorator_items = SmallVector::zero();
 883     let mut new_attrs = Vec::new();
 884     expand_decorators(a.clone(), fld, &mut decorator_items, &mut new_attrs);
 885
 886     let mut new_items: SmallVector<Annotatable> = match a {
 887         Annotatable::Item(it) => match it.node {
 888             ast::ItemMac(..) => {
 889                 expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
 890             }
 891             ast::ItemMod(_) | ast::ItemForeignMod(_) => {
 892                 let valid_ident =
 893                     it.ident.name != parse::token::special_idents::invalid.name;
 894
 895                 if valid_ident {
 896                     fld.cx.mod_push(it.ident);
 897                 }
 898                 let macro_use = contains_macro_use(fld, &new_attrs[..]);
 899                 let result = with_exts_frame!(fld.cx.syntax_env,
 900                                               macro_use,
 901                                               noop_fold_item(it, fld));
 902                 if valid_ident {
 903                     fld.cx.mod_pop();
 904                 }
 905                 result.into_iter().map(|i| Annotatable::Item(i)).collect()
 906             },
 907             _ => {
 908                 let it = P(ast::Item {
 909                     attrs: new_attrs,
 910                     ..(*it).clone()
 911                 });
 912                 noop_fold_item(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
 913             }
 914         },
 915
 916         Annotatable::TraitItem(it) => match it.node {
 917             ast::MethodTraitItem(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem {
 918                 id: ti.id,
 919                 ident: ti.ident,
 920                 attrs: ti.attrs,
 921                 node: match ti.node  {
 922                     ast::MethodTraitItem(sig, Some(body)) => {
 923                         let (sig, body) = expand_and_rename_method(sig, body, fld);
 924                         ast::MethodTraitItem(sig, Some(body))
 925                     }
 926                     _ => unreachable!()
 927                 },
 928                 span: fld.new_span(ti.span)
 929             })),
 930             _ => fold::noop_fold_trait_item(it, fld)
 931         }.into_iter().map(Annotatable::TraitItem).collect(),
 932
 933         Annotatable::ImplItem(ii) => {
 934             expand_impl_item(ii, fld).into_iter().map(Annotatable::ImplItem).collect()
 935         }
 936     };
 937
 938     new_items.push_all(decorator_items);
 939     new_items
 940 }
 941
 942 // Partition a set of attributes into one kind of attribute, and other kinds.
 943 macro_rules! partition {
 944     ($fn_name: ident, $variant: ident) => {
 945         #[allow(deprecated)] // The `allow` is needed because the `Modifier` variant might be used.
 946         fn $fn_name(attrs: &[ast::Attribute],
 947                     fld: &MacroExpander)
 948                      -> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
 949             attrs.iter().cloned().partition(|attr| {
 950                 match fld.cx.syntax_env.find(intern(&attr.name())) {
 951                     Some(rc) => match *rc {
 952                         $variant(..) => true,
 953                         _ => false
 954                     },
 955                     _ => false
 956                 }
 957             })
 958         }
 959     }
 960 }
 961
 962 partition!(multi_modifiers, MultiModifier);
 963
 964
 965 fn expand_decorators(a: Annotatable,
 966                      fld: &mut MacroExpander,
 967                      decorator_items: &mut SmallVector<Annotatable>,
 968                      new_attrs: &mut Vec<ast::Attribute>)
 969 {
 970     for attr in a.attrs() {
 971         let mname = intern(&attr.name());
 972         match fld.cx.syntax_env.find(mname) {
 973             Some(rc) => match *rc {
 974                 MultiDecorator(ref dec) => {
 975                     attr::mark_used(&attr);
 976
 977                     fld.cx.bt_push(ExpnInfo {
 978                         call_site: attr.span,
 979                         callee: NameAndSpan {
 980                             format: MacroAttribute(mname),
 981                             span: Some(attr.span),
 982                             // attributes can do whatever they like,
 983                             // for now.
 984                             allow_internal_unstable: true,
 985                         }
 986                     });
 987
 988                     // we'd ideally decorator_items.push_all(expand_annotatable(ann, fld)),
 989                     // but that double-mut-borrows fld
 990                     let mut items: SmallVector<Annotatable> = SmallVector::zero();
 991                     dec.expand(fld.cx,
 992                                attr.span,
 993                                &attr.node.value,
 994                                &a,
 995                                &mut |ann| items.push(ann));
 996                     decorator_items.extend(items.into_iter()
 997                         .flat_map(|ann| expand_annotatable(ann, fld).into_iter()));
 998
 999                     fld.cx.bt_pop();
1000                 }
1001                 _ => new_attrs.push((*attr).clone()),
1002             },
1003             _ => new_attrs.push((*attr).clone()),
1004         }
1005     }
1006 }
1007
1008 fn expand_item_multi_modifier(mut it: Annotatable,
1009                               fld: &mut MacroExpander)
1010                               -> Annotatable {
1011     let (modifiers, other_attrs) = multi_modifiers(it.attrs(), fld);
1012
1013     // Update the attrs, leave everything else alone. Is this mutation really a good idea?
1014     it = it.fold_attrs(other_attrs);
1015
1016     if modifiers.is_empty() {
1017         return it
1018     }
1019
1020     for attr in &modifiers {
1021         let mname = intern(&attr.name());
1022
1023         match fld.cx.syntax_env.find(mname) {
1024             Some(rc) => match *rc {
1025                 MultiModifier(ref mac) => {
1026                     attr::mark_used(attr);
1027                     fld.cx.bt_push(ExpnInfo {
1028                         call_site: attr.span,
1029                         callee: NameAndSpan {
1030                             format: MacroAttribute(mname),
1031                             span: Some(attr.span),
1032                             // attributes can do whatever they like,
1033                             // for now
1034                             allow_internal_unstable: true,
1035                         }
1036                     });
1037                     it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
1038                     fld.cx.bt_pop();
1039                 }
1040                 _ => unreachable!()
1041             },
1042             _ => unreachable!()
1043         }
1044     }
1045
1046     // Expansion may have added new ItemModifiers.
1047     expand_item_multi_modifier(it, fld)
1048 }
1049
1050 fn expand_impl_item(ii: P<ast::ImplItem>, fld: &mut MacroExpander)
1051                  -> SmallVector<P<ast::ImplItem>> {
1052     match ii.node {
1053         ast::ImplItemKind::Method(..) => SmallVector::one(ii.map(|ii| ast::ImplItem {
1054             id: ii.id,
1055             ident: ii.ident,
1056             attrs: ii.attrs,
1057             vis: ii.vis,
1058             node: match ii.node  {
1059                 ast::ImplItemKind::Method(sig, body) => {
1060                     let (sig, body) = expand_and_rename_method(sig, body, fld);
1061                     ast::ImplItemKind::Method(sig, body)
1062                 }
1063                 _ => unreachable!()
1064             },
1065             span: fld.new_span(ii.span)
1066         })),
1067         ast::ImplItemKind::Macro(_) => {
1068             let (span, mac) = ii.and_then(|ii| match ii.node {
1069                 ast::ImplItemKind::Macro(mac) => (ii.span, mac),
1070                 _ => unreachable!()
1071             });
1072             let maybe_new_items =
1073                 expand_mac_invoc(mac, span,
1074                                  |r| r.make_impl_items(),
1075                                  |meths, mark| meths.move_map(|m| mark_impl_item(m, mark)),
1076                                  fld);
1077
1078             match maybe_new_items {
1079                 Some(impl_items) => {
1080                     // expand again if necessary
1081                     let new_items = impl_items.into_iter().flat_map(|ii| {
1082                         expand_impl_item(ii, fld).into_iter()
1083                     }).collect();
1084                     fld.cx.bt_pop();
1085                     new_items
1086                 }
1087                 None => SmallVector::zero()
1088             }
1089         }
1090         _ => fold::noop_fold_impl_item(ii, fld)
1091     }
1092 }
1093
1094 /// Given a fn_decl and a block and a MacroExpander, expand the fn_decl, then use the
1095 /// PatIdents in its arguments to perform renaming in the FnDecl and
1096 /// the block, returning both the new FnDecl and the new Block.
1097 fn expand_and_rename_fn_decl_and_block(fn_decl: P<ast::FnDecl>, block: P<ast::Block>,
1098                                        fld: &mut MacroExpander)
1099                                        -> (P<ast::FnDecl>, P<ast::Block>) {
1100     let expanded_decl = fld.fold_fn_decl(fn_decl);
1101     let idents = fn_decl_arg_bindings(&expanded_decl);
1102     let renames =
1103         idents.iter().map(|id| (*id,fresh_name(*id))).collect();
1104     // first, a renamer for the PatIdents, for the fn_decl:
1105     let mut rename_pat_fld = PatIdentRenamer{renames: &renames};
1106     let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(expanded_decl);
1107     // now, a renamer for *all* idents, for the body:
1108     let mut rename_fld = IdentRenamer{renames: &renames};
1109     let rewritten_body = fld.fold_block(rename_fld.fold_block(block));
1110     (rewritten_fn_decl,rewritten_body)
1111 }
1112
1113 fn expand_and_rename_method(sig: ast::MethodSig, body: P<ast::Block>,
1114                             fld: &mut MacroExpander)
1115                             -> (ast::MethodSig, P<ast::Block>) {
1116     let (rewritten_fn_decl, rewritten_body)
1117         = expand_and_rename_fn_decl_and_block(sig.decl, body, fld);
1118     (ast::MethodSig {
1119         generics: fld.fold_generics(sig.generics),
1120         abi: sig.abi,
1121         explicit_self: fld.fold_explicit_self(sig.explicit_self),
1122         unsafety: sig.unsafety,
1123         constness: sig.constness,
1124         decl: rewritten_fn_decl
1125     }, rewritten_body)
1126 }
1127
1128 pub fn expand_type(t: P<ast::Ty>, fld: &mut MacroExpander) -> P<ast::Ty> {
1129     let t = match t.node.clone() {
1130         ast::Ty_::TyMac(mac) => {
1131             if fld.cx.ecfg.features.unwrap().type_macros {
1132                 let expanded_ty = match expand_mac_invoc(mac, t.span,
1133                                                          |r| r.make_ty(),
1134                                                          mark_ty,
1135                                                          fld) {
1136                     Some(ty) => ty,
1137                     None => {
1138                         return DummyResult::raw_ty(t.span);
1139                     }
1140                 };
1141
1142                 // Keep going, outside-in.
1143                 let fully_expanded = fld.fold_ty(expanded_ty);
1144                 fld.cx.bt_pop();
1145
1146                 fully_expanded.map(|t| ast::Ty {
1147                     id: ast::DUMMY_NODE_ID,
1148                     node: t.node,
1149                     span: t.span,
1150                     })
1151             } else {
1152                 feature_gate::emit_feature_err(
1153                     &fld.cx.parse_sess.span_diagnostic,
1154                     "type_macros",
1155                     t.span,
1156                     feature_gate::GateIssue::Language,
1157                     "type macros are experimental");
1158
1159                 DummyResult::raw_ty(t.span)
1160             }
1161         }
1162         _ => t
1163     };
1164
1165     fold::noop_fold_ty(t, fld)
1166 }
1167
1168 /// A tree-folder that performs macro expansion
1169 pub struct MacroExpander<'a, 'b:'a> {
1170     pub cx: &'a mut ExtCtxt<'b>,
1171 }
1172
1173 impl<'a, 'b> MacroExpander<'a, 'b> {
1174     pub fn new(cx: &'a mut ExtCtxt<'b>) -> MacroExpander<'a, 'b> {
1175         MacroExpander { cx: cx }
1176     }
1177 }
1178
1179 impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
1180     fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
1181         expand_expr(expr, self)
1182     }
1183
1184     fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
1185         expand_pat(pat, self)
1186     }
1187
1188     fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
1189         expand_item(item, self)
1190     }
1191
1192     fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
1193         expand_item_underscore(item, self)
1194     }
1195
1196     fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
1197         expand_stmt(stmt, self)
1198     }
1199
1200     fn fold_block(&mut self, block: P<Block>) -> P<Block> {
1201         expand_block(block, self)
1202     }
1203
1204     fn fold_arm(&mut self, arm: ast::Arm) -> ast::Arm {
1205         expand_arm(arm, self)
1206     }
1207
1208     fn fold_trait_item(&mut self, i: P<ast::TraitItem>) -> SmallVector<P<ast::TraitItem>> {
1209         expand_annotatable(Annotatable::TraitItem(i), self)
1210             .into_iter().map(|i| i.expect_trait_item()).collect()
1211     }
1212
1213     fn fold_impl_item(&mut self, i: P<ast::ImplItem>) -> SmallVector<P<ast::ImplItem>> {
1214         expand_annotatable(Annotatable::ImplItem(i), self)
1215             .into_iter().map(|i| i.expect_impl_item()).collect()
1216     }
1217
1218     fn fold_ty(&mut self, ty: P<ast::Ty>) -> P<ast::Ty> {
1219         expand_type(ty, self)
1220     }
1221
1222     fn new_span(&mut self, span: Span) -> Span {
1223         new_span(self.cx, span)
1224     }
1225 }
1226
1227 fn new_span(cx: &ExtCtxt, sp: Span) -> Span {
1228     /* this discards information in the case of macro-defining macros */
1229     Span {
1230         lo: sp.lo,
1231         hi: sp.hi,
1232         expn_id: cx.backtrace(),
1233     }
1234 }
1235
1236 pub struct ExpansionConfig<'feat> {
1237     pub crate_name: String,
1238     pub features: Option<&'feat Features>,
1239     pub recursion_limit: usize,
1240     pub trace_mac: bool,
1241 }
1242
1243 macro_rules! feature_tests {
1244     ($( fn $getter:ident = $field:ident, )*) => {
1245         $(
1246             pub fn $getter(&self) -> bool {
1247                 match self.features {
1248                     Some(&Features { $field: true, .. }) => true,
1249                     _ => false,
1250                 }
1251             }
1252         )*
1253     }
1254 }
1255
1256 impl<'feat> ExpansionConfig<'feat> {
1257     pub fn default(crate_name: String) -> ExpansionConfig<'static> {
1258         ExpansionConfig {
1259             crate_name: crate_name,
1260             features: None,
1261             recursion_limit: 64,
1262             trace_mac: false,
1263         }
1264     }
1265
1266     feature_tests! {
1267         fn enable_quotes = allow_quote,
1268         fn enable_asm = allow_asm,
1269         fn enable_log_syntax = allow_log_syntax,
1270         fn enable_concat_idents = allow_concat_idents,
1271         fn enable_trace_macros = allow_trace_macros,
1272         fn enable_allow_internal_unstable = allow_internal_unstable,
1273         fn enable_custom_derive = allow_custom_derive,
1274         fn enable_pushpop_unsafe = allow_pushpop_unsafe,
1275     }
1276 }
1277
1278 pub fn expand_crate<'feat>(parse_sess: &parse::ParseSess,
1279                            cfg: ExpansionConfig<'feat>,
1280                            // these are the macros being imported to this crate:
1281                            imported_macros: Vec<ast::MacroDef>,
1282                            user_exts: Vec<NamedSyntaxExtension>,
1283                            feature_gated_cfgs: &mut Vec<GatedCfgAttr>,
1284                            c: Crate) -> (Crate, HashSet<Name>) {
1285     let mut cx = ExtCtxt::new(parse_sess, c.config.clone(), cfg,
1286                               feature_gated_cfgs);
1287     if std_inject::no_core(&c) {
1288         cx.crate_root = None;
1289     } else if std_inject::no_std(&c) {
1290         cx.crate_root = Some("core");
1291     } else {
1292         cx.crate_root = Some("std");
1293     }
1294     let ret = {
1295         let mut expander = MacroExpander::new(&mut cx);
1296
1297         for def in imported_macros {
1298             expander.cx.insert_macro(def);
1299         }
1300
1301         for (name, extension) in user_exts {
1302             expander.cx.syntax_env.insert(name, extension);
1303         }
1304
1305         let mut ret = expander.fold_crate(c);
1306         ret.exported_macros = expander.cx.exported_macros.clone();
1307         parse_sess.span_diagnostic.handler().abort_if_errors();
1308         ret
1309     };
1310     return (ret, cx.syntax_env.names);
1311 }
1312
1313 // HYGIENIC CONTEXT EXTENSION:
1314 // all of these functions are for walking over
1315 // ASTs and making some change to the context of every
1316 // element that has one. a CtxtFn is a trait-ified
1317 // version of a closure in (SyntaxContext -> SyntaxContext).
1318 // the ones defined here include:
1319 // Marker - add a mark to a context
1320
1321 // A Marker adds the given mark to the syntax context
1322 struct Marker { mark: Mrk }
1323
1324 impl Folder for Marker {
1325     fn fold_ident(&mut self, id: Ident) -> Ident {
1326         ast::Ident::new(id.name, mtwt::apply_mark(self.mark, id.ctxt))
1327     }
1328     fn fold_mac(&mut self, Spanned {node, span}: ast::Mac) -> ast::Mac {
1329         Spanned {
1330             node: Mac_ {
1331                 path: self.fold_path(node.path),
1332                 tts: self.fold_tts(&node.tts),
1333                 ctxt: mtwt::apply_mark(self.mark, node.ctxt),
1334             },
1335             span: span,
1336         }
1337     }
1338 }
1339
1340 // apply a given mark to the given token trees. Used prior to expansion of a macro.
1341 fn mark_tts(tts: &[TokenTree], m: Mrk) -> Vec<TokenTree> {
1342     noop_fold_tts(tts, &mut Marker{mark:m})
1343 }
1344
1345 // apply a given mark to the given expr. Used following the expansion of a macro.
1346 fn mark_expr(expr: P<ast::Expr>, m: Mrk) -> P<ast::Expr> {
1347     Marker{mark:m}.fold_expr(expr)
1348 }
1349
1350 // apply a given mark to the given pattern. Used following the expansion of a macro.
1351 fn mark_pat(pat: P<ast::Pat>, m: Mrk) -> P<ast::Pat> {
1352     Marker{mark:m}.fold_pat(pat)
1353 }
1354
1355 // apply a given mark to the given stmt. Used following the expansion of a macro.
1356 fn mark_stmt(stmt: P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
1357     Marker{mark:m}.fold_stmt(stmt)
1358         .expect_one("marking a stmt didn't return exactly one stmt")
1359 }
1360
1361 // apply a given mark to the given item. Used following the expansion of a macro.
1362 fn mark_item(expr: P<ast::Item>, m: Mrk) -> P<ast::Item> {
1363     Marker{mark:m}.fold_item(expr)
1364         .expect_one("marking an item didn't return exactly one item")
1365 }
1366
1367 // apply a given mark to the given item. Used following the expansion of a macro.
1368 fn mark_impl_item(ii: P<ast::ImplItem>, m: Mrk) -> P<ast::ImplItem> {
1369     Marker{mark:m}.fold_impl_item(ii)
1370         .expect_one("marking an impl item didn't return exactly one impl item")
1371 }
1372
1373 fn mark_ty(ty: P<ast::Ty>, m: Mrk) -> P<ast::Ty> {
1374     Marker { mark: m }.fold_ty(ty)
1375 }
1376
1377 /// Check that there are no macro invocations left in the AST:
1378 pub fn check_for_macros(sess: &parse::ParseSess, krate: &ast::Crate) {
1379     visit::walk_crate(&mut MacroExterminator{sess:sess}, krate);
1380 }
1381
1382 /// A visitor that ensures that no macro invocations remain in an AST.
1383 struct MacroExterminator<'a>{
1384     sess: &'a parse::ParseSess
1385 }
1386
1387 impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
1388     fn visit_mac(&mut self, mac: &ast::Mac) {
1389         self.sess.span_diagnostic.span_bug(mac.span,
1390                                            "macro exterminator: expected AST \
1391                                            with no macro invocations");
1392     }
1393 }
1394
1395
1396 #[cfg(test)]
1397 mod tests {
1398     use super::{pattern_bindings, expand_crate};
1399     use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig};
1400     use ast;
1401     use ast::Name;
1402     use codemap;
1403     use ext::mtwt;
1404     use fold::Folder;
1405     use parse;
1406     use parse::token;
1407     use util::parser_testing::{string_to_parser};
1408     use util::parser_testing::{string_to_pat, string_to_crate, strs_to_idents};
1409     use visit;
1410     use visit::Visitor;
1411
1412     // a visitor that extracts the paths
1413     // from a given thingy and puts them in a mutable
1414     // array (passed in to the traversal)
1415     #[derive(Clone)]
1416     struct PathExprFinderContext {
1417         path_accumulator: Vec<ast::Path> ,
1418     }
1419
1420     impl<'v> Visitor<'v> for PathExprFinderContext {
1421         fn visit_expr(&mut self, expr: &ast::Expr) {
1422             if let ast::ExprPath(None, ref p) = expr.node {
1423                 self.path_accumulator.push(p.clone());
1424             }
1425             visit::walk_expr(self, expr);
1426         }
1427     }
1428
1429     // find the variable references in a crate
1430     fn crate_varrefs(the_crate : &ast::Crate) -> Vec<ast::Path> {
1431         let mut path_finder = PathExprFinderContext{path_accumulator:Vec::new()};
1432         visit::walk_crate(&mut path_finder, the_crate);
1433         path_finder.path_accumulator
1434     }
1435
1436     /// A Visitor that extracts the identifiers from a thingy.
1437     // as a side note, I'm starting to want to abstract over these....
1438     struct IdentFinder {
1439         ident_accumulator: Vec<ast::Ident>
1440     }
1441
1442     impl<'v> Visitor<'v> for IdentFinder {
1443         fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
1444             self.ident_accumulator.push(id);
1445         }
1446     }
1447
1448     /// Find the idents in a crate
1449     fn crate_idents(the_crate: &ast::Crate) -> Vec<ast::Ident> {
1450         let mut ident_finder = IdentFinder{ident_accumulator: Vec::new()};
1451         visit::walk_crate(&mut ident_finder, the_crate);
1452         ident_finder.ident_accumulator
1453     }
1454
1455     // these following tests are quite fragile, in that they don't test what
1456     // *kind* of failure occurs.
1457
1458     fn test_ecfg() -> ExpansionConfig<'static> {
1459         ExpansionConfig::default("test".to_string())
1460     }
1461
1462     // make sure that macros can't escape fns
1463     #[should_panic]
1464     #[test] fn macros_cant_escape_fns_test () {
1465         let src = "fn bogus() {macro_rules! z (() => (3+4));}\
1466                    fn inty() -> i32 { z!() }".to_string();
1467         let sess = parse::ParseSess::new();
1468         let crate_ast = parse::parse_crate_from_source_str(
1469             "<test>".to_string(),
1470             src,
1471             Vec::new(), &sess);
1472         // should fail:
1473         expand_crate(&sess,test_ecfg(),vec!(),vec!(), &mut vec![], crate_ast);
1474     }
1475
1476     // make sure that macros can't escape modules
1477     #[should_panic]
1478     #[test] fn macros_cant_escape_mods_test () {
1479         let src = "mod foo {macro_rules! z (() => (3+4));}\
1480                    fn inty() -> i32 { z!() }".to_string();
1481         let sess = parse::ParseSess::new();
1482         let crate_ast = parse::parse_crate_from_source_str(
1483             "<test>".to_string(),
1484             src,
1485             Vec::new(), &sess);
1486         expand_crate(&sess,test_ecfg(),vec!(),vec!(), &mut vec![], crate_ast);
1487     }
1488
1489     // macro_use modules should allow macros to escape
1490     #[test] fn macros_can_escape_flattened_mods_test () {
1491         let src = "#[macro_use] mod foo {macro_rules! z (() => (3+4));}\
1492                    fn inty() -> i32 { z!() }".to_string();
1493         let sess = parse::ParseSess::new();
1494         let crate_ast = parse::parse_crate_from_source_str(
1495             "<test>".to_string(),
1496             src,
1497             Vec::new(), &sess);
1498         expand_crate(&sess, test_ecfg(), vec!(), vec!(), &mut vec![], crate_ast);
1499     }
1500
1501     fn expand_crate_str(crate_str: String) -> ast::Crate {
1502         let ps = parse::ParseSess::new();
1503         let crate_ast = panictry!(string_to_parser(&ps, crate_str).parse_crate_mod());
1504         // the cfg argument actually does matter, here...
1505         expand_crate(&ps,test_ecfg(),vec!(),vec!(), &mut vec![], crate_ast).0
1506     }
1507
1508     // find the pat_ident paths in a crate
1509     fn crate_bindings(the_crate : &ast::Crate) -> Vec<ast::Ident> {
1510         let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
1511         visit::walk_crate(&mut name_finder, the_crate);
1512         name_finder.ident_accumulator
1513     }
1514
1515     #[test] fn macro_tokens_should_match(){
1516         expand_crate_str(
1517             "macro_rules! m((a)=>(13)) ;fn main(){m!(a);}".to_string());
1518     }
1519
1520     // should be able to use a bound identifier as a literal in a macro definition:
1521     #[test] fn self_macro_parsing(){
1522         expand_crate_str(
1523             "macro_rules! foo ((zz) => (287;));
1524             fn f(zz: i32) {foo!(zz);}".to_string()
1525             );
1526     }
1527
1528     // renaming tests expand a crate and then check that the bindings match
1529     // the right varrefs. The specification of the test case includes the
1530     // text of the crate, and also an array of arrays.  Each element in the
1531     // outer array corresponds to a binding in the traversal of the AST
1532     // induced by visit.  Each of these arrays contains a list of indexes,
1533     // interpreted as the varrefs in the varref traversal that this binding
1534     // should match.  So, for instance, in a program with two bindings and
1535     // three varrefs, the array [[1, 2], [0]] would indicate that the first
1536     // binding should match the second two varrefs, and the second binding
1537     // should match the first varref.
1538     //
1539     // Put differently; this is a sparse representation of a boolean matrix
1540     // indicating which bindings capture which identifiers.
1541     //
1542     // Note also that this matrix is dependent on the implicit ordering of
1543     // the bindings and the varrefs discovered by the name-finder and the path-finder.
1544     //
1545     // The comparisons are done post-mtwt-resolve, so we're comparing renamed
1546     // names; differences in marks don't matter any more.
1547     //
1548     // oog... I also want tests that check "bound-identifier-=?". That is,
1549     // not just "do these have the same name", but "do they have the same
1550     // name *and* the same marks"? Understanding this is really pretty painful.
1551     // in principle, you might want to control this boolean on a per-varref basis,
1552     // but that would make things even harder to understand, and might not be
1553     // necessary for thorough testing.
1554     type RenamingTest = (&'static str, Vec<Vec<usize>>, bool);
1555
1556     #[test]
1557     fn automatic_renaming () {
1558         let tests: Vec<RenamingTest> =
1559             vec!(// b & c should get new names throughout, in the expr too:
1560                 ("fn a() -> i32 { let b = 13; let c = b; b+c }",
1561                  vec!(vec!(0,1),vec!(2)), false),
1562                 // both x's should be renamed (how is this causing a bug?)
1563                 ("fn main () {let x: i32 = 13;x;}",
1564                  vec!(vec!(0)), false),
1565                 // the use of b after the + should be renamed, the other one not:
1566                 ("macro_rules! f (($x:ident) => (b + $x)); fn a() -> i32 { let b = 13; f!(b)}",
1567                  vec!(vec!(1)), false),
1568                 // the b before the plus should not be renamed (requires marks)
1569                 ("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})); fn a() -> i32 { f!(b)}",
1570                  vec!(vec!(1)), false),
1571                 // the marks going in and out of letty should cancel, allowing that $x to
1572                 // capture the one following the semicolon.
1573                 // this was an awesome test case, and caught a *lot* of bugs.
1574                 ("macro_rules! letty(($x:ident) => (let $x = 15;));
1575                   macro_rules! user(($x:ident) => ({letty!($x); $x}));
1576                   fn main() -> i32 {user!(z)}",
1577                  vec!(vec!(0)), false)
1578                 );
1579         for (idx,s) in tests.iter().enumerate() {
1580             run_renaming_test(s,idx);
1581         }
1582     }
1583
1584     // no longer a fixme #8062: this test exposes a *potential* bug; our system does
1585     // not behave exactly like MTWT, but a conversation with Matthew Flatt
1586     // suggests that this can only occur in the presence of local-expand, which
1587     // we have no plans to support. ... unless it's needed for item hygiene....
1588     #[ignore]
1589     #[test]
1590     fn issue_8062(){
1591         run_renaming_test(
1592             &("fn main() {let hrcoo = 19; macro_rules! getx(()=>(hrcoo)); getx!();}",
1593               vec!(vec!(0)), true), 0)
1594     }
1595
1596     // FIXME #6994:
1597     // the z flows into and out of two macros (g & f) along one path, and one
1598     // (just g) along the other, so the result of the whole thing should
1599     // be "let z_123 = 3; z_123"
1600     #[ignore]
1601     #[test]
1602     fn issue_6994(){
1603         run_renaming_test(
1604             &("macro_rules! g (($x:ident) =>
1605               ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}));
1606               fn a(){g!(z)}",
1607               vec!(vec!(0)),false),
1608             0)
1609     }
1610
1611     // match variable hygiene. Should expand into
1612     // fn z() {match 8 {x_1 => {match 9 {x_2 | x_2 if x_2 == x_1 => x_2 + x_1}}}}
1613     #[test]
1614     fn issue_9384(){
1615         run_renaming_test(
1616             &("macro_rules! bad_macro (($ex:expr) => ({match 9 {x | x if x == $ex => x + $ex}}));
1617               fn z() {match 8 {x => bad_macro!(x)}}",
1618               // NB: the third "binding" is the repeat of the second one.
1619               vec!(vec!(1,3),vec!(0,2),vec!(0,2)),
1620               true),
1621             0)
1622     }
1623
1624     // interpolated nodes weren't getting labeled.
1625     // should expand into
1626     // fn main(){let g1_1 = 13; g1_1}}
1627     #[test]
1628     fn pat_expand_issue_15221(){
1629         run_renaming_test(
1630             &("macro_rules! inner ( ($e:pat ) => ($e));
1631               macro_rules! outer ( ($e:pat ) => (inner!($e)));
1632               fn main() { let outer!(g) = 13; g;}",
1633               vec!(vec!(0)),
1634               true),
1635             0)
1636     }
1637
1638     // create a really evil test case where a $x appears inside a binding of $x
1639     // but *shouldn't* bind because it was inserted by a different macro....
1640     // can't write this test case until we have macro-generating macros.
1641
1642     // method arg hygiene
1643     // method expands to fn get_x(&self_0, x_1: i32) {self_0 + self_2 + x_3 + x_1}
1644     #[test]
1645     fn method_arg_hygiene(){
1646         run_renaming_test(
1647             &("macro_rules! inject_x (()=>(x));
1648               macro_rules! inject_self (()=>(self));
1649               struct A;
1650               impl A{fn get_x(&self, x: i32) {self + inject_self!() + inject_x!() + x;} }",
1651               vec!(vec!(0),vec!(3)),
1652               true),
1653             0)
1654     }
1655
1656     // ooh, got another bite?
1657     // expands to struct A; impl A {fn thingy(&self_1) {self_1;}}
1658     #[test]
1659     fn method_arg_hygiene_2(){
1660         run_renaming_test(
1661             &("struct A;
1662               macro_rules! add_method (($T:ty) =>
1663               (impl $T {  fn thingy(&self) {self;} }));
1664               add_method!(A);",
1665               vec!(vec!(0)),
1666               true),
1667             0)
1668     }
1669
1670     // item fn hygiene
1671     // expands to fn q(x_1: i32){fn g(x_2: i32){x_2 + x_1};}
1672     #[test]
1673     fn issue_9383(){
1674         run_renaming_test(
1675             &("macro_rules! bad_macro (($ex:expr) => (fn g(x: i32){ x + $ex }));
1676               fn q(x: i32) { bad_macro!(x); }",
1677               vec!(vec!(1),vec!(0)),true),
1678             0)
1679     }
1680
1681     // closure arg hygiene (ExprClosure)
1682     // expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
1683     #[test]
1684     fn closure_arg_hygiene(){
1685         run_renaming_test(
1686             &("macro_rules! inject_x (()=>(x));
1687             fn f(){(|x : i32| {(inject_x!() + x)})(3);}",
1688               vec!(vec!(1)),
1689               true),
1690             0)
1691     }
1692
1693     // macro_rules in method position. Sadly, unimplemented.
1694     #[test]
1695     fn macro_in_method_posn(){
1696         expand_crate_str(
1697             "macro_rules! my_method (() => (fn thirteen(&self) -> i32 {13}));
1698             struct A;
1699             impl A{ my_method!(); }
1700             fn f(){A.thirteen;}".to_string());
1701     }
1702
1703     // another nested macro
1704     // expands to impl Entries {fn size_hint(&self_1) {self_1;}
1705     #[test]
1706     fn item_macro_workaround(){
1707         run_renaming_test(
1708             &("macro_rules! item { ($i:item) => {$i}}
1709               struct Entries;
1710               macro_rules! iterator_impl {
1711               () => { item!( impl Entries { fn size_hint(&self) { self;}});}}
1712               iterator_impl! { }",
1713               vec!(vec!(0)), true),
1714             0)
1715     }
1716
1717     // run one of the renaming tests
1718     fn run_renaming_test(t: &RenamingTest, test_idx: usize) {
1719         let invalid_name = token::special_idents::invalid.name;
1720         let (teststr, bound_connections, bound_ident_check) = match *t {
1721             (ref str,ref conns, bic) => (str.to_string(), conns.clone(), bic)
1722         };
1723         let cr = expand_crate_str(teststr.to_string());
1724         let bindings = crate_bindings(&cr);
1725         let varrefs = crate_varrefs(&cr);
1726
1727         // must be one check clause for each binding:
1728         assert_eq!(bindings.len(),bound_connections.len());
1729         for (binding_idx,shouldmatch) in bound_connections.iter().enumerate() {
1730             let binding_name = mtwt::resolve(bindings[binding_idx]);
1731             let binding_marks = mtwt::marksof(bindings[binding_idx].ctxt, invalid_name);
1732             // shouldmatch can't name varrefs that don't exist:
1733             assert!((shouldmatch.is_empty()) ||
1734                     (varrefs.len() > *shouldmatch.iter().max().unwrap()));
1735             for (idx,varref) in varrefs.iter().enumerate() {
1736                 let print_hygiene_debug_info = || {
1737                     // good lord, you can't make a path with 0 segments, can you?
1738                     let final_varref_ident = match varref.segments.last() {
1739                         Some(pathsegment) => pathsegment.identifier,
1740                         None => panic!("varref with 0 path segments?")
1741                     };
1742                     let varref_name = mtwt::resolve(final_varref_ident);
1743                     let varref_idents : Vec<ast::Ident>
1744                         = varref.segments.iter().map(|s| s.identifier)
1745                         .collect();
1746                     println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
1747                     println!("varref's first segment's string: \"{}\"", final_varref_ident);
1748                     println!("binding #{}: {}, resolves to {}",
1749                              binding_idx, bindings[binding_idx], binding_name);
1750                     mtwt::with_sctable(|x| mtwt::display_sctable(x));
1751                 };
1752                 if shouldmatch.contains(&idx) {
1753                     // it should be a path of length 1, and it should
1754                     // be free-identifier=? or bound-identifier=? to the given binding
1755                     assert_eq!(varref.segments.len(),1);
1756                     let varref_name = mtwt::resolve(varref.segments[0].identifier);
1757                     let varref_marks = mtwt::marksof(varref.segments[0]
1758                                                            .identifier
1759                                                            .ctxt,
1760                                                      invalid_name);
1761                     if !(varref_name==binding_name) {
1762                         println!("uh oh, should match but doesn't:");
1763                         print_hygiene_debug_info();
1764                     }
1765                     assert_eq!(varref_name,binding_name);
1766                     if bound_ident_check {
1767                         // we're checking bound-identifier=?, and the marks
1768                         // should be the same, too:
1769                         assert_eq!(varref_marks,binding_marks.clone());
1770                     }
1771                 } else {
1772                     let varref_name = mtwt::resolve(varref.segments[0].identifier);
1773                     let fail = (varref.segments.len() == 1)
1774                         && (varref_name == binding_name);
1775                     // temp debugging:
1776                     if fail {
1777                         println!("failure on test {}",test_idx);
1778                         println!("text of test case: \"{}\"", teststr);
1779                         println!("");
1780                         println!("uh oh, matches but shouldn't:");
1781                         print_hygiene_debug_info();
1782                     }
1783                     assert!(!fail);
1784                 }
1785             }
1786         }
1787     }
1788
1789     #[test]
1790     fn fmt_in_macro_used_inside_module_macro() {
1791         let crate_str = "macro_rules! fmt_wrap(($b:expr)=>($b.to_string()));
1792 macro_rules! foo_module (() => (mod generated { fn a() { let xx = 147; fmt_wrap!(xx);}}));
1793 foo_module!();
1794 ".to_string();
1795         let cr = expand_crate_str(crate_str);
1796         // find the xx binding
1797         let bindings = crate_bindings(&cr);
1798         let cxbinds: Vec<&ast::Ident> =
1799             bindings.iter().filter(|b| b.name.as_str() == "xx").collect();
1800         let cxbinds: &[&ast::Ident] = &cxbinds[..];
1801         let cxbind = match (cxbinds.len(), cxbinds.get(0)) {
1802             (1, Some(b)) => *b,
1803             _ => panic!("expected just one binding for ext_cx")
1804         };
1805         let resolved_binding = mtwt::resolve(*cxbind);
1806         let varrefs = crate_varrefs(&cr);
1807
1808         // the xx binding should bind all of the xx varrefs:
1809         for (idx,v) in varrefs.iter().filter(|p| {
1810             p.segments.len() == 1
1811             && p.segments[0].identifier.name.as_str() == "xx"
1812         }).enumerate() {
1813             if mtwt::resolve(v.segments[0].identifier) != resolved_binding {
1814                 println!("uh oh, xx binding didn't match xx varref:");
1815                 println!("this is xx varref \\# {}", idx);
1816                 println!("binding: {}", cxbind);
1817                 println!("resolves to: {}", resolved_binding);
1818                 println!("varref: {}", v.segments[0].identifier);
1819                 println!("resolves to: {}",
1820                          mtwt::resolve(v.segments[0].identifier));
1821                 mtwt::with_sctable(|x| mtwt::display_sctable(x));
1822             }
1823             assert_eq!(mtwt::resolve(v.segments[0].identifier),
1824                        resolved_binding);
1825         };
1826     }
1827
1828     #[test]
1829     fn pat_idents(){
1830         let pat = string_to_pat(
1831             "(a,Foo{x:c @ (b,9),y:Bar(4,d)})".to_string());
1832         let idents = pattern_bindings(&pat);
1833         assert_eq!(idents, strs_to_idents(vec!("a","c","b","d")));
1834     }
1835
1836     // test the list of identifier patterns gathered by the visitor. Note that
1837     // 'None' is listed as an identifier pattern because we don't yet know that
1838     // it's the name of a 0-ary variant, and that 'i' appears twice in succession.
1839     #[test]
1840     fn crate_bindings_test(){
1841         let the_crate = string_to_crate("fn main (a: i32) -> i32 {|b| {
1842         match 34 {None => 3, Some(i) | i => j, Foo{k:z,l:y} => \"banana\"}} }".to_string());
1843         let idents = crate_bindings(&the_crate);
1844         assert_eq!(idents, strs_to_idents(vec!("a","b","None","i","i","z","y")));
1845     }
1846
1847     // test the IdentRenamer directly
1848     #[test]
1849     fn ident_renamer_test () {
1850         let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
1851         let f_ident = token::str_to_ident("f");
1852         let x_ident = token::str_to_ident("x");
1853         let int_ident = token::str_to_ident("i32");
1854         let renames = vec!((x_ident,Name(16)));
1855         let mut renamer = IdentRenamer{renames: &renames};
1856         let renamed_crate = renamer.fold_crate(the_crate);
1857         let idents = crate_idents(&renamed_crate);
1858         let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
1859         assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16)]);
1860     }
1861
1862     // test the PatIdentRenamer; only PatIdents get renamed
1863     #[test]
1864     fn pat_ident_renamer_test () {
1865         let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
1866         let f_ident = token::str_to_ident("f");
1867         let x_ident = token::str_to_ident("x");
1868         let int_ident = token::str_to_ident("i32");
1869         let renames = vec!((x_ident,Name(16)));
1870         let mut renamer = PatIdentRenamer{renames: &renames};
1871         let renamed_crate = renamer.fold_crate(the_crate);
1872         let idents = crate_idents(&renamed_crate);
1873         let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
1874         let x_name = x_ident.name;
1875         assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name]);
1876     }
1877 }