Append generated test macro so next test macros are aware of it

This is an attempt to improve capabilities among test macros to avoid
duplicated test runs which is rare to be aware of.

The rationale is simple: procedure of attribute macro see only attributes
following it. Macros next to processing macro will not see generated
macro if it is generated in-place. So, instead of generating test macro
in-place, appending generated test macro will let macros next to processing
macro have chance to react, for example, not generate test macro if there
is already one.

Without the fix, the new test will run twice.

See also tokio-rs/tokio#6497, d-e-s-o/test-log#46, frondeus/test-case#143,
la10736/rstest#291, google/googletest-rust#561, kezhuw/stuck#53.

Author: kezhuw

Cargo.toml

@@ -28,3 +28,4 @@ proptest = "1.6.0"
 trybuild = "1.0.96"
 tokio = { version = "1.38.0", features = ["rt-multi-thread"] }
 anyhow = "1.0.97"
+googletest = "0.14.0"

src/proptest_fn.rs

@@ -4,10 +4,41 @@ use crate::syn_utils::{Arg, Args};
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{
-    parse2, parse_quote, parse_str, spanned::Spanned, token, Block, Expr, Field, FieldMutability,
-    FnArg, Ident, ItemFn, LitStr, Pat, Result, ReturnType, Visibility,
+    parse2, parse_quote, parse_str, spanned::Spanned, token, Attribute, Block, Expr, Field,
+    FieldMutability, FnArg, Ident, ItemFn, LitStr, Pat, Result, ReturnType, Visibility,
 };
 
+// Check whether given attribute is a test attribute of forms:
+// * `#[test]`
+// * `#[core::prelude::*::test]` or `#[::core::prelude::*::test]`
+// * `#[std::prelude::*::test]` or `#[::std::prelude::*::test]`
+fn is_test_attribute(attr: &Attribute) -> bool {
+    let path = match &attr.meta {
+        syn::Meta::Path(path) => path,
+        _ => return false,
+    };
+    const CANDIDATES_LEN: usize = 4;
+
+    let candidates: [[&str; CANDIDATES_LEN]; 2] = [
+        ["core", "prelude", "*", "test"],
+        ["std", "prelude", "*", "test"],
+    ];
+    if path.leading_colon.is_none()
+        && path.segments.len() == 1
+        && path.segments[0].arguments.is_none()
+        && path.segments[0].ident == "test"
+    {
+        return true;
+    } else if path.segments.len() != candidates[0].len() {
+        return false;
+    }
+    candidates.into_iter().any(|segments| {
+        path.segments.iter().zip(segments).all(|(segment, path)| {
+            segment.arguments.is_none() && (path == "*" || segment.ident == path)
+        })
+    })
+}
+
 pub fn build_proptest(attr: TokenStream, mut item_fn: ItemFn) -> Result<TokenStream> {
     let mut attr_args = None;
     if !attr.is_empty() {
@@ -64,6 +95,12 @@ pub fn build_proptest(attr: TokenStream, mut item_fn: ItemFn) -> Result<TokenStr
     };
     item_fn.sig.inputs = parse_quote! { input: #args_type_ident };
     item_fn.block = Box::new(parse2(block)?);
+    if !item_fn.attrs.iter().any(is_test_attribute) {
+        let test_attr: Attribute = parse_quote! {
+            #[::core::prelude::v1::test]
+        };
+        item_fn.attrs.push(test_attr);
+    }
     let args_fields = args.iter().map(|arg| &arg.field);
     let config = to_proptest_config(config_args);
     let ts = quote! {
@@ -75,7 +112,6 @@ pub fn build_proptest(attr: TokenStream, mut item_fn: ItemFn) -> Result<TokenStr
         #[cfg(test)]
         proptest::proptest! {
             #config
-            #[test]
             #item_fn
         }
     };

tests/proptest_fn.rs

@@ -6,6 +6,11 @@ use proptest::{prelude::ProptestConfig, prop_assert};
 use test_strategy::proptest;
 use tokio::task::yield_now;
 
+use googletest::expect_that;
+use googletest::gtest;
+use googletest::matchers::*;
+use googletest::verify_that;
+
 #[proptest]
 fn example(_x: u32, #[strategy(1..10u32)] y: u32, #[strategy(0..#y)] z: u32) {
     assert!(1 <= y);
@@ -291,3 +296,10 @@ async fn anyhow_result_bail_async(#[strategy(1..10u8)] x: u8) -> anyhow::Result<
     yield_now().await;
     anyhow::bail!("error");
 }
+
+#[proptest]
+#[gtest]
+fn googletest_result(#[strategy(1..10u8)] x: u8) -> googletest::Result<()> {
+    expect_that!(x, ge(1));
+    verify_that!(x, lt(10))
+}