Remove residual uses of fold, and fold itself.

src/comp/driver/rustc.rs

@@ -90,8 +90,6 @@ fn compile_input(session::session sess,
                       bind parse_input(sess, p, input));
     if (sess.get_opts().output_type == link::output_type_none) {ret;}
 
-    crate = time(time_passes, "external crate reading",
-                 bind creader::read_crates(sess, crate));
     auto def_map = time(time_passes, "resolution",
                         bind resolve::resolve_crate(sess, crate));
 
@@ -121,7 +119,6 @@ fn pretty_print_input(session::session sess, eval::env env, str input,
 
     auto mode;
     if (typed) {
-        crate = creader::read_crates(sess, crate);
         auto def_map = resolve::resolve_crate(sess, crate);
         auto ty_cx = ty::mk_ctxt(sess, def_map);
         typeck::check_crate(ty_cx, crate);

src/comp/front/ast.rs

@@ -402,7 +402,7 @@ type variant = spanned[variant_];
 
 type view_item = spanned[view_item_];
 tag view_item_ {
-    view_item_use(ident, vec[@meta_item], def_id, option::t[int]);
+    view_item_use(ident, vec[@meta_item], def_id, ann);
     view_item_import(ident, vec[ident], def_id);
     view_item_export(ident);
 }

src/comp/front/creader.rs

@@ -6,7 +6,8 @@ import lib::llvm::False;
 import lib::llvm::llvm;
 import lib::llvm::mk_object_file;
 import lib::llvm::mk_section_iter;
-import middle::fold;
+import middle::resolve;
+import middle::walk;
 import middle::metadata;
 import middle::trans;
 import middle::ty;
@@ -28,13 +29,6 @@ import std::option::some;
 import std::os;
 import std::map::hashmap;
 
-// TODO: map to a real type here.
-type env = @rec(
-    session::session sess,
-    @hashmap[str, int] crate_cache,
-    vec[str] library_search_paths,
-    mutable int next_crate_num
-);
 
 // Type decoding
 
@@ -453,38 +447,49 @@ fn load_crate(session::session sess,
     fail;
 }
 
-fn fold_view_item_use(&env e, &span sp, &ast::ident ident,
-                      &vec[@ast::meta_item] meta_items,
-                      &ast::def_id id, &option::t[int] cnum_opt)
-    -> @ast::view_item {
-    auto cnum;
-    if (!e.crate_cache.contains_key(ident)) {
-        cnum = e.next_crate_num;
-        load_crate(e.sess, cnum, ident, e.library_search_paths);
-        e.crate_cache.insert(ident, e.next_crate_num);
-        e.next_crate_num += 1;
-    } else {
-        cnum = e.crate_cache.get(ident);
-    }
+type env = @rec(
+    session::session sess,
+    resolve::crate_map crate_map,
+    @hashmap[str, int] crate_cache,
+    vec[str] library_search_paths,
+    mutable int next_crate_num
+);
 
-    auto viu = ast::view_item_use(ident, meta_items, id, some[int](cnum));
-    ret @fold::respan[ast::view_item_](sp, viu);
+fn visit_view_item(env e, &@ast::view_item i) {
+    alt (i.node) {
+        case (ast::view_item_use(?ident, ?meta_items, ?id, ?ann)) {
+            auto cnum;
+            if (!e.crate_cache.contains_key(ident)) {
+                cnum = e.next_crate_num;
+                load_crate(e.sess, cnum, ident,
+                           e.library_search_paths);
+                e.crate_cache.insert(ident, e.next_crate_num);
+                e.next_crate_num += 1;
+            } else {
+                cnum = e.crate_cache.get(ident);
+            }
+            e.crate_map.insert(ann.id, cnum);
+        }
+        case (_) { }
+    }
 }
 
+
 // Reads external crates referenced by "use" directives.
 fn read_crates(session::session sess,
-               @ast::crate crate) -> @ast::crate {
+               resolve::crate_map crate_map,
+               &ast::crate crate) {
     auto e = @rec(
         sess=sess,
+        crate_map=crate_map,
         crate_cache=@common::new_str_hash[int](),
         library_search_paths=sess.get_opts().library_search_paths,
         mutable next_crate_num=1
     );
 
-    auto f = fold_view_item_use;
-    auto fld = @rec(fold_view_item_use=f
-                    with *fold::new_identity_fold[env]());
-    ret fold::fold_crate[env](e, fld, crate);
+    auto v = rec(visit_view_item_pre=bind visit_view_item(e, _)
+                 with walk::default_visitor());
+    walk::walk_crate(v, crate);
 }
 
 

src/comp/front/parser.rs

@@ -2181,7 +2181,7 @@ fn parse_use(&parser p) -> @ast::view_item {
     auto hi = p.get_hi_pos();
     expect(p, token::SEMI);
     auto use_decl = ast::view_item_use(ident, metadata, p.next_def_id(),
-                                      none[int]);
+                                       p.get_ann());
     ret @spanned(lo, hi, use_decl);
 }
 

src/comp/middle/metadata.rs

@@ -9,7 +9,6 @@ import std::option::some;
 import std::option::none;
 
 import front::ast;
-import middle::fold;
 import middle::trans;
 import middle::ty;
 import back::x86;

src/comp/middle/resolve.rs

@@ -78,10 +78,12 @@ type indexed_mod = rec(option::t[ast::_mod] m, mod_index index);
 /* native modules can't contain tags, and we don't store their ASTs because we
    only need to look at them to determine exports, which they can't control.*/
 
+type crate_map = hashmap[uint,ast::crate_num];
 
 type def_map = hashmap[uint,def];
 
-type env = rec(def_map def_map,
+type env = rec(crate_map crate_map,
+               def_map def_map,
                hashmap[ast::def_num,import_state] imports,
                hashmap[ast::def_num,@indexed_mod] mod_map,
                hashmap[def_id,vec[ident]] ext_map,
@@ -99,12 +101,14 @@ tag namespace {
 }
 
 fn resolve_crate(session sess, @ast::crate crate) -> def_map {
-    auto e = @rec(def_map = new_uint_hash[def](),
+    auto e = @rec(crate_map = new_uint_hash[ast::crate_num](),
+                  def_map = new_uint_hash[def](),
                   imports = new_int_hash[import_state](),
                   mod_map = new_int_hash[@indexed_mod](),
                   ext_map = new_def_hash[vec[ident]](),
                   ext_cache = new_ext_hash(),
                   sess = sess);
+    creader::read_crates(sess, e.crate_map, *crate);
     map_crate(e, *crate);
     resolve_imports(*e);
     check_for_collisions(e, *crate);
@@ -709,8 +713,8 @@ fn lookup_in_mod(&env e, def m, &ident id, namespace ns, dir dr)
 fn found_view_item(&env e, @ast::view_item vi, namespace ns)
     -> option::t[def] {
     alt (vi.node) {
-        case (ast::view_item_use(_, _, _, ?cnum)) {
-            ret some(ast::def_mod(tup(option::get(cnum), -1)));
+        case (ast::view_item_use(_, _, _, ?ann)) {
+            ret some(ast::def_mod(tup(e.crate_map.get(ann.id), -1)));
         }
         case (ast::view_item_import(_, _, ?defid)) {
             ret lookup_import(e, defid, ns);

src/comp/middle/typeck.rs

@@ -2,7 +2,6 @@ import front::ast;
 import front::ast::ann;
 import front::ast::mutability;
 import front::creader;
-import middle::fold;
 import driver::session;
 import util::common;
 import util::common::span;
@@ -688,7 +687,7 @@ mod collect {
                 with variant.node
             );
             write::ty_only(cx.tcx, variant.node.ann.id, result_ty);
-            result += [fold::respan(variant.span, variant_t)];
+            result += [common::respan(variant.span, variant_t)];
         }
 
         ret result;
@@ -1632,7 +1631,6 @@ mod writeback {
         }
         fn keep_going(@mutable bool ignore) -> bool { ret !*ignore; }
 
-        auto fld = fold::new_identity_fold[option::t[@fn_ctxt]]();
         auto visit = rec(keep_going=bind keep_going(ignore),
                          visit_item_pre=bind visit_item_pre(ignore, _),
                          visit_item_post=bind visit_item_post(ignore, _),

src/comp/rustc.rc

@@ -12,7 +12,6 @@ use std;
 mod middle {
     mod trans;
     mod ty;
-    mod fold;
     mod walk;
     mod metadata;
     mod resolve;

src/comp/util/common.rs

@@ -8,11 +8,9 @@ import std::option::some;
 import front::ast;
 import front::ast::ty;
 import front::ast::pat;
+import middle::walk;
 import middle::tstate::ann::ts_ann;
 
-import middle::fold;
-import middle::fold::respan;
-
 import std::io::stdout;
 import std::io::str_writer;
 import std::io::string_writer;
@@ -277,35 +275,25 @@ fn decl_lhs(@ast::decl d) -> ast::def_id {
                     ret d.ctor; /* This doesn't really make sense */
                 }
             }
-        } 
+        }
     }
 }
 
 fn has_nonlocal_exits(&ast::block b) -> bool {
-    /* overkill, but just passing around a mutable bool doesn't seem
-       to work in rustboot */
-    auto has_exits = new_str_hash[()]();
+   auto has_exits = @mutable false;
 
-   fn set_break(&flag f, &span sp, &ast::ann a) -> @ast::expr {
-        f.insert("foo", ());
-        ret @respan(sp, ast::expr_break(a));
-    }
-    fn set_cont(&flag f, &span sp, &ast::ann a) -> @ast::expr {
-        f.insert("foo", ());
-        ret @respan(sp, ast::expr_cont(a));
-    }
-    fn check_b(&flag f) -> bool {
-        ret (f.size() == 0u);
-    }
+   fn visit_expr(@mutable bool flag, &@ast::expr e) {
+       alt (e.node) {
+           case (ast::expr_break(_)) { *flag = true; }
+           case (ast::expr_cont(_)) { *flag = true; }
+           case (_) { }
+       }
+   }
 
-    auto fld0 = fold::new_identity_fold[flag]();
-
-    fld0 = @rec(fold_expr_break = bind set_break(_,_,_),
-                fold_expr_cont  = bind set_cont(_,_,_),
-                keep_going      = bind check_b(_) with *fld0);
-    fold::fold_block[flag](has_exits, fld0, b);
-
-    ret (has_exits.size() > 0u);
+    auto v = rec(visit_expr_pre=bind visit_expr(has_exits, _)
+                 with walk::default_visitor());
+    walk::walk_block(v, b);
+    ret *has_exits;
 }
 
 fn local_rhs_span(&@ast::local l, &ast::span def) -> ast::span {
@@ -315,6 +303,10 @@ fn local_rhs_span(&@ast::local l, &ast::span def) -> ast::span {
     }
 }
 
+fn respan[T](&span sp, &T t) -> spanned[T] {
+    ret rec(node=t, span=sp);
+}
+
 //
 // Local Variables:
 // mode: rust