---

yaml
---
r: 235607
b: refs/heads/stable
c: 225ad17
h: refs/heads/master
i:
  235605: d4dfd2f
  235603: 7b42e35
  235599: 98cba9e
v: v3

Author: arthurprs

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: ed49bad0ccb0e9ee7e5ebea69d72a98bed08f77f
+refs/heads/stable: 225ad1752039f6c48189e8e30d4824de691761da
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/libcollections/borrow.rs

@@ -215,7 +215,7 @@ impl<'a, B: ?Sized> Clone for Cow<'a, B> where B: ToOwned {
 impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Acquires a mutable reference to the owned form of the data.
     ///
-    /// Clones the data if it is not already owned.
+    /// Copies the data if it is not already owned.
     ///
     /// # Examples
     ///
@@ -241,7 +241,7 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
 
     /// Extracts the owned data.
     ///
-    /// Clones the data if it is not already owned.
+    /// Copies the data if it is not already owned.
     ///
     /// # Examples
     ///

branches/stable/src/libcollections/vec_deque.rs

@@ -108,8 +108,8 @@ impl<T> VecDeque<T> {
 
     /// Writes an element into the buffer, moving it.
     #[inline]
-    unsafe fn buffer_write(&mut self, off: usize, value: T) {
-        ptr::write(self.ptr().offset(off as isize), value);
+    unsafe fn buffer_write(&mut self, off: usize, t: T) {
+        ptr::write(self.ptr().offset(off as isize), t);
     }
 
     /// Returns true if and only if the buffer is at capacity
@@ -234,9 +234,9 @@ impl<T> VecDeque<T> {
     /// assert_eq!(buf.get(1).unwrap(), &4);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self, index: usize) -> Option<&T> {
-        if index < self.len() {
-            let idx = self.wrap_add(self.tail, index);
+    pub fn get(&self, i: usize) -> Option<&T> {
+        if i < self.len() {
+            let idx = self.wrap_add(self.tail, i);
             unsafe { Some(&*self.ptr().offset(idx as isize)) }
         } else {
             None
@@ -261,9 +261,9 @@ impl<T> VecDeque<T> {
     /// assert_eq!(buf[1], 7);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
-        if index < self.len() {
-            let idx = self.wrap_add(self.tail, index);
+    pub fn get_mut(&mut self, i: usize) -> Option<&mut T> {
+        if i < self.len() {
+            let idx = self.wrap_add(self.tail, i);
             unsafe { Some(&mut *self.ptr().offset(idx as isize)) }
         } else {
             None
@@ -768,7 +768,7 @@ impl<T> VecDeque<T> {
     /// assert_eq!(d.front(), Some(&2));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_front(&mut self, value: T) {
+    pub fn push_front(&mut self, t: T) {
         if self.is_full() {
             let old_cap = self.cap();
             self.buf.double();
@@ -778,7 +778,7 @@ impl<T> VecDeque<T> {
 
         self.tail = self.wrap_sub(self.tail, 1);
         let tail = self.tail;
-        unsafe { self.buffer_write(tail, value); }
+        unsafe { self.buffer_write(tail, t); }
     }
 
     /// Appends an element to the back of a buffer
@@ -794,7 +794,7 @@ impl<T> VecDeque<T> {
     /// assert_eq!(3, *buf.back().unwrap());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_back(&mut self, value: T) {
+    pub fn push_back(&mut self, t: T) {
         if self.is_full() {
             let old_cap = self.cap();
             self.buf.double();
@@ -804,7 +804,7 @@ impl<T> VecDeque<T> {
 
         let head = self.head;
         self.head = self.wrap_add(self.head, 1);
-        unsafe { self.buffer_write(head, value) }
+        unsafe { self.buffer_write(head, t) }
     }
 
     /// Removes the last element from a buffer and returns it, or `None` if
@@ -905,13 +905,13 @@ impl<T> VecDeque<T> {
         self.pop_front()
     }
 
-    /// Inserts an element at `index` within the `VecDeque`. Whichever
+    /// Inserts an element at position `i` within the `VecDeque`. Whichever
     /// end is closer to the insertion point will be moved to make room,
     /// and all the affected elements will be moved to new positions.
     ///
     /// # Panics
     ///
-    /// Panics if `index` is greater than `VecDeque`'s length
+    /// Panics if `i` is greater than `VecDeque`'s length
     ///
     /// # Examples
     /// ```
@@ -924,8 +924,8 @@ impl<T> VecDeque<T> {
     /// buf.insert(1, 11);
     /// assert_eq!(Some(&11), buf.get(1));
     /// ```
-    pub fn insert(&mut self, index: usize, value: T) {
-        assert!(index <= self.len(), "index out of bounds");
+    pub fn insert(&mut self, i: usize, t: T) {
+        assert!(i <= self.len(), "index out of bounds");
         if self.is_full() {
             let old_cap = self.cap();
             self.buf.double();
@@ -955,15 +955,15 @@ impl<T> VecDeque<T> {
         //      A - The element that should be after the insertion point
         //      M - Indicates element was moved
 
-        let idx = self.wrap_add(self.tail, index);
+        let idx = self.wrap_add(self.tail, i);
 
-        let distance_to_tail = index;
-        let distance_to_head = self.len() - index;
+        let distance_to_tail = i;
+        let distance_to_head = self.len() - i;
 
         let contiguous = self.is_contiguous();
 
         match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
-            (true, true, _) if index == 0 => {
+            (true, true, _) if i == 0 => {
                 // push_front
                 //
                 //       T
@@ -999,8 +999,8 @@ impl<T> VecDeque<T> {
                 let new_tail = self.wrap_sub(self.tail, 1);
 
                 self.copy(new_tail, self.tail, 1);
-                // Already moved the tail, so we only copy `index - 1` elements.
-                self.copy(self.tail, self.tail + 1, index - 1);
+                // Already moved the tail, so we only copy `i - 1` elements.
+                self.copy(self.tail, self.tail + 1, i - 1);
 
                 self.tail = new_tail;
             },
@@ -1027,7 +1027,7 @@ impl<T> VecDeque<T> {
                 //      [o o o o o o . . . . o o I A o o]
                 //                           M M
 
-                self.copy(self.tail - 1, self.tail, index);
+                self.copy(self.tail - 1, self.tail, i);
                 self.tail -= 1;
             },
             (false, false, true) => unsafe {
@@ -1107,16 +1107,16 @@ impl<T> VecDeque<T> {
         }
 
         // tail might've been changed so we need to recalculate
-        let new_idx = self.wrap_add(self.tail, index);
+        let new_idx = self.wrap_add(self.tail, i);
         unsafe {
-            self.buffer_write(new_idx, value);
+            self.buffer_write(new_idx, t);
         }
     }
 
-    /// Removes and returns the element at `index` from the `VecDeque`.
+    /// Removes and returns the element at position `i` from the `VecDeque`.
     /// Whichever end is closer to the removal point will be moved to make
     /// room, and all the affected elements will be moved to new positions.
-    /// Returns `None` if `index` is out of bounds.
+    /// Returns `None` if `i` is out of bounds.
     ///
     /// # Examples
     /// ```
@@ -1131,8 +1131,8 @@ impl<T> VecDeque<T> {
     /// assert_eq!(Some(&15), buf.get(2));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, index: usize) -> Option<T> {
-        if self.is_empty() || self.len() <= index {
+    pub fn remove(&mut self, i: usize) -> Option<T> {
+        if self.is_empty() || self.len() <= i {
             return None;
         }
 
@@ -1154,14 +1154,14 @@ impl<T> VecDeque<T> {
         //      R - Indicates element that is being removed
         //      M - Indicates element was moved
 
-        let idx = self.wrap_add(self.tail, index);
+        let idx = self.wrap_add(self.tail, i);
 
         let elem = unsafe {
             Some(self.buffer_read(idx))
         };
 
-        let distance_to_tail = index;
-        let distance_to_head = self.len() - index;
+        let distance_to_tail = i;
+        let distance_to_head = self.len() - i;
 
         let contiguous = self.is_contiguous();
 
@@ -1176,7 +1176,7 @@ impl<T> VecDeque<T> {
                 //      [. . . . o o o o o o . . . . . .]
                 //               M M
 
-                self.copy(self.tail + 1, self.tail, index);
+                self.copy(self.tail + 1, self.tail, i);
                 self.tail += 1;
             },
             (true, false, _) => unsafe {
@@ -1202,7 +1202,7 @@ impl<T> VecDeque<T> {
                 //      [o o o o o o . . . . . . o o o o]
                 //                               M M
 
-                self.copy(self.tail + 1, self.tail, index);
+                self.copy(self.tail + 1, self.tail, i);
                 self.tail = self.wrap_add(self.tail, 1);
             },
             (false, false, false) => unsafe {
@@ -1700,16 +1700,16 @@ impl<A> Index<usize> for VecDeque<A> {
     type Output = A;
 
     #[inline]
-    fn index(&self, index: usize) -> &A {
-        self.get(index).expect("Out of bounds access")
+    fn index(&self, i: usize) -> &A {
+        self.get(i).expect("Out of bounds access")
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> IndexMut<usize> for VecDeque<A> {
     #[inline]
-    fn index_mut(&mut self, index: usize) -> &mut A {
-        self.get_mut(index).expect("Out of bounds access")
+    fn index_mut(&mut self, i: usize) -> &mut A {
+        self.get_mut(i).expect("Out of bounds access")
     }
 }
 

branches/stable/src/libcore/atomic.rs

@@ -78,6 +78,7 @@ use intrinsics;
 use cell::UnsafeCell;
 
 use default::Default;
+use fmt;
 
 /// A boolean type which can be safely shared between threads.
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1089,3 +1090,23 @@ pub fn fence(order: Ordering) {
         }
     }
 }
+
+macro_rules! impl_Debug {
+    ($($t:ident)*) => ($(
+        #[stable(feature = "atomic_debug", since = "1.3.0")]
+        impl fmt::Debug for $t {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.debug_tuple(stringify!($t)).field(&self.load(Ordering::SeqCst)).finish()
+            }
+        }
+    )*);
+}
+
+impl_Debug!{ AtomicUsize AtomicIsize AtomicBool }
+
+#[stable(feature = "atomic_debug", since = "1.3.0")]
+impl<T> fmt::Debug for AtomicPtr<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("AtomicPtr").field(&self.load(Ordering::SeqCst)).finish()
+    }
+}

branches/stable/src/libcore/cell.rs

@@ -36,16 +36,16 @@
 //! would otherwise be disallowed though, there are occasions when interior mutability might be
 //! appropriate, or even *must* be used, e.g.
 //!
-//! * Introducing mutability 'inside' of something immutable
+//! * Introducing inherited mutability roots to shared types.
 //! * Implementation details of logically-immutable methods.
 //! * Mutating implementations of `Clone`.
 //!
-//! ## Introducing mutability 'inside' of something immutable
+//! ## Introducing inherited mutability roots to shared types
 //!
-//! Many shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
+//! Shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be
 //! cloned and shared between multiple parties. Because the contained values may be
-//! multiply-aliased, they can only be borrowed with `&`, not `&mut`. Without cells it would be
-//! impossible to mutate data inside of these smart pointers at all.
+//! multiply-aliased, they can only be borrowed as shared references, not mutable references.
+//! Without cells it would be impossible to mutate data inside of shared boxes at all!
 //!
 //! It's very common then to put a `RefCell<T>` inside shared pointer types to reintroduce
 //! mutability:
@@ -65,8 +65,8 @@
 //! ```
 //!
 //! Note that this example uses `Rc<T>` and not `Arc<T>`. `RefCell<T>`s are for single-threaded
-//! scenarios. Consider using `RwLock<T>` or `Mutex<T>` if you need shared mutability in a
-//! multi-threaded situation.
+//! scenarios. Consider using `Mutex<T>` if you need shared mutability in a multi-threaded
+//! situation.
 //!
 //! ## Implementation details of logically-immutable methods
 //!