---

yaml
---
r: 128702
b: refs/heads/try
c: 0e47f94
h: refs/heads/master
v: v3

Author: chuckries

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 69c58bcf6f8392c078e5f4ea0281e904cd8e8afb
+refs/heads/try: 0e47f9481eed2b92b0d43325dc97917e2f3329d8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/metadata/common.rs

@@ -140,10 +140,9 @@ pub enum astencode_tag { // Reserves 0x40 -- 0x5f
     tag_table_moves_map = 0x52,
     tag_table_capture_map = 0x53,
     tag_table_unboxed_closure_type = 0x54,
-    tag_table_upvar_borrow_map = 0x55,
 }
 static first_astencode_tag: uint = tag_ast as uint;
-static last_astencode_tag: uint = tag_table_upvar_borrow_map as uint;
+static last_astencode_tag: uint = tag_table_unboxed_closure_type as uint;
 impl astencode_tag {
     pub fn from_uint(value : uint) -> Option<astencode_tag> {
         let is_a_tag = first_astencode_tag <= value && value <= last_astencode_tag;

branches/try/src/librustc/middle/astencode.rs

@@ -18,7 +18,6 @@ use driver::session::Session;
 use metadata::decoder;
 use middle::def;
 use e = metadata::encoder;
-use middle::freevars;
 use middle::freevars::freevar_entry;
 use middle::region;
 use metadata::tydecode;
@@ -552,15 +551,6 @@ impl tr for freevar_entry {
     }
 }
 
-impl tr for ty::UpvarBorrow {
-    fn tr(&self, xcx: &ExtendedDecodeContext) -> ty::UpvarBorrow {
-        ty::UpvarBorrow {
-            kind: self.kind,
-            region: self.region.tr(xcx)
-        }
-    }
-}
-
 // ______________________________________________________________________
 // Encoding and decoding of MethodCallee
 
@@ -1071,29 +1061,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
                     Ok(encode_freevar_entry(rbml_w, fv_entry))
                 });
             })
-        });
-
-        for freevar in fv.iter() {
-            match freevars::get_capture_mode(tcx, id) {
-                freevars::CaptureByRef => {
-                    rbml_w.tag(c::tag_table_upvar_borrow_map, |rbml_w| {
-                        rbml_w.id(id);
-                        rbml_w.tag(c::tag_table_val, |rbml_w| {
-                            let var_id = freevar.def.def_id().node;
-                            let upvar_id = ty::UpvarId {
-                                var_id: var_id,
-                                closure_expr_id: id
-                            };
-                            let upvar_borrow = tcx.upvar_borrow_map.borrow()
-                                                  .get_copy(&upvar_id);
-                            var_id.encode(rbml_w);
-                            upvar_borrow.encode(rbml_w);
-                        })
-                    })
-                }
-                _ => {}
-            }
-        }
+        })
     }
 
     let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id };
@@ -1500,15 +1468,6 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext,
                         }).unwrap().move_iter().collect();
                         dcx.tcx.freevars.borrow_mut().insert(id, fv_info);
                     }
-                    c::tag_table_upvar_borrow_map => {
-                        let var_id: ast::NodeId = Decodable::decode(val_dsr).unwrap();
-                        let upvar_id = ty::UpvarId {
-                            var_id: xcx.tr_id(var_id),
-                            closure_expr_id: id
-                        };
-                        let ub: ty::UpvarBorrow = Decodable::decode(val_dsr).unwrap();
-                        dcx.tcx.upvar_borrow_map.borrow_mut().insert(upvar_id, ub.tr(xcx));
-                    }
                     c::tag_table_tcache => {
                         let pty = val_dsr.read_polytype(xcx);
                         let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id };

branches/try/src/librustc/middle/freevars.rs

@@ -14,7 +14,6 @@
 #![allow(non_camel_case_types)]
 
 use middle::def;
-use middle::mem_categorization::Typer;
 use middle::resolve;
 use middle::ty;
 use util::nodemap::{DefIdSet, NodeMap, NodeSet};
