rust/src/libsyntax/ext/expand.rs
John Clements 08b6057538 Macros now leave scope
Macro scope is now delimited by function, block, and module boundaries,
except for modules that are marked with #[macro_escape], which allows
macros to escape.
2013-02-26 10:36:55 -08:00

589 lines
20 KiB
Rust

// 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.
use core::prelude::*;
use ast::{crate, expr_, expr_mac, mac_invoc_tt};
use ast::{tt_delim, tt_tok, item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
use ast;
use attr;
use codemap::{span, CallInfo, ExpandedFrom, NameAndSpan};
use ext::base::*;
use fold::*;
use parse::{parser, parse_item_from_source_str, new_parser_from_tts};
use core::option;
use core::vec;
use core::hashmap::LinearMap;
pub fn expand_expr(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
e: expr_, s: span, fld: ast_fold,
orig: fn@(expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span) {
return match e {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
expr_mac(ref mac) => {
match (*mac).node {
// Token-tree macros, these will be the only case when we're
// finished transitioning.
mac_invoc_tt(pth, ref tts) => {
assert (vec::len(pth.idents) == 1u);
/* using idents and token::special_idents would make the
the macro names be hygienic */
let extname = cx.parse_sess().interner.get(pth.idents[0]);
// leaving explicit deref here to highlight unbox op:
match (*extsbox).find(&extname) {
None => {
cx.span_fatal(pth.span,
fmt!("macro undefined: '%s'", *extname))
}
Some(@SE(NormalTT(SyntaxExpanderTT{expander: exp,
span: exp_sp}))) => {
cx.bt_push(ExpandedFrom(CallInfo{
call_site: s,
callee: NameAndSpan {
name: *extname, 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
let fully_expanded = fld.fold_expr(expanded).node;
cx.bt_pop();
(fully_expanded, s)
}
_ => {
cx.span_fatal(pth.span,
fmt!("'%s' is not a tt-style macro",
*extname))
}
}
}
}
}
_ => orig(e, s, fld)
};
}
// This is a secondary mechanism for invoking syntax extensions on items:
// "decorator" attributes, such as #[auto_encode]. These are invoked by an
// 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
// these do _not_ work for macro extensions, just ItemDecorator ones.
//
// NB: there is some redundancy between this and expand_item, below, and
// they might benefit from some amount of semantic and language-UI merger.
pub fn expand_mod_items(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
module_: ast::_mod, fld: ast_fold,
orig: fn@(ast::_mod, ast_fold) -> ast::_mod)
-> ast::_mod {
// Fold the contents first:
let module_ = orig(module_, fld);
// 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.
let new_items = do vec::flat_map(module_.items) |item| {
do vec::foldr(item.attrs, ~[*item]) |attr, items| {
let mname = attr::get_attr_name(attr);
match (*extsbox).find(&mname) {
Some(@SE(ItemDecorator(dec_fn))) => {
cx.bt_push(ExpandedFrom(CallInfo {
call_site: attr.span,
callee: NameAndSpan {
name: /*bad*/ copy *mname,
span: None
}
}));
let r = dec_fn(cx, attr.span, attr.node.value, items);
cx.bt_pop();
r
},
_ => items,
}
}
};
ast::_mod { items: new_items, ..module_ }
}
// 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
})
)
// When we enter a module, record it, for the sake of `module!`
pub fn expand_item(extsbox: @mut SyntaxEnv,
cx: ext_ctxt, &&it: @ast::item, fld: ast_fold,
orig: fn@(&&v: @ast::item, ast_fold) -> Option<@ast::item>)
-> Option<@ast::item> {
// need to do expansion first... it might turn out to be a module.
let maybe_it = match it.node {
ast::item_mac(*) => expand_item_mac(extsbox, cx, it, fld),
_ => Some(it)
};
match maybe_it {
Some(it) => {
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)
}
}
None => None
}
}
// does this attribute list contain "macro_escape" ?
fn contains_macro_escape (attrs: &[ast::attribute]) -> bool{
let mut accum = false;
do attrs.each |attr| {
let mname = attr::get_attr_name(attr);
if (mname == @~"macro_escape") {
accum = true;
false
} else {
true
}
}
accum
}
// 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) =>
({
// only evaluaate this once:
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
}))
// Support for item-position macro invocations, exactly the same
// logic as for expression-position macro invocations.
pub fn expand_item_mac(+extsbox: @mut SyntaxEnv,
cx: ext_ctxt, &&it: @ast::item,
fld: ast_fold) -> Option<@ast::item> {
let (pth, tts) = match it.node {
item_mac(codemap::spanned { node: mac_invoc_tt(pth, ref tts), _}) => {
(pth, (*tts))
}
_ => cx.span_bug(it.span, ~"invalid item macro invocation")
};
let extname = cx.parse_sess().interner.get(pth.idents[0]);
let expanded = match (*extsbox).find(&extname) {
None => cx.span_fatal(pth.span,
fmt!("macro undefined: '%s!'", *extname)),
Some(@SE(NormalTT(ref expand))) => {
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)));
}
cx.bt_push(ExpandedFrom(CallInfo {
call_site: it.span,
callee: NameAndSpan {
name: *extname,
span: (*expand).span
}
}));
((*expand).expander)(cx, it.span, tts)
}
Some(@SE(IdentTT(ref expand))) => {
if it.ident == parse::token::special_idents::invalid {
cx.span_fatal(pth.span,
fmt!("macro %s! expects an ident argument",
*extname));
}
cx.bt_push(ExpandedFrom(CallInfo {
call_site: it.span,
callee: NameAndSpan {
name: *extname,
span: (*expand).span
}
}));
((*expand).expander)(cx, it.span, it.ident, tts)
}
_ => cx.span_fatal(
it.span, fmt!("%s! is not legal in item position", *extname))
};
let maybe_it = match expanded {
MRItem(it) => fld.fold_item(it),
MRExpr(_) => cx.span_fatal(pth.span,
~"expr macro in item position: "
+ *extname),
MRAny(_, item_maker, _) =>
option::chain(item_maker(), |i| {fld.fold_item(i)}),
MRDef(ref mdef) => {
extsbox.insert(@/*bad*/ copy mdef.name, @SE((*mdef).ext));
None
}
};
cx.bt_pop();
return maybe_it;
}
// expand a stmt
pub fn expand_stmt(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
&& s: stmt_, sp: span, fld: ast_fold,
orig: fn@(&&s: stmt_, span, ast_fold) -> (stmt_, span))
-> (stmt_, span) {
let (mac, pth, tts, semi) = match s {
stmt_mac(ref mac, semi) => {
match (*mac).node {
mac_invoc_tt(pth, ref tts) => ((*mac), pth, (*tts), semi)
}
}
_ => return orig(s, sp, fld)
};
assert(vec::len(pth.idents) == 1u);
let extname = cx.parse_sess().interner.get(pth.idents[0]);
let (fully_expanded, sp) = match (*extsbox).find(&extname) {
None =>
cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)),
Some(@SE(NormalTT(
SyntaxExpanderTT{expander: exp, span: exp_sp}))) => {
cx.bt_push(ExpandedFrom(CallInfo {
call_site: sp,
callee: NameAndSpan { name: *extname, span: exp_sp }
}));
let expanded = match exp(cx, mac.span, tts) {
MRExpr(e) =>
@codemap::spanned { node: stmt_expr(e, cx.next_id()),
span: e.span},
MRAny(_,_,stmt_mkr) => stmt_mkr(),
_ => cx.span_fatal(
pth.span,
fmt!("non-stmt macro in stmt pos: %s", *extname))
};
//keep going, outside-in
let fully_expanded = fld.fold_stmt(expanded).node;
cx.bt_pop();
(fully_expanded, sp)
}
_ => {
cx.span_fatal(pth.span,
fmt!("'%s' is not a tt-style macro", *extname))
}
};
(match fully_expanded {
stmt_expr(e, stmt_id) if semi => stmt_semi(e, stmt_id),
_ => { fully_expanded } /* might already have a semi */
}, sp)
}
pub fn expand_block(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
&& blk: blk_, sp: span, fld: ast_fold,
orig: fn@(&&s: blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span) {
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\"")
}
}
pub fn new_span(cx: ext_ctxt, sp: span) -> span {
/* this discards information in the case of macro-defining macros */
return span {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()};
}
// 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.
pub fn core_macros() -> ~str {
return
~"pub mod macros {
macro_rules! ignore (($($x:tt)*) => (()))
macro_rules! error ( ($( $arg:expr ),+) => (
log(::core::error, fmt!( $($arg),+ )) ))
macro_rules! warn ( ($( $arg:expr ),+) => (
log(::core::warn, fmt!( $($arg),+ )) ))
macro_rules! info ( ($( $arg:expr ),+) => (
log(::core::info, fmt!( $($arg),+ )) ))
macro_rules! debug ( ($( $arg:expr ),+) => (
log(::core::debug, fmt!( $($arg),+ )) ))
macro_rules! fail(
($msg: expr) => (
::core::sys::begin_unwind($msg, file!().to_owned(), line!())
);
() => (
fail!(~\"explicit failure\")
)
)
macro_rules! fail_unless(
($cond:expr) => {
if !$cond {
fail!(~\"assertion failed: \" + stringify!($cond))
}
}
)
macro_rules! condition (
{ $c:ident: $in:ty -> $out:ty; } => {
mod $c {
fn key(_x: @::core::condition::Handler<$in,$out>) { }
pub const cond : ::core::condition::Condition<$in,$out> =
::core::condition::Condition {
name: stringify!($c),
key: key
};
}
}
)
}";
}
// could cfg just be a borrowed pointer here?
pub fn expand_crate(parse_sess: @mut parse::ParseSess,
cfg: ast::crate_cfg, c: @crate) -> @crate {
// 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();
let afp = default_ast_fold();
let cx: ext_ctxt = mk_ctxt(parse_sess, cfg);
let f_pre = @AstFoldFns {
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|
expand_block (extsbox, cx, blk, span, recur, afp.fold_block),
new_span: |a| new_span(cx, a),
.. *afp};
let f = make_fold(f_pre);
// add a bunch of macros as though they were placed at the
// head of the program (ick).
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}}];
let cm = match parse_item_from_source_str(~"<core-macros>",
@core_macros(),
cfg,attrs,
parse_sess) {
Some(item) => item,
None => cx.bug(~"expected core macros to parse correctly")
};
// This is run for its side-effects on the expander env,
// as it registers all the core macros as expanders.
f.fold_item(cm);
let res = @f.fold_crate(*c);
return res;
}
#[cfg(test)]
mod test {
use super::*;
use util::testing::check_equal;
// make sure that fail! is present
#[test] fn fail_exists_test () {
let src = ~"fn main() { fail!(~\"something appropriately gloomy\");}";
let sess = parse::new_parse_sess(None);
let cfg = ~[];
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
@src,
cfg,sess);
expand_crate(sess,cfg,crate_ast);
}
// 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 cfg = ~[];
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
@src,
cfg,sess);
// should fail:
expand_crate(sess,cfg,crate_ast);
}
// 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 cfg = ~[];
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
@src,
cfg,sess);
// should fail:
expand_crate(sess,cfg,crate_ast);
}
// 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 cfg = ~[];
let crate_ast = parse::parse_crate_from_source_str(
~"<test>",
@src,
cfg,sess);
// should fail:
expand_crate(sess,cfg,crate_ast);
}
#[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
None => fail!(~"expected this to parse")
}
}
#[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];
check_equal (contains_macro_escape (attrs1),true);
let attrs2 = ~[attr1,attr2];
check_equal (contains_macro_escape (attrs2),false);
}
// make a "meta_word" outer attribute with the given name
fn make_dummy_attr(s: @~str) -> ast::attribute {
spanned {span:codemap::dummy_sp(),
node: attribute_
{style:attr_outer,
value:spanned
{node:meta_word(s),
span:codemap::dummy_sp()},
is_sugared_doc:false}}
}
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: