Port #[rustc_unsafe_specialization_marker] to the new attribute system

Author: GrigorenkoPV

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -333,6 +333,9 @@ pub enum AttributeKind {
     /// Represents `#[type_const]`.
     TypeConst(Span),
 
+    /// Represents `#[rustc_unsafe_specialization_marker]`.
+    UnsafeSpecializationMarker(Span),
+
     /// Represents `#[used]`
     Used { used_by: UsedBy, span: Span },
     // tidy-alphabetical-end

compiler/rustc_attr_data_structures/src/encode_cross_crate.rs

@@ -51,6 +51,7 @@ impl AttributeKind {
             TargetFeature(..) => No,
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,
+            UnsafeSpecializationMarker(..) => No,
             Used { .. } => No,
             // tidy-alphabetical-end
         }

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -96,3 +96,10 @@ impl<S: Stage> NoArgsAttributeParser<S> for SpecializationTraitParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::SpecializationTrait;
 }
+
+pub(crate) struct UnsafeSpecializationMarkerParser;
+impl<S: Stage> NoArgsAttributeParser<S> for UnsafeSpecializationMarkerParser {
+    const PATH: &[Symbol] = &[sym::rustc_unsafe_specialization_marker];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::UnsafeSpecializationMarker;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -38,6 +38,7 @@ use crate::attributes::stability::{
 use crate::attributes::traits::{
     CoinductiveParser, ConstTraitParser, DenyExplicitImplParser, DoNotImplementViaObjectParser,
     SkipDuringMethodDispatchParser, SpecializationTraitParser, TypeConstParser,
+    UnsafeSpecializationMarkerParser,
 };
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
@@ -153,6 +154,7 @@ attribute_parsers!(
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         Single<WithoutArgs<TypeConstParser>>,
+        Single<WithoutArgs<UnsafeSpecializationMarkerParser>>,
         // tidy-alphabetical-end
     ];
 );

compiler/rustc_hir_analysis/src/collect.rs

@@ -880,14 +880,13 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     )
     .unwrap_or([false; 2]);
 
-    let specialization_kind =
-        if attrs.iter().any(|attr| attr.has_name(sym::rustc_unsafe_specialization_marker)) {
-            ty::trait_def::TraitSpecializationKind::Marker
-        } else if find_attr!(attrs, AttributeKind::SpecializationTrait(_)) {
-            ty::trait_def::TraitSpecializationKind::AlwaysApplicable
-        } else {
-            ty::trait_def::TraitSpecializationKind::None
-        };
+    let specialization_kind = if find_attr!(attrs, AttributeKind::UnsafeSpecializationMarker(_)) {
+        ty::trait_def::TraitSpecializationKind::Marker
+    } else if find_attr!(attrs, AttributeKind::SpecializationTrait(_)) {
+        ty::trait_def::TraitSpecializationKind::AlwaysApplicable
+    } else {
+        ty::trait_def::TraitSpecializationKind::None
+    };
     let must_implement_one_of = attrs
         .iter()
         .find(|attr| attr.has_name(sym::rustc_must_implement_one_of))

compiler/rustc_parse/src/validate_attr.rs

@@ -298,6 +298,7 @@ fn emit_malformed_attribute(
             | sym::rustc_coinductive
             | sym::const_trait
             | sym::rustc_specialization_trait
+            | sym::rustc_unsafe_specialization_marker
             | sym::type_const
             | sym::repr
             | sym::align

compiler/rustc_passes/src/check_attr.rs

@@ -125,11 +125,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Coinductive(attr_span)
                     | AttributeKind::ConstTrait(attr_span)
                     | AttributeKind::DenyExplicitImpl(attr_span)
-                    | AttributeKind::DoNotImplementViaObject(attr_span)
-                    | AttributeKind::SpecializationTrait(attr_span),
+                    | AttributeKind::DoNotImplementViaObject(attr_span),
                 ) => {
                     self.check_must_be_applied_to_trait(*attr_span, span, target);
                 }
+                &Attribute::Parsed(
+                    AttributeKind::SpecializationTrait(attr_span)
+                    | AttributeKind::UnsafeSpecializationMarker(attr_span),
+                ) => {
+                    // FIXME(specialization): more validation is needed
+                    self.check_must_be_applied_to_trait(attr_span, span, target);
+                }
                 &Attribute::Parsed(AttributeKind::TypeConst(attr_span)) => {
                     self.check_type_const(hir_id, attr_span, target)
                 }