rust/src/libsyntax/ext/expand.rs

285 lines
11 KiB
Rust
Raw Normal View History

2012-09-10 17:38:28 -05:00
use std::map::HashMap;
2012-09-04 13:37:29 -05:00
use ast::{crate, expr_, expr_mac, mac_invoc, mac_invoc_tt,
tt_delim, tt_tok, item_mac};
2012-09-04 13:37:29 -05:00
use fold::*;
use ext::base::*;
use ext::qquote::{qq_helper};
use parse::{parser, parse_expr_from_source_str, new_parser_from_tt};
2011-08-05 15:06:11 -05:00
2012-03-02 16:36:22 -06:00
2012-09-04 13:37:29 -05:00
use codemap::{span, expanded_from};
2012-09-10 17:38:28 -05:00
fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
e: expr_, s: span, fld: ast_fold,
orig: fn@(expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span)
{
2012-08-06 14:34:08 -05:00
return match e {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
2012-08-03 21:59:04 -05:00
expr_mac(mac) => {
// Old-style macros, for compatibility, will erase this whole
// block once we've transitioned.
2012-08-06 14:34:08 -05:00
match mac.node {
2012-08-03 21:59:04 -05:00
mac_invoc(pth, args, body) => {
2012-04-23 06:04:46 -05:00
assert (vec::len(pth.idents) > 0u);
2012-07-18 18:18:02 -05: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]);
2012-08-06 14:34:08 -05:00
match exts.find(*extname) {
2012-08-20 14:23:37 -05:00
None => {
cx.span_fatal(pth.span,
2012-08-22 19:24:52 -05:00
fmt!("macro undefined: '%s'", *extname))
2011-07-27 07:19:39 -05:00
}
2012-08-20 14:23:37 -05:00
Some(item_decorator(_)) => {
2012-03-02 16:36:22 -06:00
cx.span_fatal(
pth.span,
2012-08-22 19:24:52 -05:00
fmt!("%s can only be used as a decorator", *extname));
2012-03-02 16:36:22 -06:00
}
2012-08-20 14:23:37 -05:00
Some(normal({expander: exp, span: exp_sp})) => {
let expanded = exp(cx, mac.span, args, body);
2011-07-27 07:19:39 -05:00
cx.bt_push(expanded_from({call_site: s,
2012-06-10 02:49:59 -05:00
callie: {name: *extname, span: exp_sp}}));
2011-07-27 07:19:39 -05:00
//keep going, outside-in
2011-08-05 15:06:11 -05:00
let fully_expanded = fld.fold_expr(expanded).node;
cx.bt_pop();
(fully_expanded, s)
2011-07-27 07:19:39 -05:00
}
2012-08-20 14:23:37 -05:00
Some(macro_defining(ext)) => {
let named_extension = ext(cx, mac.span, args, body);
2012-07-18 18:18:02 -05:00
exts.insert(named_extension.name, named_extension.ext);
2012-08-20 14:23:37 -05:00
(ast::expr_rec(~[], None), s)
2011-07-27 07:19:39 -05:00
}
2012-08-20 14:23:37 -05:00
Some(expr_tt(_)) => {
cx.span_fatal(pth.span,
2012-08-22 19:24:52 -05:00
fmt!("this tt-style macro should be \
invoked '%s!(...)'", *extname))
}
2012-08-20 14:23:37 -05:00
Some(item_tt(*)) => {
cx.span_fatal(pth.span,
~"cannot use item macros in this context");
}
}
}
// Token-tree macros, these will be the only case when we're
// finished transitioning.
2012-08-03 21:59:04 -05:00
mac_invoc_tt(pth, tts) => {
assert (vec::len(pth.idents) == 1u);
2012-07-18 18:18:02 -05: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]);
2012-08-06 14:34:08 -05:00
match exts.find(*extname) {
2012-08-20 14:23:37 -05:00
None => {
cx.span_fatal(pth.span,
2012-08-22 19:24:52 -05:00
fmt!("macro undefined: '%s'", *extname))
}
2012-08-20 14:23:37 -05:00
Some(expr_tt({expander: exp, span: exp_sp})) => {
2012-08-06 14:34:08 -05:00
let expanded = match exp(cx, mac.span, tts) {
2012-08-03 21:59:04 -05:00
mr_expr(e) => e,
_ => cx.span_fatal(
2012-08-22 19:24:52 -05:00
pth.span, fmt!("non-expr macro in expr pos: %s",
*extname))
};
cx.bt_push(expanded_from({call_site: s,
callie: {name: *extname, span: exp_sp}}));
//keep going, outside-in
let fully_expanded = fld.fold_expr(expanded).node;
cx.bt_pop();
(fully_expanded, s)
}
2012-08-20 14:23:37 -05:00
Some(normal({expander: exp, span: exp_sp})) => {
//convert the new-style invoc for the old-style macro
let arg = base::tt_args_to_original_flavor(cx, pth.span,
tts);
2012-08-20 14:23:37 -05:00
let expanded = exp(cx, mac.span, arg, None);
cx.bt_push(expanded_from({call_site: s,
callie: {name: *extname, span: exp_sp}}));
//keep going, outside-in
let fully_expanded = fld.fold_expr(expanded).node;
cx.bt_pop();
(fully_expanded, s)
}
2012-08-03 21:59:04 -05:00
_ => {
cx.span_fatal(pth.span,
2012-08-22 19:24:52 -05:00
fmt!("'%s' is not a tt-style macro",
*extname))
}
}
2011-07-27 07:19:39 -05:00
}
2012-08-03 21:59:04 -05:00
_ => cx.span_bug(mac.span, ~"naked syntactic bit")
}
2011-07-27 07:19:39 -05:00
}
2012-08-03 21:59:04 -05:00
_ => orig(e, s, fld)
2011-07-27 07:19:39 -05:00
};
}
// This is a secondary mechanism for invoking syntax extensions on items:
// "decorator" attributes, such as #[auto_serialize]. 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 item_decorator 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.
2012-09-10 17:38:28 -05:00
fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
module_: ast::_mod, fld: ast_fold,
2012-03-02 16:36:22 -06:00
orig: fn@(ast::_mod, ast_fold) -> ast::_mod)
-> ast::_mod
{
// Fold the contents first:
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.
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| {
2012-08-06 14:34:08 -05:00
let mname = match attr.node.value.node {
2012-08-03 21:59:04 -05:00
ast::meta_word(n) => n,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n
2012-03-02 16:36:22 -06:00
};
2012-07-18 18:18:02 -05:00
match exts.find(mname) {
2012-08-20 14:23:37 -05:00
None | Some(normal(_)) | Some(macro_defining(_))
| Some(expr_tt(_)) | Some(item_tt(*)) => items,
Some(item_decorator(dec_fn)) => {
2012-03-02 16:36:22 -06:00
dec_fn(cx, attr.span, attr.node.value, items)
}
}
}
};
2012-09-28 00:20:47 -05:00
return {items: new_items, ..module_};
2012-03-02 16:36:22 -06:00
}
// When we enter a module, record it, for the sake of `module!`
2012-09-10 17:38:28 -05:00
fn expand_item(exts: HashMap<~str, syntax_extension>,
cx: ext_ctxt, &&it: @ast::item, fld: ast_fold,
orig: fn@(&&v: @ast::item, ast_fold) -> Option<@ast::item>)
2012-08-20 14:23:37 -05:00
-> Option<@ast::item>
{
2012-08-06 14:34:08 -05:00
let is_mod = match it.node {
2012-08-03 21:59:04 -05:00
ast::item_mod(_) | ast::item_foreign_mod(_) => true,
_ => false
};
2012-08-06 14:34:08 -05:00
let maybe_it = match it.node {
2012-08-03 21:59:04 -05:00
ast::item_mac(*) => expand_item_mac(exts, cx, it, fld),
2012-08-20 14:23:37 -05:00
_ => Some(it)
};
2012-07-06 14:17:34 -05:00
2012-08-06 14:34:08 -05:00
match maybe_it {
2012-08-20 14:23:37 -05:00
Some(it) => {
2012-07-06 14:17:34 -05:00
if is_mod { cx.mod_push(it.ident); }
let ret_val = orig(it, fld);
if is_mod { cx.mod_pop(); }
2012-08-01 19:30:05 -05:00
return ret_val;
2012-07-06 14:17:34 -05:00
}
2012-08-20 14:23:37 -05:00
None => return None
2012-07-06 14:17:34 -05:00
}
}
// Support for item-position macro invocations, exactly the same
// logic as for expression-position macro invocations.
2012-09-10 17:38:28 -05:00
fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
cx: ext_ctxt, &&it: @ast::item,
2012-08-20 14:23:37 -05:00
fld: ast_fold) -> Option<@ast::item> {
2012-08-06 14:34:08 -05:00
match it.node {
2012-08-26 14:12:05 -05:00
item_mac({node: mac_invoc_tt(pth, tts), _}) => {
2012-07-18 18:18:02 -05:00
let extname = cx.parse_sess().interner.get(pth.idents[0]);
2012-08-06 14:34:08 -05:00
match exts.find(*extname) {
2012-08-20 14:23:37 -05:00
None => {
cx.span_fatal(pth.span,
2012-08-22 19:24:52 -05:00
fmt!("macro undefined: '%s'", *extname))
}
2012-08-20 14:23:37 -05:00
Some(item_tt(expand)) => {
let expanded = expand.expander(cx, it.span, it.ident, tts);
cx.bt_push(expanded_from({call_site: it.span,
callie: {name: *extname,
span: expand.span}}));
2012-08-06 14:34:08 -05:00
let maybe_it = match expanded {
2012-08-03 21:59:04 -05:00
mr_item(it) => fld.fold_item(it),
mr_expr(_) => cx.span_fatal(pth.span,
~"expr macro in item position: " +
2012-08-03 21:59:04 -05:00
*extname),
mr_def(mdef) => {
2012-07-18 18:18:02 -05:00
exts.insert(mdef.name, mdef.ext);
2012-08-20 14:23:37 -05:00
None
}
};
cx.bt_pop();
2012-08-01 19:30:05 -05:00
return maybe_it
}
2012-08-03 21:59:04 -05:00
_ => cx.span_fatal(it.span,
2012-08-22 19:24:52 -05:00
fmt!("%s is not a legal here", *extname))
}
}
2012-08-03 21:59:04 -05:00
_ => cx.span_bug(it.span, ~"invalid item macro invocation")
}
}
fn new_span(cx: ext_ctxt, sp: span) -> span {
/* this discards information in the case of macro-defining macros */
2012-08-01 19:30:05 -05:00
return {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()};
}
// FIXME (#2247): this is a terrible kludge to inject some macros into
// the default compilation environment. When the macro-definition system
// is substantially more mature, these should move from here, into a
// compiled part of libcore at very least.
fn core_macros() -> ~str {
2012-08-01 19:30:05 -05:00
return
~"{
macro_rules! ignore (($($x:tt)*) => (()))
#macro[[#error[f, ...], log(core::error, #fmt[f, ...])]];
#macro[[#warn[f, ...], log(core::warn, #fmt[f, ...])]];
#macro[[#info[f, ...], log(core::info, #fmt[f, ...])]];
#macro[[#debug[f, ...], log(core::debug, #fmt[f, ...])]];
}";
}
fn expand_crate(parse_sess: parse::parse_sess,
cfg: ast::crate_cfg, c: @crate) -> @crate {
2011-08-05 15:06:11 -05:00
let exts = syntax_expander_table();
2011-07-27 07:19:39 -05:00
let afp = default_ast_fold();
let cx: ext_ctxt = mk_ctxt(parse_sess, cfg);
2011-07-27 07:19:39 -05:00
let f_pre =
2012-06-30 18:19:07 -05:00
@{fold_expr: |a,b,c| expand_expr(exts, cx, a, b, c, afp.fold_expr),
fold_mod: |a,b| expand_mod_items(exts, cx, a, b, afp.fold_mod),
fold_item: |a,b| expand_item(exts, cx, a, b, afp.fold_item),
2012-09-04 15:29:32 -05:00
new_span: |a|new_span(cx, a),
.. *afp};
2011-07-27 07:19:39 -05:00
let f = make_fold(f_pre);
let cm = parse_expr_from_source_str(~"<core-macros>",
@core_macros(),
cfg,
parse_sess);
// This is run for its side-effects on the expander env,
// as it registers all the core macros as expanders.
f.fold_expr(cm);
2011-07-27 07:19:39 -05:00
let res = @f.fold_crate(*c);
2012-08-01 19:30:05 -05:00
return res;
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: