---

yaml
---
r: 189407
b: refs/heads/master
c: a600899
h: refs/heads/master
i:
  189405: c0ce6cf
  189403: e987367
  189399: 563c5e9
  189391: 802bb53
  189375: 7df3910
v: v3

Author: steveklabnik

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 12b846ab80ca054d2fbfb0320d33badbd5ef0112
+refs/heads/master: a60089903a54682a96646f13ee6e8b8a406621be
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 270a677d4d698916f5ad103f0afc3c070b8dbeb4
 refs/heads/try: 649d35e4d830b27806705dc5352c86ab6d6fd1a1

trunk/README.md

@@ -115,7 +115,7 @@ The Rust community congregates in a few places:
 
 ## Contributing
 
-To contribute to Rust, please see [CONTRIBUTING](CONTRIBUTING.md).
+To contribute to Rust, please see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
@@ -131,4 +131,4 @@ Rust is primarily distributed under the terms of both the MIT license
 and the Apache License (Version 2.0), with portions covered by various
 BSD-like licenses.
 
-See [LICENSE-APACHE](LICENSE-APACHE), [LICENSE-MIT](LICENSE-MIT), and [COPYRIGHT](COPYRIGHT) for details.
+See LICENSE-APACHE, LICENSE-MIT, and COPYRIGHT for details.

trunk/src/compiletest/compiletest.rs

@@ -332,7 +332,7 @@ pub fn make_test<F>(config: &Config, testfile: &Path, f: F) -> test::TestDescAnd
         desc: test::TestDesc {
             name: make_test_name(config, testfile),
             ignore: header::is_test_ignored(config, testfile),
-            should_panic: test::ShouldPanic::No,
+            should_fail: test::ShouldFail::No,
         },
         testfn: f(),
     }

trunk/src/doc/complement-design-faq.md

@@ -174,3 +174,10 @@ bindings.
 See also [a long thread][alt] on renaming `let mut` to `var`.
 
 [alt]: https://mail.mozilla.org/pipermail/rust-dev/2014-January/008319.html
+
+## Why no `--x` or `x++`?
+
+Preincrement and postincrement, while convenient, are also fairly complex. They
+require knowledge of evaluation order, and often lead to subtle bugs and
+undefined behavior in C and C++. `x = x + 1` or `x += 1` is only slightly
+longer, but unambiguous.

trunk/src/doc/grammar.md

@@ -514,7 +514,7 @@ field_expr : expr '.' ident ;
 ### Array expressions
 
 ```antlr
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ```

trunk/src/doc/intro.md

@@ -389,11 +389,11 @@ safe concurrent programs.
 Here's an example of a concurrent Rust program:
 
 ```{rust}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let guards: Vec<_> = (0..10).map(|_| {
-        thread::scoped(|| {
+        Thread::scoped(|| {
             println!("Hello, world!");
         })
     }).collect();
@@ -421,16 +421,16 @@ problem.
 Let's see an example. This Rust code will not compile:
 
 ```{rust,ignore}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let mut numbers = vec![1, 2, 3];
 
     let guards: Vec<_> = (0..3).map(|i| {
-        thread::scoped(move || {
+        Thread::scoped(move || {
             numbers[i] += 1;
             println!("numbers[{}] is {}", i, numbers[i]);
-        })
+        });
     }).collect();
 }
 ```
@@ -439,10 +439,10 @@ It gives us this error:
 
 ```text
 7:25: 10:6 error: cannot move out of captured outer variable in an `FnMut` closure
-7     thread::scoped(move || {
+7     Thread::scoped(move || {
 8       numbers[i] += 1;
 9       println!("numbers[{}] is {}", i, numbers[i]);
-10     })
+10     });
 error: aborting due to previous error
 ```
 
@@ -471,19 +471,19 @@ mutation doesn't cause a data race.
 Here's what using an Arc with a Mutex looks like:
 
 ```{rust}
-use std::thread;
+use std::thread::Thread;
 use std::sync::{Arc,Mutex};
 
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
 
     let guards: Vec<_> = (0..3).map(|i| {
         let number = numbers.clone();
-        thread::scoped(move || {
+        Thread::scoped(move || {
             let mut array = number.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
-        })
+        });
     }).collect();
 }
 ```
@@ -535,15 +535,15 @@ As an example, Rust's ownership system is _entirely_ at compile time. The
 safety check that makes this an error about moved values:
 
 ```{rust,ignore}
