Auto merge of rust-lang#38958 - sanxiyn:rollup, r=sanxiyn

bors · bors · commit 7bffede97cf5 · 2017-01-10T14:08:21.000Z
Rollup of 11 pull requests - Successful merges: rust-lang#38606, rust-lang#38607, rust-lang#38623, rust-lang#38664, rust-lang#38799, rust-lang#38816, rust-lang#38836, rust-lang#38839, rust-lang#38841, rust-lang#38849, rust-lang#38874 - Failed merges: rust-lang#38845
diff --git a/src/bootstrap/step.rs b/src/bootstrap/step.rs
@@ -316,7 +316,6 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
               "codegen-units");
         suite("check-incremental", "src/test/incremental", "incremental",
               "incremental");
-        suite("check-ui", "src/test/ui", "ui", "ui");
     }
 
     if build.config.build.contains("msvc") {
@@ -363,6 +362,7 @@ pub fn build_rules<'a>(build: &'a Build) -> Rules {
                  });
         };
 
+        suite("check-ui", "src/test/ui", "ui", "ui");
         suite("check-rpass-full", "src/test/run-pass-fulldeps",
               "run-pass", "run-pass-fulldeps");
         suite("check-rfail-full", "src/test/run-fail-fulldeps",
@@ -1374,7 +1374,6 @@ mod tests {
 
         assert!(plan.iter().any(|s| s.name.contains("-ui")));
         assert!(plan.iter().any(|s| s.name.contains("cfail")));
-        assert!(plan.iter().any(|s| s.name.contains("cfail")));
         assert!(plan.iter().any(|s| s.name.contains("cfail-full")));
         assert!(plan.iter().any(|s| s.name.contains("codegen-units")));
         assert!(plan.iter().any(|s| s.name.contains("debuginfo")));
@@ -1407,8 +1406,7 @@ mod tests {
         assert!(plan.iter().all(|s| s.host == "A"));
         assert!(plan.iter().all(|s| s.target == "C"));
 
-        assert!(plan.iter().any(|s| s.name.contains("-ui")));
-        assert!(plan.iter().any(|s| s.name.contains("cfail")));
+        assert!(!plan.iter().any(|s| s.name.contains("-ui")));
         assert!(plan.iter().any(|s| s.name.contains("cfail")));
         assert!(!plan.iter().any(|s| s.name.contains("cfail-full")));
         assert!(plan.iter().any(|s| s.name.contains("codegen-units")));
diff --git a/src/doc/nomicon/coercions.md b/src/doc/nomicon/coercions.md
@@ -17,6 +17,7 @@ Coercion is allowed between the following types:
     * `&T` to `*const T`
     * `&mut T` to `*mut T`
 * Unsizing: `T` to `U` if `T` implements `CoerceUnsized<U>`
+* Deref coercion: Expression `&x` of type `&T` to `&*x` of type `&U` if `T` derefs to `U` (i.e. `T: Deref<Target=U>`)
 
 `CoerceUnsized<Pointer<U>> for Pointer<T> where T: Unsize<U>` is implemented
 for all pointer types (including smart pointers like Box and Rc). Unsize is
@@ -27,8 +28,9 @@ only implemented automatically, and enables the following transformations:
 * `Foo<..., T, ...>` => `Foo<..., U, ...>` where:
     * `T: Unsize<U>`
     * `Foo` is a struct
-    * Only the last field of `Foo` has type `T`
+    * Only the last field of `Foo` has type involving `T`
     * `T` is not part of the type of any other fields
+    * `Bar<T>: Unsize<Bar<U>>`, if the last field of `Foo` has type `Bar<T>`
 
 Coercions occur at a *coercion site*. Any location that is explicitly typed
 will cause a coercion to its type. If inference is necessary, the coercion will
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
@@ -708,7 +708,7 @@ impl<T: ?Sized> Arc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for Arc<T> {
+unsafe impl<#[may_dangle] T: ?Sized> Drop for Arc<T> {
     /// Drops the `Arc`.
     ///
     /// This will decrement the strong reference count. If the strong reference
@@ -736,7 +736,6 @@ impl<T: ?Sized> Drop for Arc<T> {
     /// drop(foo);    // Doesn't print anything
     /// drop(foo2);   // Prints "dropped!"
     /// ```
-    #[unsafe_destructor_blind_to_params]
     #[inline]
     fn drop(&mut self) {
         // Because `fetch_sub` is already atomic, we do not need to synchronize
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
@@ -79,9 +79,10 @@
 #![feature(const_fn)]
 #![feature(core_intrinsics)]
 #![feature(custom_attribute)]
-#![feature(dropck_parametricity)]
+#![feature(dropck_eyepatch)]
 #![cfg_attr(not(test), feature(exact_size_is_empty))]
 #![feature(fundamental)]
+#![feature(generic_param_attrs)]
 #![feature(lang_items)]
 #![feature(needs_allocator)]
 #![feature(optin_builtin_traits)]
diff --git a/src/liballoc/raw_vec.rs b/src/liballoc/raw_vec.rs
@@ -539,8 +539,7 @@ impl<T> RawVec<T> {
     }
 }
 
-impl<T> Drop for RawVec<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for RawVec<T> {
     /// Frees the memory owned by the RawVec *without* trying to Drop its contents.
     fn drop(&mut self) {
         let elem_size = mem::size_of::<T>();
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
@@ -644,7 +644,7 @@ impl<T: ?Sized> Deref for Rc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Drop for Rc<T> {
+unsafe impl<#[may_dangle] T: ?Sized> Drop for Rc<T> {
     /// Drops the `Rc`.
     ///
     /// This will decrement the strong reference count. If the strong reference
@@ -672,7 +672,6 @@ impl<T: ?Sized> Drop for Rc<T> {
     /// drop(foo);    // Doesn't print anything
     /// drop(foo2);   // Prints "dropped!"
     /// ```
-    #[unsafe_destructor_blind_to_params]
     fn drop(&mut self) {
         unsafe {
             let ptr = *self.ptr;
diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
@@ -30,10 +30,10 @@
 
 #![feature(alloc)]
 #![feature(core_intrinsics)]
+#![feature(dropck_eyepatch)]
 #![feature(heap_api)]
-#![feature(heap_api)]
+#![feature(generic_param_attrs)]
 #![feature(staged_api)]
-#![feature(dropck_parametricity)]
 #![cfg_attr(test, feature(test))]
 
 #![allow(deprecated)]
@@ -258,8 +258,7 @@ impl<T> TypedArena<T> {
     }
 }
 
-impl<T> Drop for TypedArena<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for TypedArena<T> {
     fn drop(&mut self) {
         unsafe {
             // Determine how much was filled.
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
@@ -137,8 +137,7 @@ pub struct BTreeMap<K, V> {
 }
 
 #[stable(feature = "btree_drop", since = "1.7.0")]
-impl<K, V> Drop for BTreeMap<K, V> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {
     fn drop(&mut self) {
         unsafe {
             for _ in ptr::read(self).into_iter() {
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
@@ -35,10 +35,11 @@
 #![feature(box_syntax)]
 #![cfg_attr(not(test), feature(char_escape_debug))]
 #![feature(core_intrinsics)]
-#![feature(dropck_parametricity)]
+#![feature(dropck_eyepatch)]
 #![feature(exact_size_is_empty)]
 #![feature(fmt_internals)]
 #![feature(fused)]
+#![feature(generic_param_attrs)]
 #![feature(heap_api)]
 #![feature(inclusive_range)]
 #![feature(lang_items)]
diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs
@@ -726,8 +726,7 @@ impl<T> LinkedList<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Drop for LinkedList<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for LinkedList<T> {
     fn drop(&mut self) {
         while let Some(_) = self.pop_front_node() {}
     }
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
@@ -370,7 +370,8 @@ impl<T> Vec<T> {
     /// * `capacity` needs to be the capacity that the pointer was allocated with.
     ///
     /// Violating these may cause problems like corrupting the allocator's
-    /// internal datastructures.
+    /// internal datastructures. For example it is **not** safe
+    /// to build a `Vec<u8>` from a pointer to a C `char` array and a `size_t`.
     ///
     /// The ownership of `ptr` is effectively transferred to the
     /// `Vec<T>` which may then deallocate, reallocate or change the
@@ -1786,8 +1787,7 @@ impl<T: Ord> Ord for Vec<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Drop for Vec<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for Vec<T> {
     fn drop(&mut self) {
         unsafe {
             // use drop for [T]
@@ -2056,8 +2056,7 @@ impl<T: Clone> Clone for IntoIter<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Drop for IntoIter<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for IntoIter<T> {
     fn drop(&mut self) {
         // destroy the remaining elements
         for _x in self.by_ref() {}
diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs
@@ -69,8 +69,7 @@ impl<T: Clone> Clone for VecDeque<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Drop for VecDeque<T> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] T> Drop for VecDeque<T> {
     fn drop(&mut self) {
         let (front, back) = self.as_mut_slices();
         unsafe {
diff --git a/src/libcompiler_builtins/build.rs b/src/libcompiler_builtins/build.rs
@@ -192,14 +192,12 @@ fn main() {
 
     if !target.contains("ios") {
         sources.extend(&["absvti2.c",
-                         "addtf3.c",
                          "addvti3.c",
                          "ashlti3.c",
                          "ashrti3.c",
                          "clzti2.c",
                          "cmpti2.c",
                          "ctzti2.c",
-                         "divtf3.c",
                          "divti3.c",
                          "ffsti2.c",
                          "fixdfti.c",
@@ -216,17 +214,13 @@ fn main() {
                          "floatuntixf.c",
                          "lshrti3.c",
                          "modti3.c",
-                         "multf3.c",
                          "multi3.c",
                          "mulvti3.c",
                          "negti2.c",
                          "negvti2.c",
                          "parityti2.c",
                          "popcountti2.c",
-                         "powitf2.c",
-                         "subtf3.c",
                          "subvti3.c",
-                         "trampoline_setup.c",
                          "ucmpti2.c",
                          "udivmodti4.c",
                          "udivti3.c",
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
@@ -100,13 +100,26 @@ pub trait Sized {
 ///
 /// All implementations of `Unsize` are provided automatically by the compiler.
 ///
+/// `Unsize` is implemented for:
+///
+/// - `[T; N]` is `Unsize<[T]>`
+/// - `T` is `Unsize<Trait>` when `T: Trait`
+/// - `Foo<..., T, ...>` is `Unsize<Foo<..., U, ...>>` if:
+///   - `T: Unsize<U>`
+///   - Foo is a struct
+///   - Only the last field of `Foo` has a type involving `T`
+///   - `T` is not part of the type of any other fields
+///   - `Bar<T>: Unsize<Bar<U>>`, if the last field of `Foo` has type `Bar<T>`
+///
 /// `Unsize` is used along with [`ops::CoerceUnsized`][coerceunsized] to allow
 /// "user-defined" containers such as [`rc::Rc`][rc] to contain dynamically-sized
-/// types. See the [DST coercion RFC][RFC982] for more details.
+/// types. See the [DST coercion RFC][RFC982] and [the nomicon entry on coercion][nomicon-coerce]
+/// for more details.
 ///
 /// [coerceunsized]: ../ops/trait.CoerceUnsized.html
 /// [rc]: ../../std/rc/struct.Rc.html
 /// [RFC982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
+
 #[unstable(feature = "unsize", issue = "27732")]
 #[lang="unsize"]
 pub trait Unsize<T: ?Sized> {
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
@@ -2710,6 +2710,35 @@ mod impls {
 
 /// Trait that indicates that this is a pointer or a wrapper for one,
 /// where unsizing can be performed on the pointee.
+///
+/// See the [DST coercion RfC][dst-coerce] and [the nomicon entry on coercion][nomicon-coerce]
+/// for more details.
+///
+/// For builtin pointer types, pointers to `T` will coerce to pointers to `U` if `T: Unsize<U>`
+/// by converting from a thin pointer to a fat pointer.
+///
+/// For custom types, the coercion here works by coercing `Foo<T>` to `Foo<U>`
+/// provided an impl of `CoerceUnsized<Foo<U>> for Foo<T>` exists.
+/// Such an impl can only be written if `Foo<T>` has only a single non-phantomdata
+/// field involving `T`. If the type of that field is `Bar<T>`, an implementation
+/// of `CoerceUnsized<Bar<U>> for Bar<T>` must exist. The coercion will work by
+/// by coercing the `Bar<T>` field into `Bar<U>` and filling in the rest of the fields
+/// from `Foo<T>` to create a `Foo<U>`. This will effectively drill down to a pointer
+/// field and coerce that.
+///
+/// Generally, for smart pointers you will implement
+/// `CoerceUnsized<Ptr<U>> for Ptr<T> where T: Unsize<U>, U: ?Sized`, with an
+/// optional `?Sized` bound on `T` itself. For wrapper types that directly embed `T`
+/// like `Cell<T>` and `RefCell<T>`, you
+/// can directly implement `CoerceUnsized<Wrap<U>> for Wrap<T> where T: CoerceUnsized<U>`.
+/// This will let coercions of types like `Cell<Box<T>>` work.
+///
+/// [`Unsize`][unsize] is used to mark types which can be coerced to DSTs if behind
+/// pointers. It is implemented automatically by the compiler.
+///
+/// [dst-coerce]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
+/// [unsize]: ../marker/trait.Unsize.html
+/// [nomicon-coerce]: ../../nomicon/coercions.html
 #[unstable(feature = "coerce_unsized", issue = "27732")]
 #[lang="coerce_unsized"]
 pub trait CoerceUnsized<T> {
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
@@ -1175,7 +1175,7 @@ pub fn rustc_short_optgroups() -> Vec<RustcOptGroup> {
                              assumed.", "[KIND=]NAME"),
         opt::multi_s("", "crate-type", "Comma separated list of types of crates
                                     for the compiler to emit",
-                   "[bin|lib|rlib|dylib|cdylib|staticlib]"),
+                   "[bin|lib|rlib|dylib|cdylib|staticlib|proc-macro]"),
         opt::opt_s("", "crate-name", "Specify the name of the crate being built",
                "NAME"),
         opt::multi_s("", "emit", "Comma separated list of types of output for \
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
@@ -1061,8 +1061,7 @@ impl<K: Clone, V: Clone> Clone for RawTable<K, V> {
     }
 }
 
-impl<K, V> Drop for RawTable<K, V> {
-    #[unsafe_destructor_blind_to_params]
+unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
     fn drop(&mut self) {
         if self.capacity == 0 {
             return;
diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
@@ -259,6 +259,15 @@ impl OsStr {
     /// Yields a `&str` slice if the `OsStr` is valid Unicode.
     ///
     /// This conversion may entail doing a check for UTF-8 validity.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::ffi::OsStr;
+    ///
+    /// let os_str = OsStr::new("foo");
+    /// assert_eq!(os_str.to_str(), Some("foo"));
+    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_str(&self) -> Option<&str> {
         self.inner.to_str()
@@ -267,6 +276,20 @@ impl OsStr {
     /// Converts an `OsStr` to a `Cow<str>`.
     ///
     /// Any non-Unicode sequences are replaced with U+FFFD REPLACEMENT CHARACTER.
+    ///
+    /// # Examples
+    ///
+    /// Calling `to_string_lossy` on an `OsStr` with valid unicode:
+    ///
+    /// ```
+    /// use std::ffi::OsStr;
+    ///
+    /// let os_str = OsStr::new("foo");
+    /// assert_eq!(os_str.to_string_lossy(), "foo");
+    /// ```
+    ///
+    /// Had `os_str` contained invalid unicode, the `to_string_lossy` call might
+    /// have returned `"fo�"`.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_string_lossy(&self) -> Cow<str> {
         self.inner.to_string_lossy()
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
@@ -250,13 +250,14 @@
 #![feature(const_fn)]
 #![feature(core_float)]
 #![feature(core_intrinsics)]
-#![feature(dropck_parametricity)]
+#![feature(dropck_eyepatch)]
 #![feature(exact_size_is_empty)]
 #![feature(float_extras)]
 #![feature(float_from_str_radix)]
 #![feature(fn_traits)]
 #![feature(fnbox)]
 #![feature(fused)]
+#![feature(generic_param_attrs)]
 #![feature(hashmap_hasher)]
 #![feature(heap_api)]
 #![feature(inclusive_range)]
diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs
@@ -52,7 +52,7 @@ pub struct TcpStream(net_imp::TcpStream);
 ///     // ...
 /// }
 ///
-/// // accept connections and process them, spawning a new thread for each one
+/// // accept connections and process them serially
 /// for stream in listener.incoming() {
 ///     match stream {
 ///         Ok(stream) => {
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
diff --git a/src/libstd/primitive_docs.rs b/src/libstd/primitive_docs.rs
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
diff --git a/src/test/incremental/hashes/trait_impls.rs b/src/test/incremental/hashes/trait_impls.rs
diff --git a/src/test/ui/custom-derive/auxiliary/plugin.rs b/src/test/ui/custom-derive/auxiliary/plugin.rs
diff --git a/src/test/ui/custom-derive/issue-36935.rs b/src/test/ui/custom-derive/issue-36935.rs
diff --git a/src/test/ui/custom-derive/issue-36935.stderr b/src/test/ui/custom-derive/issue-36935.stderr
diff --git a/src/test/ui/span/issue-27522.rs b/src/test/ui/span/issue-27522.rs
diff --git a/src/test/ui/span/issue-27522.stderr b/src/test/ui/span/issue-27522.stderr

Original file line number	Diff line number	Diff line change
`@@ -539,8 +539,7 @@ impl<T> RawVec<T> {`
`539`	`539`	`}`
`540`	`540`	`}`
`541`	`541`
`542`		`-impl<T> Drop for RawVec<T> {`
`543`		`- #[unsafe_destructor_blind_to_params]`
	`542`	`+unsafe impl<#[may_dangle] T> Drop for RawVec<T> {`
`544`	`543`	`/// Frees the memory owned by the RawVec without trying to Drop its contents.`
`545`	`544`	`fn drop(&mut self) {`
`546`	`545`	`let elem_size = mem::size_of::<T>();`
Original file line number	Diff line number	Diff line change
`@@ -137,8 +137,7 @@ pub struct BTreeMap<K, V> {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`#[stable(feature = "btree_drop", since = "1.7.0")]`
`140`		`-impl<K, V> Drop for BTreeMap<K, V> {`
`141`		`- #[unsafe_destructor_blind_to_params]`
	`140`	`+unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {`
`142`	`141`	`fn drop(&mut self) {`
`143`	`142`	`unsafe {`
`144`	`143`	`for _ in ptr::read(self).into_iter() {`
Original file line number	Diff line number	Diff line change
`@@ -726,8 +726,7 @@ impl<T> LinkedList<T> {`
`726`	`726`	`}`
`727`	`727`
`728`	`728`	`#[stable(feature = "rust1", since = "1.0.0")]`
`729`		`-impl<T> Drop for LinkedList<T> {`
`730`		`- #[unsafe_destructor_blind_to_params]`
	`729`	`+unsafe impl<#[may_dangle] T> Drop for LinkedList<T> {`
`731`	`730`	`fn drop(&mut self) {`
`732`	`731`	`while let Some(_) = self.pop_front_node() {}`
`733`	`732`	`}`