---

yaml
---
r: 219387
b: refs/heads/snap-stage3
c: c680f08
h: refs/heads/master
i:
  219385: 111bcf4
  219383: f548767
v: v3

Author: frewsxcv

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: c044791d80ea0dc5c4b57b6030a67b69f8510239
-refs/heads/snap-stage3: 2f5683913c9815d9f12494784747f79b0f3b3066
+refs/heads/snap-stage3: c680f0818289dfcf5583a6a46aef0a3e4e7c54d2
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -11,14 +11,13 @@
 #![crate_type = "bin"]
 
 #![feature(box_syntax)]
-#![feature(dynamic_lib)]
-#![feature(libc)]
-#![feature(path_ext)]
+#![feature(collections)]
 #![feature(rustc_private)]
-#![feature(slice_extras)]
-#![feature(str_char)]
+#![feature(std_misc)]
 #![feature(test)]
-#![feature(vec_push_all)]
+#![feature(path_ext)]
+#![feature(str_char)]
+#![feature(libc)]
 
 #![deny(warnings)]
 

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

@@ -944,20 +944,9 @@ fn foo<T>(x: T) where T: Debug {
 ```
 
 When a generic function is referenced, its type is instantiated based on the
-context of the reference. For example, calling the `foo` function here:
-
-```
-use std::fmt::Debug;
-
-fn foo<T>(x: &[T]) where T: Debug {
-    // details elided
-    # ()
-}
-
-foo(&[1, 2]);
-```
-
-will instantiate type parameter `T` with `i32`.
+context of the reference. For example, calling the `iter` function defined
+above on `[1, 2]` will instantiate type parameter `T` with `i32`, and require
+the closure parameter to have type `Fn(i32)`.
 
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary if
@@ -2779,24 +2768,22 @@ meaning of the operators on standard types is given here.
 Like the [arithmetic operators](#arithmetic-operators), bitwise operators are
 syntactic sugar for calls to methods of built-in traits. This means that
 bitwise operators can be overridden for user-defined types. The default
-meaning of the operators on standard types is given here. Bitwise `&`, `|` and
-`^` applied to boolean arguments are equivalent to logical `&&`, `||` and `!=`
-evaluated in non-lazy fashion.
+meaning of the operators on standard types is given here.
 
 * `&`
-  : Bitwise AND.
+  : And.
     Calls the `bitand` method of the `std::ops::BitAnd` trait.
 * `|`
-  : Bitwise inclusive OR.
+  : Inclusive or.
     Calls the `bitor` method of the `std::ops::BitOr` trait.
 * `^`
-  : Bitwise exclusive OR.
+  : Exclusive or.
     Calls the `bitxor` method of the `std::ops::BitXor` trait.
 * `<<`
   : Left shift.
     Calls the `shl` method of the `std::ops::Shl` trait.
 * `>>`
-  : Right shift (arithmetic).
+  : Right shift.
     Calls the `shr` method of the `std::ops::Shr` trait.
 
 #### Lazy boolean operators

branches/snap-stage3/src/liballoc/arc.rs

@@ -134,7 +134,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Arc<U>> for Arc<T> {}
 /// Weak pointers will not keep the data inside of the `Arc` alive, and can be
 /// used to break cycles between `Arc` pointers.
 #[unsafe_no_drop_flag]
-#[unstable(feature = "arc_weak",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 pub struct Weak<T: ?Sized> {
     // FIXME #12808: strange name to try to avoid interfering with
@@ -191,35 +191,23 @@ impl<T: ?Sized> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(arc_weak)]
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
     ///
     /// let weak_five = five.downgrade();
     /// ```
-    #[unstable(feature = "arc_weak",
+    #[unstable(feature = "alloc",
                reason = "Weak pointers may not belong in this module.")]
     pub fn downgrade(&self) -> Weak<T> {
         // See the clone() impl for why this is relaxed
         self.inner().weak.fetch_add(1, Relaxed);
         Weak { _ptr: self._ptr }
     }
+}
 
