---

yaml
---
r: 231933
b: refs/heads/auto
c: 33f0920
h: refs/heads/master
i:
  231931: b256c63
v: v3

Author: bors

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: e8c398d05c92d4cdd7b3528b892355e0c000131b
+refs/heads/auto: 33f0920d0e81cf95cb62f380c13f100f3e1d804c
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/configure

@@ -885,6 +885,28 @@ 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" ]
@@ -956,7 +978,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[5-7]*)
+        (3.[5-8]*)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)
@@ -1030,7 +1052,7 @@ then
             esac
         else
             case $CFG_CLANG_VERSION in
-                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7*)
+                (3.2* | 3.3* | 3.4* | 3.5* | 3.6* | 3.7* | 3.8*)
                 step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
                 ;;
                 (*)

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

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

branches/auto/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 `std::rt::heap::EMPTY`. There are quite a few places where we'll
+as `alloc::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,11 +20,12 @@ the `heap` API anyway, so let's just get that dependency over with.
 So:
 
 ```rust,ignore
-#![feature(heap_api)]
+#![feature(alloc, 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/auto/src/doc/nomicon/vec-final.md

@@ -2,17 +2,16 @@
 
 ```rust
 #![feature(unique)]
-#![feature(heap_api)]
+#![feature(alloc, heap_api)]
+
+extern crate alloc;
 
 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/auto/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. For example, in
+Traits may inherit from other traits. Consider the following example:
 
 ```
 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,9 +2367,6 @@ 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