---

yaml
---
r: 127486
b: refs/heads/master
c: 954bae9
h: refs/heads/master
v: v3

Author: jakejscott

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4d27b4875e16ed6a4a0c9697432f1152b727e84a
+refs/heads/master: 954bae9df17681e611be4bf943c34b492db46dc8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 12e0f72f517516ac4fce2aed85e6142e9b874bce
 refs/heads/try: e9a2d9f337a45a2ddcd854d1039bbc9f907de41a

trunk/src/doc/guide-pointers.md

@@ -655,7 +655,7 @@ This part is coming soon.
 # Returning Pointers
 
 In many languages with pointers, you'd return a pointer from a function
-so as to avoid copying a large data structure. For example:
+so as to avoid a copying a large data structure. For example:
 
 ```{rust}
 struct BigStruct {

trunk/src/doc/guide.md

@@ -2090,7 +2090,7 @@ In this case, I happen to prefer the latter, and in the `random()` case, I prefe
 the former. I think the nested `<>`s make the first option especially ugly and
 a bit harder to read.
 
-Anyway, with us now convering our input to a number, our code looks like this:
+Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}
 use std::io;

trunk/src/doc/tutorial.md

@@ -1133,16 +1133,6 @@ let xs = Cons(1, box Cons(2, box Cons(3, box Nil)));
 let ys = xs; // copies `Cons(u32, pointer)` shallowly
 ~~~
 
-> *Note:* Names like `xs` and `ys` are a naming
-> convention for collection-like data structures
-> (like our `List`). These collections are given 
-> names appended with 's' to signify plurality, 
-> i.e. that the data structure stores multiple 
-> elements.  For example, `xs` in this case can 
-> be read as "a list of ex-es", where "x" here 
-> are elements of type `u32`.
-
-
 Rust will consider a shallow copy of a type with a destructor like `List` to
 *move ownership* of the value. After a value has been moved, the source
 location cannot be used unless it is reinitialized.

trunk/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;

trunk/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 };

trunk/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

trunk/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() };

trunk/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

trunk/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,

trunk/src/libserialize/serialize.rs

@@ -571,6 +571,8 @@ 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,

trunk/src/test/bench/rt-messaging-ping-pong.rs

@@ -22,7 +22,7 @@ use std::uint;
 
 // This is a simple bench that creates M pairs of tasks. These
 // tasks ping-pong back and forth over a pair of streams. This is a
-// canonical message-passing benchmark as it heavily strains message
+// cannonical message-passing benchmark as it heavily strains message
 // passing and almost nothing else.
 
 fn ping_pong_bench(n: uint, m: uint) {

trunk/src/test/bench/shootout-meteor.rs

@@ -101,7 +101,7 @@ impl<'a, T> Iterator<&'a T> for ListIterator<'a, T> {
 // every possible transformations (the 6 rotations with their
 // corresponding mirrored piece), with, as minimum coordinates, (0,
 // 0).  If all is false, only generate half of the possibilities (used
-// to break the symmetry of the board).
+// to break the symetry of the board).
 fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
     let mut res: Vec<Vec<(int, int)>> =
         // rotations
@@ -124,9 +124,9 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
     res
 }
 
-// A mask is a piece somewhere on the board.  It is represented as a
+// A mask is a piece somewere on the board.  It is represented as a
 // u64: for i in the first 50 bits, m[i] = 1 if the cell at (i/5, i%5)
-// is occupied.  m[50 + id] = 1 if the identifier of the piece is id.
+// is occuped.  m[50 + id] = 1 if the identifier of the piece is id.
 
 // Takes a piece with minimum coordinate (0, 0) (as generated by
 // transform).  Returns the corresponding mask if p translated by (dy,
@@ -159,7 +159,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
         vec!((0i,0i),(0,1),(0,2),(1,2),(1,3)),
         vec!((0i,0i),(0,1),(0,2),(0,3),(1,2)));
 
-    // To break the central symmetry of the problem, every
+    // To break the central symetry of the problem, every
     // transformation must be taken except for one piece (piece 3
     // here).
     let transforms: Vec<Vec<Vec<(int, int)>>> =
@@ -263,7 +263,7 @@ impl Data {
 // Records a new found solution.  Returns false if the search must be
 // stopped.
 fn handle_sol(raw_sol: &List<u64>, data: &mut Data) {
-    // because we break the symmetry, 2 solutions correspond to a call
+    // because we break the symetry, 2 solutions correspond to a call
     // to this method: the normal solution, and the same solution in
     // reverse order, i.e. the board rotated by half a turn.
     data.nb += 2;
@@ -298,7 +298,7 @@ fn search(
     for id in range(0u, 10).filter(|id| board & (1 << (id + 50)) == 0) {
         // for each mask that fits on the board
         for m in masks_at.get(id).iter().filter(|&m| board & *m == 0) {
-            // This check is too costly.
+            // This check is too costy.
             //if is_board_unfeasible(board | m, masks) {continue;}
             search(masks, board | *m, i + 1, Cons(*m, &cur), data);
         }

trunk/src/test/bench/shootout-spectralnorm.rs

@@ -36,8 +36,8 @@ fn dot(v: &[f64], u: &[f64]) -> f64 {
 
 fn mult(v: Arc<RWLock<Vec<f64>>>, out: Arc<RWLock<Vec<f64>>>,
         f: fn(&Vec<f64>, uint) -> f64) {
-    // We launch in different tasks the work to be done.  To finish
-    // this function, we need to wait for the completion of every
+    // We lanch in different tasks the work to be done.  To finish
+    // this fuction, we need to wait for the completion of every
     // tasks.  To do that, we give to each tasks a wait_chan that we
     // drop at the end of the work.  At the end of this function, we
     // wait until the channel hang up.

trunk/src/test/compile-fail/borrowck-forbid-static-unsafe-interior.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // Verify that it is not possible to take the address of
-// static items with unsafe interior.
+// static items with usnafe interior.
 
 use std::kinds::marker;
 use std::cell::UnsafeCell;

trunk/src/test/compile-fail/borrowck-managed-pointer-deref-scope.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Verify that managed pointers scope is treated like owned pointers.
-// regression test for #11586
+// Verify that managed pointers scope is treated like ownoed pointers.
+// regresion test for #11586
 
 
 use std::gc::{GC, Gc};