$DIR/auxiliary/used_crate.rs: LL| |#![allow(unused_assignments, unused_variables)] LL| |// compile-flags: -C opt-level=3 LL| |use std::fmt::Debug; // ^^ validates coverage now works with optimizations LL| | LL| 1|pub fn used_function() { LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure LL| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from LL| 1| // dependent conditions. LL| 1| let is_true = std::env::args().len() == 1; LL| 1| let mut countdown = 0; LL| 1| if is_true { LL| 1| countdown = 10; LL| 1| } ^0 LL| 1| use_this_lib_crate(); LL| 1|} LL| | LL| 2|pub fn used_only_from_bin_crate_generic_function(arg: T) { LL| 2| println!("used_only_from_bin_crate_generic_function with {:?}", arg); LL| 2|} ------------------ | Unexecuted instantiation: used_crate::used_only_from_bin_crate_generic_function::<_> ------------------ | used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec>: | LL| 1|pub fn used_only_from_bin_crate_generic_function(arg: T) { | LL| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ | used_crate::used_only_from_bin_crate_generic_function::<&str>: | LL| 1|pub fn used_only_from_bin_crate_generic_function(arg: T) { | LL| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ LL| |// Expect for above function: `Unexecuted instantiation` (see below) LL| 2|pub fn used_only_from_this_lib_crate_generic_function(arg: T) { LL| 2| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg); LL| 2|} ------------------ | used_crate::used_only_from_this_lib_crate_generic_function::<&str>: | LL| 1|pub fn used_only_from_this_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ | used_crate::used_only_from_this_lib_crate_generic_function::>: | LL| 1|pub fn used_only_from_this_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ LL| | LL| 2|pub fn used_from_bin_crate_and_lib_crate_generic_function(arg: T) { LL| 2| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); LL| 2|} ------------------ | used_crate::used_from_bin_crate_and_lib_crate_generic_function::<&str>: | LL| 1|pub fn used_from_bin_crate_and_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ | used_crate::used_from_bin_crate_and_lib_crate_generic_function::>: | LL| 1|pub fn used_from_bin_crate_and_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ LL| | LL| 2|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function(arg: T) { LL| 2| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); LL| 2|} ------------------ | used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>: | LL| 1|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ | used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>: | LL| 1|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function(arg: T) { | LL| 1| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg); | LL| 1|} ------------------ LL| | LL| 0|pub fn unused_generic_function(arg: T) { LL| 0| println!("unused_generic_function with {:?}", arg); LL| 0|} LL| | LL| 0|pub fn unused_function() { LL| 0| let is_true = std::env::args().len() == 1; LL| 0| let mut countdown = 2; LL| 0| if !is_true { LL| 0| countdown = 20; LL| 0| } LL| 0|} LL| | LL| 0|fn unused_private_function() { LL| 0| let is_true = std::env::args().len() == 1; LL| 0| let mut countdown = 2; LL| 0| if !is_true { LL| 0| countdown = 20; LL| 0| } LL| 0|} LL| | LL| 1|fn use_this_lib_crate() { LL| 1| used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs"); LL| 1| used_with_same_type_from_bin_crate_and_lib_crate_generic_function( LL| 1| "used from library used_crate.rs", LL| 1| ); LL| 1| let some_vec = vec![5, 6, 7, 8]; LL| 1| used_only_from_this_lib_crate_generic_function(some_vec); LL| 1| used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs"); LL| 1|} LL| | LL| |// FIXME(#79651): "Unexecuted instantiation" errors appear in coverage results, LL| |// for example: LL| |// LL| |// | Unexecuted instantiation: used_crate::used_only_from_bin_crate_generic_function::<_> LL| |// LL| |// These notices appear when `llvm-cov` shows instantiations. This may be a LL| |// default option, but it can be suppressed with: LL| |// LL| |// ```shell LL| |// $ `llvm-cov show --show-instantiations=0 ...` LL| |// ``` LL| |// LL| |// The notice is triggered because the function is unused by the library itself, LL| |// and when the library is compiled, a synthetic function is generated, so LL| |// unused function coverage can be reported. Coverage can be skipped for unused LL| |// generic functions with: LL| |// LL| |// ```shell LL| |// $ `rustc -Zunstable-options -C instrument-coverage=except-unused-generics ...` LL| |// ``` LL| |// LL| |// Even though this function is used by `uses_crate.rs` (and LL| |// counted), with substitutions for `T`, those instantiations are only generated LL| |// when the generic function is actually used (from the binary, not from this LL| |// library crate). So the test result shows coverage for all instantiated LL| |// versions and their generic type substitutions, plus the `Unexecuted LL| |// instantiation` message for the non-substituted version. This is valid, but LL| |// unfortunately a little confusing. LL| |// LL| |// The library crate has its own coverage map, and the only way to show unused LL| |// coverage of a generic function is to include the generic function in the LL| |// coverage map, marked as an "unused function". If the library were used by LL| |// another binary that never used this generic function, then it would be valid LL| |// to show the unused generic, with unknown substitution (`_`). LL| |// LL| |// The alternative is to exclude all generics from being included in the "unused LL| |// functions" list, which would then omit coverage results for LL| |// `unused_generic_function()`, below. $DIR/uses_crate.rs: LL| |// This test was failing on Linux for a while due to #110393 somehow making LL| |// the unused functions not instrumented, but it seems to be fine now. LL| | LL| |// Validates coverage now works with optimizations LL| |// compile-flags: -C opt-level=3 LL| | LL| |#![allow(unused_assignments, unused_variables)] LL| | LL| |// aux-build:used_crate.rs LL| |extern crate used_crate; LL| | LL| 1|fn main() { LL| 1| used_crate::used_function(); LL| 1| let some_vec = vec![1, 2, 3, 4]; LL| 1| used_crate::used_only_from_bin_crate_generic_function(&some_vec); LL| 1| used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs"); LL| 1| used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec); LL| 1| used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?"); LL| 1|}