---

yaml
---
r: 232523
b: refs/heads/try
c: d27dc3e
h: refs/heads/master
i:
  232521: f895d91
  232519: ab2ef33
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: fd53ea28d8a85ceec71bd5f4016c44eab7e58ccf
+refs/heads/try: d27dc3edd4d6f01dc2b065f2a73d4ab3fab0e252
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/reference.md

@@ -2059,6 +2059,11 @@ 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/try/src/doc/trpl/functions.md

@@ -214,11 +214,61 @@ 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.
+the given message. Because this function will cause a crash, it will never
+return, and so it has the type ‘`!`’, which is read ‘diverges’.
 
-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:
+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:
 
 ```should_panic
 # fn diverges() -> ! {

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

@@ -300,3 +300,41 @@ 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/try/src/libcollections/binary_heap.rs

@@ -112,7 +112,7 @@
 //!     //                  7
 //!     //          +-----------------+
 //!     //          |                 |
-//!     //          v   1        2    |
+//!     //          v   1        2    |  2
 //!     //          0 -----> 1 -----> 3 ---> 4
 //!     //          |        ^        ^      ^
 //!     //          |        | 1      |      |