Introduce #[rustc_auto_trait]

fmease · fmease · commit cfda2a3fa7b9 · 2023-09-25T00:02:16.000+02:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -443,10 +443,16 @@ 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 trait` is now meaningless.
+            ItemKind::Trait(box Trait { is_auto: _, unsafety, generics, bounds, items }) => {
+                let attrs = attrs.unwrap_or(&[]);
+                let is_auto = if attrs.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(&[])
                     .iter()
                     .find(|x| x.has_name(sym::const_trait))
                     .map_or(Const::No, |x| Const::Yes(x.span));
@@ -467,7 +473,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
@@ -801,7 +801,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)
                     {
@@ -932,8 +935,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     }
                 }
             }
-            ItemKind::Trait(box Trait { is_auto, generics, bounds, items, .. }) => {
-                if *is_auto == IsAuto::Yes {
+            // We intentionally ignore `is_auto` since `auto trait` 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.
                     self.deny_generic_params(generics, item.ident.span);
                     self.deny_super_traits(bounds, item.ident.span);
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: Considering 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
@@ -225,7 +225,7 @@ declare_features! (
 
     /// Allows features specific to auto traits.
     /// Renamed from `optin_builtin_traits`.
-    (active, auto_traits, "1.50.0", Some(13231), None),
+    (internal, 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
@@ -551,6 +551,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",
     ),
+    gated!(
+        rustc_auto_trait, Normal, template!(Word), WarnFollowing, auto_traits,
+        "#[rustc_auto_trait] is used to mark auto traits, only intended to be used in `core`"
+    ),
 
     // ==========================================================================
     // Internal attributes: Runtime related:
@@ -709,7 +713,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_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -893,6 +893,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::AdtDef<'_> {
 fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir().expect_item(def_id);
 
+    // FIXME: Maybe check `tcx.has_attr(def_id, sym::rustc_auto_trait)` **here**!
     let (is_auto, unsafety, items) = match item.kind {
         hir::ItemKind::Trait(is_auto, unsafety, .., items) => {
             (is_auto == hir::IsAuto::Yes, unsafety, items)
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -805,7 +805,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         entry.1.insert((self_ty.span, ""));
                     }
                     Some(Node::Item(hir::Item {
-                        kind: hir::ItemKind::Trait(rustc_ast::ast::IsAuto::Yes, ..),
+                        kind: hir::ItemKind::Trait(rustc_hir::IsAuto::Yes, ..),
                         span: item_span,
                         ..
                     })) => {
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 // FIXME: does this correctly reject trait *aliases*?
+                | 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
@@ -94,6 +94,7 @@ symbols! {
         StaticLifetime:     "'static",
 
         // Weak keywords, have special meaning only in specific contexts.
+        // FIXME(auto_traits): Remove `kw::Auto` after beta bump.
         Auto:               "auto",
         Builtin:            "builtin",
         Catch:              "catch",
@@ -1292,6 +1293,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/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
@@ -17,16 +17,18 @@
 #![feature(auto_traits)]
 #![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
@@ -5,6 +5,7 @@
 #![feature(auto_traits)]
 #![crate_type = "rlib"]
 #![no_core]
+#![allow(internal_features)]
 
 #[lang = "sized"]
 trait Sized {}
@@ -14,7 +15,8 @@ impl<T> Sync for T {}
 #[lang = "copy"]
 trait Copy {}
 #[lang = "freeze"]
-auto trait Freeze {}
+#[rustc_auto_trait]
+trait Freeze {}
 
 #[lang = "drop_in_place"]
 #[inline]

Original file line number	Diff line number	Diff line change
`@@ -801,7 +801,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`801`	`801`	`errors::VisibilityNotPermittedNote::TraitImpl,`
`802`	`802`	`);`
`803`	`803`	`if let TyKind::Err = self_ty.kind {`
`804`		`- this.err_handler().emit_err(errors::ObsoleteAuto { span: item.span });`
	`804`	`+ this.err_handler().emit_err(errors::ObsoleteAutoSyntax {`
	`805`	`+ span: item.span,`
	`806`	`+ syntax: "impl Trait for .. {}",`
	`807`	`+ });`
`805`	`808`	`}`
`806`	`809`	`if let (&Unsafe::Yes(span), &ImplPolarity::Negative(sp)) = (unsafety, polarity)`
`807`	`810`	`{`
`@@ -932,8 +935,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`932`	`935`	`}`
`933`	`936`	`}`
`934`	`937`	`}`
`935`		`- ItemKind::Trait(box Trait { is_auto, generics, bounds, items, .. }) => {`
`936`		`- if *is_auto == IsAuto::Yes {`
	`938`	+ // We intentionally ignore `is_auto` since `auto trait` is now meaningless.
	`939`	`+ ItemKind::Trait(box Trait { is_auto: _, generics, bounds, items, .. }) => {`
	`940`	`+ if attr::contains_name(&item.attrs, sym::rustc_auto_trait) {`
`937`	`941`	`// Auto traits cannot have generics, super traits nor contain items.`
`938`	`942`	`self.deny_generic_params(generics, item.ident.span);`
`939`	`943`	`self.deny_super_traits(bounds, item.ident.span);`
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)]`
Original file line number	Diff line number	Diff line change
`@@ -805,7 +805,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`805`	`805`	`entry.1.insert((self_ty.span, ""));`
`806`	`806`	`}`
`807`	`807`	`Some(Node::Item(hir::Item {`
`808`		`- kind: hir::ItemKind::Trait(rustc_ast::ast::IsAuto::Yes, ..),`
	`808`	`+ kind: hir::ItemKind::Trait(rustc_hir::IsAuto::Yes, ..),`
`809`	`809`	`span: item_span,`
`810`	`810`	`..`
`811`	`811`	`})) => {`