---

yaml
---
r: 193991
b: refs/heads/beta
c: a7a28d7
h: refs/heads/master
i:
  193989: 67254d2
  193987: 1c4c7f3
  193983: 7599770
v: v3

Author: mbrubeck

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: dbe084b5bffae155b83f9229d04d83e7273bec4f
+refs/heads/beta: a7a28d709170f5dd14439c83d115e16a11c53c06
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/Makefile.in

@@ -97,7 +97,7 @@
 #     make check-stage1-rpass TESTNAME=my-shiny-new-test
 #
 #     // Having trouble figuring out which test is failing? Turn off parallel tests
-#     make check-stage1-std RUST_TEST_THREADS=1
+#     make check-stage1-std RUST_TEST_TASKS=1
 #
 # This is hardly all there is to know of The Rust Build System's
 # mysteries. The tale continues on the wiki[1].

branches/beta/src/compiletest/compiletest.rs

@@ -19,6 +19,7 @@
 #![feature(unboxed_closures)]
 #![feature(std_misc)]
 #![feature(test)]
+#![feature(core)]
 #![feature(path_ext)]
 
 #![deny(warnings)]
@@ -224,15 +225,15 @@ pub fn run_tests(config: &Config) {
         // android debug-info test uses remote debugger
         // so, we test 1 task at once.
         // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        env::set_var("RUST_TEST_THREADS","1");
+        env::set_var("RUST_TEST_TASKS","1");
     }
 
     match config.mode {
         DebugInfoLldb => {
             // Some older versions of LLDB seem to have problems with multiple
             // instances running in parallel, so only run one test task at a
             // time.
-            env::set_var("RUST_TEST_THREADS", "1");
+            env::set_var("RUST_TEST_TASKS", "1");
         }
         _ => { /* proceed */ }
     }

branches/beta/src/compiletest/header.rs

@@ -131,7 +131,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         true
     });
 
