---

yaml
---
r: 233841
b: refs/heads/beta
c: 2076cdd
h: refs/heads/master
i:
  233839: e9e2dfe
v: v3

Author: Ms2ger

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: fe9cef7dae8732897820c0e4ca65bc7ee33604be
+refs/heads/beta: 2076cddcf235cc8eed4d4a0ad173a1a6bb90c533
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/.travis.yml

@@ -20,7 +20,7 @@ sudo: false
 before_script:
   - ./configure --enable-ccache
 script:
-  - make tidy && make check -j4
+  - make tidy check -j4
 
 env:
   - CXX=/usr/bin/g++-4.7

branches/beta/README.md

@@ -65,9 +65,6 @@ Read ["Installing Rust"] from [The Book].
    tools.
 
    ```sh
-   # Update package mirrors (may be needed if you have a fresh install of MSYS2)
-   $ pacman -Sy pacman-mirrors
-   
    # Choose one based on platform:
    $ pacman -S mingw-w64-i686-toolchain
    $ pacman -S mingw-w64-x86_64-toolchain

branches/beta/mk/main.mk

@@ -294,7 +294,7 @@ LLVM_VERSION_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --version)
 LLVM_BINDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --bindir)
 LLVM_INCDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --includedir)
 LLVM_LIBDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libdir)
-LLVM_LIBDIR_RUSTFLAGS_$(1)=-L native="$$(LLVM_LIBDIR_$(1))"
+LLVM_LIBDIR_RUSTFLAGS_$(1)=-L "$$(LLVM_LIBDIR_$(1))"
 LLVM_LDFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --ldflags)
 ifeq ($$(findstring freebsd,$(1)),freebsd)
 # On FreeBSD, it may search wrong headers (that are for pre-installed LLVM),

branches/beta/src/doc/nomicon/leaking.md

@@ -155,6 +155,7 @@ impl<T> Rc<T> {
 impl<T> Drop for Rc<T> {
     fn drop(&mut self) {
         unsafe {
+            let inner = &mut ;
             (*self.ptr).ref_count -= 1;
             if (*self.ptr).ref_count == 0 {
                 // drop the data and then free it

branches/beta/src/doc/trpl/crates-and-modules.md

@@ -115,7 +115,7 @@ $ ls target/debug
 build  deps  examples  libphrases-a7448e02a0468eaa.rlib  native
 ```
 
-`libphrases-hash.rlib` is the compiled crate. Before we see how to use this
+`libphrase-hash.rlib` is the compiled crate. Before we see how to use this
 crate from another crate, let’s break it up into multiple files.
 
 # Multiple file crates

branches/beta/src/doc/trpl/ffi.md

@@ -496,11 +496,9 @@ strings are not terminated with `\0`. If you need a NUL-terminated string for
 interoperability with C, you should use the `CString` type in the `std::ffi`
 module.
 
-The [`libc` crate on crates.io][libc] includes type aliases and function
-definitions for the C standard library in the `libc` module, and Rust links
-against `libc` and `libm` by default.
-
-[libc]: https://crates.io/crates/libc
+The standard library includes type aliases and function definitions for the C
+standard library in the `libc` module, and Rust links against `libc` and `libm`
+by default.
 
 # The "nullable pointer optimization"
 

branches/beta/src/doc/trpl/loops.md

@@ -134,7 +134,7 @@ Outputs:
 ```text
 0: Content of line one
 1: Content of line two
-2: Content of line three
+2: Content of line tree
 3: Content of line four
 ```
 

branches/beta/src/doc/trpl/testing.md

