bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #120015 - Zalathar:format, r=dtolnay

Browse source 
coverage: Format all coverage tests with `rustfmt`

As suggested by <https://github.com/rust-lang/rust/pull/119984#discussion_r1452856806>.

Test files in `tests/` are normally ignored by `x fmt`, but sometimes those files end up being run through `rustfmt` anyway, either by `rust-analyzer` or by hand.

When that happens, it's annoying to have to manually revert formatting changes that are unrelated to the actual changes being made. So it's helpful for the tests in the repository to already have standard formatting beforehand.

However, there are several coverage tests that deliberately use non-standard formatting, so that line counts reveal more information about where code regions begin and end. In those cases, we can use `#[rustfmt::skip]` to prevent that code from being disturbed.

``@rustbot`` label +A-code-coverage
This commit is contained in:
Nadrieril 2024-01-21 06:38:37 +01:00 • committed by GitHub
commit e8678b1030
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
71 changed files with 305 additions and 241 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tests/coverage/abort.cov-map
View file

@ -1,5 +1,5 @@
Function name: abort::main Function name: abort::main
Raw bytes (105): 0x[01, 01, 12, 01, 47, 05, 09, 03, 0d, 42, 11, 03, 0d, 11, 3e, 42, 11, 03, 0d, 3b, 15, 11, 3e, 42, 11, 03, 0d, 15, 36, 3b, 15, 11, 3e, 42, 11, 03, 0d, 05, 09, 0d, 01, 0d, 01, 01, 1b, 03, 02, 0b, 00, 18, 42, 01, 0c, 00, 19, 11, 00, 1a, 02, 0a, 3e, 02, 0a, 00, 0b, 3b, 02, 0c, 00, 19, 15, 00, 1a, 00, 31, 36, 00, 31, 00, 32, 33, 04, 0c, 00, 19, 05, 00, 1a, 00, 31, 09, 00, 31, 00, 32, 47, 01, 09, 00, 17, 0d, 02, 05, 01, 02] Raw bytes (105): 0x[01, 01, 12, 01, 47, 05, 09, 03, 0d, 42, 11, 03, 0d, 11, 3e, 42, 11, 03, 0d, 3b, 15, 11, 3e, 42, 11, 03, 0d, 15, 36, 3b, 15, 11, 3e, 42, 11, 03, 0d, 05, 09, 0d, 01, 0e, 01, 01, 1b, 03, 02, 0b, 00, 18, 42, 01, 0c, 00, 19, 11, 00, 1a, 02, 0a, 3e, 02, 0a, 00, 0b, 3b, 02, 0c, 00, 19, 15, 00, 1a, 00, 31, 36, 00, 31, 00, 32, 33, 04, 0c, 00, 19, 05, 00, 1a, 00, 31, 09, 00, 31, 00, 32, 47, 01, 09, 00, 17, 0d, 02, 05, 01, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 18 Number of expressions: 18
@ -22,7 +22,7 @@ Number of expressions: 18
- expression 16 operands: lhs = Expression(0, Add), rhs = Counter(3) - expression 16 operands: lhs = Expression(0, Add), rhs = Counter(3)
- expression 17 operands: lhs = Counter(1), rhs = Counter(2) - expression 17 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 13 Number of file 0 mappings: 13
- Code(Counter(0)) at (prev + 13, 1) to (start + 1, 27) - Code(Counter(0)) at (prev + 14, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24) - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
= (c0 + (c1 + c2)) = (c0 + (c1 + c2))
- Code(Expression(16, Sub)) at (prev + 1, 12) to (start + 0, 25) - Code(Expression(16, Sub)) at (prev + 1, 12) to (start + 0, 25)

1
tests/coverage/abort.coverage
View file

@ -10,6 +10,7 @@
LL| 12| } LL| 12| }
LL| 12|} LL| 12|}
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() -> Result<(), u8> { LL| 1|fn main() -> Result<(), u8> {
LL| 1| let mut countdown = 10; LL| 1| let mut countdown = 10;
LL| 11| while countdown > 0 { LL| 11| while countdown > 0 {

1
tests/coverage/abort.rs
View file

@ -10,6 +10,7 @@ extern "C" fn might_abort(should_abort: bool) {
} }
} }
#[rustfmt::skip]
fn main() -> Result<(), u8> { fn main() -> Result<(), u8> {
let mut countdown = 10; let mut countdown = 10;
while countdown > 0 { while countdown > 0 {

100
tests/coverage/async.cov-map
View file

@ -1,20 +1,20 @@
Function name: async::c Function name: async::c
Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 00, 19] Raw bytes (9): 0x[01, 01, 00, 01, 01, 09, 01, 00, 19]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 25) - Code(Counter(0)) at (prev + 9, 1) to (start + 0, 25)
Function name: async::c::{closure#0} Function name: async::c::{closure#0}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 07, 19, 01, 0e, 05, 02, 09, 00, 0a, 02, 02, 09, 00, 0a, 07, 02, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 09, 19, 01, 0e, 05, 02, 09, 00, 0a, 02, 02, 09, 00, 0a, 07, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 7, 25) to (start + 1, 14) - Code(Counter(0)) at (prev + 9, 25) to (start + 1, 14)
- Code(Counter(1)) at (prev + 2, 9) to (start + 0, 10) - Code(Counter(1)) at (prev + 2, 9) to (start + 0, 10)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10) - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c0 - c1) = (c0 - c1)
@ -22,84 +22,84 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: async::d Function name: async::d
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0f, 01, 00, 14] Raw bytes (9): 0x[01, 01, 00, 01, 01, 11, 01, 00, 14]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 15, 1) to (start + 0, 20) - Code(Counter(0)) at (prev + 17, 1) to (start + 0, 20)
Function name: async::d::{closure#0} Function name: async::d::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0f, 14, 00, 19] Raw bytes (9): 0x[01, 01, 00, 01, 01, 11, 14, 00, 19]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 15, 20) to (start + 0, 25) - Code(Counter(0)) at (prev + 17, 20) to (start + 0, 25)
Function name: async::e (unused) Function name: async::e (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 11, 01, 00, 14] Raw bytes (9): 0x[01, 01, 00, 01, 00, 13, 01, 00, 14]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 17, 1) to (start + 0, 20) - Code(Zero) at (prev + 19, 1) to (start + 0, 20)
Function name: async::e::{closure#0} (unused) Function name: async::e::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 11, 14, 00, 19] Raw bytes (9): 0x[01, 01, 00, 01, 00, 13, 14, 00, 19]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 17, 20) to (start + 0, 25) - Code(Zero) at (prev + 19, 20) to (start + 0, 25)
Function name: async::f Function name: async::f
Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 00, 14] Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 01, 00, 14]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 19, 1) to (start + 0, 20) - Code(Counter(0)) at (prev + 21, 1) to (start + 0, 20)
Function name: async::f::{closure#0} Function name: async::f::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 14, 00, 19] Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 14, 00, 19]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 19, 20) to (start + 0, 25) - Code(Counter(0)) at (prev + 21, 20) to (start + 0, 25)
Function name: async::foo (unused) Function name: async::foo (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 01, 00, 1e] Raw bytes (9): 0x[01, 01, 00, 01, 00, 17, 01, 00, 1e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 21, 1) to (start + 0, 30) - Code(Zero) at (prev + 23, 1) to (start + 0, 30)
Function name: async::foo::{closure#0} (unused) Function name: async::foo::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 15, 1e, 00, 2d] Raw bytes (9): 0x[01, 01, 00, 01, 00, 17, 1e, 00, 2d]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 21, 30) to (start + 0, 45) - Code(Zero) at (prev + 23, 30) to (start + 0, 45)
Function name: async::g Function name: async::g
Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 01, 00, 17] Raw bytes (9): 0x[01, 01, 00, 01, 01, 19, 01, 00, 17]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 23, 1) to (start + 0, 23) - Code(Counter(0)) at (prev + 25, 1) to (start + 0, 23)
Function name: async::g::{closure#0} (unused) Function name: async::g::{closure#0} (unused)
Raw bytes (69): 0x[01, 01, 00, 0d, 00, 17, 17, 01, 0c, 00, 02, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02] Raw bytes (69): 0x[01, 01, 00, 0d, 00, 19, 17, 01, 0c, 00, 02, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 09, 00, 0a, 00, 00, 0e, 00, 11, 00, 00, 12, 00, 17, 00, 00, 1b, 00, 1c, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 13 Number of file 0 mappings: 13
- Code(Zero) at (prev + 23, 23) to (start + 1, 12) - Code(Zero) at (prev + 25, 23) to (start + 1, 12)
- Code(Zero) at (prev + 2, 9) to (start + 0, 10) - Code(Zero) at (prev + 2, 9) to (start + 0, 10)
- Code(Zero) at (prev + 0, 14) to (start + 0, 17) - Code(Zero) at (prev + 0, 14) to (start + 0, 17)
- Code(Zero) at (prev + 0, 18) to (start + 0, 23) - Code(Zero) at (prev + 0, 18) to (start + 0, 23)
@ -114,20 +114,20 @@ Number of file 0 mappings: 13
- Code(Zero) at (prev + 2, 1) to (start + 0, 2) - Code(Zero) at (prev + 2, 1) to (start + 0, 2)
Function name: async::h Function name: async::h
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1f, 01, 00, 16] Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 00, 16]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 31, 1) to (start + 0, 22) - Code(Counter(0)) at (prev + 33, 1) to (start + 0, 22)
Function name: async::h::{closure#0} (unused) Function name: async::h::{closure#0} (unused)
Raw bytes (44): 0x[01, 01, 00, 08, 00, 1f, 16, 03, 0c, 00, 04, 09, 00, 0a, 00, 00, 0e, 00, 13, 00, 00, 14, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02] Raw bytes (44): 0x[01, 01, 00, 08, 00, 21, 16, 03, 0c, 00, 04, 09, 00, 0a, 00, 00, 0e, 00, 13, 00, 00, 14, 00, 19, 00, 00, 1a, 00, 1b, 00, 00, 20, 00, 22, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 8 Number of file 0 mappings: 8
- Code(Zero) at (prev + 31, 22) to (start + 3, 12) - Code(Zero) at (prev + 33, 22) to (start + 3, 12)
- Code(Zero) at (prev + 4, 9) to (start + 0, 10) - Code(Zero) at (prev + 4, 9) to (start + 0, 10)
- Code(Zero) at (prev + 0, 14) to (start + 0, 19) - Code(Zero) at (prev + 0, 14) to (start + 0, 19)
- Code(Zero) at (prev + 0, 20) to (start + 0, 25) - Code(Zero) at (prev + 0, 20) to (start + 0, 25)
@ -137,22 +137,22 @@ Number of file 0 mappings: 8
- Code(Zero) at (prev + 2, 1) to (start + 0, 2) - Code(Zero) at (prev + 2, 1) to (start + 0, 2)
Function name: async::i Function name: async::i
Raw bytes (9): 0x[01, 01, 00, 01, 01, 28, 01, 00, 13] Raw bytes (9): 0x[01, 01, 00, 01, 01, 2a, 01, 00, 13]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 40, 1) to (start + 0, 19) - Code(Counter(0)) at (prev + 42, 1) to (start + 0, 19)
Function name: async::i::{closure#0} Function name: async::i::{closure#0}
Raw bytes (78): 0x[01, 01, 02, 07, 21, 19, 1d, 0e, 01, 28, 13, 04, 0c, 0d, 05, 09, 00, 0a, 01, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 0d, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 1d, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 03, 02, 01, 00, 02] Raw bytes (78): 0x[01, 01, 02, 07, 21, 19, 1d, 0e, 01, 2a, 13, 04, 0c, 0d, 05, 09, 00, 0a, 01, 00, 0e, 00, 12, 05, 00, 13, 00, 18, 09, 00, 1c, 00, 21, 0d, 00, 27, 00, 2a, 15, 00, 2b, 00, 30, 1d, 01, 09, 00, 0a, 11, 00, 0e, 00, 11, 25, 00, 12, 00, 17, 29, 00, 1b, 00, 20, 1d, 00, 24, 00, 26, 21, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(8) - expression 0 operands: lhs = Expression(1, Add), rhs = Counter(8)
- expression 1 operands: lhs = Counter(6), rhs = Counter(7) - expression 1 operands: lhs = Counter(6), rhs = Counter(7)
Number of file 0 mappings: 14 Number of file 0 mappings: 14
- Code(Counter(0)) at (prev + 40, 19) to (start + 4, 12) - Code(Counter(0)) at (prev + 42, 19) to (start + 4, 12)
- Code(Counter(3)) at (prev + 5, 9) to (start + 0, 10) - Code(Counter(3)) at (prev + 5, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18) - Code(Counter(0)) at (prev + 0, 14) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 19) to (start + 0, 24) - Code(Counter(1)) at (prev + 0, 19) to (start + 0, 24)
@ -169,14 +169,14 @@ Number of file 0 mappings: 14
= ((c6 + c7) + c8) = ((c6 + c7) + c8)
Function name: async::j Function name: async::j
Raw bytes (53): 0x[01, 01, 02, 07, 0d, 05, 09, 09, 01, 33, 01, 13, 0c, 05, 14, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02] Raw bytes (53): 0x[01, 01, 02, 07, 0d, 05, 09, 09, 01, 35, 01, 13, 0c, 05, 14, 09, 00, 0a, 01, 00, 0e, 00, 1b, 05, 00, 1f, 00, 27, 09, 01, 09, 00, 0a, 11, 00, 0e, 00, 1a, 09, 00, 1e, 00, 20, 0d, 01, 0e, 00, 10, 03, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3) - expression 0 operands: lhs = Expression(1, Add), rhs = Counter(3)
- expression 1 operands: lhs = Counter(1), rhs = Counter(2) - expression 1 operands: lhs = Counter(1), rhs = Counter(2)
Number of file 0 mappings: 9 Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 51, 1) to (start + 19, 12) - Code(Counter(0)) at (prev + 53, 1) to (start + 19, 12)
- Code(Counter(1)) at (prev + 20, 9) to (start + 0, 10) - Code(Counter(1)) at (prev + 20, 9) to (start + 0, 10)
- Code(Counter(0)) at (prev + 0, 14) to (start + 0, 27) - Code(Counter(0)) at (prev + 0, 14) to (start + 0, 27)
- Code(Counter(1)) at (prev + 0, 31) to (start + 0, 39) - Code(Counter(1)) at (prev + 0, 31) to (start + 0, 39)
@ -188,14 +188,14 @@ Number of file 0 mappings: 9
= ((c1 + c2) + c3) = ((c1 + c2) + c3)
Function name: async::j::c Function name: async::j::c
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 35, 05, 01, 12, 05, 02, 0d, 00, 0e, 02, 0a, 0d, 00, 0e, 07, 02, 05, 00, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 37, 05, 01, 12, 05, 02, 0d, 00, 0e, 02, 0a, 0d, 00, 0e, 07, 02, 05, 00, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 53, 5) to (start + 1, 18) - Code(Counter(0)) at (prev + 55, 5) to (start + 1, 18)
- Code(Counter(1)) at (prev + 2, 13) to (start + 0, 14) - Code(Counter(1)) at (prev + 2, 13) to (start + 0, 14)
- Code(Expression(0, Sub)) at (prev + 10, 13) to (start + 0, 14) - Code(Expression(0, Sub)) at (prev + 10, 13) to (start + 0, 14)
= (c0 - c1) = (c0 - c1)
@ -203,35 +203,35 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: async::j::d Function name: async::j::d
Raw bytes (9): 0x[01, 01, 00, 01, 01, 44, 05, 00, 17] Raw bytes (9): 0x[01, 01, 00, 01, 01, 46, 05, 00, 17]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 68, 5) to (start + 0, 23) - Code(Counter(0)) at (prev + 70, 5) to (start + 0, 23)
Function name: async::j::f Function name: async::j::f
Raw bytes (9): 0x[01, 01, 00, 01, 01, 45, 05, 00, 17] Raw bytes (9): 0x[01, 01, 00, 01, 01, 47, 05, 00, 17]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 69, 5) to (start + 0, 23) - Code(Counter(0)) at (prev + 71, 5) to (start + 0, 23)
Function name: async::k (unused) Function name: async::k (unused)
Raw bytes (29): 0x[01, 01, 00, 05, 00, 4d, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02] Raw bytes (29): 0x[01, 01, 00, 05, 00, 4f, 01, 01, 0c, 00, 02, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 01, 0e, 00, 10, 00, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 5 Number of file 0 mappings: 5
- Code(Zero) at (prev + 77, 1) to (start + 1, 12) - Code(Zero) at (prev + 79, 1) to (start + 1, 12)
- Code(Zero) at (prev + 2, 14) to (start + 0, 16) - Code(Zero) at (prev + 2, 14) to (start + 0, 16)
- Code(Zero) at (prev + 1, 14) to (start + 0, 16) - Code(Zero) at (prev + 1, 14) to (start + 0, 16)
- Code(Zero) at (prev + 1, 14) to (start + 0, 16) - Code(Zero) at (prev + 1, 14) to (start + 0, 16)
- Code(Zero) at (prev + 2, 1) to (start + 0, 2) - Code(Zero) at (prev + 2, 1) to (start + 0, 2)
Function name: async::l Function name: async::l
Raw bytes (37): 0x[01, 01, 04, 01, 07, 05, 09, 0f, 02, 09, 05, 05, 01, 55, 01, 01, 0c, 02, 02, 0e, 00, 10, 05, 01, 0e, 00, 10, 09, 01, 0e, 00, 10, 0b, 02, 01, 00, 02] Raw bytes (37): 0x[01, 01, 04, 01, 07, 05, 09, 0f, 02, 09, 05, 05, 01, 57, 01, 01, 0c, 02, 02, 0e, 00, 10, 05, 01, 0e, 00, 10, 09, 01, 0e, 00, 10, 0b, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 4 Number of expressions: 4
@ -240,7 +240,7 @@ Number of expressions: 4
- expression 2 operands: lhs = Expression(3, Add), rhs = Expression(0, Sub) - expression 2 operands: lhs = Expression(3, Add), rhs = Expression(0, Sub)
- expression 3 operands: lhs = Counter(2), rhs = Counter(1) - expression 3 operands: lhs = Counter(2), rhs = Counter(1)
Number of file 0 mappings: 5 Number of file 0 mappings: 5
- Code(Counter(0)) at (prev + 85, 1) to (start + 1, 12) - Code(Counter(0)) at (prev + 87, 1) to (start + 1, 12)
- Code(Expression(0, Sub)) at (prev + 2, 14) to (start + 0, 16) - Code(Expression(0, Sub)) at (prev + 2, 14) to (start + 0, 16)
= (c0 - (c1 + c2)) = (c0 - (c1 + c2))
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 16) - Code(Counter(1)) at (prev + 1, 14) to (start + 0, 16)
@ -249,26 +249,26 @@ Number of file 0 mappings: 5
= ((c2 + c1) + (c0 - (c1 + c2))) = ((c2 + c1) + (c0 - (c1 + c2)))
Function name: async::m Function name: async::m
Raw bytes (9): 0x[01, 01, 00, 01, 01, 5d, 01, 00, 19] Raw bytes (9): 0x[01, 01, 00, 01, 01, 5f, 01, 00, 19]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 93, 1) to (start + 0, 25) - Code(Counter(0)) at (prev + 95, 1) to (start + 0, 25)
Function name: async::m::{closure#0} (unused) Function name: async::m::{closure#0} (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 5d, 19, 00, 22] Raw bytes (9): 0x[01, 01, 00, 01, 00, 5f, 19, 00, 22]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 93, 25) to (start + 0, 34) - Code(Zero) at (prev + 95, 25) to (start + 0, 34)
Function name: async::main Function name: async::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 5f, 01, 08, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 61, 01, 08, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 95, 1) to (start + 8, 2) - Code(Counter(0)) at (prev + 97, 1) to (start + 8, 2)