-    for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
+    for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_TASKS"] {
         match env::var(key) {
             Ok(val) =>
                 if exec_env.iter().find(|&&(ref x, _)| *x == key.to_string()).is_none() {

branches/beta/src/doc/reference.md

@@ -2068,7 +2068,7 @@ type int8_t = i8;
   item](#language-items) for more details.
 - `test` - indicates that this function is a test function, to only be compiled
   in case of `--test`.
-- `should_panic` - indicates that this test function should panic, inverting the success condition.
+- `should_fail` - indicates that this test function should panic, inverting the success condition.
 - `cold` - The function is unlikely to be executed, so optimize it (and calls
   to it) differently.
 

branches/beta/src/doc/trpl/crates-and-modules.md

@@ -562,11 +562,6 @@ place in the hierarchy instead. There's one more special form of `use`: you can
 people like to think of `self` as `.` and `super` as `..`, from many shells'
 display for the current directory and the parent directory.
 
-Outside of `use`, paths are relative: `foo::bar()` refers to a function inside
-of `foo` relative to where we are. If that's prefixed with `::`, as in
-`::foo::bar()`, it refers to a different `foo`, an absolute path from your
-crate root.
-
 Also, note that we `pub use`d before we declared our `mod`s. Rust requires that
 `use` declarations go first.
 

branches/beta/src/doc/trpl/functions.md

@@ -179,7 +179,7 @@ Because this function will cause a crash, it will never return, and so it has
 the type '`!`', which is read "diverges." A diverging function can be used
 as any type:
 
-```should_panic
+```should_fail
 # fn diverges() -> ! {
 #    panic!("This function never returns!");
 # }

branches/beta/src/doc/trpl/pointers.md

@@ -561,40 +561,38 @@ fn main() {
 In this case, Rust knows that `x` is being *borrowed* by the `add_one()`
 function, and since it's only reading the value, allows it.
 
-We can borrow `x` as read-only multiple times, even simultaneously:
+We can borrow `x` multiple times, as long as it's not simultaneous:
 
 ```{rust}
-fn add(x: &i32, y: &i32) -> i32 {
-    *x + *y
+fn add_one(x: &i32) -> i32 {
+    *x + 1
 }
 
 fn main() {
     let x = Box::new(5);
 
-    println!("{}", add(&x, &x));
-    println!("{}", add(&x, &x));
+    println!("{}", add_one(&*x));
+    println!("{}", add_one(&*x));
+    println!("{}", add_one(&*x));
 }
 ```
 
-We can mutably borrow `x` multiple times, but only if x itself is mutable, and
-it may not be *simultaneously* borrowed: 
+Or as long as it's not a mutable borrow. This will error:
 
 ```{rust,ignore}
-fn increment(x: &mut i32) {
-    *x += 1;
+fn add_one(x: &mut i32) -> i32 {
+    *x + 1
 }
 
 fn main() {
-    // If variable x is not "mut", this will not compile
-    let mut x = Box::new(5);
+    let x = Box::new(5);
 
-    increment(&mut x);
-    increment(&mut x);
-    println!("{}", x);
+    println!("{}", add_one(&*x)); // error: cannot borrow immutable dereference
+                                  // of `&`-pointer as mutable
 }
 ```
 
-Notice the signature of `increment()` requests a mutable reference.
+Notice we changed the signature of `add_one()` to request a mutable reference.
 
 ## Best practices
 

branches/beta/src/doc/trpl/testing.md

@@ -129,11 +129,11 @@ $ echo $?
 
 This is useful if you want to integrate `cargo test` into other tooling.
 
-We can invert our test's failure with another attribute: `should_panic`:
+We can invert our test's failure with another attribute: `should_fail`:
 
 ```rust
 #[test]
-#[should_panic]
+#[should_fail]
 fn it_works() {
     assert!(false);
 }
@@ -163,13 +163,13 @@ equality:
 
 ```rust
 #[test]
-#[should_panic]
+#[should_fail]
 fn it_works() {
     assert_eq!("Hello", "world");
 }
 ```
 
-Does this test pass or fail? Because of the `should_panic` attribute, it
+Does this test pass or fail? Because of the `should_fail` attribute, it
 passes:
 
 ```bash
@@ -189,15 +189,15 @@ running 0 tests
 test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
 ```
 
-`should_panic` tests can be fragile, as it's hard to guarantee that the test
+`should_fail` tests can be fragile, as it's hard to guarantee that the test
 didn't fail for an unexpected reason. To help with this, an optional `expected`
-parameter can be added to the `should_panic` attribute. The test harness will
+parameter can be added to the `should_fail` attribute. The test harness will
 make sure that the failure message contains the provided text. A safer version
 of the example above would be:
 
 ```
 #[test]
-#[should_panic(expected = "assertion failed")]
+#[should_fail(expected = "assertion failed")]
 fn it_works() {
     assert_eq!("Hello", "world");
 }

branches/beta/src/doc/trpl/unsafe.md

@@ -93,6 +93,10 @@ offered by the Rust language and libraries. For example, they
 - are plain-old-data, that is, they don't move ownership, again unlike
   `Box`, hence the Rust compiler cannot protect against bugs like
   use-after-free;
+- are considered sendable (if their contents is considered sendable),
+  so the compiler offers no assistance with ensuring their use is
+  thread-safe; for example, one can concurrently access a `*mut i32`
+  from two threads without synchronization.
 - lack any form of lifetimes, unlike `&`, and so the compiler cannot
   reason about dangling pointers; and
 - have no guarantees about aliasing or mutability other than mutation

branches/beta/src/liballoc/arc.rs

@@ -210,21 +210,6 @@ impl<T> Arc<T> {
         // contents.
         unsafe { &**self._ptr }
     }
-
-    // Non-inlined part of `drop`.
-    #[inline(never)]
-    unsafe fn drop_slow(&mut self) {
-        let ptr = *self._ptr;
-
-        // Destroy the data at this time, even though we may not free the box allocation itself
-        // (there may still be weak pointers lying around).
-        drop(ptr::read(&self.inner().data));
-
-        if self.inner().weak.fetch_sub(1, Release) == 1 {
-            atomic::fence(Acquire);
-            deallocate(ptr as *mut u8, size_of::<ArcInner<T>>(), min_align_of::<ArcInner<T>>())
-        }
-    }
 }
 
 /// Get the number of weak references to this value.
@@ -340,7 +325,6 @@ impl<T: Sync + Send> Drop for Arc<T> {
     ///
     /// } // implicit drop
     /// ```
-    #[inline]
     fn drop(&mut self) {
         // This structure has #[unsafe_no_drop_flag], so this drop glue may run more than once (but
         // it is guaranteed to be zeroed after the first if it's run more than once)
@@ -369,8 +353,14 @@ impl<T: Sync + Send> Drop for Arc<T> {
         // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)
         atomic::fence(Acquire);
 
-        unsafe {
-            self.drop_slow()
+        // Destroy the data at this time, even though we may not free the box allocation itself
+        // (there may still be weak pointers lying around).
+        unsafe { drop(ptr::read(&self.inner().data)); }
+
+        if self.inner().weak.fetch_sub(1, Release) == 1 {
+            atomic::fence(Acquire);
+            unsafe { deallocate(ptr as *mut u8, size_of::<ArcInner<T>>(),
+                                min_align_of::<ArcInner<T>>()) }
         }
     }
 }

branches/beta/src/liballoc/boxed.rs

@@ -264,6 +264,7 @@ impl BoxAny for Box<Any> {
     }
 }
 
+#[cfg(not(stage0))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl BoxAny for Box<Any+Send> {
     #[inline]

branches/beta/src/liballoc/heap.rs

@@ -8,6 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(stage0)]
+#[cfg(not(test))]
+use core::ptr::PtrExt;
+
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
 
 /// Return a pointer to `size` bytes of memory aligned to `align`.

branches/beta/src/liballoc/rc.rs

@@ -159,6 +159,9 @@ use core::nonzero::NonZero;
 use core::ops::{Deref, Drop};
 use core::option::Option;
 use core::option::Option::{Some, None};
+#[cfg(stage0)]
+use core::ptr::{self, PtrExt};
+#[cfg(not(stage0))]
 use core::ptr;
 use core::result::Result;
 use core::result::Result::{Ok, Err};

branches/beta/src/libarena/lib.rs

@@ -43,8 +43,12 @@ extern crate alloc;
 use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics;
+#[cfg(stage0)] // SNAP 270a677
+use std::intrinsics::{get_tydesc, TyDesc};
 use std::marker;
 use std::mem;
+#[cfg(stage0)]
+use std::num::{Int, UnsignedInt};
 use std::ptr;
 use std::rc::Rc;
 use std::rt::heap::{allocate, deallocate};
@@ -186,12 +190,14 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) {
 // HACK(eddyb) TyDesc replacement using a trait object vtable.
 // This could be replaced in the future with a custom DST layout,
 // or `&'static (drop_glue, size, align)` created by a `const fn`.
+#[cfg(not(stage0))] // SNAP 270a677
 struct TyDesc {
     drop_glue: fn(*const i8),
     size: usize,
     align: usize
 }
 
+#[cfg(not(stage0))] // SNAP 270a677
 unsafe fn get_tydesc<T>() -> *const TyDesc {
     use std::raw::TraitObject;
 

branches/beta/src/libcollections/btree/node.rs

@@ -105,6 +105,9 @@ struct MutNodeSlice<'a, K: 'a, V: 'a> {
 /// Fails if `target_alignment` is not a power of two.
 #[inline]
 fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
+    #[cfg(stage0)]
+    use core::num::UnsignedInt;
+
     assert!(target_alignment.is_power_of_two());
     (unrounded + target_alignment - 1) & !(target_alignment - 1)
 }