Revert "Add rustc_test_entrypoint_marker"

compiler/rustc_attr_ir/src/data_structures.rs

@@ -1462,9 +1462,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_strict_coherence]`.
     RustcStrictCoherence(Span),
 
-    /// Represents `#[rustc_test_entrypoint_marker]`
-    RustcTestEntrypointMarker,
-
     /// Represents `#[rustc_test_marker]`
     RustcTestMarker(Symbol),
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -192,7 +192,6 @@ impl AttributeKind {
             RustcSpecializationTrait => No,
             RustcStdInternalSymbol => No,
             RustcStrictCoherence(..) => Yes,
-            RustcTestEntrypointMarker => No,
             RustcTestMarker(..) => No,
             RustcThenThisWouldNeed(..) => No,
             RustcTrivialFieldReads => Yes,

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -214,14 +214,3 @@ impl SingleAttributeParser for RustcTestMarkerParser {
         Some(AttributeKind::RustcTestMarker(value_str))
     }
 }
-
-pub(crate) struct RustcTestEntrypointMarkerParser;
-
-impl NoArgsAttributeParser for RustcTestEntrypointMarkerParser {
-    const PATH: &[Symbol] = &[sym::rustc_test_entrypoint_marker];
-    const ALLOWED_TARGETS: AllowedTargets<'_> =
-        AllowedTargets::AllowList(&[Allow(Target::Fn), Allow(Target::Closure)]);
-    const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn;
-    const STABILITY: AttributeStability = unstable!(rustc_attrs);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcTestEntrypointMarker;
-}

compiler/rustc_attr_parsing/src/context.rs

@@ -354,7 +354,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcSpecializationTraitParser>>,
         Single<WithoutArgs<RustcStdInternalSymbolParser>>,
         Single<WithoutArgs<RustcStrictCoherenceParser>>,
-        Single<WithoutArgs<RustcTestEntrypointMarkerParser>>,
         Single<WithoutArgs<RustcTrivialFieldReadsParser>>,
         Single<WithoutArgs<SplatParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,

compiler/rustc_builtin_macros/src/test.rs

@@ -23,9 +23,6 @@ use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
 ///
 /// We mark item with an inert attribute "rustc_test_marker" which the test generation
 /// logic will pick up on.
