auto merge of #7124 : Aatch/rust/trans-refactor-pt1, r=brson

This removes all of the explicit `@mut` fields from `CrateContext`. There are still a few that are managed, but no longer do we have `@mut bool` in the structure.

Most of the changes are changing `@CrateContext` to `@mut CrateContext`, though I did change as many as I could get away with to `&CrateContext` and `&mut CrateContext`. The biggest thing preventing me from changing to `&[mut]` in most places was the instruction counter thing. In two cases, where I got a static borrow error and a dynamic borrow error, I opted to remove the count call there as it was literally the only thing preventing me from switching to `&mut CrateContext` parameters in both cases.

Other things to note:

* the EncoderContext uses borrowed pointers with lifetimes, since it can, though that required me to work around the limitation of not being able to move a structure with borrowed pointers into a heap closure. I changed as much as I could to stack closures, but unfortunately I hit the AST visitor and changing that is somewhat outside the scope of this PR. Instead (and there is a comment to this effect) I choose to unsafely get the structure into the heap, this is because I know the lifetimes involved are safe, even though the compiler can't prove it.

* Many of the changes are workarounds because of the borrow checker, either dynamically freezing it for too long, or inferring too large a scope. This is mostly just from nested function calls where each borrow is considered to last for the entire statement. Other cases are where `CrateContext` was borrowed in a `match` causing it to be borrowed for the entire length of the match, even though that wasn't wanted (or needed).

* I haven't yet tested to see if this changes compilation times in any way. I doubt there will be much of an impact however, as the only major improvements are less indirection and fewer refcount bumps.

* This lays the foundations to remove many more heap allocations in trans as many cases can be changed to use lifetimes instead.

=====

This change includes some other, minor refactorings, as I am planning a series, however I don't want to submit them all at once as it will be hell to continually rebase.

Author: bors

src/librustc/back/link.rs

@@ -18,7 +18,7 @@ use lib::llvm::ModuleRef;
 use lib;
 use metadata::common::LinkMeta;
 use metadata::{encoder, csearch, cstore};
-use middle::trans::common::CrateContext;
+use middle::trans::context::CrateContext;
 use middle::ty;
 use util::ppaux;
 
@@ -622,11 +622,11 @@ pub fn symbol_hash(tcx: ty::ctxt,
     hash.to_managed()
 }
 
