tests/coverage/holes.rs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//@ edition: 2021

// Nested items/closures should be treated as "holes", so that their spans are
// not displayed as executable code in the enclosing function.

use core::hint::black_box;

fn main() {
    black_box(());

    static MY_STATIC: () = ();

    black_box(());

    const MY_CONST: () = ();

    // Splitting this across multiple lines makes it easier to see where the
    // coverage mapping regions begin and end.
    #[rustfmt::skip]
    let _closure =
        |
            _arg: (),
        |
        {
            black_box(());
        }
        ;

    black_box(());

    fn _unused_fn() {}

    black_box(());

    struct MyStruct {
        _x: u32,
        _y: u32,
    }

    black_box(());

    impl MyStruct {
        fn _method(&self) {}
    }

    black_box(());

    trait MyTrait {}

    black_box(());

    impl MyTrait for MyStruct {}

    black_box(());

    macro_rules! _my_macro {
        () => {};
    }

    black_box(());

    #[rustfmt::skip]
    let _const =
        const
        {
            7 + 4
        }
        ;

    black_box(());

    #[rustfmt::skip]
    let _async =
        async
        {
            7 + 4
        }
        ;

    black_box(());

    // This tests the edge case of a const block nested inside an "anon const",
    // such as the length of an array literal. Handling this case requires
    // `nested_filter::OnlyBodies` or equivalent.
    #[rustfmt::skip]
    let _const_block_inside_anon_const =
        [
            0
            ;
            7
            +
            const
            {
                3
            }
        ]
        ;

    black_box(());
}