Port #[rustc_unsafe_specialization_marker] to the new attribute system

Author: GrigorenkoPV

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -298,5 +298,8 @@ pub enum AttributeKind {
 
     /// Represents `#[type_const]`.
     TypeConst(Span),
+
+    /// Represents `#[rustc_unsafe_specialization_marker]`.
+    UnsafeSpecializationMarker(Span),
     // tidy-alphabetical-end
 }

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -114,3 +114,13 @@ impl<S: Stage> NoArgsAttributeParser<S> for SpecializationTraitParser {
         AttributeKind::SpecializationTrait(span)
     }
 }
+
+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;
+
+    fn create(span: Span) -> AttributeKind {
+        AttributeKind::UnsafeSpecializationMarker(span)
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -30,6 +30,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};
@@ -138,6 +139,7 @@ attribute_parsers!(
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<TypeConstParser>>,
+        Single<WithoutArgs<UnsafeSpecializationMarkerParser>>,
         // tidy-alphabetical-end
     ];
 );

compiler/rustc_hir_analysis/src/collect.rs

@@ -1159,14 +1159,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

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

compiler/rustc_passes/src/check_attr.rs

@@ -123,11 +123,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)
                 }