Update the compiler itself to use #[rustc_auto_trait]

Author: fmease

compiler/rustc_ast/src/ast.rs

@@ -2993,7 +2993,7 @@ pub enum ItemKind {
     Union(VariantData, Generics),
     /// A trait declaration (`trait`).
     ///
-    /// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`.
+    /// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }`.
     Trait(Box<Trait>),
     /// Trait alias
     ///

compiler/rustc_data_structures/src/lib.rs

@@ -9,7 +9,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![feature(array_windows)]
 #![feature(associated_type_bounds)]
-#![feature(auto_traits)]
+#![cfg_attr(bootstrap, feature(auto_traits))]
 #![feature(cell_leak)]
 #![feature(core_intrinsics)]
 #![feature(extend_one)]

compiler/rustc_data_structures/src/marker.rs

@@ -1,28 +1,57 @@
 cfg_if!(
     if #[cfg(not(parallel_compiler))] {
+        #[cfg(bootstrap)]
         pub auto trait DynSend {}
+
+        #[cfg(not(bootstrap))]
+        #[rustc_auto_trait]
+        pub trait DynSend {}
+
+        #[cfg(bootstrap)]
         pub auto trait DynSync {}
 
+        #[cfg(not(bootstrap))]
+        #[rustc_auto_trait]
+        pub trait DynSync {}
+
         impl<T> DynSend for T {}
         impl<T> DynSync for T {}
     } else {
+        #[cfg(bootstrap)]
+        #[rustc_on_unimplemented(
+            message = "`{Self}` doesn't implement `DynSend`. \
+            Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Send`"
+        )]
+        pub unsafe auto trait DynSend {}
+
+        #[cfg(not(bootstrap))]
         #[rustc_on_unimplemented(
             message = "`{Self}` doesn't implement `DynSend`. \
             Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Send`"
         )]
+        #[rustc_auto_trait]
         // This is an auto trait for types which can be sent across threads if `sync::is_dyn_thread_safe()`
         // is true. These types can be wrapped in a `FromDyn` to get a `Send` type. Wrapping a
         // `Send` type in `IntoDynSyncSend` will create a `DynSend` type.
-        pub unsafe auto trait DynSend {}
+        pub unsafe trait DynSend {}
+
+        #[cfg(bootstrap)]
+        #[rustc_on_unimplemented(
+            message = "`{Self}` doesn't implement `DynSync`. \
+            Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Sync`"
+        )]
+        pub unsafe auto trait DynSync {}
 
+        #[cfg(not(bootstrap))]
         #[rustc_on_unimplemented(
             message = "`{Self}` doesn't implement `DynSync`. \
             Add it to `rustc_data_structures::marker` or use `IntoDynSyncSend` if it's already `Sync`"
         )]
+        #[rustc_auto_trait]
         // This is an auto trait for types which can be shared across threads if `sync::is_dyn_thread_safe()`
         // is true. These types can be wrapped in a `FromDyn` to get a `Sync` type. Wrapping a
         // `Sync` type in `IntoDynSyncSend` will create a `DynSync` type.
-        pub unsafe auto trait DynSync {}
+        pub unsafe trait DynSync {}
 
         // Same with `Sync` and `Send`.
         unsafe impl<T: DynSync + ?Sized> DynSend for &T {}

compiler/rustc_data_structures/src/sync.rs

