use std::iter;
use std::lazy::SyncOnceCell;
+use std::ops::Deref;
pub const NESTED_INDENT: &str = " ";
pub fn get_bcb_coverage_spans_with_counters(
&self,
bcb: BasicCoverageBlock,
- ) -> Option<&Vec<(CoverageSpan, CoverageKind)>> {
+ ) -> Option<&[(CoverageSpan, CoverageKind)]> {
if let Some(bcb_to_coverage_spans_with_counters) =
self.some_bcb_to_coverage_spans_with_counters.as_ref()
{
- bcb_to_coverage_spans_with_counters.get(&bcb)
+ bcb_to_coverage_spans_with_counters.get(&bcb).map(Deref::deref)
} else {
None
}
}
}
- pub fn get_bcb_dependency_counters(
- &self,
- bcb: BasicCoverageBlock,
- ) -> Option<&Vec<CoverageKind>> {
+ pub fn get_bcb_dependency_counters(&self, bcb: BasicCoverageBlock) -> Option<&[CoverageKind]> {
if let Some(bcb_to_dependency_counters) = self.some_bcb_to_dependency_counters.as_ref() {
- bcb_to_dependency_counters.get(&bcb)
+ bcb_to_dependency_counters.get(&bcb).map(Deref::deref)
} else {
None
}
/// associated with a coverage span).
pub fn validate(
&mut self,
- bcb_counters_without_direct_coverage_spans: &Vec<(
+ bcb_counters_without_direct_coverage_spans: &[(
Option<BasicCoverageBlock>,
BasicCoverageBlock,
CoverageKind,
- )>,
+ )],
) {
if self.is_enabled() {
let mut not_validated = bcb_counters_without_direct_coverage_spans
basic_coverage_blocks: &CoverageGraph,
pass_name: &str,
body_span: Span,
- coverage_spans: &Vec<CoverageSpan>,
+ coverage_spans: &[CoverageSpan],
) {
let mir_source = mir_body.source;
let def_id = mir_source.def_id();
tcx: TyCtxt<'tcx>,
mir_body: &mir::Body<'tcx>,
basic_coverage_blocks: &CoverageGraph,
- coverage_spans: &Vec<CoverageSpan>,
+ coverage_spans: &[CoverageSpan],
) -> Vec<SpanViewable> {
let mut span_viewables = Vec::new();
for coverage_span in coverage_spans {
basic_coverage_blocks: &CoverageGraph,
debug_counters: &DebugCounters,
graphviz_data: &GraphvizData,
- intermediate_expressions: &Vec<CoverageKind>,
+ intermediate_expressions: &[CoverageKind],
debug_used_expressions: &UsedExpressions,
) {
let mir_source = mir_body.source;
edge_labels.retain(|label| label != "unreachable");
let edge_counters = from_terminator
.successors()
- .map(|&successor_bb| graphviz_data.get_edge_counter(from_bcb, successor_bb));
+ .map(|successor_bb| graphviz_data.get_edge_counter(from_bcb, successor_bb));
iter::zip(&edge_labels, edge_counters)
.map(|(label, some_counter)| {
if let Some(counter) = some_counter {
mir_body: &mir::Body<'tcx>,
debug_counters: &DebugCounters,
bcb_data: &BasicCoverageBlockData,
- some_coverage_spans_with_counters: Option<&Vec<(CoverageSpan, CoverageKind)>>,
- some_dependency_counters: Option<&Vec<CoverageKind>>,
- some_intermediate_expressions: Option<&Vec<CoverageKind>>,
+ some_coverage_spans_with_counters: Option<&[(CoverageSpan, CoverageKind)]>,
+ some_dependency_counters: Option<&[CoverageKind]>,
+ some_intermediate_expressions: Option<&[CoverageKind]>,
) -> Vec<String> {
let len = bcb_data.basic_blocks.len();
let mut sections = Vec::new();