---

yaml
---
r: 218846
b: refs/heads/snap-stage3
c: 6120704
h: refs/heads/master
v: v3

Author: olombard

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: 845cee4e20532d90454b2d2d1a55d0c2dfcfee09
+refs/heads/snap-stage3: 61207046de3e64db13683f784230a1fd590c4573
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/configure

@@ -565,7 +565,7 @@ opt rpath 0 "build rpaths into rustc itself"
 # This is used by the automation to produce single-target nightlies
 opt dist-host-only 0 "only install bins for the host architecture"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
-opt llvm-version-check 1 "check if the LLVM version is supported, build anyway"
+opt llvm-version-check 1 "don't check if the LLVM version is supported, build anyway"
 
 # Optimization and debugging options. These may be overridden by the release channel, etc.
 opt_nosave optimize 1 "build optimized rust code"

branches/snap-stage3/src/doc/trpl/installing-rust.md

@@ -2,12 +2,8 @@
 
 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 Linux
-or a Mac, all you need to do is this: 
-
-> Note: you don't need to type in the `$`s, they just indicate the start of
-> each command. You’ll see many tutorials and examples around the web that
-> follow this convention: `$` for commands run as your regular user, and
-> `#` for commands you should be running as an administrator.
+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):
 
 ```bash
 $ curl -sf -L https://static.rust-lang.org/rustup.sh | sh

branches/snap-stage3/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/snap-stage3/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]: borrowing.html#The-Rules
+[borrowing]: references-and-borrowing.html#borrowing
 
 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/snap-stage3/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/snap-stage3/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)