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_ast_passes/src/ast_validation.rs

@@ -935,7 +935,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     }
                 }
             }
-            // We intentionally ignore `is_auto` since `auto trait` is now meaningless.
+            // We intentionally ignore `is_auto` since `auto` is now meaningless.
             ItemKind::Trait(box Trait { is_auto: _, generics, bounds, items, .. }) => {
                 if attr::contains_name(&item.attrs, sym::rustc_auto_trait) {
                     // Auto traits cannot have generics, super traits nor contain items.

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

@@ -20,7 +20,8 @@ This will compile:
 
 struct Foo;
 
-auto trait Enterprise {}
+#[rustc_auto_trait]
+trait Enterprise {}
 
 impl !Enterprise for Foo { }
 ```

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

@@ -5,7 +5,8 @@ Erroneous code example:
 ```compile_fail,E0567
 #![feature(auto_traits)]
 
-auto trait Generic<T> {} // error!
+#[rustc_auto_trait]
+trait Generic<T> {} // error!
 # fn main() {}
 ```
 
@@ -18,6 +19,7 @@ To fix this issue, just remove the generics:
 ```
 #![feature(auto_traits)]
 
-auto trait Generic {} // ok!
+#[rustc_auto_trait]
+trait Generic {} // ok!
 # fn main() {}
 ```

compiler/rustc_error_codes/src/error_codes/E0568.md

@@ -5,7 +5,8 @@ Erroneous code example:
 ```compile_fail,E0568
 #![feature(auto_traits)]
 
-auto trait Bound : Copy {} // error!
+#[rustc_auto_trait]
+trait Bound : Copy {} // error!
 
 fn main() {}
 ```
@@ -20,7 +21,8 @@ To fix this issue, just remove the super trait:
 ```
 #![feature(auto_traits)]
 
-auto trait Bound {} // ok!
+#[rustc_auto_trait]
+trait Bound {} // ok!
 
 fn main() {}
 ```

compiler/rustc_error_codes/src/error_codes/E0785.md

@@ -5,7 +5,8 @@ Erroneous code example:
 ```compile_fail,E0785
 #![feature(auto_traits)]
 
-auto trait AutoTrait {}
+#[rustc_auto_trait]
+trait AutoTrait {}
 
 impl dyn AutoTrait {}
 ```
@@ -24,7 +25,8 @@ Working example:
 
 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;