---

yaml
---
r: 233528
b: refs/heads/beta
c: cc65f79
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 2fb3fb24a395dfb21142f4572440214fbf551e4a
+refs/heads/beta: cc65f79e55e152b6e1bba704d1e2c7ed789da244
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/README.md

@@ -82,28 +82,6 @@ Read ["Installing Rust"] from [The Book].
    $ make && make install
    ```
 
-## Building Documentation
-
-If you’d like to build the documentation, it’s almost the same:
-
-```sh
-./configure
-$ make docs
-```
-
-Building the documentation requires building the compiler, so the above
-details will apply. Once you have the compiler built, you can
-
-```sh
-$ make docs NO_REBUILD=1 
-```
-
-To make sure you don’t re-build the compiler because you made a change
-to some documentation.
-
-The generated documentation will appear in a top-level `doc` directory,
-created by the `make` rule.
-
 ## Notes
 
 Since the Rust compiler is written in Rust, it must be built by a

branches/beta/man/rustc.1

@@ -41,7 +41,7 @@ look for anything here (the default)
 .RE
 .TP
 \fB\-l\fR [\fIKIND\fR=]\fINAME\fR
-Link the generated crate(s) to the specified library \fINAME\fR.
+Link the generated crate(s) to the specified native library \fINAME\fR.
 The optional \fIKIND\fR can be one of \fIstatic\fR, \fIdylib\fR, or
 \fIframework\fR.
 If omitted, \fIdylib\fR is assumed.
@@ -113,8 +113,7 @@ Print version info and exit.
 Use verbose output.
 .TP
 \fB\-\-extern\fR \fINAME\fR=\fIPATH\fR
-Specify where an external rust library is located. These should match
-\fIextern\fR declarations in the crate's source code.
+Specify where an external rust library is located.
 .TP
 \fB\-\-sysroot\fR \fIPATH\fR
 Override the system root.

branches/beta/mk/crates.mk

@@ -56,7 +56,7 @@ TARGET_CRATES := libc std flate arena term \
 		 alloc_system
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
-                rustc_data_structures rustc_platform_intrinsics
+                rustc_data_structures
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
 TOOLS := compiletest rustdoc rustc rustbook error-index-generator
 
@@ -74,16 +74,15 @@ DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_bo
 		     rustc_trans rustc_privacy rustc_lint
 
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
-	                log syntax serialize rustc_llvm rustc_platform_intrinsics
-DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics
+	                log syntax serialize rustc_llvm
+DEPS_rustc_typeck := rustc syntax
 DEPS_rustc_borrowck := rustc log graphviz syntax
 DEPS_rustc_resolve := rustc log syntax
 DEPS_rustc_privacy := rustc log syntax
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               log graphviz rustc_llvm rustc_back rustc_data_structures
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
-DEPS_rustc_platform_intrinsics := rustc rustc_llvm
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \

branches/beta/src/doc/reference.md

@@ -2059,11 +2059,6 @@ The following configurations must be defined by the implementation:
   `"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`.
 * `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
   `"big"`.
-* `target_env = ".."` - an option provided by the compiler by default
-  describing the runtime environment of the target platform. Some examples of
-  this are `musl` for builds targeting the MUSL libc implementation, `msvc` for
-  Windows builds targeting MSVC, and `gnu` frequently the rest of the time. This
-  option may also be blank on some platforms.
 * `target_family = "..."`. Operating system family of the target, e. g.
   `"unix"` or `"windows"`. The value of this configuration option is defined
   as a configuration itself, like `unix` or `windows`.

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

@@ -214,61 +214,11 @@ fn diverges() -> ! {
 
 `panic!` is a macro, similar to `println!()` that we’ve already seen. Unlike
 `println!()`, `panic!()` causes the current thread of execution to crash with
-the given message. Because this function will cause a crash, it will never
-return, and so it has the type ‘`!`’, which is read ‘diverges’.
+the given message.
 
-If you add a main function that calls `diverges()` and run it, you’ll get
-some output that looks like this:
-
-```text
-thread ‘<main>’ panicked at ‘This function never returns!’, hello.rs:2
-```
-
-If you want more information, you can get a backtrace by setting the
-`RUST_BACKTRACE` environment variable:
-
-```text
-$ RUST_BACKTRACE=1 ./diverges
-thread '<main>' panicked at 'This function never returns!', hello.rs:2
-stack backtrace:
-   1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r
-   2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w
-   3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw
-   4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650
-   5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa
-   6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa
-   7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231
-   8:     0x7f402773d1d8 - __rust_try
-   9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w
-  10:     0x7f4027738a19 - main
-  11:     0x7f402694ab44 - __libc_start_main
-  12:     0x7f40277386c8 - <unknown>
-  13:                0x0 - <unknown>
-```
-
-`RUST_BACKTRACE` also works with Cargo’s `run` command:
-
-```text
-$ RUST_BACKTRACE=1 cargo run
-     Running `target/debug/diverges`
-thread '<main>' panicked at 'This function never returns!', hello.rs:2
-stack backtrace:
-   1:     0x7f402773a829 - sys::backtrace::write::h0942de78b6c02817K8r
-   2:     0x7f402773d7fc - panicking::on_panic::h3f23f9d0b5f4c91bu9w
-   3:     0x7f402773960e - rt::unwind::begin_unwind_inner::h2844b8c5e81e79558Bw
-   4:     0x7f4027738893 - rt::unwind::begin_unwind::h4375279447423903650
-   5:     0x7f4027738809 - diverges::h2266b4c4b850236beaa
-   6:     0x7f40277389e5 - main::h19bb1149c2f00ecfBaa
-   7:     0x7f402773f514 - rt::unwind::try::try_fn::h13186883479104382231
-   8:     0x7f402773d1d8 - __rust_try
-   9:     0x7f402773f201 - rt::lang_start::ha172a3ce74bb453aK5w
-  10:     0x7f4027738a19 - main
-  11:     0x7f402694ab44 - __libc_start_main
-  12:     0x7f40277386c8 - <unknown>
-  13:                0x0 - <unknown>
-```
-
-A diverging function can be used as any type:
+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
 # fn diverges() -> ! {

branches/beta/src/doc/trpl/trait-objects.md

@@ -300,41 +300,3 @@ let y = TraitObject {
 // y.method();
 (y.vtable.method)(y.data);
 ```
