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.
|
|
|
|
|
2012-09-10 17:38:28 -05:00
|
|
|
use std::map::HashMap;
|
2011-07-06 17:22:23 -05:00
|
|
|
|
2012-12-12 14:25:40 -06:00
|
|
|
use ast::{crate, expr_, expr_mac, mac_invoc_tt,
|
2012-11-21 17:49:42 -06:00
|
|
|
tt_delim, tt_tok, item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
|
2012-09-04 13:37:29 -05:00
|
|
|
use fold::*;
|
|
|
|
use ext::base::*;
|
2012-11-20 18:07:57 -06:00
|
|
|
use parse::{parser, parse_expr_from_source_str, new_parser_from_tts};
|
2011-08-05 15:06:11 -05:00
|
|
|
|
2012-03-02 16:36:22 -06:00
|
|
|
|
2012-11-12 20:59:37 -06:00
|
|
|
use codemap::{span, ExpandedFrom};
|
2012-01-22 18:30:07 -06:00
|
|
|
|
2012-11-17 06:41:36 -06:00
|
|
|
|
2012-09-10 17:38:28 -05:00
|
|
|
fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
|
2012-01-22 18:30:07 -06:00
|
|
|
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 {
|
2012-07-27 19:42:32 -05:00
|
|
|
// expr_mac should really be expr_ext or something; it's the
|
|
|
|
// entry-point for all syntax extensions.
|
2012-12-04 12:50:00 -06:00
|
|
|
expr_mac(ref mac) => {
|
2012-07-27 19:42:32 -05:00
|
|
|
|
2012-12-04 12:50:00 -06:00
|
|
|
match (*mac).node {
|
2012-07-27 19:42:32 -05:00
|
|
|
|
|
|
|
// Token-tree macros, these will be the only case when we're
|
|
|
|
// finished transitioning.
|
2012-12-04 12:50:00 -06:00
|
|
|
mac_invoc_tt(pth, ref tts) => {
|
2012-07-06 20:04:28 -05:00
|
|
|
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 => {
|
2012-06-25 17:04:50 -05:00
|
|
|
cx.span_fatal(pth.span,
|
2012-08-22 19:24:52 -05:00
|
|
|
fmt!("macro undefined: '%s'", *extname))
|
2012-06-25 17:04:50 -05:00
|
|
|
}
|
2012-11-08 22:12:45 -06:00
|
|
|
Some(normal_tt({expander: exp, span: exp_sp})) => {
|
2012-12-06 13:01:58 -06:00
|
|
|
cx.bt_push(ExpandedFrom({call_site: s,
|
|
|
|
callie: {name: *extname, span: exp_sp}}));
|
|
|
|
|
2012-12-04 12:50:00 -06:00
|
|
|
let expanded = match exp(cx, (*mac).span, (*tts)) {
|
2012-08-03 21:59:04 -05:00
|
|
|
mr_expr(e) => e,
|
2012-11-19 19:31:22 -06:00
|
|
|
mr_any(expr_maker,_,_) => expr_maker(),
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => cx.span_fatal(
|
2012-08-22 19:24:52 -05:00
|
|
|
pth.span, fmt!("non-expr macro in expr pos: %s",
|
|
|
|
*extname))
|
2012-07-06 20:04:28 -05:00
|
|
|
};
|
2012-06-25 17:04:50 -05:00
|
|
|
|
|
|
|
//keep going, outside-in
|
|
|
|
let fully_expanded = fld.fold_expr(expanded).node;
|
|
|
|
cx.bt_pop();
|
|
|
|
|
|
|
|
(fully_expanded, s)
|
2012-07-12 19:59:59 -05:00
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
_ => {
|
2012-06-25 17:04:50 -05:00
|
|
|
cx.span_fatal(pth.span,
|
2012-08-22 19:24:52 -05:00
|
|
|
fmt!("'%s' is not a tt-style macro",
|
|
|
|
*extname))
|
2012-06-25 17:04:50 -05:00
|
|
|
}
|
|
|
|
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
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
|
|
|
};
|
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
|
|
|
|
// 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,
|
2012-07-31 18:38:41 -05:00
|
|
|
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:
|
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| {
|
2012-08-06 14:34:08 -05:00
|
|
|
let mname = match attr.node.value.node {
|
2012-12-04 12:50:00 -06:00
|
|
|
ast::meta_word(ref n) => (*n),
|
|
|
|
ast::meta_name_value(ref n, _) => (*n),
|
|
|
|
ast::meta_list(ref n, _) => (*n)
|
2012-03-02 16:36:22 -06:00
|
|
|
};
|
2012-07-18 18:18:02 -05:00
|
|
|
match exts.find(mname) {
|
2012-12-12 19:08:09 -06:00
|
|
|
None | Some(normal_tt(_)) | Some(item_tt(*)) => items,
|
2012-08-20 14:23:37 -05:00
|
|
|
Some(item_decorator(dec_fn)) => {
|
2012-12-12 12:44:01 -06:00
|
|
|
cx.bt_push(ExpandedFrom({call_site: attr.span,
|
|
|
|
callie: {name: copy mname,
|
|
|
|
span: None}}));
|
|
|
|
let r = dec_fn(cx, attr.span, attr.node.value, items);
|
|
|
|
cx.bt_pop();
|
|
|
|
r
|
2012-03-02 16:36:22 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-09-28 00:20:47 -05:00
|
|
|
return {items: new_items, ..module_};
|
2012-03-02 16:36:22 -06:00
|
|
|
}
|
|
|
|
|
2012-07-27 13:19:21 -05: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>,
|
2012-07-05 14:10:33 -05:00
|
|
|
cx: ext_ctxt, &&it: @ast::item, fld: ast_fold,
|
2012-09-23 06:39:27 -05:00
|
|
|
orig: fn@(&&v: @ast::item, ast_fold) -> Option<@ast::item>)
|
2012-08-20 14:23:37 -05:00
|
|
|
-> Option<@ast::item>
|
2012-05-18 12:00:49 -05:00
|
|
|
{
|
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-05-18 12:00:49 -05:00
|
|
|
};
|
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-05 14:10:33 -05:00
|
|
|
};
|
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
|
|
|
}
|
2012-05-18 12:00:49 -05:00
|
|
|
}
|
|
|
|
|
2012-07-27 13:19:21 -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>,
|
2012-07-05 18:46:32 -05:00
|
|
|
cx: ext_ctxt, &&it: @ast::item,
|
2012-08-20 14:23:37 -05:00
|
|
|
fld: ast_fold) -> Option<@ast::item> {
|
2012-12-12 14:25:40 -06:00
|
|
|
|
|
|
|
let (pth, tts) = match it.node {
|
|
|
|
item_mac({node: mac_invoc_tt(pth, ref tts), _}) => (pth, (*tts)),
|
|
|
|
_ => 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]);
|
2012-12-06 18:19:05 -06:00
|
|
|
let expanded = match exts.find(*extname) {
|
2012-11-17 06:41:36 -06:00
|
|
|
None => cx.span_fatal(pth.span,
|
|
|
|
fmt!("macro undefined: '%s!'", *extname)),
|
|
|
|
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(normal_tt(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)));
|
|
|
|
}
|
2012-12-06 18:19:05 -06:00
|
|
|
cx.bt_push(ExpandedFrom({call_site: it.span,
|
|
|
|
callie: {name: *extname,
|
|
|
|
span: (*expand).span}}));
|
|
|
|
((*expand).expander)(cx, it.span, tts)
|
2012-11-17 06:41:36 -06:00
|
|
|
}
|
2012-12-04 12:50:00 -06:00
|
|
|
Some(item_tt(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));
|
|
|
|
}
|
2012-12-06 18:19:05 -06:00
|
|
|
cx.bt_push(ExpandedFrom({call_site: it.span,
|
|
|
|
callie: {name: *extname,
|
|
|
|
span: (*expand).span}}));
|
|
|
|
((*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 {
|
|
|
|
mr_item(it) => fld.fold_item(it),
|
|
|
|
mr_expr(_) => cx.span_fatal(pth.span,
|
|
|
|
~"expr macro in item position: "
|
|
|
|
+ *extname),
|
|
|
|
mr_any(_, item_maker, _) =>
|
|
|
|
option::chain(item_maker(), |i| {fld.fold_item(i)}),
|
2012-12-04 12:50:00 -06:00
|
|
|
mr_def(ref mdef) => {
|
|
|
|
exts.insert((*mdef).name, (*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
|
|
|
}
|
|
|
|
|
2012-11-19 19:31:22 -06:00
|
|
|
fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
|
|
|
|
&& s: stmt_, sp: span, fld: ast_fold,
|
|
|
|
orig: fn@(&&s: stmt_, span, ast_fold) -> (stmt_, span))
|
|
|
|
-> (stmt_, span)
|
|
|
|
{
|
2012-12-12 14:25:40 -06:00
|
|
|
|
|
|
|
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)
|
|
|
|
};
|
2012-11-17 06:41:36 -06:00
|
|
|
|
|
|
|
assert(vec::len(pth.idents) == 1u);
|
|
|
|
let extname = cx.parse_sess().interner.get(pth.idents[0]);
|
2012-11-21 17:49:42 -06:00
|
|
|
let (fully_expanded, sp) = match exts.find(*extname) {
|
2012-11-17 06:41:36 -06:00
|
|
|
None =>
|
|
|
|
cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)),
|
|
|
|
|
|
|
|
Some(normal_tt({expander: exp, span: exp_sp})) => {
|
2012-12-06 13:01:58 -06:00
|
|
|
cx.bt_push(ExpandedFrom(
|
|
|
|
{call_site: sp, callie: {name: *extname, span: exp_sp}}));
|
2012-11-17 06:41:36 -06:00
|
|
|
let expanded = match exp(cx, mac.span, tts) {
|
2012-11-21 17:49:42 -06:00
|
|
|
mr_expr(e) =>
|
|
|
|
@{node: stmt_expr(e, cx.next_id()), span: e.span},
|
2012-11-17 06:41:36 -06:00
|
|
|
mr_any(_,_,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();
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
|
|
|
return (match fully_expanded {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-04 19:37:24 -06:00
|
|
|
fn new_span(cx: ext_ctxt, sp: span) -> span {
|
|
|
|
/* 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
|
|
|
}
|
|
|
|
|
2012-06-21 18:44:10 -05:00
|
|
|
// 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.
|
2011-12-20 15:38:10 -06:00
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn core_macros() -> ~str {
|
2012-08-01 19:30:05 -05:00
|
|
|
return
|
2012-07-14 00:57:48 -05:00
|
|
|
~"{
|
2012-09-07 18:58:27 -05:00
|
|
|
macro_rules! ignore (($($x:tt)*) => (()))
|
2012-11-26 21:34:01 -06:00
|
|
|
|
|
|
|
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),+ )) ))
|
2012-11-27 20:05:20 -06:00
|
|
|
|
|
|
|
macro_rules! die(
|
|
|
|
($msg: expr) => (
|
2012-12-10 19:22:10 -06:00
|
|
|
core::sys::begin_unwind($msg, file!(), line!())
|
2012-11-27 20:05:20 -06:00
|
|
|
);
|
|
|
|
() => (
|
2012-12-10 19:22:10 -06:00
|
|
|
die!(~\"explicit failure\")
|
2012-11-27 20:05:20 -06:00
|
|
|
)
|
|
|
|
)
|
2011-12-20 15:38:10 -06:00
|
|
|
}";
|
|
|
|
}
|
|
|
|
|
2012-04-18 01:34:48 -05:00
|
|
|
fn expand_crate(parse_sess: parse::parse_sess,
|
2012-03-27 16:03:57 -05:00
|
|
|
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();
|
2012-03-27 16:03:57 -05:00
|
|
|
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),
|
2012-07-05 14:10:33 -05:00
|
|
|
fold_item: |a,b| expand_item(exts, cx, a, b, afp.fold_item),
|
2012-11-19 19:31:22 -06:00
|
|
|
fold_stmt: |a,b,c| expand_stmt(exts, cx, a, b, c, afp.fold_stmt),
|
|
|
|
new_span: |a| new_span(cx, a),
|
2012-09-04 15:29:32 -05:00
|
|
|
.. *afp};
|
2011-07-27 07:19:39 -05:00
|
|
|
let f = make_fold(f_pre);
|
2012-07-14 00:57:48 -05:00
|
|
|
let cm = parse_expr_from_source_str(~"<core-macros>",
|
2012-04-30 13:52:07 -05:00
|
|
|
@core_macros(),
|
2012-03-27 16:03:57 -05:00
|
|
|
cfg,
|
|
|
|
parse_sess);
|
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.
|
|
|
|
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;
|
2011-07-06 17:22:23 -05:00
|
|
|
}
|
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|