---

yaml
---
r: 191709
b: refs/heads/tmp
c: f2e3c74
h: refs/heads/master
i:
  191707: 603f67f
v: v3

Author: alexcrichton

[refs]

@@ -34,6 +34,6 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: e98e391337fdbf32607de4889345c13fed9de21b
+refs/heads/tmp: f2e3c7469b56cd744e613a05a1ea73f441f66401
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 4a5101a42f8ea36bdbe14749e672ab78cb971726

branches/tmp/src/compiletest/compiletest.rs

@@ -19,6 +19,7 @@
 #![feature(unboxed_closures)]
 #![feature(std_misc)]
 #![feature(test)]
+#![feature(core)]
 #![feature(path_ext)]
 
 #![deny(warnings)]

branches/tmp/src/compiletest/runtest.rs

@@ -1052,22 +1052,22 @@ fn scan_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
-    let ch = haystack.char_at(*idx);
-    if ch != needle {
+    let range = haystack.char_range_at(*idx);
+    if range.ch != needle {
         return false;
     }
-    *idx += ch.len_utf8();
+    *idx = range.next;
     return true;
 }
 
 fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
     let mut i = *idx;
     while i < haystack.len() {
-        let ch = haystack.char_at(i);
-        if ch < '0' || '9' < ch {
+        let range = haystack.char_range_at(i);
+        if range.ch < '0' || '9' < range.ch {
             break;
         }
-        i += ch.len_utf8();
+        i = range.next;
     }
     if i == *idx {
         return false;
@@ -1083,9 +1083,9 @@ fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
         if haystack_i >= haystack.len() {
             return false;
         }
-        let ch = haystack.char_at(haystack_i);
-        haystack_i += ch.len_utf8();
-        if !scan_char(needle, ch, &mut needle_i) {
+        let range = haystack.char_range_at(haystack_i);
+        haystack_i = range.next;
+        if !scan_char(needle, range.ch, &mut needle_i) {
             return false;
         }
     }

branches/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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/tmp/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)
 }