149 lines
7.9 KiB
Plaintext
149 lines
7.9 KiB
Plaintext
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| 1|pub fn used_function() {
|
|
6| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure
|
|
7| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
|
|
8| 1| // dependent conditions.
|
|
9| 1| let is_true = std::env::args().len() == 1;
|
|
10| 1| let mut countdown = 0;
|
|
11| 1| if is_true {
|
|
12| 1| countdown = 10;
|
|
13| 1| }
|
|
^0
|
|
14| 1| use_this_lib_crate();
|
|
15| 1|}
|
|
16| |
|
|
17| 2|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
|
|
18| 2| println!("used_only_from_bin_crate_generic_function with {:?}", arg);
|
|
19| 2|}
|
|
------------------
|
|
| used_crate::used_only_from_bin_crate_generic_function::<&str>:
|
|
| 17| 1|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
|
|
| 18| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg);
|
|
| 19| 1|}
|
|
------------------
|
|
| used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>:
|
|
| 17| 1|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
|
|
| 18| 1| println!("used_only_from_bin_crate_generic_function with {:?}", arg);
|
|
| 19| 1|}
|
|
------------------
|
|
| Unexecuted instantiation: used_crate::used_only_from_bin_crate_generic_function::<_>
|
|
------------------
|
|
20| |// Expect for above function: `Unexecuted instantiation` (see below)
|
|
21| 2|pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
22| 2| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
|
|
23| 2|}
|
|
------------------
|
|
| used_crate::used_only_from_this_lib_crate_generic_function::<alloc::vec::Vec<i32>>:
|
|
| 21| 1|pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 22| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
|
|
| 23| 1|}
|
|
------------------
|
|
| used_crate::used_only_from_this_lib_crate_generic_function::<&str>:
|
|
| 21| 1|pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 22| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
|
|
| 23| 1|}
|
|
------------------
|
|
24| |
|
|
25| 2|pub fn used_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
26| 2| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
27| 2|}
|
|
------------------
|
|
| used_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>:
|
|
| 25| 1|pub fn used_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 26| 1| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
| 27| 1|}
|
|
------------------
|
|
| used_crate::used_from_bin_crate_and_lib_crate_generic_function::<&str>:
|
|
| 25| 1|pub fn used_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 26| 1| println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
| 27| 1|}
|
|
------------------
|
|
28| |
|
|
29| 2|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
30| 2| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
31| 2|}
|
|
------------------
|
|
| used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>:
|
|
| 29| 1|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 30| 1| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
| 31| 1|}
|
|
------------------
|
|
| used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>:
|
|
| 29| 1|pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function<T: Debug>(arg: T) {
|
|
| 30| 1| println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);
|
|
| 31| 1|}
|
|
------------------
|
|
32| |
|
|
33| 0|pub fn unused_generic_function<T: Debug>(arg: T) {
|
|
34| 0| println!("unused_generic_function with {:?}", arg);
|
|
35| 0|}
|
|
36| |
|
|
37| 0|pub fn unused_function() {
|
|
38| 0| let is_true = std::env::args().len() == 1;
|
|
39| 0| let mut countdown = 2;
|
|
40| 0| if !is_true {
|
|
41| 0| countdown = 20;
|
|
42| 0| }
|
|
43| 0|}
|
|
44| |
|
|
45| 0|fn unused_private_function() {
|
|
46| 0| let is_true = std::env::args().len() == 1;
|
|
47| 0| let mut countdown = 2;
|
|
48| 0| if !is_true {
|
|
49| 0| countdown = 20;
|
|
50| 0| }
|
|
51| 0|}
|
|
52| |
|
|
53| 1|fn use_this_lib_crate() {
|
|
54| 1| used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");
|
|
55| 1| used_with_same_type_from_bin_crate_and_lib_crate_generic_function(
|
|
56| 1| "used from library used_crate.rs",
|
|
57| 1| );
|
|
58| 1| let some_vec = vec![5, 6, 7, 8];
|
|
59| 1| used_only_from_this_lib_crate_generic_function(some_vec);
|
|
60| 1| used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");
|
|
61| 1|}
|
|
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.
|
|
|