-    /// Get the number of weak references to this value.
-    #[inline]
-    #[unstable(feature = "arc_counts")]
-    pub fn weak_count(this: &Arc<T>) -> usize {
-        this.inner().weak.load(SeqCst) - 1
-    }
-
-    /// Get the number of strong references to this value.
-    #[inline]
-    #[unstable(feature = "arc_counts")]
-    pub fn strong_count(this: &Arc<T>) -> usize {
-        this.inner().strong.load(SeqCst)
-    }
-
+impl<T: ?Sized> Arc<T> {
     #[inline]
     fn inner(&self) -> &ArcInner<T> {
         // This unsafety is ok because while this arc is alive we're guaranteed
@@ -248,15 +236,13 @@ impl<T: ?Sized> Arc<T> {
 
 /// Get the number of weak references to this value.
 #[inline]
-#[unstable(feature = "arc_counts")]
-#[deprecated(since = "1.2.0", reason = "renamed to Arc::weak_count")]
-pub fn weak_count<T: ?Sized>(this: &Arc<T>) -> usize { Arc::weak_count(this) }
+#[unstable(feature = "alloc")]
+pub fn weak_count<T: ?Sized>(this: &Arc<T>) -> usize { this.inner().weak.load(SeqCst) - 1 }
 
 /// Get the number of strong references to this value.
 #[inline]
-#[unstable(feature = "arc_counts")]
-#[deprecated(since = "1.2.0", reason = "renamed to Arc::strong_count")]
-pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { Arc::strong_count(this) }
+#[unstable(feature = "alloc")]
+pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { this.inner().strong.load(SeqCst) }
 
 
 /// Returns a mutable reference to the contained value if the `Arc<T>` is unique.
@@ -269,7 +255,7 @@ pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { Arc::strong_count(this)
 /// # Examples
 ///
 /// ```
-/// # #![feature(arc_unique, alloc)]
+/// # #![feature(alloc)]
 /// extern crate alloc;
 /// # fn main() {
 /// use alloc::arc::{Arc, get_mut};
@@ -285,12 +271,10 @@ pub fn strong_count<T: ?Sized>(this: &Arc<T>) -> usize { Arc::strong_count(this)
 /// # }
 /// ```
 #[inline]
-#[unstable(feature = "arc_unique")]
-#[deprecated(since = "1.2.0",
-             reason = "this function is unsafe with weak pointers")]
+#[unstable(feature = "alloc")]
 pub unsafe fn get_mut<T: ?Sized>(this: &mut Arc<T>) -> Option<&mut T> {
     // FIXME(#24880) potential race with upgraded weak pointers here
-    if Arc::strong_count(this) == 1 && Arc::weak_count(this) == 0 {
+    if strong_count(this) == 1 && weak_count(this) == 0 {
         // This unsafety is ok because we're guaranteed that the pointer
         // returned is the *only* pointer that will ever be returned to T. Our
         // reference count is guaranteed to be 1 at this point, and we required
@@ -358,7 +342,7 @@ impl<T: Clone> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(arc_unique)]
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// # unsafe {
@@ -368,9 +352,7 @@ impl<T: Clone> Arc<T> {
     /// # }
     /// ```
     #[inline]
-    #[unstable(feature = "arc_unique")]
-    #[deprecated(since = "1.2.0",
-                 reason = "this function is unsafe with weak pointers")]
+    #[unstable(feature = "alloc")]
     pub unsafe fn make_unique(&mut self) -> &mut T {
         // FIXME(#24880) potential race with upgraded weak pointers here
         //
@@ -456,7 +438,7 @@ impl<T: ?Sized> Drop for Arc<T> {
     }
 }
 
-#[unstable(feature = "arc_weak",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T: ?Sized> Weak<T> {
     /// Upgrades a weak reference to a strong reference.
@@ -469,7 +451,7 @@ impl<T: ?Sized> Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(arc_weak)]
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
@@ -497,7 +479,7 @@ impl<T: ?Sized> Weak<T> {
     }
 }
 
-#[unstable(feature = "arc_weak",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T: ?Sized> Clone for Weak<T> {
     /// Makes a clone of the `Weak<T>`.
@@ -507,7 +489,7 @@ impl<T: ?Sized> Clone for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(arc_weak)]
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// let weak_five = Arc::new(5).downgrade();
@@ -531,7 +513,7 @@ impl<T: ?Sized> Drop for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(arc_weak)]
+    /// # #![feature(alloc)]
     /// use std::sync::Arc;
     ///
     /// {

branches/snap-stage3/src/liballoc/boxed.rs

@@ -10,9 +10,9 @@
 
 //! A pointer type for heap allocation.
 //!
-//! `Box<T>`, casually referred to as a 'box', provides the simplest form of
-//! heap allocation in Rust. Boxes provide ownership for this allocation, and
-//! drop their contents when they go out of scope.
+//! `Box<T>`, casually referred to as a 'box', provides the simplest form of heap allocation in
+//! Rust. Boxes provide ownership for this allocation, and drop their contents when they go out of
+//! scope.
 //!
 //! # Examples
 //!
@@ -39,17 +39,15 @@
 //!
 //! This will print `Cons(1, Cons(2, Nil))`.
 //!
-//! Recursive structures must be boxed, because if the definition of `Cons`
-//! looked like this:
+//! Recursive structures must be boxed, because if the definition of `Cons` looked like this:
 //!
 //! ```rust,ignore
 //! Cons(T, List<T>),
 //! ```
 //!
