---

yaml
---
r: 275183
b: refs/heads/stable
c: 145190b
h: refs/heads/master
i:
  275181: 93d0887
  275179: 0e8a783
  275175: 762f805
  275167: 262bd5e

Author: fhahn

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: f28677506c29507433ed2de4d7ad2b07c4cf0111
+refs/heads/stable: 145190bd2aec3b6ad9e4ed4da8490d810c9d0bee
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/book/ownership.md

@@ -157,7 +157,7 @@ this point of time). These two parts of the vector (the one on the stack and
 one on the heap) must agree with each other at all times with regards to
 things like the length, capacity etc.
 
-When we move `v` to `v2`, rust actually does a bitwise copy of the vector
+When we move `v` to `v2`, Rust actually does a bitwise copy of the vector
 object `v` into the stack allocation represented by `v2`. This shallow copy
 does not create a copy of the heap allocation containing the actual data.
 Which means that there would be two pointers to the contents of the vector

branches/stable/src/doc/nomicon/other-reprs.md

@@ -57,7 +57,7 @@ These reprs have no effect on a struct.
 
 # repr(packed)
 
-`repr(packed)` forces rust to strip any padding, and only align the type to a
+`repr(packed)` forces Rust to strip any padding, and only align the type to a
 byte. This may improve the memory footprint, but will likely have other negative
 side-effects.
 

branches/stable/src/doc/reference.md

