feat(call_graph): Add option for an explicit call graph trace length limit

Author: zalanlevai

mutest-driver-cli/src/lib.rs

@@ -133,6 +133,7 @@ pub fn command() -> clap::Command {
         .group(clap::ArgGroup::new("unsafe-targeting").args(&["safe", "cautious", "risky", "unsafe"]).multiple(false))
         .arg(clap::arg!(--"mutation-operators" [MUTATION_OPERATORS] "Mutation operators to apply to the code, separated by commas.").value_delimiter(',').value_parser(mutation_operators::possible_values()).default_value("all").display_order(115))
         .arg(clap::arg!(--"call-graph-depth-limit" [CALL_GRAPH_DEPTH_LIMIT] "Limit depth of call graph analysis, which is complete by default.").value_parser(clap::value_parser!(usize)).display_order(150))
+        .arg(clap::arg!(--"call-graph-trace-length-limit" [CALL_GRAPH_TRACE_LENGTH_LIMIT] "Limit maximum length of analyzed call traces during call graph analysis, which is complete by default.").value_parser(clap::value_parser!(usize)).display_order(150))
         .arg(clap::arg!(-d --depth [DEPTH] "Callees of each test function are mutated up to the specified depth.").default_value("3").value_parser(clap::value_parser!(usize)).display_order(150))
         .arg(clap::arg!(--"mutant-batch-algorithm" [MUTANT_BATCH_ALGORITHM] "Algorithm to use to batch mutations into mutants.").value_parser(mutant_batch_algorithm::possible_values()).default_value(mutant_batch_algorithm::NONE).display_order(199))
         .arg(clap::arg!(--"mutant-batch-size" [MUTANT_BATCH_SIZE] "Maximum number of mutations to batch into a single mutant.").default_value("1").value_parser(clap::value_parser!(usize)).display_order(199))

mutest-driver/src/config.rs

@@ -96,6 +96,7 @@ pub struct Options<'op, 'm> {
     pub unsafe_targeting: UnsafeTargeting,
     pub operators: Operators<'op, 'm>,
     pub call_graph_depth_limit: Option<usize>,
+    pub call_graph_trace_length_limit: Option<usize>,
     pub mutation_depth: usize,
     pub mutation_batching_algorithm: MutationBatchingAlgorithm,
     pub mutation_batching_randomness: MutationBatchingRandomness,

mutest-driver/src/main.rs

@@ -237,6 +237,7 @@ pub fn main() {
         };
 
         let mut call_graph_depth_limit = mutest_arg_matches.get_one::<usize>("call-graph-depth-limit").copied();
+        let mut call_graph_trace_length_limit = mutest_arg_matches.get_one::<usize>("call-graph-trace-length-limit").copied();
         let mutation_depth = *mutest_arg_matches.get_one::<usize>("depth").unwrap();
 
         if let Some(call_graph_depth_limit_value) = call_graph_depth_limit && call_graph_depth_limit_value < mutation_depth {
@@ -248,6 +249,15 @@ pub fn main() {
             call_graph_depth_limit = None;
         }
 
+        if let Some(call_graph_trace_length_limit_value) = call_graph_trace_length_limit && call_graph_trace_length_limit_value < mutation_depth {
+            let mut diagnostic = early_dcx.early_struct_warn("explicit call graph trace length limit argument ignored as mutation depth exceeds it");
+            diagnostic.note(format!("mutation depth is set to {mutation_depth}"));
+            diagnostic.note(format!("call graph trace length limit was explicitly set to {call_graph_trace_length_limit_value}, but will be ignored"));
+            diagnostic.emit();
+
+            call_graph_trace_length_limit = None;
+        }
+
         let mutation_batching_algorithm = {
             use mutest_driver_cli::mutant_batch_algorithm as opts;
 
@@ -333,6 +343,7 @@ pub fn main() {
                 unsafe_targeting,
                 operators: &mutation_operators,
                 call_graph_depth_limit,
+                call_graph_trace_length_limit,
                 mutation_depth,
                 mutation_batching_algorithm,
                 mutation_batching_randomness,

mutest-driver/src/passes/analysis.rs

@@ -122,19 +122,19 @@ pub fn run(config: &mut Config) -> CompilerResult<Option<AnalysisPassResult>> {
 
             let all_mutable_fns_count = mutest_emit::analysis::call_graph::all_mutable_fns(tcx, &tests).count();
 
-            let call_graph_depth_limit = match opts.call_graph_depth_limit {
-                Some(call_graph_depth_limit) => {
-                    if call_graph_depth_limit < opts.mutation_depth {
-                        tcx.dcx().fatal("mutation depth exceeds explicit call graph depth limit argument");
-                    }
-                    Some(call_graph_depth_limit)
-                }
-                None => None,
-            };
+            let call_graph_depth_limit = opts.call_graph_depth_limit;
+            if let Some(v) = call_graph_depth_limit && v < opts.mutation_depth {
+                tcx.dcx().fatal("mutation depth exceeds explicit call graph depth limit argument");
+            }
+
+            let call_graph_trace_length_limit = opts.call_graph_trace_length_limit;
+            if let Some(v) = call_graph_trace_length_limit && v < opts.mutation_depth {
+                tcx.dcx().fatal("mutation depth exceeds explicit call graph trace length limit argument");
+            }
 
             let t_target_analysis_start = Instant::now();
 
-            let (call_graph, mut reachable_fns) = mutest_emit::analysis::call_graph::reachable_fns(tcx, &def_res, &generated_crate_ast, &tests, call_graph_depth_limit);
+            let (call_graph, mut reachable_fns) = mutest_emit::analysis::call_graph::reachable_fns(tcx, &def_res, &generated_crate_ast, &tests, call_graph_depth_limit, call_graph_trace_length_limit);
             let mut json_definitions = Default::default();
             if let Some(write_opts) = &opts.write_opts {
                 let t_write_start = Instant::now();

mutest-emit/src/analysis/call_graph.rs

@@ -347,6 +347,7 @@ pub fn reachable_fns<'ast, 'tcx, 'tst>(
     krate: &'ast ast::Crate,
     tests: &'tst [Test],
     depth_limit: Option<usize>,
+    trace_length_limit: Option<usize>,
 ) -> (CallGraph<'tcx>, Vec<Target<'tst>>) {
     let mut call_graph = CallGraph {
         virtual_calls_count: 0,
@@ -613,6 +614,7 @@ pub fn reachable_fns<'ast, 'tcx, 'tst>(
         unsafety: Option<UnsafeSource>,
         call_trace: &mut CallTrace<'tcx>,
         targets: &mut FxHashMap<hir::LocalDefId, Target<'tst>>,
+        trace_length_limit: Option<usize>,
     ) {
         let &[.., caller] = &call_trace.nested_calls[..] else { return; };
 
@@ -670,6 +672,11 @@ pub fn reachable_fns<'ast, 'tcx, 'tst>(
             entry_point.unsafe_call_path = Ord::max(unsafety, entry_point.unsafe_call_path);
         }
 
+        if let Some(trace_length_limit) = trace_length_limit && call_trace.nested_calls.len() >= trace_length_limit {
+            tcx.dcx().warn("exceeded explicit call graph trace length limit");
+            return;
+        }
+
         for &call in callee_lookup_cache.callees_of_nested_caller(caller) {
             // We have encontered a recursion point along this call trace; end the search along this trace.
             if call_trace.nested_calls.iter().any(|callee_in_trace| call.callee == *callee_in_trace) { continue; }
@@ -681,7 +688,7 @@ pub fn reachable_fns<'ast, 'tcx, 'tst>(
                 hir::Safety::Unsafe => Some(UnsafeSource::Unsafe),
             };
 
-            record_targets(tcx, def_res, krate, test_def_ids, callee_lookup_cache, test, unsafety, call_trace, targets);
+            record_targets(tcx, def_res, krate, test_def_ids, callee_lookup_cache, test, unsafety, call_trace, targets, trace_length_limit);
 
             call_trace.nested_calls.pop();
         }
@@ -694,7 +701,7 @@ pub fn reachable_fns<'ast, 'tcx, 'tst>(
             let Some(test) = tests.iter().find(|test| test.def_id == entry_point) else { unreachable!() };
             let unsafety = None;
             let mut call_trace = CallTrace { root: entry_point, nested_calls: smallvec![call.callee] };
-            record_targets(tcx, def_res, krate, &test_def_ids, &callee_lookup_cache, test, unsafety, &mut call_trace, &mut targets);
+            record_targets(tcx, def_res, krate, &test_def_ids, &callee_lookup_cache, test, unsafety, &mut call_trace, &mut targets, trace_length_limit);
         }
     }
 

tests/ui/args/ignore_explicit_call_graph_trace_length_limit_arg_if_mutation_depth_exceeds_it.rs

@@ -0,0 +1,3 @@
+//@ build
+//@ stderr
+//@ mutest-flags: --call-graph-trace-length-limit=3 --depth=5

tests/ui/args/ignore_explicit_call_graph_trace_length_limit_arg_if_mutation_depth_exceeds_it.stderr

@@ -0,0 +1,5 @@
+warning: explicit call graph trace length limit argument ignored as mutation depth exceeds it
+  |
+  = note: mutation depth is set to 5
+  = note: call graph trace length limit was explicitly set to 3, but will be ignored
+

tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs

@@ -0,0 +1,28 @@
+//@ print-call-graph
+//@ print-targets
+//@ stdout
+//@ stderr
+//@ mutest-flags: -v --call-graph-trace-length-limit=3
+
+fn depth_5() {}
+
+fn depth_4() {
+    depth_5();
+}
+
+fn depth_3() {
+    depth_4();
+}
+
+fn depth_2() {
+    depth_3();
+}
+
+fn depth_1() {
+    depth_2();
+}
+
+#[test]
+fn test() {
+    depth_1();
+}

tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.stderr

@@ -0,0 +1,4 @@
+warning: exceeded explicit call graph trace length limit
+
+warning: 1 warning emitted
+

tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.stdout

@@ -0,0 +1,43 @@
+built call graph with depth of 5
+reached 60.00% of functions from tests (3 out of 5 functions)
+
+@@@ call graph @@@
+
+entry points:
+
+test test
+  -> depth_1 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:21:1: 21:13 (#0)
+
+nested calls at distance 1:
+
+depth_1 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:21:1: 21:13 (#0)
+  -> depth_2 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:17:1: 17:13 (#0)
+
+nested calls at distance 2:
+
+depth_2 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:17:1: 17:13 (#0)
+  -> depth_3 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:13:1: 13:13 (#0)
+
+nested calls at distance 3:
+
+depth_3 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:13:1: 13:13 (#0)
+  -> depth_4 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:9:1: 9:13 (#0)
+
+nested calls at distance 4:
+
+depth_4 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:9:1: 9:13 (#0)
+  -> depth_5 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:7:1: 7:13 (#0)
+
+
+@@@ targets @@@
+
+tests -(2)-> depth_3 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:13:1: 13:13 (#0)
+  (2) test
+
+tests -(1)-> depth_2 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:17:1: 17:13 (#0)
+  (1) test
+
+tests -(0)-> depth_1 at tests/ui/call_graph/warn_on_incomplete_call_graph_due_to_explicit_trace_length_limit.rs:21:1: 21:13 (#0)
+  (0) test
+
+targets: 3 total; 3 safe; 0 unsafe (0 tainted)