Macros

src/comp/driver/rustc.rs

@@ -80,10 +80,10 @@ fn parse_input(session::session sess, &ast::crate_cfg cfg, str input)
     -> @ast::crate {
     ret if (str::ends_with(input, ".rc")) {
             parser::parse_crate_from_crate_file
-                (input, cfg, sess.get_codemap())
+                (input, cfg, sess.get_parse_sess())
         } else if (str::ends_with(input, ".rs")) {
             parser::parse_crate_from_source_file
-                (input, cfg, sess.get_codemap())
+                (input, cfg, sess.get_parse_sess())
         } else { sess.fatal("unknown input file type: " + input); fail };
 }
 
@@ -110,6 +110,9 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
         crate = time(time_passes, "building test harness",
                      bind front::test::modify_for_testing(crate));
     }
+    crate = time(time_passes, "expansion",
+                 bind syntax::ext::expand::expand_crate(sess, crate));
+
     auto ast_map = time(time_passes, "ast indexing",
                         bind middle::ast_map::map_crate(*crate));
     time(time_passes, "external crate/lib resolution",
@@ -357,7 +360,8 @@ fn build_session(@session::options sopts) -> session::session {
     auto target_cfg = build_target_config();
     auto cstore = cstore::mk_cstore();
     ret session::session(target_cfg, sopts, cstore,
-                         codemap::new_codemap(), 0u);
+                         @rec(cm=codemap::new_codemap(), mutable next_id=0),
+                         0u);
 }
 
 fn parse_pretty(session::session sess, &str name) -> pp_mode {

src/comp/driver/session.rs

@@ -11,6 +11,7 @@ import std::option::some;
 import std::option::none;
 import std::str;
 import std::vec;
+import syntax::parse::parser::parse_sess;
 
 tag os { os_win32; os_macos; os_linux; }
 
@@ -47,26 +48,26 @@ type crate_metadata = rec(str name, vec[u8] data);
 obj session(@config targ_cfg,
             @options opts,
             metadata::cstore::cstore cstore,
-            codemap::codemap cm,
+            parse_sess parse_sess,
             mutable uint err_count) {
     fn get_targ_cfg() -> @config { ret targ_cfg; }
     fn get_opts() -> @options { ret opts; }
     fn get_cstore() -> metadata::cstore::cstore { cstore }
     fn span_fatal(span sp, str msg) -> ! {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_error(some(sp), msg, cm);
+        codemap::emit_error(some(sp), msg, parse_sess.cm);
         fail;
     }
     fn fatal(str msg) -> ! {
-        codemap::emit_error(none, msg, cm);
+        codemap::emit_error(none, msg, parse_sess.cm);
         fail;
     }
     fn span_err(span sp, str msg) {
-        codemap::emit_error(some(sp), msg, cm);
+        codemap::emit_error(some(sp), msg, parse_sess.cm);
         err_count += 1u;
     }
     fn err(str msg) {
-        codemap::emit_error(none, msg, cm);
+        codemap::emit_error(none, msg, parse_sess.cm);
         err_count += 1u;
     }
     fn abort_if_errors() {
@@ -76,17 +77,17 @@ obj session(@config targ_cfg,
     }
     fn span_warn(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_warning(some(sp), msg, cm);
+        codemap::emit_warning(some(sp), msg, parse_sess.cm);
     }
     fn warn(str msg) {
-        codemap::emit_warning(none, msg, cm);
+        codemap::emit_warning(none, msg, parse_sess.cm);
     }
     fn span_note(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        codemap::emit_note(some(sp), msg, cm);
+        codemap::emit_note(some(sp), msg, parse_sess.cm);
     }
     fn note(str msg) {
-        codemap::emit_note(none, msg, cm);
+        codemap::emit_note(none, msg, parse_sess.cm);
     }
     fn span_bug(span sp, str msg) -> ! {
         self.span_fatal(sp, #fmt("internal compiler error %s", msg));
@@ -98,9 +99,13 @@ obj session(@config targ_cfg,
         self.span_bug(sp, "unimplemented " + msg);
     }
     fn unimpl(str msg) -> ! { self.bug("unimplemented " + msg); }
-    fn get_codemap() -> codemap::codemap { ret cm; }
+    fn get_codemap() -> codemap::codemap { ret parse_sess.cm; }
     fn lookup_pos(uint pos) -> codemap::loc {
-        ret codemap::lookup_pos(cm, pos);
+        ret codemap::lookup_pos(parse_sess.cm, pos);
+    }
+    fn get_parse_sess() -> parse_sess { ret parse_sess; }
+    fn next_node_id() -> ast::node_id {
+        ret syntax::parse::parser::next_node_id(parse_sess);
     }
     fn span_str(span sp) -> str {
         ret codemap::span_to_str(sp, self.get_codemap());

src/comp/middle/trans.rs

@@ -6378,8 +6378,8 @@ fn trans_expr_out(&@block_ctxt cx, &@ast::expr e, out_method output) ->
         case (ast::expr_rec(?args, ?base)) {
             ret trans_rec(cx, args, base, e.id);
         }
-        case (ast::expr_ext(_, _, _, ?expanded)) {
-            ret trans_expr(cx, expanded);
+        case (ast::expr_mac(_)) {
+            ret cx.fcx.lcx.ccx.sess.bug("unexpanded macro");
         }
         case (ast::expr_fail(?expr)) {
             ret trans_fail_expr(cx, some(e.span), expr);

src/comp/middle/tstate/pre_post_conditions.rs

@@ -570,9 +570,8 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) {
         case (expr_break) { clear_pp(expr_pp(fcx.ccx, e)); }
         case (expr_cont) { clear_pp(expr_pp(fcx.ccx, e)); }
         case (expr_port(_)) { clear_pp(expr_pp(fcx.ccx, e)); }
-        case (expr_ext(_, _, _, ?expanded)) {
-            find_pre_post_expr(fcx, expanded);
-            copy_pre_post(fcx.ccx, e.id, expanded);
+        case (expr_mac(_)) {
+            fcx.ccx.tcx.sess.bug("unexpanded macro");
         }
         case (expr_anon_obj(?anon_obj, _)) {
             alt (anon_obj.with_obj) {

src/comp/middle/tstate/states.rs

@@ -367,8 +367,8 @@ fn find_pre_post_state_expr(&fn_ctxt fcx, &prestate pres, @expr e) -> bool {
         case (expr_chan(?ex)) {
             ret find_pre_post_state_sub(fcx, pres, ex, e.id, none);
         }
-        case (expr_ext(_, _, _, ?expanded)) {
-            ret find_pre_post_state_sub(fcx, pres, expanded, e.id, none);
+        case (expr_mac(_)) {
+            fcx.ccx.tcx.sess.bug("unexpanded macro");
         }
         case (expr_put(?maybe_e)) {
             alt (maybe_e) {

src/comp/middle/typeck.rs

@@ -1780,10 +1780,8 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
             }
             write::ty_only_fixup(fcx, id, tpt._1);
         }
-        case (ast::expr_ext(?p, ?args, ?body, ?expanded)) {
-            check_expr(fcx, expanded);
-            auto t = expr_ty(fcx.ccx.tcx, expanded);
-            write::ty_only_fixup(fcx, id, t);
+        case (ast::expr_mac(_)) {
+            fcx.ccx.tcx.sess.bug("unexpanded macro");
         }
         case (ast::expr_fail(?expr_opt)) {
             alt (expr_opt) {

src/comp/rustc.rc

@@ -53,6 +53,7 @@ mod syntax {
         mod fmt;
         mod env;
         mod simplext;
+        mod expand;
     }
     mod print {
         mod pprust;

src/comp/syntax/ast.rs

@@ -305,7 +305,6 @@ tag expr_ {
     expr_field(@expr, ident);
     expr_index(@expr, @expr);
     expr_path(path);
-    expr_ext(path, (@expr)[], option::t[str], @expr);
     expr_fail(option::t[@expr]);
     expr_break;
     expr_cont;
@@ -325,6 +324,16 @@ tag expr_ {
     expr_port(option::t[@ty]);
     expr_chan(@expr);
     expr_anon_obj(anon_obj, ty_param[]);
+    expr_mac(mac);
+}
+
+type mac = spanned[mac_];
+
+tag mac_ {
+    mac_invoc(path, (@expr)[], option::t[str]);
+    mac_embed_type(@ty);
+    mac_embed_block(block);
+    mac_ellipsis;
 }
 
 type lit = spanned[lit_];
@@ -434,6 +443,7 @@ tag ty_ {
     ty_path(path, node_id);
     ty_type;
     ty_constr(@ty, (@constr)[]);
+    ty_mac(mac);
 }
 
 

src/comp/syntax/ext/base.rs

@@ -2,7 +2,7 @@ import std::ivec;
 import std::vec;
 import std::option;
 import std::map::hashmap;
-import parse::parser::parse_sess;
+import driver::session::session;
 import codemap::span;
 import std::map::new_str_hash;
 import codemap;
@@ -41,14 +41,14 @@ type ext_ctxt =
         span_msg_fn span_unimpl,
         next_id_fn next_id);
 
-fn mk_ctxt(&parse_sess sess) -> ext_ctxt {
-    fn ext_span_fatal_(&codemap::codemap cm, span sp, str msg) -> ! {
-        codemap::emit_error(option::some(sp), msg, cm);
+fn mk_ctxt(&session sess) -> ext_ctxt {
+    fn ext_span_fatal_(&session sess, span sp, str msg) -> ! {
+        sess.span_err(sp, msg);
         fail;
     }
-    auto ext_span_fatal = bind ext_span_fatal_(sess.cm, _, _);
-    fn ext_span_unimpl_(&codemap::codemap cm, span sp, str msg) -> ! {
-        codemap::emit_error(option::some(sp), "unimplemented " + msg, cm);
+    auto ext_span_fatal = bind ext_span_fatal_(sess, _, _);
+    fn ext_span_unimpl_(&session sess, span sp, str msg) -> ! {
+        sess.span_err(sp, "unimplemented " + msg);
         fail;
     }
 
@@ -59,9 +59,12 @@ fn mk_ctxt(&parse_sess sess) -> ext_ctxt {
     // the extensions the file name of the crate being compiled so they can
     // use it to guess whether paths should be prepended with "std::". This is
     // super-ugly and needs a better solution.
-    auto crate_file_name_hack = sess.cm.files.(0).name;
-    auto ext_span_unimpl = bind ext_span_unimpl_(sess.cm, _, _);
-    auto ext_next_id = bind parse::parser::next_node_id(sess);
+    auto crate_file_name_hack = sess.get_codemap().files.(0).name;
+    auto ext_span_unimpl = bind ext_span_unimpl_(sess, _, _);
+    fn ext_next_id_(&session sess) -> ast::node_id {
+        ret sess.next_node_id(); // temporary, until bind works better
+    }
+    auto ext_next_id = bind ext_next_id_(sess);
     ret rec(crate_file_name_hack=crate_file_name_hack,
             span_fatal=ext_span_fatal,
             span_unimpl=ext_span_unimpl,

src/comp/syntax/ext/expand.rs

@@ -0,0 +1,78 @@
+
+import codemap::emit_error;
+import driver::session;
+import syntax::ast::crate;
+import syntax::ast::expr_;
+import syntax::ast::expr_mac;
+import syntax::ast::mac_invoc;
+import syntax::fold::*;
+
+import std::option::none;
+import std::option::some;
+
+import std::map::hashmap;
+import std::ivec;
+
+fn expand_expr(&hashmap[str, base::syntax_extension] exts, 
+               &session::session sess, &expr_ e, ast_fold fld, 
+               &fn(&ast::expr_, ast_fold) -> expr_ orig) -> expr_ {
+    ret alt(e) {
+        case (expr_mac(?mac)) {
+            alt(mac.node) {
+                case (mac_invoc(?pth, ?args, ?body)) {
+                    assert(ivec::len(pth.node.idents) > 0u);
+                    auto extname = pth.node.idents.(0);
+                    auto ext_cx = base::mk_ctxt(sess);
+                    alt (exts.find(extname)) {
+                        case (none) {
+                            emit_error(some(pth.span), 
+                                       "unknown syntax expander: '"
+                                       + extname + "'", sess.get_codemap());
+                            fail
+                        }
+                        case (some(base::normal(?ext))) {
+                            //keep going, outside-in
+                            fld.fold_expr(ext(ext_cx, pth.span, 
+                                              args, body)).node
+                        }
+                        case (some(base::macro_defining(?ext))) {
+                            auto named_extension 
+                                = ext(ext_cx, pth.span, args, body);
+                            exts.insert(named_extension._0,
+                                        named_extension._1);
+                            ast::expr_tup(~[])
+                        }
+                    }
+                }
+                case (_) {
+                    emit_error(some(mac.span), "naked syntactic bit",
+                               sess.get_codemap());
+                    fail
+                }
+            }
+        }
+        case (_) { orig(e, fld) }
+    };
+}
+
+fn expand_crate(&session::session sess, &@crate c) -> @crate {
+    auto exts = ext::base::syntax_expander_table();
+    auto afp = default_ast_fold();
+    auto f_pre =
+        rec(fold_expr = bind expand_expr(exts, sess, _, _, afp.fold_expr)
+            with *afp);
+    auto f = make_fold(f_pre);
+    auto res = @f.fold_crate(*c);
+    dummy_out(f); //temporary: kill circular reference
+    ret res;
+
+}
+
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End: