---

yaml
---
r: 127673
b: refs/heads/snap-stage3
c: f3d88c3
h: refs/heads/master
i:
  127671: d4ab49e
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 49a970f2449a78f28b6c301e542d38593094ca77
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9c772cd391034ad29a444e748708df5a0bfff0a2
+refs/heads/snap-stage3: f3d88c320d4b08e5534f2193462e6a20e27b1d85
 refs/heads/try: d9c23fcbaea89871667272a67ecb8d3a512162f3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide.md

@@ -27,7 +27,7 @@ Sound good? Let's go!
 # Installing Rust
 
 The first step to using Rust is to install it! There are a number of ways to
-install Rust, but the easiest is to use the `rustup` script. If you're on
+install Rust, but the easiest is to use the the `rustup` script. If you're on
 Linux or a Mac, all you need to do is this (note that you don't need to type
 in the `$`s, they just indicate the start of each command):
 
@@ -120,7 +120,7 @@ to make a projects directory in my home directory, and keep all my projects
 there. Rust does not care where your code lives.
 
 This actually leads to one other concern we should address: this tutorial will
-assume that you have basic familiarity with the command line. Rust does not
+assume that you have basic familiarity with the command-line. Rust does not
 require that you know a whole ton about the command line, but until the
 language is in a more finished state, IDE support is spotty. Rust makes no
 specific demands on your editing tooling, or where your code lives.
@@ -452,7 +452,7 @@ what you need, so it's not verboten.
 
 Let's get back to bindings. Rust variable bindings have one more aspect that
 differs from other languages: bindings are required to be initialized with a
-value before you're allowed to use them. If we try...
+value before you're allowed to use it. If we try...
 
 ```{ignore}
 let x;
@@ -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 converting our input to a number, our code looks like this:
+Anyway, with us now convering our input to a number, our code looks like this:
 
 ```{rust,ignore}
 use std::io;
@@ -2281,7 +2281,7 @@ change that by adding loops!
 
 ## Looping
 
-As we already discussed, the `loop` keyword gives us an infinite loop. So
+As we already discussed, the `loop` key word gives us an infinite loop. So
 let's add that in:
 
 ```{rust,no_run}
@@ -4099,7 +4099,7 @@ fn inverse(x: f64) -> Result<f64, String> {
 ```
 
 We don't want to take the inverse of zero, so we check to make sure that we
-weren't passed zero. If we were, then we return an `Err`, with a message. If
+weren't passed one. If we weren't, then we return an `Err`, with a message. If
 it's okay, we return an `Ok`, with the answer.
 
 Why does this matter? Well, remember how `match` does exhaustive matches?

branches/snap-stage3/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.

branches/snap-stage3/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/snap-stage3/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/snap-stage3/src/librustc/middle/dead.rs

@@ -412,18 +412,14 @@ struct DeadVisitor<'a> {
 
 impl<'a> DeadVisitor<'a> {
     fn should_warn_about_field(&mut self, node: &ast::StructField_) -> bool {
-        let (is_named, has_leading_underscore) = match node.ident() {
-            Some(ref ident) => (true, token::get_ident(*ident).get().as_bytes()[0] == ('_' as u8)),
-            _ => (false, false)
-        };
+        let is_named = node.ident().is_some();
         let field_type = ty::node_id_to_type(self.tcx, node.id);
         let is_marker_field = match ty::ty_to_def_id(field_type) {
             Some(def_id) => self.tcx.lang_items.items().any(|(_, item)| *item == Some(def_id)),
             _ => false
         };
         is_named
             && !self.symbol_is_live(node.id, None)
-            && !has_leading_underscore
             && !is_marker_field
             && !has_allow_dead_code_or_lang_attr(node.attrs.as_slice())
     }
@@ -468,13 +464,15 @@ impl<'a> DeadVisitor<'a> {
                       id: ast::NodeId,
                       span: codemap::Span,
                       ident: ast::Ident) {
-        self.tcx
-            .sess
-            .add_lint(lint::builtin::DEAD_CODE,
-                      id,
-                      span,
-                      format!("code is never used: `{}`",
-                              token::get_ident(ident)));
+        let name = ident.as_str();
+        if !name.starts_with("_") {
+            self.tcx
+                .sess
+                .add_lint(lint::builtin::DEAD_CODE,
+                          id,
+                          span,
+                          format!("code is never used: `{}`", name));
+        }
     }
 }
 

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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,

branches/snap-stage3/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) {