Struct rustc_mir_transform::coverage::spans::CoverageSpansGenerator
source · struct CoverageSpansGenerator<'a, 'tcx> {
mir_body: &'a Body<'tcx>,
fn_sig_span: Span,
body_span: Span,
basic_coverage_blocks: &'a CoverageGraph,
sorted_spans_iter: Option<IntoIter<CoverageSpan>>,
some_curr: Option<CoverageSpan>,
curr_original_span: Span,
some_prev: Option<CoverageSpan>,
prev_original_span: Span,
prev_expn_span: Option<Span>,
pending_dups: Vec<CoverageSpan>,
refined_spans: Vec<CoverageSpan>,
}
Expand description
Converts the initial set of CoverageSpan
s (one per MIR Statement
or Terminator
) into a
minimal set of CoverageSpan
s, using the BCB CFG to determine where it is safe and useful to:
- Remove duplicate source code coverage regions
- Merge spans that represent continuous (both in source code and control flow), non-branching execution
- Carve out (leave uncovered) any span that will be counted by another MIR (notably, closures)
Fields§
§mir_body: &'a Body<'tcx>
The MIR, used to look up BasicBlockData
.
fn_sig_span: Span
A Span
covering the signature of function for the MIR.
body_span: Span
A Span
covering the function body of the MIR (typically from left curly brace to right
curly brace).
basic_coverage_blocks: &'a CoverageGraph
The BasicCoverageBlock Control Flow Graph (BCB CFG).
sorted_spans_iter: Option<IntoIter<CoverageSpan>>
The initial set of CoverageSpan
s, sorted by Span
(lo
and hi
) and by relative
dominance between the BasicCoverageBlock
s of equal Span
s.
some_curr: Option<CoverageSpan>
The current CoverageSpan
to compare to its prev
, to possibly merge, discard, force the
discard of the prev
(and or pending_dups
), or keep both (with prev
moved to
pending_dups
). If curr
is not discarded or merged, it becomes prev
for the next
iteration.
curr_original_span: Span
The original span
for curr
, in case curr.span()
is modified. The curr_original_span
must not be mutated (except when advancing to the next curr
), even if curr.span()
is mutated.
some_prev: Option<CoverageSpan>
The CoverageSpan from a prior iteration; typically assigned from that iteration’s curr
.
If that curr
was discarded, prev
retains its value from the previous iteration.
prev_original_span: Span
Assigned from curr_original_span
from the previous iteration. The prev_original_span
must not be mutated (except when advancing to the next prev
), even if prev.span()
is mutated.
prev_expn_span: Option<Span>
A copy of the expn_span from the prior iteration.
pending_dups: Vec<CoverageSpan>
One or more CoverageSpan
s with the same Span
but different BasicCoverageBlock
s, and
no BasicCoverageBlock
in this list dominates another BasicCoverageBlock
in the list.
If a new curr
span also fits this criteria (compared to an existing list of
pending_dups
), that curr
CoverageSpan
moves to prev
before possibly being added to
the pending_dups
list, on the next iteration. As a result, if prev
and pending_dups
have the same Span
, the criteria for pending_dups
holds for prev
as well: a prev
with a matching Span
does not dominate any pending_dup
and no pending_dup
dominates a
prev
with a matching Span
)
refined_spans: Vec<CoverageSpan>
The final CoverageSpan
s to add to the coverage map. A Counter
or Expression
will also be injected into the MIR for each CoverageSpan
.
Implementations§
source§impl<'a, 'tcx> CoverageSpansGenerator<'a, 'tcx>
impl<'a, 'tcx> CoverageSpansGenerator<'a, 'tcx>
sourcepub(super) fn generate_coverage_spans(
mir_body: &'a Body<'tcx>,
fn_sig_span: Span,
body_span: Span,
basic_coverage_blocks: &'a CoverageGraph
) -> Vec<CoverageSpan>
pub(super) fn generate_coverage_spans( mir_body: &'a Body<'tcx>, fn_sig_span: Span, body_span: Span, basic_coverage_blocks: &'a CoverageGraph ) -> Vec<CoverageSpan>
Generate a minimal set of CoverageSpan
s, each representing a contiguous code region to be
counted.
The basic steps are:
-
Extract an initial set of spans from the
Statement
s andTerminator
s of eachBasicCoverageBlockData
. -
Sort the spans by span.lo() (starting position). Spans that start at the same position are sorted with longer spans before shorter spans; and equal spans are sorted (deterministically) based on “dominator” relationship (if any).
-
Traverse the spans in sorted order to identify spans that can be dropped (for instance, if another span or spans are already counting the same code region), or should be merged into a broader combined span (because it represents a contiguous, non-branching, and uninterrupted region of source code).
Closures are exposed in their enclosing functions as
Assign
Rvalue
s, and since closures have their own MIR, theirSpan
in their enclosing function should be left “uncovered”.
Note the resulting vector of CoverageSpan
s may not be fully sorted (and does not need
to be).
fn mir_to_initial_sorted_coverage_spans(&self) -> Vec<CoverageSpan>
sourcefn to_refined_spans(self) -> Vec<CoverageSpan>
fn to_refined_spans(self) -> Vec<CoverageSpan>
Iterate through the sorted CoverageSpan
s, and return the refined list of merged and
de-duplicated CoverageSpan
s.
fn push_refined_span(&mut self, covspan: CoverageSpan)
fn check_invoked_macro_name_span(&mut self)
fn bcb_to_initial_coverage_spans( &self, bcb: BasicCoverageBlock, bcb_data: &'a BasicCoverageBlockData ) -> Vec<CoverageSpan>
fn curr(&self) -> &CoverageSpan
fn curr_mut(&mut self) -> &mut CoverageSpan
fn prev(&self) -> &CoverageSpan
fn prev_mut(&mut self) -> &mut CoverageSpan
fn take_prev(&mut self) -> CoverageSpan
sourcefn check_pending_dups(&mut self)
fn check_pending_dups(&mut self)
If there are pending_dups
but prev
is not a matching dup (prev.span
doesn’t match the
pending_dups
spans), then one of the following two things happened during the previous
iteration:
- the previous
curr
span (which is nowprev
) was not a duplicate of the pending_dups (in which case there should be at least two spans inpending_dups
); or - the
span
ofprev
was modified bycurr_mut().merge_from(prev)
(in which casepending_dups
could have as few as one span) In either case, no more spans will match the span ofpending_dups
, so add thepending_dups
if they don’t overlapcurr
, and clear the list.
sourcefn next_coverage_span(&mut self) -> bool
fn next_coverage_span(&mut self) -> bool
Advance prev
to curr
(if any), and curr
to the next CoverageSpan
in sorted order.
sourcefn take_curr(&mut self) -> CoverageSpan
fn take_curr(&mut self) -> CoverageSpan
If called, then the next call to next_coverage_span()
will not update prev
with the
curr
coverage span.
sourcefn prev_starts_after_next(&self, next_curr: &CoverageSpan) -> bool
fn prev_starts_after_next(&self, next_curr: &CoverageSpan) -> bool
Returns true if the curr span should be skipped because prev has already advanced beyond the
end of curr. This can only happen if a prior iteration updated prev
to skip past a region
of code, such as skipping past a closure.
sourcefn prev_ends_before_curr(&self) -> bool
fn prev_ends_before_curr(&self) -> bool
Returns true if the curr span starts past the end of the prev span, which means they don’t overlap, so we now know the prev can be added to the refined coverage spans.
sourcefn carve_out_span_for_closure(&mut self)
fn carve_out_span_for_closure(&mut self)
If prev
s span extends left of the closure (curr
), carve out the closure’s span from
prev
’s span. (The closure’s coverage counters will be injected when processing the
closure’s own MIR.) Add the portion of the span to the left of the closure; and if the span
extends to the right of the closure, update prev
to that portion of the span. For any
pending_dups
, repeat the same process.
sourcefn hold_pending_dups_unless_dominated(&mut self)
fn hold_pending_dups_unless_dominated(&mut self)
Called if curr.span
equals prev_original_span
(and potentially equal to all
pending_dups
spans, if any). Keep in mind, prev.span()
may have been changed.
If prev.span() was merged into other spans (with matching BCB, for instance),
prev.span.hi()
will be greater than (further right of) prev_original_span.hi()
.
If prev.span() was split off to the right of a closure, prev.span().lo() will be
greater than prev_original_span.lo(). The actual span of prev_original_span
is
not as important as knowing that prev()
used to have the same span as curr()
,
which means their sort order is still meaningful for determining the dominator
relationship.
When two CoverageSpan
s have the same Span
, dominated spans can be discarded; but if
neither CoverageSpan
dominates the other, both (or possibly more than two) are held,
until their disposition is determined. In this latter case, the prev
dup is moved into
pending_dups
so the new curr
dup can be moved to prev
for the next iteration.
sourcefn cutoff_prev_at_overlapping_curr(&mut self)
fn cutoff_prev_at_overlapping_curr(&mut self)
curr
overlaps prev
. If prev
s span extends left of curr
s span, keep only
statements that end before curr.lo()
(if any), and add the portion of the
combined span for those statements. Any other statements have overlapping spans
that can be ignored because curr
and/or other upcoming statements/spans inside
the overlap area will produce their own counters. This disambiguation process
avoids injecting multiple counters for overlapping spans, and the potential for
double-counting.
fn span_bcb_dominates( &self, dom_covspan: &CoverageSpan, covspan: &CoverageSpan ) -> bool
Auto Trait Implementations§
impl<'a, 'tcx> !RefUnwindSafe for CoverageSpansGenerator<'a, 'tcx>
impl<'a, 'tcx> !Send for CoverageSpansGenerator<'a, 'tcx>
impl<'a, 'tcx> !Sync for CoverageSpansGenerator<'a, 'tcx>
impl<'a, 'tcx> Unpin for CoverageSpansGenerator<'a, 'tcx>
impl<'a, 'tcx> !UnwindSafe for CoverageSpansGenerator<'a, 'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 256 bytes