---

yaml
---
r: 224189
b: refs/heads/beta
c: c80bff0
h: refs/heads/master
i:
  224187: faf5389
v: v3

Author: echochamber

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 3fa90902423717bbb2915317bc9a8bfe9994ec3b
+refs/heads/beta: c80bff0186ab938167a649edb325c9499e594247
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 938f5d7af401e2d8238522fed4a612943b6e77fd
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

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

@@ -340,7 +340,7 @@ libraries:
 Note that frameworks are only available on OSX targets.
 
 The different `kind` values are meant to differentiate how the native library
-participates in linkage. From a linkage perspective, the Rust compiler creates
+participates in linkage. From a linkage perspective, the rust compiler creates
 two flavors of artifacts: partial (rlib/staticlib) and final (dylib/binary).
 Native dynamic library and framework dependencies are propagated to the final
 artifact boundary, while static library dependencies are not propagated at
@@ -350,9 +350,9 @@ artifact.
 A few examples of how this model can be used are:
 
 * A native build dependency. Sometimes some C/C++ glue is needed when writing
-  some Rust code, but distribution of the C/C++ code in a library format is just
+  some rust code, but distribution of the C/C++ code in a library format is just
   a burden. In this case, the code will be archived into `libfoo.a` and then the
-  Rust crate would declare a dependency via `#[link(name = "foo", kind =
+  rust crate would declare a dependency via `#[link(name = "foo", kind =
   "static")]`.
 
   Regardless of the flavor of output for the crate, the native static library
@@ -361,7 +361,7 @@ A few examples of how this model can be used are:
 
 * A normal dynamic dependency. Common system libraries (like `readline`) are
   available on a large number of systems, and often a static copy of these
-  libraries cannot be found. When this dependency is included in a Rust crate,
+  libraries cannot be found. When this dependency is included in a rust crate,
   partial targets (like rlibs) will not link to the library, but when the rlib
   is included in a final target (like a binary), the native library will be
   linked in.

branches/beta/src/doc/trpl/installing-rust.md

@@ -2,7 +2,7 @@
 
 The first step to using Rust is to install it! There are a number of ways to
 install Rust, but the easiest is to use the `rustup` script. If you're on Linux
-or a Mac, all you need to do is this:
+or a Mac, all you need to do is this: 
 
 > Note: you don't need to type in the `$`s, they just indicate the start of
 > each command. You’ll see many tutorials and examples around the web that
@@ -25,12 +25,6 @@ $ sh rustup.sh
 [insecurity]: http://curlpipesh.tumblr.com
 
 If you're on Windows, please download the appropriate [installer][install-page].
-**NOTE:** By default, the Windows installer will not add Rust to the %PATH%
-system variable. If this is the only version of Rust you are installing and you
-want to be able to run it from the command line, click on "Advanced" on the
-install dialog and on the "Product Features" page ensure "Add to PATH" is
-installed on the local hard drive.
-
 
 [install-page]: http://www.rust-lang.org/install.html
 
@@ -93,11 +87,6 @@ rustc 1.0.0 (a59de37e9 2015-05-13)
 
 If you did, Rust has been installed successfully! Congrats!
 
-If you didn't and you're on Windows, check that Rust is in your %PATH% system
-variable. If it isn't, run the installer again, select "Change" on the "Change,
-repair, or remove installation" page and ensure "Add to PATH" is installed on
-the local hard drive.
-
 This installer also installs a copy of the documentation locally, so you can
 read it offline. On UNIX systems, `/usr/local/share/doc/rust` is the location.
 On Windows, it's in a `share/doc` directory, inside wherever you installed Rust
@@ -112,5 +101,5 @@ resources include [the user’s forum][users], and
 
 [irc]: irc://irc.mozilla.org/#rust
 [mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
-[users]: http://users.rust-lang.org/
+[users]: http://users.rust-lang.org/ 
 [stackoverflow]: http://stackoverflow.com/questions/tagged/rust

branches/beta/src/doc/trpl/release-channels.md

@@ -43,26 +43,3 @@ This will help alert the team in case there’s an accidental regression.
 Additionally, testing against nightly can catch regressions even sooner, and so
 if you don’t mind a third build, we’d appreciate testing against all channels.
 
-As an example, many Rust programmers use [Travis](https://travis-ci.org/) to
-test their crates, which is free for open source projects. Travis [supports
-Rust directly][travis], and you can use a `.travis.yml` file like this to
-test on all channels:
-
-```yaml
-language: rust
-rust:
-  - nightly
-  - beta
-  - stable
-
-matrix:
-  allow_failures:
-    - rust: nightly
-```
-
-[travis]: http://docs.travis-ci.com/user/languages/rust/
-
-With this configuration, Travis will test all three channels, but if something
-breaks on nightly, it won’t fail your build. A similar configuration is
-recommended for any CI system, check the documentation of the one you’re
-using for more details.

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

@@ -100,14 +100,10 @@ that you normally can not do. Just three. Here they are:
 
 That’s it. It’s important that `unsafe` does not, for example, ‘turn off the
 borrow checker’. Adding `unsafe` to some random Rust code doesn’t change its
-semantics, it won’t just start accepting anything. But it will let you write
-things that _do_ break some of the rules.
+semantics, it won’t just start accepting anything.
 
-You will also encounter the `unsafe` keyword when writing bindings to foreign
-(non-Rust) interfaces. You're encouraged to write a safe, native Rust interface
-around the methods provided by the library.
-
-Let’s go over the basic three abilities listed, in order.
+But it will let you write things that _do_ break some of the rules. Let’s go
+over these three abilities in order.
 
 ## Access or update a `static mut`
 

branches/beta/src/doc/trpl/while-loops.md

@@ -88,6 +88,24 @@ for x in 0..10 {
 }
 ```
 
