Introduce #[rustc_auto_trait]

fmease · fmease · commit f7a12f573890 · 2023-10-03T19:23:10.000+02:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -443,7 +443,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     items: new_impl_items,
                 }))
             }
-            ItemKind::Trait(box Trait { is_auto, unsafety, generics, bounds, items }) => {
+            // We intentionally ignore `is_auto` since `auto` is now meaningless.
+            ItemKind::Trait(box Trait { is_auto: _, unsafety, generics, bounds, items }) => {
+                let is_auto =
+                    if attrs.unwrap_or(&[]).iter().any(|attr| attr.has_name(sym::rustc_auto_trait))
+                    {
+                        IsAuto::Yes
+                    } else {
+                        IsAuto::No
+                    };
                 // FIXME(const_trait_impl, effects, fee1-dead) this should be simplified if possible
                 let constness = attrs
                     .unwrap_or(&[])
@@ -467,7 +475,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (unsafety, items, bounds)
                     },
                 );
-                hir::ItemKind::Trait(*is_auto, unsafety, generics, bounds, items)
+                hir::ItemKind::Trait(is_auto, unsafety, generics, bounds, items)
             }
             ItemKind::TraitAlias(generics, bounds) => {
                 let (generics, bounds) = self.lower_generics(
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
@@ -184,8 +184,8 @@ ast_passes_nested_lifetimes = nested quantification of lifetimes
 
 ast_passes_nomangle_ascii = `#[no_mangle]` requires ASCII identifier
 
-ast_passes_obsolete_auto = `impl Trait for .. {"{}"}` is an obsolete syntax
-    .help = use `auto trait Trait {"{}"}` instead
+ast_passes_obsolete_auto_syntax = `{$syntax}` is an obsolete syntax for auto traits
+    .help = use `#[rustc_auto_trait] trait Trait {"{}"}` instead
 
 ast_passes_optional_const_exclusive = `~const` and `{$modifier}` are mutually exclusive
 
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -810,7 +810,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                         errors::VisibilityNotPermittedNote::TraitImpl,
                     );
                     if let TyKind::Err = self_ty.kind {
-                        this.err_handler().emit_err(errors::ObsoleteAuto { span: item.span });
+                        this.err_handler().emit_err(errors::ObsoleteAutoSyntax {
+                            span: item.span,
+                            syntax: "impl Trait for .. {}",
+                        });
                     }
                     if let (&Unsafe::Yes(span), &ImplPolarity::Negative(sp)) = (unsafety, polarity)
                     {
@@ -941,15 +944,16 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     }
                 }
             }
