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(sess, 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));
     auto d =
@@ -351,8 +354,9 @@ fn build_session_options(str binary, getopts::match match, str binary_dir) ->
 fn build_session(@session::options sopts) -> session::session {
     auto target_cfg = build_target_config();
     auto crate_cache = std::map::new_int_hash[session::crate_metadata]();
-    ret session::session(target_cfg, sopts, crate_cache, [],
-                         [], [], codemap::new_codemap(), 0u);
+    ret session::session(target_cfg, sopts, crate_cache, [], [], [], 
+                         @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

@@ -10,6 +10,7 @@ import std::option;
 import std::option::some;
 import std::option::none;
 import std::str;
+import syntax::parse::parser::parse_sess;
 
 tag os { os_win32; os_macos; os_linux; }
 
@@ -48,25 +49,25 @@ obj session(@config targ_cfg,
             mutable vec[str] used_crate_files,
             mutable vec[str] used_libraries,
             mutable vec[str] used_link_args,
-            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 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));
@@ -139,9 +140,13 @@ obj session(@config targ_cfg,
     fn get_used_crate_files() -> vec[str] {
        ret used_crate_files;
     }
-    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

@@ -6246,8 +6246,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_ext(_, _, _)) {
+            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

@@ -567,9 +567,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_ext(_, _, _)) {
+            fcx.ccx.tcx.sess.bug("unexpanded macro");
         }
         case (expr_anon_obj(?anon_obj, _)) {
             alt (anon_obj.with_obj) {

src/comp/middle/tstate/states.rs

@@ -323,8 +323,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_ext(_, _, _)) {
+            fcx.ccx.tcx.sess.bug("unexpanded macro");
         }
         case (expr_put(?maybe_e)) {
             alt (maybe_e) {

src/comp/middle/typeck.rs

@@ -1700,10 +1700,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_ext(_,_,_)) {
+            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

@@ -277,7 +277,7 @@ tag expr_ {
     expr_field(@expr, ident);
     expr_index(@expr, @expr);
     expr_path(path);
-    expr_ext(path, vec[@expr], option::t[str], @expr);
+    expr_ext(path, vec[@expr], option::t[str]);
     expr_fail(option::t[@expr]);
     expr_break;
     expr_cont;
@@ -297,6 +297,9 @@ tag expr_ {
     expr_port(option::t[@ty]);
     expr_chan(@expr);
     expr_anon_obj(anon_obj, vec[ty_param]);
+    /* for the macro system */
+    expr_embeded_type(@ty);
+    expr_embeded_block(block);
 }
 
 type lit = spanned[lit_];

src/comp/syntax/ext/base.rs

@@ -1,7 +1,7 @@
 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;
@@ -39,18 +39,21 @@ 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;
     }
-    auto ext_span_unimpl = bind ext_span_unimpl_(sess.cm, _, _);
-    auto ext_next_id = bind parse::parser::next_node_id(sess);
+    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(span_fatal=ext_span_fatal,
             span_unimpl=ext_span_unimpl,
             next_id=ext_next_id);

src/comp/syntax/ext/expand.rs

@@ -0,0 +1,65 @@
+
+import codemap::emit_error;
+import driver::session;
+import syntax::ast::crate;
+import syntax::ast::expr_;
+import syntax::ast::expr_ext;
+import syntax::fold::*;
+
+import std::option::none;
+import std::option::some;
+
+import std::map::hashmap;
+import std::vec;
+
+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_ext(?pth, ?args, ?body)) {
+            assert (vec::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(vec::empty[ast::elt]())
+                }
+            }
+
+        }
+        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: