---

yaml
---
r: 234168
b: refs/heads/beta
c: e8c398d
h: refs/heads/master
v: v3

Author: dotdash

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

branches/beta/configure

@@ -885,28 +885,6 @@ then
     CFG_DISABLE_JEMALLOC=1
 fi
 
-# default gcc version under OpenBSD maybe too old, try using egcc, which is a
-# gcc version from ports
-if [ $CFG_OSTYPE = unknown-openbsd ]
-then
-    if [ $("$CFG_GCC" --version 2>&1 | grep -c ' 4\.[0-6]') -ne 0 ]; then
-        step_msg "older GCC found, try with egcc instead"
-
-        # probe again but using egcc
-        probe CFG_GCC egcc
-
-        # and use egcc/eg++ for CC/CXX too if it was found
-        # (but user setting has priority)
-        if [ -n "$CFG_GCC" ]; then
-            CC="${CC:-egcc}"
-            CXX="${CXX:-eg++}"
-        fi
-    fi
-
-    step_msg "on OpenBSD, disabling jemalloc"
-    CFG_DISABLE_JEMALLOC=1
-fi
-
 # OS X 10.9, gcc is actually clang. This can cause some confusion in the build
 # system, so if we find that gcc is clang, we should just use clang directly.
 if [ $CFG_OSTYPE = apple-darwin -a -z "$CFG_ENABLE_CLANG" ]
@@ -978,7 +956,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[5-8]*)
+        (3.[5-7]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
@@ -1052,7 +1030,7 @@ then
             esac
         else
             case $CFG_CLANG_VERSION in
-                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7* | 3.8*)
+                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*)
                 step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
                 ;;
                 (*)

branches/beta/src/doc/nomicon/destructors.md

@@ -26,16 +26,13 @@ this is totally fine.
 For instance, a custom implementation of `Box` might write `Drop` like this:
 
 ```rust
-#![feature(alloc, heap_api, core_intrinsics, unique)]
-
-extern crate alloc;
+#![feature(heap_api, core_intrinsics, unique)]
 
+use std::rt::heap;
 use std::ptr::Unique;
 use std::intrinsics::drop_in_place;
 use std::mem;
 
-use alloc::heap;
-
 struct Box<T>{ ptr: Unique<T> }
 
 impl<T> Drop for Box<T> {
@@ -48,7 +45,6 @@ impl<T> Drop for Box<T> {
         }
     }
 }
-# fn main() {}
 ```
 
 and this works fine because when Rust goes to drop the `ptr` field it just sees
@@ -58,16 +54,13 @@ use-after-free the `ptr` because when drop exits, it becomes inacessible.
 However this wouldn't work:
 
 ```rust
-#![feature(alloc, heap_api, core_intrinsics, unique)]
-
-extern crate alloc;
+#![feature(heap_api, core_intrinsics, unique)]
 
+use std::rt::heap;
 use std::ptr::Unique;
 use std::intrinsics::drop_in_place;
 use std::mem;
 
-use alloc::heap;
-
 struct Box<T>{ ptr: Unique<T> }
 
 impl<T> Drop for Box<T> {
@@ -94,7 +87,6 @@ impl<T> Drop for SuperBox<T> {
         }
     }
 }
-# fn main() {}
 ```
 
 After we deallocate the `box`'s ptr in SuperBox's destructor, Rust will
@@ -137,16 +129,13 @@ The classic safe solution to overriding recursive drop and allowing moving out
 of Self during `drop` is to use an Option:
 
 ```rust
-#![feature(alloc, heap_api, core_intrinsics, unique)]
-
-extern crate alloc;
+#![feature(heap_api, core_intrinsics, unique)]
 
+use std::rt::heap;
 use std::ptr::Unique;
 use std::intrinsics::drop_in_place;
 use std::mem;
 
-use alloc::heap;
-
 struct Box<T>{ ptr: Unique<T> }
 
 impl<T> Drop for Box<T> {
@@ -176,7 +165,6 @@ impl<T> Drop for SuperBox<T> {
         }
     }
 }
-# fn main() {}
 ```
 
 However this has fairly odd semantics: you're saying that a field that *should*

branches/beta/src/doc/nomicon/vec-alloc.md

