Arbitrary self types v2: stabilize test changes

All the test changes necessary for stabilization here.

Author: adetaylor

compiler/rustc_codegen_cranelift/example/arbitrary_self_types_pointers_and_wrappers.rs

@@ -1,6 +1,6 @@
 // Adapted from rustc run-pass test suite
 
-#![feature(arbitrary_self_types, unsize, coerce_unsized, dispatch_from_dyn)]
+#![feature(unsize, coerce_unsized, dispatch_from_dyn)]
 
 use std::marker::Unsize;
 use std::ops::{CoerceUnsized, Deref, DispatchFromDyn};

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -47,13 +47,6 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<*const U> for *const T {}
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<*mut U> for *mut T {}
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T> {}
 
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
-
-impl<T: ?Sized> LegacyReceiver for &T {}
-impl<T: ?Sized> LegacyReceiver for &mut T {}
-impl<T: ?Sized> LegacyReceiver for Box<T> {}
-
 #[lang = "copy"]
 pub trait Copy {}
 

compiler/rustc_codegen_gcc/example/arbitrary_self_types_pointers_and_wrappers.rs

@@ -1,6 +1,6 @@
 // Adapted from rustc run-pass test suite
 
-#![feature(arbitrary_self_types, unsize, coerce_unsized, dispatch_from_dyn)]
+#![feature(unsize, coerce_unsized, dispatch_from_dyn)]
 #![feature(rustc_attrs)]
 #![allow(internal_features)]
 

compiler/rustc_codegen_gcc/example/mini_core.rs

@@ -44,13 +44,6 @@ impl<T: ?Sized+Unsize<U>, U: ?Sized> DispatchFromDyn<*const U> for *const T {}
 impl<T: ?Sized+Unsize<U>, U: ?Sized> DispatchFromDyn<*mut U> for *mut T {}
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U, ()>> for Box<T, ()> {}
 
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
-
-impl<T: ?Sized> LegacyReceiver for &T {}
-impl<T: ?Sized> LegacyReceiver for &mut T {}
-impl<T: ?Sized, A: Allocator> LegacyReceiver for Box<T, A> {}
-
 #[lang = "copy"]
 pub trait Copy {}
 

compiler/rustc_lint_defs/src/builtin.rs

@@ -4844,8 +4844,6 @@ declare_lint! {
     /// UB in safe code afterwards. For example:
     ///
     /// ```ignore (causes a warning)
-    /// #![feature(arbitrary_self_types)]
-    ///
     /// trait Trait {
     ///     fn f(self: *const Self)
     ///     where

library/core/src/marker.rs

@@ -1152,7 +1152,8 @@ pub trait FnPtr: Copy + Clone {
 /// type as a receiver are dyn-compatible. For example, this compiles:
 ///
 /// ```
-/// #![feature(arbitrary_self_types, derive_coerce_pointee)]
+/// #![feature(derive_coerce_pointee)]
+/// # #![cfg_attr(bootstrap, feature(legacy_receiver_trait))]
 /// use std::marker::CoercePointee;
 /// use std::ops::Deref;
 ///
@@ -1166,6 +1167,9 @@ pub trait FnPtr: Copy + Clone {
 ///         &self.0
 ///     }
 /// }
+/// #
+/// # #[cfg(bootstrap)]
+/// # impl<T: ?Sized> core::ops::LegacyReceiver for MySmartPointer<T> {}
 ///
 /// // You can always define this trait. (as long as you have #![feature(arbitrary_self_types)])
 /// trait MyTrait {

library/core/src/ops/deref.rs

@@ -300,7 +300,7 @@ unsafe impl<T: ?Sized> DerefPure for &mut T {}
 
 /// Indicates that a struct can be used as a method receiver.
 /// That is, a type can use this type as a type of `self`, like this:
-/// ```compile_fail
+/// ```
 /// # // This is currently compile_fail because the compiler-side parts
 /// # // of arbitrary_self_types are not implemented
 /// use std::ops::Receiver;

src/doc/unstable-book/src/language-features/coroutines.md

@@ -89,7 +89,7 @@ Feedback on the design and usage is always appreciated!
 The `Coroutine` trait in `std::ops` currently looks like:
 
 ```rust
-# #![feature(arbitrary_self_types, coroutine_trait)]
+# #![feature(coroutine_trait)]
 # use std::ops::CoroutineState;
 # use std::pin::Pin;
 
@@ -184,7 +184,7 @@ fn main() {
 This coroutine literal will compile down to something similar to:
 
 ```rust
-#![feature(arbitrary_self_types, coroutine_trait)]
+#![feature(coroutine_trait)]
 
 use std::ops::{Coroutine, CoroutineState};
 use std::pin::Pin;

tests/auxiliary/minicore.rs

@@ -31,11 +31,6 @@ macro_rules! impl_marker_trait {
 #[lang = "sized"]
 pub trait Sized {}
 
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
-impl<T: ?Sized> LegacyReceiver for &T {}
-impl<T: ?Sized> LegacyReceiver for &mut T {}
-
 #[lang = "copy"]
 pub trait Copy: Sized {}
 

tests/codegen/avr/avr-func-addrspace.rs

@@ -9,7 +9,7 @@
 // It also validates that functions can be called through function pointers
 // through traits.
 
-#![feature(no_core, lang_items, intrinsics, unboxed_closures, arbitrary_self_types)]
+#![feature(no_core, lang_items, intrinsics, unboxed_closures)]
 #![crate_type = "lib"]
 #![no_core]
 
@@ -18,8 +18,6 @@ pub trait Sized {}
 #[lang = "copy"]
 pub trait Copy {}
 impl<T: ?Sized> Copy for *const T {}
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
 #[lang = "tuple_trait"]
 pub trait Tuple {}