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