Skip to content

Commit 3cf5a6b

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of #115930 - Zalathar:spans-bug, r=compiler-errors
coverage: Fix an unstable-sort inconsistency in coverage spans This code was calling `sort_unstable_by`, but failed to impose a total order on the initial spans. That resulted in unpredictable handling of closure spans, producing inconsistencies in the coverage maps and in user-visible coverage reports. This PR fixes the problem by always sorting closure spans before otherwise-identical non-closure spans, and also switches to a stable sort in case the ordering is still not total. --- In addition to the fix itself, this PR also contains a cleanup to the comparison function that I was working on when I discovered the bug.
2 parents 970ee09 + 01b67f4 commit 3cf5a6b

File tree

10 files changed

+325
-50
lines changed

10 files changed

+325
-50
lines changed

‎compiler/rustc_data_structures/src/graph/dominators/mod.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ pub fn dominators<G: ControlFlowGraph>(graph: &G) -> Dominators<G::Node> {
5151
// Traverse the graph, collecting a number of things:
5252
//
5353
// * Preorder mapping (to it, and back to the actual ordering)
54-
// * Postorder mapping (used exclusively for rank_partial_cmp on the final product)
54+
// * Postorder mapping (used exclusively for `cmp_in_dominator_order` on the final product)
5555
// * Parents for each vertex in the preorder tree
5656
//
5757
// These are all done here rather than through one of the 'standard'
@@ -342,8 +342,8 @@ impl<Node: Idx> Dominators<Node> {
342342
/// relationship, the dominator will always precede the dominated. (The relative ordering
343343
/// of two unrelated nodes will also be consistent, but otherwise the order has no
344344
/// meaning.) This method cannot be used to determine if either Node dominates the other.
345-
pub fn rank_partial_cmp(&self, lhs: Node, rhs: Node) -> Option<Ordering> {
346-
self.post_order_rank[rhs].partial_cmp(&self.post_order_rank[lhs])
345+
pub fn cmp_in_dominator_order(&self, lhs: Node, rhs: Node) -> Ordering {
346+
self.post_order_rank[rhs].cmp(&self.post_order_rank[lhs])
347347
}
348348

349349
/// Returns true if `a` dominates `b`.

‎compiler/rustc_mir_transform/src/coverage/graph.rs

+2-6
Original file line numberDiff line numberDiff line change
@@ -199,12 +199,8 @@ impl CoverageGraph {
199199
}
200200

201201
#[inline(always)]
202-
pub fn rank_partial_cmp(
203-
&self,
204-
a: BasicCoverageBlock,
205-
b: BasicCoverageBlock,
206-
) -> Option<Ordering> {
207-
self.dominators.as_ref().unwrap().rank_partial_cmp(a, b)
202+
pub fn cmp_in_dominator_order(&self, a: BasicCoverageBlock, b: BasicCoverageBlock) -> Ordering {
203+
self.dominators.as_ref().unwrap().cmp_in_dominator_order(a, b)
208204
}
209205
}
210206

‎compiler/rustc_mir_transform/src/coverage/spans.rs

+15-25
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@ use rustc_span::source_map::original_sp;
1212
use rustc_span::{BytePos, ExpnKind, MacroKind, Span, Symbol};
1313

1414
use std::cell::OnceCell;
15-
use std::cmp::Ordering;
1615

1716
#[derive(Debug, Copy, Clone)]
1817
pub(super) enum CoverageStatement {
@@ -333,30 +332,21 @@ impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
333332

334333
initial_spans.push(CoverageSpan::for_fn_sig(self.fn_sig_span));
335334

336-
initial_spans.sort_unstable_by(|a, b| {
337-
if a.span.lo() == b.span.lo() {
338-
if a.span.hi() == b.span.hi() {
339-
if a.is_in_same_bcb(b) {
340-
Some(Ordering::Equal)
341-
} else {
342-
// Sort equal spans by dominator relationship (so dominators always come
343-
// before the dominated equal spans). When later comparing two spans in
344-
// order, the first will either dominate the second, or they will have no
345-
// dominator relationship.
346-
self.basic_coverage_blocks.rank_partial_cmp(a.bcb, b.bcb)
347-
}
348-
} else {
349-
// Sort hi() in reverse order so shorter spans are attempted after longer spans.
350-
// This guarantees that, if a `prev` span overlaps, and is not equal to, a
351-
// `curr` span, the prev span either extends further left of the curr span, or
352-
// they start at the same position and the prev span extends further right of
353-
// the end of the curr span.
354-
b.span.hi().partial_cmp(&a.span.hi())
355-
}
356-
} else {
357-
a.span.lo().partial_cmp(&b.span.lo())
358-
}
359-
.unwrap()
335+
initial_spans.sort_by(|a, b| {
336+
// First sort by span start.
337+
Ord::cmp(&a.span.lo(), &b.span.lo())
338+
// If span starts are the same, sort by span end in reverse order.
339+
// This ensures that if spans A and B are adjacent in the list,
340+
// and they overlap but are not equal, then either:
341+
// - Span A extends further left, or
342+
// - Both have the same start and span A extends further right
343+
.then_with(|| Ord::cmp(&a.span.hi(), &b.span.hi()).reverse())
344+
// If both spans are equal, sort the BCBs in dominator order,
345+
// so that dominating BCBs come before other BCBs they dominate.
346+
.then_with(|| self.basic_coverage_blocks.cmp_in_dominator_order(a.bcb, b.bcb))
347+
// If two spans are otherwise identical, put closure spans first,
348+
// as this seems to be what the refinement step expects.
349+
.then_with(|| Ord::cmp(&a.is_closure, &b.is_closure).reverse())
360350
});
361351

362352
initial_spans

‎tests/coverage-map/status-quo/closure.cov-map

+7-7
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
Function name: closure::main
2-
Raw bytes (170): 0x[01, 01, 17, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 05, 05, 5a, 01, 05, 18, 01, 08, 01, 0f, 0d, 03, 16, 0e, 06, 0a, 07, 10, 05, 13, 0d, 0b, 1a, 0e, 08, 09, 0f, 10, 05, 0e, 09, 13, 16, 05, 0d, 18, 17, 19, 09, 01, 21, 1b, 04, 09, 00, 29, 1f, 01, 09, 00, 2d, 23, 01, 09, 00, 24, 27, 05, 09, 00, 24, 2b, 02, 09, 00, 21, 2f, 04, 09, 00, 21, 33, 04, 09, 00, 28, 37, 09, 09, 00, 32, 3b, 04, 09, 00, 33, 3f, 07, 09, 00, 4b, 43, 08, 09, 01, 09, 47, 0a, 09, 01, 09, 4b, 08, 09, 01, 09, 4f, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 5a, 04, 06, 00, 07, 57, 01, 05, 03, 02]
2+
Raw bytes (170): 0x[01, 01, 17, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 00, 01, 05, 05, 5a, 01, 05, 18, 01, 08, 01, 0f, 0d, 03, 16, 0e, 06, 0a, 07, 10, 05, 13, 0d, 0b, 1a, 0e, 06, 0a, 0f, 10, 05, 0c, 16, 13, 16, 05, 0d, 18, 17, 19, 09, 01, 1e, 1b, 04, 09, 00, 29, 1f, 01, 09, 00, 2d, 23, 01, 09, 00, 24, 27, 05, 09, 00, 24, 2b, 02, 09, 00, 21, 2f, 04, 09, 00, 21, 33, 04, 09, 00, 28, 37, 09, 09, 00, 32, 3b, 04, 09, 00, 33, 3f, 07, 09, 00, 4b, 43, 08, 09, 00, 48, 47, 0a, 09, 00, 47, 4b, 08, 09, 00, 44, 4f, 0a, 08, 00, 10, 05, 00, 11, 04, 06, 5a, 04, 06, 00, 07, 57, 01, 05, 03, 02]
33
Number of files: 1
44
- file 0 => global file 1
55
Number of expressions: 23
@@ -32,13 +32,13 @@ Number of file 0 mappings: 24
3232
= (c0 + Zero)
3333
- Code(Expression(1, Add)) at (prev + 16, 5) to (start + 19, 13)
3434
= (c0 + Zero)
35-
- Code(Expression(2, Add)) at (prev + 26, 14) to (start + 8, 9)
35+
- Code(Expression(2, Add)) at (prev + 26, 14) to (start + 6, 10)
3636
= (c0 + Zero)
37-
- Code(Expression(3, Add)) at (prev + 16, 5) to (start + 14, 9)
37+
- Code(Expression(3, Add)) at (prev + 16, 5) to (start + 12, 22)
3838
= (c0 + Zero)
3939
- Code(Expression(4, Add)) at (prev + 22, 5) to (start + 13, 24)
4040
= (c0 + Zero)
41-
- Code(Expression(5, Add)) at (prev + 25, 9) to (start + 1, 33)
41+
- Code(Expression(5, Add)) at (prev + 25, 9) to (start + 1, 30)
4242
= (c0 + Zero)
4343
- Code(Expression(6, Add)) at (prev + 4, 9) to (start + 0, 41)
4444
= (c0 + Zero)
@@ -60,11 +60,11 @@ Number of file 0 mappings: 24
6060
= (c0 + Zero)
6161
- Code(Expression(15, Add)) at (prev + 7, 9) to (start + 0, 75)
6262
= (c0 + Zero)
63-
- Code(Expression(16, Add)) at (prev + 8, 9) to (start + 1, 9)
63+
- Code(Expression(16, Add)) at (prev + 8, 9) to (start + 0, 72)
6464
= (c0 + Zero)
65-
- Code(Expression(17, Add)) at (prev + 10, 9) to (start + 1, 9)
65+
- Code(Expression(17, Add)) at (prev + 10, 9) to (start + 0, 71)
6666
= (c0 + Zero)
67-
- Code(Expression(18, Add)) at (prev + 8, 9) to (start + 1, 9)
67+
- Code(Expression(18, Add)) at (prev + 8, 9) to (start + 0, 68)
6868
= (c0 + Zero)
6969
- Code(Expression(19, Add)) at (prev + 10, 8) to (start + 0, 16)
7070
= (c0 + Zero)

‎tests/coverage-map/status-quo/closure_bug.cov-map

+148
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,148 @@
1+
Function name: closure_bug::main
2+
Raw bytes (241): 0x[01, 01, 34, 01, 00, 01, 05, 05, ce, 01, 01, 05, cb, 01, 00, 05, ce, 01, 01, 05, cb, 01, 09, 05, ce, 01, 01, 05, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, c3, 01, 00, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, bb, 01, 00, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, bb, 01, 11, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 11, b6, 01, bb, 01, 11, 0d, be, 01, c3, 01, 0d, 09, c6, 01, cb, 01, 09, 05, ce, 01, 01, 05, 11, 01, 06, 01, 03, 0a, 03, 09, 05, 01, 0e, 05, 01, 0f, 00, 17, ce, 01, 00, 17, 00, 18, cb, 01, 02, 09, 00, 0a, 13, 06, 05, 01, 0e, 09, 01, 0f, 00, 17, c6, 01, 00, 17, 00, 18, c3, 01, 02, 09, 00, 0a, 3b, 06, 05, 01, 0e, 0d, 01, 0f, 00, 17, be, 01, 00, 17, 00, 18, bb, 01, 02, 09, 00, 0a, 7b, 06, 05, 01, 0e, 11, 01, 0f, 00, 17, b6, 01, 00, 17, 00, 18, b3, 01, 01, 01, 00, 02]
3+
Number of files: 1
4+
- file 0 => global file 1
5+
Number of expressions: 52
6+
- expression 0 operands: lhs = Counter(0), rhs = Zero
7+
- expression 1 operands: lhs = Counter(0), rhs = Counter(1)
8+
- expression 2 operands: lhs = Counter(1), rhs = Expression(51, Sub)
9+
- expression 3 operands: lhs = Counter(0), rhs = Counter(1)
10+
- expression 4 operands: lhs = Expression(50, Add), rhs = Zero
11+
- expression 5 operands: lhs = Counter(1), rhs = Expression(51, Sub)
12+
- expression 6 operands: lhs = Counter(0), rhs = Counter(1)
13+
- expression 7 operands: lhs = Expression(50, Add), rhs = Counter(2)
14+
- expression 8 operands: lhs = Counter(1), rhs = Expression(51, Sub)
15+
- expression 9 operands: lhs = Counter(0), rhs = Counter(1)
16+
- expression 10 operands: lhs = Counter(2), rhs = Expression(49, Sub)
17+
- expression 11 operands: lhs = Expression(50, Add), rhs = Counter(2)
18+
- expression 12 operands: lhs = Counter(1), rhs = Expression(51, Sub)
19+
- expression 13 operands: lhs = Counter(0), rhs = Counter(1)
20+
- expression 14 operands: lhs = Expression(48, Add), rhs = Zero
21+
- expression 15 operands: lhs = Counter(2), rhs = Expression(49, Sub)
22+
- expression 16 operands: lhs = Expression(50, Add), rhs = Counter(2)
23+
- expression 17 operands: lhs = Counter(1), rhs = Expression(51, Sub)
24+
- expression 18 operands: lhs = Counter(0), rhs = Counter(1)
25+
- expression 19 operands: lhs = Expression(48, Add), rhs = Counter(3)
26+
- expression 20 operands: lhs = Counter(2), rhs = Expression(49, Sub)
27+
- expression 21 operands: lhs = Expression(50, Add), rhs = Counter(2)
28+
- expression 22 operands: lhs = Counter(1), rhs = Expression(51, Sub)
29+
- expression 23 operands: lhs = Counter(0), rhs = Counter(1)
30+
- expression 24 operands: lhs = Counter(3), rhs = Expression(47, Sub)
31+
- expression 25 operands: lhs = Expression(48, Add), rhs = Counter(3)
32+
- expression 26 operands: lhs = Counter(2), rhs = Expression(49, Sub)
33+
- expression 27 operands: lhs = Expression(50, Add), rhs = Counter(2)
34+
- expression 28 operands: lhs = Counter(1), rhs = Expression(51, Sub)
35+
- expression 29 operands: lhs = Counter(0), rhs = Counter(1)
36+
- expression 30 operands: lhs = Expression(46, Add), rhs = Zero
37+
- expression 31 operands: lhs = Counter(3), rhs = Expression(47, Sub)
38+
- expression 32 operands: lhs = Expression(48, Add), rhs = Counter(3)
39+
- expression 33 operands: lhs = Counter(2), rhs = Expression(49, Sub)
40+
- expression 34 operands: lhs = Expression(50, Add), rhs = Counter(2)
41+
- expression 35 operands: lhs = Counter(1), rhs = Expression(51, Sub)
42+
- expression 36 operands: lhs = Counter(0), rhs = Counter(1)
43+
- expression 37 operands: lhs = Expression(46, Add), rhs = Counter(4)
44+
- expression 38 operands: lhs = Counter(3), rhs = Expression(47, Sub)
45+
- expression 39 operands: lhs = Expression(48, Add), rhs = Counter(3)
46+
- expression 40 operands: lhs = Counter(2), rhs = Expression(49, Sub)
47+
- expression 41 operands: lhs = Expression(50, Add), rhs = Counter(2)
48+
- expression 42 operands: lhs = Counter(1), rhs = Expression(51, Sub)
49+
- expression 43 operands: lhs = Counter(0), rhs = Counter(1)
50+
- expression 44 operands: lhs = Counter(4), rhs = Expression(45, Sub)
51+
- expression 45 operands: lhs = Expression(46, Add), rhs = Counter(4)
52+
- expression 46 operands: lhs = Counter(3), rhs = Expression(47, Sub)
53+
- expression 47 operands: lhs = Expression(48, Add), rhs = Counter(3)
54+
- expression 48 operands: lhs = Counter(2), rhs = Expression(49, Sub)
55+
- expression 49 operands: lhs = Expression(50, Add), rhs = Counter(2)
56+
- expression 50 operands: lhs = Counter(1), rhs = Expression(51, Sub)
57+
- expression 51 operands: lhs = Counter(0), rhs = Counter(1)
58+
Number of file 0 mappings: 17
59+
- Code(Counter(0)) at (prev + 6, 1) to (start + 3, 10)
60+
- Code(Expression(0, Add)) at (prev + 9, 5) to (start + 1, 14)
61+
= (c0 + Zero)
62+
- Code(Counter(1)) at (prev + 1, 15) to (start + 0, 23)
63+
- Code(Expression(51, Sub)) at (prev + 0, 23) to (start + 0, 24)
64+
= (c0 - c1)
65+
- Code(Expression(50, Add)) at (prev + 2, 9) to (start + 0, 10)
66+
= (c1 + (c0 - c1))
67+
- Code(Expression(4, Add)) at (prev + 6, 5) to (start + 1, 14)
68+
= ((c1 + (c0 - c1)) + Zero)
69+
- Code(Counter(2)) at (prev + 1, 15) to (start + 0, 23)
70+
- Code(Expression(49, Sub)) at (prev + 0, 23) to (start + 0, 24)
71+
= ((c1 + (c0 - c1)) - c2)
72+
- Code(Expression(48, Add)) at (prev + 2, 9) to (start + 0, 10)
73+
= (c2 + ((c1 + (c0 - c1)) - c2))
74+
- Code(Expression(14, Add)) at (prev + 6, 5) to (start + 1, 14)
75+
= ((c2 + ((c1 + (c0 - c1)) - c2)) + Zero)
76+
- Code(Counter(3)) at (prev + 1, 15) to (start + 0, 23)
77+
- Code(Expression(47, Sub)) at (prev + 0, 23) to (start + 0, 24)
78+
= ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)
79+
- Code(Expression(46, Add)) at (prev + 2, 9) to (start + 0, 10)
80+
= (c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3))
81+
- Code(Expression(30, Add)) at (prev + 6, 5) to (start + 1, 14)
82+
= ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) + Zero)
83+
- Code(Counter(4)) at (prev + 1, 15) to (start + 0, 23)
84+
- Code(Expression(45, Sub)) at (prev + 0, 23) to (start + 0, 24)
85+
= ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4)
86+
- Code(Expression(44, Add)) at (prev + 1, 1) to (start + 0, 2)
87+
= (c4 + ((c3 + ((c2 + ((c1 + (c0 - c1)) - c2)) - c3)) - c4))
88+
89+
Function name: closure_bug::main::{closure#0}
90+
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]
91+
Number of files: 1
92+
- file 0 => global file 1
93+
Number of expressions: 2
94+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
95+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
96+
Number of file 0 mappings: 4
97+
- Code(Counter(0)) at (prev + 13, 9) to (start + 0, 18)
98+
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
99+
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
100+
= (c0 - c1)
101+
- Code(Expression(1, Add)) at (prev + 0, 41) to (start + 0, 42)
102+
= (c1 + (c0 - c1))
103+
104+
Function name: closure_bug::main::{closure#1}
105+
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]
106+
Number of files: 1
107+
- file 0 => global file 1
108+
Number of expressions: 2
109+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
110+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
111+
Number of file 0 mappings: 4
112+
- Code(Counter(0)) at (prev + 22, 9) to (start + 0, 18)
113+
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
114+
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
115+
= (c0 - c1)
116+
- Code(Expression(1, Add)) at (prev + 0, 41) to (start + 0, 42)
117+
= (c1 + (c0 - c1))
118+
119+
Function name: closure_bug::main::{closure#2}
120+
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]
121+
Number of files: 1
122+
- file 0 => global file 1
123+
Number of expressions: 2
124+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
125+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
126+
Number of file 0 mappings: 4
127+
- Code(Counter(0)) at (prev + 31, 9) to (start + 0, 18)
128+
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
129+
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
130+
= (c0 - c1)
131+
- Code(Expression(1, Add)) at (prev + 0, 41) to (start + 0, 42)
132+
= (c1 + (c0 - c1))
133+
134+
Function name: closure_bug::main::{closure#3}
135+
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]
136+
Number of files: 1
137+
- file 0 => global file 1
138+
Number of expressions: 2
139+
- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
140+
- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
141+
Number of file 0 mappings: 4
142+
- Code(Counter(0)) at (prev + 40, 9) to (start + 0, 18)
143+
- Code(Counter(1)) at (prev + 0, 21) to (start + 0, 25)
144+
- Code(Expression(0, Sub)) at (prev + 0, 35) to (start + 0, 40)
145+
= (c0 - c1)
146+
- Code(Expression(1, Add)) at (prev + 0, 41) to (start + 0, 42)
147+
= (c1 + (c0 - c1))
148+

‎tests/coverage-map/status-quo/closure_bug.rs

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
// Regression test for #115930.
2+
// All of these closures are identical, and should produce identical output in
3+
// the coverage report. However, an unstable sort was causing them to be treated
4+
// inconsistently when preparing coverage spans.
5+
6+
fn main() {
7+
let truthy = std::env::args().len() == 1;
8+
9+
let a
10+
=
11+
|
12+
|
13+
if truthy { true } else { false };
14+
15+
a();
16+
if truthy { a(); }
17+
18+
let b
19+
=
20+
|
21+
|
22+
if truthy { true } else { false };
23+
24+
b();
25+
if truthy { b(); }
26+
27+
let c
28+
=
29+
|
30+
|
31+
if truthy { true } else { false };
32+
33+
c();
34+
if truthy { c(); }
35+
36+
let d
37+
=
38+
|
39+
|
40+
if truthy { true } else { false };
41+
42+
d();
43+
if truthy { d(); }
44+
}

‎tests/coverage-map/status-quo/generator.cov-map

+2-2
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ Number of file 0 mappings: 4
1414
= (c1 + (c0 - c1))
1515

1616
Function name: generator::main
17-
Raw bytes (71): 0x[01, 01, 0b, 01, 00, 05, 0b, 09, 0d, 11, 00, 11, 15, 2a, 19, 11, 15, 15, 19, 26, 00, 2a, 19, 11, 15, 09, 01, 0f, 01, 02, 19, 03, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 07, 01, 0e, 00, 35, 0f, 02, 0b, 00, 2e, 2a, 01, 22, 00, 27, 26, 00, 2c, 00, 2e, 1f, 01, 0e, 00, 35, 23, 02, 01, 00, 02]
17+
Raw bytes (71): 0x[01, 01, 0b, 01, 00, 05, 0b, 09, 0d, 11, 00, 11, 15, 2a, 19, 11, 15, 15, 19, 26, 00, 2a, 19, 11, 15, 09, 01, 0f, 01, 02, 16, 03, 07, 0b, 00, 2e, 11, 01, 2b, 00, 2d, 07, 01, 0e, 00, 35, 0f, 02, 0b, 00, 2e, 2a, 01, 22, 00, 27, 26, 00, 2c, 00, 2e, 1f, 01, 0e, 00, 35, 23, 02, 01, 00, 02]
1818
Number of files: 1
1919
- file 0 => global file 1
2020
Number of expressions: 11
@@ -30,7 +30,7 @@ Number of expressions: 11
3030
- expression 9 operands: lhs = Expression(10, Sub), rhs = Counter(6)
3131
- expression 10 operands: lhs = Counter(4), rhs = Counter(5)
3232
Number of file 0 mappings: 9
33-
- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 25)
33+
- Code(Counter(0)) at (prev + 15, 1) to (start + 2, 22)
3434
- Code(Expression(0, Add)) at (prev + 7, 11) to (start + 0, 46)
3535
= (c0 + Zero)
3636
- Code(Counter(4)) at (prev + 1, 43) to (start + 0, 45)

