Test fixes and rebase conflicts

Author: alexcrichton

src/doc/guide-error-handling.md

@@ -147,10 +147,10 @@ for all but the most trivial of situations.
 Here's an example of using `Result`:
 
 ```rust
-#[deriving(Show)]
+#[derive(Show)]
 enum Version { Version1, Version2 }
 
-#[deriving(Show)]
+#[derive(Show)]
 enum ParseError { InvalidHeaderLength, InvalidVersion }
 
 fn parse_version(header: &[u8]) -> Result<Version, ParseError> {

src/doc/guide-ffi.md

@@ -262,6 +262,7 @@ referenced Rust object.
 Rust code:
 
 ~~~~no_run
+# use std::boxed::Box;
 
 #[repr(C)]
 struct RustObject {
@@ -286,7 +287,7 @@ extern {
 
 fn main() {
     // Create the object that will be referenced in the callback
-    let mut rust_object = box RustObject { a: 5 };
+    let mut rust_object = Box::new(RustObject { a: 5 });
 
     unsafe {
         register_callback(&mut *rust_object, callback);

src/doc/guide-ownership.md

@@ -81,27 +81,29 @@ therefore deallocates the memory for you. Here's the equivalent example in
 Rust:
 
 ```rust
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 }
 ```
 
-The `box` keyword creates a `Box<T>` (specifically `Box<int>` in this case) by
-allocating a small segment of memory on the heap with enough space to fit an
-`int`. But where in the code is the box deallocated? We said before that we
-must have a deallocation for each allocation. Rust handles this for you. It
+The `Box::new` function creates a `Box<T>` (specifically `Box<int>` in this
+case) by allocating a small segment of memory on the heap with enough space to
+fit an `int`. But where in the code is the box deallocated? We said before that
+we must have a deallocation for each allocation. Rust handles this for you. It
 knows that our handle, `x`, is the owning reference to our box. Rust knows that
 `x` will go out of scope at the end of the block, and so it inserts a call to
 deallocate the memory at the end of the scope. Because the compiler does this
-for us, it's impossible to forget. We always have exactly one deallocation paired
-with each of our allocations.
+for us, it's impossible to forget. We always have exactly one deallocation
+  paired with each of our allocations.
 
 This is pretty straightforward, but what happens when we want to pass our box
 to a function? Let's look at some code:
 
 ```rust
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     add_one(x);
 }
@@ -115,8 +117,9 @@ This code works, but it's not ideal. For example, let's add one more line of
 code, where we print out the value of `x`:
 
 ```{rust,ignore}
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     add_one(x);
 
@@ -148,8 +151,9 @@ To fix this, we can have `add_one` give ownership back when it's done with the
 box:
 
 ```rust
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     let y = add_one(x);
 

src/doc/guide-pointers.md

@@ -455,12 +455,13 @@ fn rc_succ(x: Rc<int>) -> int { *x + 1 }
 Note that the caller of your function will have to modify their calls slightly:
 
 ```{rust}
+# use std::boxed::Box;
 use std::rc::Rc;
 
 fn succ(x: &int) -> int { *x + 1 }
 
 let ref_x = &5i;
-let box_x = box 5i;
+let box_x = Box::new(5i);
 let rc_x  = Rc::new(5i);
 
 succ(ref_x);
@@ -477,24 +478,17 @@ those contents.
 heap allocation in Rust. Creating a box looks like this:
 
 ```{rust}
-let x = box(std::boxed::HEAP) 5i;
+# use std::boxed::Box;
+let x = Box::new(5i);
 ```
 
-`box` is a keyword that does 'placement new,' which we'll talk about in a bit.
-`box` will be useful for creating a number of heap-allocated types, but is not
-quite finished yet. In the meantime, `box`'s type defaults to
-`std::boxed::HEAP`, and so you can leave it off:
-
-```{rust}
-let x = box 5i;
-```
-
-As you might assume from the `HEAP`, boxes are heap allocated. They are
-deallocated automatically by Rust when they go out of scope:
+Boxes are heap allocated and they are deallocated automatically by Rust when
+they go out of scope:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     // stuff happens
 
@@ -513,8 +507,9 @@ You don't need to fully grok the theory of affine types or regions to grok
 boxes, though. As a rough approximation, you can treat this Rust code:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     // stuff happens
 }
@@ -553,12 +548,13 @@ for more detail on how lifetimes work.
 Using boxes and references together is very common. For example:
 
 ```{rust}
+# use std::boxed::Box;
 fn add_one(x: &int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x));
 }
@@ -570,12 +566,13 @@ function, and since it's only reading the value, allows it.
 We can borrow `x` multiple times, as long as it's not simultaneous:
 
 ```{rust}
+# use std::boxed::Box;
 fn add_one(x: &int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x));
     println!("{}", add_one(&*x));
@@ -586,12 +583,13 @@ fn main() {
 Or as long as it's not a mutable borrow. This will error:
 
 ```{rust,ignore}
