Remove the environment concept from front::eval

This is the old method of conditional compilation. It is going away.

Issue #489

2 files changed, 31 insertions, 59 deletions

diff --git a/src/comp/front/eval.rs b/src/comp/front/eval.rs
index 2dc76bd793b..df794992311 100644
--- a/src/comp/front/eval.rs
+++ b/src/comp/front/eval.rs
@@ -23,17 +23,14 @@ tag val { val_bool(bool); val_int(int); val_str(str); }
 
 tag eval_mode { mode_depend; mode_parse; }
 
-type env = vec[tup(ident, val)];
-
 type ctx =
     @rec(parser p,
          eval_mode mode,
          mutable vec[str] deps,
          session::session sess,
          mutable uint chpos,
-         mutable int next_id);
-
-fn mk_env() -> env { ret []; }
+         mutable int next_id,
+         ast::crate_cfg cfg);
 
 fn val_is_bool(val v) -> bool {
     alt (v) { case (val_bool(_)) { true } case (_) { false } }
@@ -59,13 +56,6 @@ fn val_as_str(val v) -> str {
     alt (v) { case (val_str(?s)) { s } case (_) { fail } }
 }
 
-fn lookup(session::session sess, env e, span sp, ident i) -> val {
-    for (tup(ident, val) pair in e) {
-        if (str::eq(i, pair._0)) { ret pair._1; }
-    }
-    sess.span_fatal(sp, "unknown variable: " + i)
-}
-
 fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
     alt (lit.node) {
         case (ast::lit_bool(?b)) { val_bool(b) }
@@ -75,18 +65,14 @@ fn eval_lit(ctx cx, span sp, @ast::lit lit) -> val {
     }
 }
 
-fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
+fn eval_expr(ctx cx, @ast::expr x) -> val {
     alt (x.node) {
         case (ast::expr_path(?pth)) {
-            if (vec::len[ident](pth.node.idents) == 1u &&
-                    vec::len[@ast::ty](pth.node.types) == 0u) {
-                ret lookup(cx.sess, e, x.span, pth.node.idents.(0));
-            }
             cx.sess.span_fatal(x.span, "evaluating structured path-name");
         }
         case (ast::expr_lit(?lit)) { ret eval_lit(cx, x.span, lit); }
         case (ast::expr_unary(?op, ?a)) {
-            auto av = eval_expr(cx, e, a);
+            auto av = eval_expr(cx, a);
             alt (op) {
                 case (ast::not) {
                     if (val_is_bool(av)) { ret val_bool(!val_as_bool(av)); }
@@ -98,8 +84,8 @@ fn eval_expr(ctx cx, env e, @ast::expr x) -> val {
             }
         }
         case (ast::expr_binary(?op, ?a, ?b)) {
-            auto av = eval_expr(cx, e, a);
-            auto bv = eval_expr(cx, e, b);
+            auto av = eval_expr(cx, a);
+            auto bv = eval_expr(cx, b);
             alt (op) {
                 case (ast::add) {
                     if (val_is_int(av) && val_is_int(bv)) {
@@ -177,30 +163,30 @@ fn val_eq(session::session sess, span sp, val av, val bv) -> bool {
     } else { sess.span_fatal(sp, "bad types in comparison") }
 }
 
-fn eval_crate_directives(ctx cx, env e, vec[@ast::crate_directive] cdirs,
+fn eval_crate_directives(ctx cx, vec[@ast::crate_directive] cdirs,
                          str prefix, &mutable vec[@ast::view_item] view_items,
                          &mutable vec[@ast::item] items) {
     for (@ast::crate_directive sub_cdir in cdirs) {
-        eval_crate_directive(cx, e, sub_cdir, prefix, view_items, items);
+        eval_crate_directive(cx, sub_cdir, prefix, view_items, items);
     }
 }
 
-fn eval_crate_directives_to_mod(ctx cx, env e,
+fn eval_crate_directives_to_mod(ctx cx,
                                 vec[@ast::crate_directive] cdirs, str prefix)
    -> ast::_mod {
     let vec[@ast::view_item] view_items = [];
     let vec[@ast::item] items = [];
-    eval_crate_directives(cx, e, cdirs, prefix, view_items, items);
+    eval_crate_directives(cx, cdirs, prefix, view_items, items);
     ret rec(view_items=view_items, items=items);
 }
 
-fn eval_crate_directive_block(ctx cx, env e, &ast::block blk, str prefix,
+fn eval_crate_directive_block(ctx cx, &ast::block blk, str prefix,
                               &mutable vec[@ast::view_item] view_items,
                               &mutable vec[@ast::item] items) {
     for (@ast::stmt s in blk.node.stmts) {
         alt (s.node) {
             case (ast::stmt_crate_directive(?cdir)) {
-                eval_crate_directive(cx, e, cdir, prefix, view_items, items);
+                eval_crate_directive(cx, cdir, prefix, view_items, items);
             }
             case (_) {
                 cx.sess.span_fatal(s.span,
@@ -210,22 +196,22 @@ fn eval_crate_directive_block(ctx cx, env e, &ast::block blk, str prefix,
     }
 }
 
-fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
+fn eval_crate_directive_expr(ctx cx, @ast::expr x, str prefix,
                              &mutable vec[@ast::view_item] view_items,
                              &mutable vec[@ast::item] items) {
     alt (x.node) {
         case (ast::expr_if(?cond, ?thn, ?elopt)) {
-            auto cv = eval_expr(cx, e, cond);
+            auto cv = eval_expr(cx, cond);
             if (!val_is_bool(cv)) {
                 cx.sess.span_fatal(x.span, "bad cond type in 'if'");
             }
             if (val_as_bool(cv)) {
-                ret eval_crate_directive_block(cx, e, thn, prefix, view_items,
+                ret eval_crate_directive_block(cx, thn, prefix, view_items,
                                                items);
             }
             alt (elopt) {
                 case (some(?els)) {
-                    ret eval_crate_directive_expr(cx, e, els, prefix,
+                    ret eval_crate_directive_expr(cx, els, prefix,
                                                   view_items, items);
                 }
                 case (_) {
@@ -235,19 +221,19 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
             }
         }
         case (ast::expr_alt(?v, ?arms)) {
-            auto vv = eval_expr(cx, e, v);
+            auto vv = eval_expr(cx, v);
             for (ast::arm arm in arms) {
                 alt (arm.pat.node) {
                     case (ast::pat_lit(?lit, _)) {
                         auto pv = eval_lit(cx, arm.pat.span, lit);
                         if (val_eq(cx.sess, arm.pat.span, vv, pv)) {
-                            ret eval_crate_directive_block(cx, e, arm.block,
+                            ret eval_crate_directive_block(cx, arm.block,
                                                            prefix, view_items,
                                                            items);
                         }
                     }
                     case (ast::pat_wild(_)) {
-                        ret eval_crate_directive_block(cx, e, arm.block,
+                        ret eval_crate_directive_block(cx, arm.block,
                                                        prefix, view_items,
                                                        items);
                     }
@@ -260,24 +246,23 @@ fn eval_crate_directive_expr(ctx cx, env e, @ast::expr x, str prefix,
             cx.sess.span_fatal(x.span, "no cases matched in 'alt'");
         }
         case (ast::expr_block(?block)) {
-            ret eval_crate_directive_block(cx, e, block, prefix, view_items,
+            ret eval_crate_directive_block(cx, block, prefix, view_items,
                                            items);
         }
         case (_) { cx.sess.span_fatal(x.span, "unsupported expr type"); }
     }
 }
 
-fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
+fn eval_crate_directive(ctx cx, @ast::crate_directive cdir, str prefix,
                         &mutable vec[@ast::view_item] view_items,
                         &mutable vec[@ast::item] items) {
     alt (cdir.node) {
         case (ast::cdir_let(?id, ?x, ?cdirs)) {
-            auto v = eval_expr(cx, e, x);
-            auto e0 = [tup(id, v)] + e;
-            eval_crate_directives(cx, e0, cdirs, prefix, view_items, items);
+            auto v = eval_expr(cx, x);
+            eval_crate_directives(cx, cdirs, prefix, view_items, items);
         }
         case (ast::cdir_expr(?x)) {
-            eval_crate_directive_expr(cx, e, x, prefix, view_items, items);
+            eval_crate_directive_expr(cx, x, prefix, view_items, items);
         }
         case (ast::cdir_src_mod(?id, ?file_opt, ?attrs)) {
             auto file_path = id + ".rs";
@@ -292,7 +277,7 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
             };
             if (cx.mode == mode_depend) { cx.deps += [full_path]; ret; }
             auto p0 =
-                new_parser(cx.sess, e, full_path, cx.chpos,
+                new_parser(cx.sess, cx.cfg, full_path, cx.chpos,
                            cx.next_id);
             auto inner_attrs = parse_inner_attrs_and_next(p0);
             auto mod_attrs = attrs + inner_attrs._0;
@@ -315,7 +300,7 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
             } else {
                 prefix + std::fs::path_sep() + path
             };
-            auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
+            auto m0 = eval_crate_directives_to_mod(cx, cdirs, full_path);
             auto i = @rec(ident=id,
                           attrs=attrs,
                           id=cx.next_id,
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index e2f51cba6a5..0d86d5d949e 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -32,7 +32,6 @@ type parser =
         fn restrict(restriction) ;
         fn get_restriction() -> restriction ;
         fn get_file_type() -> file_type ;
-        fn get_env() -> eval::env ;
         fn get_cfg() -> ast::crate_cfg;
         fn get_session() -> session::session ;
         fn get_span() -> common::span ;
@@ -50,10 +49,9 @@ type parser =
         fn next_id() -> ast::node_id ;
     };
 
-fn new_parser(session::session sess, eval::env env,
+fn new_parser(session::session sess, ast::crate_cfg cfg,
               str path, uint pos, ast::node_id next_id) -> parser {
     obj stdio_parser(session::session sess,
-                     eval::env env,
                      ast::crate_cfg cfg,
                      file_type ftype,
                      mutable token::token tok,
@@ -85,7 +83,6 @@ fn new_parser(session::session sess, eval::env env,
         fn get_hi_pos() -> uint { ret hi; }
         fn get_last_lo_pos() -> uint { ret last_lo; }
         fn get_file_type() -> file_type { ret ftype; }
-        fn get_env() -> eval::env { ret env; }
         fn get_cfg() -> ast::crate_cfg { ret cfg; }
         fn get_prec_table() -> vec[op_spec] { ret precs; }
         fn get_str(token::str_num i) -> str {
@@ -106,17 +103,6 @@ fn new_parser(session::session sess, eval::env env,
         fn next_id() -> ast::node_id { ret next_id_var; }
     }
 
-    auto cfg = {
-        fn m(&tup(ast::ident, eval::val) item) -> @ast::meta_item {
-            auto name = item._0;
-            auto value = eval::val_as_str(item._1);
-            auto meta_item_ = ast::meta_name_value(name, value);
-            ret @rec(node=meta_item_,
-                     span=rec(lo=0u,hi=0u));
-        }
-        vec::map(m, env)
-    };
-
     auto ftype = SOURCE_FILE;
     if (str::ends_with(path, ".rc")) { ftype = CRATE_FILE; }
     auto srdr = io::file_reader(path);
@@ -128,7 +114,7 @@ fn new_parser(session::session sess, eval::env env,
 
     lexer::consume_whitespace_and_comments(rdr);
     auto npos = rdr.get_chpos();
-    ret stdio_parser(sess, env, cfg, ftype, lexer::next_token(rdr),
+    ret stdio_parser(sess, cfg, ftype, lexer::next_token(rdr),
                      npos, npos, npos, UNRESTRICTED, rdr,
                      prec_table(), next_id, bad_expr_word_table(),
                      ext::syntax_expander_table());
@@ -2465,9 +2451,10 @@ fn parse_crate_from_crate_file(&parser p) -> @ast::crate {
              mutable deps=deps,
              sess=p.get_session(),
              mutable chpos=p.get_chpos(),
-             mutable next_id=p.next_id());
+             mutable next_id=p.next_id(),
+             cfg = p.get_cfg());
     auto m =
-        eval::eval_crate_directives_to_mod(cx, p.get_env(), cdirs, prefix);
+        eval::eval_crate_directives_to_mod(cx, cdirs, prefix);
     auto hi = p.get_hi_pos();
     expect(p, token::EOF);
     ret @spanned(lo, hi, rec(directives=cdirs,