---

yaml
---
r: 212110
b: refs/heads/tmp
c: bdef7fa
h: refs/heads/master
v: v3

Author: FuGangqiang

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 62e70d35be3fe532c26a400b499c58a18f18dd3a
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 971731849d7bf88aff38c43ac164b28a8a4a8bcf
+refs/heads/tmp: bdef7faaba1f0e253115b222827b02e8b2ef97c7
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: b77d60adb019bb5de05e884a99f3290ec4694137
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/doc/trpl/guessing-game.md

@@ -38,7 +38,7 @@ Finally, Cargo generated a ‘Hello, world!’ for us. Check out `src/main.rs`:
 
 ```rust
 fn main() {
-    println!("Hello, world!")
+    println!("Hello, world!");
 }
 ```
 
@@ -362,7 +362,7 @@ everything that follows it is part of it, until the next section starts.
 Cargo uses the dependencies section to know what dependencies on external
 crates you have, and what versions you require. In this case, we’ve used version `0.3.0`.
 Cargo understands [Semantic Versioning][semver], which is a standard for writing version
-numbers. If we wanted to use the latest version we could use `*` or we could use a range 
+numbers. If we wanted to use the latest version we could use `*` or we could use a range
 of versions. [Cargo’s documentation][cargodoc] contains more details.
 
 [semver]: http://semver.org

branches/tmp/src/doc/trpl/iterators.md

@@ -213,7 +213,7 @@ As we've said before, an iterator is something that we can call the
 `.next()` method on repeatedly, and it gives us a sequence of things.
 Because you need to call the method, this means that iterators
 can be *lazy* and not generate all of the values upfront. This code,
-for example, does not actually generate the numbers `1-99`, instead
+for example, does not actually generate the numbers `1-100`, instead
 creating a value that merely represents the sequence:
 
 ```rust

branches/tmp/src/doc/trpl/mutability.md

@@ -89,7 +89,7 @@ philosophy, memory safety, and the mechanism by which Rust guarantees it, the
 > * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html
-[borrowing]: references-and-borrowing.html#borrowing
+[borrowing]: borrowing.html#The-Rules
 
 So, that’s the real definition of ‘immutability’: is this safe to have two
 pointers to? In `Arc<T>`’s case, yes: the mutation is entirely contained inside

branches/tmp/src/liballoc/arc.rs

@@ -250,9 +250,6 @@ pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { this.inner().strong.loa
 ///
 /// Returns `None` if the `Arc<T>` is not unique.
 ///
-/// This function is marked **unsafe** because it is racy if weak pointers
-/// are active.
-///
 /// # Examples
 ///
 /// ```
