add FCW to #[should_panic] when applied to non #[test] or #[bench] fns

Author: Bryntet

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -286,6 +286,7 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
             // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
             sym::rustc_align,
             sym::rustc_align_static,
+            sym::rustc_test_dummy,
             // obviously compatible with self
             sym::naked,
             // documentation

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -306,6 +306,17 @@ impl<S: Stage> SingleAttributeParser<S> for RustcScalableVectorParser {
     }
 }
 
+pub(crate) struct RustcTestDummy;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcTestDummy {
+    const PATH: &[Symbol] = &[sym::rustc_test_dummy];
+
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcTestDummy;
+}
 pub(crate) struct RustcTestMarker;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcTestMarker {

compiler/rustc_attr_parsing/src/context.rs

@@ -67,7 +67,7 @@ use crate::attributes::rustc_internal::{
     RustcLintUntrackedQueryInformationParser, RustcMainParser, RustcMustImplementOneOfParser,
     RustcNeverReturnsNullPointerParser, RustcNoImplicitAutorefsParser,
     RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
-    RustcSimdMonomorphizeLaneLimitParser, RustcTestMarker,
+    RustcSimdMonomorphizeLaneLimitParser, RustcTestDummy, RustcTestMarker,
 };
 use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
@@ -272,6 +272,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcNoImplicitAutorefsParser>>,
         Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
         Single<WithoutArgs<RustcShouldNotBeCalledOnConstItems>>,
+        Single<WithoutArgs<RustcTestDummy>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,

compiler/rustc_builtin_macros/src/test.rs

@@ -113,7 +113,7 @@ pub(crate) fn expand_test_or_bench(
     item: Annotatable,
     is_bench: bool,
 ) -> Vec<Annotatable> {
-    let (item, is_stmt) = match item {
+    let (mut item, is_stmt) = match item {
         Annotatable::Item(i) => (i, false),
         Annotatable::Stmt(box ast::Stmt { kind: ast::StmtKind::Item(i), .. }) => (i, true),
         other => {
@@ -136,6 +136,8 @@ pub(crate) fn expand_test_or_bench(
         return vec![];
     }
 
+    item.attrs.push(cx.attr_word(sym::rustc_test_dummy, cx.with_def_site_ctxt(attr_sp)));
+
     if let Some(attr) = attr::find_by_name(&item.attrs, sym::naked) {
         cx.dcx().emit_err(errors::NakedFunctionTestingAttribute {
             testing_span: attr_sp,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1377,6 +1377,12 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_test_marker, Normal, template!(NameValueStr: "name"), WarnFollowing,
         EncodeCrossCrate::No, "the `#[rustc_test_marker]` attribute is used internally to track tests",
     ),
+
+    rustc_attr!(
+        rustc_test_dummy, Normal, template!(Word), ErrorPreceding,
+        EncodeCrossCrate::No, "the `#[rustc_test_dummy]` attribute is used internally to track tests",
+    ),
+
     rustc_attr!(
         rustc_unsafe_specialization_marker, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -981,6 +981,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
     RustcSimdMonomorphizeLaneLimit(Limit),
 
+    /// Represents `#[rustc_test_dummy]`
+    RustcTestDummy,
+
     /// Represents `#[rustc_test_marker]`
     RustcTestMarker { fn_name: Symbol },
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -109,6 +109,7 @@ impl AttributeKind {
             RustcScalableVector { .. } => Yes,
             RustcShouldNotBeCalledOnConstItems(..) => Yes,
             RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate
+            RustcTestDummy => No,
             RustcTestMarker { .. } => No,
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,

compiler/rustc_passes/messages.ftl

@@ -498,6 +498,9 @@ passes_sanitize_attribute_not_allowed =
     .no_body = function has no body
     .help = sanitize attribute can be applied to a function (with body), impl block, or module
 
+passes_should_panic_must_be_applied_to_test = `#[should_panic]` should only be applied to `#[test]` functions
+    .warn = {-passes_previously_accepted}
+
 passes_trait_impl_const_stability_mismatch = const stability on the impl does not match the const stability on the trait
 passes_trait_impl_const_stability_mismatch_impl_stable = this impl is (implicitly) stable...
 passes_trait_impl_const_stability_mismatch_impl_unstable = this impl is unstable...

compiler/rustc_passes/src/check_attr.rs

@@ -223,6 +223,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::RustcMustImplementOneOf { attr_span, fn_names }) => {
                     self.check_rustc_must_implement_one_of(*attr_span, fn_names, hir_id,target)
                 },
+                Attribute::Parsed(AttributeKind::ShouldPanic { span,.. }) => {
+                    self.check_should_panic(attrs, *span, target);
+                },
                 Attribute::Parsed(
                     AttributeKind::EiiExternTarget { .. }
                     | AttributeKind::EiiExternItem
@@ -272,6 +275,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcSimdMonomorphizeLaneLimit(..)
                     | AttributeKind::RustcShouldNotBeCalledOnConstItems(..)
                     | AttributeKind::RustcTestMarker { .. }
+                    | AttributeKind::RustcTestDummy
                     | AttributeKind::ExportStable
                     | AttributeKind::FfiConst(..)
                     | AttributeKind::UnstableFeatureBound(..)
@@ -283,7 +287,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::PassByValue (..)
                     | AttributeKind::StdInternalSymbol (..)
                     | AttributeKind::Coverage (..)
-                    | AttributeKind::ShouldPanic { .. }
                     | AttributeKind::Coroutine(..)
                     | AttributeKind::Linkage(..)
                     | AttributeKind::MustUse { .. }
@@ -449,6 +452,15 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.check_mix_no_mangle_export(hir_id, attrs);
     }
 
+    fn check_should_panic(&self, attrs: &[Attribute], attr_span: Span, target: Target) {
+        // The error message only makes sense if it's actually being applied on a function
+        if matches!(target, Target::Fn) {
+            if !find_attr!(attrs, AttributeKind::RustcTestDummy) {
+                self.dcx().emit_warn(errors::MustBeAppliedToTest { attr_span, warning: true });
+            }
+        }
+    }
+
     fn check_rustc_must_implement_one_of(
         &self,
         attr_span: Span,

compiler/rustc_passes/src/errors.rs

@@ -1360,3 +1360,12 @@ pub(crate) struct FunctionNamesDuplicated {
     #[primary_span]
     pub spans: Vec<Span>,
 }
+
+#[derive(Diagnostic)]
+#[diag(passes_should_panic_must_be_applied_to_test)]
+pub(crate) struct MustBeAppliedToTest {
+    #[primary_span]
+    pub attr_span: Span,
+    #[warning]
+    pub warning: bool,
+}