-
-## Object Safety
-
-Not every trait can be used to make a trait object. For example, vectors implement
-`Clone`, but if we try to make a trait object:
-
-```ignore
-let v = vec![1, 2, 3];
-let o = &v as &Clone;
-```
-
-We get an error:
-
-```text
-error: cannot convert to a trait object because trait `core::clone::Clone` is not object-safe [E0038]
-let o = &v as &Clone;
-        ^~
-note: the trait cannot require that `Self : Sized`
-let o = &v as &Clone;
-        ^~
-```
-
-The error says that `Clone` is not ‘object-safe’. Only traits that are
-object-safe can be made into trait objects. A trait is object-safe if both of
-these are true:
-
-* the trait does not require that `Self: Sized`
-* all of its methods are object-safe
-
-So what makes a method object-safe? Each method must require that `Self: Sized`
-or all of the following:
-
-* must not have any type parameters
-* must not use `Self`
-
-Whew! As we can see, almost all of these rules talk about `Self`. A good intuition
-is “except in special circumstances, if your trait’s method uses `Self`, it is not
-object-safe.”

branches/beta/src/liballoc/arc.rs

@@ -137,8 +137,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Arc<U>> for Arc<T> {}
 /// used to break cycles between `Arc` pointers.
 #[unsafe_no_drop_flag]
 #[unstable(feature = "arc_weak",
-           reason = "Weak pointers may not belong in this module.",
-           issue = "27718")]
+           reason = "Weak pointers may not belong in this module.")]
 pub struct Weak<T: ?Sized> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -210,8 +209,7 @@ impl<T: ?Sized> Arc<T> {
     /// let weak_five = five.downgrade();
     /// ```
     #[unstable(feature = "arc_weak",
-               reason = "Weak pointers may not belong in this module.",
-               issue = "27718")]
+               reason = "Weak pointers may not belong in this module.")]
     pub fn downgrade(&self) -> Weak<T> {
         loop {
             // This Relaxed is OK because we're checking the value in the CAS
@@ -236,14 +234,14 @@ impl<T: ?Sized> Arc<T> {
 
     /// Get the number of weak references to this value.
     #[inline]
-    #[unstable(feature = "arc_counts", issue = "27718")]
+    #[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", issue = "27718")]
+    #[unstable(feature = "arc_counts")]
     pub fn strong_count(this: &Arc<T>) -> usize {
         this.inner().strong.load(SeqCst)
     }
@@ -351,7 +349,7 @@ impl<T: Clone> Arc<T> {
     /// let mut_five = Arc::make_unique(&mut five);
     /// ```
     #[inline]
-    #[unstable(feature = "arc_unique", issue = "27718")]
+    #[unstable(feature = "arc_unique")]
     pub fn make_unique(this: &mut Arc<T>) -> &mut T {
         // Note that we hold both a strong reference and a weak reference.
         // Thus, releasing our strong reference only will not, by itself, cause
@@ -429,7 +427,7 @@ impl<T: ?Sized> Arc<T> {
     /// # }
     /// ```
     #[inline]
-    #[unstable(feature = "arc_unique", issue = "27718")]
+    #[unstable(feature = "arc_unique")]
     pub fn get_mut(this: &mut Arc<T>) -> Option<&mut T> {
         if this.is_unique() {
             // This unsafety is ok because we're guaranteed that the pointer
@@ -543,8 +541,7 @@ impl<T: ?Sized> Drop for Arc<T> {
 }
 
 #[unstable(feature = "arc_weak",
-           reason = "Weak pointers may not belong in this module.",
-           issue = "27718")]
+           reason = "Weak pointers may not belong in this module.")]
 impl<T: ?Sized> Weak<T> {
     /// Upgrades a weak reference to a strong reference.
     ///
@@ -592,8 +589,7 @@ impl<T: ?Sized> Weak<T> {
 }
 
 #[unstable(feature = "arc_weak",
-           reason = "Weak pointers may not belong in this module.",
-           issue = "27718")]
+           reason = "Weak pointers may not belong in this module.")]
 impl<T: ?Sized> Clone for Weak<T> {
     /// Makes a clone of the `Weak<T>`.
     ///

branches/beta/src/liballoc/boxed.rs

@@ -85,15 +85,13 @@ use core::raw::{TraitObject};
 /// ```
 #[lang = "exchange_heap"]
 #[unstable(feature = "box_heap",
-           reason = "may be renamed; uncertain about custom allocator design",
-           issue = "27779")]
+           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`.
 #[unstable(feature = "box_heap",
-           reason = "may be renamed; uncertain about custom allocator design",
-           issue = "27779")]
+           reason = "may be renamed; uncertain about custom allocator design")]
 #[derive(Copy, Clone)]
 pub struct ExchangeHeapSingleton { _force_singleton: () }
 
@@ -123,9 +121,7 @@ pub struct Box<T: ?Sized>(Unique<T>);
 /// 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.",
-           issue = "27779")]
+#[unstable(feature = "placement_in", reason = "placement box design is still being worked out.")]
 pub struct IntermediateBox<T: ?Sized>{
     ptr: *mut u8,
     size: usize,
@@ -226,8 +222,7 @@ impl<T : ?Sized> Box<T> {
     /// lead to memory problems like double-free, for example if the
     /// function is called twice on the same raw pointer.
     #[unstable(feature = "box_raw",
-               reason = "may be renamed or moved out of Box scope",
-               issue = "27768")]
+               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 {
@@ -250,8 +245,7 @@ impl<T : ?Sized> Box<T> {
     /// let raw = Box::into_raw(seventeen);
     /// let boxed_again = unsafe { Box::from_raw(raw) };
     /// ```