-//! It wouldn't work. This is because the size of a `List` depends on how many
-//! elements are in the list, and so we don't know how much memory to allocate
-//! for a `Cons`. By introducing a `Box`, which has a defined size, we know how
-//! big `Cons` needs to be.
+//! It wouldn't work. This is because the size of a `List` depends on how many elements are in the
+//! list, and so we don't know how much memory to allocate for a `Cons`. By introducing a `Box`,
+//! which has a defined size, we know how big `Cons` needs to be.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -71,7 +69,7 @@ use core::raw::{TraitObject};
 /// The following two examples are equivalent:
 ///
 /// ```
-/// # #![feature(box_heap)]
+/// # #![feature(alloc)]
 /// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
@@ -81,7 +79,7 @@ use core::raw::{TraitObject};
 /// }
 /// ```
 #[lang = "exchange_heap"]
-#[unstable(feature = "box_heap",
+#[unstable(feature = "alloc",
            reason = "may be renamed; uncertain about custom allocator design")]
 pub const HEAP: () = ();
 
@@ -121,37 +119,12 @@ impl<T : ?Sized> Box<T> {
     /// Function is unsafe, because improper use of this function may
     /// lead to memory problems like double-free, for example if the
     /// function is called twice on the same raw pointer.
-    #[unstable(feature = "box_raw",
+    #[unstable(feature = "alloc",
                reason = "may be renamed or moved out of Box scope")]
     #[inline]
-    // NB: may want to be called from_ptr, see comments on CStr::from_ptr
     pub unsafe fn from_raw(raw: *mut T) -> Self {
         mem::transmute(raw)
     }
-
-    /// Consumes the `Box`, returning the wrapped raw pointer.
-    ///
-    /// After call to this function, caller is responsible for the memory
-    /// previously managed by `Box`, in particular caller should properly
-    /// destroy `T` and release memory. The proper way to do it is to
-    /// convert pointer back to `Box` with `Box::from_raw` function, because
-    /// `Box` does not specify, how memory is allocated.
-    ///
-    /// # Examples
-    /// ```
-    /// # #![feature(box_raw)]
-    /// use std::boxed;
-    ///
-    /// let seventeen = Box::new(17u32);
-    /// let raw = boxed::into_raw(seventeen);
-    /// let boxed_again = unsafe { Box::from_raw(raw) };
-    /// ```
-    #[unstable(feature = "box_raw", reason = "may be renamed")]
-    #[inline]
-    // NB: may want to be called into_ptr, see comments on CStr::from_ptr
-    pub fn into_raw(b: Box<T>) -> *mut T {
-        unsafe { mem::transmute(b) }
-    }
 }
 
 /// Consumes the `Box`, returning the wrapped raw pointer.
@@ -164,18 +137,18 @@ impl<T : ?Sized> Box<T> {
 ///
 /// # Examples
 /// ```
-/// # #![feature(box_raw)]
+/// # #![feature(alloc)]
 /// use std::boxed;
 ///
 /// let seventeen = Box::new(17u32);
 /// let raw = boxed::into_raw(seventeen);
 /// let boxed_again = unsafe { Box::from_raw(raw) };
 /// ```
-#[unstable(feature = "box_raw", reason = "may be renamed")]
-#[deprecated(since = "1.2.0", reason = "renamed to Box::into_raw")]
+#[unstable(feature = "alloc",
+           reason = "may be renamed")]
 #[inline]
 pub fn into_raw<T : ?Sized>(b: Box<T>) -> *mut T {
-    Box::into_raw(b)
+    unsafe { mem::transmute(b) }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -208,7 +181,7 @@ impl<T: Clone> Clone for Box<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(box_raw)]
+    /// # #![feature(alloc, core)]
     /// let x = Box::new(5);
     /// let mut y = Box::new(10);
     ///
@@ -269,7 +242,7 @@ impl Box<Any> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
-                let raw = Box::into_raw(self);
+                let raw = into_raw(self);
                 let to: TraitObject =
                     mem::transmute::<*mut Any, TraitObject>(raw);
 
@@ -361,7 +334,7 @@ impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
 /// -> i32>`.
 ///
 /// ```
-/// #![feature(fnbox)]
+/// #![feature(core)]
 ///
 /// use std::boxed::FnBox;
 /// use std::collections::HashMap;
@@ -382,7 +355,7 @@ impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
 /// }
 /// ```
 #[rustc_paren_sugar]
-#[unstable(feature = "fnbox", reason = "Newly introduced")]
+#[unstable(feature = "core", reason = "Newly introduced")]
 pub trait FnBox<A> {
     type Output;