2
tests/coverage/async.coverage
View file

@ -1,6 +1,8 @@
LL| |#![feature(coverage_attribute)] LL| |#![feature(coverage_attribute)]
LL| |#![feature(custom_inner_attributes)] // for #![rustfmt::skip]
LL| |#![feature(noop_waker)] LL| |#![feature(noop_waker)]
LL| |#![allow(unused_assignments, dead_code)] LL| |#![allow(unused_assignments, dead_code)]
LL| |#![rustfmt::skip]
LL| |// edition: 2018 LL| |// edition: 2018
LL| |// compile-flags: -Copt-level=1 LL| |// compile-flags: -Copt-level=1
LL| | LL| |

2
tests/coverage/async.rs
View file

@ -1,6 +1,8 @@
#![feature(coverage_attribute)] #![feature(coverage_attribute)]
#![feature(custom_inner_attributes)] // for #![rustfmt::skip]
#![feature(noop_waker)] #![feature(noop_waker)]
#![allow(unused_assignments, dead_code)] #![allow(unused_assignments, dead_code)]
#![rustfmt::skip]
// edition: 2018 // edition: 2018
// compile-flags: -Copt-level=1 // compile-flags: -Copt-level=1

84
tests/coverage/closure.cov-map
View file

@ -1,12 +1,12 @@
Function name: closure::main Function name: closure::main
Raw bytes (128): 0x[01, 01, 02, 01, 05, 05, 02, 18, 01, 08, 01, 0f, 0d, 01, 16, 0e, 06, 0a, 01, 10, 05, 13, 0d, 01, 1a, 0e, 06, 0a, 01, 10, 05, 0c, 16, 01, 16, 05, 0d, 18, 01, 19, 09, 01, 1e, 01, 04, 09, 00, 29, 01, 01, 09, 00, 2d, 01, 01, 09, 00, 24, 01, 05, 09, 00, 24, 01, 02, 09, 00, 21, 01, 04, 09, 00, 21, 01, 04, 09, 00, 28, 01, 09, 09, 00, 32, 01, 04, 09, 00, 33, 01, 07, 09, 00, 4b, 01, 08, 09, 00, 48, 01, 0a, 09, 00, 47, 01, 08, 09, 00, 44, 01, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 02, 04, 06, 00, 07, 07, 01, 05, 03, 02] Raw bytes (128): 0x[01, 01, 02, 01, 05, 05, 02, 18, 01, 09, 01, 0f, 0d, 01, 16, 0e, 06, 0a, 01, 10, 05, 13, 0d, 01, 1a, 0e, 06, 0a, 01, 10, 05, 0c, 16, 01, 16, 05, 0d, 18, 01, 19, 09, 01, 1e, 01, 04, 09, 00, 29, 01, 01, 09, 00, 2d, 01, 01, 09, 00, 24, 01, 05, 09, 00, 24, 01, 02, 09, 00, 21, 01, 04, 09, 00, 21, 01, 04, 09, 00, 28, 01, 09, 09, 00, 32, 01, 04, 09, 00, 33, 01, 07, 09, 00, 4b, 01, 08, 09, 00, 48, 01, 0a, 09, 00, 47, 01, 08, 09, 00, 44, 01, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 02, 04, 06, 00, 07, 07, 01, 05, 03, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 24 Number of file 0 mappings: 24
- Code(Counter(0)) at (prev + 8, 1) to (start + 15, 13) - Code(Counter(0)) at (prev + 9, 1) to (start + 15, 13)
- Code(Counter(0)) at (prev + 22, 14) to (start + 6, 10) - Code(Counter(0)) at (prev + 22, 14) to (start + 6, 10)
- Code(Counter(0)) at (prev + 16, 5) to (start + 19, 13) - Code(Counter(0)) at (prev + 16, 5) to (start + 19, 13)
- Code(Counter(0)) at (prev + 26, 14) to (start + 6, 10) - Code(Counter(0)) at (prev + 26, 14) to (start + 6, 10)
@ -34,14 +34,14 @@ Number of file 0 mappings: 24
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#0} Function name: closure::main::{closure#0}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 27, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 28, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 39, 5) to (start + 2, 20) - Code(Counter(0)) at (prev + 40, 5) to (start + 2, 20)
- Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10) - Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10)
- Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11) - Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11)
= (c0 - c1) = (c0 - c1)
@ -49,46 +49,46 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#10} (unused) Function name: closure::main::{closure#10} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 9a, 01, 07, 00, 21] Raw bytes (10): 0x[01, 01, 00, 01, 00, 9b, 01, 07, 00, 21]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 154, 7) to (start + 0, 33) - Code(Zero) at (prev + 155, 7) to (start + 0, 33)
Function name: closure::main::{closure#11} (unused) Function name: closure::main::{closure#11} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 9e, 01, 07, 00, 21] Raw bytes (10): 0x[01, 01, 00, 01, 00, 9f, 01, 07, 00, 21]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 158, 7) to (start + 0, 33) - Code(Zero) at (prev + 159, 7) to (start + 0, 33)
Function name: closure::main::{closure#12} (unused) Function name: closure::main::{closure#12} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, a6, 01, 01, 00, 17] Raw bytes (10): 0x[01, 01, 00, 01, 00, a7, 01, 01, 00, 17]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 166, 1) to (start + 0, 23) - Code(Zero) at (prev + 167, 1) to (start + 0, 23)
Function name: closure::main::{closure#13} (unused) Function name: closure::main::{closure#13} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, ab, 01, 0d, 02, 0e] Raw bytes (10): 0x[01, 01, 00, 01, 00, ac, 01, 0d, 02, 0e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 171, 13) to (start + 2, 14) - Code(Zero) at (prev + 172, 13) to (start + 2, 14)
Function name: closure::main::{closure#14} Function name: closure::main::{closure#14}
Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, b2, 01, 0d, 02, 1b, 05, 02, 1e, 00, 25, 02, 00, 2f, 00, 33, 07, 01, 0d, 00, 0e] Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, b3, 01, 0d, 02, 1b, 05, 02, 1e, 00, 25, 02, 00, 2f, 00, 33, 07, 01, 0d, 00, 0e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 178, 13) to (start + 2, 27) - Code(Counter(0)) at (prev + 179, 13) to (start + 2, 27)
- Code(Counter(1)) at (prev + 2, 30) to (start + 0, 37) - Code(Counter(1)) at (prev + 2, 30) to (start + 0, 37)
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51) - Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1) = (c0 - c1)
@ -96,7 +96,7 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#15} Function name: closure::main::{closure#15}
Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, ba, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a] Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, bb, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 3 Number of expressions: 3
@ -104,7 +104,7 @@ Number of expressions: 3
- expression 1 operands: lhs = Counter(0), rhs = Counter(1) - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1) - expression 2 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 6 Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 186, 9) to (start + 0, 10) - Code(Counter(0)) at (prev + 187, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21) - Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21)
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
- Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27) - Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27)
@ -115,14 +115,14 @@ Number of file 0 mappings: 6
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#16} Function name: closure::main::{closure#16}
Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, c4, 01, 0d, 02, 1b, 05, 02, 1e, 00, 25, 02, 00, 2f, 00, 33, 07, 01, 0d, 00, 0e] Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, c5, 01, 0d, 02, 1b, 05, 02, 1e, 00, 25, 02, 00, 2f, 00, 33, 07, 01, 0d, 00, 0e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 196, 13) to (start + 2, 27) - Code(Counter(0)) at (prev + 197, 13) to (start + 2, 27)
- Code(Counter(1)) at (prev + 2, 30) to (start + 0, 37) - Code(Counter(1)) at (prev + 2, 30) to (start + 0, 37)
- Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51) - Code(Expression(0, Sub)) at (prev + 0, 47) to (start + 0, 51)
= (c0 - c1) = (c0 - c1)
@ -130,7 +130,7 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#17} Function name: closure::main::{closure#17}
Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, cc, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a] Raw bytes (41): 0x[01, 01, 03, 05, 0a, 01, 05, 01, 05, 06, 01, cd, 01, 09, 00, 0a, 03, 01, 0d, 00, 15, 01, 01, 11, 01, 1b, 05, 01, 1e, 00, 25, 0a, 00, 2f, 00, 33, 03, 02, 09, 00, 0a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 3 Number of expressions: 3
@ -138,7 +138,7 @@ Number of expressions: 3
- expression 1 operands: lhs = Counter(0), rhs = Counter(1) - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
- expression 2 operands: lhs = Counter(0), rhs = Counter(1) - expression 2 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 6 Number of file 0 mappings: 6
- Code(Counter(0)) at (prev + 204, 9) to (start + 0, 10) - Code(Counter(0)) at (prev + 205, 9) to (start + 0, 10)
- Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21) - Code(Expression(0, Add)) at (prev + 1, 13) to (start + 0, 21)
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
- Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27) - Code(Counter(0)) at (prev + 1, 17) to (start + 1, 27)
@ -149,14 +149,14 @@ Number of file 0 mappings: 6
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#18} Function name: closure::main::{closure#18}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 18, 0d, 02, 1c, 05, 02, 1d, 02, 12, 02, 02, 12, 00, 13, 07, 01, 11, 01, 0e] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 19, 0d, 02, 1c, 05, 02, 1d, 02, 12, 02, 02, 12, 00, 13, 07, 01, 11, 01, 0e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 24, 13) to (start + 2, 28) - Code(Counter(0)) at (prev + 25, 13) to (start + 2, 28)
- Code(Counter(1)) at (prev + 2, 29) to (start + 2, 18) - Code(Counter(1)) at (prev + 2, 29) to (start + 2, 18)
- Code(Expression(0, Sub)) at (prev + 2, 18) to (start + 0, 19) - Code(Expression(0, Sub)) at (prev + 2, 18) to (start + 0, 19)
= (c0 - c1) = (c0 - c1)
@ -164,14 +164,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#19} Function name: closure::main::{closure#19}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 42, 0d, 02, 1c, 05, 02, 1d, 02, 12, 02, 02, 12, 00, 13, 07, 01, 11, 01, 0e] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 43, 0d, 02, 1c, 05, 02, 1d, 02, 12, 02, 02, 12, 00, 13, 07, 01, 11, 01, 0e]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 66, 13) to (start + 2, 28) - Code(Counter(0)) at (prev + 67, 13) to (start + 2, 28)
- Code(Counter(1)) at (prev + 2, 29) to (start + 2, 18) - Code(Counter(1)) at (prev + 2, 29) to (start + 2, 18)
- Code(Expression(0, Sub)) at (prev + 2, 18) to (start + 0, 19) - Code(Expression(0, Sub)) at (prev + 2, 18) to (start + 0, 19)
= (c0 - c1) = (c0 - c1)
@ -179,14 +179,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#1} Function name: closure::main::{closure#1}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 51, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 52, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 81, 5) to (start + 2, 20) - Code(Counter(0)) at (prev + 82, 5) to (start + 2, 20)
- Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10) - Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10)
- Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11) - Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11)
= (c0 - c1) = (c0 - c1)
@ -194,14 +194,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#2} Function name: closure::main::{closure#2}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 67, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 68, 05, 02, 14, 05, 02, 15, 02, 0a, 02, 02, 0a, 00, 0b, 07, 01, 09, 01, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 103, 5) to (start + 2, 20) - Code(Counter(0)) at (prev + 104, 5) to (start + 2, 20)
- Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10) - Code(Counter(1)) at (prev + 2, 21) to (start + 2, 10)
- Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11) - Code(Expression(0, Sub)) at (prev + 2, 10) to (start + 0, 11)
= (c0 - c1) = (c0 - c1)
@ -209,61 +209,61 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure::main::{closure#3} (unused) Function name: closure::main::{closure#3} (unused)
Raw bytes (25): 0x[01, 01, 00, 04, 00, 80, 01, 05, 01, 14, 00, 01, 15, 02, 0a, 00, 02, 0a, 00, 0b, 00, 01, 09, 01, 06] Raw bytes (25): 0x[01, 01, 00, 04, 00, 81, 01, 05, 01, 14, 00, 01, 15, 02, 0a, 00, 02, 0a, 00, 0b, 00, 01, 09, 01, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Zero) at (prev + 128, 5) to (start + 1, 20) - Code(Zero) at (prev + 129, 5) to (start + 1, 20)
- Code(Zero) at (prev + 1, 21) to (start + 2, 10) - Code(Zero) at (prev + 1, 21) to (start + 2, 10)
- Code(Zero) at (prev + 2, 10) to (start + 0, 11) - Code(Zero) at (prev + 2, 10) to (start + 0, 11)
- Code(Zero) at (prev + 1, 9) to (start + 1, 6) - Code(Zero) at (prev + 1, 9) to (start + 1, 6)
Function name: closure::main::{closure#4} (unused) Function name: closure::main::{closure#4} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 88, 01, 35, 00, 43] Raw bytes (10): 0x[01, 01, 00, 01, 00, 89, 01, 35, 00, 43]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 136, 53) to (start + 0, 67) - Code(Zero) at (prev + 137, 53) to (start + 0, 67)
Function name: closure::main::{closure#5} Function name: closure::main::{closure#5}
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8b, 01, 3d, 00, 4f] Raw bytes (10): 0x[01, 01, 00, 01, 01, 8c, 01, 3d, 00, 4f]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 139, 61) to (start + 0, 79) - Code(Counter(0)) at (prev + 140, 61) to (start + 0, 79)
Function name: closure::main::{closure#6} Function name: closure::main::{closure#6}
Raw bytes (10): 0x[01, 01, 00, 01, 01, 8c, 01, 41, 00, 57] Raw bytes (10): 0x[01, 01, 00, 01, 01, 8d, 01, 41, 00, 57]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 140, 65) to (start + 0, 87) - Code(Counter(0)) at (prev + 141, 65) to (start + 0, 87)
Function name: closure::main::{closure#7} (unused) Function name: closure::main::{closure#7} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 8d, 01, 3b, 00, 51] Raw bytes (10): 0x[01, 01, 00, 01, 00, 8e, 01, 3b, 00, 51]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 141, 59) to (start + 0, 81) - Code(Zero) at (prev + 142, 59) to (start + 0, 81)
Function name: closure::main::{closure#8} (unused) Function name: closure::main::{closure#8} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 92, 01, 3b, 00, 55] Raw bytes (10): 0x[01, 01, 00, 01, 00, 93, 01, 3b, 00, 55]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 146, 59) to (start + 0, 85) - Code(Zero) at (prev + 147, 59) to (start + 0, 85)
Function name: closure::main::{closure#9} (unused) Function name: closure::main::{closure#9} (unused)
Raw bytes (10): 0x[01, 01, 00, 01, 00, 94, 01, 38, 02, 06] Raw bytes (10): 0x[01, 01, 00, 01, 00, 95, 01, 38, 02, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 148, 56) to (start + 2, 6) - Code(Zero) at (prev + 149, 56) to (start + 2, 6)

1
tests/coverage/closure.coverage
View file

@ -5,6 +5,7 @@
LL| |// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by LL| |// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by
LL| |// <https://github.com/rust-lang/rust/pull/83666>. LL| |// <https://github.com/rust-lang/rust/pull/83666>.
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/closure.rs
View file

@ -5,6 +5,7 @@
// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by // `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by
// <https://github.com/rust-lang/rust/pull/83666>. // <https://github.com/rust-lang/rust/pull/83666>.
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

20
tests/coverage/closure_bug.cov-map
View file

@ -1,5 +1,5 @@
Function name: closure_bug::main Function name: closure_bug::main
Raw bytes (201): 0x[01, 01, 26, 01, 05, 05, 02, 05, 02, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 82, 01, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 01, 06, 01, 03, 0a, 01, 09, 05, 01, 0e, 05, 01, 0f, 00, 17, 02, 00, 17, 00, 18, 97, 01, 02, 09, 00, 0a, 97, 01, 06, 05, 01, 0e, 09, 01, 0f, 00, 17, 92, 01, 00, 17, 00, 18, 8f, 01, 02, 09, 00, 0a, 8f, 01, 06, 05, 01, 0e, 0d, 01, 0f, 00, 17, 8a, 01, 00, 17, 00, 18, 87, 01, 02, 09, 00, 0a, 87, 01, 06, 05, 01, 0e, 11, 01, 0f, 00, 17, 82, 01, 00, 17, 00, 18, 7f, 01, 01, 00, 02] Raw bytes (201): 0x[01, 01, 26, 01, 05, 05, 02, 05, 02, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 09, 92, 01, 97, 01, 09, 05, 02, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 82, 01, 87, 01, 11, 0d, 8a, 01, 8f, 01, 0d, 09, 92, 01, 97, 01, 09, 05, 02, 11, 01, 07, 01, 03, 0a, 01, 09, 05, 01, 0e, 05, 01, 0f, 00, 17, 02, 00, 17, 00, 18, 97, 01, 02, 09, 00, 0a, 97, 01, 06, 05, 01, 0e, 09, 01, 0f, 00, 17, 92, 01, 00, 17, 00, 18, 8f, 01, 02, 09, 00, 0a, 8f, 01, 06, 05, 01, 0e, 0d, 01, 0f, 00, 17, 8a, 01, 00, 17, 00, 18, 87, 01, 02, 09, 00, 0a, 87, 01, 06, 05, 01, 0e, 11, 01, 0f, 00, 17, 82, 01, 00, 17, 00, 18, 7f, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 38 Number of expressions: 38
@ -42,7 +42,7 @@ Number of expressions: 38
- expression 36 operands: lhs = Expression(37, Add), rhs = Counter(2) - expression 36 operands: lhs = Expression(37, Add), rhs = Counter(2)
- expression 37 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 37 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 17 Number of file 0 mappings: 17
- Code(Counter(0)) at (prev + 6, 1) to (start + 3, 10) - Code(Counter(0)) at (prev + 7, 1) to (start + 3, 10)
- Code(Counter(0)) at (prev + 9, 5) to (start + 1, 14) - Code(Counter(0)) at (prev + 9, 5) to (start + 1, 14)
- Code(Counter(1)) at (prev + 1, 15) to (start + 0, 23) - Code(Counter(1)) at (prev + 1, 15) to (start + 0, 23)
- Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 24) - Code(Expression(0, Sub)) at (prev + 0, 23) to (start + 0, 24)
@ -72,14 +72,14 @@ Number of file 0 mappings: 17
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) = (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
Function name: closure_bug::main::{closure#0} Function name: closure_bug::main::{closure#0}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 0d, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 0e, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 13, 9) to (start + 0, 18) - Code(Counter(0)) at (prev + 14, 9) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25) - Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40) - Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
= (c0 - c1) = (c0 - c1)
@ -87,14 +87,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure_bug::main::{closure#1} Function name: closure_bug::main::{closure#1}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 16, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 17, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 22, 9) to (start + 0, 18) - Code(Counter(0)) at (prev + 23, 9) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25) - Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40) - Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
= (c0 - c1) = (c0 - c1)
@ -102,14 +102,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure_bug::main::{closure#2} Function name: closure_bug::main::{closure#2}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 1f, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 20, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 31, 9) to (start + 0, 18) - Code(Counter(0)) at (prev + 32, 9) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25) - Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40) - Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
= (c0 - c1) = (c0 - c1)
@ -117,14 +117,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure_bug::main::{closure#3} Function name: closure_bug::main::{closure#3}
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 28, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 29, 09, 00, 12, 05, 00, 15, 00, 19, 02, 00, 23, 00, 28, 07, 00, 29, 00, 2a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 40, 9) to (start + 0, 18) - Code(Counter(0)) at (prev + 41, 9) to (start + 0, 18)
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25) - Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40) - Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/closure_bug.coverage
View file

@ -3,6 +3,7 @@
LL| |// the coverage report. However, an unstable sort was causing them to be treated LL| |// the coverage report. However, an unstable sort was causing them to be treated
LL| |// inconsistently when preparing coverage spans. LL| |// inconsistently when preparing coverage spans.
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| let truthy = std::env::args().len() == 1; LL| 1| let truthy = std::env::args().len() == 1;
LL| 1| LL| 1|

1
tests/coverage/closure_bug.rs
View file

@ -3,6 +3,7 @@
// the coverage report. However, an unstable sort was causing them to be treated // the coverage report. However, an unstable sort was causing them to be treated
// inconsistently when preparing coverage spans. // inconsistently when preparing coverage spans.
#[rustfmt::skip]
fn main() { fn main() {
let truthy = std::env::args().len() == 1; let truthy = std::env::args().len() == 1;

12
tests/coverage/closure_macro.cov-map
View file

@ -1,20 +1,20 @@
Function name: closure_macro::load_configuration_files Function name: closure_macro::load_configuration_files
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1d, 01, 02, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 1e, 01, 02, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 29, 1) to (start + 2, 2) - Code(Counter(0)) at (prev + 30, 1) to (start + 2, 2)
Function name: closure_macro::main Function name: closure_macro::main
Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 21, 01, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02] Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 22, 01, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7 Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 33, 1) to (start + 1, 33) - Code(Counter(0)) at (prev + 34, 1) to (start + 1, 33)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15) - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15)
= (c0 - c1) = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19) - Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
@ -27,10 +27,10 @@ Number of file 0 mappings: 7
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure_macro::main::{closure#0} Function name: closure_macro::main::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 23, 12, 00, 54] Raw bytes (9): 0x[01, 01, 00, 01, 01, 24, 12, 00, 54]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 35, 18) to (start + 0, 84) - Code(Counter(0)) at (prev + 36, 18) to (start + 0, 84)

3
tests/coverage/closure_macro.coverage
View file

@ -14,7 +14,8 @@
LL| | LL| |
LL| |macro_rules! on_error { LL| |macro_rules! on_error {
LL| | ($value:expr, $error_message:expr) => { LL| | ($value:expr, $error_message:expr) => {
LL| | $value.or_else(|e| { // FIXME(85000): no coverage in closure macros LL| | $value.or_else(|e| {
LL| | // FIXME(85000): no coverage in closure macros
LL| | let message = format!($error_message, e); LL| | let message = format!($error_message, e);
LL| | if message.len() > 0 { LL| | if message.len() > 0 {
LL| | println!("{}", message); LL| | println!("{}", message);

3
tests/coverage/closure_macro.rs
View file

@ -14,7 +14,8 @@ macro_rules! bail {
macro_rules! on_error { macro_rules! on_error {
($value:expr, $error_message:expr) => { ($value:expr, $error_message:expr) => {
$value.or_else(|e| { // FIXME(85000): no coverage in closure macros $value.or_else(|e| {
// FIXME(85000): no coverage in closure macros
let message = format!($error_message, e); let message = format!($error_message, e);
if message.len() > 0 { if message.len() > 0 {
println!("{}", message); println!("{}", message);

16
tests/coverage/closure_macro_async.cov-map
View file

@ -1,28 +1,28 @@
Function name: closure_macro_async::load_configuration_files Function name: closure_macro_async::load_configuration_files
Raw bytes (9): 0x[01, 01, 00, 01, 01, 1e, 01, 02, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 1f, 01, 02, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 30, 1) to (start + 2, 2) - Code(Counter(0)) at (prev + 31, 1) to (start + 2, 2)
Function name: closure_macro_async::test Function name: closure_macro_async::test
Raw bytes (9): 0x[01, 01, 00, 01, 01, 22, 01, 00, 2b] Raw bytes (9): 0x[01, 01, 00, 01, 01, 23, 01, 00, 2b]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 34, 1) to (start + 0, 43) - Code(Counter(0)) at (prev + 35, 1) to (start + 0, 43)
Function name: closure_macro_async::test::{closure#0} Function name: closure_macro_async::test::{closure#0}
Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 22, 2b, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02] Raw bytes (43): 0x[01, 01, 02, 01, 05, 05, 02, 07, 01, 23, 2b, 01, 21, 02, 02, 09, 00, 0f, 05, 00, 12, 00, 13, 02, 00, 12, 00, 13, 05, 00, 54, 00, 55, 02, 02, 09, 02, 0b, 07, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7 Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 34, 43) to (start + 1, 33) - Code(Counter(0)) at (prev + 35, 43) to (start + 1, 33)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15) - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 15)
= (c0 - c1) = (c0 - c1)
- Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19) - Code(Counter(1)) at (prev + 0, 18) to (start + 0, 19)
@ -35,10 +35,10 @@ Number of file 0 mappings: 7
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: closure_macro_async::test::{closure#0}::{closure#0} Function name: closure_macro_async::test::{closure#0}::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 24, 12, 00, 54] Raw bytes (9): 0x[01, 01, 00, 01, 01, 25, 12, 00, 54]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 36, 18) to (start + 0, 84) - Code(Counter(0)) at (prev + 37, 18) to (start + 0, 84)

3
tests/coverage/closure_macro_async.coverage
View file

@ -15,7 +15,8 @@
LL| | LL| |
LL| |macro_rules! on_error { LL| |macro_rules! on_error {
LL| | ($value:expr, $error_message:expr) => { LL| | ($value:expr, $error_message:expr) => {
LL| | $value.or_else(|e| { // FIXME(85000): no coverage in closure macros LL| | $value.or_else(|e| {
LL| | // FIXME(85000): no coverage in closure macros
LL| | let message = format!($error_message, e); LL| | let message = format!($error_message, e);
LL| | if message.len() > 0 { LL| | if message.len() > 0 {
LL| | println!("{}", message); LL| | println!("{}", message);

3
tests/coverage/closure_macro_async.rs
View file

@ -15,7 +15,8 @@ macro_rules! bail {
macro_rules! on_error { macro_rules! on_error {
($value:expr, $error_message:expr) => { ($value:expr, $error_message:expr) => {
$value.or_else(|e| { // FIXME(85000): no coverage in closure macros $value.or_else(|e| {
// FIXME(85000): no coverage in closure macros
let message = format!($error_message, e); let message = format!($error_message, e);
if message.len() > 0 { if message.len() > 0 {
println!("{}", message); println!("{}", message);

4
tests/coverage/conditions.cov-map
View file

@ -1,5 +1,5 @@
Function name: conditions::main Function name: conditions::main
Raw bytes (784): 0x[01, 01, 8e, 01, 09, 33, 37, 41, 3b, 3d, 35, 39, 05, 00, b7, 04, 09, 05, 00, 0d, 35, 26, 39, 0d, 35, 3b, 3d, 35, 39, 37, 41, 3b, 3d, 35, 39, b2, 04, 0d, b7, 04, 09, 05, 00, 45, 00, 83, 01, 49, 45, 00, 7e, 31, 83, 01, 49, 45, 00, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, 76, 51, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, a7, 01, 55, 4d, 51, a3, 01, 59, a7, 01, 55, 4d, 51, 49, 9f, 01, a3, 01, 59, a7, 01, 55, 4d, 51, 61, 00, e3, 01, 65, 61, 00, de, 01, 2d, e3, 01, 65, 61, 00, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, d6, 01, 6d, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, 8b, 02, 71, 69, 6d, 87, 02, 75, 8b, 02, 71, 69, 6d, ff, 01, 00, 65, 83, 02, 87, 02, 75, 8b, 02, 71, 69, 6d, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 79, 00, d7, 02, 7d, 79, 00, d2, 02, 29, d7, 02, 7d, 79, 00, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, ca, 02, 85, 01, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, f3, 03, 89, 01, 81, 01, 85, 01, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, da, 03, 19, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 9b, 04, 1d, 15, 19, 97, 04, 21, 9b, 04, 1d, 15, 19, 8f, 04, 9f, 04, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, a3, 04, ae, 04, a7, 04, 31, ab, 04, 2d, 25, 29, b2, 04, 0d, b7, 04, 09, 05, 00, 44, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 00, 02, 06, 00, 07, 03, 03, 09, 00, 0a, b7, 04, 00, 10, 00, 1d, 09, 01, 09, 01, 0a, b2, 04, 02, 0f, 00, 1c, 0d, 01, 0c, 00, 19, 26, 00, 1d, 00, 2a, 22, 00, 2e, 00, 3c, 37, 00, 3d, 02, 0a, 41, 02, 0a, 00, 0b, 33, 01, 09, 01, 12, ae, 04, 03, 09, 00, 0f, 03, 03, 09, 01, 0c, 45, 01, 0d, 02, 06, 00, 02, 06, 00, 07, 83, 01, 02, 08, 00, 15, 49, 00, 16, 02, 06, 7e, 02, 0f, 00, 1c, 7a, 01, 0c, 00, 19, 76, 00, 1d, 00, 2a, 72, 00, 2e, 00, 3c, a3, 01, 00, 3d, 02, 0a, 59, 02, 0a, 00, 0b, 9f, 01, 01, 09, 00, 17, 31, 02, 09, 00, 0f, 9b, 01, 03, 08, 00, 0c, 5d, 01, 0d, 01, 10, 61, 01, 11, 02, 0a, 00, 02, 0a, 00, 0b, e3, 01, 02, 0c, 00, 19, 65, 00, 1a, 02, 0a, de, 01, 03, 11, 00, 1e, da, 01, 01, 10, 00, 1d, d6, 01, 00, 21, 00, 2e, d2, 01, 00, 32, 00, 40, 87, 02, 00, 41, 02, 0e, 75, 02, 0e, 00, 0f, 83, 02, 01, 0d, 00, 1b, 2d, 02, 0d, 00, 13, 00, 02, 06, 00, 07, fb, 01, 02, 09, 01, 0c, 79, 01, 0d, 02, 06, 00, 02, 06, 00, 07, e7, 03, 02, 09, 00, 0a, d7, 02, 00, 10, 00, 1d, 7d, 00, 1e, 02, 06, d2, 02, 02, 0f, 00, 1c, ce, 02, 01, 0c, 00, 19, ca, 02, 00, 1d, 00, 2a, c6, 02, 00, 2e, 00, 3c, ef, 03, 00, 3d, 02, 0a, 8d, 01, 02, 0a, 00, 0b, eb, 03, 01, 09, 00, 17, 29, 02, 0d, 02, 0f, 8f, 04, 05, 09, 00, 0a, e7, 03, 00, 10, 00, 1d, 11, 00, 1e, 02, 06, e2, 03, 02, 0f, 00, 1c, de, 03, 01, 0c, 00, 19, da, 03, 00, 1d, 00, 2a, d6, 03, 00, 2e, 00, 3c, 97, 04, 00, 3d, 02, 0a, 21, 02, 0a, 00, 0b, 93, 04, 01, 09, 00, 17, 25, 02, 09, 00, 0f, 8b, 04, 02, 01, 00, 02] Raw bytes (784): 0x[01, 01, 8e, 01, 09, 33, 37, 41, 3b, 3d, 35, 39, 05, 00, b7, 04, 09, 05, 00, 0d, 35, 26, 39, 0d, 35, 3b, 3d, 35, 39, 37, 41, 3b, 3d, 35, 39, b2, 04, 0d, b7, 04, 09, 05, 00, 45, 00, 83, 01, 49, 45, 00, 7e, 31, 83, 01, 49, 45, 00, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, 76, 51, 7a, 4d, 7e, 31, 83, 01, 49, 45, 00, a7, 01, 55, 4d, 51, a3, 01, 59, a7, 01, 55, 4d, 51, 49, 9f, 01, a3, 01, 59, a7, 01, 55, 4d, 51, 61, 00, e3, 01, 65, 61, 00, de, 01, 2d, e3, 01, 65, 61, 00, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, d6, 01, 6d, da, 01, 69, de, 01, 2d, e3, 01, 65, 61, 00, 8b, 02, 71, 69, 6d, 87, 02, 75, 8b, 02, 71, 69, 6d, ff, 01, 00, 65, 83, 02, 87, 02, 75, 8b, 02, 71, 69, 6d, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 79, 00, d7, 02, 7d, 79, 00, d2, 02, 29, d7, 02, 7d, 79, 00, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, ca, 02, 85, 01, ce, 02, 81, 01, d2, 02, 29, d7, 02, 7d, 79, 00, f3, 03, 89, 01, 81, 01, 85, 01, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, da, 03, 19, de, 03, 15, e2, 03, 25, e7, 03, 11, 7d, eb, 03, ef, 03, 8d, 01, f3, 03, 89, 01, 81, 01, 85, 01, 9b, 04, 1d, 15, 19, 97, 04, 21, 9b, 04, 1d, 15, 19, 8f, 04, 9f, 04, 11, 93, 04, 97, 04, 21, 9b, 04, 1d, 15, 19, a3, 04, ae, 04, a7, 04, 31, ab, 04, 2d, 25, 29, b2, 04, 0d, b7, 04, 09, 05, 00, 44, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 00, 02, 06, 00, 07, 03, 03, 09, 00, 0a, b7, 04, 00, 10, 00, 1d, 09, 01, 09, 01, 0a, b2, 04, 02, 0f, 00, 1c, 0d, 01, 0c, 00, 19, 26, 00, 1d, 00, 2a, 22, 00, 2e, 00, 3c, 37, 00, 3d, 02, 0a, 41, 02, 0a, 00, 0b, 33, 01, 09, 01, 12, ae, 04, 03, 09, 00, 0f, 03, 03, 09, 01, 0c, 45, 01, 0d, 02, 06, 00, 02, 06, 00, 07, 83, 01, 02, 08, 00, 15, 49, 00, 16, 02, 06, 7e, 02, 0f, 00, 1c, 7a, 01, 0c, 00, 19, 76, 00, 1d, 00, 2a, 72, 00, 2e, 00, 3c, a3, 01, 00, 3d, 02, 0a, 59, 02, 0a, 00, 0b, 9f, 01, 01, 09, 00, 17, 31, 02, 09, 00, 0f, 9b, 01, 03, 08, 00, 0c, 5d, 01, 0d, 01, 10, 61, 01, 11, 02, 0a, 00, 02, 0a, 00, 0b, e3, 01, 02, 0c, 00, 19, 65, 00, 1a, 02, 0a, de, 01, 04, 11, 00, 1e, da, 01, 01, 10, 00, 1d, d6, 01, 00, 21, 00, 2e, d2, 01, 00, 32, 00, 40, 87, 02, 00, 41, 02, 0e, 75, 02, 0e, 00, 0f, 83, 02, 01, 0d, 00, 1b, 2d, 02, 0d, 00, 13, 00, 02, 06, 00, 07, fb, 01, 02, 09, 01, 0c, 79, 01, 0d, 02, 06, 00, 02, 06, 00, 07, e7, 03, 02, 09, 00, 0a, d7, 02, 00, 10, 00, 1d, 7d, 00, 1e, 02, 06, d2, 02, 02, 0f, 00, 1c, ce, 02, 01, 0c, 00, 19, ca, 02, 00, 1d, 00, 2a, c6, 02, 00, 2e, 00, 3c, ef, 03, 00, 3d, 02, 0a, 8d, 01, 02, 0a, 00, 0b, eb, 03, 01, 09, 00, 17, 29, 02, 0d, 02, 0f, 8f, 04, 05, 09, 00, 0a, e7, 03, 00, 10, 00, 1d, 11, 00, 1e, 02, 06, e2, 03, 02, 0f, 00, 1c, de, 03, 01, 0c, 00, 19, da, 03, 00, 1d, 00, 2a, d6, 03, 00, 2e, 00, 3c, 97, 04, 00, 3d, 02, 0a, 21, 02, 0a, 00, 0b, 93, 04, 01, 09, 00, 17, 25, 02, 09, 00, 0f, 8b, 04, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 142 Number of expressions: 142
@ -197,7 +197,7 @@ Number of file 0 mappings: 68
- Code(Expression(56, Add)) at (prev + 2, 12) to (start + 0, 25) - Code(Expression(56, Add)) at (prev + 2, 12) to (start + 0, 25)
= (c24 + Zero) = (c24 + Zero)
- Code(Counter(25)) at (prev + 0, 26) to (start + 2, 10) - Code(Counter(25)) at (prev + 0, 26) to (start + 2, 10)
- Code(Expression(55, Sub)) at (prev + 3, 17) to (start + 0, 30) - Code(Expression(55, Sub)) at (prev + 4, 17) to (start + 0, 30)
= ((c24 + Zero) - c25) = ((c24 + Zero) - c25)
- Code(Expression(54, Sub)) at (prev + 1, 16) to (start + 0, 29) - Code(Expression(54, Sub)) at (prev + 1, 16) to (start + 0, 29)
= (((c24 + Zero) - c25) - c11) = (((c24 + Zero) - c25) - c11)

1
tests/coverage/conditions.coverage
View file

@ -49,6 +49,7 @@
LL| 1| if countdown > 7 { LL| 1| if countdown > 7 {
LL| 1| countdown -= 4; LL| 1| countdown -= 4;
LL| 1| } LL| 1| }
LL| | //
LL| 0| else if countdown > 2 { LL| 0| else if countdown > 2 {
LL| 0| if countdown < 1 || countdown > 5 || countdown != 9 { LL| 0| if countdown < 1 || countdown > 5 || countdown != 9 {
LL| 0| countdown = 0; LL| 0| countdown = 0;

1
tests/coverage/conditions.rs
View file

@ -45,6 +45,7 @@ fn main() {
if countdown > 7 { if countdown > 7 {
countdown -= 4; countdown -= 4;
} }
//
else if countdown > 2 { else if countdown > 2 {
if countdown < 1 || countdown > 5 || countdown != 9 { if countdown < 1 || countdown > 5 || countdown != 9 {
countdown = 0; countdown = 0;

16
tests/coverage/coroutine.cov-map
View file

@ -1,5 +1,5 @@
Function name: coroutine::get_u32 Function name: coroutine::get_u32
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 0b, 01, 01, 0b, 05, 01, 0e, 00, 13, 02, 00, 1d, 00, 3c, 07, 01, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 0b, 01, 01, 0b, 05, 02, 09, 00, 0e, 02, 02, 09, 00, 28, 07, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
@ -7,14 +7,14 @@ Number of expressions: 2
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 11) - Code(Counter(0)) at (prev + 11, 1) to (start + 1, 11)
- Code(Counter(1)) at (prev + 1, 14) to (start + 0, 19) - Code(Counter(1)) at (prev + 2, 9) to (start + 0, 14)
- Code(Expression(0, Sub)) at (prev + 0, 29) to (start + 0, 60) - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 40)
= (c0 - c1) = (c0 - c1)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2) - Code(Expression(1, Add)) at (prev + 2, 1) to (start + 0, 2)
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: coroutine::main Function name: coroutine::main
Raw bytes (65): 0x[01, 01, 08, 07, 0d, 05, 09, 11, 15, 1e, 19, 11, 15, 15, 19, 1e, 19, 11, 15, 09, 01, 0f, 01, 02, 16, 01, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 03, 01, 0e, 00, 35, 11, 02, 0b, 00, 2e, 1e, 01, 22, 00, 27, 1a, 00, 2c, 00, 2e, 17, 01, 0e, 00, 35, 1a, 02, 01, 00, 02] Raw bytes (65): 0x[01, 01, 08, 07, 0d, 05, 09, 11, 15, 1e, 19, 11, 15, 15, 19, 1e, 19, 11, 15, 09, 01, 13, 01, 02, 16, 01, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 03, 01, 0e, 00, 35, 11, 02, 0b, 00, 2e, 1e, 01, 22, 00, 27, 1a, 00, 2c, 00, 2e, 17, 01, 0e, 00, 35, 1a, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 8 Number of expressions: 8
@ -27,7 +27,7 @@ Number of expressions: 8
- expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(6) - expression 6 operands: lhs = Expression(7, Sub), rhs = Counter(6)
- expression 7 operands: lhs = Counter(4), rhs = Counter(5) - expression 7 operands: lhs = Counter(4), rhs = Counter(5)
Number of file 0 mappings: 9 Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 22) - Code(Counter(0)) at (prev + 19, 1) to (start + 2, 22)
- Code(Counter(0)) at (prev + 7, 11) to (start + 0, 46) - Code(Counter(0)) at (prev + 7, 11) to (start + 0, 46)
- Code(Counter(4)) at (prev + 1, 43) to (start + 0, 45) - Code(Counter(4)) at (prev + 1, 43) to (start + 0, 45)
- Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 53) - Code(Expression(0, Add)) at (prev + 1, 14) to (start + 0, 53)
@ -43,11 +43,11 @@ Number of file 0 mappings: 9
= ((c4 - c5) - c6) = ((c4 - c5) - c6)
Function name: coroutine::main::{closure#0} Function name: coroutine::main::{closure#0}
Raw bytes (14): 0x[01, 01, 00, 02, 01, 11, 1c, 01, 1f, 05, 02, 10, 01, 06] Raw bytes (14): 0x[01, 01, 00, 02, 01, 15, 1c, 01, 1f, 05, 02, 10, 01, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 2 Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 17, 28) to (start + 1, 31) - Code(Counter(0)) at (prev + 21, 28) to (start + 1, 31)
- Code(Counter(1)) at (prev + 2, 16) to (start + 1, 6) - Code(Counter(1)) at (prev + 2, 16) to (start + 1, 6)

7
tests/coverage/coroutine.coverage
View file

@ -9,8 +9,11 @@
LL| |// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic LL| |// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic
LL| |// to handle this condition, and still report dead block coverage. LL| |// to handle this condition, and still report dead block coverage.
LL| 1|fn get_u32(val: bool) -> Result<u32, String> { LL| 1|fn get_u32(val: bool) -> Result<u32, String> {
LL| 1| if val { Ok(1) } else { Err(String::from("some error")) } LL| 1| if val {
^0 LL| 1| Ok(1)
LL| | } else {
LL| 0| Err(String::from("some error"))
LL| | }
LL| 1|} LL| 1|}
LL| | LL| |
LL| 1|fn main() { LL| 1|fn main() {

6
tests/coverage/coroutine.rs
View file

@ -9,7 +9,11 @@ use std::pin::Pin;
// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic // drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic
// to handle this condition, and still report dead block coverage. // to handle this condition, and still report dead block coverage.
fn get_u32(val: bool) -> Result<u32, String> { fn get_u32(val: bool) -> Result<u32, String> {
if val { Ok(1) } else { Err(String::from("some error")) } if val {
Ok(1)
} else {
Err(String::from("some error"))
}
} }
fn main() { fn main() {

68
tests/coverage/fn_sig_into_try.cov-map
View file

@ -1,53 +1,53 @@
Function name: fn_sig_into_try::a Function name: fn_sig_into_try::a
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0a, 01, 04, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 0a, 01, 05, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 10, 1) to (start + 4, 2) - Code(Counter(0)) at (prev + 10, 1) to (start + 5, 2)
Function name: fn_sig_into_try::b Function name: fn_sig_into_try::b
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 10, 01, 02, 0f, 00, 02, 0f, 00, 10, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 11, 01, 03, 0f, 00, 03, 0f, 00, 10, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero - expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub) - expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 16, 1) to (start + 2, 15) - Code(Counter(0)) at (prev + 17, 1) to (start + 3, 15)
- Code(Zero) at (prev + 2, 15) to (start + 0, 16)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
= (c0 - Zero)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= (Zero + (c0 - Zero))
Function name: fn_sig_into_try::c
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 16, 01, 02, 17, 00, 02, 17, 00, 18, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 22, 1) to (start + 2, 23)
- Code(Zero) at (prev + 2, 23) to (start + 0, 24)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
= (c0 - Zero)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= (Zero + (c0 - Zero))
Function name: fn_sig_into_try::d
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 1c, 01, 03, 0f, 00, 03, 0f, 00, 10, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 28, 1) to (start + 3, 15)
- Code(Zero) at (prev + 3, 15) to (start + 0, 16) - Code(Zero) at (prev + 3, 15) to (start + 0, 16)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12) - Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
= (c0 - Zero) = (c0 - Zero)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2) - Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= (Zero + (c0 - Zero)) = (Zero + (c0 - Zero))
Function name: fn_sig_into_try::c
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 18, 01, 03, 17, 00, 03, 17, 00, 18, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 24, 1) to (start + 3, 23)
- Code(Zero) at (prev + 3, 23) to (start + 0, 24)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
= (c0 - Zero)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= (Zero + (c0 - Zero))
Function name: fn_sig_into_try::d
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 1f, 01, 04, 0f, 00, 04, 0f, 00, 10, 02, 01, 05, 00, 0c, 07, 01, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 31, 1) to (start + 4, 15)
- Code(Zero) at (prev + 4, 15) to (start + 0, 16)
- Code(Expression(0, Sub)) at (prev + 1, 5) to (start + 0, 12)
= (c0 - Zero)
- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
= (Zero + (c0 - Zero))

4
tests/coverage/fn_sig_into_try.coverage
View file

@ -8,12 +8,14 @@
LL| |// signature should be handled in the same way. LL| |// signature should be handled in the same way.
LL| | LL| |
LL| 1|fn a() -> Option<i32> LL| 1|fn a() -> Option<i32>
LL| 1|//
LL| 1|{ LL| 1|{
LL| 1| Some(7i32); LL| 1| Some(7i32);
LL| 1| Some(0) LL| 1| Some(0)
LL| 1|} LL| 1|}
LL| | LL| |
LL| 1|fn b() -> Option<i32> LL| 1|fn b() -> Option<i32>
LL| 1|//
LL| 1|{ LL| 1|{
LL| 1| Some(7i32)?; LL| 1| Some(7i32)?;
^0 ^0
@ -21,6 +23,7 @@
LL| 1|} LL| 1|}
LL| | LL| |
LL| 1|fn c() -> Option<i32> LL| 1|fn c() -> Option<i32>
LL| 1|//
LL| 1|{ LL| 1|{
LL| 1| let _ = Some(7i32)?; LL| 1| let _ = Some(7i32)?;
^0 ^0
@ -28,6 +31,7 @@
LL| 1|} LL| 1|}
LL| | LL| |
LL| 1|fn d() -> Option<i32> LL| 1|fn d() -> Option<i32>
LL| 1|//
LL| 1|{ LL| 1|{
LL| 1| let _: () = (); LL| 1| let _: () = ();
LL| 1| Some(7i32)?; LL| 1| Some(7i32)?;

4
tests/coverage/fn_sig_into_try.rs
View file

@ -8,24 +8,28 @@
// signature should be handled in the same way. // signature should be handled in the same way.
fn a() -> Option<i32> fn a() -> Option<i32>
//
{ {
Some(7i32); Some(7i32);
Some(0) Some(0)
} }
fn b() -> Option<i32> fn b() -> Option<i32>
//
{ {
Some(7i32)?; Some(7i32)?;
Some(0) Some(0)
} }
fn c() -> Option<i32> fn c() -> Option<i32>
//
{ {
let _ = Some(7i32)?; let _ = Some(7i32)?;
Some(0) Some(0)
} }
fn d() -> Option<i32> fn d() -> Option<i32>
//
{ {
let _: () = (); let _: () = ();
Some(7i32)?; Some(7i32)?;

6
tests/coverage/generics.coverage
View file

@ -1,11 +1,11 @@
LL| |#![allow(unused_assignments)] LL| |#![allow(unused_assignments)]
LL| |// failure-status: 1 LL| |// failure-status: 1
LL| | LL| |
LL| |struct Firework<T> where T: Copy + std::fmt::Display { LL| |struct Firework<T: Copy + std::fmt::Display> {
LL| | strength: T, LL| | strength: T,
LL| |} LL| |}
LL| | LL| |
LL| |impl<T> Firework<T> where T: Copy + std::fmt::Display { LL| |impl<T: Copy + std::fmt::Display> Firework<T> {
LL| | #[inline(always)] LL| | #[inline(always)]
LL| 3| fn set_strength(&mut self, new_strength: T) { LL| 3| fn set_strength(&mut self, new_strength: T) {
LL| 3| self.strength = new_strength; LL| 3| self.strength = new_strength;
@ -23,7 +23,7 @@
------------------ ------------------
LL| |} LL| |}
LL| | LL| |
LL| |impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display { LL| |impl<T: Copy + std::fmt::Display> Drop for Firework<T> {
LL| | #[inline(always)] LL| | #[inline(always)]
LL| 2| fn drop(&mut self) { LL| 2| fn drop(&mut self) {
LL| 2| println!("BOOM times {}!!!", self.strength); LL| 2| println!("BOOM times {}!!!", self.strength);

6
tests/coverage/generics.rs
View file

@ -1,18 +1,18 @@
#![allow(unused_assignments)] #![allow(unused_assignments)]
// failure-status: 1 // failure-status: 1
struct Firework<T> where T: Copy + std::fmt::Display { struct Firework<T: Copy + std::fmt::Display> {
strength: T, strength: T,
} }
impl<T> Firework<T> where T: Copy + std::fmt::Display { impl<T: Copy + std::fmt::Display> Firework<T> {
#[inline(always)] #[inline(always)]
fn set_strength(&mut self, new_strength: T) { fn set_strength(&mut self, new_strength: T) {
self.strength = new_strength; self.strength = new_strength;
} }
} }
impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display { impl<T: Copy + std::fmt::Display> Drop for Firework<T> {
#[inline(always)] #[inline(always)]
fn drop(&mut self) { fn drop(&mut self) {
println!("BOOM times {}!!!", self.strength); println!("BOOM times {}!!!", self.strength);

4
tests/coverage/if.cov-map
View file

@ -1,12 +1,12 @@
Function name: if::main Function name: if::main
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 03, 01, 12, 10, 05, 13, 05, 05, 06, 02, 05, 06, 00, 07, 07, 01, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 04, 01, 12, 10, 05, 13, 05, 05, 06, 02, 05, 06, 00, 07, 07, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 3, 1) to (start + 18, 16) - Code(Counter(0)) at (prev + 4, 1) to (start + 18, 16)
- Code(Counter(1)) at (prev + 19, 5) to (start + 5, 6) - Code(Counter(1)) at (prev + 19, 5) to (start + 5, 6)
- Code(Expression(0, Sub)) at (prev + 5, 6) to (start + 0, 7) - Code(Expression(0, Sub)) at (prev + 5, 6) to (start + 0, 7)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/if.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments, unused_variables)] LL| |#![allow(unused_assignments, unused_variables)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/if.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments, unused_variables)] #![allow(unused_assignments, unused_variables)]
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

4
tests/coverage/if_else.cov-map
View file

@ -1,5 +1,5 @@
Function name: if_else::main Function name: if_else::main
Raw bytes (53): 0x[01, 01, 07, 01, 05, 05, 02, 1b, 09, 05, 02, 09, 16, 1b, 09, 05, 02, 07, 01, 03, 01, 08, 10, 05, 09, 05, 05, 06, 02, 08, 09, 02, 10, 1b, 06, 09, 00, 10, 09, 01, 05, 05, 06, 16, 07, 05, 05, 06, 13, 06, 01, 00, 02] Raw bytes (53): 0x[01, 01, 07, 01, 05, 05, 02, 1b, 09, 05, 02, 09, 16, 1b, 09, 05, 02, 07, 01, 04, 01, 08, 10, 05, 09, 05, 05, 06, 02, 08, 09, 02, 10, 1b, 06, 09, 00, 10, 09, 01, 05, 05, 06, 16, 07, 05, 05, 06, 13, 06, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 7 Number of expressions: 7
@ -11,7 +11,7 @@ Number of expressions: 7
- expression 5 operands: lhs = Expression(6, Add), rhs = Counter(2) - expression 5 operands: lhs = Expression(6, Add), rhs = Counter(2)
- expression 6 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 6 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7 Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 3, 1) to (start + 8, 16) - Code(Counter(0)) at (prev + 4, 1) to (start + 8, 16)
- Code(Counter(1)) at (prev + 9, 5) to (start + 5, 6) - Code(Counter(1)) at (prev + 9, 5) to (start + 5, 6)
- Code(Expression(0, Sub)) at (prev + 8, 9) to (start + 2, 16) - Code(Expression(0, Sub)) at (prev + 8, 9) to (start + 2, 16)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/if_else.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments, unused_variables)] LL| |#![allow(unused_assignments, unused_variables)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/if_else.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments, unused_variables)] #![allow(unused_assignments, unused_variables)]
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

4
tests/coverage/if_not.cov-map
View file

@ -1,5 +1,5 @@
Function name: if_not::if_not Function name: if_not::if_not
Raw bytes (86): 0x[01, 01, 10, 01, 05, 05, 02, 3f, 09, 05, 02, 09, 3a, 3f, 09, 05, 02, 37, 0d, 09, 3a, 3f, 09, 05, 02, 0d, 32, 37, 0d, 09, 3a, 3f, 09, 05, 02, 0a, 01, 04, 01, 03, 0d, 02, 04, 05, 02, 06, 05, 02, 06, 00, 07, 3f, 03, 09, 01, 0d, 3a, 02, 05, 02, 06, 09, 02, 06, 00, 07, 37, 03, 09, 01, 0d, 32, 02, 05, 02, 06, 0d, 02, 0c, 02, 06, 2f, 03, 01, 00, 02] Raw bytes (86): 0x[01, 01, 10, 01, 05, 05, 02, 3f, 09, 05, 02, 09, 3a, 3f, 09, 05, 02, 37, 0d, 09, 3a, 3f, 09, 05, 02, 0d, 32, 37, 0d, 09, 3a, 3f, 09, 05, 02, 0a, 01, 05, 01, 03, 0d, 02, 04, 05, 02, 06, 05, 02, 06, 00, 07, 3f, 03, 09, 01, 0d, 3a, 02, 05, 02, 06, 09, 02, 06, 00, 07, 37, 03, 09, 01, 0d, 32, 02, 05, 02, 06, 0d, 02, 0c, 02, 06, 2f, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 16 Number of expressions: 16
@ -20,7 +20,7 @@ Number of expressions: 16
- expression 14 operands: lhs = Expression(15, Add), rhs = Counter(2) - expression 14 operands: lhs = Expression(15, Add), rhs = Counter(2)
- expression 15 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 15 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 10 Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 4, 1) to (start + 3, 13) - Code(Counter(0)) at (prev + 5, 1) to (start + 3, 13)
- Code(Expression(0, Sub)) at (prev + 4, 5) to (start + 2, 6) - Code(Expression(0, Sub)) at (prev + 4, 5) to (start + 2, 6)
= (c0 - c1) = (c0 - c1)
- Code(Counter(1)) at (prev + 2, 6) to (start + 0, 7) - Code(Counter(1)) at (prev + 2, 6) to (start + 0, 7)

1
tests/coverage/if_not.coverage
View file

@ -1,6 +1,7 @@
LL| |#![feature(coverage_attribute)] LL| |#![feature(coverage_attribute)]
LL| |// edition: 2021 LL| |// edition: 2021
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 12|fn if_not(cond: bool) { LL| 12|fn if_not(cond: bool) {
LL| 12| if LL| 12| if
LL| 12| ! LL| 12| !

1
tests/coverage/if_not.rs
View file

@ -1,6 +1,7 @@
#![feature(coverage_attribute)] #![feature(coverage_attribute)]
// edition: 2021 // edition: 2021
#[rustfmt::skip]
fn if_not(cond: bool) { fn if_not(cond: bool) {
if if
! !

18
tests/coverage/inline-dead.cov-map
View file

@ -1,20 +1,20 @@
Function name: inline_dead::dead (unused) Function name: inline_dead::dead (unused)
Raw bytes (9): 0x[01, 01, 00, 01, 00, 19, 01, 02, 02] Raw bytes (9): 0x[01, 01, 00, 01, 00, 17, 01, 02, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Zero) at (prev + 25, 1) to (start + 2, 2) - Code(Zero) at (prev + 23, 1) to (start + 2, 2)
Function name: inline_dead::live::<false> Function name: inline_dead::live::<false>
Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 10, 01, 01, 09, 00, 02, 09, 00, 0f, 02, 02, 09, 00, 0a, 07, 02, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 0e, 01, 01, 09, 00, 02, 09, 00, 0f, 02, 02, 09, 00, 0a, 07, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Zero - expression 0 operands: lhs = Counter(0), rhs = Zero
- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub) - expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 16, 1) to (start + 1, 9) - Code(Counter(0)) at (prev + 14, 1) to (start + 1, 9)
- Code(Zero) at (prev + 2, 9) to (start + 0, 15) - Code(Zero) at (prev + 2, 9) to (start + 0, 15)
- Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10) - Code(Expression(0, Sub)) at (prev + 2, 9) to (start + 0, 10)
= (c0 - Zero) = (c0 - Zero)
@ -22,16 +22,16 @@ Number of file 0 mappings: 4
= (Zero + (c0 - Zero)) = (Zero + (c0 - Zero))
Function name: inline_dead::main Function name: inline_dead::main
Raw bytes (14): 0x[01, 01, 00, 02, 01, 04, 01, 03, 0d, 01, 07, 06, 02, 02] Raw bytes (14): 0x[01, 01, 00, 02, 01, 04, 01, 03, 0d, 01, 05, 06, 02, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 2 Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 4, 1) to (start + 3, 13) - Code(Counter(0)) at (prev + 4, 1) to (start + 3, 13)
- Code(Counter(0)) at (prev + 7, 6) to (start + 2, 2) - Code(Counter(0)) at (prev + 5, 6) to (start + 2, 2)
Function name: inline_dead::main::{closure#0} Function name: inline_dead::main::{closure#0}
Raw bytes (23): 0x[01, 01, 02, 00, 06, 01, 00, 03, 01, 07, 17, 01, 16, 00, 02, 0d, 00, 0e, 03, 02, 05, 00, 06] Raw bytes (23): 0x[01, 01, 02, 00, 06, 01, 00, 03, 01, 07, 17, 01, 16, 00, 01, 17, 00, 18, 03, 01, 05, 00, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
@ -39,7 +39,7 @@ Number of expressions: 2
- expression 1 operands: lhs = Counter(0), rhs = Zero - expression 1 operands: lhs = Counter(0), rhs = Zero
Number of file 0 mappings: 3 Number of file 0 mappings: 3
- Code(Counter(0)) at (prev + 7, 23) to (start + 1, 22) - Code(Counter(0)) at (prev + 7, 23) to (start + 1, 22)
- Code(Zero) at (prev + 2, 13) to (start + 0, 14) - Code(Zero) at (prev + 1, 23) to (start + 0, 24)
- Code(Expression(0, Add)) at (prev + 2, 5) to (start + 0, 6) - Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 6)
= (Zero + (c0 - Zero)) = (Zero + (c0 - Zero))

5
tests/coverage/inline-dead.coverage
View file

@ -5,9 +5,8 @@
LL| 1| println!("{}", live::<false>()); LL| 1| println!("{}", live::<false>());
LL| 1| LL| 1|
LL| 1| let f = |x: bool| { LL| 1| let f = |x: bool| {
LL| 1| debug_assert!( LL| 1| debug_assert!(x);
LL| 0| x ^0
LL| | );
LL| 1| }; LL| 1| };
LL| 1| f(false); LL| 1| f(false);
LL| 1|} LL| 1|}

4
tests/coverage/inline-dead.rs
View file

@ -5,9 +5,7 @@ fn main() {
println!("{}", live::<false>()); println!("{}", live::<false>());
let f = |x: bool| { let f = |x: bool| {
debug_assert!( debug_assert!(x);
x
);
}; };
f(false); f(false);
} }

24
tests/coverage/issue-84561.cov-map
View file

@ -7,14 +7,14 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 4, 10) to (start + 0, 19) - Code(Counter(0)) at (prev + 4, 10) to (start + 0, 19)
Function name: <issue_84561::Foo as core::fmt::Debug>::fmt Function name: <issue_84561::Foo as core::fmt::Debug>::fmt
Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 88, 01, 05, 01, 25, 05, 01, 25, 00, 26, 02, 01, 09, 00, 0f, 07, 01, 05, 00, 06] Raw bytes (29): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 8a, 01, 05, 01, 25, 05, 01, 25, 00, 26, 02, 01, 09, 00, 0f, 07, 01, 05, 00, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 136, 5) to (start + 1, 37) - Code(Counter(0)) at (prev + 138, 5) to (start + 1, 37)
- Code(Counter(1)) at (prev + 1, 37) to (start + 0, 38) - Code(Counter(1)) at (prev + 1, 37) to (start + 0, 38)
- Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15) - Code(Expression(0, Sub)) at (prev + 1, 9) to (start + 0, 15)
= (c0 - c1) = (c0 - c1)
@ -22,15 +22,15 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: issue_84561::main Function name: issue_84561::main
Raw bytes (10): 0x[01, 01, 00, 01, 01, b2, 01, 01, 04, 02] Raw bytes (10): 0x[01, 01, 00, 01, 01, b4, 01, 01, 04, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 178, 1) to (start + 4, 2) - Code(Counter(0)) at (prev + 180, 1) to (start + 4, 2)
Function name: issue_84561::test1 Function name: issue_84561::test1
Raw bytes (78): 0x[01, 01, 0e, 05, 06, 01, 05, 09, 36, 03, 09, 0d, 2e, 33, 0d, 09, 36, 03, 09, 11, 26, 2b, 11, 0d, 2e, 33, 0d, 09, 36, 03, 09, 09, 01, 98, 01, 01, 01, 0b, 05, 01, 0c, 00, 1e, 03, 01, 05, 00, 0b, 09, 00, 0c, 00, 1e, 33, 01, 0d, 01, 0b, 0d, 01, 0c, 00, 1e, 2b, 01, 05, 03, 0b, 11, 03, 0c, 00, 1e, 23, 01, 01, 00, 02] Raw bytes (78): 0x[01, 01, 0e, 05, 06, 01, 05, 09, 36, 03, 09, 0d, 2e, 33, 0d, 09, 36, 03, 09, 11, 26, 2b, 11, 0d, 2e, 33, 0d, 09, 36, 03, 09, 09, 01, 9a, 01, 01, 01, 0b, 05, 01, 0c, 00, 1e, 03, 01, 05, 00, 0b, 09, 00, 0c, 00, 1e, 33, 01, 0d, 01, 0b, 0d, 01, 0c, 00, 1e, 2b, 01, 05, 03, 0b, 11, 03, 0c, 00, 1e, 23, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 14 Number of expressions: 14
@ -49,7 +49,7 @@ Number of expressions: 14
- expression 12 operands: lhs = Counter(2), rhs = Expression(13, Sub) - expression 12 operands: lhs = Counter(2), rhs = Expression(13, Sub)
- expression 13 operands: lhs = Expression(0, Add), rhs = Counter(2) - expression 13 operands: lhs = Expression(0, Add), rhs = Counter(2)
Number of file 0 mappings: 9 Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 152, 1) to (start + 1, 11) - Code(Counter(0)) at (prev + 154, 1) to (start + 1, 11)
- Code(Counter(1)) at (prev + 1, 12) to (start + 0, 30) - Code(Counter(1)) at (prev + 1, 12) to (start + 0, 30)
- Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 11) - Code(Expression(0, Add)) at (prev + 1, 5) to (start + 0, 11)
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
@ -64,28 +64,28 @@ Number of file 0 mappings: 9
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)) = (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
Function name: issue_84561::test2 Function name: issue_84561::test2
Raw bytes (24): 0x[01, 01, 02, 05, 06, 01, 05, 03, 01, ae, 01, 01, 01, 10, 05, 01, 11, 00, 23, 03, 01, 01, 00, 02] Raw bytes (24): 0x[01, 01, 02, 05, 06, 01, 05, 03, 01, b0, 01, 01, 01, 10, 05, 01, 11, 00, 23, 03, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(1), rhs = Expression(1, Sub) - expression 0 operands: lhs = Counter(1), rhs = Expression(1, Sub)
- expression 1 operands: lhs = Counter(0), rhs = Counter(1) - expression 1 operands: lhs = Counter(0), rhs = Counter(1)
Number of file 0 mappings: 3 Number of file 0 mappings: 3
- Code(Counter(0)) at (prev + 174, 1) to (start + 1, 16) - Code(Counter(0)) at (prev + 176, 1) to (start + 1, 16)
- Code(Counter(1)) at (prev + 1, 17) to (start + 0, 35) - Code(Counter(1)) at (prev + 1, 17) to (start + 0, 35)
- Code(Expression(0, Add)) at (prev + 1, 1) to (start + 0, 2) - Code(Expression(0, Add)) at (prev + 1, 1) to (start + 0, 2)
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: issue_84561::test2::call_print Function name: issue_84561::test2::call_print
Raw bytes (10): 0x[01, 01, 00, 01, 01, a5, 01, 09, 02, 0a] Raw bytes (10): 0x[01, 01, 00, 01, 01, a7, 01, 09, 02, 0a]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 165, 9) to (start + 2, 10) - Code(Counter(0)) at (prev + 167, 9) to (start + 2, 10)
Function name: issue_84561::test3 Function name: issue_84561::test3
Raw bytes (436): 0x[01, 01, 41, 05, 09, 0d, 00, 15, 19, 12, 00, 15, 19, 21, 00, 1e, 00, 21, 00, 31, 00, 3d, 41, 2e, 45, 3d, 41, 42, 49, 45, 00, 3f, 51, 42, 49, 45, 00, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 92, 01, 55, 51, 00, 8f, 01, 5d, 92, 01, 55, 51, 00, 87, 01, 61, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 82, 01, 65, 87, 01, 61, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, 71, fe, 01, 82, 02, 71, 69, 6d, 69, 6d, 82, 02, 71, 69, 6d, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, f3, 01, 7d, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, ee, 01, 00, f3, 01, 7d, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, 33, 01, 06, 01, 03, 1c, 05, 04, 09, 01, 1c, 02, 02, 05, 04, 1f, 0d, 05, 05, 00, 1f, 06, 01, 05, 00, 1f, 15, 01, 09, 01, 1c, 12, 02, 05, 00, 1f, 0e, 01, 05, 00, 0f, 00, 00, 20, 00, 30, 21, 01, 05, 03, 0f, 00, 03, 20, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 1e, 01, 05, 00, 0f, 00, 05, 09, 03, 10, 00, 05, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 1a, 04, 09, 05, 06, 31, 06, 05, 03, 06, 22, 04, 05, 03, 06, 3d, 04, 09, 04, 06, 2e, 05, 08, 00, 0f, 45, 01, 09, 03, 0a, 2a, 05, 09, 03, 0a, 3f, 05, 08, 00, 0f, 51, 01, 09, 00, 13, 00, 03, 0d, 00, 1d, 3a, 03, 09, 00, 13, 00, 03, 0d, 00, 1d, 87, 01, 03, 05, 00, 0f, 8f, 01, 01, 0c, 00, 13, 5d, 01, 0d, 00, 13, 8a, 01, 02, 0d, 00, 13, 82, 01, 04, 05, 02, 13, 65, 03, 0d, 00, 13, 7e, 02, 0d, 00, 13, f3, 01, 03, 05, 00, 0f, 69, 01, 0c, 00, 13, 6d, 01, 0d, 03, 0e, 75, 04, 0d, 00, 13, fb, 01, 02, 0d, 00, 17, 82, 02, 01, 14, 00, 1b, 71, 01, 15, 00, 1b, fe, 01, 02, 15, 00, 1b, f6, 01, 04, 0d, 00, 13, 7d, 03, 09, 00, 19, ee, 01, 02, 05, 00, 0f, ea, 01, 03, 09, 00, 22, 00, 02, 05, 00, 0f, 00, 03, 09, 00, 2c, 00, 02, 01, 00, 02] Raw bytes (436): 0x[01, 01, 41, 05, 09, 0d, 00, 15, 19, 12, 00, 15, 19, 21, 00, 1e, 00, 21, 00, 31, 00, 3d, 41, 2e, 45, 3d, 41, 42, 49, 45, 00, 3f, 51, 42, 49, 45, 00, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 92, 01, 55, 51, 00, 8f, 01, 5d, 92, 01, 55, 51, 00, 87, 01, 61, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 82, 01, 65, 87, 01, 61, 5d, 8a, 01, 8f, 01, 5d, 92, 01, 55, 51, 00, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, 71, fe, 01, 82, 02, 71, 69, 6d, 69, 6d, 82, 02, 71, 69, 6d, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, f3, 01, 7d, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, ee, 01, 00, f3, 01, 7d, 75, f6, 01, fb, 01, 79, 71, fe, 01, 82, 02, 71, 69, 6d, 33, 01, 08, 01, 03, 1c, 05, 04, 09, 01, 1c, 02, 02, 05, 04, 1f, 0d, 05, 05, 00, 1f, 06, 01, 05, 00, 1f, 15, 01, 09, 01, 1c, 12, 02, 05, 00, 1f, 0e, 01, 05, 00, 0f, 00, 00, 20, 00, 30, 21, 01, 05, 03, 0f, 00, 03, 20, 00, 30, 00, 00, 33, 00, 41, 00, 00, 4b, 00, 5a, 1e, 01, 05, 00, 0f, 00, 05, 09, 03, 10, 00, 05, 0d, 00, 1b, 00, 02, 0d, 00, 1c, 1a, 04, 09, 05, 06, 31, 06, 05, 03, 06, 22, 04, 05, 03, 06, 3d, 04, 09, 04, 06, 2e, 05, 08, 00, 0f, 45, 01, 09, 03, 0a, 2a, 05, 09, 03, 0a, 3f, 05, 08, 00, 0f, 51, 01, 09, 00, 13, 00, 03, 0d, 00, 1d, 3a, 03, 09, 00, 13, 00, 03, 0d, 00, 1d, 87, 01, 03, 05, 00, 0f, 8f, 01, 01, 0c, 00, 13, 5d, 01, 0d, 00, 13, 8a, 01, 02, 0d, 00, 13, 82, 01, 04, 05, 02, 13, 65, 03, 0d, 00, 13, 7e, 02, 0d, 00, 13, f3, 01, 03, 05, 00, 0f, 69, 01, 0c, 00, 13, 6d, 01, 0d, 03, 0e, 75, 04, 0d, 00, 13, fb, 01, 02, 0d, 00, 17, 82, 02, 01, 14, 00, 1b, 71, 01, 15, 00, 1b, fe, 01, 02, 15, 00, 1b, f6, 01, 04, 0d, 00, 13, 7d, 03, 09, 00, 19, ee, 01, 02, 05, 00, 0f, ea, 01, 03, 09, 00, 22, 00, 02, 05, 00, 0f, 00, 03, 09, 00, 2c, 00, 02, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 65 Number of expressions: 65
@ -155,7 +155,7 @@ Number of expressions: 65
- expression 63 operands: lhs = Expression(64, Sub), rhs = Counter(28) - expression 63 operands: lhs = Expression(64, Sub), rhs = Counter(28)
- expression 64 operands: lhs = Counter(26), rhs = Counter(27) - expression 64 operands: lhs = Counter(26), rhs = Counter(27)
Number of file 0 mappings: 51 Number of file 0 mappings: 51
- Code(Counter(0)) at (prev + 6, 1) to (start + 3, 28) - Code(Counter(0)) at (prev + 8, 1) to (start + 3, 28)
- Code(Counter(1)) at (prev + 4, 9) to (start + 1, 28) - Code(Counter(1)) at (prev + 4, 9) to (start + 1, 28)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 4, 31) - Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 4, 31)
= (c1 - c2) = (c1 - c2)

2
tests/coverage/issue-84561.coverage
View file

@ -3,6 +3,8 @@
LL| |// failure-status: 101 LL| |// failure-status: 101
LL| 21|#[derive(PartialEq, Eq)] LL| 21|#[derive(PartialEq, Eq)]
LL| |struct Foo(u32); LL| |struct Foo(u32);
LL| |
LL| |#[rustfmt::skip]
LL| 1|fn test3() { LL| 1|fn test3() {
LL| 1| let is_true = std::env::args().len() == 1; LL| 1| let is_true = std::env::args().len() == 1;
LL| 1| let bar = Foo(1); LL| 1| let bar = Foo(1);

2
tests/coverage/issue-84561.rs
View file

@ -3,6 +3,8 @@
// failure-status: 101 // failure-status: 101
#[derive(PartialEq, Eq)] #[derive(PartialEq, Eq)]
struct Foo(u32); struct Foo(u32);
#[rustfmt::skip]
fn test3() { fn test3() {
let is_true = std::env::args().len() == 1; let is_true = std::env::args().len() == 1;
let bar = Foo(1); let bar = Foo(1);

4
tests/coverage/lazy_boolean.cov-map
View file

@ -1,5 +1,5 @@
Function name: lazy_boolean::main Function name: lazy_boolean::main
Raw bytes (636): 0x[01, 01, a4, 01, 01, 05, 09, 8a, 05, 8f, 05, 09, 05, 02, 05, 02, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 09, 8a, 05, 8f, 05, 09, 05, 02, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 25, d2, 04, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1c, 01, 03, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 06, 00, 07, 87, 05, 02, 09, 00, 11, 8f, 05, 02, 0d, 00, 12, 8a, 05, 02, 0d, 00, 12, ff, 04, 03, 09, 00, 11, 87, 05, 02, 0d, 00, 12, 82, 05, 02, 0d, 00, 12, f7, 04, 02, 09, 00, 11, ff, 04, 00, 14, 00, 19, 11, 00, 1d, 00, 22, ef, 04, 01, 09, 00, 11, f7, 04, 00, 14, 00, 19, 15, 00, 1d, 00, 22, ef, 04, 03, 09, 01, 10, ea, 04, 02, 05, 03, 06, 19, 03, 06, 00, 07, e7, 04, 03, 09, 00, 10, 1d, 01, 05, 03, 06, e2, 04, 05, 05, 03, 06, df, 04, 05, 08, 00, 10, da, 04, 00, 11, 02, 06, 21, 02, 06, 00, 07, d7, 04, 02, 08, 00, 0f, 25, 00, 10, 02, 06, d2, 04, 02, 0c, 02, 06, cf, 04, 03, 01, 00, 02] Raw bytes (636): 0x[01, 01, a4, 01, 01, 05, 09, 8a, 05, 8f, 05, 09, 05, 02, 05, 02, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 09, 8a, 05, 8f, 05, 09, 05, 02, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 25, d2, 04, d7, 04, 25, 21, da, 04, df, 04, 21, 1d, e2, 04, e7, 04, 1d, 19, ea, 04, ef, 04, 19, 15, f2, 04, f7, 04, 15, 11, fa, 04, ff, 04, 11, 0d, 82, 05, 87, 05, 0d, 09, 8a, 05, 8f, 05, 09, 05, 02, 1c, 01, 04, 01, 07, 0f, 05, 07, 10, 04, 06, 02, 04, 06, 00, 07, 87, 05, 02, 09, 00, 11, 8f, 05, 02, 0d, 00, 12, 8a, 05, 02, 0d, 00, 12, ff, 04, 03, 09, 00, 11, 87, 05, 02, 0d, 00, 12, 82, 05, 02, 0d, 00, 12, f7, 04, 02, 09, 00, 11, ff, 04, 00, 14, 00, 19, 11, 00, 1d, 00, 22, ef, 04, 01, 09, 00, 11, f7, 04, 00, 14, 00, 19, 15, 00, 1d, 00, 22, ef, 04, 03, 09, 01, 10, ea, 04, 02, 05, 03, 06, 19, 03, 06, 00, 07, e7, 04, 03, 09, 00, 10, 1d, 01, 05, 03, 06, e2, 04, 05, 05, 03, 06, df, 04, 05, 08, 00, 10, da, 04, 00, 11, 02, 06, 21, 02, 06, 00, 07, d7, 04, 02, 08, 00, 0f, 25, 00, 10, 02, 06, d2, 04, 02, 0c, 02, 06, cf, 04, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 164 Number of expressions: 164
@ -168,7 +168,7 @@ Number of expressions: 164
- expression 162 operands: lhs = Expression(163, Add), rhs = Counter(2) - expression 162 operands: lhs = Expression(163, Add), rhs = Counter(2)
- expression 163 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 163 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 28 Number of file 0 mappings: 28
- Code(Counter(0)) at (prev + 3, 1) to (start + 7, 15) - Code(Counter(0)) at (prev + 4, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 4, 6) - Code(Counter(1)) at (prev + 7, 16) to (start + 4, 6)
- Code(Expression(0, Sub)) at (prev + 4, 6) to (start + 0, 7) - Code(Expression(0, Sub)) at (prev + 4, 6) to (start + 0, 7)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/lazy_boolean.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments, unused_variables)] LL| |#![allow(unused_assignments, unused_variables)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/lazy_boolean.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments, unused_variables)] #![allow(unused_assignments, unused_variables)]
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

4
tests/coverage/loop_break_value.cov-map
View file

@ -1,8 +1,8 @@
Function name: loop_break_value::main Function name: loop_break_value::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 03, 01, 0a, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 04, 01, 0a, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 3, 1) to (start + 10, 2) - Code(Counter(0)) at (prev + 4, 1) to (start + 10, 2)

1
tests/coverage/loop_break_value.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments, unused_variables)] LL| |#![allow(unused_assignments, unused_variables)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| let result LL| 1| let result
LL| 1| = LL| 1| =

1
tests/coverage/loop_break_value.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments, unused_variables)] #![allow(unused_assignments, unused_variables)]
#[rustfmt::skip]
fn main() { fn main() {
let result let result
= =

4
tests/coverage/partial_eq.cov-map
View file

@ -55,10 +55,10 @@ Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 12, 5) to (start + 6, 6) - Code(Counter(0)) at (prev + 12, 5) to (start + 6, 6)
Function name: partial_eq::main Function name: partial_eq::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 01, 05, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 15, 01, 0a, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 21, 1) to (start + 5, 2) - Code(Counter(0)) at (prev + 21, 1) to (start + 10, 2)

7
tests/coverage/partial_eq.coverage
View file

@ -23,7 +23,12 @@
LL| 1| let version_3_2_1 = Version::new(3, 2, 1); LL| 1| let version_3_2_1 = Version::new(3, 2, 1);
LL| 1| let version_3_3_0 = Version::new(3, 3, 0); LL| 1| let version_3_3_0 = Version::new(3, 3, 0);
LL| 1| LL| 1|
LL| 1| println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); LL| 1| println!(
LL| 1| "{:?} < {:?} = {}",
LL| 1| version_3_2_1,
LL| 1| version_3_3_0,
LL| 1| version_3_2_1 < version_3_3_0
LL| 1| );
LL| 1|} LL| 1|}
LL| | LL| |
LL| |/* LL| |/*

7
tests/coverage/partial_eq.rs
View file

@ -22,7 +22,12 @@ fn main() {
let version_3_2_1 = Version::new(3, 2, 1); let version_3_2_1 = Version::new(3, 2, 1);
let version_3_3_0 = Version::new(3, 3, 0); let version_3_3_0 = Version::new(3, 3, 0);
println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0); println!(
"{:?} < {:?} = {}",
version_3_2_1,
version_3_3_0,
version_3_2_1 < version_3_3_0
);
} }
/* /*

4
tests/coverage/simple_loop.cov-map
View file

@ -1,5 +1,5 @@
Function name: simple_loop::main Function name: simple_loop::main
Raw bytes (57): 0x[01, 01, 09, 01, 05, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 07, 01, 03, 01, 09, 10, 05, 0a, 05, 05, 06, 02, 05, 06, 00, 07, 1f, 05, 0d, 02, 0e, 1a, 04, 0d, 00, 12, 09, 02, 0a, 03, 0a, 1a, 06, 01, 00, 02] Raw bytes (57): 0x[01, 01, 09, 01, 05, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 1f, 09, 23, 09, 05, 02, 07, 01, 04, 01, 09, 10, 05, 0a, 05, 05, 06, 02, 05, 06, 00, 07, 1f, 05, 0d, 02, 0e, 1a, 04, 0d, 00, 12, 09, 02, 0a, 03, 0a, 1a, 06, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 9 Number of expressions: 9
@ -13,7 +13,7 @@ Number of expressions: 9
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(2) - expression 7 operands: lhs = Expression(8, Add), rhs = Counter(2)
- expression 8 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 8 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 7 Number of file 0 mappings: 7
- Code(Counter(0)) at (prev + 3, 1) to (start + 9, 16) - Code(Counter(0)) at (prev + 4, 1) to (start + 9, 16)
- Code(Counter(1)) at (prev + 10, 5) to (start + 5, 6) - Code(Counter(1)) at (prev + 10, 5) to (start + 5, 6)
- Code(Expression(0, Sub)) at (prev + 5, 6) to (start + 0, 7) - Code(Expression(0, Sub)) at (prev + 5, 6) to (start + 0, 7)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/simple_loop.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments)] LL| |#![allow(unused_assignments)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/simple_loop.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments)] #![allow(unused_assignments)]
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

4
tests/coverage/simple_match.cov-map
View file

@ -1,5 +1,5 @@
Function name: simple_match::main Function name: simple_match::main
Raw bytes (78): 0x[01, 01, 0c, 01, 05, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 0a, 01, 03, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 06, 00, 07, 27, 05, 09, 00, 0d, 22, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 22, 02, 11, 02, 12, 09, 04, 0d, 07, 0e, 0d, 0a, 0d, 00, 0f, 11, 03, 01, 00, 02] Raw bytes (78): 0x[01, 01, 0c, 01, 05, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 27, 11, 2b, 2f, 05, 02, 09, 0d, 0a, 01, 04, 01, 07, 0f, 05, 07, 10, 02, 06, 02, 02, 06, 00, 07, 27, 05, 09, 00, 0d, 22, 05, 0d, 00, 16, 09, 02, 0d, 00, 0e, 22, 02, 11, 02, 12, 09, 04, 0d, 07, 0e, 0d, 0a, 0d, 00, 0f, 11, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 12 Number of expressions: 12
@ -16,7 +16,7 @@ Number of expressions: 12
- expression 10 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 10 operands: lhs = Counter(1), rhs = Expression(0, Sub)
- expression 11 operands: lhs = Counter(2), rhs = Counter(3) - expression 11 operands: lhs = Counter(2), rhs = Counter(3)
Number of file 0 mappings: 10 Number of file 0 mappings: 10
- Code(Counter(0)) at (prev + 3, 1) to (start + 7, 15) - Code(Counter(0)) at (prev + 4, 1) to (start + 7, 15)
- Code(Counter(1)) at (prev + 7, 16) to (start + 2, 6) - Code(Counter(1)) at (prev + 7, 16) to (start + 2, 6)
- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7) - Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
= (c0 - c1) = (c0 - c1)

1
tests/coverage/simple_match.coverage
View file

@ -1,5 +1,6 @@
LL| |#![allow(unused_assignments, unused_variables)] LL| |#![allow(unused_assignments, unused_variables)]
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure 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| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

1
tests/coverage/simple_match.rs
View file

@ -1,5 +1,6 @@
#![allow(unused_assignments, unused_variables)] #![allow(unused_assignments, unused_variables)]
#[rustfmt::skip]
fn main() { fn main() {
// Initialize test constants in a way that cannot be determined at compile time, to ensure // Initialize test constants in a way that cannot be determined at compile time, to ensure
// rustc and LLVM cannot optimize out statements (or coverage counters) downstream from // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from

4
tests/coverage/thin-lto.cov-map
View file

@ -1,8 +1,8 @@
Function name: thin_lto::main Function name: thin_lto::main
Raw bytes (9): 0x[01, 01, 00, 01, 01, 03, 01, 01, 02] Raw bytes (9): 0x[01, 01, 00, 01, 01, 03, 01, 00, 11]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 0 Number of expressions: 0
Number of file 0 mappings: 1 Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 3, 1) to (start + 1, 2) - Code(Counter(0)) at (prev + 3, 1) to (start + 0, 17)

3
tests/coverage/thin-lto.coverage
View file

@ -1,5 +1,4 @@
LL| |// compile-flags: -O -C lto=thin -C prefer-dynamic=no LL| |// compile-flags: -O -C lto=thin -C prefer-dynamic=no
LL| | LL| |
LL| 1|pub fn main() { LL| 1|pub fn main() {}
LL| 1|}

3
tests/coverage/thin-lto.rs
View file

@ -1,4 +1,3 @@
// compile-flags: -O -C lto=thin -C prefer-dynamic=no // compile-flags: -O -C lto=thin -C prefer-dynamic=no
pub fn main() { pub fn main() {}
}

20
tests/coverage/try_error_result.cov-map
View file

@ -1,12 +1,12 @@
Function name: <try_error_result::Thing1>::get_thing_2 Function name: <try_error_result::Thing1>::get_thing_2
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 28, 05, 01, 18, 05, 02, 0d, 00, 14, 02, 02, 0d, 00, 1a, 07, 02, 05, 00, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 29, 05, 01, 18, 05, 02, 0d, 00, 14, 02, 02, 0d, 00, 1a, 07, 02, 05, 00, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 40, 5) to (start + 1, 24) - Code(Counter(0)) at (prev + 41, 5) to (start + 1, 24)
- Code(Counter(1)) at (prev + 2, 13) to (start + 0, 20) - Code(Counter(1)) at (prev + 2, 13) to (start + 0, 20)
- Code(Expression(0, Sub)) at (prev + 2, 13) to (start + 0, 26) - Code(Expression(0, Sub)) at (prev + 2, 13) to (start + 0, 26)
= (c0 - c1) = (c0 - c1)
@ -14,14 +14,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: <try_error_result::Thing2>::call Function name: <try_error_result::Thing2>::call
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 33, 05, 01, 18, 05, 02, 0d, 00, 14, 02, 02, 0d, 00, 13, 07, 02, 05, 00, 06] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 34, 05, 01, 18, 05, 02, 0d, 00, 14, 02, 02, 0d, 00, 13, 07, 02, 05, 00, 06]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 51, 5) to (start + 1, 24) - Code(Counter(0)) at (prev + 52, 5) to (start + 1, 24)
- Code(Counter(1)) at (prev + 2, 13) to (start + 0, 20) - Code(Counter(1)) at (prev + 2, 13) to (start + 0, 20)
- Code(Expression(0, Sub)) at (prev + 2, 13) to (start + 0, 19) - Code(Expression(0, Sub)) at (prev + 2, 13) to (start + 0, 19)
= (c0 - c1) = (c0 - c1)
@ -44,14 +44,14 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: try_error_result::main Function name: try_error_result::main
Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 70, 01, 02, 0c, 05, 03, 05, 00, 06, 02, 02, 05, 00, 0b, 07, 01, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 73, 01, 02, 0c, 05, 03, 05, 00, 06, 02, 02, 05, 00, 0b, 07, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
- expression 0 operands: lhs = Counter(0), rhs = Counter(1) - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub) - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
Number of file 0 mappings: 4 Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 112, 1) to (start + 2, 12) - Code(Counter(0)) at (prev + 115, 1) to (start + 2, 12)
- Code(Counter(1)) at (prev + 3, 5) to (start + 0, 6) - Code(Counter(1)) at (prev + 3, 5) to (start + 0, 6)
- Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 11) - Code(Expression(0, Sub)) at (prev + 2, 5) to (start + 0, 11)
= (c0 - c1) = (c0 - c1)
@ -59,7 +59,7 @@ Number of file 0 mappings: 4
= (c1 + (c0 - c1)) = (c1 + (c0 - c1))
Function name: try_error_result::test1 Function name: try_error_result::test1
Raw bytes (77): 0x[01, 01, 09, 01, 07, 05, 09, 03, 0d, 1d, 11, 16, 1d, 03, 0d, 1f, 0d, 23, 19, 11, 15, 0b, 01, 0c, 01, 02, 17, 03, 07, 09, 00, 0e, 16, 02, 09, 04, 1a, 1d, 06, 0d, 00, 29, 11, 00, 29, 00, 2a, 0e, 01, 0d, 00, 2a, 15, 00, 2a, 00, 2b, 12, 04, 0d, 00, 2a, 19, 00, 2a, 00, 2b, 0d, 03, 05, 00, 0b, 1b, 01, 01, 00, 02] Raw bytes (77): 0x[01, 01, 09, 01, 07, 05, 09, 03, 0d, 1d, 11, 16, 1d, 03, 0d, 1f, 0d, 23, 19, 11, 15, 0b, 01, 0d, 01, 02, 17, 03, 07, 09, 00, 0e, 16, 02, 09, 04, 1a, 1d, 06, 0d, 00, 29, 11, 00, 29, 00, 2a, 0e, 01, 0d, 00, 2a, 15, 00, 2a, 00, 2b, 12, 04, 0d, 00, 2a, 19, 00, 2a, 00, 2b, 0d, 03, 05, 00, 0b, 1b, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 9 Number of expressions: 9
@ -73,7 +73,7 @@ Number of expressions: 9
- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(6) - expression 7 operands: lhs = Expression(8, Add), rhs = Counter(6)
- expression 8 operands: lhs = Counter(4), rhs = Counter(5) - expression 8 operands: lhs = Counter(4), rhs = Counter(5)
Number of file 0 mappings: 11 Number of file 0 mappings: 11
- Code(Counter(0)) at (prev + 12, 1) to (start + 2, 23) - Code(Counter(0)) at (prev + 13, 1) to (start + 2, 23)
- Code(Expression(0, Add)) at (prev + 7, 9) to (start + 0, 14) - Code(Expression(0, Add)) at (prev + 7, 9) to (start + 0, 14)
= (c0 + (c1 + c2)) = (c0 + (c1 + c2))
- Code(Expression(5, Sub)) at (prev + 2, 9) to (start + 4, 26) - Code(Expression(5, Sub)) at (prev + 2, 9) to (start + 4, 26)
@ -91,7 +91,7 @@ Number of file 0 mappings: 11
= (((c4 + c5) + c6) + c3) = (((c4 + c5) + c6) + c3)
Function name: try_error_result::test2 Function name: try_error_result::test2
Raw bytes (358): 0x[01, 01, 3b, 01, 07, 05, 09, 03, 0d, 41, 11, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 4a, 15, 41, 11, 46, 19, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 5e, 25, 49, 21, 49, 21, 5e, 25, 49, 21, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, 92, 01, 41, 03, 0d, 8e, 01, 29, 92, 01, 41, 03, 0d, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, a6, 01, 35, 45, 31, 45, 31, a6, 01, 35, 45, 31, ba, 01, 3d, 4d, 39, 4d, 39, ba, 01, 3d, 4d, 39, c3, 01, 0d, c7, 01, db, 01, cb, 01, cf, 01, 11, 15, d3, 01, d7, 01, 19, 1d, 21, 25, df, 01, e3, 01, 29, 2d, e7, 01, eb, 01, 31, 35, 39, 3d, 28, 01, 3c, 01, 03, 17, 03, 08, 09, 00, 0e, 92, 01, 02, 09, 04, 1a, 41, 06, 0d, 00, 2f, 11, 00, 2f, 00, 30, 4a, 00, 31, 03, 35, 15, 04, 11, 00, 12, 46, 02, 11, 04, 12, 3e, 05, 11, 00, 14, 46, 00, 17, 00, 41, 19, 00, 41, 00, 42, 42, 00, 43, 00, 5f, 1d, 00, 5f, 00, 60, 3e, 01, 0d, 00, 20, 5a, 01, 11, 00, 14, 49, 00, 17, 00, 41, 21, 00, 41, 00, 42, 5e, 00, 43, 00, 60, 25, 00, 60, 00, 61, 5a, 01, 0d, 00, 20, 86, 01, 04, 11, 00, 14, 8e, 01, 00, 17, 00, 42, 29, 00, 42, 00, 43, 8a, 01, 00, 44, 00, 61, 2d, 00, 61, 00, 62, 86, 01, 01, 0d, 00, 20, a2, 01, 01, 11, 00, 14, 45, 00, 17, 01, 36, 31, 01, 36, 00, 37, a6, 01, 01, 12, 00, 2f, 35, 00, 2f, 00, 30, a2, 01, 01, 0d, 00, 20, b6, 01, 01, 11, 00, 14, 4d, 00, 17, 01, 36, 39, 02, 11, 00, 12, ba, 01, 01, 12, 00, 2f, 3d, 01, 11, 00, 12, b6, 01, 02, 0d, 00, 20, 0d, 03, 05, 00, 0b, bf, 01, 01, 01, 00, 02] Raw bytes (358): 0x[01, 01, 3b, 01, 07, 05, 09, 03, 0d, 41, 11, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 4a, 15, 41, 11, 46, 19, 4a, 15, 41, 11, 42, 1d, 46, 19, 4a, 15, 41, 11, 5e, 25, 49, 21, 49, 21, 5e, 25, 49, 21, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, 92, 01, 41, 03, 0d, 8e, 01, 29, 92, 01, 41, 03, 0d, 8a, 01, 2d, 8e, 01, 29, 92, 01, 41, 03, 0d, a6, 01, 35, 45, 31, 45, 31, a6, 01, 35, 45, 31, ba, 01, 3d, 4d, 39, 4d, 39, ba, 01, 3d, 4d, 39, c3, 01, 0d, c7, 01, db, 01, cb, 01, cf, 01, 11, 15, d3, 01, d7, 01, 19, 1d, 21, 25, df, 01, e3, 01, 29, 2d, e7, 01, eb, 01, 31, 35, 39, 3d, 28, 01, 3e, 01, 03, 17, 03, 08, 09, 00, 0e, 92, 01, 02, 09, 04, 1a, 41, 06, 0d, 00, 2f, 11, 00, 2f, 00, 30, 4a, 00, 31, 03, 35, 15, 04, 11, 00, 12, 46, 02, 11, 04, 12, 3e, 05, 11, 00, 14, 46, 00, 17, 00, 41, 19, 00, 41, 00, 42, 42, 00, 43, 00, 5f, 1d, 00, 5f, 00, 60, 3e, 01, 0d, 00, 20, 5a, 01, 11, 00, 14, 49, 00, 17, 00, 41, 21, 00, 41, 00, 42, 5e, 00, 43, 00, 60, 25, 00, 60, 00, 61, 5a, 01, 0d, 00, 20, 86, 01, 04, 11, 00, 14, 8e, 01, 00, 17, 00, 42, 29, 00, 42, 00, 43, 8a, 01, 00, 44, 00, 61, 2d, 00, 61, 00, 62, 86, 01, 01, 0d, 00, 20, a2, 01, 01, 11, 00, 14, 45, 00, 17, 01, 36, 31, 01, 36, 00, 37, a6, 01, 01, 12, 00, 2f, 35, 00, 2f, 00, 30, a2, 01, 01, 0d, 00, 20, b6, 01, 01, 11, 00, 14, 4d, 00, 17, 01, 36, 39, 02, 11, 00, 12, ba, 01, 01, 12, 00, 2f, 3d, 01, 11, 00, 12, b6, 01, 02, 0d, 00, 20, 0d, 03, 05, 00, 0b, bf, 01, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 59 Number of expressions: 59
@ -155,7 +155,7 @@ Number of expressions: 59
- expression 57 operands: lhs = Counter(12), rhs = Counter(13) - expression 57 operands: lhs = Counter(12), rhs = Counter(13)
- expression 58 operands: lhs = Counter(14), rhs = Counter(15) - expression 58 operands: lhs = Counter(14), rhs = Counter(15)
Number of file 0 mappings: 40 Number of file 0 mappings: 40
- Code(Counter(0)) at (prev + 60, 1) to (start + 3, 23) - Code(Counter(0)) at (prev + 62, 1) to (start + 3, 23)
- Code(Expression(0, Add)) at (prev + 8, 9) to (start + 0, 14) - Code(Expression(0, Add)) at (prev + 8, 9) to (start + 0, 14)
= (c0 + (c1 + c2)) = (c0 + (c1 + c2))
- Code(Expression(36, Sub)) at (prev + 2, 9) to (start + 4, 26) - Code(Expression(36, Sub)) at (prev + 2, 9) to (start + 4, 26)

3
tests/coverage/try_error_result.coverage
View file

@ -9,6 +9,7 @@
LL| | } LL| | }
LL| 6|} LL| 6|}
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn test1() -> Result<(), ()> { LL| 1|fn test1() -> Result<(), ()> {
LL| 1| let mut LL| 1| let mut
LL| 1| countdown = 10 LL| 1| countdown = 10
@ -58,6 +59,7 @@
LL| 17| } LL| 17| }
LL| |} LL| |}
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn test2() -> Result<(), ()> { LL| 1|fn test2() -> Result<(), ()> {
LL| 1| let thing1 = Thing1{}; LL| 1| let thing1 = Thing1{};
LL| 1| let mut LL| 1| let mut
@ -115,6 +117,7 @@
LL| 0| Ok(()) LL| 0| Ok(())
LL| 1|} LL| 1|}
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() -> Result<(), ()> { LL| 1|fn main() -> Result<(), ()> {
LL| 1| test1().expect_err("test1 should fail"); LL| 1| test1().expect_err("test1 should fail");
LL| 1| test2() LL| 1| test2()

3
tests/coverage/try_error_result.rs
View file

@ -9,6 +9,7 @@ fn call(return_error: bool) -> Result<(), ()> {
} }
} }
#[rustfmt::skip]
fn test1() -> Result<(), ()> { fn test1() -> Result<(), ()> {
let mut let mut
countdown = 10 countdown = 10
@ -57,6 +58,7 @@ impl Thing2 {
} }
} }
#[rustfmt::skip]
fn test2() -> Result<(), ()> { fn test2() -> Result<(), ()> {
let thing1 = Thing1{}; let thing1 = Thing1{};
let mut let mut
@ -109,6 +111,7 @@ fn test2() -> Result<(), ()> {
Ok(()) Ok(())
} }
#[rustfmt::skip]
fn main() -> Result<(), ()> { fn main() -> Result<(), ()> {
test1().expect_err("test1 should fail"); test1().expect_err("test1 should fail");
test2() test2()

6
tests/coverage/while.cov-map
View file

@ -1,5 +1,5 @@
Function name: while::main Function name: while::main
Raw bytes (28): 0x[01, 01, 02, 01, 00, 03, 00, 04, 01, 01, 01, 01, 10, 03, 02, 0b, 00, 14, 00, 00, 15, 01, 06, 06, 02, 01, 00, 02] Raw bytes (28): 0x[01, 01, 02, 01, 00, 03, 00, 04, 01, 01, 01, 01, 10, 03, 02, 0b, 00, 14, 00, 00, 15, 02, 06, 06, 03, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 2 Number of expressions: 2
@ -9,7 +9,7 @@ Number of file 0 mappings: 4
- Code(Counter(0)) at (prev + 1, 1) to (start + 1, 16) - Code(Counter(0)) at (prev + 1, 1) to (start + 1, 16)
- Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 20) - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 20)
= (c0 + Zero) = (c0 + Zero)
- Code(Zero) at (prev + 0, 21) to (start + 1, 6) - Code(Zero) at (prev + 0, 21) to (start + 2, 6)
- Code(Expression(1, Sub)) at (prev + 2, 1) to (start + 0, 2) - Code(Expression(1, Sub)) at (prev + 3, 1) to (start + 0, 2)
= ((c0 + Zero) - Zero) = ((c0 + Zero) - Zero)

1
tests/coverage/while.coverage
View file

@ -1,6 +1,7 @@
LL| 1|fn main() { LL| 1|fn main() {
LL| 1| let num = 9; LL| 1| let num = 9;
LL| 1| while num >= 10 { LL| 1| while num >= 10 {
LL| 0| // loop body
LL| 0| } LL| 0| }
LL| 1|} LL| 1|}

1
tests/coverage/while.rs
View file

@ -1,5 +1,6 @@
fn main() { fn main() {
let num = 9; let num = 9;
while num >= 10 { while num >= 10 {
// loop body
} }
} }

4
tests/coverage/while_early_ret.cov-map
View file

@ -1,5 +1,5 @@
Function name: while_early_ret::main Function name: while_early_ret::main
Raw bytes (61): 0x[01, 01, 06, 01, 05, 03, 09, 0e, 05, 03, 09, 17, 09, 0d, 11, 09, 01, 04, 01, 01, 1b, 03, 03, 09, 02, 0a, 0e, 05, 0d, 02, 0e, 0a, 06, 15, 02, 16, 0d, 04, 15, 00, 1b, 11, 04, 15, 00, 1b, 05, 03, 0a, 03, 0a, 09, 06, 05, 00, 0b, 13, 01, 01, 00, 02] Raw bytes (61): 0x[01, 01, 06, 01, 05, 03, 09, 0e, 05, 03, 09, 17, 09, 0d, 11, 09, 01, 05, 01, 01, 1b, 03, 03, 09, 02, 0a, 0e, 05, 0d, 02, 0e, 0a, 06, 15, 02, 16, 0d, 04, 15, 00, 1b, 11, 04, 15, 00, 1b, 05, 03, 0a, 03, 0a, 09, 06, 05, 00, 0b, 13, 01, 01, 00, 02]
Number of files: 1 Number of files: 1
- file 0 => global file 1 - file 0 => global file 1
Number of expressions: 6 Number of expressions: 6
@ -10,7 +10,7 @@ Number of expressions: 6
- expression 4 operands: lhs = Expression(5, Add), rhs = Counter(2) - expression 4 operands: lhs = Expression(5, Add), rhs = Counter(2)
- expression 5 operands: lhs = Counter(3), rhs = Counter(4) - expression 5 operands: lhs = Counter(3), rhs = Counter(4)
Number of file 0 mappings: 9 Number of file 0 mappings: 9
- Code(Counter(0)) at (prev + 4, 1) to (start + 1, 27) - Code(Counter(0)) at (prev + 5, 1) to (start + 1, 27)
- Code(Expression(0, Add)) at (prev + 3, 9) to (start + 2, 10) - Code(Expression(0, Add)) at (prev + 3, 9) to (start + 2, 10)
= (c0 + c1) = (c0 + c1)
- Code(Expression(3, Sub)) at (prev + 5, 13) to (start + 2, 14) - Code(Expression(3, Sub)) at (prev + 5, 13) to (start + 2, 14)

1
tests/coverage/while_early_ret.coverage
View file

@ -1,6 +1,7 @@
LL| |#![allow(unused_assignments)] LL| |#![allow(unused_assignments)]
LL| |// failure-status: 1 LL| |// failure-status: 1
LL| | LL| |
LL| |#[rustfmt::skip]
LL| 1|fn main() -> Result<(), u8> { LL| 1|fn main() -> Result<(), u8> {
LL| 1| let mut countdown = 10; LL| 1| let mut countdown = 10;
LL| | while LL| | while

1
tests/coverage/while_early_ret.rs
View file

@ -1,6 +1,7 @@
#![allow(unused_assignments)] #![allow(unused_assignments)]
// failure-status: 1 // failure-status: 1
#[rustfmt::skip]
fn main() -> Result<(), u8> { fn main() -> Result<(), u8> {
let mut countdown = 10; let mut countdown = 10;
while while