@@ -114,8 +114,17 @@ cfg_if! {
         use std::ops::Add;
         use std::cell::Cell;
 
+        #[cfg(bootstrap)]
         pub unsafe auto trait Send {}
+        #[cfg(not(bootstrap))]
+        #[rustc_auto_trait]
+        pub unsafe trait Send {}
+
+        #[cfg(bootstrap)]
         pub unsafe auto trait Sync {}
+        #[cfg(not(bootstrap))]
+        #[rustc_auto_trait]
+        pub unsafe trait Sync {}
 
         unsafe impl<T> Send for T {}
         unsafe impl<T> Sync for T {}

compiler/rustc_error_codes/src/error_codes/E0198.md

@@ -15,14 +15,12 @@ unsafe.
 
 This will compile:
 
-```ignore (ignore auto_trait future compatibility warning)
-#![feature(auto_traits)]
+```
+#![feature(negative_impls)]
 
 struct Foo;
 
-auto trait Enterprise {}
+trait Enterprise {}
 
 impl !Enterprise for Foo { }
 ```
-
-Please note that negative impls are only allowed for auto traits.

compiler/rustc_error_codes/src/error_codes/E0321.md

@@ -1,10 +1,10 @@
-A cross-crate opt-out trait was implemented on something which wasn't a struct
+A cross-crate auto trait was implemented on something which wasn't a struct
 or enum type.
 
 Erroneous code example:
 
 ```compile_fail,E0321
-#![feature(auto_traits)]
+#![feature(negative_impls)]
 
 struct Foo;
 
@@ -16,6 +16,6 @@ unsafe impl Send for &'static Foo {}
 //        `&'static Foo`
 ```
 
-Only structs and enums are permitted to impl Send, Sync, and other opt-out
+Only structs and enums are permitted to impl Send, Sync, and other auto
 trait, and the struct or enum must be local to the current crate. So, for
 example, `unsafe impl Send for Rc<Foo>` is not allowed.

compiler/rustc_error_codes/src/error_codes/E0380.md

@@ -3,7 +3,8 @@ An auto trait was declared with a method or an associated item.
 Erroneous code example:
 
 ```compile_fail,E0380
-unsafe auto trait Trait {
+#[rustc_auto_trait]
+unsafe trait Trait {
     type Output; // error!
 }
 ```

compiler/rustc_error_codes/src/error_codes/E0567.md

@@ -3,9 +3,10 @@ Generics have been used on an auto trait.
 Erroneous code example:
 
 ```compile_fail,E0567
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
-auto trait Generic<T> {} // error!
+#[rustc_auto_trait]
+trait Generic<T> {} // error!
 # fn main() {}
 ```
 
@@ -16,8 +17,9 @@ parameters.
 To fix this issue, just remove the generics:
 
 ```
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
-auto trait Generic {} // ok!
+#[rustc_auto_trait]
+trait Generic {} // ok!
 # fn main() {}
 ```

compiler/rustc_error_codes/src/error_codes/E0568.md

@@ -3,9 +3,10 @@ A super trait has been added to an auto trait.
 Erroneous code example:
 
 ```compile_fail,E0568
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
-auto trait Bound : Copy {} // error!
+#[rustc_auto_trait]
+trait Bound : Copy {} // error!
 
 fn main() {}
 ```
@@ -18,9 +19,10 @@ all the existing types could implement `Bound` because very few of them have the
 To fix this issue, just remove the super trait:
 
 ```
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
-auto trait Bound {} // ok!
+#[rustc_auto_trait]
+trait Bound {} // ok!
 
 fn main() {}
 ```

compiler/rustc_error_codes/src/error_codes/E0785.md

@@ -3,9 +3,10 @@ An inherent `impl` was written on a dyn auto trait.
 Erroneous code example:
 
 ```compile_fail,E0785
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
-auto trait AutoTrait {}
+#[rustc_auto_trait]
+trait AutoTrait {}
 
 impl dyn AutoTrait {}
 ```
@@ -20,11 +21,12 @@ trait, it cannot be implemented at all.
 Working example:
 
 ```
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 
 trait PrincipalTrait {}
 
-auto trait AutoTrait {}
+#[rustc_auto_trait]
+trait AutoTrait {}
 
 impl dyn PrincipalTrait + AutoTrait + Send {}
 ```

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -71,7 +71,8 @@ fn do_orphan_check_impl<'tcx>(
     //
     // ```
     // // Crate A
-    // auto trait Foo { }
+    // #[rustc_auto_trait]
+    // trait Foo { }
     // fn two_foos<A:Foo,B:Foo>(..) {
     //     one_foo::<(A,B)>(..)
     // }
@@ -127,7 +128,8 @@ fn do_orphan_check_impl<'tcx>(
         // This is necessary in order for autotrait bounds on methods of trait
         // objects to be sound.
         //
-        //     auto trait AutoTrait {}
+        //     #[rustc_auto_trait]
+        //     trait AutoTrait {}
         //
         //     trait ObjectSafeTrait {
         //         fn f(&self) where Self: AutoTrait;

compiler/rustc_middle/src/traits/mod.rs

@@ -160,21 +160,17 @@ impl<'tcx> ObligationCause<'tcx> {
         self.code = f(std::mem::take(&mut self.code)).into();
     }
 
+    /// Creates a cause for obligations that are derived from `obligation` by a recursive search.
+    ///
+    /// E.g., for a builtin bound, or eventually a `#[rustc_auto_trait] trait Foo`.
+    /// If `obligation` is itself a derived obligation, this is just a clone, but
+    /// otherwise we create a "derived obligation" cause so as to keep track of the
+    /// original root obligation for error reporting.
     pub fn derived_cause(
         mut self,
         parent_trait_pred: ty::PolyTraitPredicate<'tcx>,
         variant: impl FnOnce(DerivedObligationCause<'tcx>) -> ObligationCauseCode<'tcx>,
     ) -> ObligationCause<'tcx> {
-        /*!
-         * Creates a cause for obligations that are derived from
-         * `obligation` by a recursive search (e.g., for a builtin
-         * bound, or eventually a `auto trait Foo`). If `obligation`
-         * is itself a derived obligation, this is just a clone, but
-         * otherwise we create a "derived obligation" cause so as to
-         * keep track of the original root obligation for error
-         * reporting.
-         */
-
         // NOTE(flaper87): As of now, it keeps track of the whole error
         // chain. Ideally, we should have a way to configure this either
         // by using -Z verbose or just a CLI argument.

compiler/rustc_trait_selection/src/traits/object_safety.rs

@@ -561,7 +561,8 @@ fn virtual_call_violation_for_method<'tcx>(
 
         // dyn Trait is okay:
         //
-        //     auto trait AutoTrait {}
+        //     #[rustc_auto_trait]
+        //     trait AutoTrait {}
         //
         //     trait Trait {
         //         fn f(&self) where Self: AutoTrait;
@@ -580,7 +581,7 @@ fn virtual_call_violation_for_method<'tcx>(
             && tcx.trait_is_auto(pred_trait_ref.def_id)
         {
             // Consider bounds like `Self: Bound<Self>`. Auto traits are not
-            // allowed to have generic parameters so `auto trait Bound<T> {}`
+            // allowed to have generic parameters so `#[rustc_auto_trait] trait Bound<T> {}`
             // would already have reported an error at the definition of the
             // auto trait.
             if pred_trait_ref.args.len() != 1 {

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -354,7 +354,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         Ok(fully_flattened)
     }
 
-    /// This handles the case where an `auto trait Foo` impl is being used.
+    /// This handles the case where an auto trait `Foo` impl is being used.
     /// The idea is that the impl applies to `X : Foo` if the following conditions are met:
     ///
     /// 1. For each constituent type `Y` in `X`, `Y : Foo` holds