add FCW to invalid #[should_panic] and #[ignore]

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -655,7 +655,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     }
 
     fn print_attribute_inline(&mut self, attr: &ast::Attribute, is_inline: bool) -> bool {
-        if attr.has_name(sym::cfg_trace) || attr.has_name(sym::cfg_attr_trace) {
+        if attr.has_any_name(&[sym::cfg_trace, sym::cfg_attr_trace, sym::test_trace]) {
             // It's not a valid identifier, so avoid printing it
             // to keep the printed code reasonably parse-able.
             return false;

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -264,6 +264,7 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
             sym::cfg_attr_trace,
             // testing (allowed here so better errors can be generated in `rustc_builtin_macros::test`)
             sym::test,
+            sym::test_trace,
             sym::ignore,
             sym::should_panic,
             sym::bench,

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -63,6 +63,7 @@ pub(crate) mod rustc_internal;
 pub(crate) mod semantics;
 pub(crate) mod stability;
 pub(crate) mod test_attrs;
+pub(crate) mod trace;
 pub(crate) mod traits;
 pub(crate) mod transparency;
 pub(crate) mod util;

compiler/rustc_attr_parsing/src/attributes/trace.rs

@@ -0,0 +1,13 @@
+use super::prelude::*;
+
+pub(crate) struct TestTraceParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for TestTraceParser {
+    const PATH: &[Symbol] = &[sym::test_trace];
+
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::TestTrace;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -82,6 +82,7 @@ use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
 };
 use crate::attributes::test_attrs::{IgnoreParser, ShouldPanicParser};
+use crate::attributes::trace::TestTraceParser;
 use crate::attributes::traits::{
     AllowIncoherentImplParser, CoinductiveParser, DenyExplicitImplParser,
     DoNotImplementViaObjectParser, FundamentalParser, MarkerParser, ParenSugarParser,
@@ -290,6 +291,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcShouldNotBeCalledOnConstItems>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
+        Single<WithoutArgs<TestTraceParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         Single<WithoutArgs<TypeConstParser>>,

compiler/rustc_attr_parsing/src/validate_attr.rs

@@ -22,7 +22,8 @@ use rustc_span::{Span, Symbol, sym};
 use crate::{AttributeParser, Late, session_diagnostics as errors};
 
 pub fn check_attr(psess: &ParseSess, attr: &Attribute) {
-    if attr.is_doc_comment() || attr.has_name(sym::cfg_trace) || attr.has_name(sym::cfg_attr_trace)
+    if attr.is_doc_comment()
+        || attr.has_any_name(&[sym::cfg_trace, sym::cfg_attr_trace, sym::test_trace])
     {
         return;
     }

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,11 @@ pub(crate) fn expand_test_or_bench(
         return vec![];
     }
 
+    // Add a trace to the originating test function, so that we can
+    // check if attributes that have `#[test]` or `#[bench]` as a requirement
+    // actually are annotated with said attributes
+    item.attrs.push(cx.attr_word(sym::test_trace, 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

@@ -1140,6 +1140,10 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         cfg_attr_trace, Normal, template!(Word /* irrelevant */), DuplicatesOk,
         EncodeCrossCrate::No
     ),
+    ungated!(
+        test_trace, Normal, template!(Word), ErrorFollowing,
+        EncodeCrossCrate::No
+    ),
 
     // ==========================================================================
     // Internal attributes, Diagnostics related:

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1018,6 +1018,9 @@ pub enum AttributeKind {
     /// `#[unsafe(force_target_feature(enable = "...")]`.
     TargetFeature { features: ThinVec<(Symbol, Span)>, attr_span: Span, was_forced: bool },
 
+    /// Represents `#[<test_trace>]`
+    TestTrace,
+
     /// Represents `#[thread_local]`
     ThreadLocal,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -128,6 +128,7 @@ impl AttributeKind {
             Stability { .. } => Yes,
             StdInternalSymbol(..) => No,
             TargetFeature { .. } => No,
+            TestTrace => No,
             ThreadLocal => No,
             TrackCaller(..) => Yes,
             TypeConst(..) => Yes,

compiler/rustc_passes/messages.ftl

@@ -29,6 +29,9 @@ passes_attr_application_struct_union =
     attribute should be applied to a struct or union
     .label = not a struct or union
 
+passes_attr_must_be_applied_to_test_or_bench = `#[{$attr_name}]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+    .warn = {-passes_previously_accepted}
+
 passes_autodiff_attr =
     `#[autodiff]` should be applied to a function
     .label = not a function

compiler/rustc_passes/src/check_attr.rs

@@ -224,6 +224,12 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     self.check_rustc_must_implement_one_of(*attr_span, fn_names, hir_id,target)
                 },
                 Attribute::Parsed(AttributeKind::DoNotRecommend{attr_span}) => {self.check_do_not_recommend(*attr_span, hir_id, target, item)},
+                Attribute::Parsed(AttributeKind::ShouldPanic { span, .. }) => {
+                    self.check_should_panic(attrs, *span, target);
+                },
+                Attribute::Parsed(AttributeKind::Ignore { span, .. }) => {
+                    self.check_ignore(attrs, *span, target);
+                }
                 Attribute::Parsed(
                     AttributeKind::EiiDeclaration { .. }
                     | AttributeKind::EiiForeignItem
@@ -235,7 +241,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Pointee(..)
                     | AttributeKind::Dummy
                     | AttributeKind::RustcBuiltinMacro { .. }
-                    | AttributeKind::Ignore { .. }
                     | AttributeKind::InstructionSet(..)
                     | AttributeKind::Path(..)
                     | AttributeKind::NoImplicitPrelude(..)
@@ -286,7 +291,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::PassByValue (..)
                     | AttributeKind::StdInternalSymbol (..)
                     | AttributeKind::Coverage (..)
-                    | AttributeKind::ShouldPanic { .. }
                     | AttributeKind::Coroutine(..)
                     | AttributeKind::Linkage(..)
                     | AttributeKind::MustUse { .. }
@@ -315,6 +319,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcDumpPredicates
                     | AttributeKind::RustcDumpDefParents
                     | AttributeKind::RustcDumpVtable(..)
+                    | AttributeKind::TestTrace
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
@@ -484,6 +489,32 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.check_mix_no_mangle_export(hir_id, attrs);
     }
 
+    fn check_ignore(&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::TestTrace) {
+                self.dcx().emit_warn(errors::MustBeAppliedToTest {
+                    attr_span,
+                    attr_name: sym::ignore,
+                    warning: true,
+                });
+            }
+        }
+    }
+
+    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::TestTrace) {
+                self.dcx().emit_warn(errors::MustBeAppliedToTest {
+                    attr_span,
+                    attr_name: sym::should_panic,
+                    warning: true,
+                });
+            }
+        }
+    }
+
     fn check_rustc_must_implement_one_of(
         &self,
         attr_span: Span,

compiler/rustc_passes/src/errors.rs

@@ -1316,3 +1316,13 @@ pub(crate) struct FunctionNamesDuplicated {
     #[primary_span]
     pub spans: Vec<Span>,
 }
+
+#[derive(Diagnostic)]
+#[diag(passes_attr_must_be_applied_to_test_or_bench)]
+pub(crate) struct MustBeAppliedToTest {
+    #[primary_span]
+    pub attr_span: Span,
+    #[warning]
+    pub warning: bool,
+    pub attr_name: Symbol,
+}

compiler/rustc_span/src/symbol.rs

@@ -2273,6 +2273,7 @@ symbols! {
         test_case,
         test_removed_feature,
         test_runner,
+        test_trace: "<test_trace>",
         test_unstable_lint,
         thread,
         thread_local,

tests/ui/attributes/ignore.rs

@@ -0,0 +1,18 @@
+//@ check-pass
+#![feature(test)]
+
+#[ignore]
+//~^ WARN `#[ignore]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+//~| WARN this was previously accepted
+pub fn foo() {}
+
+
+#[test]
+#[ignore]
+pub fn bar() {}
+
+#[ignore]
+#[bench]
+pub fn bazz() {}
+
+fn main() { }

tests/ui/attributes/ignore.stderr

@@ -0,0 +1,10 @@
+warning: `#[ignore]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+  --> $DIR/ignore.rs:4:1
+   |
+LL | #[ignore]
+   | ^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
+warning: 1 warning emitted
+

tests/ui/attributes/should-panic.rs

@@ -0,0 +1,18 @@
+//@ check-pass
+#![feature(test)]
+
+#[should_panic]
+//~^ WARN `#[should_panic]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+//~| WARN this was previously accepted
+pub fn foo() {}
+
+
+#[test]
+#[should_panic]
+pub fn bar() {}
+
+#[should_panic]
+#[bench]
+pub fn bazz() {}
+
+fn main() { }

tests/ui/attributes/should-panic.stderr

@@ -0,0 +1,10 @@
+warning: `#[should_panic]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+  --> $DIR/should-panic.rs:4:1
+   |
+LL | #[should_panic]
+   | ^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
+warning: 1 warning emitted
+

tests/ui/attributes/test_trace.rs

@@ -0,0 +1,20 @@
+//@ compile-flags: --test
+
+fn main() {}
+
+#[test_trace]
+//~^ ERROR cannot find attribute `test_trace` in this scope
+fn foo() {}
+
+
+#[test]
+#[test_trace]
+//~^ ERROR cannot find attribute `test_trace` in this scope
+fn bar() {}
+
+#[test]
+#[test_trace]
+//~^ ERROR cannot find attribute `test_trace` in this scope
+#[test]
+//~^ WARN duplicated attribute
+fn bazz() {}

tests/ui/attributes/test_trace.stderr

@@ -0,0 +1,46 @@
+error: cannot find attribute `test_trace` in this scope
+  --> $DIR/test_trace.rs:5:3
+   |
+LL | #[test_trace]
+   |   ^^^^^^^^^^
+   |
+help: a built-in attribute with a similar name exists
+   |
+LL - #[test_trace]
+LL + #[<test_trace>]
+   |
+
+error: cannot find attribute `test_trace` in this scope
+  --> $DIR/test_trace.rs:11:3
+   |
+LL | #[test_trace]
+   |   ^^^^^^^^^^
+   |
+help: a built-in attribute with a similar name exists
+   |
+LL - #[test_trace]
+LL + #[<test_trace>]
+   |
+
+error: cannot find attribute `test_trace` in this scope
+  --> $DIR/test_trace.rs:16:3
+   |
+LL | #[test_trace]
+   |   ^^^^^^^^^^
+   |
+help: a built-in attribute with a similar name exists
+   |
+LL - #[test_trace]
+LL + #[<test_trace>]
+   |
+
+warning: duplicated attribute
+  --> $DIR/test_trace.rs:18:1
+   |
+LL | #[test]
+   | ^^^^^^^
+   |
+   = note: `#[warn(duplicate_macro_attributes)]` on by default
+
+error: aborting due to 3 previous errors; 1 warning emitted
+

tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs

@@ -9,10 +9,16 @@ fn b() {}
 #[unsafe(test)] //~ ERROR: is not an unsafe attribute
 fn aa() {}
 
-#[unsafe(ignore = "test")] //~ ERROR: is not an unsafe attribute
+#[unsafe(ignore = "test")]
+//~^ ERROR: is not an unsafe attribute
+//~| WARN`#[ignore]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+//~| WARN this was previously accepted by the compiler
 fn bb() {}
 
-#[unsafe(should_panic(expected = "test"))] //~ ERROR: is not an unsafe attribute
+#[unsafe(should_panic(expected = "test"))]
+//~^ ERROR: is not an unsafe attribute
+//~| WARN `#[should_panic]` should only be applied to functions annotated with `#[test]` or `#[bench]`
+//~| WARN this was previously accepted
 fn cc() {}
 
 #[unsafe(macro_use)] //~ ERROR: is not an unsafe attribute