‎tests/run-coverage/closure.coverage

+7-7
Original file line numberDiff line numberDiff line change
@@ -76,8 +76,8 @@
7676
LL| 1| some_string = None;
7777
LL| 1| let
7878
LL| 1| a
79-
LL| 1| =
80-
LL| 1| ||
79+
LL| | =
80+
LL| | ||
8181
LL| 1| {
8282
LL| 1| let mut countdown = 0;
8383
LL| 1| if is_false {
@@ -98,8 +98,8 @@
9898
LL| 1|
9999
LL| 1| let
100100
LL| 1| quote_closure
101-
LL| 1| =
102-
LL| 1| |val|
101+
LL| | =
102+
LL| | |val|
103103
LL| 5| {
104104
LL| 5| let mut countdown = 0;
105105
LL| 5| if is_false {
@@ -186,7 +186,7 @@
186186
LL| | ;
187187
LL| |
188188
LL| 1| let short_used_not_covered_closure_line_break_block_embedded_branch =
189-
LL| 1| | _unused_arg: u8 |
189+
LL| | | _unused_arg: u8 |
190190
LL| 0| {
191191
LL| 0| println!(
192192
LL| 0| "not called: {}",
@@ -196,7 +196,7 @@
196196
LL| | ;
197197
LL| |
198198
LL| 1| let short_used_covered_closure_line_break_no_block_embedded_branch =
199-
LL| 1| | _unused_arg: u8 |
199+
LL| | | _unused_arg: u8 |
200200
LL| 1| println!(
201201
LL| 1| "not called: {}",
202202
LL| 1| if is_true { "check" } else { "me" }
@@ -205,7 +205,7 @@
205205
LL| | ;
206206
LL| |
207207
LL| 1| let short_used_covered_closure_line_break_block_embedded_branch =
208-
LL| 1| | _unused_arg: u8 |
208+
LL| | | _unused_arg: u8 |
209209
LL| 1| {
210210
LL| 1| println!(
211211
LL| 1| "not called: {}",

0 commit comments

Comments
 (0)