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.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use ast::{Block, Crate, DeclLocal, PatMac};
12 use ast::{Local, Ident, Mac_, Name};
13 use ast::{ItemMac, MacStmtWithSemicolon, Mrk, Stmt, StmtDecl, StmtMac};
14 use ast::{StmtExpr, StmtSemi};
18 use ext::build::AstBuilder;
20 use attr::{AttrMetaMethods, WithAttrs};
22 use codemap::{Span, Spanned, ExpnInfo, NameAndSpan, MacroBang, MacroAttribute};
24 use feature_gate::{self, Features};
27 use util::move_map::MoveMap;
29 use parse::token::{fresh_mark, fresh_name, intern};
31 use util::small_vector::SmallVector;
36 use std::collections::HashSet;
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 {
43 // expr_mac should really be expr_ext or something; it's the
44 // entry-point for all syntax extensions.
45 ast::ExprMac(mac) => {
47 // Assert that we drop any macro attributes on the floor here
50 let expanded_expr = match expand_mac_invoc(mac, span,
55 return DummyResult::raw_expr(span);
59 // Keep going, outside-in.
60 let fully_expanded = fld.fold_expr(expanded_expr);
61 let span = fld.new_span(span);
64 fully_expanded.map(|e| ast::Expr {
65 id: ast::DUMMY_NODE_ID,
72 ast::ExprInPlace(placer, value_expr) => {
73 // Ensure feature-gate is enabled
74 feature_gate::check_for_placement_in(
76 &fld.cx.parse_sess.span_diagnostic,
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))
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))
92 ast::ExprWhileLet(pat, expr, body, opt_ident) => {
93 let pat = fld.fold_pat(pat);
94 let expr = fld.fold_expr(expr);
96 // Hygienic renaming of the body.
97 let ((body, opt_ident), mut rewritten_pats) =
98 rename_in_scope(vec![pat],
101 |rename_fld, fld, (body, opt_ident)| {
102 expand_loop_block(rename_fld.fold_block(body), opt_ident, fld)
104 assert!(rewritten_pats.len() == 1);
106 fld.cx.expr(span, ast::ExprWhileLet(rewritten_pats.remove(0), expr, body, opt_ident))
107 .with_attrs(fold_thin_attrs(attrs, fld))
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))
116 ast::ExprForLoop(pat, head, body, opt_ident) => {
117 let pat = fld.fold_pat(pat);
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],
124 |rename_fld, fld, (body, opt_ident)| {
125 expand_loop_block(rename_fld.fold_block(body), opt_ident, fld)
127 assert!(rewritten_pats.len() == 1);
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))
134 ast::ExprIfLet(pat, sub_expr, body, else_opt) => {
135 let pat = fld.fold_pat(pat);
137 // Hygienic renaming of the body.
138 let (body, mut rewritten_pats) =
139 rename_in_scope(vec![pat],
142 |rename_fld, fld, body| {
143 fld.fold_block(rename_fld.fold_block(body))
145 assert!(rewritten_pats.len() == 1);
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))
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,
159 P(ast::Expr{id:id, node: new_node, span: fld.new_span(span),
160 attrs: fold_thin_attrs(attrs, fld)})
164 P(noop_fold_expr(ast::Expr {
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,
182 fld: &mut MacroExpander)
184 F: for<'a> FnOnce(Box<MacResult+'a>) -> Option<T>,
185 G: FnOnce(T, Mrk) -> T,
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
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 \
198 // let compilation continue
201 let extname = pth.segments[0].identifier.name;
202 match fld.cx.syntax_env.find(extname) {
204 let mut err = fld.cx.struct_span_err(
206 &format!("macro undefined: '{}!'",
208 fld.cx.suggest_macro_name(&extname.as_str(), pth.span, &mut err);
211 // let compilation continue
214 Some(rc) => match *rc {
215 NormalTT(ref expandfun, exp_span, allow_internal_unstable) => {
216 fld.cx.bt_push(ExpnInfo {
218 callee: NameAndSpan {
219 format: MacroBang(extname),
221 allow_internal_unstable: allow_internal_unstable,
224 let fm = fresh_mark();
225 let marked_before = mark_tts(&tts[..], fm);
227 // The span that we pass to the expanders we want to
228 // be the root of the call stack. That's the most
229 // relevant span and it's the actual invocation of
231 let mac_span = fld.cx.original_span();
234 let expanded = expandfun.expand(fld.cx,
237 parse_thunk(expanded)
239 let parsed = match opt_parsed {
244 &format!("non-expression macro in expression position: {}",
250 Some(mark_thunk(parsed,fm))
255 &format!("'{}' is not a tt-style macro",
263 /// Rename loop label and expand its loop body
265 /// The renaming procedure for loop is different in the sense that the loop
266 /// body is in a block enclosed by loop head so the renaming of loop label
267 /// must be propagated to the enclosed context.
268 fn expand_loop_block(loop_block: P<Block>,
269 opt_ident: Option<Ident>,
270 fld: &mut MacroExpander) -> (P<Block>, Option<Ident>) {
273 let new_label = fresh_name(label);
274 let rename = (label, new_label);
276 // The rename *must not* be added to the pending list of current
277 // syntax context otherwise an unrelated `break` or `continue` in
278 // the same context will pick that up in the deferred renaming pass
279 // and be renamed incorrectly.
280 let mut rename_list = vec!(rename);
281 let mut rename_fld = IdentRenamer{renames: &mut rename_list};
282 let renamed_ident = rename_fld.fold_ident(label);
284 // The rename *must* be added to the enclosed syntax context for
285 // `break` or `continue` to pick up because by definition they are
286 // in a block enclosed by loop head.
287 fld.cx.syntax_env.push_frame();
288 fld.cx.syntax_env.info().pending_renames.push(rename);
289 let expanded_block = expand_block_elts(loop_block, fld);
290 fld.cx.syntax_env.pop_frame();
292 (expanded_block, Some(renamed_ident))
294 None => (fld.fold_block(loop_block), opt_ident)
298 // eval $e with a new exts frame.
299 // must be a macro so that $e isn't evaluated too early.
300 macro_rules! with_exts_frame {
301 ($extsboxexpr:expr,$macros_escape:expr,$e:expr) =>
302 ({$extsboxexpr.push_frame();
303 $extsboxexpr.info().macros_escape = $macros_escape;
305 $extsboxexpr.pop_frame();
310 // When we enter a module, record it, for the sake of `module!`
311 pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
312 -> SmallVector<P<ast::Item>> {
313 let it = expand_item_multi_modifier(Annotatable::Item(it), fld);
315 expand_annotatable(it, fld)
316 .into_iter().map(|i| i.expect_item()).collect()
319 /// Expand item_underscore
320 fn expand_item_underscore(item: ast::Item_, fld: &mut MacroExpander) -> ast::Item_ {
322 ast::ItemFn(decl, unsafety, constness, abi, generics, body) => {
323 let (rewritten_fn_decl, rewritten_body)
324 = expand_and_rename_fn_decl_and_block(decl, body, fld);
325 let expanded_generics = fold::noop_fold_generics(generics,fld);
326 ast::ItemFn(rewritten_fn_decl, unsafety, constness, abi,
327 expanded_generics, rewritten_body)
329 _ => noop_fold_item_underscore(item, fld)
333 // does this attribute list contain "macro_use" ?
334 fn contains_macro_use(fld: &mut MacroExpander, attrs: &[ast::Attribute]) -> bool {
336 let mut is_use = attr.check_name("macro_use");
337 if attr.check_name("macro_escape") {
339 fld.cx.struct_span_warn(attr.span,
340 "macro_escape is a deprecated synonym for macro_use");
342 if let ast::AttrStyle::Inner = attr.node.style {
343 err.fileline_help(attr.span, "consider an outer attribute, \
344 #[macro_use] mod ...").emit();
351 match attr.node.value.node {
352 ast::MetaWord(..) => (),
353 _ => fld.cx.span_err(attr.span, "arguments to macro_use are not allowed here"),
361 // Support for item-position macro invocations, exactly the same
362 // logic as for expression-position macro invocations.
363 pub fn expand_item_mac(it: P<ast::Item>,
364 fld: &mut MacroExpander) -> SmallVector<P<ast::Item>> {
365 let (extname, path_span, tts, span, attrs, ident) = it.and_then(|it| match it.node {
366 ItemMac(codemap::Spanned { node: Mac_ { path, tts, .. }, .. }) =>
367 (path.segments[0].identifier.name, path.span, tts, it.span, it.attrs, it.ident),
368 _ => fld.cx.span_bug(it.span, "invalid item macro invocation")
371 let fm = fresh_mark();
373 let expanded = match fld.cx.syntax_env.find(extname) {
375 fld.cx.span_err(path_span,
376 &format!("macro undefined: '{}!'",
378 // let compilation continue
379 return SmallVector::zero();
382 Some(rc) => match *rc {
383 NormalTT(ref expander, tt_span, allow_internal_unstable) => {
384 if ident.name != parse::token::special_idents::invalid.name {
387 &format!("macro {}! expects no ident argument, given '{}'",
390 return SmallVector::zero();
392 fld.cx.bt_push(ExpnInfo {
394 callee: NameAndSpan {
395 format: MacroBang(extname),
397 allow_internal_unstable: allow_internal_unstable,
400 // mark before expansion:
401 let marked_before = mark_tts(&tts[..], fm);
402 expander.expand(fld.cx, span, &marked_before[..])
404 IdentTT(ref expander, tt_span, allow_internal_unstable) => {
405 if ident.name == parse::token::special_idents::invalid.name {
406 fld.cx.span_err(path_span,
407 &format!("macro {}! expects an ident argument",
409 return SmallVector::zero();
411 fld.cx.bt_push(ExpnInfo {
413 callee: NameAndSpan {
414 format: MacroBang(extname),
416 allow_internal_unstable: allow_internal_unstable,
419 // mark before expansion:
420 let marked_tts = mark_tts(&tts[..], fm);
421 expander.expand(fld.cx, span, ident, marked_tts)
424 if ident.name == parse::token::special_idents::invalid.name {
425 fld.cx.span_err(path_span, "macro_rules! expects an ident argument");
426 return SmallVector::zero();
429 fld.cx.bt_push(ExpnInfo {
431 callee: NameAndSpan {
432 format: MacroBang(extname),
434 // `macro_rules!` doesn't directly allow
435 // unstable (this is orthogonal to whether
436 // the macro it creates allows it)
437 allow_internal_unstable: false,
440 // DON'T mark before expansion.
442 let allow_internal_unstable = attr::contains_name(&attrs,
443 "allow_internal_unstable");
445 // ensure any #[allow_internal_unstable]s are
446 // detected (including nested macro definitions
448 if allow_internal_unstable && !fld.cx.ecfg.enable_allow_internal_unstable() {
449 feature_gate::emit_feature_err(
450 &fld.cx.parse_sess.span_diagnostic,
451 "allow_internal_unstable",
453 feature_gate::GateIssue::Language,
454 feature_gate::EXPLAIN_ALLOW_INTERNAL_UNSTABLE)
457 let export = attr::contains_name(&attrs, "macro_export");
458 let def = ast::MacroDef {
461 id: ast::DUMMY_NODE_ID,
466 allow_internal_unstable: allow_internal_unstable,
469 fld.cx.insert_macro(def);
471 // macro_rules! has a side effect but expands to nothing.
473 return SmallVector::zero();
476 fld.cx.span_err(span,
477 &format!("{}! is not legal in item position",
479 return SmallVector::zero();
484 expanded.make_items()
487 let items = match items {
490 .map(|i| mark_item(i, fm))
491 .flat_map(|i| fld.fold_item(i).into_iter())
495 fld.cx.span_err(path_span,
496 &format!("non-item macro in item position: {}",
498 return SmallVector::zero();
507 fn expand_stmt(stmt: P<Stmt>, fld: &mut MacroExpander) -> SmallVector<P<Stmt>> {
508 let stmt = stmt.and_then(|stmt| stmt);
509 let (mac, style, attrs) = match stmt.node {
510 StmtMac(mac, style, attrs) => (mac, style, attrs),
511 _ => return expand_non_macro_stmt(stmt, fld)
514 // Assert that we drop any macro attributes on the floor here
517 let maybe_new_items =
518 expand_mac_invoc(mac.and_then(|m| m), stmt.span,
520 |stmts, mark| stmts.move_map(|m| mark_stmt(m, mark)),
523 let mut fully_expanded = match maybe_new_items {
525 // Keep going, outside-in.
526 let new_items = stmts.into_iter().flat_map(|s| {
527 fld.fold_stmt(s).into_iter()
532 None => SmallVector::zero()
535 // If this is a macro invocation with a semicolon, then apply that
536 // semicolon to the final statement produced by expansion.
537 if style == MacStmtWithSemicolon {
538 if let Some(stmt) = fully_expanded.pop() {
539 let new_stmt = stmt.map(|Spanned {node, span}| {
542 StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id),
543 _ => node /* might already have a semi */
548 fully_expanded.push(new_stmt);
555 // expand a non-macro stmt. this is essentially the fallthrough for
556 // expand_stmt, above.
557 fn expand_non_macro_stmt(Spanned {node, span: stmt_span}: Stmt, fld: &mut MacroExpander)
558 -> SmallVector<P<Stmt>> {
561 StmtDecl(decl, node_id) => decl.and_then(|Spanned {node: decl, span}| match decl {
562 DeclLocal(local) => {
564 let rewritten_local = local.map(|Local {id, pat, ty, init, span, attrs}| {
565 // expand the ty since TyFixedLengthVec contains an Expr
566 // and thus may have a macro use
567 let expanded_ty = ty.map(|t| fld.fold_ty(t));
568 // expand the pat (it might contain macro uses):
569 let expanded_pat = fld.fold_pat(pat);
570 // find the PatIdents in the pattern:
571 // oh dear heaven... this is going to include the enum
572 // names, as well... but that should be okay, as long as
573 // the new names are gensyms for the old ones.
574 // generate fresh names, push them to a new pending list
575 let idents = pattern_bindings(&expanded_pat);
576 let mut new_pending_renames =
577 idents.iter().map(|ident| (*ident, fresh_name(*ident))).collect();
578 // rewrite the pattern using the new names (the old
579 // ones have already been applied):
580 let rewritten_pat = {
581 // nested binding to allow borrow to expire:
582 let mut rename_fld = IdentRenamer{renames: &mut new_pending_renames};
583 rename_fld.fold_pat(expanded_pat)
585 // add them to the existing pending renames:
586 fld.cx.syntax_env.info().pending_renames
587 .extend(new_pending_renames);
592 // also, don't forget to expand the init:
593 init: init.map(|e| fld.fold_expr(e)),
595 attrs: fold::fold_thin_attrs(attrs, fld),
598 SmallVector::one(P(Spanned {
599 node: StmtDecl(P(Spanned {
600 node: DeclLocal(rewritten_local),
608 noop_fold_stmt(Spanned {
609 node: StmtDecl(P(Spanned {
619 noop_fold_stmt(Spanned {
627 // expand the arm of a 'match', renaming for macro hygiene
628 fn expand_arm(arm: ast::Arm, fld: &mut MacroExpander) -> ast::Arm {
629 // expand pats... they might contain macro uses:
630 let expanded_pats = arm.pats.move_map(|pat| fld.fold_pat(pat));
631 if expanded_pats.is_empty() {
632 panic!("encountered match arm with 0 patterns");
635 // apply renaming and then expansion to the guard and the body:
636 let ((rewritten_guard, rewritten_body), rewritten_pats) =
637 rename_in_scope(expanded_pats,
639 (arm.guard, arm.body),
640 |rename_fld, fld, (ag, ab)|{
641 let rewritten_guard = ag.map(|g| fld.fold_expr(rename_fld.fold_expr(g)));
642 let rewritten_body = fld.fold_expr(rename_fld.fold_expr(ab));
643 (rewritten_guard, rewritten_body)
647 attrs: fold::fold_attrs(arm.attrs, fld),
648 pats: rewritten_pats,
649 guard: rewritten_guard,
650 body: rewritten_body,
654 fn rename_in_scope<X, F>(pats: Vec<P<ast::Pat>>,
655 fld: &mut MacroExpander,
658 -> (X, Vec<P<ast::Pat>>)
659 where F: Fn(&mut IdentRenamer, &mut MacroExpander, X) -> X
661 // all of the pats must have the same set of bindings, so use the
662 // first one to extract them and generate new names:
663 let idents = pattern_bindings(&pats[0]);
664 let new_renames = idents.into_iter().map(|id| (id, fresh_name(id))).collect();
665 // apply the renaming, but only to the PatIdents:
666 let mut rename_pats_fld = PatIdentRenamer{renames:&new_renames};
667 let rewritten_pats = pats.move_map(|pat| rename_pats_fld.fold_pat(pat));
669 let mut rename_fld = IdentRenamer{ renames:&new_renames };
670 (f(&mut rename_fld, fld, x), rewritten_pats)
673 /// A visitor that extracts the PatIdent (binding) paths
674 /// from a given thingy and puts them in a mutable
677 struct PatIdentFinder {
678 ident_accumulator: Vec<ast::Ident>
681 impl<'v> Visitor<'v> for PatIdentFinder {
682 fn visit_pat(&mut self, pattern: &ast::Pat) {
684 ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => {
685 self.ident_accumulator.push(path1.node);
686 // visit optional subpattern of PatIdent:
687 if let Some(ref subpat) = *inner {
688 self.visit_pat(subpat)
691 // use the default traversal for non-PatIdents
692 _ => visit::walk_pat(self, pattern)
697 /// find the PatIdent paths in a pattern
698 fn pattern_bindings(pat: &ast::Pat) -> Vec<ast::Ident> {
699 let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
700 name_finder.visit_pat(pat);
701 name_finder.ident_accumulator
704 /// find the PatIdent paths in a
705 fn fn_decl_arg_bindings(fn_decl: &ast::FnDecl) -> Vec<ast::Ident> {
706 let mut pat_idents = PatIdentFinder{ident_accumulator:Vec::new()};
707 for arg in &fn_decl.inputs {
708 pat_idents.visit_pat(&arg.pat);
710 pat_idents.ident_accumulator
713 // expand a block. pushes a new exts_frame, then calls expand_block_elts
714 pub fn expand_block(blk: P<Block>, fld: &mut MacroExpander) -> P<Block> {
715 // see note below about treatment of exts table
716 with_exts_frame!(fld.cx.syntax_env,false,
717 expand_block_elts(blk, fld))
720 // expand the elements of a block.
721 pub fn expand_block_elts(b: P<Block>, fld: &mut MacroExpander) -> P<Block> {
722 b.map(|Block {id, stmts, expr, rules, span}| {
723 let new_stmts = stmts.into_iter().flat_map(|x| {
724 // perform all pending renames
726 let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
727 let mut rename_fld = IdentRenamer{renames:pending_renames};
728 rename_fld.fold_stmt(x).expect_one("rename_fold didn't return one value")
730 // expand macros in the statement
731 fld.fold_stmt(renamed_stmt).into_iter()
733 let new_expr = expr.map(|x| {
735 let pending_renames = &mut fld.cx.syntax_env.info().pending_renames;
736 let mut rename_fld = IdentRenamer{renames:pending_renames};
737 rename_fld.fold_expr(x)
751 fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
754 _ => return noop_fold_pat(p, fld)
756 p.map(|ast::Pat {node, span, ..}| {
757 let (pth, tts) = match node {
758 PatMac(mac) => (mac.node.path, mac.node.tts),
761 if pth.segments.len() > 1 {
762 fld.cx.span_err(pth.span, "expected macro name without module separators");
763 return DummyResult::raw_pat(span);
765 let extname = pth.segments[0].identifier.name;
766 let marked_after = match fld.cx.syntax_env.find(extname) {
768 fld.cx.span_err(pth.span,
769 &format!("macro undefined: '{}!'",
771 // let compilation continue
772 return DummyResult::raw_pat(span);
775 Some(rc) => match *rc {
776 NormalTT(ref expander, tt_span, allow_internal_unstable) => {
777 fld.cx.bt_push(ExpnInfo {
779 callee: NameAndSpan {
780 format: MacroBang(extname),
782 allow_internal_unstable: allow_internal_unstable,
786 let fm = fresh_mark();
787 let marked_before = mark_tts(&tts[..], fm);
788 let mac_span = fld.cx.original_span();
789 let pat = expander.expand(fld.cx,
791 &marked_before[..]).make_pat();
792 let expanded = match pat {
798 "non-pattern macro in pattern position: {}",
802 return DummyResult::raw_pat(span);
807 mark_pat(expanded,fm)
810 fld.cx.span_err(span,
811 &format!("{}! is not legal in pattern position",
813 return DummyResult::raw_pat(span);
819 fld.fold_pat(marked_after).node.clone();
823 id: ast::DUMMY_NODE_ID,
824 node: fully_expanded,
830 /// A tree-folder that applies every rename in its (mutable) list
831 /// to every identifier, including both bindings and varrefs
832 /// (and lots of things that will turn out to be neither)
833 pub struct IdentRenamer<'a> {
834 renames: &'a mtwt::RenameList,
837 impl<'a> Folder for IdentRenamer<'a> {
838 fn fold_ident(&mut self, id: Ident) -> Ident {
839 Ident::new(id.name, mtwt::apply_renames(self.renames, id.ctxt))
841 fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
842 fold::noop_fold_mac(mac, self)
846 /// A tree-folder that applies every rename in its list to
847 /// the idents that are in PatIdent patterns. This is more narrowly
848 /// focused than IdentRenamer, and is needed for FnDecl,
849 /// where we want to rename the args but not the fn name or the generics etc.
850 pub struct PatIdentRenamer<'a> {
851 renames: &'a mtwt::RenameList,
854 impl<'a> Folder for PatIdentRenamer<'a> {
855 fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
857 ast::PatIdent(..) => {},
858 _ => return noop_fold_pat(pat, self)
861 pat.map(|ast::Pat {id, node, span}| match node {
862 ast::PatIdent(binding_mode, Spanned{span: sp, node: ident}, sub) => {
863 let new_ident = Ident::new(ident.name,
864 mtwt::apply_renames(self.renames, ident.ctxt));
866 ast::PatIdent(binding_mode,
867 Spanned{span: self.new_span(sp), node: new_ident},
868 sub.map(|p| self.fold_pat(p)));
872 span: self.new_span(span)
878 fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
879 fold::noop_fold_mac(mac, self)
883 fn expand_annotatable(a: Annotatable,
884 fld: &mut MacroExpander)
885 -> SmallVector<Annotatable> {
886 let a = expand_item_multi_modifier(a, fld);
888 let mut decorator_items = SmallVector::zero();
889 let mut new_attrs = Vec::new();
890 expand_decorators(a.clone(), fld, &mut decorator_items, &mut new_attrs);
892 let mut new_items: SmallVector<Annotatable> = match a {
893 Annotatable::Item(it) => match it.node {
894 ast::ItemMac(..) => {
895 expand_item_mac(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
897 ast::ItemMod(_) | ast::ItemForeignMod(_) => {
899 it.ident.name != parse::token::special_idents::invalid.name;
902 fld.cx.mod_push(it.ident);
904 let macro_use = contains_macro_use(fld, &new_attrs[..]);
905 let result = with_exts_frame!(fld.cx.syntax_env,
907 noop_fold_item(it, fld));
911 result.into_iter().map(|i| Annotatable::Item(i)).collect()
914 let it = P(ast::Item {
918 noop_fold_item(it, fld).into_iter().map(|i| Annotatable::Item(i)).collect()
922 Annotatable::TraitItem(it) => match it.node {
923 ast::MethodTraitItem(_, Some(_)) => SmallVector::one(it.map(|ti| ast::TraitItem {
927 node: match ti.node {
928 ast::MethodTraitItem(sig, Some(body)) => {
929 let (sig, body) = expand_and_rename_method(sig, body, fld);
930 ast::MethodTraitItem(sig, Some(body))
934 span: fld.new_span(ti.span)
936 _ => fold::noop_fold_trait_item(it, fld)
937 }.into_iter().map(Annotatable::TraitItem).collect(),
939 Annotatable::ImplItem(ii) => {
940 expand_impl_item(ii, fld).into_iter().map(Annotatable::ImplItem).collect()
944 new_items.push_all(decorator_items);
948 // Partition a set of attributes into one kind of attribute, and other kinds.
949 macro_rules! partition {
950 ($fn_name: ident, $variant: ident) => {
951 #[allow(deprecated)] // The `allow` is needed because the `Modifier` variant might be used.
952 fn $fn_name(attrs: &[ast::Attribute],
954 -> (Vec<ast::Attribute>, Vec<ast::Attribute>) {
955 attrs.iter().cloned().partition(|attr| {
956 match fld.cx.syntax_env.find(intern(&attr.name())) {
957 Some(rc) => match *rc {
958 $variant(..) => true,
968 partition!(multi_modifiers, MultiModifier);
971 fn expand_decorators(a: Annotatable,
972 fld: &mut MacroExpander,
973 decorator_items: &mut SmallVector<Annotatable>,
974 new_attrs: &mut Vec<ast::Attribute>)
976 for attr in a.attrs() {
977 let mname = intern(&attr.name());
978 match fld.cx.syntax_env.find(mname) {
979 Some(rc) => match *rc {
980 MultiDecorator(ref dec) => {
981 attr::mark_used(&attr);
983 fld.cx.bt_push(ExpnInfo {
984 call_site: attr.span,
985 callee: NameAndSpan {
986 format: MacroAttribute(mname),
987 span: Some(attr.span),
988 // attributes can do whatever they like,
990 allow_internal_unstable: true,
994 // we'd ideally decorator_items.push_all(expand_annotatable(ann, fld)),
995 // but that double-mut-borrows fld
996 let mut items: SmallVector<Annotatable> = SmallVector::zero();
1001 &mut |ann| items.push(ann));
1002 decorator_items.extend(items.into_iter()
1003 .flat_map(|ann| expand_annotatable(ann, fld).into_iter()));
1007 _ => new_attrs.push((*attr).clone()),
1009 _ => new_attrs.push((*attr).clone()),
1014 fn expand_item_multi_modifier(mut it: Annotatable,
1015 fld: &mut MacroExpander)
1017 let (modifiers, other_attrs) = multi_modifiers(it.attrs(), fld);
1019 // Update the attrs, leave everything else alone. Is this mutation really a good idea?
1020 it = it.fold_attrs(other_attrs);
1022 if modifiers.is_empty() {
1026 for attr in &modifiers {
1027 let mname = intern(&attr.name());
1029 match fld.cx.syntax_env.find(mname) {
1030 Some(rc) => match *rc {
1031 MultiModifier(ref mac) => {
1032 attr::mark_used(attr);
1033 fld.cx.bt_push(ExpnInfo {
1034 call_site: attr.span,
1035 callee: NameAndSpan {
1036 format: MacroAttribute(mname),
1037 span: Some(attr.span),
1038 // attributes can do whatever they like,
1040 allow_internal_unstable: true,
1043 it = mac.expand(fld.cx, attr.span, &*attr.node.value, it);
1052 // Expansion may have added new ItemModifiers.
1053 expand_item_multi_modifier(it, fld)
1056 fn expand_impl_item(ii: P<ast::ImplItem>, fld: &mut MacroExpander)
1057 -> SmallVector<P<ast::ImplItem>> {
1059 ast::ImplItemKind::Method(..) => SmallVector::one(ii.map(|ii| ast::ImplItem {
1064 node: match ii.node {
1065 ast::ImplItemKind::Method(sig, body) => {
1066 let (sig, body) = expand_and_rename_method(sig, body, fld);
1067 ast::ImplItemKind::Method(sig, body)
1071 span: fld.new_span(ii.span)
1073 ast::ImplItemKind::Macro(_) => {
1074 let (span, mac) = ii.and_then(|ii| match ii.node {
1075 ast::ImplItemKind::Macro(mac) => (ii.span, mac),
1078 let maybe_new_items =
1079 expand_mac_invoc(mac, span,
1080 |r| r.make_impl_items(),
1081 |meths, mark| meths.move_map(|m| mark_impl_item(m, mark)),
1084 match maybe_new_items {
1085 Some(impl_items) => {
1086 // expand again if necessary
1087 let new_items = impl_items.into_iter().flat_map(|ii| {
1088 expand_impl_item(ii, fld).into_iter()
1093 None => SmallVector::zero()
1096 _ => fold::noop_fold_impl_item(ii, fld)
1100 /// Given a fn_decl and a block and a MacroExpander, expand the fn_decl, then use the
1101 /// PatIdents in its arguments to perform renaming in the FnDecl and
1102 /// the block, returning both the new FnDecl and the new Block.
1103 fn expand_and_rename_fn_decl_and_block(fn_decl: P<ast::FnDecl>, block: P<ast::Block>,
1104 fld: &mut MacroExpander)
1105 -> (P<ast::FnDecl>, P<ast::Block>) {
1106 let expanded_decl = fld.fold_fn_decl(fn_decl);
1107 let idents = fn_decl_arg_bindings(&expanded_decl);
1109 idents.iter().map(|id| (*id,fresh_name(*id))).collect();
1110 // first, a renamer for the PatIdents, for the fn_decl:
1111 let mut rename_pat_fld = PatIdentRenamer{renames: &renames};
1112 let rewritten_fn_decl = rename_pat_fld.fold_fn_decl(expanded_decl);
1113 // now, a renamer for *all* idents, for the body:
1114 let mut rename_fld = IdentRenamer{renames: &renames};
1115 let rewritten_body = fld.fold_block(rename_fld.fold_block(block));
1116 (rewritten_fn_decl,rewritten_body)
1119 fn expand_and_rename_method(sig: ast::MethodSig, body: P<ast::Block>,
1120 fld: &mut MacroExpander)
1121 -> (ast::MethodSig, P<ast::Block>) {
1122 let (rewritten_fn_decl, rewritten_body)
1123 = expand_and_rename_fn_decl_and_block(sig.decl, body, fld);
1125 generics: fld.fold_generics(sig.generics),
1127 explicit_self: fld.fold_explicit_self(sig.explicit_self),
1128 unsafety: sig.unsafety,
1129 constness: sig.constness,
1130 decl: rewritten_fn_decl
1134 pub fn expand_type(t: P<ast::Ty>, fld: &mut MacroExpander) -> P<ast::Ty> {
1135 let t = match t.node.clone() {
1136 ast::Ty_::TyMac(mac) => {
1137 if fld.cx.ecfg.features.unwrap().type_macros {
1138 let expanded_ty = match expand_mac_invoc(mac, t.span,
1144 return DummyResult::raw_ty(t.span);
1148 // Keep going, outside-in.
1149 let fully_expanded = fld.fold_ty(expanded_ty);
1152 fully_expanded.map(|t| ast::Ty {
1153 id: ast::DUMMY_NODE_ID,
1158 feature_gate::emit_feature_err(
1159 &fld.cx.parse_sess.span_diagnostic,
1162 feature_gate::GateIssue::Language,
1163 "type macros are experimental");
1165 DummyResult::raw_ty(t.span)
1171 fold::noop_fold_ty(t, fld)
1174 /// A tree-folder that performs macro expansion
1175 pub struct MacroExpander<'a, 'b:'a> {
1176 pub cx: &'a mut ExtCtxt<'b>,
1179 impl<'a, 'b> MacroExpander<'a, 'b> {
1180 pub fn new(cx: &'a mut ExtCtxt<'b>) -> MacroExpander<'a, 'b> {
1181 MacroExpander { cx: cx }
1185 impl<'a, 'b> Folder for MacroExpander<'a, 'b> {
1186 fn fold_expr(&mut self, expr: P<ast::Expr>) -> P<ast::Expr> {
1187 expand_expr(expr, self)
1190 fn fold_pat(&mut self, pat: P<ast::Pat>) -> P<ast::Pat> {
1191 expand_pat(pat, self)
1194 fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
1195 expand_item(item, self)
1198 fn fold_item_underscore(&mut self, item: ast::Item_) -> ast::Item_ {
1199 expand_item_underscore(item, self)
1202 fn fold_stmt(&mut self, stmt: P<ast::Stmt>) -> SmallVector<P<ast::Stmt>> {
1203 expand_stmt(stmt, self)
1206 fn fold_block(&mut self, block: P<Block>) -> P<Block> {
1207 expand_block(block, self)
1210 fn fold_arm(&mut self, arm: ast::Arm) -> ast::Arm {
1211 expand_arm(arm, self)
1214 fn fold_trait_item(&mut self, i: P<ast::TraitItem>) -> SmallVector<P<ast::TraitItem>> {
1215 expand_annotatable(Annotatable::TraitItem(i), self)
1216 .into_iter().map(|i| i.expect_trait_item()).collect()
1219 fn fold_impl_item(&mut self, i: P<ast::ImplItem>) -> SmallVector<P<ast::ImplItem>> {
1220 expand_annotatable(Annotatable::ImplItem(i), self)
1221 .into_iter().map(|i| i.expect_impl_item()).collect()
1224 fn fold_ty(&mut self, ty: P<ast::Ty>) -> P<ast::Ty> {
1225 expand_type(ty, self)
1228 fn new_span(&mut self, span: Span) -> Span {
1229 new_span(self.cx, span)
1233 fn new_span(cx: &ExtCtxt, sp: Span) -> Span {
1234 /* this discards information in the case of macro-defining macros */
1238 expn_id: cx.backtrace(),
1242 pub struct ExpansionConfig<'feat> {
1243 pub crate_name: String,
1244 pub features: Option<&'feat Features>,
1245 pub recursion_limit: usize,
1246 pub trace_mac: bool,
1249 macro_rules! feature_tests {
1250 ($( fn $getter:ident = $field:ident, )*) => {
1252 pub fn $getter(&self) -> bool {
1253 match self.features {
1254 Some(&Features { $field: true, .. }) => true,
1262 impl<'feat> ExpansionConfig<'feat> {
1263 pub fn default(crate_name: String) -> ExpansionConfig<'static> {
1265 crate_name: crate_name,
1267 recursion_limit: 64,
1273 fn enable_quotes = allow_quote,
1274 fn enable_asm = allow_asm,
1275 fn enable_log_syntax = allow_log_syntax,
1276 fn enable_concat_idents = allow_concat_idents,
1277 fn enable_trace_macros = allow_trace_macros,
1278 fn enable_allow_internal_unstable = allow_internal_unstable,
1279 fn enable_custom_derive = allow_custom_derive,
1280 fn enable_pushpop_unsafe = allow_pushpop_unsafe,
1284 pub fn expand_crate(mut cx: ExtCtxt,
1285 // these are the macros being imported to this crate:
1286 imported_macros: Vec<ast::MacroDef>,
1287 user_exts: Vec<NamedSyntaxExtension>,
1288 c: Crate) -> (Crate, HashSet<Name>) {
1289 if std_inject::no_core(&c) {
1290 cx.crate_root = None;
1291 } else if std_inject::no_std(&c) {
1292 cx.crate_root = Some("core");
1294 cx.crate_root = Some("std");
1297 let mut expander = MacroExpander::new(&mut cx);
1299 for def in imported_macros {
1300 expander.cx.insert_macro(def);
1303 for (name, extension) in user_exts {
1304 expander.cx.syntax_env.insert(name, extension);
1307 let mut ret = expander.fold_crate(c);
1308 ret.exported_macros = expander.cx.exported_macros.clone();
1309 cx.parse_sess.span_diagnostic.abort_if_errors();
1312 return (ret, cx.syntax_env.names);
1315 // HYGIENIC CONTEXT EXTENSION:
1316 // all of these functions are for walking over
1317 // ASTs and making some change to the context of every
1318 // element that has one. a CtxtFn is a trait-ified
1319 // version of a closure in (SyntaxContext -> SyntaxContext).
1320 // the ones defined here include:
1321 // Marker - add a mark to a context
1323 // A Marker adds the given mark to the syntax context
1324 struct Marker { mark: Mrk }
1326 impl Folder for Marker {
1327 fn fold_ident(&mut self, id: Ident) -> Ident {
1328 ast::Ident::new(id.name, mtwt::apply_mark(self.mark, id.ctxt))
1330 fn fold_mac(&mut self, Spanned {node, span}: ast::Mac) -> ast::Mac {
1333 path: self.fold_path(node.path),
1334 tts: self.fold_tts(&node.tts),
1335 ctxt: mtwt::apply_mark(self.mark, node.ctxt),
1342 // apply a given mark to the given token trees. Used prior to expansion of a macro.
1343 fn mark_tts(tts: &[TokenTree], m: Mrk) -> Vec<TokenTree> {
1344 noop_fold_tts(tts, &mut Marker{mark:m})
1347 // apply a given mark to the given expr. Used following the expansion of a macro.
1348 fn mark_expr(expr: P<ast::Expr>, m: Mrk) -> P<ast::Expr> {
1349 Marker{mark:m}.fold_expr(expr)
1352 // apply a given mark to the given pattern. Used following the expansion of a macro.
1353 fn mark_pat(pat: P<ast::Pat>, m: Mrk) -> P<ast::Pat> {
1354 Marker{mark:m}.fold_pat(pat)
1357 // apply a given mark to the given stmt. Used following the expansion of a macro.
1358 fn mark_stmt(stmt: P<ast::Stmt>, m: Mrk) -> P<ast::Stmt> {
1359 Marker{mark:m}.fold_stmt(stmt)
1360 .expect_one("marking a stmt didn't return exactly one stmt")
1363 // apply a given mark to the given item. Used following the expansion of a macro.
1364 fn mark_item(expr: P<ast::Item>, m: Mrk) -> P<ast::Item> {
1365 Marker{mark:m}.fold_item(expr)
1366 .expect_one("marking an item didn't return exactly one item")
1369 // apply a given mark to the given item. Used following the expansion of a macro.
1370 fn mark_impl_item(ii: P<ast::ImplItem>, m: Mrk) -> P<ast::ImplItem> {
1371 Marker{mark:m}.fold_impl_item(ii)
1372 .expect_one("marking an impl item didn't return exactly one impl item")
1375 fn mark_ty(ty: P<ast::Ty>, m: Mrk) -> P<ast::Ty> {
1376 Marker { mark: m }.fold_ty(ty)
1379 /// Check that there are no macro invocations left in the AST:
1380 pub fn check_for_macros(sess: &parse::ParseSess, krate: &ast::Crate) {
1381 visit::walk_crate(&mut MacroExterminator{sess:sess}, krate);
1384 /// A visitor that ensures that no macro invocations remain in an AST.
1385 struct MacroExterminator<'a>{
1386 sess: &'a parse::ParseSess
1389 impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
1390 fn visit_mac(&mut self, mac: &ast::Mac) {
1391 self.sess.span_diagnostic.span_bug(mac.span,
1392 "macro exterminator: expected AST \
1393 with no macro invocations");
1400 use super::{pattern_bindings, expand_crate};
1401 use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig};
1405 use ext::base::ExtCtxt;
1410 use util::parser_testing::{string_to_parser};
1411 use util::parser_testing::{string_to_pat, string_to_crate, strs_to_idents};
1415 // a visitor that extracts the paths
1416 // from a given thingy and puts them in a mutable
1417 // array (passed in to the traversal)
1419 struct PathExprFinderContext {
1420 path_accumulator: Vec<ast::Path> ,
1423 impl<'v> Visitor<'v> for PathExprFinderContext {
1424 fn visit_expr(&mut self, expr: &ast::Expr) {
1425 if let ast::ExprPath(None, ref p) = expr.node {
1426 self.path_accumulator.push(p.clone());
1428 visit::walk_expr(self, expr);
1432 // find the variable references in a crate
1433 fn crate_varrefs(the_crate : &ast::Crate) -> Vec<ast::Path> {
1434 let mut path_finder = PathExprFinderContext{path_accumulator:Vec::new()};
1435 visit::walk_crate(&mut path_finder, the_crate);
1436 path_finder.path_accumulator
1439 /// A Visitor that extracts the identifiers from a thingy.
1440 // as a side note, I'm starting to want to abstract over these....
1441 struct IdentFinder {
1442 ident_accumulator: Vec<ast::Ident>
1445 impl<'v> Visitor<'v> for IdentFinder {
1446 fn visit_ident(&mut self, _: codemap::Span, id: ast::Ident){
1447 self.ident_accumulator.push(id);
1451 /// Find the idents in a crate
1452 fn crate_idents(the_crate: &ast::Crate) -> Vec<ast::Ident> {
1453 let mut ident_finder = IdentFinder{ident_accumulator: Vec::new()};
1454 visit::walk_crate(&mut ident_finder, the_crate);
1455 ident_finder.ident_accumulator
1458 // these following tests are quite fragile, in that they don't test what
1459 // *kind* of failure occurs.
1461 fn test_ecfg() -> ExpansionConfig<'static> {
1462 ExpansionConfig::default("test".to_string())
1465 // make sure that macros can't escape fns
1467 #[test] fn macros_cant_escape_fns_test () {
1468 let src = "fn bogus() {macro_rules! z (() => (3+4));}\
1469 fn inty() -> i32 { z!() }".to_string();
1470 let sess = parse::ParseSess::new();
1471 let crate_ast = parse::parse_crate_from_source_str(
1472 "<test>".to_string(),
1476 let mut gated_cfgs = vec![];
1477 let ecx = ExtCtxt::new(&sess, vec![], test_ecfg(), &mut gated_cfgs);
1478 expand_crate(ecx, vec![], vec![], crate_ast);
1481 // make sure that macros can't escape modules
1483 #[test] fn macros_cant_escape_mods_test () {
1484 let src = "mod foo {macro_rules! z (() => (3+4));}\
1485 fn inty() -> i32 { z!() }".to_string();
1486 let sess = parse::ParseSess::new();
1487 let crate_ast = parse::parse_crate_from_source_str(
1488 "<test>".to_string(),
1491 let mut gated_cfgs = vec![];
1492 let ecx = ExtCtxt::new(&sess, vec![], test_ecfg(), &mut gated_cfgs);
1493 expand_crate(ecx, vec![], vec![], crate_ast);
1496 // macro_use modules should allow macros to escape
1497 #[test] fn macros_can_escape_flattened_mods_test () {
1498 let src = "#[macro_use] mod foo {macro_rules! z (() => (3+4));}\
1499 fn inty() -> i32 { z!() }".to_string();
1500 let sess = parse::ParseSess::new();
1501 let crate_ast = parse::parse_crate_from_source_str(
1502 "<test>".to_string(),
1505 let mut gated_cfgs = vec![];
1506 let ecx = ExtCtxt::new(&sess, vec![], test_ecfg(), &mut gated_cfgs);
1507 expand_crate(ecx, vec![], vec![], crate_ast);
1510 fn expand_crate_str(crate_str: String) -> ast::Crate {
1511 let ps = parse::ParseSess::new();
1512 let crate_ast = panictry!(string_to_parser(&ps, crate_str).parse_crate_mod());
1513 // the cfg argument actually does matter, here...
1514 let mut gated_cfgs = vec![];
1515 let ecx = ExtCtxt::new(&ps, vec![], test_ecfg(), &mut gated_cfgs);
1516 expand_crate(ecx, vec![], vec![], crate_ast).0
1519 // find the pat_ident paths in a crate
1520 fn crate_bindings(the_crate : &ast::Crate) -> Vec<ast::Ident> {
1521 let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()};
1522 visit::walk_crate(&mut name_finder, the_crate);
1523 name_finder.ident_accumulator
1526 #[test] fn macro_tokens_should_match(){
1528 "macro_rules! m((a)=>(13)) ;fn main(){m!(a);}".to_string());
1531 // should be able to use a bound identifier as a literal in a macro definition:
1532 #[test] fn self_macro_parsing(){
1534 "macro_rules! foo ((zz) => (287;));
1535 fn f(zz: i32) {foo!(zz);}".to_string()
1539 // renaming tests expand a crate and then check that the bindings match
1540 // the right varrefs. The specification of the test case includes the
1541 // text of the crate, and also an array of arrays. Each element in the
1542 // outer array corresponds to a binding in the traversal of the AST
1543 // induced by visit. Each of these arrays contains a list of indexes,
1544 // interpreted as the varrefs in the varref traversal that this binding
1545 // should match. So, for instance, in a program with two bindings and
1546 // three varrefs, the array [[1, 2], [0]] would indicate that the first
1547 // binding should match the second two varrefs, and the second binding
1548 // should match the first varref.
1550 // Put differently; this is a sparse representation of a boolean matrix
1551 // indicating which bindings capture which identifiers.
1553 // Note also that this matrix is dependent on the implicit ordering of
1554 // the bindings and the varrefs discovered by the name-finder and the path-finder.
1556 // The comparisons are done post-mtwt-resolve, so we're comparing renamed
1557 // names; differences in marks don't matter any more.
1559 // oog... I also want tests that check "bound-identifier-=?". That is,
1560 // not just "do these have the same name", but "do they have the same
1561 // name *and* the same marks"? Understanding this is really pretty painful.
1562 // in principle, you might want to control this boolean on a per-varref basis,
1563 // but that would make things even harder to understand, and might not be
1564 // necessary for thorough testing.
1565 type RenamingTest = (&'static str, Vec<Vec<usize>>, bool);
1568 fn automatic_renaming () {
1569 let tests: Vec<RenamingTest> =
1570 vec!(// b & c should get new names throughout, in the expr too:
1571 ("fn a() -> i32 { let b = 13; let c = b; b+c }",
1572 vec!(vec!(0,1),vec!(2)), false),
1573 // both x's should be renamed (how is this causing a bug?)
1574 ("fn main () {let x: i32 = 13;x;}",
1575 vec!(vec!(0)), false),
1576 // the use of b after the + should be renamed, the other one not:
1577 ("macro_rules! f (($x:ident) => (b + $x)); fn a() -> i32 { let b = 13; f!(b)}",
1578 vec!(vec!(1)), false),
1579 // the b before the plus should not be renamed (requires marks)
1580 ("macro_rules! f (($x:ident) => ({let b=9; ($x + b)})); fn a() -> i32 { f!(b)}",
1581 vec!(vec!(1)), false),
1582 // the marks going in and out of letty should cancel, allowing that $x to
1583 // capture the one following the semicolon.
1584 // this was an awesome test case, and caught a *lot* of bugs.
1585 ("macro_rules! letty(($x:ident) => (let $x = 15;));
1586 macro_rules! user(($x:ident) => ({letty!($x); $x}));
1587 fn main() -> i32 {user!(z)}",
1588 vec!(vec!(0)), false)
1590 for (idx,s) in tests.iter().enumerate() {
1591 run_renaming_test(s,idx);
1595 // no longer a fixme #8062: this test exposes a *potential* bug; our system does
1596 // not behave exactly like MTWT, but a conversation with Matthew Flatt
1597 // suggests that this can only occur in the presence of local-expand, which
1598 // we have no plans to support. ... unless it's needed for item hygiene....
1603 &("fn main() {let hrcoo = 19; macro_rules! getx(()=>(hrcoo)); getx!();}",
1604 vec!(vec!(0)), true), 0)
1608 // the z flows into and out of two macros (g & f) along one path, and one
1609 // (just g) along the other, so the result of the whole thing should
1610 // be "let z_123 = 3; z_123"
1615 &("macro_rules! g (($x:ident) =>
1616 ({macro_rules! f(($y:ident)=>({let $y=3;$x}));f!($x)}));
1618 vec!(vec!(0)),false),
1622 // match variable hygiene. Should expand into
1623 // fn z() {match 8 {x_1 => {match 9 {x_2 | x_2 if x_2 == x_1 => x_2 + x_1}}}}
1627 &("macro_rules! bad_macro (($ex:expr) => ({match 9 {x | x if x == $ex => x + $ex}}));
1628 fn z() {match 8 {x => bad_macro!(x)}}",
1629 // NB: the third "binding" is the repeat of the second one.
1630 vec!(vec!(1,3),vec!(0,2),vec!(0,2)),
1635 // interpolated nodes weren't getting labeled.
1636 // should expand into
1637 // fn main(){let g1_1 = 13; g1_1}}
1639 fn pat_expand_issue_15221(){
1641 &("macro_rules! inner ( ($e:pat ) => ($e));
1642 macro_rules! outer ( ($e:pat ) => (inner!($e)));
1643 fn main() { let outer!(g) = 13; g;}",
1649 // create a really evil test case where a $x appears inside a binding of $x
1650 // but *shouldn't* bind because it was inserted by a different macro....
1651 // can't write this test case until we have macro-generating macros.
1653 // method arg hygiene
1654 // method expands to fn get_x(&self_0, x_1: i32) {self_0 + self_2 + x_3 + x_1}
1656 fn method_arg_hygiene(){
1658 &("macro_rules! inject_x (()=>(x));
1659 macro_rules! inject_self (()=>(self));
1661 impl A{fn get_x(&self, x: i32) {self + inject_self!() + inject_x!() + x;} }",
1662 vec!(vec!(0),vec!(3)),
1667 // ooh, got another bite?
1668 // expands to struct A; impl A {fn thingy(&self_1) {self_1;}}
1670 fn method_arg_hygiene_2(){
1673 macro_rules! add_method (($T:ty) =>
1674 (impl $T { fn thingy(&self) {self;} }));
1682 // expands to fn q(x_1: i32){fn g(x_2: i32){x_2 + x_1};}
1686 &("macro_rules! bad_macro (($ex:expr) => (fn g(x: i32){ x + $ex }));
1687 fn q(x: i32) { bad_macro!(x); }",
1688 vec!(vec!(1),vec!(0)),true),
1692 // closure arg hygiene (ExprClosure)
1693 // expands to fn f(){(|x_1 : i32| {(x_2 + x_1)})(3);}
1695 fn closure_arg_hygiene(){
1697 &("macro_rules! inject_x (()=>(x));
1698 fn f(){(|x : i32| {(inject_x!() + x)})(3);}",
1704 // macro_rules in method position. Sadly, unimplemented.
1706 fn macro_in_method_posn(){
1708 "macro_rules! my_method (() => (fn thirteen(&self) -> i32 {13}));
1710 impl A{ my_method!(); }
1711 fn f(){A.thirteen;}".to_string());
1714 // another nested macro
1715 // expands to impl Entries {fn size_hint(&self_1) {self_1;}
1717 fn item_macro_workaround(){
1719 &("macro_rules! item { ($i:item) => {$i}}
1721 macro_rules! iterator_impl {
1722 () => { item!( impl Entries { fn size_hint(&self) { self;}});}}
1723 iterator_impl! { }",
1724 vec!(vec!(0)), true),
1728 // run one of the renaming tests
1729 fn run_renaming_test(t: &RenamingTest, test_idx: usize) {
1730 let invalid_name = token::special_idents::invalid.name;
1731 let (teststr, bound_connections, bound_ident_check) = match *t {
1732 (ref str,ref conns, bic) => (str.to_string(), conns.clone(), bic)
1734 let cr = expand_crate_str(teststr.to_string());
1735 let bindings = crate_bindings(&cr);
1736 let varrefs = crate_varrefs(&cr);
1738 // must be one check clause for each binding:
1739 assert_eq!(bindings.len(),bound_connections.len());
1740 for (binding_idx,shouldmatch) in bound_connections.iter().enumerate() {
1741 let binding_name = mtwt::resolve(bindings[binding_idx]);
1742 let binding_marks = mtwt::marksof(bindings[binding_idx].ctxt, invalid_name);
1743 // shouldmatch can't name varrefs that don't exist:
1744 assert!((shouldmatch.is_empty()) ||
1745 (varrefs.len() > *shouldmatch.iter().max().unwrap()));
1746 for (idx,varref) in varrefs.iter().enumerate() {
1747 let print_hygiene_debug_info = || {
1748 // good lord, you can't make a path with 0 segments, can you?
1749 let final_varref_ident = match varref.segments.last() {
1750 Some(pathsegment) => pathsegment.identifier,
1751 None => panic!("varref with 0 path segments?")
1753 let varref_name = mtwt::resolve(final_varref_ident);
1754 let varref_idents : Vec<ast::Ident>
1755 = varref.segments.iter().map(|s| s.identifier)
1757 println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
1758 println!("varref's first segment's string: \"{}\"", final_varref_ident);
1759 println!("binding #{}: {}, resolves to {}",
1760 binding_idx, bindings[binding_idx], binding_name);
1761 mtwt::with_sctable(|x| mtwt::display_sctable(x));
1763 if shouldmatch.contains(&idx) {
1764 // it should be a path of length 1, and it should
1765 // be free-identifier=? or bound-identifier=? to the given binding
1766 assert_eq!(varref.segments.len(),1);
1767 let varref_name = mtwt::resolve(varref.segments[0].identifier);
1768 let varref_marks = mtwt::marksof(varref.segments[0]
1772 if !(varref_name==binding_name) {
1773 println!("uh oh, should match but doesn't:");
1774 print_hygiene_debug_info();
1776 assert_eq!(varref_name,binding_name);
1777 if bound_ident_check {
1778 // we're checking bound-identifier=?, and the marks
1779 // should be the same, too:
1780 assert_eq!(varref_marks,binding_marks.clone());
1783 let varref_name = mtwt::resolve(varref.segments[0].identifier);
1784 let fail = (varref.segments.len() == 1)
1785 && (varref_name == binding_name);
1788 println!("failure on test {}",test_idx);
1789 println!("text of test case: \"{}\"", teststr);
1791 println!("uh oh, matches but shouldn't:");
1792 print_hygiene_debug_info();
1801 fn fmt_in_macro_used_inside_module_macro() {
1802 let crate_str = "macro_rules! fmt_wrap(($b:expr)=>($b.to_string()));
1803 macro_rules! foo_module (() => (mod generated { fn a() { let xx = 147; fmt_wrap!(xx);}}));
1806 let cr = expand_crate_str(crate_str);
1807 // find the xx binding
1808 let bindings = crate_bindings(&cr);
1809 let cxbinds: Vec<&ast::Ident> =
1810 bindings.iter().filter(|b| b.name.as_str() == "xx").collect();
1811 let cxbinds: &[&ast::Ident] = &cxbinds[..];
1812 let cxbind = match (cxbinds.len(), cxbinds.get(0)) {
1814 _ => panic!("expected just one binding for ext_cx")
1816 let resolved_binding = mtwt::resolve(*cxbind);
1817 let varrefs = crate_varrefs(&cr);
1819 // the xx binding should bind all of the xx varrefs:
1820 for (idx,v) in varrefs.iter().filter(|p| {
1821 p.segments.len() == 1
1822 && p.segments[0].identifier.name.as_str() == "xx"
1824 if mtwt::resolve(v.segments[0].identifier) != resolved_binding {
1825 println!("uh oh, xx binding didn't match xx varref:");
1826 println!("this is xx varref \\# {}", idx);
1827 println!("binding: {}", cxbind);
1828 println!("resolves to: {}", resolved_binding);
1829 println!("varref: {}", v.segments[0].identifier);
1830 println!("resolves to: {}",
1831 mtwt::resolve(v.segments[0].identifier));
1832 mtwt::with_sctable(|x| mtwt::display_sctable(x));
1834 assert_eq!(mtwt::resolve(v.segments[0].identifier),
1841 let pat = string_to_pat(
1842 "(a,Foo{x:c @ (b,9),y:Bar(4,d)})".to_string());
1843 let idents = pattern_bindings(&pat);
1844 assert_eq!(idents, strs_to_idents(vec!("a","c","b","d")));
1847 // test the list of identifier patterns gathered by the visitor. Note that
1848 // 'None' is listed as an identifier pattern because we don't yet know that
1849 // it's the name of a 0-ary variant, and that 'i' appears twice in succession.
1851 fn crate_bindings_test(){
1852 let the_crate = string_to_crate("fn main (a: i32) -> i32 {|b| {
1853 match 34 {None => 3, Some(i) | i => j, Foo{k:z,l:y} => \"banana\"}} }".to_string());
1854 let idents = crate_bindings(&the_crate);
1855 assert_eq!(idents, strs_to_idents(vec!("a","b","None","i","i","z","y")));
1858 // test the IdentRenamer directly
1860 fn ident_renamer_test () {
1861 let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
1862 let f_ident = token::str_to_ident("f");
1863 let x_ident = token::str_to_ident("x");
1864 let int_ident = token::str_to_ident("i32");
1865 let renames = vec!((x_ident,Name(16)));
1866 let mut renamer = IdentRenamer{renames: &renames};
1867 let renamed_crate = renamer.fold_crate(the_crate);
1868 let idents = crate_idents(&renamed_crate);
1869 let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
1870 assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16)]);
1873 // test the PatIdentRenamer; only PatIdents get renamed
1875 fn pat_ident_renamer_test () {
1876 let the_crate = string_to_crate("fn f(x: i32){let x = x; x}".to_string());
1877 let f_ident = token::str_to_ident("f");
1878 let x_ident = token::str_to_ident("x");
1879 let int_ident = token::str_to_ident("i32");
1880 let renames = vec!((x_ident,Name(16)));
1881 let mut renamer = PatIdentRenamer{renames: &renames};
1882 let renamed_crate = renamer.fold_crate(the_crate);
1883 let idents = crate_idents(&renamed_crate);
1884 let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect();
1885 let x_name = x_ident.name;
1886 assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name]);