---

yaml
---
r: 211423
b: refs/heads/tmp
c: 4458b5a
h: refs/heads/master
i:
  211421: 4d05d3d
  211419: 38ca013
  211415: 75ae61c
  211407: 5789978
  211391: 7d49911
v: v3

Author: sfackler

[refs]

@@ -32,7 +32,7 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 2d00dc3b85aaf81caa3a4e5764c5e185a4dd0a7c
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 53941be9814f05496b3147da393c639a9d48957e
+refs/heads/tmp: 4458b5a9d5f11af5cfeb2201a4065131baeeec36
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 704c2ee730d2e948d11a2edd77e3f35de8329a6e
 refs/heads/gate: 97c84447b65164731087ea82685580cc81424412

branches/tmp/src/doc/complement-design-faq.md

@@ -160,7 +160,7 @@ that all delimiters be balanced.
 ## `->` for function return type
 
 This is to make the language easier to parse for humans, especially in the face
-of higher-order functions. `fn foo<T>(f: fn(i32): i32, fn(T): U): U` is not
+of higher-order functions. `fn foo<T>(f: fn(int): int, fn(T): U): U` is not
 particularly easy to read.
 
 ## Why is `let` used to introduce variables?

branches/tmp/src/doc/style/errors/ergonomics.md

@@ -14,8 +14,8 @@ use std::io::{File, Open, Write, IoError};
 
 struct Info {
     name: String,
-    age: i32,
-    rating: i32
+    age: int,
+    rating: int
 }
 
 fn write_info(info: &Info) -> Result<(), IoError> {
@@ -36,8 +36,8 @@ use std::io::{File, Open, Write, IoError};
 
 struct Info {
     name: String,
-    age: i32,
-    rating: i32
+    age: int,
+    rating: int
 }
 
 fn write_info(info: &Info) -> Result<(), IoError> {
@@ -63,4 +63,4 @@ for more details.
 ### The `Result`-`impl` pattern [FIXME]
 
 > **[FIXME]** Document the way that the `io` module uses trait impls
-> on `std::io::Result` to painlessly propagate errors.
+> on `IoResult` to painlessly propagate errors.

branches/tmp/src/doc/style/features/functions-and-methods/input.md

@@ -57,15 +57,15 @@ it becomes.
 Prefer
 
 ```rust
-fn foo<T: Iterator<i32>>(c: T) { ... }
+fn foo<T: Iterator<int>>(c: T) { ... }
 ```
 
 over any of
 
 ```rust
-fn foo(c: &[i32]) { ... }
-fn foo(c: &Vec<i32>) { ... }
-fn foo(c: &SomeOtherCollection<i32>) { ... }
+fn foo(c: &[int]) { ... }
+fn foo(c: &Vec<int>) { ... }
+fn foo(c: &SomeOtherCollection<int>) { ... }
 ```
 
 if the function only needs to iterate over the data.
@@ -121,7 +121,7 @@ The primary exception: sometimes a function is meant to modify data
 that the caller already owns, for example to re-use a buffer:
 
 ```rust
-fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize>
+fn read(&mut self, buf: &mut [u8]) -> IoResult<uint>
 ```
 
 (From the [Reader trait](http://static.rust-lang.org/doc/master/std/io/trait.Reader.html#tymethod.read).)

branches/tmp/src/doc/style/features/functions-and-methods/output.md

@@ -19,15 +19,15 @@ Prefer
 ```rust
 struct SearchResult {
     found: bool,          // item in container?
-    expected_index: usize // what would the item's index be?
+    expected_index: uint  // what would the item's index be?
 }
 
 fn binary_search(&self, k: Key) -> SearchResult
 ```
 or
 
 ```rust
-fn binary_search(&self, k: Key) -> (bool, usize)
+fn binary_search(&self, k: Key) -> (bool, uint)
 ```
 
 over

branches/tmp/src/doc/style/features/let.md

@@ -5,7 +5,7 @@
 Prefer
 
 ```rust
-fn use_mutex(m: sync::mutex::Mutex<i32>) {
+fn use_mutex(m: sync::mutex::Mutex<int>) {
     let guard = m.lock();
     do_work(guard);
     drop(guard); // unlock the lock
@@ -16,7 +16,7 @@ fn use_mutex(m: sync::mutex::Mutex<i32>) {
 over
 
 ```rust
-fn use_mutex(m: sync::mutex::Mutex<i32>) {
+fn use_mutex(m: sync::mutex::Mutex<int>) {
     do_work(m.lock());
     // do other work
 }

branches/tmp/src/doc/style/features/traits/reuse.md

@@ -15,7 +15,7 @@ trait Printable {
     fn print(&self) { println!("{:?}", *self) }
 }
 
-impl Printable for i32 {}
+impl Printable for int {}
 
 impl Printable for String {
     fn print(&self) { println!("{}", *self) }

branches/tmp/src/doc/style/features/types/newtype.md

@@ -43,12 +43,12 @@ promises to the client.
 
 For example, consider a function `my_transform` that returns a compound iterator
 type `Enumerate<Skip<vec::MoveItems<T>>>`. We wish to hide this type from the
-client, so that the client's view of the return type is roughly `Iterator<(usize,
+client, so that the client's view of the return type is roughly `Iterator<(uint,
 T)>`. We can do so using the newtype pattern:
 
 ```rust
 struct MyTransformResult<T>(Enumerate<Skip<vec::MoveItems<T>>>);
-impl<T> Iterator<(usize, T)> for MyTransformResult<T> { ... }
+impl<T> Iterator<(uint, T)> for MyTransformResult<T> { ... }
 
 fn my_transform<T, Iter: Iterator<T>>(iter: Iter) -> MyTransformResult<T> {
     ...

branches/tmp/src/doc/style/ownership/builders.md

@@ -75,7 +75,7 @@ impl Command {
     }
 
     /// Executes the command as a child process, which is returned.
-    pub fn spawn(&self) -> std::io::Result<Process> {
+    pub fn spawn(&self) -> IoResult<Process> {
         ...
     }
 }

branches/tmp/src/doc/style/style/features.md

@@ -3,7 +3,7 @@
 Terminate `return` statements with semicolons:
 
 ``` rust
-fn foo(bar: i32) -> Option<i32> {
+fn foo(bar: int) -> Option<int> {
     if some_condition() {
         return None;
     }

branches/tmp/src/doc/style/style/imports.md

@@ -44,7 +44,7 @@ For example:
 use option::Option;
 use mem;
 
-let i: isize = mem::transmute(Option(0));
+let i: int = mem::transmute(Option(0));
 ```
 
 > **[FIXME]** Add rationale.

branches/tmp/src/doc/style/style/whitespace.md

@@ -10,7 +10,7 @@
 
 ``` rust
 #[deprecated = "Use `bar` instead."]
-fn foo(a: usize, b: usize) -> usize {
+fn foo(a: uint, b: uint) -> uint {
     a + b
 }
 ```

branches/tmp/src/doc/trpl/associated-types.md

@@ -43,7 +43,7 @@ trait Graph {
 Now, our clients can be abstract over a given `Graph`:
 
 ```rust,ignore
-fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> usize { ... }
+fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> uint { ... }
 ```
 
 No need to deal with the `E`dge type here!

branches/tmp/src/doc/trpl/box-syntax-and-patterns.md

@@ -58,7 +58,7 @@ fn main() {
 ```
 
 The idea is that by passing around a box, you're only copying a pointer, rather
-than the hundred `i32`s that make up the `BigStruct`.
+than the hundred `int`s that make up the `BigStruct`.
 
 This is an antipattern in Rust. Instead, write this:
 

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

@@ -134,8 +134,8 @@ x: &'a i32,
 # }
 ```
 
-uses it. So why do we need a lifetime here? We need to ensure that any
-reference to the contained `i32` does not outlive the containing `Foo`.
+uses it. So why do we need a lifetime here? We need to ensure that any reference
+to a `Foo` cannot outlive the reference to an `i32` it contains.
 
 ## Thinking in scopes
 

branches/tmp/src/doc/trpl/references-and-borrowing.md

@@ -206,7 +206,7 @@ fn main() {
 ^
 ```
 
-In other words, the mutable borrow is held through the rest of our example. What
+In other words, the mutable borow is held through the rest of our example. What
 we want is for the mutable borrow to end _before_ we try to call `println!` and
 make an immutable borrow. In Rust, borrowing is tied to the scope that the
 borrow is valid for. And our scopes look like this:

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

@@ -146,7 +146,7 @@ print_area(5);
 We get a compile-time error:
 
 ```text
-error: the trait `HasArea` is not implemented for the type `_` [E0277]
+error: failed to find an implementation of trait main::HasArea for int
 ```
 
 So far, we’ve only added trait implementations to structs, but you can

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/libcollections/fmt.rs

@@ -164,8 +164,8 @@
 //! provides some helper methods.
 //!
 //! Additionally, the return value of this function is `fmt::Result` which is a
-//! typedef to `Result<(), std::io::Error>` (also known as `std::io::Result<()>`).
-//! Formatting implementations should ensure that they return errors from `write!`
+//! typedef to `Result<(), IoError>` (also known as `IoResult<()>`). Formatting
+//! implementations should ensure that they return errors from `write!`
 //! correctly (propagating errors upward).
 //!
 //! An example of implementing the formatting traits would look