@@ -148,8 +147,11 @@ pub fn with_freevars<T>(tcx: &ty::ctxt, fid: ast::NodeId, f: |&[freevar_entry]|
     }
 }
 
-pub fn get_capture_mode<T: Typer>(tcx: &T, closure_expr_id: ast::NodeId) -> CaptureMode {
-    let fn_ty = tcx.node_ty(closure_expr_id).ok().expect("couldn't find closure ty?");
+pub fn get_capture_mode(tcx: &ty::ctxt,
+                        closure_expr_id: ast::NodeId)
+                        -> CaptureMode
+{
+    let fn_ty = ty::node_id_to_type(tcx, closure_expr_id);
     match ty::ty_closure_store(fn_ty) {
         ty::RegionTraitStore(..) => CaptureByRef,
         ty::UniqTraitStore => CaptureByValue

branches/try/src/librustc/middle/trans/_match.rs

@@ -189,9 +189,7 @@
 #![allow(non_camel_case_types)]
 
 use back::abi;
-use mc = middle::mem_categorization;
 use driver::config::FullDebugInfo;
-use euv = middle::expr_use_visitor;
 use llvm;
 use llvm::{ValueRef, BasicBlockRef};
 use middle::const_eval;
@@ -1294,58 +1292,13 @@ pub fn trans_match<'a>(
     trans_match_inner(bcx, match_expr.id, discr_expr, arms, dest)
 }
 
-/// Checks whether the binding in `discr` is assigned to anywhere in the expression `body`
-fn is_discr_reassigned(bcx: &Block, discr: &ast::Expr, body: &ast::Expr) -> bool {
-    match discr.node {
-        ast::ExprPath(..) => match bcx.def(discr.id) {
-            def::DefArg(vid, _) | def::DefBinding(vid, _) |
-            def::DefLocal(vid, _) | def::DefUpvar(vid, _, _, _) => {
-                let mut rc = ReassignmentChecker {
-                    node: vid,
-                    reassigned: false
-                };
-                {
-                    let mut visitor = euv::ExprUseVisitor::new(&mut rc, bcx);
-                    visitor.walk_expr(body);
-                }
-                rc.reassigned
-            }
-            _ => false
-        },
-        _ => false
-    }
-}
-
-struct ReassignmentChecker {
-    node: ast::NodeId,
-    reassigned: bool
-}
-
-impl euv::Delegate for ReassignmentChecker {
-    fn consume(&mut self, _: ast::NodeId, _: Span, _: mc::cmt, _: euv::ConsumeMode) {}
-    fn consume_pat(&mut self, _: &ast::Pat, _: mc::cmt, _: euv::ConsumeMode) {}
-    fn borrow(&mut self, _: ast::NodeId, _: Span, _: mc::cmt, _: ty::Region,
-              _: ty::BorrowKind, _: euv::LoanCause) {}
-    fn decl_without_init(&mut self, _: ast::NodeId, _: Span) {}
-
-    fn mutate(&mut self, _: ast::NodeId, _: Span, cmt: mc::cmt, _: euv::MutateMode) {
-        match cmt.cat {
-            mc::cat_copied_upvar(mc::CopiedUpvar { upvar_id: vid, .. }) |
-            mc::cat_arg(vid) | mc::cat_local(vid) => self.reassigned = self.node == vid,
-            _ => {}
-        }
-    }
-}
-
-fn create_bindings_map(bcx: &Block, pat: Gc<ast::Pat>,
-                      discr: &ast::Expr, body: &ast::Expr) -> BindingsMap {
+fn create_bindings_map(bcx: &Block, pat: Gc<ast::Pat>) -> BindingsMap {
     // Create the bindings map, which is a mapping from each binding name
     // to an alloca() that will be the value for that local variable.
     // Note that we use the names because each binding will have many ids
     // from the various alternatives.
     let ccx = bcx.ccx();
     let tcx = bcx.tcx();
-    let reassigned = is_discr_reassigned(bcx, discr, body);
     let mut bindings_map = HashMap::new();
     pat_bindings(&tcx.def_map, &*pat, |bm, p_id, span, path1| {
         let ident = path1.node;
@@ -1357,7 +1310,7 @@ fn create_bindings_map(bcx: &Block, pat: Gc<ast::Pat>,
         let trmode;
         match bm {
             ast::BindByValue(_)
-                if !ty::type_moves_by_default(tcx, variable_ty) || reassigned => {
+                if !ty::type_moves_by_default(tcx, variable_ty) => {
                 llmatch = alloca_no_lifetime(bcx,
                                  llvariable_ty.ptr_to(),
                                  "__llmatch");
@@ -1418,7 +1371,7 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>,
     let arm_datas: Vec<ArmData> = arms.iter().map(|arm| ArmData {
         bodycx: fcx.new_id_block("case_body", arm.body.id),
         arm: arm,
-        bindings_map: create_bindings_map(bcx, *arm.pats.get(0), discr_expr, &*arm.body)
+        bindings_map: create_bindings_map(bcx, *arm.pats.get(0))
     }).collect();
 
     let mut static_inliner = StaticInliner { tcx: scope_cx.tcx() };

branches/try/src/librustc/middle/trans/common.rs

@@ -16,7 +16,6 @@ use driver::session::Session;
 use llvm;
 use llvm::{ValueRef, BasicBlockRef, BuilderRef};
 use llvm::{True, False, Bool};
-use mc = middle::mem_categorization;
 use middle::def;
 use middle::lang_items::LangItem;
 use middle::subst;
@@ -482,36 +481,6 @@ impl<'a> Block<'a> {
     }
 }
 
-impl<'a> mc::Typer for Block<'a> {
-    fn tcx<'a>(&'a self) -> &'a ty::ctxt {
-        self.tcx()
-    }
-
-    fn node_ty(&self, id: ast::NodeId) -> mc::McResult<ty::t> {
-        Ok(node_id_type(self, id))
-    }
-
-    fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option<ty::t> {
-        self.tcx().method_map.borrow().find(&method_call).map(|method| method.ty)
-    }
-
-    fn adjustments<'a>(&'a self) -> &'a RefCell<NodeMap<ty::AutoAdjustment>> {
-        &self.tcx().adjustments
-    }
-
-    fn is_method_call(&self, id: ast::NodeId) -> bool {
-        self.tcx().method_map.borrow().contains_key(&typeck::MethodCall::expr(id))
-    }
-
-    fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option<ast::NodeId> {
-        self.tcx().region_maps.temporary_scope(rvalue_id)
-    }
-
-    fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> ty::UpvarBorrow {
-        self.tcx().upvar_borrow_map.borrow().get_copy(&upvar_id)
-    }
-}
-
 pub struct Result<'a> {
     pub bcx: &'a Block<'a>,
     pub val: ValueRef

branches/try/src/librustc/middle/ty.rs

@@ -539,7 +539,7 @@ pub struct UpvarId {
     pub closure_expr_id: ast::NodeId,
 }
 
-#[deriving(Clone, PartialEq, Eq, Hash, Show, Encodable, Decodable)]
+#[deriving(Clone, PartialEq, Eq, Hash, Show)]
 pub enum BorrowKind {
     /// Data must be immutable and is aliasable.
     ImmBorrow,
@@ -634,7 +634,7 @@ pub enum BorrowKind {
  *   the closure, so sometimes it is necessary for them to be larger
  *   than the closure lifetime itself.
  */
-#[deriving(PartialEq, Clone, Encodable, Decodable)]
+#[deriving(PartialEq, Clone)]
 pub struct UpvarBorrow {
     pub kind: BorrowKind,
     pub region: ty::Region,

branches/try/src/libserialize/serialize.rs

@@ -571,8 +571,6 @@ impl<E, D: Decoder<E>, T: Decodable<D, E>> Decodable<D, E> for RefCell<T> {
 
 // ___________________________________________________________________________
 // Helper routines
-//
-// In some cases, these should eventually be coded as traits.
 
 pub trait EncoderHelpers<E> {
     fn emit_from_vec<T>(&mut self,