// Copyright 2012-2013 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use ast; use codemap; use codemap::{CodeMap, span, ExpnInfo, ExpandedFrom}; use codemap::CallInfo; use diagnostic::span_handler; use ext; use parse; use parse::token; use core::hashmap::HashMap; // new-style macro! tt code: // // SyntaxExpanderTT, SyntaxExpanderTTItem, MacResult, // NormalTT, IdentTT // // also note that ast::mac used to have a bunch of extraneous cases and // is now probably a redundant AST node, can be merged with // ast::mac_invoc_tt. pub struct MacroDef { name: ~str, ext: SyntaxExtension } pub type ItemDecorator = @fn(@ext_ctxt, span, @ast::meta_item, ~[@ast::item]) -> ~[@ast::item]; pub struct SyntaxExpanderTT { expander: SyntaxExpanderTTFun, span: Option } pub type SyntaxExpanderTTFun = @fn(@ext_ctxt, span, &[ast::token_tree]) -> MacResult; pub struct SyntaxExpanderTTItem { expander: SyntaxExpanderTTItemFun, span: Option } pub type SyntaxExpanderTTItemFun = @fn(@ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> MacResult; pub enum MacResult { MRExpr(@ast::expr), MRItem(@ast::item), MRAny(@fn() -> @ast::expr, @fn() -> Option<@ast::item>, @fn() -> @ast::stmt), MRDef(MacroDef) } pub enum SyntaxExtension { // #[auto_encode] and such ItemDecorator(ItemDecorator), // Token-tree expanders NormalTT(SyntaxExpanderTT), // An IdentTT is a macro that has an // identifier in between the name of the // macro and the argument. Currently, // the only examples of this are // macro_rules! and proto! // perhaps macro_rules! will lose its odd special identifier argument, // and this can go away also IdentTT(SyntaxExpanderTTItem), } pub type SyntaxEnv = @mut MapChain; // Name : the domain of SyntaxEnvs // want to change these to uints.... // note that we use certain strings that are not legal as identifiers // to indicate, for instance, how blocks are supposed to behave. type Name = @~str; // Transformer : the codomain of SyntaxEnvs // NB: it may seem crazy to lump both of these into one environment; // what would it mean to bind "foo" to BlockLimit(true)? The idea // is that this follows the lead of MTWT, and accommodates growth // toward a more uniform syntax syntax (sorry) where blocks are just // another kind of transformer. pub enum Transformer { // this identifier maps to a syntax extension or macro SE(SyntaxExtension), // should blocks occurring here limit macro scopes? ScopeMacros(bool) } // The base map of methods for expanding syntax extension // AST nodes into full ASTs pub fn syntax_expander_table() -> SyntaxEnv { // utility function to simplify creating NormalTT syntax extensions fn builtin_normal_tt(f: SyntaxExpanderTTFun) -> @Transformer { @SE(NormalTT(SyntaxExpanderTT{expander: f, span: None})) } // utility function to simplify creating IdentTT syntax extensions fn builtin_item_tt(f: SyntaxExpanderTTItemFun) -> @Transformer { @SE(IdentTT(SyntaxExpanderTTItem{expander: f, span: None})) } let mut syntax_expanders = HashMap::new(); // NB identifier starts with space, and can't conflict with legal idents syntax_expanders.insert(@~" block", @ScopeMacros(true)); syntax_expanders.insert(@~"macro_rules", builtin_item_tt( ext::tt::macro_rules::add_new_extension)); syntax_expanders.insert(@~"fmt", builtin_normal_tt(ext::fmt::expand_syntax_ext)); syntax_expanders.insert( @~"auto_encode", @SE(ItemDecorator(ext::auto_encode::expand_auto_encode))); syntax_expanders.insert( @~"auto_decode", @SE(ItemDecorator(ext::auto_encode::expand_auto_decode))); syntax_expanders.insert(@~"env", builtin_normal_tt(ext::env::expand_syntax_ext)); syntax_expanders.insert(@~"bytes", builtin_normal_tt(ext::bytes::expand_syntax_ext)); syntax_expanders.insert(@~"concat_idents", builtin_normal_tt( ext::concat_idents::expand_syntax_ext)); syntax_expanders.insert(@~"log_syntax", builtin_normal_tt( ext::log_syntax::expand_syntax_ext)); syntax_expanders.insert(@~"deriving", @SE(ItemDecorator( ext::deriving::expand_meta_deriving))); // Quasi-quoting expanders syntax_expanders.insert(@~"quote_tokens", builtin_normal_tt(ext::quote::expand_quote_tokens)); syntax_expanders.insert(@~"quote_expr", builtin_normal_tt(ext::quote::expand_quote_expr)); syntax_expanders.insert(@~"quote_ty", builtin_normal_tt(ext::quote::expand_quote_ty)); syntax_expanders.insert(@~"quote_item", builtin_normal_tt(ext::quote::expand_quote_item)); syntax_expanders.insert(@~"quote_pat", builtin_normal_tt(ext::quote::expand_quote_pat)); syntax_expanders.insert(@~"quote_stmt", builtin_normal_tt(ext::quote::expand_quote_stmt)); syntax_expanders.insert(@~"line", builtin_normal_tt( ext::source_util::expand_line)); syntax_expanders.insert(@~"col", builtin_normal_tt( ext::source_util::expand_col)); syntax_expanders.insert(@~"file", builtin_normal_tt( ext::source_util::expand_file)); syntax_expanders.insert(@~"stringify", builtin_normal_tt( ext::source_util::expand_stringify)); syntax_expanders.insert(@~"include", builtin_normal_tt( ext::source_util::expand_include)); syntax_expanders.insert(@~"include_str", builtin_normal_tt( ext::source_util::expand_include_str)); syntax_expanders.insert(@~"include_bin", builtin_normal_tt( ext::source_util::expand_include_bin)); syntax_expanders.insert(@~"module_path", builtin_normal_tt( ext::source_util::expand_mod)); syntax_expanders.insert(@~"proto", builtin_item_tt(ext::pipes::expand_proto)); syntax_expanders.insert(@~"asm", builtin_normal_tt(ext::asm::expand_asm)); syntax_expanders.insert( @~"trace_macros", builtin_normal_tt(ext::trace_macros::expand_trace_macros)); MapChain::new(~syntax_expanders) } // One of these is made during expansion and incrementally updated as we go; // when a macro expansion occurs, the resulting nodes have the backtrace() // -> expn_info of their expansion context stored into their span. pub trait ext_ctxt { fn codemap(&self) -> @CodeMap; fn parse_sess(&self) -> @mut parse::ParseSess; fn cfg(&self) -> ast::crate_cfg; fn call_site(&self) -> span; fn print_backtrace(&self); fn backtrace(&self) -> Option<@ExpnInfo>; fn mod_push(&self, mod_name: ast::ident); fn mod_pop(&self); fn mod_path(&self) -> ~[ast::ident]; fn bt_push(&self, ei: codemap::ExpnInfo); fn bt_pop(&self); fn span_fatal(&self, sp: span, msg: &str) -> !; fn span_err(&self, sp: span, msg: &str); fn span_warn(&self, sp: span, msg: &str); fn span_unimpl(&self, sp: span, msg: &str) -> !; fn span_bug(&self, sp: span, msg: &str) -> !; fn bug(&self, msg: &str) -> !; fn next_id(&self) -> ast::node_id; fn trace_macros(&self) -> bool; fn set_trace_macros(&self, x: bool); /* for unhygienic identifier transformation */ fn str_of(&self, id: ast::ident) -> ~str; fn ident_of(&self, st: &str) -> ast::ident; } pub fn mk_ctxt(parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg) -> @ext_ctxt { struct CtxtRepr { parse_sess: @mut parse::ParseSess, cfg: ast::crate_cfg, backtrace: @mut Option<@ExpnInfo>, // These two @mut's should really not be here, // but the self types for CtxtRepr are all wrong // and there are bugs in the code for object // types that make this hard to get right at the // moment. - nmatsakis mod_path: @mut ~[ast::ident], trace_mac: @mut bool } impl ext_ctxt for CtxtRepr { fn codemap(&self) -> @CodeMap { self.parse_sess.cm } fn parse_sess(&self) -> @mut parse::ParseSess { self.parse_sess } fn cfg(&self) -> ast::crate_cfg { copy self.cfg } fn call_site(&self) -> span { match *self.backtrace { Some(@ExpandedFrom(CallInfo {call_site: cs, _})) => cs, None => self.bug("missing top span") } } fn print_backtrace(&self) { } fn backtrace(&self) -> Option<@ExpnInfo> { *self.backtrace } fn mod_push(&self, i: ast::ident) { self.mod_path.push(i); } fn mod_pop(&self) { self.mod_path.pop(); } fn mod_path(&self) -> ~[ast::ident] { copy *self.mod_path } fn bt_push(&self, ei: codemap::ExpnInfo) { match ei { ExpandedFrom(CallInfo {call_site: cs, callee: ref callee}) => { *self.backtrace = Some(@ExpandedFrom(CallInfo { call_site: span {lo: cs.lo, hi: cs.hi, expn_info: *self.backtrace}, callee: copy *callee})); } } } fn bt_pop(&self) { match *self.backtrace { Some(@ExpandedFrom(CallInfo { call_site: span {expn_info: prev, _}, _ })) => { *self.backtrace = prev } _ => self.bug("tried to pop without a push") } } fn span_fatal(&self, sp: span, msg: &str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_fatal(sp, msg); } fn span_err(&self, sp: span, msg: &str) { self.print_backtrace(); self.parse_sess.span_diagnostic.span_err(sp, msg); } fn span_warn(&self, sp: span, msg: &str) { self.print_backtrace(); self.parse_sess.span_diagnostic.span_warn(sp, msg); } fn span_unimpl(&self, sp: span, msg: &str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_unimpl(sp, msg); } fn span_bug(&self, sp: span, msg: &str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.span_bug(sp, msg); } fn bug(&self, msg: &str) -> ! { self.print_backtrace(); self.parse_sess.span_diagnostic.handler().bug(msg); } fn next_id(&self) -> ast::node_id { return parse::next_node_id(self.parse_sess); } fn trace_macros(&self) -> bool { *self.trace_mac } fn set_trace_macros(&self, x: bool) { *self.trace_mac = x } fn str_of(&self, id: ast::ident) -> ~str { copy *self.parse_sess.interner.get(id) } fn ident_of(&self, st: &str) -> ast::ident { self.parse_sess.interner.intern(st) } } let imp: @CtxtRepr = @CtxtRepr { parse_sess: parse_sess, cfg: cfg, backtrace: @mut None, mod_path: @mut ~[], trace_mac: @mut false }; ((imp) as @ext_ctxt) } pub fn expr_to_str(cx: @ext_ctxt, expr: @ast::expr, err_msg: ~str) -> ~str { match expr.node { ast::expr_lit(l) => match l.node { ast::lit_str(s) => copy *s, _ => cx.span_fatal(l.span, err_msg) }, _ => cx.span_fatal(expr.span, err_msg) } } pub fn expr_to_ident(cx: @ext_ctxt, expr: @ast::expr, err_msg: &str) -> ast::ident { match expr.node { ast::expr_path(p) => { if p.types.len() > 0u || p.idents.len() != 1u { cx.span_fatal(expr.span, err_msg); } return p.idents[0]; } _ => cx.span_fatal(expr.span, err_msg) } } pub fn check_zero_tts(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree], name: &str) { if tts.len() != 0 { cx.span_fatal(sp, fmt!("%s takes no arguments", name)); } } pub fn get_single_str_from_tts(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree], name: &str) -> ~str { if tts.len() != 1 { cx.span_fatal(sp, fmt!("%s takes 1 argument.", name)); } match tts[0] { ast::tt_tok(_, token::LIT_STR(ident)) => cx.str_of(ident), _ => cx.span_fatal(sp, fmt!("%s requires a string.", name)) } } pub fn get_exprs_from_tts(cx: @ext_ctxt, tts: &[ast::token_tree]) -> ~[@ast::expr] { let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), vec::to_owned(tts)); let mut es = ~[]; while *p.token != token::EOF { if es.len() != 0 { p.eat(&token::COMMA); } es.push(p.parse_expr()); } es } // in order to have some notion of scoping for macros, // we want to implement the notion of a transformation // environment. // This environment maps Names to Transformers. // Initially, this includes macro definitions and // block directives. // Actually, the following implementation is parameterized // by both key and value types. //impl question: how to implement it? Initially, the // env will contain only macros, so it might be painful // to add an empty frame for every context. Let's just // get it working, first.... // NB! the mutability of the underlying maps means that // if expansion is out-of-order, a deeper scope may be // able to refer to a macro that was added to an enclosing // scope lexically later than the deeper scope. // Note on choice of representation: I've been pushed to // use a top-level managed pointer by some difficulties // with pushing and popping functionally, and the ownership // issues. As a result, the values returned by the table // also need to be managed; the &'self ... type that Maps // return won't work for things that need to get outside // of that managed pointer. The easiest way to do this // is just to insist that the values in the tables are // managed to begin with. // a transformer env is either a base map or a map on top // of another chain. pub enum MapChain { BaseMapChain(~HashMap), ConsMapChain(~HashMap,@mut MapChain) } // get the map from an env frame impl MapChain{ // Constructor. I don't think we need a zero-arg one. fn new(init: ~HashMap) -> @mut MapChain { @mut BaseMapChain(init) } // add a new frame to the environment (functionally) fn push_frame (@mut self) -> @mut MapChain { @mut ConsMapChain(~HashMap::new() ,self) } // no need for pop, it'll just be functional. // utility fn... // ugh: can't get this to compile with mut because of the // lack of flow sensitivity. fn get_map<'a>(&'a self) -> &'a HashMap { match *self { BaseMapChain (~ref map) => map, ConsMapChain (~ref map,_) => map } } // traits just don't work anywhere...? //pub impl Map for MapChain { fn contains_key (&self, key: &K) -> bool { match *self { BaseMapChain (ref map) => map.contains_key(key), ConsMapChain (ref map,ref rest) => (map.contains_key(key) || rest.contains_key(key)) } } // should each_key and each_value operate on shadowed // names? I think not. // delaying implementing this.... fn each_key (&self, _f: &fn (&K)->bool) { fail!("unimplemented 2013-02-15T10:01"); } fn each_value (&self, _f: &fn (&V) -> bool) { fail!("unimplemented 2013-02-15T10:02"); } // Returns a copy of the value that the name maps to. // Goes down the chain 'til it finds one (or bottom out). fn find (&self, key: &K) -> Option<@V> { match self.get_map().find (key) { Some(ref v) => Some(**v), None => match *self { BaseMapChain (_) => None, ConsMapChain (_,ref rest) => rest.find(key) } } } // insert the binding into the top-level map fn insert (&mut self, key: K, ext: @V) -> bool { // can't abstract over get_map because of flow sensitivity... match *self { BaseMapChain (~ref mut map) => map.insert(key, ext), ConsMapChain (~ref mut map,_) => map.insert(key,ext) } } } #[cfg(test)] mod test { use super::MapChain; use core::hashmap::HashMap; #[test] fn testenv () { let mut a = HashMap::new(); a.insert (@~"abc",@15); let m = MapChain::new(~a); m.insert (@~"def",@16); // FIXME: #4492 (ICE) assert_eq!(m.find(&@~"abc"),Some(@15)); // .... assert_eq!(m.find(&@~"def"),Some(@16)); assert_eq!(*(m.find(&@~"abc").get()),15); assert_eq!(*(m.find(&@~"def").get()),16); let n = m.push_frame(); // old bindings are still present: assert_eq!(*(n.find(&@~"abc").get()),15); assert_eq!(*(n.find(&@~"def").get()),16); n.insert (@~"def",@17); // n shows the new binding assert_eq!(*(n.find(&@~"abc").get()),15); assert_eq!(*(n.find(&@~"def").get()),17); // ... but m still has the old ones // FIXME: #4492: assert_eq!(m.find(&@~"abc"),Some(@15)); // FIXME: #4492: assert_eq!(m.find(&@~"def"),Some(@16)); assert_eq!(*(m.find(&@~"abc").get()),15); assert_eq!(*(m.find(&@~"def").get()),16); } }