2012-12-03 18:48:01 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2013-02-25 13:11:21 -06:00
|
|
|
use ast::{blk_, attribute_, attr_outer, meta_word};
|
2012-12-23 16:41:37 -06:00
|
|
|
use ast::{crate, expr_, expr_mac, mac_invoc_tt};
|
2013-03-26 15:38:07 -05:00
|
|
|
use ast::{item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
|
2012-12-23 16:41:37 -06:00
|
|
|
use ast;
|
2013-02-11 10:36:42 -06:00
|
|
|
use attr;
|
2013-02-25 13:11:21 -06:00
|
|
|
use codemap;
|
|
|
|
use codemap::{span, CallInfo, ExpandedFrom, NameAndSpan, spanned};
|
2012-09-04 13:37:29 -05:00
|
|
|
use ext::base::*;
|
2012-12-23 16:41:37 -06:00
|
|
|
use fold::*;
|
2013-02-25 13:11:21 -06:00
|
|
|
use parse;
|
2013-03-26 15:38:07 -05:00
|
|
|
use parse::{parse_item_from_source_str};
|
2011-08-05 15:06:11 -05:00
|
|
|
|
2013-03-01 15:30:06 -06:00
|
|
|
pub fn expand_expr(extsbox: @mut SyntaxEnv,
|
2013-03-12 15:00:50 -05:00
|
|
|
cx: @ext_ctxt,
|
2013-03-01 15:30:06 -06:00
|
|
|
e: &expr_,
|
|
|
|
s: span,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold,
|
|
|
|
orig: @fn(&expr_, span, @ast_fold) -> (expr_, span))
|
2013-01-29 16:41:40 -06:00
|
|
|
-> (expr_, span) {
|
2013-02-18 00:20:36 -06:00
|
|
|
match *e {
|
|
|
|
// expr_mac should really be expr_ext or something; it's the
|
|
|
|
// entry-point for all syntax extensions.
|
|
|
|
expr_mac(ref mac) => {
|
2012-12-04 12:50:00 -06:00
|
|
|
match (*mac).node {
|
2013-03-04 15:58:31 -06:00
|
|
|
// Token-tree macros:
|
2013-02-18 00:20:36 -06:00
|
|
|
mac_invoc_tt(pth, ref tts) => {
|
2013-03-04 15:58:31 -06:00
|
|
|
if (pth.idents.len() > 1u) {
|
|
|
|
cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!("expected macro name without module \
|
2013-03-04 18:50:52 -06:00
|
|
|
separators"));
|
2013-03-04 15:58:31 -06:00
|
|
|
}
|
2013-02-18 00:20:36 -06:00
|
|
|
/* using idents and token::special_idents would make the
|
|
|
|
the macro names be hygienic */
|
|
|
|
let extname = cx.parse_sess().interner.get(pth.idents[0]);
|
2013-02-27 13:03:21 -06:00
|
|
|
// leaving explicit deref here to highlight unbox op:
|
|
|
|
match (*extsbox).find(&extname) {
|
2013-02-18 00:20:36 -06:00
|
|
|
None => {
|
|
|
|
cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!("macro undefined: '%s'", *extname))
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
2013-02-27 13:03:21 -06:00
|
|
|
Some(@SE(NormalTT(SyntaxExpanderTT{
|
2013-02-18 00:20:36 -06:00
|
|
|
expander: exp,
|
|
|
|
span: exp_sp
|
2013-02-27 13:03:21 -06:00
|
|
|
}))) => {
|
2013-02-18 00:20:36 -06:00
|
|
|
cx.bt_push(ExpandedFrom(CallInfo {
|
|
|
|
call_site: s,
|
|
|
|
callee: NameAndSpan {
|
2013-02-24 23:27:51 -06:00
|
|
|
name: copy *extname,
|
2013-02-18 00:20:36 -06:00
|
|
|
span: exp_sp,
|
|
|
|
},
|
|
|
|
}));
|
|
|
|
|
|
|
|
let expanded = match exp(cx, mac.span, *tts) {
|
|
|
|
MRExpr(e) => e,
|
|
|
|
MRAny(expr_maker,_,_) => expr_maker(),
|
|
|
|
_ => {
|
|
|
|
cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!(
|
|
|
|
"non-expr macro in expr pos: %s",
|
|
|
|
*extname
|
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//keep going, outside-in
|
2013-02-24 23:27:51 -06:00
|
|
|
let fully_expanded =
|
|
|
|
copy fld.fold_expr(expanded).node;
|
2013-02-18 00:20:36 -06:00
|
|
|
cx.bt_pop();
|
|
|
|
|
|
|
|
(fully_expanded, s)
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!("'%s' is not a tt-style macro", *extname)
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
|
|
|
}
|
2013-02-18 00:20:36 -06:00
|
|
|
}
|
|
|
|
_ => orig(e, s, fld)
|
|
|
|
}
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
|
|
|
|
2012-07-27 19:42:32 -05:00
|
|
|
// This is a secondary mechanism for invoking syntax extensions on items:
|
2012-12-17 21:31:04 -06:00
|
|
|
// "decorator" attributes, such as #[auto_encode]. These are invoked by an
|
2012-07-27 19:42:32 -05:00
|
|
|
// attribute prefixing an item, and are interpreted by feeding the item
|
|
|
|
// through the named attribute _as a syntax extension_ and splicing in the
|
|
|
|
// resulting item vec into place in favour of the decorator. Note that
|
2013-01-22 18:45:27 -06:00
|
|
|
// these do _not_ work for macro extensions, just ItemDecorator ones.
|
2012-07-27 19:42:32 -05:00
|
|
|
//
|
|
|
|
// NB: there is some redundancy between this and expand_item, below, and
|
|
|
|
// they might benefit from some amount of semantic and language-UI merger.
|
2013-03-01 15:30:06 -06:00
|
|
|
pub fn expand_mod_items(extsbox: @mut SyntaxEnv,
|
2013-03-12 15:00:50 -05:00
|
|
|
cx: @ext_ctxt,
|
2013-03-01 15:30:06 -06:00
|
|
|
module_: &ast::_mod,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold,
|
|
|
|
orig: @fn(&ast::_mod, @ast_fold) -> ast::_mod)
|
2013-01-29 16:41:40 -06:00
|
|
|
-> ast::_mod {
|
2013-03-15 14:24:24 -05:00
|
|
|
|
2012-03-02 16:36:22 -06:00
|
|
|
// Fold the contents first:
|
2012-07-31 18:38:41 -05:00
|
|
|
let module_ = orig(module_, fld);
|
2012-03-02 16:36:22 -06:00
|
|
|
|
|
|
|
// For each item, look through the attributes. If any of them are
|
|
|
|
// decorated with "item decorators", then use that function to transform
|
|
|
|
// the item into a new set of items.
|
2012-07-31 18:38:41 -05:00
|
|
|
let new_items = do vec::flat_map(module_.items) |item| {
|
2012-09-28 00:20:47 -05:00
|
|
|
do vec::foldr(item.attrs, ~[*item]) |attr, items| {
|
2013-02-11 10:36:42 -06:00
|
|
|
let mname = attr::get_attr_name(attr);
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
match (*extsbox).find(&mname) {
|
|
|
|
Some(@SE(ItemDecorator(dec_fn))) => {
|
2013-02-21 02:16:31 -06:00
|
|
|
cx.bt_push(ExpandedFrom(CallInfo {
|
|
|
|
call_site: attr.span,
|
|
|
|
callee: NameAndSpan {
|
|
|
|
name: /*bad*/ copy *mname,
|
|
|
|
span: None
|
|
|
|
}
|
|
|
|
}));
|
2012-12-12 12:44:01 -06:00
|
|
|
let r = dec_fn(cx, attr.span, attr.node.value, items);
|
|
|
|
cx.bt_pop();
|
|
|
|
r
|
2013-02-26 12:15:29 -06:00
|
|
|
},
|
|
|
|
_ => items,
|
2012-03-02 16:36:22 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-01-15 18:05:20 -06:00
|
|
|
ast::_mod { items: new_items, ..module_ }
|
2012-03-02 16:36:22 -06:00
|
|
|
}
|
|
|
|
|
2012-07-27 13:19:21 -05:00
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
// eval $e with a new exts frame:
|
|
|
|
macro_rules! with_exts_frame (
|
|
|
|
($extsboxexpr:expr,$e:expr) =>
|
|
|
|
({let extsbox = $extsboxexpr;
|
|
|
|
let oldexts = *extsbox;
|
|
|
|
*extsbox = oldexts.push_frame();
|
|
|
|
let result = $e;
|
|
|
|
*extsbox = oldexts;
|
|
|
|
result
|
|
|
|
})
|
|
|
|
)
|
|
|
|
|
2012-07-27 13:19:21 -05:00
|
|
|
// When we enter a module, record it, for the sake of `module!`
|
2013-02-26 12:15:29 -06:00
|
|
|
pub fn expand_item(extsbox: @mut SyntaxEnv,
|
2013-03-12 15:00:50 -05:00
|
|
|
cx: @ext_ctxt,
|
2013-03-01 15:30:06 -06:00
|
|
|
it: @ast::item,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold,
|
|
|
|
orig: @fn(@ast::item, @ast_fold) -> Option<@ast::item>)
|
2013-01-29 16:41:40 -06:00
|
|
|
-> Option<@ast::item> {
|
2013-02-26 12:15:29 -06:00
|
|
|
// need to do expansion first... it might turn out to be a module.
|
2012-08-06 14:34:08 -05:00
|
|
|
let maybe_it = match it.node {
|
2013-02-26 12:15:29 -06:00
|
|
|
ast::item_mac(*) => expand_item_mac(extsbox, cx, it, fld),
|
2012-08-20 14:23:37 -05:00
|
|
|
_ => Some(it)
|
2012-07-05 14:10:33 -05:00
|
|
|
};
|
2012-08-06 14:34:08 -05:00
|
|
|
match maybe_it {
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(it) => {
|
2013-02-26 12:15:29 -06:00
|
|
|
match it.node {
|
|
|
|
ast::item_mod(_) | ast::item_foreign_mod(_) => {
|
|
|
|
cx.mod_push(it.ident);
|
|
|
|
let result =
|
|
|
|
// don't push a macro scope for macro_escape:
|
|
|
|
if contains_macro_escape(it.attrs) {
|
|
|
|
orig(it,fld)
|
|
|
|
} else {
|
|
|
|
// otherwise, push a scope:
|
|
|
|
with_exts_frame!(extsbox,orig(it,fld))
|
|
|
|
};
|
|
|
|
cx.mod_pop();
|
|
|
|
result
|
|
|
|
}
|
|
|
|
_ => orig(it,fld)
|
|
|
|
}
|
2012-07-06 14:17:34 -05:00
|
|
|
}
|
2013-02-26 12:15:29 -06:00
|
|
|
None => None
|
2012-07-06 14:17:34 -05:00
|
|
|
}
|
2012-05-18 12:00:49 -05:00
|
|
|
}
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
// does this attribute list contain "macro_escape" ?
|
2013-05-02 17:33:33 -05:00
|
|
|
pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool {
|
|
|
|
attrs.any(|attr| "macro_escape" == *attr::get_attr_name(attr))
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// this macro disables (one layer of) macro
|
|
|
|
// scoping, to allow a block to add macro bindings
|
|
|
|
// to its parent env
|
|
|
|
macro_rules! without_macro_scoping(
|
|
|
|
($extsexpr:expr,$exp:expr) =>
|
|
|
|
({
|
2013-02-26 17:48:00 -06:00
|
|
|
// only evaluate this once:
|
2013-02-26 12:15:29 -06:00
|
|
|
let exts = $extsexpr;
|
|
|
|
// capture the existing binding:
|
|
|
|
let existingBlockBinding =
|
|
|
|
match exts.find(&@~" block"){
|
|
|
|
Some(binding) => binding,
|
|
|
|
None => cx.bug("expected to find \" block\" binding")
|
|
|
|
};
|
|
|
|
// this prevents the block from limiting the macros' scope:
|
|
|
|
exts.insert(@~" block",@ScopeMacros(false));
|
|
|
|
let result = $exp;
|
|
|
|
// reset the block binding. Note that since the original
|
|
|
|
// one may have been inherited, this procedure may wind
|
|
|
|
// up introducing a block binding where one didn't exist
|
|
|
|
// before.
|
|
|
|
exts.insert(@~" block",existingBlockBinding);
|
|
|
|
result
|
|
|
|
}))
|
|
|
|
|
2012-07-27 13:19:21 -05:00
|
|
|
// Support for item-position macro invocations, exactly the same
|
|
|
|
// logic as for expression-position macro invocations.
|
2013-04-17 11:15:08 -05:00
|
|
|
pub fn expand_item_mac(extsbox: @mut SyntaxEnv,
|
|
|
|
cx: @ext_ctxt, it: @ast::item,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold)
|
|
|
|
-> Option<@ast::item> {
|
2012-12-12 14:25:40 -06:00
|
|
|
let (pth, tts) = match it.node {
|
2013-01-30 11:56:33 -06:00
|
|
|
item_mac(codemap::spanned { node: mac_invoc_tt(pth, ref tts), _}) => {
|
2013-02-24 23:27:51 -06:00
|
|
|
(pth, copy *tts)
|
2012-12-27 13:36:00 -06:00
|
|
|
}
|
2012-12-12 14:25:40 -06:00
|
|
|
_ => cx.span_bug(it.span, ~"invalid item macro invocation")
|
|
|
|
};
|
2012-11-17 06:41:36 -06:00
|
|
|
|
|
|
|
let extname = cx.parse_sess().interner.get(pth.idents[0]);
|
2013-02-26 12:15:29 -06:00
|
|
|
let expanded = match (*extsbox).find(&extname) {
|
2012-11-17 06:41:36 -06:00
|
|
|
None => cx.span_fatal(pth.span,
|
|
|
|
fmt!("macro undefined: '%s!'", *extname)),
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
Some(@SE(NormalTT(ref expand))) => {
|
2012-11-08 22:12:45 -06:00
|
|
|
if it.ident != parse::token::special_idents::invalid {
|
|
|
|
cx.span_fatal(pth.span,
|
|
|
|
fmt!("macro %s! expects no ident argument, \
|
|
|
|
given '%s'", *extname,
|
|
|
|
*cx.parse_sess().interner.get(it.ident)));
|
|
|
|
}
|
2013-02-21 02:16:31 -06:00
|
|
|
cx.bt_push(ExpandedFrom(CallInfo {
|
|
|
|
call_site: it.span,
|
|
|
|
callee: NameAndSpan {
|
2013-02-24 23:27:51 -06:00
|
|
|
name: copy *extname,
|
|
|
|
span: expand.span
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
|
|
|
}));
|
2012-12-06 18:19:05 -06:00
|
|
|
((*expand).expander)(cx, it.span, tts)
|
2012-11-17 06:41:36 -06:00
|
|
|
}
|
2013-02-26 12:15:29 -06:00
|
|
|
Some(@SE(IdentTT(ref expand))) => {
|
2012-11-08 22:12:45 -06:00
|
|
|
if it.ident == parse::token::special_idents::invalid {
|
|
|
|
cx.span_fatal(pth.span,
|
|
|
|
fmt!("macro %s! expects an ident argument",
|
|
|
|
*extname));
|
|
|
|
}
|
2013-02-21 02:16:31 -06:00
|
|
|
cx.bt_push(ExpandedFrom(CallInfo {
|
|
|
|
call_site: it.span,
|
|
|
|
callee: NameAndSpan {
|
2013-02-24 23:27:51 -06:00
|
|
|
name: copy *extname,
|
|
|
|
span: expand.span
|
2013-02-21 02:16:31 -06:00
|
|
|
}
|
|
|
|
}));
|
2012-12-06 18:19:05 -06:00
|
|
|
((*expand).expander)(cx, it.span, it.ident, tts)
|
2012-11-17 06:41:36 -06:00
|
|
|
}
|
|
|
|
_ => cx.span_fatal(
|
|
|
|
it.span, fmt!("%s! is not legal in item position", *extname))
|
|
|
|
};
|
2012-11-08 22:12:45 -06:00
|
|
|
|
2012-11-17 06:41:36 -06:00
|
|
|
let maybe_it = match expanded {
|
2013-01-22 18:45:27 -06:00
|
|
|
MRItem(it) => fld.fold_item(it),
|
|
|
|
MRExpr(_) => cx.span_fatal(pth.span,
|
2012-11-17 06:41:36 -06:00
|
|
|
~"expr macro in item position: "
|
|
|
|
+ *extname),
|
2013-03-16 14:49:12 -05:00
|
|
|
MRAny(_, item_maker, _) => item_maker().chain(|i| {fld.fold_item(i)}),
|
2013-01-22 18:45:27 -06:00
|
|
|
MRDef(ref mdef) => {
|
2013-02-26 12:15:29 -06:00
|
|
|
extsbox.insert(@/*bad*/ copy mdef.name, @SE((*mdef).ext));
|
2012-11-17 06:41:36 -06:00
|
|
|
None
|
|
|
|
}
|
|
|
|
};
|
|
|
|
cx.bt_pop();
|
|
|
|
return maybe_it;
|
2012-07-05 14:10:33 -05:00
|
|
|
}
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
// expand a stmt
|
2013-03-01 15:30:06 -06:00
|
|
|
pub fn expand_stmt(extsbox: @mut SyntaxEnv,
|
2013-03-12 15:00:50 -05:00
|
|
|
cx: @ext_ctxt,
|
2013-03-01 15:30:06 -06:00
|
|
|
s: &stmt_,
|
|
|
|
sp: span,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold,
|
|
|
|
orig: @fn(&stmt_, span, @ast_fold) -> (stmt_, span))
|
2013-01-29 16:41:40 -06:00
|
|
|
-> (stmt_, span) {
|
2013-02-18 00:20:36 -06:00
|
|
|
let (mac, pth, tts, semi) = match *s {
|
2012-12-12 14:25:40 -06:00
|
|
|
stmt_mac(ref mac, semi) => {
|
2013-02-18 00:20:36 -06:00
|
|
|
match mac.node {
|
2013-02-24 23:27:51 -06:00
|
|
|
mac_invoc_tt(pth, ref tts) => {
|
|
|
|
(copy *mac, pth, copy *tts, semi)
|
|
|
|
}
|
2012-12-12 14:25:40 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => return orig(s, sp, fld)
|
|
|
|
};
|
2013-03-04 15:58:31 -06:00
|
|
|
if (pth.idents.len() > 1u) {
|
|
|
|
cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!("expected macro name without module \
|
2013-03-04 18:50:52 -06:00
|
|
|
separators"));
|
2013-03-04 15:58:31 -06:00
|
|
|
}
|
2012-11-17 06:41:36 -06:00
|
|
|
let extname = cx.parse_sess().interner.get(pth.idents[0]);
|
2013-02-26 12:15:29 -06:00
|
|
|
let (fully_expanded, sp) = match (*extsbox).find(&extname) {
|
2012-11-17 06:41:36 -06:00
|
|
|
None =>
|
|
|
|
cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)),
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
Some(@SE(NormalTT(
|
|
|
|
SyntaxExpanderTT{expander: exp, span: exp_sp}))) => {
|
2013-02-21 02:16:31 -06:00
|
|
|
cx.bt_push(ExpandedFrom(CallInfo {
|
|
|
|
call_site: sp,
|
2013-02-24 23:27:51 -06:00
|
|
|
callee: NameAndSpan { name: copy *extname, span: exp_sp }
|
2013-02-21 02:16:31 -06:00
|
|
|
}));
|
2012-11-17 06:41:36 -06:00
|
|
|
let expanded = match exp(cx, mac.span, tts) {
|
2013-01-22 18:45:27 -06:00
|
|
|
MRExpr(e) =>
|
2013-01-30 11:56:33 -06:00
|
|
|
@codemap::spanned { node: stmt_expr(e, cx.next_id()),
|
2012-12-27 13:36:00 -06:00
|
|
|
span: e.span},
|
2013-01-22 18:45:27 -06:00
|
|
|
MRAny(_,_,stmt_mkr) => stmt_mkr(),
|
2012-11-17 06:41:36 -06:00
|
|
|
_ => cx.span_fatal(
|
|
|
|
pth.span,
|
|
|
|
fmt!("non-stmt macro in stmt pos: %s", *extname))
|
|
|
|
};
|
|
|
|
|
|
|
|
//keep going, outside-in
|
2013-02-24 23:27:51 -06:00
|
|
|
let fully_expanded = copy fld.fold_stmt(expanded).node;
|
2012-11-17 06:41:36 -06:00
|
|
|
cx.bt_pop();
|
|
|
|
|
2012-11-21 17:49:42 -06:00
|
|
|
(fully_expanded, sp)
|
2012-11-19 19:31:22 -06:00
|
|
|
}
|
2012-11-18 23:30:48 -06:00
|
|
|
|
2012-11-17 06:41:36 -06:00
|
|
|
_ => {
|
|
|
|
cx.span_fatal(pth.span,
|
2012-11-21 17:49:42 -06:00
|
|
|
fmt!("'%s' is not a tt-style macro", *extname))
|
2012-11-17 06:41:36 -06:00
|
|
|
}
|
2012-11-21 17:49:42 -06:00
|
|
|
};
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
(match fully_expanded {
|
2012-11-21 17:49:42 -06:00
|
|
|
stmt_expr(e, stmt_id) if semi => stmt_semi(e, stmt_id),
|
|
|
|
_ => { fully_expanded } /* might already have a semi */
|
|
|
|
}, sp)
|
2012-11-17 06:41:36 -06:00
|
|
|
|
2012-11-19 19:31:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
|
2013-03-01 15:30:06 -06:00
|
|
|
pub fn expand_block(extsbox: @mut SyntaxEnv,
|
2013-03-12 15:00:50 -05:00
|
|
|
cx: @ext_ctxt,
|
2013-03-01 15:30:06 -06:00
|
|
|
blk: &blk_,
|
|
|
|
sp: span,
|
2013-03-12 15:00:50 -05:00
|
|
|
fld: @ast_fold,
|
|
|
|
orig: @fn(&blk_, span, @ast_fold) -> (blk_, span))
|
2013-03-01 15:30:06 -06:00
|
|
|
-> (blk_, span) {
|
2013-02-26 12:15:29 -06:00
|
|
|
match (*extsbox).find(&@~" block") {
|
|
|
|
// no scope limit on macros in this block, no need
|
|
|
|
// to push an exts frame:
|
|
|
|
Some(@ScopeMacros(false)) => {
|
|
|
|
orig (blk,sp,fld)
|
|
|
|
},
|
|
|
|
// this block should limit the scope of its macros:
|
|
|
|
Some(@ScopeMacros(true)) => {
|
|
|
|
// see note below about treatment of exts table
|
|
|
|
with_exts_frame!(extsbox,orig(blk,sp,fld))
|
|
|
|
},
|
|
|
|
_ => cx.span_bug(sp,
|
|
|
|
~"expected ScopeMacros binding for \" block\"")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-12 15:00:50 -05:00
|
|
|
pub fn new_span(cx: @ext_ctxt, sp: span) -> span {
|
2012-02-04 19:37:24 -06:00
|
|
|
/* this discards information in the case of macro-defining macros */
|
2012-11-12 17:12:20 -06:00
|
|
|
return span {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()};
|
2012-02-04 19:37:24 -06:00
|
|
|
}
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
// FIXME (#2247): this is a moderately bad kludge to inject some macros into
|
|
|
|
// the default compilation environment. It would be much nicer to use
|
|
|
|
// a mechanism like syntax_quote to ensure hygiene.
|
2011-12-20 15:38:10 -06:00
|
|
|
|
2013-01-29 16:41:40 -06:00
|
|
|
pub fn core_macros() -> ~str {
|
2012-08-01 19:30:05 -05:00
|
|
|
return
|
2013-02-26 12:15:29 -06:00
|
|
|
~"pub mod macros {
|
2012-09-07 18:58:27 -05:00
|
|
|
macro_rules! ignore (($($x:tt)*) => (()))
|
2012-11-26 21:34:01 -06:00
|
|
|
|
2013-03-07 20:45:22 -06:00
|
|
|
macro_rules! error (
|
|
|
|
($arg:expr) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(1u32, fmt!( \"%?\", $arg ))
|
2013-03-07 20:45:22 -06:00
|
|
|
);
|
|
|
|
($( $arg:expr ),+) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(1u32, fmt!( $($arg),+ ))
|
2013-03-07 20:45:22 -06:00
|
|
|
)
|
|
|
|
)
|
2013-04-23 15:30:58 -05:00
|
|
|
|
2013-03-07 20:45:22 -06:00
|
|
|
macro_rules! warn (
|
|
|
|
($arg:expr) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(2u32, fmt!( \"%?\", $arg ))
|
2013-03-07 20:45:22 -06:00
|
|
|
);
|
|
|
|
($( $arg:expr ),+) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(2u32, fmt!( $($arg),+ ))
|
2013-03-07 20:45:22 -06:00
|
|
|
)
|
|
|
|
)
|
2013-04-23 15:30:58 -05:00
|
|
|
|
2013-03-07 20:45:22 -06:00
|
|
|
macro_rules! info (
|
|
|
|
($arg:expr) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(3u32, fmt!( \"%?\", $arg ))
|
2013-03-07 20:45:22 -06:00
|
|
|
);
|
|
|
|
($( $arg:expr ),+) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(3u32, fmt!( $($arg),+ ))
|
2013-03-07 20:45:22 -06:00
|
|
|
)
|
|
|
|
)
|
2013-04-23 15:30:58 -05:00
|
|
|
|
2013-03-07 20:45:22 -06:00
|
|
|
macro_rules! debug (
|
|
|
|
($arg:expr) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(4u32, fmt!( \"%?\", $arg ))
|
2013-03-07 20:45:22 -06:00
|
|
|
);
|
|
|
|
($( $arg:expr ),+) => (
|
2013-03-08 20:32:03 -06:00
|
|
|
__log(4u32, fmt!( $($arg),+ ))
|
2013-03-07 20:45:22 -06:00
|
|
|
)
|
|
|
|
)
|
2012-11-27 20:05:20 -06:00
|
|
|
|
2013-01-31 20:24:09 -06:00
|
|
|
macro_rules! fail(
|
|
|
|
() => (
|
2013-04-23 15:30:58 -05:00
|
|
|
fail!(\"explicit failure\")
|
|
|
|
);
|
|
|
|
($msg:expr) => (
|
|
|
|
::core::sys::FailWithCause::fail_with($msg, file!(), line!())
|
|
|
|
);
|
|
|
|
($( $arg:expr ),+) => (
|
|
|
|
::core::sys::FailWithCause::fail_with(fmt!( $($arg),+ ), file!(), line!())
|
2013-01-31 20:24:09 -06:00
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2013-03-22 15:11:03 -05:00
|
|
|
macro_rules! assert(
|
|
|
|
($cond:expr) => {
|
|
|
|
if !$cond {
|
2013-04-23 15:30:58 -05:00
|
|
|
::core::sys::FailWithCause::fail_with(
|
|
|
|
~\"assertion failed: \" + stringify!($cond), file!(), line!())
|
2013-01-22 18:00:07 -06:00
|
|
|
}
|
2013-03-19 13:05:20 -05:00
|
|
|
};
|
|
|
|
($cond:expr, $msg:expr) => {
|
|
|
|
if !$cond {
|
2013-04-23 15:30:58 -05:00
|
|
|
::core::sys::FailWithCause::fail_with($msg, file!(), line!())
|
|
|
|
}
|
|
|
|
};
|
|
|
|
($cond:expr, $( $arg:expr ),+) => {
|
|
|
|
if !$cond {
|
|
|
|
::core::sys::FailWithCause::fail_with(fmt!( $($arg),+ ), file!(), line!())
|
2013-03-19 13:05:20 -05:00
|
|
|
}
|
2013-01-22 18:00:07 -06:00
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2013-03-13 14:10:32 -05:00
|
|
|
macro_rules! assert_eq (
|
2013-04-23 15:30:58 -05:00
|
|
|
($given:expr , $expected:expr) => (
|
|
|
|
{
|
|
|
|
let given_val = $given;
|
|
|
|
let expected_val = $expected;
|
|
|
|
// check both directions of equality....
|
|
|
|
if !((given_val == expected_val) && (expected_val == given_val)) {
|
2013-05-09 06:52:07 -05:00
|
|
|
fail!(\"left: %? does not equal right: %?\", given_val, expected_val);
|
2013-04-23 15:30:58 -05:00
|
|
|
}
|
2013-05-06 06:51:48 -05:00
|
|
|
}
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
macro_rules! assert_approx_eq (
|
|
|
|
($given:expr , $expected:expr) => (
|
|
|
|
{
|
|
|
|
use core::cmp::ApproxEq;
|
|
|
|
|
|
|
|
let given_val = $given;
|
|
|
|
let expected_val = $expected;
|
|
|
|
// check both directions of equality....
|
|
|
|
if !(
|
|
|
|
given_val.approx_eq(&expected_val) &&
|
|
|
|
expected_val.approx_eq(&given_val)
|
|
|
|
) {
|
|
|
|
fail!(\"left: %? does not approximately equal right: %?\",
|
|
|
|
given_val, expected_val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
($given:expr , $expected:expr , $epsilon:expr) => (
|
|
|
|
{
|
|
|
|
use core::cmp::ApproxEq;
|
|
|
|
|
|
|
|
let given_val = $given;
|
|
|
|
let expected_val = $expected;
|
|
|
|
let epsilon_val = $epsilon;
|
|
|
|
// check both directions of equality....
|
|
|
|
if !(
|
|
|
|
given_val.approx_eq_eps(&expected_val, &epsilon_val) &&
|
|
|
|
expected_val.approx_eq_eps(&given_val, &epsilon_val)
|
|
|
|
) {
|
|
|
|
fail!(\"left: %? does not approximately equal right: %? with epsilon: %?\",
|
|
|
|
given_val, expected_val, epsilon_val);
|
|
|
|
}
|
2013-04-23 15:30:58 -05:00
|
|
|
}
|
|
|
|
)
|
|
|
|
)
|
2013-03-13 14:10:32 -05:00
|
|
|
|
2012-12-14 13:52:11 -06:00
|
|
|
macro_rules! condition (
|
|
|
|
|
2013-05-06 12:05:36 -05:00
|
|
|
{ pub $c:ident: $in:ty -> $out:ty; } => {
|
|
|
|
|
|
|
|
pub mod $c {
|
|
|
|
fn key(_x: @::core::condition::Handler<$in,$out>) { }
|
|
|
|
|
|
|
|
pub static cond :
|
|
|
|
::core::condition::Condition<'static,$in,$out> =
|
|
|
|
::core::condition::Condition {
|
|
|
|
name: stringify!($c),
|
|
|
|
key: key
|
|
|
|
};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-12-14 13:52:11 -06:00
|
|
|
{ $c:ident: $in:ty -> $out:ty; } => {
|
|
|
|
|
2013-05-06 12:05:36 -05:00
|
|
|
// FIXME (#6009): remove mod's `pub` below once variant above lands.
|
2013-04-22 16:43:02 -05:00
|
|
|
pub mod $c {
|
2012-12-27 19:53:04 -06:00
|
|
|
fn key(_x: @::core::condition::Handler<$in,$out>) { }
|
2012-12-14 13:52:11 -06:00
|
|
|
|
2013-03-22 16:00:15 -05:00
|
|
|
pub static cond :
|
2013-03-22 17:52:50 -05:00
|
|
|
::core::condition::Condition<'static,$in,$out> =
|
2012-12-27 19:53:04 -06:00
|
|
|
::core::condition::Condition {
|
2013-02-26 13:34:00 -06:00
|
|
|
name: stringify!($c),
|
|
|
|
key: key
|
|
|
|
};
|
2012-12-14 13:52:11 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2013-05-08 10:38:39 -05:00
|
|
|
//
|
|
|
|
// A scheme-style conditional that helps to improve code clarity in some instances when
|
|
|
|
// the `if`, `else if`, and `else` keywords obscure predicates undesirably.
|
|
|
|
//
|
|
|
|
// # Example
|
|
|
|
//
|
|
|
|
// ~~~
|
|
|
|
// let clamped =
|
|
|
|
// if x > mx { mx }
|
|
|
|
// else if x < mn { mn }
|
|
|
|
// else { x };
|
|
|
|
// ~~~
|
|
|
|
//
|
|
|
|
// Using `cond!`, the above could be written as:
|
|
|
|
//
|
|
|
|
// ~~~
|
|
|
|
// let clamped = cond!(
|
|
|
|
// | x > mx { mx }
|
|
|
|
// | x < mn { mn }
|
|
|
|
// _ { x }
|
|
|
|
// );
|
|
|
|
// ~~~
|
|
|
|
//
|
|
|
|
// The optional default case is denoted by `_`.
|
|
|
|
//
|
|
|
|
macro_rules! cond (
|
|
|
|
($( | $pred:expr $body:block)+ _ $default:block ) => (
|
|
|
|
$(if $pred $body else)+
|
|
|
|
$default
|
|
|
|
);
|
|
|
|
// for if the default case was ommitted
|
|
|
|
( $( | $pred:expr $body:block )+ ) => (
|
|
|
|
$(if $pred $body)else+
|
|
|
|
);
|
|
|
|
)
|
2011-12-20 15:38:10 -06:00
|
|
|
}";
|
|
|
|
}
|
|
|
|
|
2013-02-21 02:16:31 -06:00
|
|
|
pub fn expand_crate(parse_sess: @mut parse::ParseSess,
|
2013-01-29 16:41:40 -06:00
|
|
|
cfg: ast::crate_cfg, c: @crate) -> @crate {
|
2013-02-26 12:15:29 -06:00
|
|
|
// adding *another* layer of indirection here so that the block
|
|
|
|
// visitor can swap out one exts table for another for the duration
|
|
|
|
// of the block. The cleaner alternative would be to thread the
|
|
|
|
// exts table through the fold, but that would require updating
|
|
|
|
// every method/element of AstFoldFns in fold.rs.
|
|
|
|
let extsbox = @mut syntax_expander_table();
|
2011-07-27 07:19:39 -05:00
|
|
|
let afp = default_ast_fold();
|
2013-03-12 15:00:50 -05:00
|
|
|
let cx: @ext_ctxt = mk_ctxt(parse_sess, copy cfg);
|
2013-01-08 16:00:45 -06:00
|
|
|
let f_pre = @AstFoldFns {
|
2013-02-26 12:15:29 -06:00
|
|
|
fold_expr: |expr,span,recur|
|
|
|
|
expand_expr(extsbox, cx, expr, span, recur, afp.fold_expr),
|
|
|
|
fold_mod: |modd,recur|
|
|
|
|
expand_mod_items(extsbox, cx, modd, recur, afp.fold_mod),
|
|
|
|
fold_item: |item,recur|
|
|
|
|
expand_item(extsbox, cx, item, recur, afp.fold_item),
|
|
|
|
fold_stmt: |stmt,span,recur|
|
|
|
|
expand_stmt(extsbox, cx, stmt, span, recur, afp.fold_stmt),
|
|
|
|
fold_block: |blk,span,recur|
|
2013-02-27 13:03:21 -06:00
|
|
|
expand_block(extsbox, cx, blk, span, recur, afp.fold_block),
|
2013-01-08 16:00:45 -06:00
|
|
|
new_span: |a| new_span(cx, a),
|
|
|
|
.. *afp};
|
2011-07-27 07:19:39 -05:00
|
|
|
let f = make_fold(f_pre);
|
2013-02-26 12:15:29 -06:00
|
|
|
// add a bunch of macros as though they were placed at the
|
|
|
|
// head of the program (ick).
|
2013-02-27 13:03:21 -06:00
|
|
|
let attrs = ~[
|
|
|
|
spanned {
|
|
|
|
span: codemap::dummy_sp(),
|
|
|
|
node: attribute_ {
|
|
|
|
style: attr_outer,
|
|
|
|
value: @spanned {
|
|
|
|
node: meta_word(@~"macro_escape"),
|
|
|
|
span: codemap::dummy_sp(),
|
|
|
|
},
|
|
|
|
is_sugared_doc: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
];
|
2013-02-26 12:15:29 -06:00
|
|
|
|
|
|
|
let cm = match parse_item_from_source_str(~"<core-macros>",
|
|
|
|
@core_macros(),
|
2013-02-27 13:03:21 -06:00
|
|
|
copy cfg,
|
|
|
|
attrs,
|
2013-02-26 12:15:29 -06:00
|
|
|
parse_sess) {
|
|
|
|
Some(item) => item,
|
|
|
|
None => cx.bug(~"expected core macros to parse correctly")
|
|
|
|
};
|
2011-12-20 15:38:10 -06:00
|
|
|
// This is run for its side-effects on the expander env,
|
|
|
|
// as it registers all the core macros as expanders.
|
2013-02-26 12:15:29 -06:00
|
|
|
f.fold_item(cm);
|
2011-12-20 15:38:10 -06:00
|
|
|
|
2013-02-18 00:20:36 -06:00
|
|
|
@f.fold_crate(&*c)
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
2013-02-26 12:15:29 -06:00
|
|
|
|
2013-04-03 12:28:14 -05:00
|
|
|
// given a function from paths to paths, produce
|
|
|
|
// an ast_fold that applies that function:
|
|
|
|
fn fun_to_path_folder(f: @fn(&ast::Path)->ast::Path) -> @ast_fold{
|
|
|
|
let afp = default_ast_fold();
|
|
|
|
let f_pre = @AstFoldFns{
|
|
|
|
fold_path : |p, _| f(p),
|
|
|
|
.. *afp
|
|
|
|
};
|
|
|
|
make_fold(f_pre)
|
|
|
|
}
|
|
|
|
/* going to have to figure out whether the table is passed in or
|
|
|
|
extracted from TLS...
|
|
|
|
// update the ctxts in a path to get a rename node
|
|
|
|
fn ctxt_update_rename(from: ast::Name,
|
|
|
|
fromctx: ast::SyntaxContext, to: ast::Name) ->
|
|
|
|
@fn(&ast::Path,@ast_fold)->ast::Path {
|
|
|
|
return |p:&ast::Path,_|
|
|
|
|
ast::Path {span: p.span,
|
|
|
|
global: p.global,
|
|
|
|
idents: p.idents.map(|id|
|
|
|
|
ast::ident{
|
|
|
|
repr: id.repr,
|
|
|
|
// this needs to be cached....
|
|
|
|
ctxt: Some(@ast::Rename(from,fromctx,
|
|
|
|
to,id.ctxt))
|
|
|
|
}),
|
|
|
|
rp: p.rp,
|
|
|
|
types: p.types};
|
|
|
|
}
|
|
|
|
|
|
|
|
// update the ctxts in a path to get a mark node
|
|
|
|
fn ctxt_update_mark(mark: uint) ->
|
|
|
|
@fn(&ast::Path,@ast_fold)->ast::Path {
|
|
|
|
return |p:&ast::Path,_|
|
|
|
|
ast::Path {span: p.span,
|
|
|
|
global: p.global,
|
|
|
|
idents: p.idents.map(|id|
|
|
|
|
ast::ident{
|
|
|
|
repr: id.repr,
|
|
|
|
// this needs to be cached....
|
|
|
|
ctxt: Some(@ast::Mark(mark,id.ctxt))
|
|
|
|
}),
|
|
|
|
rp: p.rp,
|
|
|
|
types: p.types};
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
2013-02-26 12:15:29 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use super::*;
|
2013-02-25 13:11:21 -06:00
|
|
|
use ast;
|
|
|
|
use ast::{attribute_, attr_outer, meta_word};
|
|
|
|
use codemap;
|
|
|
|
use codemap::spanned;
|
|
|
|
use parse;
|
|
|
|
use core::option::{None, Some};
|
2013-02-26 12:15:29 -06:00
|
|
|
|
|
|
|
// make sure that fail! is present
|
|
|
|
#[test] fn fail_exists_test () {
|
2013-05-05 17:18:51 -05:00
|
|
|
let src = ~"fn main() { fail!(\"something appropriately gloomy\");}";
|
2013-02-26 12:15:29 -06:00
|
|
|
let sess = parse::new_parse_sess(None);
|
|
|
|
let crate_ast = parse::parse_crate_from_source_str(
|
|
|
|
~"<test>",
|
|
|
|
@src,
|
2013-05-12 15:50:57 -05:00
|
|
|
~[],sess);
|
|
|
|
expand_crate(sess,~[],crate_ast);
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// these following tests are quite fragile, in that they don't test what
|
|
|
|
// *kind* of failure occurs.
|
|
|
|
|
|
|
|
// make sure that macros can leave scope
|
|
|
|
#[should_fail]
|
|
|
|
#[test] fn macros_cant_escape_fns_test () {
|
|
|
|
let src = ~"fn bogus() {macro_rules! z (() => (3+4))}\
|
|
|
|
fn inty() -> int { z!() }";
|
|
|
|
let sess = parse::new_parse_sess(None);
|
|
|
|
let crate_ast = parse::parse_crate_from_source_str(
|
|
|
|
~"<test>",
|
|
|
|
@src,
|
2013-05-12 15:50:57 -05:00
|
|
|
~[],sess);
|
2013-02-26 12:15:29 -06:00
|
|
|
// should fail:
|
2013-05-12 15:50:57 -05:00
|
|
|
expand_crate(sess,~[],crate_ast);
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// make sure that macros can leave scope for modules
|
|
|
|
#[should_fail]
|
|
|
|
#[test] fn macros_cant_escape_mods_test () {
|
|
|
|
let src = ~"mod foo {macro_rules! z (() => (3+4))}\
|
|
|
|
fn inty() -> int { z!() }";
|
|
|
|
let sess = parse::new_parse_sess(None);
|
|
|
|
let crate_ast = parse::parse_crate_from_source_str(
|
|
|
|
~"<test>",
|
|
|
|
@src,
|
2013-05-12 15:50:57 -05:00
|
|
|
~[],sess);
|
2013-02-26 12:15:29 -06:00
|
|
|
// should fail:
|
2013-05-12 15:50:57 -05:00
|
|
|
expand_crate(sess,~[],crate_ast);
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// macro_escape modules shouldn't cause macros to leave scope
|
|
|
|
#[test] fn macros_can_escape_flattened_mods_test () {
|
|
|
|
let src = ~"#[macro_escape] mod foo {macro_rules! z (() => (3+4))}\
|
|
|
|
fn inty() -> int { z!() }";
|
|
|
|
let sess = parse::new_parse_sess(None);
|
|
|
|
let crate_ast = parse::parse_crate_from_source_str(
|
|
|
|
~"<test>",
|
|
|
|
@src,
|
2013-05-12 15:50:57 -05:00
|
|
|
~[], sess);
|
2013-02-26 12:15:29 -06:00
|
|
|
// should fail:
|
2013-05-12 15:50:57 -05:00
|
|
|
expand_crate(sess,~[],crate_ast);
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test] fn core_macros_must_parse () {
|
|
|
|
let src = ~"
|
|
|
|
pub mod macros {
|
|
|
|
macro_rules! ignore (($($x:tt)*) => (()))
|
|
|
|
|
|
|
|
macro_rules! error ( ($( $arg:expr ),+) => (
|
|
|
|
log(::core::error, fmt!( $($arg),+ )) ))
|
|
|
|
}";
|
|
|
|
let sess = parse::new_parse_sess(None);
|
|
|
|
let cfg = ~[];
|
|
|
|
let item_ast = parse::parse_item_from_source_str(
|
|
|
|
~"<test>",
|
|
|
|
@src,
|
|
|
|
cfg,~[make_dummy_attr (@~"macro_escape")],sess);
|
|
|
|
match item_ast {
|
|
|
|
Some(_) => (), // success
|
2013-05-05 17:18:51 -05:00
|
|
|
None => fail!("expected this to parse")
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test] fn test_contains_flatten (){
|
|
|
|
let attr1 = make_dummy_attr (@~"foo");
|
|
|
|
let attr2 = make_dummy_attr (@~"bar");
|
|
|
|
let escape_attr = make_dummy_attr (@~"macro_escape");
|
|
|
|
let attrs1 = ~[attr1, escape_attr, attr2];
|
2013-03-13 17:30:37 -05:00
|
|
|
assert_eq!(contains_macro_escape (attrs1),true);
|
2013-02-26 12:15:29 -06:00
|
|
|
let attrs2 = ~[attr1,attr2];
|
2013-03-13 17:30:37 -05:00
|
|
|
assert_eq!(contains_macro_escape (attrs2),false);
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// make a "meta_word" outer attribute with the given name
|
|
|
|
fn make_dummy_attr(s: @~str) -> ast::attribute {
|
2013-02-28 09:25:31 -06:00
|
|
|
spanned {
|
|
|
|
span:codemap::dummy_sp(),
|
|
|
|
node: attribute_ {
|
|
|
|
style: attr_outer,
|
|
|
|
value: @spanned {
|
|
|
|
node: meta_word(s),
|
|
|
|
span: codemap::dummy_sp(),
|
|
|
|
},
|
|
|
|
is_sugared_doc: false,
|
|
|
|
}
|
|
|
|
}
|
2013-02-26 12:15:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|