@@ -120,26 +120,13 @@ And that's reflected in the summary line:
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
 ```
 
-We also get a non-zero status code. We can use `$?` on OS X and Linux:
+We also get a non-zero status code:
 
 ```bash
 $ echo $?
 101
 ```
 
-On Windows, if you’re using `cmd`:
-
-```bash
-> echo %ERRORLEVEL%
-```
-
-And if you’re using PowerShell:
-
-```bash
-> echo $LASTEXITCODE # the code itself
-> echo $? # a boolean, fail or succeed
-```
-
 This is useful if you want to integrate `cargo test` into other tooling.
 
 We can invert our test's failure with another attribute: `should_panic`:

branches/beta/src/liballoc/arc.rs

@@ -73,7 +73,6 @@ use boxed::Box;
 
 use core::sync::atomic;
 use core::sync::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
-use core::borrow;
 use core::fmt;
 use core::cmp::Ordering;
 use core::mem::{align_of_val, size_of_val};
@@ -1110,7 +1109,3 @@ mod tests {
         assert!(y.upgrade().is_none());
     }
 }
-
-impl<T: ?Sized> borrow::Borrow<T> for Arc<T> {
-    fn borrow(&self) -> &T { &**self }
-}

branches/beta/src/liballoc/boxed.rs

@@ -57,7 +57,6 @@ use heap;
 use raw_vec::RawVec;
 
 use core::any::Any;
-use core::borrow;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{self, Hash};
@@ -563,10 +562,3 @@ impl<T: Clone> Clone for Box<[T]> {
     }
 }
 
-impl<T: ?Sized> borrow::Borrow<T> for Box<T> {
-    fn borrow(&self) -> &T { &**self }
-}
-
-impl<T: ?Sized> borrow::BorrowMut<T> for Box<T> {
-    fn borrow_mut(&mut self) -> &mut T { &mut **self }
-}

branches/beta/src/liballoc/rc.rs

@@ -158,7 +158,6 @@ use boxed::Box;
 #[cfg(test)]
 use std::boxed::Box;
 
-use core::borrow;
 use core::cell::Cell;
 use core::cmp::Ordering;
 use core::fmt;
@@ -1092,7 +1091,3 @@ mod tests {
         assert_eq!(foo, foo.clone());
     }
 }
-
-impl<T: ?Sized> borrow::Borrow<T> for Rc<T> {
-    fn borrow(&self) -> &T { &**self }
-}

branches/beta/src/libcollections/borrow.rs

@@ -21,10 +21,119 @@ use core::ops::Deref;
 use core::option::Option;
 
 use fmt;
+use alloc::{boxed, rc, arc};
 
 use self::Cow::*;
 
-pub use core::borrow::{Borrow, BorrowMut};
+/// A trait for borrowing data.
+///
+/// In general, there may be several ways to "borrow" a piece of data.  The
+/// typical ways of borrowing a type `T` are `&T` (a shared borrow) and `&mut T`
+/// (a mutable borrow). But types like `Vec<T>` provide additional kinds of
+/// borrows: the borrowed slices `&[T]` and `&mut [T]`.
+///
+/// When writing generic code, it is often desirable to abstract over all ways
+/// of borrowing data from a given type. That is the role of the `Borrow`
+/// trait: if `T: Borrow<U>`, then `&U` can be borrowed from `&T`.  A given
+/// type can be borrowed as multiple different types. In particular, `Vec<T>:
+/// Borrow<Vec<T>>` and `Vec<T>: Borrow<[T]>`.
+///
+/// If you are implementing `Borrow` and both `Self` and `Borrowed` implement
+/// `Hash`, `Eq`, and/or `Ord`, they must produce the same result.
+///
+/// `Borrow` is very similar to, but different than, `AsRef`. See
+/// [the book][book] for more.
+///
+/// [book]: ../../book/borrow-and-asref.html
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait Borrow<Borrowed: ?Sized> {
+    /// Immutably borrows from an owned value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::borrow::Borrow;
+    ///
+    /// fn check<T: Borrow<str>>(s: T) {
+    ///     assert_eq!("Hello", s.borrow());
+    /// }
+    ///
+    /// let s = "Hello".to_string();
+    ///
+    /// check(s);
+    ///
+    /// let s = "Hello";
+    ///
+    /// check(s);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn borrow(&self) -> &Borrowed;
+}
+
+/// A trait for mutably borrowing data.
+///
+/// Similar to `Borrow`, but for mutable borrows.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait BorrowMut<Borrowed: ?Sized> : Borrow<Borrowed> {
+    /// Mutably borrows from an owned value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::borrow::BorrowMut;
+    ///
+    /// fn check<T: BorrowMut<[i32]>>(mut v: T) {
+    ///     assert_eq!(&mut [1, 2, 3], v.borrow_mut());
+    /// }
+    ///
+    /// let v = vec![1, 2, 3];
+    ///
+    /// check(v);
+    /// ```
+    #[stable(feature = "rust1", since = "1.0.0")]
+    fn borrow_mut(&mut self) -> &mut Borrowed;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Borrow<T> for T {
+    fn borrow(&self) -> &T { self }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> BorrowMut<T> for T {
+    fn borrow_mut(&mut self) -> &mut T { self }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: ?Sized> Borrow<T> for &'a T {
+    fn borrow(&self) -> &T { &**self }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: ?Sized> Borrow<T> for &'a mut T {
+    fn borrow(&self) -> &T { &**self }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a, T: ?Sized> BorrowMut<T> for &'a mut T {
+    fn borrow_mut(&mut self) -> &mut T { &mut **self }
+}
+
+impl<T: ?Sized> Borrow<T> for boxed::Box<T> {
+    fn borrow(&self) -> &T { &**self }
+}
+
+impl<T: ?Sized> BorrowMut<T> for boxed::Box<T> {
+    fn borrow_mut(&mut self) -> &mut T { &mut **self }
+}
+
+impl<T: ?Sized> Borrow<T> for rc::Rc<T> {
+    fn borrow(&self) -> &T { &**self }
+}
+
+impl<T: ?Sized> Borrow<T> for arc::Arc<T> {
+    fn borrow(&self) -> &T { &**self }
+}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B> where B: ToOwned, <B as ToOwned>::Owned: 'a {