Use new style attribute

Author: calebzulawski

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -1,3 +1,5 @@
+use rustc_hir::limit::Limit;
+
 use super::prelude::*;
 use super::util::parse_single_integer;
 
@@ -49,3 +51,18 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
         Some(AttributeKind::RustcObjectLifetimeDefault)
     }
 }
+
+pub(crate) struct RustcSimdMonomorphizeLaneLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcSimdMonomorphizeLaneLimitParser {
+    const PATH: &[Symbol] = &[sym::rustc_simd_monomorphize_lane_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+    const TEMPLATE: AttributeTemplate = template!(List: &["N"]);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        parse_single_integer(cx, args)
+            .map(|n| AttributeKind::RustcSimdMonomorphizeLaneLimit(Limit::new(n as usize)))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -53,7 +53,7 @@ use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
     RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
-    RustcObjectLifetimeDefaultParser,
+    RustcObjectLifetimeDefaultParser, RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
@@ -195,6 +195,7 @@ attribute_parsers!(
         Single<RustcLayoutScalarValidRangeEnd>,
         Single<RustcLayoutScalarValidRangeStart>,
         Single<RustcObjectLifetimeDefaultParser>,
+        Single<RustcSimdMonomorphizeLaneLimitParser>,
         Single<SanitizeParser>,
         Single<ShouldPanicParser>,
         Single<SkipDuringMethodDispatchParser>,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -642,6 +642,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_object_lifetime_default]`.
     RustcObjectLifetimeDefault,
 
+    /// Represents `#[rustc_simd_monomorphize_lane_limit(N)]`.
+    RustcSimdMonomorphizeLaneLimit(Limit),
+
     /// Represents `#[sanitize]`
     ///
     /// the on set and off set are distjoint since there's a third option: unset.

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -85,6 +85,7 @@ impl AttributeKind {
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcObjectLifetimeDefault => No,
+            RustcSimdMonomorphizeLaneLimit(..) => Yes,
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,
             SkipDuringMethodDispatch { .. } => No,

compiler/rustc_passes/src/check_attr.rs

@@ -254,6 +254,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::MacroEscape( .. )
                     | AttributeKind::RustcLayoutScalarValidRangeStart(..)
                     | AttributeKind::RustcLayoutScalarValidRangeEnd(..)
+                    | AttributeKind::RustcSimdMonomorphizeLaneLimit(..)
                     | AttributeKind::ExportStable
                     | AttributeKind::FfiConst(..)
                     | AttributeKind::UnstableFeatureBound(..)

compiler/rustc_ty_utils/src/layout.rs

@@ -7,6 +7,8 @@ use rustc_abi::{
     VariantIdx, Variants, WrappingRange,
 };
 use rustc_hashes::Hash64;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::query::Providers;
@@ -562,21 +564,18 @@ fn layout_of_uncached<'tcx>(
             let e_ly = cx.layout_of(e_ty)?;
 
             // Check for the rustc_simd_monomorphize_lane_limit attribute and check the lane limit
-            if let Some(attr) =
-                tcx.get_attrs_by_path(def.did(), &[sym::rustc_simd_monomorphize_lane_limit]).next()
-            {
-                if let Some(lit) = attr.value_lit() {
-                    if let Ok(limit) = lit.symbol.as_str().parse::<u64>() {
-                        if e_len > limit {
-                            return Err(map_error(
-                                &cx,
-                                ty,
-                                rustc_abi::LayoutCalculatorError::OversizedSimdType {
-                                    max_lanes: limit,
-                                },
-                            ));
-                        }
-                    }
+            if let Some(limit) = find_attr!(
+                tcx.get_all_attrs(def.did()),
+                AttributeKind::RustcSimdMonomorphizeLaneLimit(limit) => limit
+            ) {
+                if !limit.value_within_limit(e_len as usize) {
+                    return Err(map_error(
+                        &cx,
+                        ty,
+                        rustc_abi::LayoutCalculatorError::OversizedSimdType {
+                            max_lanes: limit.0 as u64,
+                        },
+                    ));
                 }
             }
 

tests/ui/simd/simd-lane-limit-err-npow2.rs

@@ -3,7 +3,7 @@
 //@ build-fail
 
 #[repr(simd, packed)]
-#[rustc_simd_monomorphize_lane_limit = "4"]
+#[rustc_simd_monomorphize_lane_limit(4)]
 struct V<T, const N: usize>([T; N]);
 
 fn main() {

tests/ui/simd/simd-lane-limit-err.rs

@@ -3,7 +3,7 @@
 //@ build-fail
 
 #[repr(simd, packed)]
-#[rustc_simd_monomorphize_lane_limit = "4"]
+#[rustc_simd_monomorphize_lane_limit(4)]
 struct V<T, const N: usize>([T; N]);
 
 fn main() {

tests/ui/simd/simd-lane-limit-ok.rs

@@ -3,7 +3,7 @@
 //@ build-pass
 
 #[repr(simd, packed)]
-#[rustc_simd_monomorphize_lane_limit = "8"]
+#[rustc_simd_monomorphize_lane_limit(8)]
 struct V<T, const N: usize>([T; N]);
 
 const LANES: usize = 4;