---

yaml
---
r: 190423
b: refs/heads/snap-stage3
c: e2605b4
h: refs/heads/master
i:
  190421: 31c2f25
  190419: aa9fe8a
  190415: 502dfb2
v: v3

Author: sfackler

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 857ac28867722111249b5c3ef68e32499bd11ea0
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 777f5d959930711acc321a50c493b984b780f156
+refs/heads/snap-stage3: e2605b42c7ce37717118fe240f7d0e8c4eae3598
 refs/heads/try: 1c28ab65017d74fc13d003f7c7a73d1a48e5406f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/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.

branches/snap-stage3/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_fail: test::ShouldFail::No,
+            should_panic: test::ShouldPanic::No,
         },
         testfn: f(),
     }

branches/snap-stage3/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();
 }
 ```

branches/snap-stage3/src/doc/reference.md

@@ -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:
 
 ```

branches/snap-stage3/src/libarena/lib.rs

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

branches/snap-stage3/src/libcollections/enum_set.rs

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

branches/snap-stage3/src/libcollections/slice.rs

@@ -1647,14 +1647,14 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_tail_empty() {
         let a = Vec::<i32>::new();
         a.tail();
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_tail_mut_empty() {
         let mut a = Vec::<i32>::new();
         a.tail_mut();
@@ -1681,14 +1681,14 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_init_empty() {
         let a = Vec::<i32>::new();
         a.init();
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_init_mut_empty() {
         let mut a = Vec::<i32>::new();
         a.init_mut();
@@ -1790,7 +1790,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_swap_remove_fail() {
         let mut v = vec![1];
         let _ = v.swap_remove(0);
@@ -2205,7 +2205,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_insert_oob() {
         let mut a = vec![1, 2, 3];
         a.insert(4, 5);
@@ -2229,7 +2229,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_remove_fail() {
         let mut a = vec![1];
         let _ = a.remove(0);
@@ -2253,7 +2253,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_permute_fail() {
         let v: [(Box<_>, Rc<_>); 4] =
             [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
@@ -2528,7 +2528,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_windowsator_0() {
         let v = &[1,2,3,4];
         let _it = v.windows(0);
@@ -2564,7 +2564,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_chunksator_0() {
         let v = &[1,2,3,4];
         let _it = v.chunks(0);
@@ -2647,7 +2647,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_overflow_does_not_cause_segfault() {
         let mut v = vec![];
         v.reserve_exact(-1);
@@ -2656,7 +2656,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_overflow_does_not_cause_segfault_managed() {
         let mut v = vec![Rc::new(1)];
         v.reserve_exact(-1);
@@ -2833,7 +2833,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_mut_chunks_0() {
         let mut v = [1, 2, 3, 4];
         let _it = v.chunks_mut(0);

branches/snap-stage3/src/libcollections/str.rs

@@ -1877,7 +1877,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_slice_fail() {
         "中华Việt Nam".slice(0, 2);
     }
@@ -2095,7 +2095,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_as_bytes_fail() {
         // Don't double free. (I'm not sure if this exercises the
         // original problem code path anymore.)
@@ -2132,7 +2132,7 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_subslice_offset_2() {
         let a = "alchemiter";
         let b = "cruxtruder";

branches/snap-stage3/src/libcollections/string.rs

@@ -1232,14 +1232,14 @@ mod tests {
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_str_truncate_invalid_len() {
         let mut s = String::from_str("12345");
         s.truncate(6);
     }
 
     #[test]
-    #[should_fail]
+    #[should_panic]
     fn test_str_truncate_split_codepoint() {
         let mut s = String::from_str("\u{FC}"); // ü
         s.truncate(1);
@@ -1272,7 +1272,7 @@ mod tests {
         assert_eq!(s, "ไทย中华Vit Nam; foobar");
     }
 
-    #[test] #[should_fail]
+    #[test] #[should_panic]
     fn remove_bad() {
         "ศ".to_string().remove(1);
     }
@@ -1286,8 +1286,8 @@ mod tests {
         assert_eq!(s, "ệfooยbar");
     }
 
-    #[test] #[should_fail] fn insert_bad1() { "".to_string().insert(1, 't'); }
-    #[test] #[should_fail] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
+    #[test] #[should_panic] fn insert_bad1() { "".to_string().insert(1, 't'); }
+    #[test] #[should_panic] fn insert_bad2() { "ệ".to_string().insert(1, 't'); }
 
     #[test]
     fn test_slicing() {