+# use std::boxed::Box;
 fn add_one(x: &mut int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x)); // error: cannot borrow immutable dereference
                                   // of `&`-pointer as mutable
@@ -612,22 +610,23 @@ Sometimes, you need a recursive data structure. The simplest is known as a
 
 
 ```{rust}
-#[deriving(Show)]
+# use std::boxed::Box;
+#[derive(Show)]
 enum List<T> {
     Cons(T, Box<List<T>>),
     Nil,
 }
 
 fn main() {
-    let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil)));
+    let list: List<int> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Cons(3, Box::new(List::Nil))))));
     println!("{:?}", list);
 }
 ```
 
 This prints:
 
 ```text
-Cons(1, box Cons(2, box Cons(3, box Nil)))
+Cons(1, Box(Cons(2, Box(Cons(3, Box(Nil))))))
 ```
 
 The reference to another `List` inside of the `Cons` enum variant must be a box,
@@ -667,6 +666,7 @@ In many languages with pointers, you'd return a pointer from a function
 so as to avoid copying a large data structure. For example:
 
 ```{rust}
+# use std::boxed::Box;
 struct BigStruct {
     one: int,
     two: int,
@@ -675,15 +675,15 @@ struct BigStruct {
 }
 
 fn foo(x: Box<BigStruct>) -> Box<BigStruct> {
-    return box *x;
+    return Box::new(*x);
 }
 
 fn main() {
-    let x = box BigStruct {
+    let x = Box::new(BigStruct {
         one: 1,
         two: 2,
         one_hundred: 100,
-    };
+    });
 
     let y = foo(x);
 }
@@ -695,6 +695,7 @@ than the hundred `int`s that make up the `BigStruct`.
 This is an antipattern in Rust. Instead, write this:
 
 ```{rust}
+# use std::boxed::Box;
 struct BigStruct {
     one: int,
     two: int,
@@ -707,13 +708,13 @@ fn foo(x: Box<BigStruct>) -> BigStruct {
 }
 
 fn main() {
-    let x = box BigStruct {
+    let x = Box::new(BigStruct {
         one: 1,
         two: 2,
         one_hundred: 100,
-    };
+    });
 
-    let y = box foo(x);
+    let y = Box::new(foo(x));
 }
 ```
 

src/doc/guide-unsafe.md

@@ -197,6 +197,7 @@ extern crate libc;
 use libc::{c_void, size_t, malloc, free};
 use std::mem;
 use std::ptr;
+# use std::boxed::Box;
 
 // Define a wrapper around the handle returned by the foreign code.
 // Unique<T> has the same semantics as Box<T>
@@ -265,7 +266,7 @@ impl<T: Send> Drop for Unique<T> {
 // A comparison between the built-in `Box` and this reimplementation
 fn main() {
     {
-        let mut x = box 5i;
+        let mut x = Box::new(5i);
         *x = 10;
     } // `x` is freed here
 
@@ -653,7 +654,7 @@ sugar for dynamic allocations via `malloc` and `free`:
 
 ```
 #![no_std]
-#![feature(lang_items)]
+#![feature(lang_items, box_syntax)]
 
 extern crate libc;
 

src/doc/guide.md

@@ -3802,18 +3802,19 @@ enum List {             // error: illegal recursive enum type
 
 But the compiler complains that the type is recursive, that is, it could be
 arbitrarily large. To remedy this, Rust provides a fixed-size container called
-a **box** that can hold any type. You can box up any value with the `box`
-keyword. Our boxed List gets the type `Box<List>` (more on the notation when we
+a **Box** that can hold any type. You can box up any value with the `Box::new`
+function. Our boxed List gets the type `Box<List>` (more on the notation when we
 get to generics):
 
 ```{rust}
+# use std::boxed::Box;
 enum List {
     Node(u32, Box<List>),
     Nil
 }
 
 fn main() {
-    let list = List::Node(0, box List::Node(1, box List::Nil));
+    let list = List::Node(0, Box::new(List::Node(1, Box::new(List::Nil))));
 }
 ```
 
@@ -3826,8 +3827,9 @@ just like regular references. This (rather silly) example dynamically allocates
 an integer `5` and makes `x` a pointer to it:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5;
+    let x = Box::new(5);
     println!("{}", *x);     // Prints 5
 }
 ```
@@ -3858,7 +3860,8 @@ Boxes are the sole owner of their contents, so you cannot take a mutable
 reference to them and then use the original box:
 
 ```{rust,ignore}
-let mut x = box 5;
+# use std::boxed::Box;
+let mut x = Box::new(5);
 let y = &mut x;
 
 *x; // you might expect 5, but this is actually an error
@@ -3879,7 +3882,8 @@ As long as `y` is borrowing the contents, we cannot use `x`. After `y` is
 done borrowing the value, we can use it again. This works fine:
 
 ```{rust}
-let mut x = box 5;
+# use std::boxed::Box;
+let mut x = Box::new(5);
 
 {
     let y = &mut x;