Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 3cf5a6b

Browse files
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‎

Lines changed: 3 additions & 3 deletions
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‎

Lines changed: 2 additions & 6 deletions
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‎

Lines changed: 15 additions & 25 deletions
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‎

Lines changed: 7 additions & 7 deletions
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)
Lines changed: 148 additions & 0 deletions
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+
Lines changed: 44 additions & 0 deletions
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‎

Lines changed: 2 additions & 2 deletions
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‎

Lines changed: 7 additions & 7 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /