replace last_use with liveness info

Author: nikomatsakis

src/rustc/driver/driver.rs

@@ -4,8 +4,7 @@ import session::session;
 import syntax::parse;
 import syntax::{ast, codemap};
 import syntax::attr;
-import middle::{trans, resolve, freevars, kind, ty, typeck,
-                last_use, lint};
+import middle::{trans, resolve, freevars, kind, ty, typeck, lint};
 import syntax::print::{pp, pprust};
 import util::{ppaux, filesearch};
 import back::link;
@@ -192,29 +191,27 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
          bind middle::check_loop::check_crate(ty_cx, crate));
     time(time_passes, "alt checking",
          bind middle::check_alt::check_crate(ty_cx, crate));
-    let _last_use_map =
+    let (last_use_map, spill_map) =
         time(time_passes, "liveness checking",
              bind middle::liveness::check_crate(ty_cx, method_map, crate));
     time(time_passes, "typestate checking",
          bind middle::tstate::ck::check_crate(ty_cx, crate));
     let (root_map, mutbl_map) = time(
         time_passes, "borrow checking",
         bind middle::borrowck::check_crate(ty_cx, method_map, crate));
-    let (copy_map, ref_map) =
+    let (copy_map, _ref_map) =
         time(time_passes, "alias checking",
              bind middle::alias::check_crate(ty_cx, crate));
-    let (last_uses, spill_map) = time(time_passes, "last use finding",
-        bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx));
     time(time_passes, "kind checking",
-         bind kind::check_crate(ty_cx, method_map, last_uses, crate));
+         bind kind::check_crate(ty_cx, method_map, last_use_map, crate));
 
     lint::check_crate(ty_cx, crate, sess.opts.lint_opts, time_passes);
 
     if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; }
     let outputs = option::get(outputs);
 
     let maps = {mutbl_map: mutbl_map, root_map: root_map,
-                copy_map: copy_map, last_uses: last_uses,
+                copy_map: copy_map, last_use_map: last_use_map,
                 impl_map: impl_map, method_map: method_map,
                 vtable_map: vtable_map, spill_map: spill_map};
 

src/rustc/middle/astencode.rs

@@ -1,5 +1,6 @@
 import util::ppaux::ty_to_str;
 
+import dvec::extensions;
 import syntax::ast;
 import syntax::fold;
 import syntax::visit;
@@ -18,7 +19,7 @@ import std::serialization::serializer_helpers;
 import std::serialization::deserializer_helpers;
 import std::prettyprint::serializer;
 import std::smallintmap::map;
-import middle::{ty, typeck, last_use};
+import middle::{ty, typeck};
 import middle::typeck::{method_origin,
                         serialize_method_origin,
                         deserialize_method_origin,
@@ -52,11 +53,11 @@ type maps = {
     mutbl_map: middle::borrowck::mutbl_map,
     root_map: middle::borrowck::root_map,
     copy_map: middle::alias::copy_map,
-    last_uses: middle::last_use::last_uses,
+    last_use_map: middle::liveness::last_use_map,
     impl_map: middle::resolve::impl_map,
     method_map: middle::typeck::method_map,
     vtable_map: middle::typeck::vtable_map,
-    spill_map: middle::last_use::spill_map
+    spill_map: middle::liveness::spill_map
 };
 
 type decode_ctxt = @{
@@ -539,10 +540,6 @@ impl helper for ebml::ebml_deserializer {
         let fv = deserialize_method_origin(self);
         fv.tr(xcx)
     }
-    fn read_is_last_use(xcx: extended_decode_ctxt) -> last_use::is_last_use {
-        let lu = last_use::deserialize_is_last_use(self);
-        lu.tr(xcx)
-    }
 }
 
 impl of tr for method_origin {
@@ -561,17 +558,6 @@ impl of tr for method_origin {
     }
 }
 
-impl of tr for last_use::is_last_use {
-    fn tr(xcx: extended_decode_ctxt) -> last_use::is_last_use {
-        alt self {
-          last_use::is_last_use { self }
-          last_use::closes_over(ids) {
-            last_use::closes_over(vec::map(ids, {|id| xcx.tr_id(id)}))
-          }
-        }
-    }
-}
-
 // ______________________________________________________________________
 // Encoding and decoding vtable_res
 
@@ -844,11 +830,13 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
         }
     }
 
-    option::iter(maps.last_uses.find(id)) {|m|
+    option::iter(maps.last_use_map.find(id)) {|m|
         ebml_w.tag(c::tag_table_last_use) {||
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val) {||
-                last_use::serialize_is_last_use(ebml_w, m)
+                ebml_w.emit_from_vec((*m).get()) {|id|
+                    ebml_w.emit_int(id);
+                }
             }
         }
     }
@@ -975,7 +963,11 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                 let bounds = val_dsr.read_bounds(xcx);
                 dcx.tcx.ty_param_bounds.insert(id, bounds);
             } else if tag == (c::tag_table_last_use as uint) {
-                dcx.maps.last_uses.insert(id, val_dsr.read_is_last_use(xcx));
+                let ids = val_dsr.read_to_vec {||
+                    xcx.tr_id(val_dsr.read_int())
+                };
+                let dvec = @dvec::from_vec(vec::to_mut(ids));
+                dcx.maps.last_use_map.insert(id, dvec);
             } else if tag == (c::tag_table_method_map as uint) {
                 dcx.maps.method_map.insert(id,
                                            val_dsr.read_method_origin(xcx));

src/rustc/middle/borrowck.rs

@@ -138,10 +138,10 @@ enum loan_path {
 // a complete record of a loan that was granted
 type loan = {lp: @loan_path, cmt: cmt, mutbl: ast::mutability};
 
-fn save_and_restore<T:copy,U>(&t: T, f: fn() -> U) -> U {
-    let old_t = t;
+fn save_and_restore<T:copy,U>(&save_and_restore_t: T, f: fn() -> U) -> U {
+    let old_save_and_restore_t = save_and_restore_t;
     let u <- f();
-    t = old_t;
+    save_and_restore_t = old_save_and_restore_t;
     ret u;
 }
 
@@ -888,6 +888,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
                      sp: span, id: ast::node_id, &&self: check_loan_ctxt,
                      visitor: visit::vt<check_loan_ctxt>) {
 
+    #debug["purity on entry=%?", self.declared_purity];
     save_and_restore(self.in_ctor) {||
         save_and_restore(self.declared_purity) {||
             // In principle, we could consider fk_anon(*) or
@@ -909,6 +910,7 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
             visit::visit_fn(fk, decl, body, sp, id, self, visitor);
         }
     }
+    #debug["purity on exit=%?", self.declared_purity];
 }
 
 fn check_loans_in_expr(expr: @ast::expr,

src/rustc/middle/kind.rs

@@ -8,6 +8,7 @@ import std::map::hashmap;
 import util::ppaux::{ty_to_str, tys_to_str};
 import syntax::print::pprust::expr_to_str;
 import freevars::freevar_entry;
+import dvec::extensions;
 
 // Kind analysis pass.
 //
@@ -56,15 +57,15 @@ type rval_map = std::map::hashmap<node_id, ()>;
 type ctx = {tcx: ty::ctxt,
             rval_map: rval_map,
             method_map: typeck::method_map,
-            last_uses: last_use::last_uses};
+            last_use_map: liveness::last_use_map};
 
 fn check_crate(tcx: ty::ctxt, method_map: typeck::method_map,
-               last_uses: last_use::last_uses, crate: @crate)
+               last_use_map: liveness::last_use_map, crate: @crate)
     -> rval_map {
     let ctx = {tcx: tcx,
                rval_map: std::map::int_hash(),
                method_map: method_map,
-               last_uses: last_uses};
+               last_use_map: last_use_map};
     let visit = visit::mk_vt(@{
         visit_expr: check_expr,
         visit_stmt: check_stmt,
@@ -177,11 +178,10 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
             // if this is the last use of the variable, then it will be
             // a move and not a copy
             let is_move = {
-                let last_uses = alt check cx.last_uses.find(fn_id) {
-                  some(last_use::closes_over(vars)) { vars }
-                  none { [] }
-                };
-                last_uses.contains(id)
+                alt check cx.last_use_map.find(fn_id) {
+                  some(vars) {(*vars).contains(id)}
+                  none {false}
+                }
             };
 
             let ty = ty::node_id_to_type(cx.tcx, id);
@@ -367,7 +367,7 @@ fn is_nullary_variant(cx: ctx, ex: @expr) -> bool {
 
 fn check_copy_ex(cx: ctx, ex: @expr, _warn: bool) {
     if ty::expr_is_lval(cx.method_map, ex) &&
-       !cx.last_uses.contains_key(ex.id) &&
+       !cx.last_use_map.contains_key(ex.id) &&
        !is_nullary_variant(cx, ex) {
         let ty = ty::expr_ty(cx.tcx, ex);
         check_copy(cx, ty, ex.span);