-    #[unstable(feature = "box_raw", reason = "may be renamed",
-               issue = "27768")]
+    #[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 {
@@ -476,7 +470,7 @@ impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
 /// }
 /// ```
 #[rustc_paren_sugar]
-#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")]
+#[unstable(feature = "fnbox", reason = "Newly introduced")]
 pub trait FnBox<A> {
     type Output;
 

branches/beta/src/liballoc/heap.rs

@@ -12,8 +12,7 @@
             reason = "the precise API and guarantees it provides may be tweaked \
                       slightly, especially to possibly take into account the \
                       types being stored to make room for a future \
-                      tracing garbage collector",
-            issue = "27700")]
+                      tracing garbage collector")]
 
 use core::{isize, usize};
 

branches/beta/src/liballoc/lib.rs

@@ -64,8 +64,7 @@
 #![allow(unused_attributes)]
 #![unstable(feature = "alloc",
             reason = "this library is unlikely to be stabilized in its current \
-                      form or name",
-            issue = "27783")]
+                      form or name")]
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
        html_root_url = "https://doc.rust-lang.org/nightly/",
@@ -84,7 +83,6 @@
 #![feature(lang_items)]
 #![feature(no_std)]
 #![feature(nonzero)]
-#![feature(num_bits_bytes)]
 #![feature(optin_builtin_traits)]
 #![feature(placement_in_syntax)]
 #![feature(placement_new_protocol)]
@@ -132,8 +130,7 @@ pub mod raw_vec;
 /// Common out-of-memory routine
 #[cold]
 #[inline(never)]
-#[unstable(feature = "oom", reason = "not a scrutinized interface",
-           issue = "27700")]
+#[unstable(feature = "oom", reason = "not a scrutinized interface")]
 pub fn oom() -> ! {
     // FIXME(#14674): This really needs to do something other than just abort
     //                here, but any printing done must be *guaranteed* to not

branches/beta/src/liballoc/raw_vec.rs

@@ -15,7 +15,6 @@ use heap;
 use super::oom;
 use super::boxed::Box;
 use core::ops::Drop;
-use core;
 
 /// A low-level utility for more ergonomically allocating, reallocating, and deallocating a
 /// a buffer of memory on the heap without having to worry about all the corner cases
@@ -444,8 +443,11 @@ impl<T> Drop for RawVec<T> {
 // user-space. e.g. PAE or x32
 
 #[inline]
+#[cfg(target_pointer_width = "64")]
+fn alloc_guard(_alloc_size: usize) { }
+
+#[inline]
+#[cfg(target_pointer_width = "32")]
 fn alloc_guard(alloc_size: usize) {
-    if core::usize::BITS < 64 {
-        assert!(alloc_size <= ::core::isize::MAX as usize, "capacity overflow");
-    }
+    assert!(alloc_size <= ::core::isize::MAX as usize, "capacity overflow");
 }