-pub fn get_symbol_hash(ccx: @CrateContext, t: ty::t) -> @str {
+pub fn get_symbol_hash(ccx: &mut CrateContext, t: ty::t) -> @str {
     match ccx.type_hashcodes.find(&t) {
       Some(&h) => h,
       None => {
-        let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
+        let hash = symbol_hash(ccx.tcx, &mut ccx.symbol_hasher, t, ccx.link_meta);
         ccx.type_hashcodes.insert(t, hash);
         hash
       }
@@ -705,7 +705,7 @@ pub fn exported_name(sess: Session,
             path_name(sess.ident_of(vers))));
 }
 
-pub fn mangle_exported_name(ccx: @CrateContext,
+pub fn mangle_exported_name(ccx: &mut CrateContext,
                             path: path,
                             t: ty::t) -> ~str {
     let hash = get_symbol_hash(ccx, t);
@@ -714,7 +714,7 @@ pub fn mangle_exported_name(ccx: @CrateContext,
                          ccx.link_meta.vers);
 }
 
-pub fn mangle_internal_name_by_type_only(ccx: @CrateContext,
+pub fn mangle_internal_name_by_type_only(ccx: &mut CrateContext,
                                          t: ty::t,
                                          name: &str) -> ~str {
     let s = ppaux::ty_to_short_str(ccx.tcx, t);
@@ -725,7 +725,7 @@ pub fn mangle_internal_name_by_type_only(ccx: @CrateContext,
           path_name(ccx.sess.ident_of(hash))]);
 }
 
-pub fn mangle_internal_name_by_type_and_seq(ccx: @CrateContext,
+pub fn mangle_internal_name_by_type_and_seq(ccx: &mut CrateContext,
                                          t: ty::t,
                                          name: &str) -> ~str {
     let s = ppaux::ty_to_str(ccx.tcx, t);
@@ -736,18 +736,18 @@ pub fn mangle_internal_name_by_type_and_seq(ccx: @CrateContext,
           path_name((ccx.names)(name))]);
 }
 
-pub fn mangle_internal_name_by_path_and_seq(ccx: @CrateContext,
+pub fn mangle_internal_name_by_path_and_seq(ccx: &mut CrateContext,
                                             path: path,
                                             flav: &str) -> ~str {
     return mangle(ccx.sess,
                   vec::append_one(path, path_name((ccx.names)(flav))));
 }
 
-pub fn mangle_internal_name_by_path(ccx: @CrateContext, path: path) -> ~str {
+pub fn mangle_internal_name_by_path(ccx: &mut CrateContext, path: path) -> ~str {
     return mangle(ccx.sess, path);
 }
 
-pub fn mangle_internal_name_by_seq(ccx: @CrateContext, flav: &str) -> ~str {
+pub fn mangle_internal_name_by_seq(ccx: &mut CrateContext, flav: &str) -> ~str {
     return fmt!("%s_%u", flav, (ccx.names)(flav).name);
 }
 

src/librustc/driver/driver.rs

@@ -219,109 +219,109 @@ pub fn compile_rest(sess: Session,
     crate = time(time_passes, ~"intrinsic injection", ||
                  front::intrinsic_inject::inject_intrinsic(sess, crate));
 
-    crate = time(time_passes, ~"extra injection", ||
-                 front::std_inject::maybe_inject_libstd_ref(sess, crate));
+        crate = time(time_passes, ~"extra injection", ||
+                     front::std_inject::maybe_inject_libstd_ref(sess, crate));
 
-    let ast_map = time(time_passes, ~"ast indexing", ||
-                       syntax::ast_map::map_crate(sess.diagnostic(), crate));
+        let ast_map = time(time_passes, ~"ast indexing", ||
+                           syntax::ast_map::map_crate(sess.diagnostic(), crate));
 
-    time(time_passes, ~"external crate/lib resolution", ||
-         creader::read_crates(sess.diagnostic(), crate, sess.cstore,
-                              sess.filesearch,
-                              session::sess_os_to_meta_os(sess.targ_cfg.os),
-                              sess.opts.is_static,
-                              token::get_ident_interner()));
+        time(time_passes, ~"external crate/lib resolution", ||
+             creader::read_crates(sess.diagnostic(), crate, sess.cstore,
+                                  sess.filesearch,
+                                  session::sess_os_to_meta_os(sess.targ_cfg.os),
+                                  sess.opts.is_static,
+                                  token::get_ident_interner()));
 
-    let lang_items = time(time_passes, ~"language item collection", ||
-                          middle::lang_items::collect_language_items(crate, sess));
+        let lang_items = time(time_passes, ~"language item collection", ||
+                              middle::lang_items::collect_language_items(crate, sess));
 
-    let middle::resolve::CrateMap {
-        def_map: def_map,
-        exp_map2: exp_map2,
-        trait_map: trait_map
-    } =
-        time(time_passes, ~"resolution", ||
-             middle::resolve::resolve_crate(sess, lang_items, crate));
+        let middle::resolve::CrateMap {
+            def_map: def_map,
+            exp_map2: exp_map2,
+            trait_map: trait_map
+        } =
+            time(time_passes, ~"resolution", ||
+                 middle::resolve::resolve_crate(sess, lang_items, crate));
 
-    time(time_passes, ~"looking for entry point",
-         || middle::entry::find_entry_point(sess, crate, ast_map));
+        time(time_passes, ~"looking for entry point",
+             || middle::entry::find_entry_point(sess, crate, ast_map));
 
-    let freevars = time(time_passes, ~"freevar finding", ||
-                        freevars::annotate_freevars(def_map, crate));
+        let freevars = time(time_passes, ~"freevar finding", ||
+                            freevars::annotate_freevars(def_map, crate));
 
-    let region_map = time(time_passes, ~"region resolution", ||
-                          middle::region::resolve_crate(sess, def_map, crate));
+        let region_map = time(time_passes, ~"region resolution", ||
+                              middle::region::resolve_crate(sess, def_map, crate));
 
-    let rp_set = time(time_passes, ~"region parameterization inference", ||
-                      middle::region::determine_rp_in_crate(sess, ast_map, def_map, crate));
+        let rp_set = time(time_passes, ~"region parameterization inference", ||
+                          middle::region::determine_rp_in_crate(sess, ast_map, def_map, crate));
 
-    let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars,
-                            region_map, rp_set, lang_items);
+        let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars,
+                                region_map, rp_set, lang_items);
 
-    // passes are timed inside typeck
-    let (method_map, vtable_map) = typeck::check_crate(
-        ty_cx, trait_map, crate);
+        // passes are timed inside typeck
+        let (method_map, vtable_map) = typeck::check_crate(
+            ty_cx, trait_map, crate);
 
-    // These next two const passes can probably be merged
-    time(time_passes, ~"const marking", ||
-         middle::const_eval::process_crate(crate, ty_cx));
+        // These next two const passes can probably be merged
+        time(time_passes, ~"const marking", ||
+             middle::const_eval::process_crate(crate, ty_cx));
 
-    time(time_passes, ~"const checking", ||
-         middle::check_const::check_crate(sess, crate, ast_map, def_map,
-                                          method_map, ty_cx));
+        time(time_passes, ~"const checking", ||
+             middle::check_const::check_crate(sess, crate, ast_map, def_map,
+                                              method_map, ty_cx));
 
-    if phases.to == cu_typeck { return (Some(crate), Some(ty_cx)); }
+        if phases.to == cu_typeck { return (Some(crate), Some(ty_cx)); }
 
-    time(time_passes, ~"privacy checking", ||
-         middle::privacy::check_crate(ty_cx, &method_map, crate));
+        time(time_passes, ~"privacy checking", ||
+             middle::privacy::check_crate(ty_cx, &method_map, crate));
 
-    time(time_passes, ~"effect checking", ||
-         middle::effect::check_crate(ty_cx, method_map, crate));
+        time(time_passes, ~"effect checking", ||
+             middle::effect::check_crate(ty_cx, method_map, crate));
 
-    time(time_passes, ~"loop checking", ||
-         middle::check_loop::check_crate(ty_cx, crate));
+        time(time_passes, ~"loop checking", ||
+             middle::check_loop::check_crate(ty_cx, crate));
 
-    let middle::moves::MoveMaps {moves_map, moved_variables_set,
-                                 capture_map} =
-        time(time_passes, ~"compute moves", ||
-             middle::moves::compute_moves(ty_cx, method_map, crate));
+        let middle::moves::MoveMaps {moves_map, moved_variables_set,
+                                     capture_map} =
+            time(time_passes, ~"compute moves", ||
+                 middle::moves::compute_moves(ty_cx, method_map, crate));
 
-    time(time_passes, ~"match checking", ||
-         middle::check_match::check_crate(ty_cx, method_map,
-                                          moves_map, crate));
+        time(time_passes, ~"match checking", ||
+             middle::check_match::check_crate(ty_cx, method_map,
+                                              moves_map, crate));
 
-    time(time_passes, ~"liveness checking", ||
-         middle::liveness::check_crate(ty_cx, method_map,
-                                       capture_map, crate));
-
-    let (root_map, write_guard_map) =
-        time(time_passes, ~"borrow checking", ||
-             middle::borrowck::check_crate(ty_cx, method_map,
-                                           moves_map, moved_variables_set,
+        time(time_passes, ~"liveness checking", ||
+             middle::liveness::check_crate(ty_cx, method_map,
                                            capture_map, crate));
 
-    time(time_passes, ~"kind checking", ||
-         kind::check_crate(ty_cx, method_map, crate));
+        let (root_map, write_guard_map) =
+            time(time_passes, ~"borrow checking", ||
+                 middle::borrowck::check_crate(ty_cx, method_map,
+                                               moves_map, moved_variables_set,
+                                               capture_map, crate));
 
-    time(time_passes, ~"lint checking", ||
-         lint::check_crate(ty_cx, crate));
+        time(time_passes, ~"kind checking", ||
+             kind::check_crate(ty_cx, method_map, crate));
 
-    if phases.to == cu_no_trans { return (Some(crate), Some(ty_cx)); }
+        time(time_passes, ~"lint checking", ||
+             lint::check_crate(ty_cx, crate));
 
-    let maps = astencode::Maps {
-        root_map: root_map,
-        method_map: method_map,
-        vtable_map: vtable_map,
-        write_guard_map: write_guard_map,
-        moves_map: moves_map,
-        capture_map: capture_map
-    };
+        if phases.to == cu_no_trans { return (Some(crate), Some(ty_cx)); }
 
-    let outputs = outputs.get_ref();
-    time(time_passes, ~"translation", ||
-         trans::base::trans_crate(sess, crate, ty_cx,
-                                  &outputs.obj_filename,
-                                  exp_map2, maps))
+        let maps = astencode::Maps {
+            root_map: root_map,
+            method_map: method_map,
+            vtable_map: vtable_map,
+            write_guard_map: write_guard_map,
+            moves_map: moves_map,
+            capture_map: capture_map
+        };
+
+        let outputs = outputs.get_ref();
+        time(time_passes, ~"translation", ||
+             trans::base::trans_crate(sess, crate, ty_cx,
+                                      &outputs.obj_filename,
+                                      exp_map2, maps))
     };
 
     let outputs = outputs.get_ref();