@@ -261,27 +258,24 @@ pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { this.inner().strong.loa
 /// # fn main() {
 /// use alloc::arc::{Arc, get_mut};
 ///
-/// # unsafe {
 /// let mut x = Arc::new(3);
 /// *get_mut(&mut x).unwrap() = 4;
 /// assert_eq!(*x, 4);
 ///
 /// let _y = x.clone();
 /// assert!(get_mut(&mut x).is_none());
 /// # }
-/// # }
 /// ```
 #[inline]
 #[unstable(feature = "alloc")]
-pub unsafe fn get_mut<T: ?Sized>(this: &mut Arc<T>) -> Option<&mut T> {
-    // FIXME(#24880) potential race with upgraded weak pointers here
+pub fn get_mut<T: ?Sized>(this: &mut Arc<T>) -> Option<&mut T> {
     if strong_count(this) == 1 && weak_count(this) == 0 {
         // This unsafety is ok because we're guaranteed that the pointer
         // returned is the *only* pointer that will ever be returned to T. Our
         // reference count is guaranteed to be 1 at this point, and we required
         // the Arc itself to be `mut`, so we're returning the only possible
         // reference to the inner data.
-        let inner = &mut **this._ptr;
+        let inner = unsafe { &mut **this._ptr };
         Some(&mut inner.data)
     } else {
         None
@@ -338,26 +332,19 @@ impl<T: Clone> Arc<T> {
     /// This is also referred to as a copy-on-write operation because the inner
     /// data is cloned if the reference count is greater than one.
     ///
-    /// This method is marked **unsafe** because it is racy if weak pointers
-    /// are active.
-    ///
     /// # Examples
     ///
     /// ```
     /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
-    /// # unsafe {
     /// let mut five = Arc::new(5);
     ///
     /// let mut_five = five.make_unique();
-    /// # }
     /// ```
     #[inline]
     #[unstable(feature = "alloc")]
-    pub unsafe fn make_unique(&mut self) -> &mut T {
-        // FIXME(#24880) potential race with upgraded weak pointers here
-        //
+    pub fn make_unique(&mut self) -> &mut T {
         // Note that we hold a strong reference, which also counts as a weak
         // reference, so we only clone if there is an additional reference of
         // either kind.
@@ -367,7 +354,7 @@ impl<T: Clone> Arc<T> {
         }
         // As with `get_mut()`, the unsafety is ok because our reference was
         // either unique to begin with, or became one upon cloning the contents.
-        let inner = &mut **self._ptr;
+        let inner = unsafe { &mut **self._ptr };
         &mut inner.data
     }
 }
@@ -757,43 +744,39 @@ mod tests {
 
     #[test]
     fn test_arc_get_mut() {
-        unsafe {
-            let mut x = Arc::new(3);
-            *get_mut(&mut x).unwrap() = 4;
-            assert_eq!(*x, 4);
-            let y = x.clone();
-            assert!(get_mut(&mut x).is_none());
-            drop(y);
-            assert!(get_mut(&mut x).is_some());
-            let _w = x.downgrade();
-            assert!(get_mut(&mut x).is_none());
-        }
+        let mut x = Arc::new(3);
+        *get_mut(&mut x).unwrap() = 4;
+        assert_eq!(*x, 4);
+        let y = x.clone();
+        assert!(get_mut(&mut x).is_none());
+        drop(y);
+        assert!(get_mut(&mut x).is_some());
+        let _w = x.downgrade();
+        assert!(get_mut(&mut x).is_none());
     }
 
     #[test]
     fn test_cowarc_clone_make_unique() {
-        unsafe {
-            let mut cow0 = Arc::new(75);
-            let mut cow1 = cow0.clone();
-            let mut cow2 = cow1.clone();
-
-            assert!(75 == *cow0.make_unique());
-            assert!(75 == *cow1.make_unique());
-            assert!(75 == *cow2.make_unique());
-
-            *cow0.make_unique() += 1;
-            *cow1.make_unique() += 2;
-            *cow2.make_unique() += 3;
-
-            assert!(76 == *cow0);
-            assert!(77 == *cow1);
-            assert!(78 == *cow2);
-
-            // none should point to the same backing memory
-            assert!(*cow0 != *cow1);
-            assert!(*cow0 != *cow2);
-            assert!(*cow1 != *cow2);
-        }
+        let mut cow0 = Arc::new(75);
+        let mut cow1 = cow0.clone();
+        let mut cow2 = cow1.clone();
+
+        assert!(75 == *cow0.make_unique());
+        assert!(75 == *cow1.make_unique());
+        assert!(75 == *cow2.make_unique());
+
+        *cow0.make_unique() += 1;
+        *cow1.make_unique() += 2;
+        *cow2.make_unique() += 3;
+
+        assert!(76 == *cow0);
+        assert!(77 == *cow1);
+        assert!(78 == *cow2);
+
+        // none should point to the same backing memory
+        assert!(*cow0 != *cow1);
+        assert!(*cow0 != *cow2);
+        assert!(*cow1 != *cow2);
     }
 
     #[test]
@@ -806,9 +789,7 @@ mod tests {
         assert!(75 == *cow1);
         assert!(75 == *cow2);
 
-        unsafe {
-            *cow0.make_unique() += 1;
-        }
+        *cow0.make_unique() += 1;
 
         assert!(76 == *cow0);
         assert!(75 == *cow1);
@@ -829,9 +810,7 @@ mod tests {
         assert!(75 == *cow0);
         assert!(75 == *cow1_weak.upgrade().unwrap());
 
-        unsafe {
-            *cow0.make_unique() += 1;
-        }
+        *cow0.make_unique() += 1;
 
         assert!(76 == *cow0);
         assert!(cow1_weak.upgrade().is_none());

branches/tmp/src/libcollections/str.rs

@@ -30,7 +30,7 @@
 //! You can get a non-`'static` `&str` by taking a slice of a `String`:
 //!
 //! ```
-//! let some_string = "Hello, world.".to_string();
+//! # let some_string = "Hello, world.".to_string();
 //! let s = &some_string;
 //! ```
 //!

branches/tmp/src/libcore/option.rs

@@ -320,7 +320,7 @@ impl<T> Option<T> {
     ///
     /// ```{.should_panic}
     /// let x: Option<&str> = None;
-    /// x.expect("the world is ending"); // panics with `the world is ending`
+    /// x.expect("the world is ending"); // panics with `world is ending`
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -422,8 +422,7 @@ impl<T> Option<T> {
         }
     }
 
-    /// Applies a function to the contained value (if any),
-    /// or returns a `default` (if not).
+    /// Applies a function to the contained value or returns a default.
     ///
     /// # Examples
     ///
@@ -436,15 +435,14 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U {
+    pub fn map_or<U, F: FnOnce(T) -> U>(self, def: U, f: F) -> U {
         match self {
             Some(t) => f(t),
-            None => default,
+            None => def
         }
     }
 
-    /// Applies a function to the contained value (if any),
-    /// or computes a `default` (if not).
+    /// Applies a function to the contained value or computes a default.
     ///
     /// # Examples
     ///
@@ -459,10 +457,10 @@ impl<T> Option<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U {
+    pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, def: D, f: F) -> U {
         match self {
             Some(t) => f(t),
-            None => default()
+            None => def()
         }
     }
 

branches/tmp/src/libstd/collections/hash/table.rs

@@ -528,7 +528,6 @@ fn test_rounding() {
 
 // Returns a tuple of (key_offset, val_offset),
 // from the start of a mallocated array.
-#[inline]
 fn calculate_offsets(hashes_size: usize,
                      keys_size: usize, keys_align: usize,
                      vals_align: usize)