---

yaml
---
r: 129595
b: refs/heads/auto
c: 4aff964
h: refs/heads/master
i:
  129593: 45d07c3
  129591: ced7b7c
v: v3

Author: tshepang

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 5550edef46ba7893b90d210913e3b37ffd77cae4
+refs/heads/auto: 4aff964463b90ae8a27d68ae7d85b6ba721d0779
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/guide.md

@@ -1801,6 +1801,7 @@ Let's try compiling what Cargo gave us:
 ```{bash}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
+$
 ```
 
 Excellent! Open up your `src/main.rs` again. We'll be writing all of
@@ -1816,6 +1817,7 @@ $ cargo run
    Compiling guessing_game v0.1.0 (file:/home/you/projects/guessing_game)
      Running `target/guessing_game`
 Hello, world!
+$
 ```
 
 Great! The `run` command comes in handy when you need to rapidly iterate on a project.
@@ -1960,6 +1962,7 @@ fn main() {
 ```{notrust,ignore}
 $ cargo build
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
+$
 ```
 
 Excellent! Try running our new program a few times:
@@ -2018,7 +2021,7 @@ And trying it out:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 57
 Please input your guess.
@@ -2289,12 +2292,13 @@ print an error message and return. Let's give this a shot:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 17
 Please input your guess.
 5
 Please input a number!
+$
 ```
 
 Uh, what? But we did!
@@ -2354,13 +2358,14 @@ Let's try it!
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 58
 Please input your guess.
-  76
+  76  
 You guessed: 76
 Too big!