-            ItemKind::Trait(box Trait { is_auto, generics, bounds, items, .. }) => {
+            // We intentionally ignore `is_auto` since `auto` is now meaningless.
+            ItemKind::Trait(box Trait { is_auto: _, generics, bounds, items, .. }) => {
                 let is_const_trait = attr::contains_name(&item.attrs, sym::const_trait);
                 self.with_in_trait(is_const_trait, |this| {
-                    if *is_auto == IsAuto::Yes {
+                    if attr::contains_name(&item.attrs, sym::rustc_auto_trait) {
                         // Auto traits cannot have generics, super traits nor contain items.
-                        this.deny_generic_params(generics, item.ident.span);
-                        this.deny_super_traits(bounds, item.ident.span);
-                        this.deny_where_clause(&generics.where_clause, item.ident.span);
-                        this.deny_items(items, item.ident.span);
+                        self.deny_generic_params(generics, item.ident.span);
+                        self.deny_super_traits(bounds, item.ident.span);
+                        self.deny_where_clause(&generics.where_clause, item.ident.span);
+                        self.deny_items(items, item.ident.span);
                     }
 
                     // Equivalent of `visit::walk_item` for `ItemKind::Trait` that inserts a bound
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
@@ -417,11 +417,12 @@ pub struct OutOfOrderParams<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_passes_obsolete_auto)]
+#[diag(ast_passes_obsolete_auto_syntax)]
 #[help]
-pub struct ObsoleteAuto {
+pub struct ObsoleteAutoSyntax {
     #[primary_span]
     pub span: Span,
+    pub syntax: &'static str,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -298,12 +298,11 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             }
 
             ast::ItemKind::Trait(box ast::Trait { is_auto: ast::IsAuto::Yes, .. }) => {
-                gate_feature_post!(
-                    &self,
-                    auto_traits,
-                    i.span,
-                    "auto traits are experimental and possibly buggy"
-                );
+                // FIXME: Consider using a structured suggestion.
+                self.sess.emit_err(errors::ObsoleteAutoSyntax {
+                    span: i.span,
+                    syntax: "auto trait Trait {}",
+                });
             }
 
             ast::ItemKind::TraitAlias(..) => {
diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
@@ -223,9 +223,6 @@ declare_features! (
     // feature-group-start: internal feature gates
     // -------------------------------------------------------------------------
 
-    /// Allows features specific to auto traits.
-    /// Renamed from `optin_builtin_traits`.
-    (active, auto_traits, "1.50.0", Some(13231), None),
     /// Allows using `box` in patterns (RFC 469).
     (active, box_patterns, "1.0.0", Some(29641), None),
     /// Allows `#[doc(notable_trait)]`.
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -550,6 +550,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         may_dangle, Normal, template!(Word), WarnFollowing, dropck_eyepatch,
         "`may_dangle` has unstable semantics and may be removed in the future",
     ),
+    rustc_attr!(
+        rustc_auto_trait, Normal, template!(Word), WarnFollowing,
+        "`#[rustc_auto_trait]` is used to mark auto traits, only intended to be used in `core`",
+    ),
 
     // ==========================================================================
     // Internal attributes: Runtime related:
@@ -712,7 +716,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     rustc_attr!(
         rustc_coinductive, AttributeType::Normal, template!(Word), WarnFollowing, @only_local: true,
-        "#![rustc_coinductive] changes a trait to be coinductive, allowing cycles in the trait solver."
+        "#[rustc_coinductive] changes a trait to be coinductive, allowing cycles in the trait solver."
     ),
     rustc_attr!(
         rustc_allow_incoherent_impl, AttributeType::Normal, template!(Word), ErrorFollowing, @only_local: true,
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
@@ -50,6 +50,9 @@ declare_features! (
     (removed, allocator, "1.0.0", None, None, None),
     /// Allows a test to fail without failing the whole suite.
     (removed, allow_fail, "1.19.0", Some(46488), None, Some("removed due to no clear use cases")),
+    /// Allows features specific to auto traits.
+    /// Renamed from `optin_builtin_traits`.
+    (removed, auto_traits, "1.50.0", Some(13231), None, Some("removed in favor of `#[rustc_auto_trait]`")),
     (removed, await_macro, "1.38.0", Some(50547), None,
      Some("subsumed by `.await` syntax")),
     /// Allows using the `box $expr` syntax.
@@ -147,9 +150,8 @@ declare_features! (
     /// A way to temporarily opt out of opt-in copy. This will *never* be accepted.
     (removed, opt_out_copy, "1.0.0", None, None, None),
     /// Allows features specific to OIBIT (now called auto traits).
-    /// Renamed to `auto_traits`.
-    (removed, optin_builtin_traits, "1.0.0", Some(13231), None,
-     Some("renamed to `auto_traits`")),
+    /// Renamed to `auto_traits` which has then been removed in favor of `rustc_attrs`.
+    (removed, optin_builtin_traits, "1.0.0", Some(13231), None, Some("removed in favor of `#[rustc_auto_trait]`")),
     /// Allows overlapping impls of marker traits.
     (removed, overlapping_marker_traits, "1.42.0", Some(29864), None,
      Some("removed in favor of `#![feature(marker_trait_attr)]`")),
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -167,10 +167,13 @@ impl CheckAttrVisitor<'_> {
                 | sym::rustc_dirty
                 | sym::rustc_if_this_changed
                 | sym::rustc_then_this_would_need => self.check_rustc_dirty_clean(&attr),
-                sym::rustc_coinductive
-                | sym::rustc_must_implement_one_of
+                sym::const_trait
+                | sym::rustc_auto_trait
+                | sym::rustc_coinductive
                 | sym::rustc_deny_explicit_impl
-                | sym::const_trait => self.check_must_be_applied_to_trait(&attr, span, target),
+                | sym::rustc_must_implement_one_of => {
+                    self.check_must_be_applied_to_trait(&attr, span, target)
+                }
                 sym::cmse_nonsecure_entry => {
                     self.check_cmse_nonsecure_entry(hir_id, attr, span, target)
                 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -1291,6 +1291,7 @@ symbols! {
         rustc_allow_incoherent_impl,
         rustc_allowed_through_unstable_modules,
         rustc_attrs,
+        rustc_auto_trait,
         rustc_box,
         rustc_builtin_macro,
         rustc_capture_analysis,
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
@@ -196,14 +196,14 @@
 //
 // Language features:
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(auto_traits))]
 #![cfg_attr(not(bootstrap), feature(effects))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]
 #![feature(allow_internal_unstable)]
 #![feature(asm_const)]
 #![feature(associated_type_bounds)]
-#![feature(auto_traits)]
 #![feature(c_unwind)]
 #![feature(cfg_sanitize)]
 #![feature(cfg_target_has_atomic)]
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
@@ -56,6 +56,12 @@ macro marker_impls {
     ( $(#[$($meta:tt)*])* unsafe $Trait:ident for ) => {},
 }
 
+#[cfg(bootstrap)]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
+#[allow(missing_docs)]
+pub unsafe auto trait Send {}
+
 /// Types that can be transferred across thread boundaries.
 ///
 /// This trait is automatically implemented when the compiler determines it's
@@ -73,13 +79,15 @@ macro marker_impls {
 /// [`Rc`]: ../../std/rc/struct.Rc.html
 /// [arc]: ../../std/sync/struct.Arc.html
 /// [ub]: ../../reference/behavior-considered-undefined.html
+#[cfg(not(bootstrap))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Send")]
 #[rustc_on_unimplemented(
     message = "`{Self}` cannot be sent between threads safely",
     label = "`{Self}` cannot be sent between threads safely"
 )]
-pub unsafe auto trait Send {
+#[rustc_auto_trait]
+pub unsafe trait Send {
     // empty.
 }
 
@@ -498,6 +506,13 @@ impl Copy for ! {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Copy for &T {}
 
+#[cfg(bootstrap)]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "Sync")]
+#[lang = "sync"]
+#[allow(missing_docs)]
+pub unsafe auto trait Sync {}
+
 /// Types for which it is safe to share references between threads.
 ///
 /// This trait is automatically implemented when the compiler determines
@@ -568,6 +583,7 @@ impl<T: ?Sized> Copy for &T {}
 /// [ub]: ../../reference/behavior-considered-undefined.html
 /// [transmute]: crate::mem::transmute
 /// [nomicon-send-and-sync]: ../../nomicon/send-and-sync.html
+#[cfg(not(bootstrap))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Sync")]
 #[lang = "sync"]
@@ -631,7 +647,8 @@ impl<T: ?Sized> Copy for &T {}
     message = "`{Self}` cannot be shared between threads safely",
     label = "`{Self}` cannot be shared between threads safely"
 )]
-pub unsafe auto trait Sync {
+#[rustc_auto_trait]
+pub unsafe trait Sync {
     // FIXME(estebank): once support to add notes in `rustc_on_unimplemented`
     // lands in beta, and it has been extended to check whether a closure is
     // anywhere in the requirement chain, extend it as such (#48534):
@@ -862,12 +879,18 @@ pub trait DiscriminantKind {
     type Discriminant: Clone + Copy + Debug + Eq + PartialEq + Hash + Send + Sync + Unpin;
 }
 
+#[cfg(bootstrap)]
+#[lang = "freeze"]
+pub(crate) unsafe auto trait Freeze {}
+
 /// Compiler-internal trait used to determine whether a type contains
 /// any `UnsafeCell` internally, but not through an indirection.
 /// This affects, for example, whether a `static` of that type is
 /// placed in read-only static memory or writable static memory.
+#[cfg(not(bootstrap))]
 #[lang = "freeze"]
-pub(crate) unsafe auto trait Freeze {}
+#[rustc_auto_trait]
+pub(crate) unsafe trait Freeze {}
 
 impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
 marker_impls! {
@@ -879,6 +902,12 @@ marker_impls! {
         {T: ?Sized} &mut T,
 }
 
+#[cfg(bootstrap)]
+#[stable(feature = "pin", since = "1.33.0")]
+#[lang = "unpin"]
+#[allow(missing_docs)]
+pub auto trait Unpin {}
+
 /// Types that can be safely moved after being pinned.
 ///
 /// Rust itself has no notion of immovable types, and considers moves (e.g.,
@@ -920,13 +949,15 @@ marker_impls! {
 /// [`mem::replace`]: crate::mem::replace
 /// [Pin]: crate::pin::Pin
 /// [`pin` module]: crate::pin
+#[cfg(not(bootstrap))]
 #[stable(feature = "pin", since = "1.33.0")]
 #[rustc_on_unimplemented(
     note = "consider using the `pin!` macro\nconsider using `Box::pin` if you need to access the pinned value outside of the current scope",
     message = "`{Self}` cannot be unpinned"
 )]
 #[lang = "unpin"]
-pub auto trait Unpin {}
+#[rustc_auto_trait]
+pub trait Unpin {}
 
 /// A marker type which does not implement `Unpin`.
 ///
diff --git a/library/core/src/panic/unwind_safe.rs b/library/core/src/panic/unwind_safe.rs
@@ -7,6 +7,12 @@ use crate::pin::Pin;
 use crate::ptr::{NonNull, Unique};
 use crate::task::{Context, Poll};
 
+#[cfg(bootstrap)]
+#[stable(feature = "catch_unwind", since = "1.9.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "unwind_safe_trait")]
+#[allow(missing_docs)]
+pub auto trait UnwindSafe {}
+
 /// A marker trait which represents "panic safe" types in Rust.
 ///
 /// This trait is implemented by default for many types and behaves similarly in
@@ -81,13 +87,21 @@ use crate::task::{Context, Poll};
 /// above, the lack of `unsafe` means it is mostly an advisory. The
 /// [`AssertUnwindSafe`] wrapper struct can be used to force this trait to be
 /// implemented for any closed over variables passed to `catch_unwind`.
+#[cfg(not(bootstrap))]
 #[stable(feature = "catch_unwind", since = "1.9.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "unwind_safe_trait")]
 #[rustc_on_unimplemented(
     message = "the type `{Self}` may not be safely transferred across an unwind boundary",
     label = "`{Self}` may not be safely transferred across an unwind boundary"
 )]
-pub auto trait UnwindSafe {}
+#[rustc_auto_trait]
+pub trait UnwindSafe {}
+
+#[cfg(bootstrap)]
+#[stable(feature = "catch_unwind", since = "1.9.0")]
+#[cfg_attr(not(test), rustc_diagnostic_item = "ref_unwind_safe_trait")]
+#[allow(missing_docs)]
+pub auto trait RefUnwindSafe {}
 
 /// A marker trait representing types where a shared reference is considered
 /// unwind safe.
@@ -97,6 +111,7 @@ pub auto trait UnwindSafe {}
 ///
 /// This is a "helper marker trait" used to provide impl blocks for the
 /// [`UnwindSafe`] trait, for more information see that documentation.
+#[cfg(not(bootstrap))]
 #[stable(feature = "catch_unwind", since = "1.9.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "ref_unwind_safe_trait")]
 #[rustc_on_unimplemented(
@@ -105,7 +120,8 @@ pub auto trait UnwindSafe {}
     label = "`{Self}` may contain interior mutability and a reference may not be safely \
              transferrable across a catch_unwind boundary"
 )]
-pub auto trait RefUnwindSafe {}
+#[rustc_auto_trait]
+pub trait RefUnwindSafe {}
 
 /// A simple wrapper around a type to assert that it is unwind safe.
 ///
diff --git a/library/rtstartup/rsbegin.rs b/library/rtstartup/rsbegin.rs
@@ -14,19 +14,21 @@
 
 #![feature(no_core)]
 #![feature(lang_items)]
-#![feature(auto_traits)]
+#![feature(rustc_attrs)]
 #![crate_type = "rlib"]
 #![no_core]
-#![allow(non_camel_case_types)]
+#![allow(internal_features, non_camel_case_types)]
 
 #[lang = "sized"]
 trait Sized {}
 #[lang = "sync"]
-auto trait Sync {}
+#[rustc_auto_trait]
+trait Sync {}
 #[lang = "copy"]
 trait Copy {}
 #[lang = "freeze"]
-auto trait Freeze {}
+#[rustc_auto_trait]
+trait Freeze {}
 
 #[lang = "drop_in_place"]
 #[inline]
diff --git a/library/rtstartup/rsend.rs b/library/rtstartup/rsend.rs

Original file line number	Diff line number	Diff line change
`@@ -810,7 +810,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`810`	`810`	`errors::VisibilityNotPermittedNote::TraitImpl,`
`811`	`811`	`);`
`812`	`812`	`if let TyKind::Err = self_ty.kind {`
`813`		`- this.err_handler().emit_err(errors::ObsoleteAuto { span: item.span });`
	`813`	`+ this.err_handler().emit_err(errors::ObsoleteAutoSyntax {`
	`814`	`+ span: item.span,`
	`815`	`+ syntax: "impl Trait for .. {}",`
	`816`	`+ });`
`814`	`817`	`}`
`815`	`818`	`if let (&Unsafe::Yes(span), &ImplPolarity::Negative(sp)) = (unsafety, polarity)`
`816`	`819`	`{`
`@@ -941,15 +944,16 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`941`	`944`	`}`
`942`	`945`	`}`
`943`	`946`	`}`
`944`		`- ItemKind::Trait(box Trait { is_auto, generics, bounds, items, .. }) => {`
	`947`	+ // We intentionally ignore `is_auto` since `auto` is now meaningless.
	`948`	`+ ItemKind::Trait(box Trait { is_auto: _, generics, bounds, items, .. }) => {`
`945`	`949`	`let is_const_trait = attr::contains_name(&item.attrs, sym::const_trait);`
`946`	`950`	`self.with_in_trait(is_const_trait, \|this\| {`
`947`		`- if *is_auto == IsAuto::Yes {`
	`951`	`+ if attr::contains_name(&item.attrs, sym::rustc_auto_trait) {`
`948`	`952`	`// Auto traits cannot have generics, super traits nor contain items.`
`949`		`- this.deny_generic_params(generics, item.ident.span);`
`950`		`- this.deny_super_traits(bounds, item.ident.span);`
`951`		`- this.deny_where_clause(&generics.where_clause, item.ident.span);`
`952`		`- this.deny_items(items, item.ident.span);`
	`953`	`+ self.deny_generic_params(generics, item.ident.span);`
	`954`	`+ self.deny_super_traits(bounds, item.ident.span);`
	`955`	`+ self.deny_where_clause(&generics.where_clause, item.ident.span);`
	`956`	`+ self.deny_items(items, item.ident.span);`
`953`	`957`	`}`
`954`	`958`
`955`	`959`	// Equivalent of `visit::walk_item` for `ItemKind::Trait` that inserts a bound
Original file line number	Diff line number	Diff line change
`@@ -417,11 +417,12 @@ pub struct OutOfOrderParams<'a> {`
`417`	`417`	`}`
`418`	`418`
`419`	`419`	`#[derive(Diagnostic)]`
`420`		`-#[diag(ast_passes_obsolete_auto)]`
	`420`	`+#[diag(ast_passes_obsolete_auto_syntax)]`
`421`	`421`	`#[help]`
`422`		`-pub struct ObsoleteAuto {`
	`422`	`+pub struct ObsoleteAutoSyntax {`
`423`	`423`	`#[primary_span]`
`424`	`424`	`pub span: Span,`
	`425`	`+ pub syntax: &'static str,`
`425`	`426`	`}`
`426`	`427`
`427`	`428`	`#[derive(Diagnostic)]`