---

yaml
---
r: 275181
b: refs/heads/stable
c: 397ab31
h: refs/heads/master
i:
  275179: 0e8a783

Author: matklad

[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: 901eca9e6ce7a527e1014fda3301e6ddf1365096
+refs/heads/stable: 397ab315e76d59f634b79aa2c694571ad0c3e000
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

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 at the
-top of [modules](#modules) and [blocks](grammar.html#block-expressions).
+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.
 
 > **Note**: Unlike in many languages,
 > `use` declarations in Rust do *not* declare linkage dependency with external crates.
@@ -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/liblibc

@@ -1 +1 @@
-Subproject commit 16f1c190afbc7605ed50a40f802189e436de68f6
+Subproject commit 1b1eea2cdd77c63d73ba0b09b905a91910d1c992

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

branches/stable/src/libsyntax/parse/attr.rs

@@ -11,7 +11,7 @@
 use attr;
 use ast;
 use codemap::{spanned, Spanned, mk_sp, Span};
-use parse::common::SeqSep;
+use parse::common::*; //resolve bug?
 use parse::PResult;
 use parse::token;
 use parse::parser::{Parser, TokenType};
@@ -200,7 +200,7 @@ impl<'a> Parser<'a> {
     fn parse_meta_seq(&mut self) -> PResult<'a, Vec<P<ast::MetaItem>>> {
         self.parse_unspanned_seq(&token::OpenDelim(token::Paren),
                                  &token::CloseDelim(token::Paren),
-                                 SeqSep::trailing_allowed(token::Comma),
+                                 seq_sep_trailing_allowed(token::Comma),
                                  |p: &mut Parser<'a>| p.parse_meta_item())
     }
 }

branches/stable/src/libsyntax/parse/common.rs

@@ -19,18 +19,16 @@ pub struct SeqSep {
     pub trailing_sep_allowed: bool,
 }
 
-impl SeqSep {
-    pub fn trailing_allowed(t: token::Token) -> SeqSep {
-        SeqSep {
-            sep: Some(t),
-            trailing_sep_allowed: true,
-        }
+pub fn seq_sep_trailing_allowed(t: token::Token) -> SeqSep {
+    SeqSep {
+        sep: Some(t),
+        trailing_sep_allowed: true,
     }
+}
 
-    pub fn none() -> SeqSep {
-        SeqSep {
-            sep: None,
-            trailing_sep_allowed: false,
-        }
+pub fn seq_sep_none() -> SeqSep {
+    SeqSep {
+        sep: None,
+        trailing_sep_allowed: false,
     }
 }