---

yaml
---
r: 227479
b: refs/heads/auto
c: 8a7b0fa
h: refs/heads/master
i:
  227477: 8069ec1
  227475: a798630
  227471: 364c2e1
v: v3

Author: alexcrichton

[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: e47eb7c2c850c49d5358d64cb3de6e82ff5fc99a
+refs/heads/auto: 8a7b0fad531f2cbb40aace2bdfb5f03060a61d33
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/src/libcollections/binary_heap.rs

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

branches/auto/src/libcollections/btree/node.rs

@@ -387,29 +387,8 @@ impl<K, V> Node<K, V> {
 
     #[inline]
     pub fn as_slices_internal_mut<'b>(&'b mut self) -> MutNodeSlice<'b, K, V> {
-        let len = self.len();
-        let is_leaf = self.is_leaf();
-        let keys = unsafe { slice::from_raw_parts_mut(*self.keys, len) };
-        let vals = unsafe { slice::from_raw_parts_mut(*self.vals, len) };
-        let edges: &mut [_] = if is_leaf {
-            &mut []
-        } else {
-            unsafe {
-                let data = match self.edges {
-                    None => heap::EMPTY as *mut Node<K,V>,
-                    Some(ref mut p) => **p as *mut Node<K,V>,
-                };
-                slice::from_raw_parts_mut(data, len + 1)
-            }
-        };
-        MutNodeSlice {
-            keys: keys,
-            vals: vals,
-            edges: edges,
-            head_is_edge: true,
-            tail_is_edge: true,
-            has_edges: !is_leaf,
-        }
+        // FIXME(#27620): Bad: This relies on structure layout!
+        unsafe { mem::transmute(self.as_slices_internal()) }
     }
 
     #[inline]

branches/auto/src/libcollectionstest/str.rs

@@ -85,26 +85,6 @@ fn test_find_str() {
     assert_eq!(data[43..86].find("ย中"), Some(67 - 43));
     assert_eq!(data[43..86].find("iệt"), Some(77 - 43));
     assert_eq!(data[43..86].find("Nam"), Some(83 - 43));
-
-    // find every substring -- assert that it finds it, or an earlier occurence.
-    let string = "Việt Namacbaabcaabaaba";
-    for (i, ci) in string.char_indices() {
-        let ip = i + ci.len_utf8();
-        for j in string[ip..].char_indices()
-                             .map(|(i, _)| i)
-                             .chain(Some(string.len() - ip))
-        {
-            let pat = &string[i..ip + j];
-            assert!(match string.find(pat) {
-                None => false,
-                Some(x) => x <= i,
-            });
-            assert!(match string.rfind(pat) {
-                None => false,
-                Some(x) => x >= i,
-            });
-        }
-    }
 }
 
 fn s(x: &str) -> String { x.to_string() }

branches/auto/src/libcore/lib.rs

@@ -78,8 +78,7 @@
 #![feature(optin_builtin_traits)]
 #![feature(reflect)]
 #![feature(rustc_attrs)]
-#![cfg_attr(stage0, feature(simd))]
-#![cfg_attr(not(stage0), feature(repr_simd, platform_intrinsics))]
+#![feature(simd)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 
@@ -151,13 +150,7 @@ pub mod iter;
 pub mod option;
 pub mod raw;
 pub mod result;
-
-#[cfg(stage0)]
-#[path = "simd_old.rs"]
-pub mod simd;
-#[cfg(not(stage0))]
 pub mod simd;
-
 pub mod slice;
 pub mod str;
 pub mod hash;

branches/auto/src/libcore/marker.rs

@@ -13,6 +13,15 @@
 //! Rust types can be classified in various useful ways according to
 //! intrinsic properties of the type. These classifications, often called
 //! 'kinds', are represented as traits.
+//!
+//! They cannot be implemented by user code, but are instead implemented
+//! by the compiler automatically for the types to which they apply.
+//!
+//! Marker types are special types that are used with unsafe code to
+//! inform the compiler of special constraints. Marker types should
+//! only be needed when you are creating an abstraction that is
+//! implemented using unsafe code. In that case, you may want to embed
+//! some of the marker types below into your type.
 
 #![stable(feature = "rust1", since = "1.0.0")]