-use std::thread;
+use std::thread::Thread;
 
 fn main() {
     let numbers = vec![1, 2, 3];
 
     let guards: Vec<_> = (0..3).map(|i| {
-        thread::scoped(move || {
+        Thread::scoped(move || {
             println!("{}", numbers[i]);
-        })
+        });
     }).collect();
 }
 ```

trunk/src/doc/reference.md

@@ -2847,7 +2847,7 @@ automatically dereferenced to make the field access possible.
 ### Array expressions
 
 ```{.ebnf .gram}
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ';' expr] ;
 ```
@@ -3007,6 +3007,10 @@ A type cast expression is denoted with the binary operator `as`.
 Executing an `as` expression casts the value on the left-hand side to the type
 on the right-hand side.
 
+A numeric value can be cast to any numeric type. A raw pointer value can be
+cast to or from any integral type or raw pointer type. Any other cast is
+unsupported and will fail to compile.
+
 An example of an `as` expression:
 
 ```

trunk/src/doc/style/errors/ergonomics.md

@@ -22,9 +22,9 @@ fn write_info(info: &Info) -> Result<(), IoError> {
     let mut file = File::open_mode(&Path::new("my_best_friends.txt"),
                                    Open, Write);
     // Early return on error
-    try!(file.write_line(&format!("name: {}", info.name)));
-    try!(file.write_line(&format!("age: {}", info.age)));
-    try!(file.write_line(&format!("rating: {}", info.rating)));
+    try!(file.write_line(format!("name: {}", info.name).as_slice()));
+    try!(file.write_line(format!("age: {}", info.age).as_slice()));
+    try!(file.write_line(format!("rating: {}", info.rating).as_slice()));
     return Ok(());
 }
 ```
@@ -44,15 +44,15 @@ fn write_info(info: &Info) -> Result<(), IoError> {
     let mut file = File::open_mode(&Path::new("my_best_friends.txt"),
                                    Open, Write);
     // Early return on error
-    match file.write_line(&format!("name: {}", info.name)) {
+    match file.write_line(format!("name: {}", info.name).as_slice()) {
         Ok(_) => (),
         Err(e) => return Err(e)
     }
-    match file.write_line(&format!("age: {}", info.age)) {
+    match file.write_line(format!("age: {}", info.age).as_slice()) {
         Ok(_) => (),
         Err(e) => return Err(e)
     }
-    return file.write_line(&format!("rating: {}", info.rating));
+    return file.write_line(format!("rating: {}", info.rating).as_slice());
 }
 ```
 

trunk/src/doc/trpl/SUMMARY.md

@@ -16,11 +16,11 @@
     * [Standard Input](standard-input.md)
     * [Guessing Game](guessing-game.md)
 * [II: Intermediate Rust](intermediate.md)
+    * [More Strings](more-strings.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)
     * [Pointers](pointers.md)
     * [Ownership](ownership.md)
-    * [More Strings](more-strings.md)
     * [Patterns](patterns.md)
     * [Method Syntax](method-syntax.md)
     * [Closures](closures.md)

trunk/src/doc/trpl/concurrency.md

@@ -223,8 +223,15 @@ method which has this signature:
 fn lock(&self) -> LockResult<MutexGuard<T>>
 ```
 
-Because `Send` is not implemented for `MutexGuard<T>`, we can't transfer the
-guard across thread boundaries, which gives us our error.
+If we [look at the code for MutexGuard](https://github.com/rust-lang/rust/blob/ca4b9674c26c1de07a2042cb68e6a062d7184cef/src/libstd/sync/mutex.rs#L172), we'll see
+this:
+
+```ignore
+__marker: marker::NoSend,
+```
+
+Because our guard is `NoSend`, it's not `Send`. Which means we can't actually
+transfer the guard across thread boundaries, which gives us our error.
 
 We can use `Arc<T>` to fix this. Here's the working version:
 

trunk/src/doc/trpl/method-syntax.md

@@ -50,29 +50,7 @@ You can think of this first parameter as being the `x` in `x.foo()`. The three
 variants correspond to the three kinds of thing `x` could be: `self` if it's
 just a value on the stack, `&self` if it's a reference, and `&mut self` if it's
 a mutable reference. We should default to using `&self`, as it's the most
-common. Here's an example of all three variants:
-
-```rust
-struct Circle {
-    x: f64,
-    y: f64,
-    radius: f64,
-}
-
-impl Circle {
-    fn reference(&self) {
-       println!("taking self by reference!"); 
-    }
-
-    fn mutable_reference(&mut self) {
-       println!("taking self by mutable reference!"); 
-    }
-
-    fn takes_ownership(self) {
-       println!("taking ownership of self!"); 
-    }
-}
-```
+common.
 
 Finally, as you may remember, the value of the area of a circle is `π*r²`.
 Because we took the `&self` parameter to `area`, we can use it just like any

trunk/src/doc/trpl/more-strings.md

@@ -278,18 +278,7 @@ This will print:
 
 Many more bytes than graphemes!
 
-# `Deref` coercions
+# Other Documentation
 
-References to `String`s will automatically coerce into `&str`s. Like this:
-
-```
-fn hello(s: &str) {
-   println!("Hello, {}!", s);
-}
-
-let slice = "Steve";
-let string = "Steve".to_string();
-
-hello(slice);
-hello(&string);
-```
+* [the `&str` API documentation](../std/str/index.html)
+* [the `String` API documentation](../std/string/index.html)

trunk/src/doc/trpl/plugins.md

@@ -63,7 +63,7 @@ that implements Roman numeral integer literals.
 
 ```ignore
 #![crate_type="dylib"]
