src/test/run-make-fulldeps/coverage/lib/used_crate.rs

   1 #![allow(unused_assignments, unused_variables)]
   2 // compile-flags: -C opt-level=3 # validates coverage now works with optimizations
   3 use std::fmt::Debug;
   4
   5 pub fn used_function() {
   6     // Initialize test constants in a way that cannot be determined at compile time, to ensure
   7     // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
   8     // dependent conditions.
   9     let is_true = std::env::args().len() == 1;
  10     let mut countdown = 0;
  11     if is_true {
  12         countdown = 10;
  13     }
  14     use_this_lib_crate();
  15 }
  16
  17 pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
  18     println!("used_only_from_bin_crate_generic_function with {:?}", arg);
  19 }
  20 // Expect for above function: `Unexecuted instantiation` (see below)
  21 pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
  22     println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
  23 }
  24
  25 pub fn used_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
  26     println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
  27 }
  28
  29 pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
  30     println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
  31 }
  32
  33 pub fn unused_generic_function<T: Debug>(arg: T) {
  34     println!("unused_generic_function with {:?}", arg);
  35 }
  36
  37 pub fn unused_function() {
  38     let is_true = std::env::args().len() == 1;
  39     let mut countdown = 2;
  40     if !is_true {
  41         countdown = 20;
  42     }
  43 }
  44
  45 fn unused_private_function() {
  46     let is_true = std::env::args().len() == 1;
  47     let mut countdown = 2;
  48     if !is_true {
  49         countdown = 20;
  50     }
  51 }
  52
  53 fn use_this_lib_crate() {
  54     used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");
  55     used_with_same_type_from_bin_crate_and_lib_crate_generic_function(
  56         "used from library used_crate.rs",
  57     );
  58     let some_vec = vec![5, 6, 7, 8];
  59     used_only_from_this_lib_crate_generic_function(some_vec);
  60     used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");
  61 }
  62
  63 // FIXME(#79651): "Unexecuted instantiation" errors appear in coverage results,
  64 // for example:
  65 //
  66 // | Unexecuted instantiation: used_crate::used_only_from_bin_crate_generic_function::<_>
  67 //
  68 // These notices appear when `llvm-cov` shows instantiations. This may be a
  69 // default option, but it can be suppressed with:
  70 //
  71 // ```shell
  72 // $ `llvm-cov show --show-instantiations=0 ...`
  73 // ```
  74 //
  75 // The notice is triggered because the function is unused by the library itself,
  76 // and when the library is compiled, a synthetic function is generated, so
  77 // unused function coverage can be reported. Coverage can be skipped for unused
  78 // generic functions with:
  79 //
  80 // ```shell
  81 // $ `rustc -Zunstable-options -C instrument-coverage=except-unused-generics ...`
  82 // ```
  83 //
  84 // Even though this function is used by `uses_crate.rs` (and
  85 // counted), with substitutions for `T`, those instantiations are only generated
  86 // when the generic function is actually used (from the binary, not from this
  87 // library crate). So the test result shows coverage for all instantiated
  88 // versions and their generic type substitutions, plus the `Unexecuted
  89 // instantiation` message for the non-substituted version. This is valid, but
  90 // unfortunately a little confusing.
  91 //
  92 // The library crate has its own coverage map, and the only way to show unused
  93 // coverage of a generic function is to include the generic function in the
  94 // coverage map, marked as an "unused function". If the library were used by
  95 // another binary that never used this generic function, then it would be valid
  96 // to show the unused generic, with unknown substitution (`_`).
  97 //
  98 // The alternative is to exclude all generics from being included in the "unused
  99 // functions" list, which would then omit coverage results for
 100 // `unused_generic_function<T>()`, below.