---

yaml
---
r: 212031
b: refs/heads/tmp
c: c516eee
h: refs/heads/master
i:
  212029: 1cb6c05
  212027: a18231e
  212023: 88aba40
  212015: 7c2de22
  211999: bee6436
  211967: 1401657
v: v3

Author: SimonSapin

[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: 42a59aef710c66e17627e00cc4d00cf29a7b46ed
+refs/heads/tmp: c516eee503ae643ead9553fed70528230feb2b1f
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: b77d60adb019bb5de05e884a99f3290ec4694137
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/CONTRIBUTING.md

@@ -84,8 +84,7 @@ feature. We use the 'fork and pull' model described there.
 Please make pull requests against the `master` branch.
 
 All pull requests are reviewed by another person. We have a bot,
-@rust-highfive, that will automatically assign a random person to review your
-request.
+@rust-highfive, that will automatically assign a random person to review your request.
 
 If you want to request that a specific person reviews your pull request,
 you can add an `r?` to the message. For example, Steve usually reviews
@@ -125,10 +124,6 @@ To save @bors some work, and to get small changes through more quickly, when
 the other rollup-eligible patches too, and they'll get tested and merged at
 the same time.
 
-To find documentation-related issues, sort by the [A-docs label][adocs]. 
-
-[adocs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs
-
 ## Issue Triage
 
 Sometimes, an issue will stay open, even though the bug has been fixed. And
@@ -137,40 +132,8 @@ meantime.
 
 It can be helpful to go through older bug reports and make sure that they are
 still valid. Load up an older issue, double check that it's still true, and
-leave a comment letting us know if it is or is not. The [least recently
-updated sort][lru] is good for finding issues like this.
-
-Contributors with sufficient permissions on the Rust repo can help by adding
-labels to triage issues:
-
-* Yellow, **A**-prefixed labels state which **area** of the project an issue
-  relates to. 
-
-* Magenta, **B**-prefixed labels identify bugs which **belong** elsewhere. 
-
-* Green, **E**-prefixed labels explain the level of **experience** necessary
-  to fix the issue.
-
-* Red, **I**-prefixed labels indicate the **importance** of the issue. The
-  [I-nominated][inom] label indicates that an issue has been nominated for
-  prioritizing at the next triage meeting. 
-
-* Orange, **P**-prefixed labels indicate a bug's **priority**. These labels
-  are only assigned during triage meetings, and replace the [I-nominated][inom]
-  label. 
-
-* Blue, **T**-prefixed bugs denote which **team** the issue belongs to.
-
-* Dark blue, **beta-** labels track changes which need to be backported into
-  the beta branches. 
- 
-* The purple **metabug** label marks lists of bugs collected by other
-  categories.  
-
-If you're looking for somewhere to start, check out the [E-easy][eeasy] tag. 
+leave a comment letting us know if it is or is not. The [least recently updated sort][lru] is good for finding issues like this.
 
-[inom]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-nominated
-[eeasy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
 [lru]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc
 
 ## Out-of-tree Contributions

branches/tmp/src/libcollections/binary_heap.rs

@@ -153,7 +153,7 @@
 use core::prelude::*;
 
 use core::iter::{FromIterator};
-use core::mem::swap;
+use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
 use slice;
@@ -484,42 +484,46 @@ impl<T: Ord> BinaryHeap<T> {
 
     // The implementations of sift_up and sift_down use unsafe blocks in
     // order to move an element out of the vector (leaving behind a
-    // hole), shift along the others and move the removed element back into the
-    // vector at the final location of the hole.
-    // The `Hole` type is used to represent this, and make sure
-    // the hole is filled back at the end of its scope, even on panic.
-    // Using a hole reduces the constant factor compared to using swaps,
-    // which involves twice as many moves.
-    fn sift_up(&mut self, start: usize, pos: usize) {
+    // zeroed element), shift along the others and move it back into the
+    // vector over the junk element. This reduces the constant factor
+    // compared to using swaps, which involves twice as many moves.
+    fn sift_up(&mut self, start: usize, mut pos: usize) {
         unsafe {
-            // Take out the value at `pos` and create a hole.
-            let mut hole = Hole::new(&mut self.data, pos);
+            let new = replace(&mut self.data[pos], zeroed());
 
-            while hole.pos() > start {
-                let parent = (hole.pos() - 1) / 2;
-                if hole.removed() <= hole.get(parent) { break }
-                hole.move_to(parent);
+            while pos > start {
+                let parent = (pos - 1) >> 1;
+
+                if new <= self.data[parent] { break; }
+
+                let x = replace(&mut self.data[parent], zeroed());
+                ptr::write(&mut self.data[pos], x);
+                pos = parent;
             }
+            ptr::write(&mut self.data[pos], new);
         }
     }
 
     fn sift_down_range(&mut self, mut pos: usize, end: usize) {
-        let start = pos;
         unsafe {
-            let mut hole = Hole::new(&mut self.data, pos);
+            let start = pos;
+            let new = replace(&mut self.data[pos], zeroed());
+
             let mut child = 2 * pos + 1;
             while child < end {
                 let right = child + 1;
-                if right < end && !(hole.get(child) > hole.get(right)) {
+                if right < end && !(self.data[child] > self.data[right]) {
                     child = right;
                 }
-                hole.move_to(child);
-                child = 2 * hole.pos() + 1;
+                let x = replace(&mut self.data[child], zeroed());
+                ptr::write(&mut self.data[pos], x);
+                pos = child;
+                child = 2 * pos + 1;
             }
 
-            pos = hole.pos;
+            ptr::write(&mut self.data[pos], new);
+            self.sift_up(start, pos);
         }
-        self.sift_up(start, pos);
     }
 
     fn sift_down(&mut self, pos: usize) {
@@ -550,73 +554,6 @@ impl<T: Ord> BinaryHeap<T> {
     pub fn clear(&mut self) { self.drain(); }
 }
 
-/// Hole represents a hole in a slice i.e. an index without valid value
-/// (because it was moved from or duplicated).
-/// In drop, `Hole` will restore the slice by filling the hole
-/// position with the value that was originally removed.
-struct Hole<'a, T: 'a> {
-    data: &'a mut [T],
-    /// `elt` is always `Some` from new until drop.
-    elt: Option<T>,
-    pos: usize,
-}
-
-impl<'a, T> Hole<'a, T> {
-    /// Create a new Hole at index `pos`.
-    fn new(data: &'a mut [T], pos: usize) -> Self {
-        unsafe {
-            let elt = ptr::read(&data[pos]);
-            Hole {
-                data: data,
-                elt: Some(elt),
-                pos: pos,
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn pos(&self) -> usize { self.pos }
-
-    /// Return a reference to the element removed
-    #[inline(always)]
-    fn removed(&self) -> &T {
-        self.elt.as_ref().unwrap()
-    }
-
-    /// Return a reference to the element at `index`.
-    ///
-    /// Panics if the index is out of bounds.
-    ///
-    /// Unsafe because index must not equal pos.
-    #[inline(always)]
-    unsafe fn get(&self, index: usize) -> &T {
-        debug_assert!(index != self.pos);
-        &self.data[index]
-    }
-
-    /// Move hole to new location
-    ///
-    /// Unsafe because index must not equal pos.
-    #[inline(always)]
-    unsafe fn move_to(&mut self, index: usize) {
-        debug_assert!(index != self.pos);
-        let index_ptr: *const _ = &self.data[index];
-        let hole_ptr = &mut self.data[self.pos];
-        ptr::copy_nonoverlapping(index_ptr, hole_ptr, 1);
-        self.pos = index;
-    }
-}
-
-impl<'a, T> Drop for Hole<'a, T> {
-    fn drop(&mut self) {
-        // fill the hole again
-        unsafe {
-            let pos = self.pos;
-            ptr::write(&mut self.data[pos], self.elt.take().unwrap());
-        }
-    }
-}
-
 /// `BinaryHeap` iterator.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter <'a, T: 'a> {

branches/tmp/src/libcore/cell.rs

@@ -143,7 +143,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use clone::Clone;
-use cmp::{PartialEq, Eq};
+use cmp::PartialEq;
 use default::Default;
 use marker::{Copy, Send, Sync, Sized};
 use ops::{Deref, DerefMut, Drop};
@@ -263,9 +263,6 @@ impl<T:PartialEq + Copy> PartialEq for Cell<T> {
     }
 }
 
-#[stable(feature = "cell_eq", since = "1.2.0")]
-impl<T:Eq + Copy> Eq for Cell<T> {}
-
 /// A mutable memory location with dynamically checked borrow rules
 ///
 /// See the [module-level documentation](index.html) for more.
@@ -276,7 +273,7 @@ pub struct RefCell<T: ?Sized> {
 }
 
 /// An enumeration of values returned from the `state` method on a `RefCell<T>`.
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug)]
 #[unstable(feature = "std_misc")]
 pub enum BorrowState {
     /// The cell is currently being read, there is at least one active `borrow`.
@@ -482,9 +479,6 @@ impl<T: ?Sized + PartialEq> PartialEq for RefCell<T> {
     }
 }
 
-#[stable(feature = "cell_eq", since = "1.2.0")]
-impl<T: ?Sized + Eq> Eq for RefCell<T> {}
-
 struct BorrowRef<'b> {
     _borrow: &'b Cell<BorrowFlag>,
 }
@@ -551,13 +545,30 @@ impl<'b, T: ?Sized> Deref for Ref<'b, T> {
 ///
 /// A `Clone` implementation would interfere with the widespread
 /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
+#[deprecated(since = "1.2.0", reason = "moved to a `Ref::clone` associated function")]
 #[unstable(feature = "core",
            reason = "likely to be moved to a method, pending language changes")]
 #[inline]
 pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> {
-    Ref {
-        _value: orig._value,
-        _borrow: orig._borrow.clone(),
+    Ref::clone(orig)
+}
+
+impl<'b, T: ?Sized> Ref<'b, T> {
+    /// Copies a `Ref`.
+    ///
+    /// The `RefCell` is already immutably borrowed, so this cannot fail.
+    ///
+    /// This is an associated function that needs to be used as `Ref::clone(...)`.
+    /// A `Clone` implementation or a method would interfere with the widespread
+    /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
+    #[unstable(feature = "cell_extras",
+               reason = "likely to be moved to a method, pending language changes")]
+    #[inline]
+    pub fn clone(orig: &Ref<'b, T>) -> Ref<'b, T> {
+        Ref {
+            _value: orig._value,
+            _borrow: orig._borrow.clone(),
+        }
     }
 }
 

branches/tmp/src/libcoretest/cell.rs

@@ -115,13 +115,13 @@ fn discard_doesnt_unborrow() {
 }
 
 #[test]
-fn clone_ref_updates_flag() {
+fn ref_clone_updates_flag() {
     let x = RefCell::new(0);
     {
         let b1 = x.borrow();
         assert_eq!(x.borrow_state(), BorrowState::Reading);
         {
-            let _b2 = clone_ref(&b1);
+            let _b2 = Ref::clone(&b1);
             assert_eq!(x.borrow_state(), BorrowState::Reading);
         }
         assert_eq!(x.borrow_state(), BorrowState::Reading);