+$
 ```
 
 Nice! You can see I even added spaces before my guess, and it still figured
@@ -2431,7 +2436,7 @@ that `return`? If we give a non-number answer, we'll `return` and quit. Observe:
 ```{notrust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 59
 Please input your guess.
@@ -2449,6 +2454,7 @@ You win!
 Please input your guess.
 quit
 Please input a number!
+$
 ```
 
 Ha! `quit` actually quits. As does any other non-number input. Well, this is
@@ -2563,7 +2569,7 @@ Now we should be good! Let's try:
 ```{rust,ignore}
 $ cargo build
    Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-$ ./target/guessing_game
+$ ./target/guessing_game 
 Guess the number!
 The secret number is: 61
 Please input your guess.
@@ -2765,6 +2771,7 @@ $ cargo run
    Compiling modules v0.0.1 (file:///home/you/projects/modules)
      Running `target/modules`
 Hello, world!
+$
 ```
 
 Nice!
@@ -2804,8 +2811,7 @@ be named, by convention.
 Next, we added an `extern crate modules` to the top of our `src/main.rs`. This,
 as you can guess, lets Rust know that our crate relies on another, external
 crate. We also had to modify our call to `print_hello`: now that it's in
-another crate, we need to first specify the crate, then the module inside of it,
-then the function name.
+another crate, we need to specify that crate first.
 
 This doesn't _quite_ work yet. Try it:
 
@@ -2916,6 +2922,7 @@ This should all compile as usual:
 ```{notrust,ignore}
 $ cargo build
    Compiling modules v0.0.1 (file:///home/you/projects/modules)
+$
 ```
 
 We've seen how the `::` operator can be used to call into modules, but when
@@ -3089,6 +3096,7 @@ $ cargo run
    Compiling testing v0.0.1 (file:///home/you/projects/testing)
      Running `target/testing`
 Hello, world!
+$
 ```
 
 Great. Rust's infrastructure supports tests in two sorts of places, and they're
@@ -3241,6 +3249,7 @@ running 1 test
 test foo ... ok
 
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
+$
 ```
 
 Nice! Our test passes, as we expected. Let's get rid of that warning for our `main`
@@ -3708,18 +3717,18 @@ That's a lot to take in. It's also one of the _most_ important concepts in
 all of Rust. Let's see this syntax in action:
 
 ```{rust}
-{
+{ 
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // other code here...
-
+   
 } // privilege 1: when x goes out of scope, this memory is deallocated
 
 /// this function borrows an integer. It's given back automatically when the
 /// function returns.
-fn foo(x: &int) -> &int { x }
+fn foo(x: &int) -> &int { x } 
 
-{
+{ 
     let x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     // privilege 2: you may lend that resource, to as many borrowers as you'd like
@@ -3729,14 +3738,14 @@ fn foo(x: &int) -> &int { x }
     foo(&x); // functions can borrow too!
 
     let a = &x; // we can do this alllllll day!
-}
+} 
 
-{
+{ 
     let mut x = 5i; // x is the owner of this integer, which is memory on the stack.
 
     let y = &mut x; // privilege 3: you may lend that resource to a single borrower,
                     // mutably
-}
+}   
 ```
 
 If you are a borrower, you get a few privileges as well, but must also obey a
@@ -4525,7 +4534,7 @@ let one_to_one_hundred = range(0i, 100i).collect();
 ```
 
 As you can see, we call `collect()` on our iterator. `collect()` takes
-as many values as the iterator will give it, and returns a collection
+as many values as the iterator will give it, and returns a collection 
 of the results. So why won't this compile? Rust can't determine what
 type of things you want to collect, and so you need to let it know.
 Here's the version that does compile:
@@ -5498,7 +5507,7 @@ fn main() {
 }
 ```
 
-Whew! This isn't too terrible. You can see that we still `let x = 5i`,
+Whew! This isn't too terrible. You can see that we still `let x = 5i`, 
 but then things get a little bit hairy. Three more bindings get set: a
 static format string, an argument vector, and the aruments. We then
 invoke the `println_args` function with the generated arguments.
@@ -5521,9 +5530,9 @@ There are two circumstances where Rust's safety provisions don't work well.
 The first is when interfacing with C code, and the second is when building
 certain kinds of abstractions.
 
-Rust has support for FFI (which you can read about in the [FFI
-Guide](guide-ffi.html)), but can't guarantee that the C code will be safe.
-Therefore, Rust marks such functions with the `unsafe`
+Rust has support for FFI, (which you can read about in the [FFI
+Guide](guide-ffi.html)) but Rust can't guarantee that the C code will be safe,
+like Rust's will. Therefore, Rust marks such functions with the `unsafe`
 keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust

branches/auto/src/doc/rust.md

@@ -891,8 +891,9 @@ There are several kinds of view item:
 ##### Extern crate declarations
 
 ~~~~ {.ebnf .gram}
-extern_crate_decl : "extern" "crate" crate_name
-crate_name: ident | ( string_lit as ident )
+extern_crate_decl : "extern" "crate" ident [ '(' link_attrs ')' ] ? [ '=' string_lit ] ? ;
+link_attrs : link_attr [ ',' link_attrs ] + ;
+link_attr : ident '=' literal ;
 ~~~~
 
 An _`extern crate` declaration_ specifies a dependency on an external crate.
@@ -912,9 +913,11 @@ Four examples of `extern crate` declarations:
 ~~~~ {.ignore}
 extern crate pcre;
 
-extern crate std; // equivalent to: extern crate std as std;
+extern crate std; // equivalent to: extern crate std = "std";
 
-extern crate "std" as ruststd; // linking to 'std' under another name
+extern crate ruststd = "std"; // linking to 'std' under another name
+
+extern crate foo = "some/where/rust-foo#foo:1.0"; // a full crate ID for external tools
 ~~~~
 
 ##### Use declarations

branches/auto/src/liballoc/heap.rs

@@ -12,7 +12,6 @@
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
 //                and `nonnull`
 
-use core::ptr::RawPtr;
 #[cfg(not(test))] use core::raw;
 #[cfg(not(test))] use util;
 
@@ -70,11 +69,6 @@ pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint,
 /// the value returned by `usable_size` for the requested size.
 #[inline]
 pub unsafe fn deallocate(ptr: *mut u8, size: uint, align: uint) {
-    // FIXME(14395) This is only required for DST ~[T], it should be removed once
-    // we fix that representation to not use null pointers.
-    if ptr.is_null() {
-        return;
-    }
     imp::deallocate(ptr, size, align)
 }
 

branches/auto/src/libcollections/bitv.rs

@@ -2557,7 +2557,7 @@ mod tests {
     }
 
     fn rng() -> rand::IsaacRng {
-        let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let seed = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
         rand::SeedableRng::from_seed(seed)
     }
 

branches/auto/src/libcollections/dlist.rs

@@ -1088,8 +1088,7 @@ mod tests {
         let n = list_from([1i,2,3]);
         spawn(proc() {
             check_links(&n);
-            let a: &[_] = &[&1,&2,&3];
-            assert_eq!(a, n.iter().collect::<Vec<&int>>().as_slice());
+            assert_eq!(&[&1,&2,&3], n.iter().collect::<Vec<&int>>().as_slice());
         });
     }
 

branches/auto/src/libcollections/hash/mod.rs

@@ -346,8 +346,7 @@ mod tests {
         assert_eq!(hasher.hash(&'a'), 97);
 
         assert_eq!(hasher.hash(&("a")), 97 + 0xFF);
-        let cs: &[u8] = &[1u8, 2u8, 3u8];
-        assert_eq!(hasher.hash(& cs), 9);
+        assert_eq!(hasher.hash(& &[1u8, 2u8, 3u8]), 9);
 
         unsafe {
             let ptr: *const int = mem::transmute(5i);

branches/auto/src/libcollections/hash/sip.rs

@@ -495,8 +495,8 @@ mod tests {
         assert!(s != t && t != u);
         assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 
-        let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]);
-        let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]);
+        let v = (&[1u8], &[0u8, 0], &[0u8]);
+        let w = (&[1u8, 0, 0, 0], &[], &[]);
 
         assert!(v != w);
         assert!(hash(&v) != hash(&w));

branches/auto/src/libcollections/ringbuf.rs

@@ -243,8 +243,7 @@ impl<T> RingBuf<T> {
     /// buf.push(5i);
     /// buf.push(3);
     /// buf.push(4);
-    /// let b: &[_] = &[&5, &3, &4];
-    /// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), b);
+    /// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), &[&5, &3, &4]);
     /// ```
     pub fn iter<'a>(&'a self) -> Items<'a, T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
@@ -264,8 +263,7 @@ impl<T> RingBuf<T> {
     /// for num in buf.mut_iter() {
     ///     *num = *num - 2;
     /// }
-    /// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
-    /// assert_eq!(buf.mut_iter().collect::<Vec<&mut int>>().as_slice(), b);
+    /// assert_eq!(buf.mut_iter().collect::<Vec<&mut int>>().as_slice(), &[&mut 3, &mut 1, &mut 2]);
     /// ```
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -867,18 +865,12 @@ mod tests {
         for i in range(0i, 5) {
             d.push_back(i);
         }
-        {
-            let b: &[_] = &[&0,&1,&2,&3,&4];
-            assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), b);
-        }
+        assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), &[&0,&1,&2,&3,&4]);
 
         for i in range(6i, 9) {
             d.push_front(i);
         }
-        {
-            let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
-            assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), b);
-        }
+        assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), &[&8,&7,&6,&0,&1,&2,&3,&4]);
 
         let mut it = d.iter();
         let mut len = d.len();
@@ -898,16 +890,12 @@ mod tests {
         for i in range(0i, 5) {
             d.push_back(i);
         }
-        {
-            let b: &[_] = &[&4,&3,&2,&1,&0];
-            assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), b);
-        }
+        assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0]);
 
         for i in range(6i, 9) {
             d.push_front(i);
         }
-        let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
-        assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), b);
+        assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0,&6,&7,&8]);
     }
 
     #[test]