-///
-/// The test function also gains a `#[rustc_test_entrypoint_marker]` attribute for tools to pick up
-/// on. This behavior is *unstable*.
 pub(crate) fn expand_test_case(
     ecx: &mut ExtCtxt<'_>,
     attr_sp: Span,
@@ -380,12 +377,6 @@ pub(crate) fn expand_test_or_bench(
     let test_extern =
         cx.item(sp, ast::AttrVec::new(), ast::ItemKind::ExternCrate(None, test_ident));
 
-    let item = {
-        let mut item = item;
-        item.attrs.push(cx.attr_word(sym::rustc_test_entrypoint_marker, attr_sp));
-        item
-    };
-
     debug!("synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
 
     if is_stmt {

compiler/rustc_feature/src/builtin_attrs.rs

@@ -364,7 +364,6 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     sym::prelude_import,
     sym::rustc_paren_sugar,
     sym::rustc_inherit_overflow_checks,
-    sym::rustc_test_entrypoint_marker,
     sym::rustc_test_marker,
     sym::rustc_allow_lifetime_dependent_specialization,
     sym::rustc_specialization_trait,

compiler/rustc_passes/src/check_attr.rs

@@ -400,7 +400,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::RustcSpecializationTrait => (),
             AttributeKind::RustcStdInternalSymbol => (),
             AttributeKind::RustcStrictCoherence(..) => (),
-            AttributeKind::RustcTestEntrypointMarker => (),
             AttributeKind::RustcTestMarker(..) => (),
             AttributeKind::RustcThenThisWouldNeed(..) => (),
             AttributeKind::RustcTrivialFieldReads => (),

compiler/rustc_span/src/symbol.rs

@@ -1879,7 +1879,6 @@ symbols! {
         rustc_splat,
         rustc_std_internal_symbol,
         rustc_strict_coherence,
-        rustc_test_entrypoint_marker,
         rustc_test_marker,
         rustc_then_this_would_need,
         rustc_trivial_field_reads,

tests/pretty/tests-are-sorted.pp

@@ -30,7 +30,6 @@
         testfn: test::StaticTestFn(#[coverage(off)] ||
                 test::assert_test_result(m_test())),
     };
-#[rustc_test_entrypoint_marker]
 fn m_test() {}
 
 extern crate test;
@@ -56,7 +55,6 @@
                 test::assert_test_result(z_test())),
     };
 #[ignore = "not yet implemented"]
-#[rustc_test_entrypoint_marker]
 fn z_test() {}
 
 extern crate test;
@@ -81,7 +79,6 @@
         testfn: test::StaticTestFn(#[coverage(off)] ||
                 test::assert_test_result(a_test())),
     };
-#[rustc_test_entrypoint_marker]
 fn a_test() {}
 #[rustc_main]
 #[coverage(off)]

tests/ui/macros/parse-test.rs

@@ -0,0 +1,18 @@
+//@ check-pass
+//@ compile-flags: --test
+// Test that we can pass a test through a macro_rules! macro that removes the span of the item
+// Regression test for https://github.com/rust-lang/rust/issues/161917
+#![feature(macro_attr)]
+
+macro_rules! ohno {
+    attr() { $(#[$a:meta])* fn $name:ident () $body: block } => {
+        $(#[$a])*
+        fn $name () $body
+    }
+}
+
+#[test]
+#[ohno]
+fn my_test() {}
+
+fn main() {}

tests/ui/proc-macro/auxiliary/test-count-attributes.rs

@@ -0,0 +1,23 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn assert_no_attributes(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    // This will count the "attributes" (in reality the number of hash symbols) on the item.
+    assert_eq!(item.to_string().chars().filter(|c| *c == '#').count(), 0);
+    item
+}
+
+#[proc_macro_attribute]
+pub fn assert_one_attribute(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    // This will count the "attributes" (in reality the number of hash symbols) on the item.
+    assert_eq!(item.to_string().chars().filter(|c| *c == '#').count(), 1);
+    item
+}
+
+#[proc_macro_attribute]
+pub fn assert_two_attributes(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    // This will count the "attributes" (in reality the number of hash symbols) on the item.
+    assert_eq!(item.to_string().chars().filter(|c| *c == '#').count(), 2);
+    item
+}

tests/ui/proc-macro/auxiliary/test-re-emit.rs

@@ -0,0 +1,8 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn remove_span(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    // `.to_string().parse()` will lose the span of the token stream
+    item.to_string().parse().unwrap()
+}

tests/ui/proc-macro/test-count-attributes.rs

@@ -0,0 +1,30 @@
+//@ check-pass
+//@ proc-macro: test-count-attributes.rs
+//@ compile-flags: --test
+// Tests whether attributes on tests can be observed by proc macros
+// Regression test for https://github.com/rust-lang/rust/issues/161920
+
+#[test]
+#[test_count_attributes::assert_no_attributes]
+fn meow1() {}
+
+#[test_count_attributes::assert_one_attribute]
+#[test]
+fn meow2() {}
+
+#[test]
+#[should_panic]
+#[test_count_attributes::assert_one_attribute]
+fn meow3() {}
+
+#[test]
+#[test_count_attributes::assert_one_attribute]
+#[should_panic]
+fn meow4() {}
+
+#[test_count_attributes::assert_two_attributes]
+#[test]
+#[should_panic]
+fn meow5() {}
+
+fn main() {}

tests/ui/proc-macro/test-re-emit.rs

@@ -0,0 +1,15 @@
+//@ check-pass
+//@ proc-macro: test-re-emit.rs
+//@ compile-flags: --test
+// Test that we can pass a test through a proc macro that removes the span of the item
+// Regression test for https://github.com/rust-lang/rust/issues/161917
+
+#[test]
+#[test_re_emit::remove_span]
+fn meow1() {}
+
+#[test_re_emit::remove_span]
+#[test]
+fn meow2() {}
+
+fn main() {}