@@ -9,7 +9,7 @@ This is perfectly fine because we already have `cap == 0` as our sentinel for no
 allocation. We don't even need to handle it specially in almost any code because
 we usually need to check if `cap > len` or `len > 0` anyway. The traditional
 Rust value to put here is `0x01`. The standard library actually exposes this
-as `alloc::heap::EMPTY`. There are quite a few places where we'll
+as `std::rt::heap::EMPTY`. There are quite a few places where we'll
 want to use `heap::EMPTY` because there's no real allocation to talk about but
 `null` would make the compiler do bad things.
 
@@ -20,12 +20,11 @@ the `heap` API anyway, so let's just get that dependency over with.
 So:
 
 ```rust,ignore
-#![feature(alloc, heap_api)]
+#![feature(heap_api)]
 
+use std::rt::heap::EMPTY;
 use std::mem;
 
-use alloc::heap::EMPTY;
-
 impl<T> Vec<T> {
     fn new() -> Self {
         assert!(mem::size_of::<T>() != 0, "We're not ready to handle ZSTs");

branches/beta/src/doc/nomicon/vec-final.md

@@ -2,16 +2,17 @@
 
 ```rust
 #![feature(unique)]
-#![feature(alloc, heap_api)]
-
-extern crate alloc;
+#![feature(heap_api)]
 
 use std::ptr::{Unique, self};
+use std::rt::heap;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::marker::PhantomData;
 
-use alloc::heap;
+
+
+
 
 struct RawVec<T> {
     ptr: Unique<T>,

branches/beta/src/doc/reference.md

@@ -1489,14 +1489,14 @@ impl Num for f64 {
 let x: f64 = Num::from_i32(42);
 ```
 
-Traits may inherit from other traits. Consider the following example:
+Traits may inherit from other traits. For example, in
 
 ```
 trait Shape { fn area(&self) -> f64; }
 trait Circle : Shape { fn radius(&self) -> f64; }
 ```
 
-The syntax `Circle : Shape` means that types that implement `Circle` must also
+the syntax `Circle : Shape` means that types that implement `Circle` must also
 have an implementation for `Shape`. Multiple supertraits are separated by `+`,
 `trait Circle : Shape + PartialEq { }`. In an implementation of `Circle` for a
 given type `T`, methods can refer to `Shape` methods, since the typechecker
@@ -2059,31 +2059,31 @@ arbitrarily complex configurations through nesting.
 
 The following configurations must be defined by the implementation:
 
-* `debug_assertions` - Enabled by default when compiling without optimizations.
+* `debug_assertions`. Enabled by default when compiling without optimizations.
   This can be used to enable extra debugging code in development but not in
   production.  For example, it controls the behavior of the standard library's
   `debug_assert!` macro.
-* `target_arch = "..."` - Target CPU architecture, such as `"x86"`, `"x86_64"`
+* `target_arch = "..."`. Target CPU architecture, such as `"x86"`, `"x86_64"`
   `"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`.
-* `target_endian = "..."` - Endianness of the target CPU, either `"little"` or
+* `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
   `"big"`.
-* `target_env = ".."` - An option provided by the compiler by default
+* `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.
+* `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`.
-* `target_os = "..."` - Operating system of the target, examples include
+* `target_os = "..."`. Operating system of the target, examples include
   `"windows"`, `"macos"`, `"ios"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
   `"bitrig"` , `"openbsd"` or `"netbsd"`.
-* `target_pointer_width = "..."` - Target pointer width in bits. This is set
+* `target_pointer_width = "..."`. Target pointer width in bits. This is set
   to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
   64-bit pointers.
-* `test` - Enabled when compiling the test harness (using the `--test` flag).
-* `unix` - See `target_family`.
-* `windows` - See `target_family`.
+* `test`. Enabled when compiling the test harness (using the `--test` flag).
+* `unix`. See `target_family`.
+* `windows`. See `target_family`.
 
 You can also set another attribute based on a `cfg` variable with `cfg_attr`:
 
@@ -2367,6 +2367,9 @@ The currently implemented features of the reference compiler are:
             into a Rust program. This capability, especially the signature for the
             annotated function, is subject to change.
 
+* `struct_inherit` - Allows using struct inheritance, which is barely
+                     implemented and will probably be removed. Don't use this.
+
 * `struct_variant` - Structural enum variants (those with named fields). It is
                      currently unknown whether this style of enum variant is as
                      fully supported as the tuple-forms, and it's not certain