---

yaml
---
r: 191831
b: refs/heads/snap-stage3
c: 7c333e9
h: refs/heads/master
i:
  191829: 5c056b4
  191827: 6febed7
  191823: 9da28bc
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 809a554fca2d0ebc2ba50077016fe282a4064752
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 48df3fb678d0a6a3eb1407410673de7ef8a1ae2f
+refs/heads/snap-stage3: 7c333e99bffd4d93a17b0db3495b30e0a8552b5b
 refs/heads/try: ce76bff75603a754d092456285ff455eb871633d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/src/libarena/lib.rs

@@ -42,9 +42,12 @@ extern crate alloc;
 
 use std::cell::{Cell, RefCell};
 use std::cmp;
+use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
 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};
@@ -183,25 +186,6 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) {
     ((p & !1) as *const TyDesc, p & 1 == 1)
 }
 
-// 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`.
-struct TyDesc {
-    drop_glue: fn(*const i8),
-    size: usize,
-    align: usize
-}
-
-unsafe fn get_tydesc<T>() -> *const TyDesc {
-    use std::raw::TraitObject;
-
-    let ptr = &*(1 as *const T);
-
-    // Can use any trait that is implemented for all types.
-    let obj = mem::transmute::<&marker::MarkerTrait, TraitObject>(ptr);
-    obj.vtable as *const TyDesc
-}
-
 impl<'longer_than_self> Arena<'longer_than_self> {
     fn chunk_size(&self) -> usize {
         self.copy_head.borrow().capacity()

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

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

@@ -35,7 +35,6 @@
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag)]
 #![feature(step_by)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(rand, rustc_private, test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 

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

@@ -8,6 +8,45 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[cfg(stage0)]
+/// Creates a `Vec` containing the arguments.
+///
+/// `vec!` allows `Vec`s to be defined with the same syntax as array expressions.
+/// There are two forms of this macro:
+///
+/// - Create a `Vec` containing a given list of elements:
+///
+/// ```
+/// let v = vec![1, 2, 3];
+/// assert_eq!(v[0], 1);
+/// assert_eq!(v[1], 2);
+/// assert_eq!(v[2], 3);
+/// ```
+///
+/// - Create a `Vec` from a given element and size:
+///
+/// ```
+/// let v = vec![1; 3];
+/// assert_eq!(v, [1, 1, 1]);
+/// ```
+///
+/// Note that unlike array expressions this syntax supports all elements
+/// which implement `Clone` and the number of elements doesn't have to be
+/// a constant.
+#[macro_export]
+#[stable(feature = "rust1", since = "1.0.0")]
+macro_rules! vec {
+    ($elem:expr; $n:expr) => (
+        $crate::vec::from_elem($elem, $n)
+    );
+    ($($x:expr),*) => (
+        <[_] as $crate::slice::SliceExt>::into_vec(
+            $crate::boxed::Box::new([$($x),*]))
+    );
+    ($($x:expr,)*) => (vec![$($x),*])
+}
+
+#[cfg(not(stage0))]
 /// Creates a `Vec` containing the arguments.
 ///
 /// `vec!` allows `Vec`s to be defined with the same syntax as array expressions.
@@ -45,10 +84,11 @@ macro_rules! vec {
     ($($x:expr,)*) => (vec![$($x),*])
 }
 
-// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is
-// required for this macro definition, is not available. Instead use the
-// `slice::into_vec`  function which is only available with cfg(test)
+// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is required for this
+// macro definition, is not available. Instead use the `slice::into_vec`  function which is only
+// available with cfg(test)
 // NB see the slice::hack module in slice.rs for more information
+#[cfg(not(stage0))]
 #[cfg(test)]
 macro_rules! vec {
     ($elem:expr; $n:expr) => (