-#![feature(plugin_registrar, rustc_private)]
+#![feature(plugin_registrar)]
 
 extern crate syntax;
 extern crate rustc;
@@ -92,13 +92,13 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     };
 
-    let mut text = &*text;
+    let mut text = &text;
     let mut total = 0;
     while !text.is_empty() {
         match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {
             Some(&(rn, val)) => {
                 total += val;
-                text = &text[rn.len()..];
+                text = text.slice_from(rn.len());
             }
             None => {
                 cx.span_err(sp, "invalid Roman numeral");
@@ -107,7 +107,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     }
 
-    MacEager::expr(cx.expr_u32(sp, total))
+    MacEager::expr(cx.expr_usize(sp, total))
 }
 
 #[plugin_registrar]

trunk/src/doc/trpl/pointers.md

@@ -634,8 +634,8 @@ use-case for boxes.
 ### Returning data
 
 This is important enough to have its own section entirely. The TL;DR is this:
-you don't want to return pointers, even when you might in a language like C or
-C++.
+you don't generally want to return pointers, even when you might in a language
+like C or C++.
 
 See [Returning Pointers](#returning-pointers) below for more.
 

trunk/src/doc/trpl/traits.md

@@ -435,46 +435,3 @@ println!("the inverse of {} is {:?}", 2.0f64, inverse(2.0f64));
 println!("the inverse of {} is {:?}", 0.0f32, inverse(0.0f32));
 println!("the inverse of {} is {:?}", 0.0f64, inverse(0.0f64));
 ```
-
-## Default methods
-
-There's one last feature of traits we should cover: default methods. It's
-easiest just to show an example:
-
-```rust
-trait Foo {
-    fn bar(&self);
-
-    fn baz(&self) { println!("We called baz."); }
-}
-```
-
-Implementors of the `Foo` trait need to implement `bar()`, but they don't
-need to implement `baz()`. They'll get this default behavior. They can
-override the default if they so choose:
-
-```rust
-# trait Foo {
-# fn bar(&self);
-# fn baz(&self) { println!("We called baz."); }
-# }
-struct UseDefault;
-
-impl Foo for UseDefault {
-    fn bar(&self) { println!("We called bar."); }
-}
-
-struct OverrideDefault;
-
-impl Foo for OverrideDefault {
-    fn bar(&self) { println!("We called bar."); }
-
-    fn baz(&self) { println!("Override baz!"); }
-}
-
-let default = UseDefault;
-default.baz(); // prints "We called bar."
-
-let over = OverrideDefault;
-over.baz(); // prints "Override baz!"
-```

trunk/src/libarena/lib.rs

@@ -323,7 +323,7 @@ fn test_arena_destructors() {
 }
 
 #[test]
-#[should_panic]
+#[should_fail]
 fn test_arena_destructors_fail() {
     let arena = Arena::new();
     // Put some stuff in the arena.

trunk/src/libcollections/enum_set.rs

@@ -490,7 +490,7 @@ mod test {
     }
 
     #[test]
-    #[should_panic]
+    #[should_fail]
     fn test_overflow() {
         #[allow(dead_code)]
         #[derive(Copy)]

trunk/src/libcollections/fmt.rs

@@ -198,7 +198,7 @@
 //!         // for details, and the function `pad` can be used to pad strings.
 //!         let decimals = f.precision().unwrap_or(3);
 //!         let string = f64::to_str_exact(magnitude, decimals);
-//!         f.pad_integral(true, "", &string)
+//!         f.pad_integral(true, "", string.as_slice())
 //!     }
 //! }
 //!