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 {}
 

library/core/src/marker.rs

@@ -1169,7 +1169,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;
 ///
@@ -1183,6 +1184,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

@@ -303,7 +303,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

@@ -43,11 +43,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

@@ -10,7 +10,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]
 

tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs

@@ -9,7 +9,7 @@
 //@ compile-flags: -Cno-prepopulate-passes -Zsanitizer=kcfi -Copt-level=0
 
 #![crate_type = "lib"]
-#![feature(arbitrary_self_types, no_core, lang_items)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
 extern crate minicore;

tests/rustdoc-json/impls/auto.rs

@@ -4,9 +4,6 @@
 #[lang = "sized"]
 trait Sized {}
 
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
-
 pub auto trait Bar {}
 
 /// has span
@@ -15,8 +12,8 @@ impl Foo {
 }
 
 // Testing spans, so all tests below code
-//@ is "$.index[*][?(@.docs=='has span')].span.begin" "[13, 0]"
-//@ is "$.index[*][?(@.docs=='has span')].span.end" "[15, 1]"
+//@ is "$.index[*][?(@.docs=='has span')].span.begin" "[10, 0]"
+//@ is "$.index[*][?(@.docs=='has span')].span.end" "[12, 1]"
 // FIXME: this doesn't work due to https://github.com/freestrings/jsonpath/issues/91
 // is "$.index[*][?(@.inner.impl.is_synthetic==true)].span" null
 pub struct Foo;

tests/ui/async-await/inference_var_self_argument.stderr

