feat: Add support for discovering quickcheck tests

While quichcheck tests expand into a regular #[test] with the original property test function stored within a new wrapper function declaration, the call within the generated wrapper to the quickcheck harness casts the original function item into a function pointer. This results in the information necessary to construct a call relation between the wrapper function and the original property test function to be lost.

To solve this, we introduce a very thin layer of special handling for quickcheck test definitions. The same idea could be reused for other test wrappers that work in a similar way to quickcheck.

Author: zalanlevai

mutest-driver/src/passes/analysis.rs

@@ -191,7 +191,7 @@ pub fn run(config: &mut Config) -> CompilerResult<Option<AnalysisPassResult>> {
             let t_test_discovery_start = Instant::now();
             let tests = opts.crate_kind.provides_tests()
                 .then(|| match opts.embedded {
-                    false => mutest_emit::analysis::tests::collect_tests(&generated_crate_ast, &def_res),
+                    false => mutest_emit::analysis::tests::collect_tests(tcx, &generated_crate_ast, &def_res),
                     true => mutest_emit::analysis::tests::collect_and_mark_embedded_tests(sess, &mut generated_crate_ast, &def_res),
                 })
                 .unwrap_or_default();

mutest-driver/src/print.rs

@@ -463,7 +463,8 @@ pub fn print_mutations<'tcx>(tcx: TyCtxt<'tcx>, mutations: &[Mut], mutation_batc
         );
 
         if let TargetReachability::DirectEntry = mutation.target.reachability {
-            let entry_point = LocalEntryPoint { local_def_id: mutation.target.def_id().expect_local() };
+            // NOTE: The entry point's original body override, if any, can be discarded here, as it is no longer used.
+            let entry_point = LocalEntryPoint { local_def_id: mutation.target.def_id().expect_local(), body_local_def_id: None };
 
             if nested { print!("  "); }
             println!("  <- {entry_point} (direct entry point)",

mutest-emit/src/analysis/call_graph.rs

@@ -12,7 +12,7 @@ use smallvec::{SmallVec, smallvec};
 use crate::analysis::ast_lowering;
 use crate::analysis::hir;
 use crate::analysis::res;
-use crate::analysis::tests::{self, Test};
+use crate::analysis::tests::{self, Test, TestKind};
 use crate::analysis::ty::{self, TyCtxt};
 use crate::codegen::ast;
 use crate::codegen::ast::visit::Visitor;
@@ -131,9 +131,14 @@ pub struct EntryPointAssoc {
 #[derive(Copy, Clone, Debug)]
 pub struct LocalEntryPoint {
     pub local_def_id: hir::LocalDefId,
+    pub body_local_def_id: Option<hir::LocalDefId>,
 }
 
 impl LocalEntryPoint {
+    pub fn body_local_def_id(&self) -> hir::LocalDefId {
+        self.body_local_def_id.unwrap_or(self.local_def_id)
+    }
+
     pub fn path_str<'tcx>(&self, tcx: TyCtxt<'tcx>) -> String {
         res::def_id_path(tcx, self.local_def_id.to_def_id()).iter()
             .skip(1) // Skip crate name in entry point path strings.
@@ -346,7 +351,10 @@ impl<'a> EntryPoints<'a> {
             EntryPoints::Tests(tests) => {
                 let iter = tests.iter()
                     .filter(|test| !test.ignore)
-                    .map(|test| LocalEntryPoint { local_def_id: test.def_id });
+                    .map(|test| match &test.kind {
+                        &TestKind::Test => LocalEntryPoint { local_def_id: test.def_id, body_local_def_id: None },
+                        &TestKind::QuickCheck { original_def_id } => LocalEntryPoint { local_def_id: test.def_id, body_local_def_id: Some(original_def_id) },
+                    });
                 Box::new(iter)
             },
             EntryPoints::External => Box::new(iter::empty()),
@@ -559,7 +567,7 @@ pub fn reachable_fns<'ast, 'tcx, 'ent>(
     let mut previously_found_callees: FxHashSet<Callee<'tcx>> = Default::default();
 
     for entry_point in entry_points.iter() {
-        let body_mir = tcx.instance_mir(ty::InstanceKind::Item(entry_point.local_def_id.to_def_id()));
+        let body_mir = tcx.instance_mir(ty::InstanceKind::Item(entry_point.body_local_def_id().to_def_id()));
 
         // NOTE: We expect entry points to be non-polymorphic (i.e. no type or const generic) functions.
         //       This is because we cannot build a complete call graph with uninstantiated type and const parameters.
@@ -915,7 +923,8 @@ pub fn reachable_fns<'ast, 'tcx, 'ent>(
                 _ => None,
             };
             let mut call_trace = CallTrace { root: entry_point, nested_calls: smallvec![call.callee] };
-            let entry_point = LocalEntryPoint { local_def_id: entry_point };
+            // HACK: We can discard any def body overrides for entry points, as we have already collected all call information from them.
+            let entry_point = LocalEntryPoint { local_def_id: entry_point, body_local_def_id: None };
             record_nested_targets(tcx, def_res, krate, &test_def_ids, &callee_lookup_cache, entry_point, targeting, unsafety, &mut call_trace, &mut targets, trace_length_limit);
         }
     }

mutest-emit/src/analysis/tests.rs

@@ -10,13 +10,19 @@ use crate::analysis::ast_lowering;
 use crate::analysis::hir;
 use crate::codegen::ast;
 use crate::codegen::ast::visit::Visitor;
-use crate::codegen::symbols::{DUMMY_SP, FileNameDisplayPreference, Ident, Symbol, path, sym};
+use crate::codegen::symbols::{DUMMY_SP, ExpnKind, FileNameDisplayPreference, Ident, MacroKind, Symbol, path, sym};
+
+pub enum TestKind {
+    Test,
+    QuickCheck { original_def_id: hir::LocalDefId },
+}
 
 pub struct Test {
     pub path: Vec<Ident>,
     pub descriptor: Box<ast::Item>,
     pub item: Box<ast::Item>,
     pub def_id: hir::LocalDefId,
+    pub kind: TestKind,
     pub ignore: bool,
 }
 
@@ -58,7 +64,7 @@ fn is_test_case(item: &ast::Item) -> bool {
     item.attrs.iter().any(|attr| attr.has_name(sym::rustc_test_marker))
 }
 
-fn extract_expanded_tests(def_res: &ast_lowering::DefResolutions, path: &[Ident], items: &[Box<ast::Item>]) -> Vec<Test> {
+fn extract_expanded_tests<'tcx>(tcx: TyCtxt<'tcx>, def_res: &ast_lowering::DefResolutions, path: &[Ident], items: &[Box<ast::Item>]) -> Vec<Test> {
     let mut tests = vec![];
 
     let mut item_iterator = items.iter();
@@ -74,29 +80,54 @@ fn extract_expanded_tests(def_res: &ast_lowering::DefResolutions, path: &[Ident]
 
         let Some(ident) = test_case.kind.ident() else { panic!("encountered test case without ident"); };
 
+        let mut kind = TestKind::Test;
+        let expn_data = test_item.span.ctxt().outer_expn_data();
+        let expn_macro_crate_name = expn_data.macro_def_id.map(|def_id| tcx.crate_name(def_id.krate).as_str().to_owned());
+        match (expn_macro_crate_name.as_deref(), expn_data.kind) {
+            (Some("quickcheck"), ExpnKind::Macro(MacroKind::Bang, _)) => {
+                if let ast::ItemKind::Fn(fn_item) = &test_item.kind && let Some(body) = &fn_item.body {
+                    if let [original_fn_item_stmt, _] = &body.stmts[..] && let ast::StmtKind::Item(original_fn_item) = &original_fn_item_stmt.kind {
+                        let Some(original_def_id) = def_res.node_id_to_def_id.get(&original_fn_item.id).copied() else { unreachable!(); };
+                        kind = TestKind::QuickCheck { original_def_id };
+                    }
+                }
+            }
+            (Some("quickcheck_macros"), ExpnKind::Macro(MacroKind::Attr, _)) => {
+                if let ast::ItemKind::Fn(fn_item) = &test_item.kind && let Some(body) = &fn_item.body {
+                    if let [original_fn_item_stmt, _] = &body.stmts[..] && let ast::StmtKind::Item(original_fn_item) = &original_fn_item_stmt.kind {
+                        let Some(original_def_id) = def_res.node_id_to_def_id.get(&original_fn_item.id).copied() else { unreachable!(); };
+                        kind = TestKind::QuickCheck { original_def_id };
+                    }
+                }
+            }
+            _ => {}
+        }
+
         let ignore = test_item.attrs.iter().any(|attr| attr.has_name(sym::ignore));
 
         tests.push(Test {
             path: path.iter().copied().chain(iter::once(ident)).collect(),
             descriptor: test_case.to_owned(),
             item: test_item.to_owned(),
             def_id,
+            kind,
             ignore,
         });
     }
 
     tests
 }
 
-struct TestCollector<'op> {
+struct TestCollector<'tcx, 'op> {
+    tcx: TyCtxt<'tcx>,
+    def_res: &'op ast_lowering::DefResolutions,
     current_path: Vec<Ident>,
     tests: Vec<Test>,
-    def_res: &'op ast_lowering::DefResolutions,
 }
 
-impl<'ast, 'op> ast::visit::Visitor<'ast> for TestCollector<'op> {
+impl<'tcx, 'ast, 'op> ast::visit::Visitor<'ast> for TestCollector<'tcx, 'op> {
     fn visit_crate(&mut self, krate: &'ast ast::Crate) {
-        let mut tests = extract_expanded_tests(self.def_res, &self.current_path, &krate.items);
+        let mut tests = extract_expanded_tests(self.tcx, self.def_res, &self.current_path, &krate.items);
         self.tests.append(&mut tests);
 
         ast::visit::walk_crate(self, krate);
@@ -108,7 +139,7 @@ impl<'ast, 'op> ast::visit::Visitor<'ast> for TestCollector<'op> {
 
             if let Some(ident) = ident { self.current_path.push(ident); }
 
-            let mut tests = extract_expanded_tests(self.def_res, &self.current_path, &items);
+            let mut tests = extract_expanded_tests(self.tcx, self.def_res, &self.current_path, &items);
             self.tests.append(&mut tests);
 
             ast::visit::walk_item(self, item);
@@ -118,8 +149,8 @@ impl<'ast, 'op> ast::visit::Visitor<'ast> for TestCollector<'op> {
     }
 }
 
-pub fn collect_tests(krate: &ast::Crate, def_res: &ast_lowering::DefResolutions) -> Vec<Test> {
-    let mut collector = TestCollector { current_path: vec![], tests: vec![], def_res };
+pub fn collect_tests<'tcx>(tcx: TyCtxt<'tcx>, krate: &ast::Crate, def_res: &ast_lowering::DefResolutions) -> Vec<Test> {
+    let mut collector = TestCollector { tcx, def_res, current_path: vec![], tests: vec![] };
     collector.visit_crate(krate);
 
     collector.tests
@@ -237,6 +268,7 @@ fn extract_and_mark_expanded_embedded_tests(sess: &Session, def_res: &ast_loweri
             descriptor,
             item: test_item,
             def_id,
+            kind: TestKind::Test,
             ignore,
         });
 

tests/ui/test_discovery/auxiliary/quickcheck.rs

@@ -0,0 +1,25 @@
+#![crate_type = "lib"]
+
+#[macro_export]
+macro_rules! quickcheck {
+    {
+        $(#[$m:meta])*
+        fn $fn_name:ident($($arg_name:ident : $arg_ty:ty),*) -> $ret:ty {
+            $($code:tt)*
+        }
+    } => (
+        #[test]
+        $(#[$m])*
+        fn $fn_name() {
+            fn prop($($arg_name: $arg_ty),*) -> $ret {
+                $($code)*
+            }
+            $crate::quickcheck(prop as fn($($arg_ty),*) -> $ret);
+        }
+    )
+}
+
+// Dummy implementation of the underlying quickcheck tester.
+pub fn quickcheck(f: fn(u32, u32) -> bool) {
+    assert!(f(0, 0));
+}

tests/ui/test_discovery/auxiliary/quickcheck_macros.rs

@@ -0,0 +1,34 @@
+//@ edition: 2024
+
+#![crate_type = "proc-macro"]
+
+#![feature(proc_macro_quote)]
+
+extern crate proc_macro;
+
+use proc_macro::{Ident, Span, TokenStream, TokenTree, quote};
+
+#[proc_macro_attribute]
+pub fn quickcheck(_args: TokenStream, input: TokenStream) -> TokenStream {
+    let mut original_ident = None;
+
+    let prop_fn = input.into_iter()
+        .map(|token_tree| {
+            // HACK: Find first ident, ignoring the `fn` keyword.
+            if let TokenTree::Ident(ident) = &token_tree && ident.to_string() != "fn" && let None = &original_ident {
+                original_ident = Some(ident.clone());
+            }
+            token_tree
+        })
+        .collect::<TokenStream>();
+
+    let Some(ident) = original_ident else { panic!("cannot find prop fn ident"); };
+
+    quote! {
+        #[test]
+        fn $ident() {
+            $prop_fn
+            ::quickcheck::quickcheck($ident as fn(u32, u32) -> bool);
+        }
+    }
+}

tests/ui/test_discovery/quickcheck.rs

@@ -0,0 +1,26 @@
+//@ print-tests
+//@ print-targets
+//@ stdout
+//@ stderr: empty
+//@ aux-build: quickcheck.rs
+//@ aux-build: quickcheck_macros.rs
+
+extern crate quickcheck;
+extern crate quickcheck_macros;
+
+use quickcheck_macros::quickcheck;
+
+fn mutable_fn(a: u32, b: u32) -> u32 {
+    a + b
+}
+
+quickcheck::quickcheck! {
+    fn quickcheck_decl_macro_test(a: u32, b: u32) -> bool {
+        a + b == mutable_fn(a, b)
+    }
+}
+
+#[quickcheck]
+fn quickcheck_attr_macro_test(a: u32, b: u32) -> bool {
+    a + b == mutable_fn(a, b)
+}

tests/ui/test_discovery/quickcheck.stdout

@@ -0,0 +1,15 @@
+
+@@@ tests @@@
+
+test quickcheck_attr_macro_test
+test quickcheck_decl_macro_test
+
+tests: 2 total; 0 ignored
+
+@@@ targets @@@
+
+tests -(0)-> mutable_fn at tests/ui/test_discovery/quickcheck.rs:13:1: 13:37 (#0)
+  (0) quickcheck_attr_macro_test
+  (0) quickcheck_decl_macro_test
+
+targets: 1 total; 1 safe; 0 unsafe (0 tainted)