+You may also encounter situations where you have nested loops and need to 
+specify which one your `break` or `continue` statement is for. Like most 
+other languages, by default a `break` or `continue` will apply to innermost 
+loop. In a sitation where you would like to a `break` or `continue` for one 
+of the outer loops, you can use labels to specify which loop the `break` or
+ `continue` statement applies to. This will only print when both `x` and `y` are
+ odd:
+
+```rust
+'outer: for x in 0..10 {
+    'inner: for y in 0..10 {
+        if x % 2 == 0 { continue 'outer; } // continues the loop over x
+        if y % 2 == 0 { continue 'inner; } // continues the loop over y
+        println!("x: {}, y: {}", x, y);
+    }
+}
+```
+
 Both `continue` and `break` are valid in both `while` loops and [`for` loops][for].
 
 [for]: for-loops.html

branches/beta/src/liballoc/boxed.rs

@@ -55,16 +55,13 @@
 
 use core::prelude::*;
 
-use heap;
-
 use core::any::Any;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::marker::{self, Unsize};
+use core::marker::Unsize;
 use core::mem;
 use core::ops::{CoerceUnsized, Deref, DerefMut};
-use core::ops::{Placer, Boxed, Place, InPlace, BoxPlace};
 use core::ptr::Unique;
 use core::raw::{TraitObject};
 
@@ -75,7 +72,7 @@ use core::raw::{TraitObject};
 ///
 /// ```
 /// # #![feature(box_heap)]
-/// #![feature(box_syntax, placement_in_syntax)]
+/// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
 /// fn main() {
@@ -86,110 +83,15 @@ use core::raw::{TraitObject};
 #[lang = "exchange_heap"]
 #[unstable(feature = "box_heap",
            reason = "may be renamed; uncertain about custom allocator design")]
-pub const HEAP: ExchangeHeapSingleton =
-    ExchangeHeapSingleton { _force_singleton: () };
-
-/// This the singleton type used solely for `boxed::HEAP`.
-#[derive(Copy, Clone)]
-pub struct ExchangeHeapSingleton { _force_singleton: () }
+pub const HEAP: () = ();
 
 /// A pointer type for heap allocation.
 ///
 /// See the [module-level documentation](../../std/boxed/index.html) for more.
 #[lang = "owned_box"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[fundamental]