@@ -4,8 +4,8 @@ error[E0307]: invalid `self` parameter type: `&dyn Foo`
 LL |     async fn foo(self: &dyn Foo) {
    |                        ^^^^^^^^
    |
-   = note: type of `self` must be `Self` or a type that dereferences to it
-   = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+   = note: type of `self` must be `Self` or some type implementing `Receiver`
+   = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error[E0038]: the trait `Foo` is not dyn compatible
   --> $DIR/inference_var_self_argument.rs:5:5

tests/ui/async-await/issue-66312.stderr

@@ -4,8 +4,8 @@ error[E0307]: invalid `self` parameter type: `T`
 LL |     fn is_some(self: T);
    |                      ^
    |
-   = note: type of `self` must be `Self` or a type that dereferences to it
-   = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+   = note: type of `self` must be `Self` or some type implementing `Receiver`
+   = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error[E0308]: mismatched types
   --> $DIR/issue-66312.rs:9:8

tests/ui/async-await/issues/issue-53249.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2018
 
-#![feature(arbitrary_self_types)]
-
 use std::task::{self, Poll};
 use std::future::Future;
 use std::marker::Unpin;

tests/ui/deriving/deriving-coerce-pointee-neg.rs

@@ -1,5 +1,5 @@
 //@ proc-macro: malicious-macro.rs
-#![feature(derive_coerce_pointee, arbitrary_self_types)]
+#![feature(derive_coerce_pointee)]
 
 extern crate core;
 extern crate malicious_macro;

tests/ui/deriving/deriving-coerce-pointee.rs

@@ -1,5 +1,5 @@
 //@ run-pass
-#![feature(derive_coerce_pointee, arbitrary_self_types)]
+#![feature(derive_coerce_pointee)]
 
 use std::marker::CoercePointee;
 

tests/ui/feature-gates/feature-gate-arbitrary-self-types-pointers.feature.stderr

@@ -1,6 +1,3 @@
-//@ revisions: default feature
-#![cfg_attr(feature, feature(arbitrary_self_types))]
-
 trait Foo {
     fn foo(self: *const Self); //~ ERROR `*const Self` cannot be used as the type of `self`
 }

tests/ui/feature-gates/feature-gate-arbitrary-self-types-pointers.rs

@@ -1,5 +1,5 @@
 error[E0658]: `*const Bar` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
-  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:11:18
+  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:8:18
    |
 LL |     fn foo(self: *const Self) {}
    |                  ^^^^^^^^^^^
@@ -10,7 +10,7 @@ LL |     fn foo(self: *const Self) {}
    = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error[E0658]: `*mut Bar` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
-  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:15:18
+  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:12:18
    |
 LL |     fn bar(self: *mut Self) {}
    |                  ^^^^^^^^^
@@ -21,7 +21,7 @@ LL |     fn bar(self: *mut Self) {}
    = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error[E0658]: `*const Self` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
-  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:5:18
+  --> $DIR/feature-gate-arbitrary-self-types-pointers.rs:2:18
    |
 LL |     fn foo(self: *const Self);
    |                  ^^^^^^^^^^^

tests/ui/feature-gates/feature-gate-arbitrary-self-types-pointers.default.stderr tests/ui/feature-gates/feature-gate-arbitrary-self-types-pointers.stderr

@@ -4,8 +4,8 @@ error[E0307]: invalid `self` parameter type: `Cell<&Self>`
 LL |     fn cell(self: Cell<&Self>);
    |                   ^^^^^^^^^^^
    |
-   = note: type of `self` must be `Self` or a type that dereferences to it
-   = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+   = note: type of `self` must be `Self` or some type implementing `Receiver`
+   = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error: aborting due to 1 previous error
 

tests/ui/feature-gates/feature-gate-arbitrary-self-types.rs

@@ -1,6 +1,6 @@
 // Check that a self parameter type requires a DispatchFromDyn impl to be dyn-compatible.
 
-#![feature(arbitrary_self_types, unsize, coerce_unsized)]
+#![feature(unsize, coerce_unsized)]
 
 use std::{
     marker::Unsize,

tests/ui/feature-gates/feature-gate-arbitrary-self-types.stderr

@@ -4,8 +4,8 @@ error[E0307]: invalid `self` parameter type: `Box<(dyn Trait + 'static)>`
 LL |     fn dyn_instead_of_self(self: Box<dyn Trait>);
    |                                  ^^^^^^^^^^^^^^
    |
-   = note: type of `self` must be `Self` or a type that dereferences to it
-   = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+   = note: type of `self` must be `Self` or some type implementing `Receiver`
+   = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 error: aborting due to 1 previous error
 

tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr

@@ -4,7 +4,7 @@
 struct Struct;
 impl Struct {
     async fn box_ref_Struct(self: Box<Self, impl FnMut(&mut Self)>) -> &u32 {
-    //~^ ERROR Box<Struct, impl FnMut(&mut Self)>` cannot be used as the type of `self` without
+        //~^ ERROR the trait bound
         &1
     }
 }

tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.rs

@@ -1,14 +1,16 @@
-error[E0658]: `Box<Struct, impl FnMut(&mut Self)>` cannot be used as the type of `self` without the `arbitrary_self_types` feature
+error[E0277]: the trait bound `impl FnMut(&mut Self): Allocator` is not satisfied
   --> $DIR/could-not-resolve-issue-121503.rs:6:35
    |
 LL |     async fn box_ref_Struct(self: Box<Self, impl FnMut(&mut Self)>) -> &u32 {
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Allocator` is not implemented for `impl FnMut(&mut Self)`
    |
-   = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
-   = help: add `#![feature(arbitrary_self_types)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-   = help: consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
+note: required by a bound in `Box`
+  --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+help: consider restricting opaque type `impl FnMut(&mut Self)` with unstable trait `Allocator`
+   |
+LL |     async fn box_ref_Struct(self: Box<Self, impl FnMut(&mut Self) + std::alloc::Allocator>) -> &u32 {
+   |                                                                   +++++++++++++++++++++++
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0658`.
+For more information about this error, try `rustc --explain E0277`.

tests/ui/issues/issue-56806.stderr

@@ -1,5 +1,4 @@
 #![deny(unused_must_use)]
-#![feature(arbitrary_self_types)]
 
 use std::iter::Iterator;
 use std::future::Future;