De-@ move maps and rework parts of trans.

Author: eddyb

src/librustc/back/link.rs

@@ -559,7 +559,7 @@ fn get_symbol_hash(ccx: &CrateContext, t: ty::t) -> ~str {
 
     let mut type_hashcodes = ccx.type_hashcodes.borrow_mut();
     let mut symbol_hasher = ccx.symbol_hasher.borrow_mut();
-    let hash = symbol_hash(ccx.tcx, symbol_hasher.get(), t, &ccx.link_meta);
+    let hash = symbol_hash(ccx.tcx(), symbol_hasher.get(), t, &ccx.link_meta);
     type_hashcodes.get().insert(t, hash.clone());
     hash
 }
@@ -694,7 +694,7 @@ pub fn mangle_exported_name(ccx: &CrateContext, path: PathElems,
 pub fn mangle_internal_name_by_type_only(ccx: &CrateContext,
                                          t: ty::t,
                                          name: &str) -> ~str {
-    let s = ppaux::ty_to_short_str(ccx.tcx, t);
+    let s = ppaux::ty_to_short_str(ccx.tcx(), t);
     let path = [PathName(token::intern(name)),
                 PathName(token::intern(s))];
     let hash = get_symbol_hash(ccx, t);
@@ -704,7 +704,7 @@ pub fn mangle_internal_name_by_type_only(ccx: &CrateContext,
 pub fn mangle_internal_name_by_type_and_seq(ccx: &CrateContext,
                                             t: ty::t,
                                             name: &str) -> ~str {
-    let s = ppaux::ty_to_str(ccx.tcx, t);
+    let s = ppaux::ty_to_str(ccx.tcx(), t);
     let path = [PathName(token::intern(s)),
                 gensym_name(name)];
     let hash = get_symbol_hash(ccx, t);

src/librustc/driver/driver.rs

@@ -35,6 +35,7 @@ use std::cell::{Cell, RefCell};
 use std::io;
 use std::io::fs;
 use std::io::MemReader;
+use std::mem::drop;
 use std::os;
 use std::vec_ng::Vec;
 use std::vec_ng;
@@ -357,17 +358,20 @@ pub fn phase_3_run_analysis_passes(sess: Session,
 
     time(time_passes, "match checking", (), |_|
          middle::check_match::check_crate(&ty_cx, method_map,
-                                          moves_map, krate));
+                                          &moves_map, krate));
 
     time(time_passes, "liveness checking", (), |_|
          middle::liveness::check_crate(&ty_cx, method_map,
-                                       capture_map, krate));
+                                       &capture_map, krate));
 
     let root_map =
         time(time_passes, "borrow checking", (), |_|
              middle::borrowck::check_crate(&ty_cx, method_map,
-                                           moves_map, moved_variables_set,
-                                           capture_map, krate));
+                                           &moves_map, &moved_variables_set,
+                                           &capture_map, krate));
+
+    drop(moves_map);
+    drop(moved_variables_set);
 
     time(time_passes, "kind checking", (), |_|
          kind::check_crate(&ty_cx, method_map, krate));
@@ -396,7 +400,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
             root_map: root_map,
             method_map: method_map,
             vtable_map: vtable_map,
-            capture_map: capture_map
+            capture_map: RefCell::new(capture_map)
         },
         reachable: reachable_map
     }
@@ -414,10 +418,13 @@ pub struct CrateTranslation {
 /// Run the translation phase to LLVM, after which the AST and analysis can
 /// be discarded.
 pub fn phase_4_translate_to_llvm(krate: ast::Crate,
-                                 analysis: &CrateAnalysis,
-                                 outputs: &OutputFilenames) -> CrateTranslation {
-    time(analysis.ty_cx.sess.time_passes(), "translation", krate, |krate|
-         trans::base::trans_crate(krate, analysis, outputs))
+                                 analysis: CrateAnalysis,
+                                 outputs: &OutputFilenames) -> (ty::ctxt, CrateTranslation) {
+    // Option dance to work around the lack of stack once closures.
+    let time_passes = analysis.ty_cx.sess.time_passes();
+    let mut analysis = Some(analysis);
+    time(time_passes, "translation", krate, |krate|
+         trans::base::trans_crate(krate, analysis.take_unwrap(), outputs))
 }
 
 /// Run LLVM itself, producing a bitcode file, assembly file or object file
@@ -582,9 +589,9 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &Input,
 
         let analysis = phase_3_run_analysis_passes(sess, &expanded_crate, ast_map);
         if stop_after_phase_3(&analysis.ty_cx.sess) { return; }
-        let trans = phase_4_translate_to_llvm(expanded_crate,
-                                              &analysis, &outputs);
-        (outputs, trans, analysis.ty_cx.sess)
+        let (tcx, trans) = phase_4_translate_to_llvm(expanded_crate,
+                                                     analysis, &outputs);
+        (outputs, trans, tcx.sess)
     };
     phase_5_run_llvm_passes(&sess, &trans, &outputs);
     if stop_after_phase_5(&sess) { return; }