@@ -841,8 +841,8 @@ extern crate std as ruststd; // linking to 'std' under another name
 
 A _use declaration_ creates one or more local name bindings synonymous with
 some other [path](#paths). Usually a `use` declaration is used to shorten the
-path required to refer to a module item. These declarations may appear in
-[modules](#modules) and [blocks](grammar.html#block-expressions), usually at the top.
+path required to refer to a module item. These declarations may appear at the
+top of [modules](#modules) and [blocks](grammar.html#block-expressions).
 
 > **Note**: Unlike in many languages,
 > `use` declarations in Rust do *not* declare linkage dependency with external crates.
@@ -1764,7 +1764,7 @@ pub mod submodule {
 # fn main() {}
 ```
 
-For a rust program to pass the privacy checking pass, all paths must be valid
+For a Rust program to pass the privacy checking pass, all paths must be valid
 accesses given the two rules above. This includes all use statements,
 expressions, types, etc.
 
@@ -3564,9 +3564,8 @@ Each instance of a trait object includes:
    each method of `SomeTrait` that `T` implements, a pointer to `T`'s
    implementation (i.e. a function pointer).
 
-The purpose of trait objects is to permit "late binding" of methods. Calling a
-method on a trait object results in virtual dispatch at runtime: that is, a
-function pointer is loaded from the trait object vtable and invoked indirectly.
+The purpose of trait objects is to permit "late binding" of methods. A call to
+a method on a trait object is only resolved to a vtable entry at compile time.
 The actual implementation for each vtable entry can vary on an object-by-object
 basis.
 

branches/stable/src/libcollections/slice.rs

@@ -407,7 +407,7 @@ impl<T> [T] {
     }
 
     /// Returns an iterator over `size` elements of the slice at a
-    /// time. The chunks are slices and do not overlap. If `size` does not divide the
+    /// time. The chunks do not overlap. If `size` does not divide the
     /// length of the slice, then the last chunk will not have length
     /// `size`.
     ///
@@ -433,7 +433,7 @@ impl<T> [T] {
     }
 
     /// Returns an iterator over `chunk_size` elements of the slice at a time.
-    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does
+    /// The chunks are mutable and do not overlap. If `chunk_size` does
     /// not divide the length of the slice, then the last chunk will not
     /// have length `chunk_size`.
     ///

branches/stable/src/libcollections/vec.rs

@@ -135,49 +135,6 @@ use super::range::RangeArgument;
 /// }
 /// ```
 ///
-/// # Indexing
-///
-/// The Vec type allows to access values by index, because it implements the
-/// `Index` trait. An example will be more explicit:
-///
-/// ```
-/// let v = vec!(0, 2, 4, 6);
-/// println!("{}", v[1]); // it will display '2'
-/// ```
-///
-/// However be careful: if you try to access an index which isn't in the Vec,
-/// your software will panic! You cannot do this:
-///
-/// ```ignore
-/// let v = vec!(0, 2, 4, 6);
-/// println!("{}", v[6]); // it will panic!
-/// ```
-///
-/// In conclusion: always check if the index you want to get really exists
-/// before doing it.
-///
-/// # Slicing
-///
-/// A Vec can be mutable. Slices, on the other hand, are read-only objects.
-/// To get a slice, use "&". Example:
-///
-/// ```
-/// fn read_slice(slice: &[usize]) {
-///     // ...
-/// }
-///
-/// let v = vec!(0, 1);
-/// read_slice(&v);
-///
-/// // ... and that's all!
-/// // you can also do it like this:
-/// let x : &[usize] = &v;
-/// ```
-///
-/// In Rust, it's more common to pass slices as arguments rather than vectors
-/// when you just want to provide a read access. The same goes for String and
-/// &str.
-///
 /// # Capacity and reallocation
 ///
 /// The capacity of a vector is the amount of space allocated for any future

branches/stable/src/libgetopts/lib.rs

@@ -331,8 +331,9 @@ impl Matches {
     /// Returns the string argument supplied to one of several matching options or `None`.
     pub fn opts_str(&self, names: &[String]) -> Option<String> {
         for nm in names {
-            if let Some(Val(ref s)) = self.opt_val(&nm[..]) {
-                  return Some(s.clone())
+            match self.opt_val(&nm[..]) {
+                Some(Val(ref s)) => return Some(s.clone()),
+                _ => (),
             }
         }
         None

branches/stable/src/librustc_trans/back/link.rs

@@ -226,8 +226,9 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>,
 }
 
 fn get_symbol_hash<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> String {
-    if let Some(h) = ccx.type_hashcodes().borrow().get(&t) {
-        return h.to_string()
+    match ccx.type_hashcodes().borrow().get(&t) {
+        Some(h) => return h.to_string(),
+        None => {}
     }
 
     let mut symbol_hasher = ccx.symbol_hasher().borrow_mut();
@@ -314,8 +315,9 @@ pub fn mangle<PI: Iterator<Item=InternedString>>(path: PI, hash: Option<&str>) -
         push(&mut n, &data);
     }
 
-    if let Some(s) = hash {
-        push(&mut n, s)
+    match hash {
+        Some(s) => push(&mut n, s),
+        None => {}
     }
 
     n.push('E'); // End name-sequence.

branches/stable/src/librustc_trans/trans/base.rs

@@ -150,8 +150,9 @@ impl Drop for _InsnCtxt {
 pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
     debug!("new InsnCtxt: {}", s);
     TASK_LOCAL_INSN_KEY.with(|slot| {
-        if let Some(ctx) = slot.borrow_mut().as_mut() {
-            ctx.push(s)
+        match slot.borrow_mut().as_mut() {
+            Some(ctx) => ctx.push(s),
+            None => {}
         }
     });
     _InsnCtxt {
@@ -197,8 +198,9 @@ fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                 name: &str,
                                 did: DefId)
                                 -> ValueRef {
-    if let Some(n) = ccx.externs().borrow().get(name) {
-        return *n;
+    match ccx.externs().borrow().get(name) {
+        Some(n) => return *n,
+        None => (),
     }
 
     let f = declare::declare_rust_fn(ccx, name, fn_ty);
@@ -236,8 +238,9 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                   -> ValueRef {
     let name = ccx.sess().cstore.item_symbol(did);
     let ty = type_of(ccx, t);
-    if let Some(n) = ccx.externs().borrow_mut().get(&name) {
-        return *n;
+    match ccx.externs().borrow_mut().get(&name) {
+        Some(n) => return *n,
+        None => (),
     }
     // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
     // FIXME(nagisa): investigate whether it can be changed into define_global
@@ -2752,8 +2755,9 @@ fn contains_null(s: &str) -> bool {
 pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
     debug!("get_item_val(id=`{}`)", id);
 
-    if let Some(v) = ccx.item_vals().borrow().get(&id).cloned() {
-        return v;
+    match ccx.item_vals().borrow().get(&id).cloned() {
+        Some(v) => return v,
+        None => {}
     }
 
     let item = ccx.tcx().map.get(id);

branches/stable/src/librustc_trans/trans/common.rs

@@ -947,8 +947,9 @@ pub fn C_u8(ccx: &CrateContext, i: u8) -> ValueRef {
 // our boxed-and-length-annotated strings.
 pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
     unsafe {
-        if let Some(&llval) = cx.const_cstr_cache().borrow().get(&s) {
-            return llval;
+        match cx.const_cstr_cache().borrow().get(&s) {
+            Some(&llval) => return llval,
+            None => ()
         }
 
         let sc = llvm::LLVMConstStringInContext(cx.llcx(),

branches/stable/src/librustc_trans/trans/type_of.rs

@@ -182,8 +182,9 @@ pub fn type_of_fn_from_ty<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fty: Ty<'tcx>)
 //     recursive types. For example, enum types rely on this behavior.
 
 pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
-    if let Some(t) = cx.llsizingtypes().borrow().get(&t).cloned() {
-        return t;
+    match cx.llsizingtypes().borrow().get(&t).cloned() {
+        Some(t) => return t,
+        None => ()
     }
 
     debug!("sizing_type_of {:?}", t);
@@ -316,8 +317,9 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> Type {
 /// NB: If you update this, be sure to update `sizing_type_of()` as well.
 pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
     // Check the cache.
-    if let Some(&llty) = cx.lltypes().borrow().get(&t) {
-        return llty;
+    match cx.lltypes().borrow().get(&t) {
+        Some(&llty) => return llty,
+        None => ()
     }
 
     debug!("type_of {:?}", t);

branches/stable/src/librustdoc/html/render.rs

@@ -2734,19 +2734,18 @@ fn make_item_keywords(it: &clean::Item) -> String {
 
 fn get_index_search_type(item: &clean::Item,
                          parent: Option<String>) -> Option<IndexItemFunctionType> {
-    let (decl, selfty) = match item.inner {
-        clean::FunctionItem(ref f) => (&f.decl, None),
-        clean::MethodItem(ref m) => (&m.decl, Some(&m.self_)),
-        clean::TyMethodItem(ref m) => (&m.decl, Some(&m.self_)),
+    let decl = match item.inner {
+        clean::FunctionItem(ref f) => &f.decl,
+        clean::MethodItem(ref m) => &m.decl,
+        clean::TyMethodItem(ref m) => &m.decl,
         _ => return None
     };
 
     let mut inputs = Vec::new();
 
     // Consider `self` an argument as well.
-    match parent.and_then(|p| selfty.map(|s| (p, s)) ) {
-        Some((_, &clean::SelfStatic)) | None => (),
-        Some((name, _)) => inputs.push(Type { name: Some(name.to_ascii_lowercase()) }),
+    if let Some(name) = parent {
+        inputs.push(Type { name: Some(name.to_ascii_lowercase()) });
     }
 
     inputs.extend(&mut decl.inputs.values.iter().map(|arg| {

branches/stable/src/librustdoc/lib.rs

@@ -385,8 +385,9 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
         *s.borrow_mut() = analysis.take();
     });
 
-    if let Some(name) = matches.opt_str("crate-name") {
-        krate.name = name
+    match matches.opt_str("crate-name") {
+        Some(name) => krate.name = name,
+        None => {}
     }
 
     // Process all of the crate attributes, extracting plugin metadata along

branches/stable/src/libstd/net/addr.rs

@@ -467,8 +467,9 @@ impl ToSocketAddrs for str {
     type Iter = vec::IntoIter<SocketAddr>;
     fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {
         // try to parse as a regular SocketAddr first
-        if let Some(addr) = self.parse().ok() {
-            return Ok(vec![addr].into_iter());
+        match self.parse().ok() {
+            Some(addr) => return Ok(vec![addr].into_iter()),
+            None => {}
         }
 
         macro_rules! try_opt {

branches/stable/src/libstd/net/parser.rs

@@ -66,8 +66,9 @@ impl<'a> Parser<'a> {
     fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>])
                -> Option<T> {
         for pf in parsers {
-            if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {
-                return Some(r);
+            match self.read_atomically(|p: &mut Parser| pf(p)) {
+                Some(r) => return Some(r),
+                None => {}
             }
         }
         None

branches/stable/src/libstd/primitive_docs.rs

@@ -12,50 +12,6 @@
 //
 /// The boolean type.
 ///
-/// The `bool` represents a value, which could only be either `true` or `false`.
-///
-/// # Basic usage
-///
-/// `bool` implements various traits, such as [`BitAnd`], [`BitOr`], [`Not`], etc.,
-/// which allow us to perform boolean operations using `&`, `|` and `!`.
-///
-/// [`if`] always demands a `bool` value. [`assert!`], being an important macro in testing,
-/// checks whether an expression returns `true`.
-///
-/// ```
-/// let bool_val = true & false | false;
-/// assert!(!bool_val);
-/// ```
-///
-/// [`assert!`]: std/macro.assert!.html
-/// [`if` conditionals]: ../../book/if.html
-/// [`BitAnd`]: ../ops/trait.BitAnd.html
-/// [`BitOr`]: ../ops/trait.BitOr.html
-/// [`Not`]: ../ops/trait.Not.html
-///
-/// # Examples
-///
-/// A trivial example of the usage of `bool`,
-///
-/// ```
-/// let praise_the_borrow_checker = true;
-///
-/// // using the `if` conditional
-/// if praise_the_borrow_checker {
-///     println!("oh, yeah!");
-/// } else {
-///     println!("what?!!");
-/// }
-///
-/// // ... or, a match pattern
-/// match praise_the_borrow_checker {
-///     true => println!("keep praising!"),
-///     false => println!("you should praise!"),
-/// }
-/// ```
-///
-/// Also, since `bool` implements the [`Copy`](../marker/trait.Copy.html) trait, we don't
-/// have to worry about the move semantics (just like the integer and float primitives).
 mod prim_bool { }
 
 #[doc(primitive = "char")]
@@ -577,3 +533,4 @@ mod prim_isize { }
 /// *[See also the `std::usize` module](usize/index.html).*
 ///
 mod prim_usize { }
+

branches/stable/src/libstd/sys/windows/thread_local.rs

@@ -69,8 +69,9 @@ static mut DTORS: *mut Vec<(Key, Dtor)> = ptr::null_mut();
 pub unsafe fn create(dtor: Option<Dtor>) -> Key {
     let key = c::TlsAlloc();
     assert!(key != c::TLS_OUT_OF_INDEXES);
-    if let Some(f) = dtor {
-        register_dtor(key, f);
+    match dtor {
+        Some(f) => register_dtor(key, f),
+        None => {}
     }
     return key;
 }