-pub struct Box<T: ?Sized>(Unique<T>);
-
-/// `IntermediateBox` represents uninitialized backing storage for `Box`.
-///
-/// FIXME (pnkfelix): Ideally we would just reuse `Box<T>` instead of
-/// introducing a separate `IntermediateBox<T>`; but then you hit
-/// issues when you e.g. attempt to destructure an instance of `Box`,
-/// since it is a lang item and so it gets special handling by the
-/// compiler.  Easier just to make this parallel type for now.
-///
-/// FIXME (pnkfelix): Currently the `box` protocol only supports
-/// creating instances of sized types. This IntermediateBox is
-/// designed to be forward-compatible with a future protocol that
-/// supports creating instances of unsized types; that is why the type
-/// parameter has the `?Sized` generalization marker, and is also why
-/// this carries an explicit size. However, it probably does not need
-/// to carry the explicit alignment; that is just a work-around for
-/// the fact that the `align_of` intrinsic currently requires the
-/// input type to be Sized (which I do not think is strictly
-/// necessary).
-#[unstable(feature = "placement_in", reason = "placement box design is still being worked out.")]
-pub struct IntermediateBox<T: ?Sized>{
-    ptr: *mut u8,
-    size: usize,
-    align: usize,
-    marker: marker::PhantomData<*mut T>,
-}
-
-impl<T> Place<T> for IntermediateBox<T> {
-    fn pointer(&mut self) -> *mut T {
-        unsafe { ::core::mem::transmute(self.ptr) }
-    }
-}
-
-unsafe fn finalize<T>(b: IntermediateBox<T>) -> Box<T> {
-    let p = b.ptr as *mut T;
-    mem::forget(b);
-    mem::transmute(p)
-}
-
-fn make_place<T>() -> IntermediateBox<T> {
-    let size = mem::size_of::<T>();
-    let align = mem::align_of::<T>();
-
-    let p = if size == 0 {
-        heap::EMPTY as *mut u8
-    } else {
-        let p = unsafe {
-            heap::allocate(size, align)
-        };
-        if p.is_null() {
-            panic!("Box make_place allocation failure.");
-        }
-        p
-    };
-
-    IntermediateBox { ptr: p, size: size, align: align, marker: marker::PhantomData }
-}
-
-impl<T> BoxPlace<T> for IntermediateBox<T> {
-    fn make_place() -> IntermediateBox<T> { make_place() }
-}
-
-impl<T> InPlace<T> for IntermediateBox<T> {
-    type Owner = Box<T>;
-    unsafe fn finalize(self) -> Box<T> { finalize(self) }
-}
-
-impl<T> Boxed for Box<T> {
-    type Data = T;
-    type Place = IntermediateBox<T>;
-    unsafe fn finalize(b: IntermediateBox<T>) -> Box<T> { finalize(b) }
-}
-
-impl<T> Placer<T> for ExchangeHeapSingleton {
-    type Place = IntermediateBox<T>;
-
-    fn make_place(self) -> IntermediateBox<T> {
-        make_place()
-    }
-}
-
-impl<T: ?Sized> Drop for IntermediateBox<T> {
-    fn drop(&mut self) {
-        if self.size > 0 {
-            unsafe {
-                heap::deallocate(self.ptr, self.size, self.align)
-            }
-        }
-    }
-}
+pub struct Box<T>(Unique<T>);
 
 impl<T> Box<T> {
     /// Allocates memory on the heap and then moves `x` into it.
@@ -297,7 +199,8 @@ impl<T: Clone> Clone for Box<T> {
     /// let y = x.clone();
     /// ```
     #[inline]
-    fn clone(&self) -> Box<T> { box (HEAP) {(**self).clone()} }
+    fn clone(&self) -> Box<T> { box {(**self).clone()} }
+
     /// Copies `source`'s contents into `self` without creating a new allocation.
     ///
     /// # Examples

branches/beta/src/liballoc/lib.rs

@@ -70,8 +70,6 @@
        test(no_crate_inject))]
 #![no_std]
 
-// SNAP d4432b3
-#![allow(unused_features)] // until feature(placement_in_syntax) is in snap
 #![feature(allocator)]
 #![feature(box_syntax)]
 #![feature(coerce_unsized)]
@@ -84,8 +82,6 @@
 #![feature(no_std)]
 #![feature(nonzero)]
 #![feature(optin_builtin_traits)]
-#![feature(placement_in_syntax)]
-#![feature(placement_new_protocol)]
 #![feature(raw)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]

branches/beta/src/libcore/intrinsics.rs

@@ -184,14 +184,6 @@ extern "rust-intrinsic" {
     /// elements.
     pub fn size_of<T>() -> usize;
 
-    #[cfg(not(stage0))]
-    /// Moves a value to an uninitialized memory location.
-    ///
-    /// Drop glue is not run on the destination.
-    pub fn move_val_init<T>(dst: *mut T, src: T);
-
-    // SNAP d4432b3
-    #[cfg(stage0)]
     /// Moves a value to an uninitialized memory location.
     ///
     /// Drop glue is not run on the destination.

branches/beta/src/libcore/iter.rs

@@ -2555,7 +2555,7 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
 #[unstable(feature = "iter_unfold")]
 #[derive(Clone)]
 #[deprecated(since = "1.2.0",
-             reason = "has not gained enough traction to retain its position \
+             reason = "has gained enough traction to retain its position \
                        in the standard library")]
 #[allow(deprecated)]
 pub struct Unfold<St, F> {
@@ -2567,7 +2567,7 @@ pub struct Unfold<St, F> {
 
 #[unstable(feature = "iter_unfold")]
 #[deprecated(since = "1.2.0",
-             reason = "has not gained enough traction to retain its position \
+             reason = "has gained enough traction to retain its position \
                        in the standard library")]
 #[allow(deprecated)]
 impl<A, St, F> Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
@@ -3018,7 +3018,7 @@ type IterateState<T, F> = (F, Option<T>, bool);
 /// from a given seed value.
 #[unstable(feature = "iter_iterate")]
 #[deprecated(since = "1.2.0",
-             reason = "has not gained enough traction to retain its position \
+             reason = "has gained enough traction to retain its position \
                        in the standard library")]
 #[allow(deprecated)]
 pub type Iterate<T, F> = Unfold<IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
@@ -3027,7 +3027,7 @@ pub type Iterate<T, F> = Unfold<IterateState<T, F>, fn(&mut IterateState<T, F>)
 /// repeated applications of the given function `f`.
 #[unstable(feature = "iter_iterate")]
 #[deprecated(since = "1.2.0",
-             reason = "has not gained enough traction to retain its position \
+             reason = "has gained enough traction to retain its position \
                        in the standard library")]
 #[allow(deprecated)]
 pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where