src/librustc/middle/astencode.rs

@@ -34,6 +34,7 @@ use syntax;
 
 use std::libc;
 use std::cast;
+use std::cell::RefCell;
 use std::io::Seek;
 use std::rc::Rc;
 use std::vec_ng::Vec;
@@ -53,13 +54,13 @@ pub struct Maps {
     root_map: middle::borrowck::root_map,
     method_map: middle::typeck::MethodMap,
     vtable_map: middle::typeck::vtable_map,
-    capture_map: middle::moves::CaptureMap,
+    capture_map: RefCell<middle::moves::CaptureMap>,
 }
 
 struct DecodeContext<'a> {
     cdata: @cstore::crate_metadata,
     tcx: &'a ty::ctxt,
-    maps: Maps
+    maps: &'a Maps
 }
 
 struct ExtendedDecodeContext<'a> {
@@ -82,7 +83,7 @@ trait tr_intern {
 pub fn encode_inlined_item(ecx: &e::EncodeContext,
                            ebml_w: &mut writer::Encoder,
                            ii: e::InlinedItemRef,
-                           maps: Maps) {
+                           maps: &Maps) {
     let id = match ii {
         e::IIItemRef(i) => i.id,
         e::IIForeignRef(i) => i.id,
@@ -115,7 +116,7 @@ pub fn encode_exported_macro(ebml_w: &mut writer::Encoder, i: &ast::Item) {
 
 pub fn decode_inlined_item(cdata: @cstore::crate_metadata,
                            tcx: &ty::ctxt,
-                           maps: Maps,
+                           maps: &Maps,
                            path: Vec<ast_map::PathElem>,
                            par_doc: ebml::Doc)
                            -> Result<ast::InlinedItem, Vec<ast_map::PathElem>> {
@@ -906,7 +907,7 @@ impl<'a> write_tag_and_id for writer::Encoder<'a> {
 struct SideTableEncodingIdVisitor<'a,'b> {
     ecx_ptr: *libc::c_void,
     new_ebml_w: &'a mut writer::Encoder<'b>,
-    maps: Maps,
+    maps: &'a Maps,
 }
 
 impl<'a,'b> ast_util::IdVisitingOperation for
@@ -929,7 +930,7 @@ impl<'a,'b> ast_util::IdVisitingOperation for
 }
 
 fn encode_side_tables_for_ii(ecx: &e::EncodeContext,
-                             maps: Maps,
+                             maps: &Maps,
                              ebml_w: &mut writer::Encoder,
                              ii: &ast::InlinedItem) {
     ebml_w.start_tag(c::tag_table as uint);
@@ -951,7 +952,7 @@ fn encode_side_tables_for_ii(ecx: &e::EncodeContext,
 }
 
 fn encode_side_tables_for_id(ecx: &e::EncodeContext,
-                             maps: Maps,
+                             maps: &Maps,
                              ebml_w: &mut writer::Encoder,
                              id: ast::NodeId) {
     let tcx = ecx.tcx;
@@ -1075,20 +1076,16 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
         }
     }
 
-    {
-        let capture_map = maps.capture_map.borrow();
-        let r = capture_map.get().find(&id);
-        for &cap_vars in r.iter() {
-            ebml_w.tag(c::tag_table_capture_map, |ebml_w| {
-                ebml_w.id(id);
-                ebml_w.tag(c::tag_table_val, |ebml_w| {
-                    ebml_w.emit_from_vec(cap_vars.deref().as_slice(),
-                                         |ebml_w, cap_var| {
-                        cap_var.encode(ebml_w);
-                    })
+    for &cap_vars in maps.capture_map.borrow().get().find(&id).iter() {
+        ebml_w.tag(c::tag_table_capture_map, |ebml_w| {
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val, |ebml_w| {
+                ebml_w.emit_from_vec(cap_vars.deref().as_slice(),
+                                        |ebml_w, cap_var| {
+                    cap_var.encode(ebml_w);
                 })
             })
-        }
+        })
     }
 }
 

src/librustc/middle/borrowck/check_loans.rs

@@ -715,9 +715,7 @@ impl<'a> CheckLoanCtxt<'a> {
     fn check_captured_variables(&self,
                                 closure_id: ast::NodeId,
                                 span: Span) {
-        let capture_map = self.bccx.capture_map.borrow();
-        let cap_vars = capture_map.get().get(&closure_id);
-        for cap_var in cap_vars.deref().iter() {
+        for cap_var in self.bccx.capture_map.get(&closure_id).deref().iter() {
             let var_id = ast_util::def_id_of_def(cap_var.def).node;
             let var_path = @LpVar(var_id);
             self.check_if_path_is_moved(closure_id, span,

src/librustc/middle/borrowck/gather_loans/gather_moves.rs

@@ -47,9 +47,7 @@ pub fn gather_move_from_pat(bccx: &BorrowckCtxt,
 pub fn gather_captures(bccx: &BorrowckCtxt,
                        move_data: &MoveData,
                        closure_expr: &ast::Expr) {
-    let capture_map = bccx.capture_map.borrow();
-    let captured_vars = capture_map.get().get(&closure_expr.id);
-    for captured_var in captured_vars.deref().iter() {
+    for captured_var in bccx.capture_map.get(&closure_expr.id).deref().iter() {
         match captured_var.mode {
             moves::CapMove => {
                 let cmt = bccx.cat_captured_var(closure_expr.id,

src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -261,10 +261,7 @@ impl<'a> GuaranteeLifetimeContext<'a> {
         match cmt.guarantor().cat {
             mc::cat_local(id) |
             mc::cat_arg(id) => {
-                let moved_variables_set = self.bccx
-                                              .moved_variables_set
-                                              .borrow();
-                moved_variables_set.get().contains(&id)
+                self.bccx.moved_variables_set.contains(&id)
             }
             mc::cat_rvalue(..) |
             mc::cat_static_item |

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -440,9 +440,7 @@ impl<'a> GatherLoanCtxt<'a> {
 
     fn guarantee_captures(&mut self,
                           closure_expr: &ast::Expr) {
-        let capture_map = self.bccx.capture_map.borrow();
-        let captured_vars = capture_map.get().get(&closure_expr.id);
-        for captured_var in captured_vars.deref().iter() {
+        for captured_var in self.bccx.capture_map.get(&closure_expr.id).deref().iter() {
             match captured_var.mode {
                 moves::CapCopy | moves::CapMove => { continue; }
                 moves::CapRef => { }

src/librustc/middle/borrowck/mod.rs

@@ -18,6 +18,7 @@ use middle::typeck;
 use middle::moves;
 use middle::dataflow::DataFlowContext;
 use middle::dataflow::DataFlowOperator;
+use util::nodemap::NodeSet;
 use util::ppaux::{note_and_explain_region, Repr, UserString};
 
 use std::cell::{Cell, RefCell};
@@ -72,9 +73,9 @@ impl<'a> Visitor<()> for BorrowckCtxt<'a> {
 
 pub fn check_crate(tcx: &ty::ctxt,
                    method_map: typeck::MethodMap,
-                   moves_map: moves::MovesMap,
-                   moved_variables_set: moves::MovedVariablesSet,
-                   capture_map: moves::CaptureMap,
+                   moves_map: &NodeSet,
+                   moved_variables_set: &NodeSet,
+                   capture_map: &moves::CaptureMap,
                    krate: &ast::Crate)
                    -> root_map {
     let mut bccx = BorrowckCtxt {
@@ -157,9 +158,9 @@ fn borrowck_fn(this: &mut BorrowckCtxt,
 pub struct BorrowckCtxt<'a> {
     tcx: &'a ty::ctxt,
     method_map: typeck::MethodMap,
-    moves_map: moves::MovesMap,
-    moved_variables_set: moves::MovedVariablesSet,
-    capture_map: moves::CaptureMap,
+    moves_map: &'a NodeSet,
+    moved_variables_set: &'a NodeSet,
+    capture_map: &'a moves::CaptureMap,
     root_map: root_map,
 
     // Statistics:
@@ -416,8 +417,7 @@ impl<'a> BorrowckCtxt<'a> {
     }
 
     pub fn is_move(&self, id: ast::NodeId) -> bool {
-        let moves_map = self.moves_map.borrow();
-        moves_map.get().contains(&id)
+        self.moves_map.contains(&id)
     }
 
     pub fn mc(&self) -> mc::MemCategorizationContext<TcxTyper<'a>> {

src/librustc/middle/check_match.rs

@@ -16,7 +16,7 @@ use middle::pat_util::*;
 use middle::ty::*;
 use middle::ty;
 use middle::typeck::MethodMap;
-use middle::moves;
+use util::nodemap::NodeSet;
 use util::ppaux::ty_to_str;
 
 use std::cmp;
@@ -33,7 +33,7 @@ use syntax::visit::{Visitor, FnKind};
 struct MatchCheckCtxt<'a> {
     tcx: &'a ty::ctxt,
     method_map: MethodMap,
-    moves_map: moves::MovesMap
+    moves_map: &'a NodeSet
 }
 
 impl<'a> Visitor<()> for MatchCheckCtxt<'a> {
@@ -50,7 +50,7 @@ impl<'a> Visitor<()> for MatchCheckCtxt<'a> {
 
 pub fn check_crate(tcx: &ty::ctxt,
                    method_map: MethodMap,
-                   moves_map: moves::MovesMap,
+                   moves_map: &NodeSet,
                    krate: &Crate) {
     let mut cx = MatchCheckCtxt {
         tcx: tcx,
@@ -953,8 +953,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
                     by_ref_span = Some(span);
                 }
                 BindByValue(_) => {
-                    let moves_map = cx.moves_map.borrow();
-                    if moves_map.get().contains(&id) {
+                    if cx.moves_map.contains(&id) {
                         any_by_move = true;
                     }
                 }
@@ -991,8 +990,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
             if pat_is_binding(def_map, p) {
                 match p.node {
                     PatIdent(_, _, sub) => {
-                        let moves_map = cx.moves_map.borrow();
-                        if moves_map.get().contains(&p.id) {
+                        if cx.moves_map.contains(&p.id) {
                             check_move(p, sub);
                         }
                     }

src/librustc/middle/const_eval.rs

@@ -126,23 +126,18 @@ pub fn lookup_variant_by_id(tcx: &ty::ctxt,
             }
         }
     } else {
-        {
-            let extern_const_variants = tcx.extern_const_variants.borrow();
-            match extern_const_variants.get().find(&variant_def) {
-                Some(&e) => return e,
-                None => {}
-            }
+        match tcx.extern_const_variants.borrow().get().find(&variant_def) {
+            Some(&e) => return e,
+            None => {}
         }
         let maps = astencode::Maps {
             root_map: @RefCell::new(HashMap::new()),
             method_map: @RefCell::new(FnvHashMap::new()),
             vtable_map: @RefCell::new(NodeMap::new()),
-            capture_map: @RefCell::new(NodeMap::new())
+            capture_map: RefCell::new(NodeMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, enum_def,
-            |a, b, c, d| astencode::decode_inlined_item(a, b,
-                                                        maps,
-                                                        c, d)) {
+            |a, b, c, d| astencode::decode_inlined_item(a, b, &maps, c, d)) {
             csearch::found(ast::IIItem(item)) => match item.node {
                 ItemEnum(ast::EnumDef { variants: ref variants }, _) => {
                     variant_expr(variants.as_slice(), variant_def.node)
@@ -151,12 +146,8 @@ pub fn lookup_variant_by_id(tcx: &ty::ctxt,
             },
             _ => None
         };
-        {
-            let mut extern_const_variants = tcx.extern_const_variants
-                                               .borrow_mut();
-            extern_const_variants.get().insert(variant_def, e);
-            return e;
-        }
+        tcx.extern_const_variants.borrow_mut().get().insert(variant_def, e);
+        return e;
     }
 }
 
@@ -187,10 +178,10 @@ pub fn lookup_const_by_id(tcx: &ty::ctxt, def_id: ast::DefId)
             root_map: @RefCell::new(HashMap::new()),
             method_map: @RefCell::new(FnvHashMap::new()),
             vtable_map: @RefCell::new(NodeMap::new()),
-            capture_map: @RefCell::new(NodeMap::new())
+            capture_map: RefCell::new(NodeMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, def_id,
-            |a, b, c, d| astencode::decode_inlined_item(a, b, maps, c, d)) {
+            |a, b, c, d| astencode::decode_inlined_item(a, b, &maps, c, d)) {
             csearch::found(ast::IIItem(item)) => match item.node {
                 ItemStatic(_, ast::MutImmutable, const_expr) => Some(const_expr),
                 _ => None