rust/tests/coverage/inline-dead.rs

// Regression test for issue #98833.
//@ compile-flags: -Zinline-mir -Cdebug-assertions=off

fn main() {
    println!("{}", live::<false>());

    let f = |x: bool| {
        debug_assert!(x);
    };
    f(false);
}

#[inline]
fn live<const B: bool>() -> u32 {
    if B {
        dead()
    } else {
        0
    }
}

#[inline]
fn dead() -> u32 {
    42
}
Fix unreachable coverage generation for inlined functions To generate a function coverage we need at least one coverage counter, so a coverage from unreachable blocks is retained only when some live counters remain. The previous implementation incorrectly retained unreachable coverage, because it didn't account for the fact that those live counters can belong to another function due to inlining. 2022-07-03 00:00:00 +00:00			`// Regression test for issue #98833.`
Remove reachable coverage without counters Remove reachable coverage without counters to maintain invariant that either there is no coverage at all or there is a live coverage counter left that provides the function source hash. The motivating example would be a following closure: ```rust let f = \|x: bool\| { debug_assert!(x); }; ``` Which, with span changes from #93967, with disabled debug assertions, after the final CFG simplifications but before removal of dead blocks, gives rise to MIR: ```rust fn main::{closure#0}(_1: &[closure@a.rs:2:13: 2:22], _2: bool) -> () { debug x => _2; let mut _0: (); bb0: { Coverage::Expression(4294967295) = 1 - 2; return; } ... } ``` 2022-07-25 00:00:00 +00:00			`//@ compile-flags: -Zinline-mir -Cdebug-assertions=off`
Fix unreachable coverage generation for inlined functions To generate a function coverage we need at least one coverage counter, so a coverage from unreachable blocks is retained only when some live counters remain. The previous implementation incorrectly retained unreachable coverage, because it didn't account for the fact that those live counters can belong to another function due to inlining. 2022-07-03 00:00:00 +00:00
			`fn main() {`
			`println!("{}", live::<false>());`
Remove reachable coverage without counters Remove reachable coverage without counters to maintain invariant that either there is no coverage at all or there is a live coverage counter left that provides the function source hash. The motivating example would be a following closure: ```rust let f = \|x: bool\| { debug_assert!(x); }; ``` Which, with span changes from #93967, with disabled debug assertions, after the final CFG simplifications but before removal of dead blocks, gives rise to MIR: ```rust fn main::{closure#0}(_1: &[closure@a.rs:2:13: 2:22], _2: bool) -> () { debug x => _2; let mut _0: (); bb0: { Coverage::Expression(4294967295) = 1 - 2; return; } ... } ``` 2022-07-25 00:00:00 +00:00
			`let f = \|x: bool\| {`
coverage: Format all remaining tests These tests can simply be reformatted as normal, because the resulting changes are unimportant. 2024-01-16 02:52:08 +00:00			`debug_assert!(x);`
Remove reachable coverage without counters Remove reachable coverage without counters to maintain invariant that either there is no coverage at all or there is a live coverage counter left that provides the function source hash. The motivating example would be a following closure: ```rust let f = \|x: bool\| { debug_assert!(x); }; ``` Which, with span changes from #93967, with disabled debug assertions, after the final CFG simplifications but before removal of dead blocks, gives rise to MIR: ```rust fn main::{closure#0}(_1: &[closure@a.rs:2:13: 2:22], _2: bool) -> () { debug x => _2; let mut _0: (); bb0: { Coverage::Expression(4294967295) = 1 - 2; return; } ... } ``` 2022-07-25 00:00:00 +00:00			`};`
			`f(false);`
Fix unreachable coverage generation for inlined functions To generate a function coverage we need at least one coverage counter, so a coverage from unreachable blocks is retained only when some live counters remain. The previous implementation incorrectly retained unreachable coverage, because it didn't account for the fact that those live counters can belong to another function due to inlining. 2022-07-03 00:00:00 +00:00			`}`

			`#[inline]`
			`fn live<const B: bool>() -> u32 {`
			`if B {`
			`dead()`
			`} else {`
			`0`
			`}`
			`}`

			`#[inline]`
			`fn dead() -> u32 {`
			`42`
			`}`