From 2694b84fbf2c49e1cb7583abf6f62db4a972b614 Mon Sep 17 00:00:00 2001
From: Ziru Niu <zirconium.n@gmail.com>
Date: Tue, 5 Sep 2023 06:58:01 +0800
Subject: [PATCH 1/9] remove unneeded `ToPredicate` impls
---
compiler/rustc_middle/src/ty/mod.rs | 32 -----------------------------
1 file changed, 32 deletions(-)
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index eb8ea0bc11470..d9bd9ad5543d0 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1253,14 +1253,6 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for TraitRef<'tcx> {
}
}
-impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for TraitPredicate<'tcx> {
- #[inline(always)]
- fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx> {
- let p: Predicate<'tcx> = self.to_predicate(tcx);
- p.expect_clause()
- }
-}
-
impl<'tcx> ToPredicate<'tcx> for Binder<'tcx, TraitRef<'tcx>> {
#[inline(always)]
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
@@ -1287,18 +1279,6 @@ impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for Binder<'tcx, TraitRef
}
}
-impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for TraitRef<'tcx> {
- fn to_predicate(self, tcx: TyCtxt<'tcx>) -> PolyTraitPredicate<'tcx> {
- ty::Binder::dummy(self).to_predicate(tcx)
- }
-}
-
-impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for TraitPredicate<'tcx> {
- fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> PolyTraitPredicate<'tcx> {
- ty::Binder::dummy(self)
- }
-}
-
impl<'tcx> ToPredicate<'tcx> for PolyTraitPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
self.map_bound(|p| PredicateKind::Clause(ClauseKind::Trait(p))).to_predicate(tcx)
@@ -1312,12 +1292,6 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyTraitPredicate<'tcx> {
}
}
-impl<'tcx> ToPredicate<'tcx> for OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>> {
- fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- ty::Binder::dummy(PredicateKind::Clause(ClauseKind::RegionOutlives(self))).to_predicate(tcx)
- }
-}
-
impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
self.map_bound(|p| PredicateKind::Clause(ClauseKind::RegionOutlives(p))).to_predicate(tcx)
@@ -1330,12 +1304,6 @@ impl<'tcx> ToPredicate<'tcx> for OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>> {
}
}
-impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
- fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- self.map_bound(|p| PredicateKind::Clause(ClauseKind::TypeOutlives(p))).to_predicate(tcx)
- }
-}
-
impl<'tcx> ToPredicate<'tcx> for ProjectionPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
ty::Binder::dummy(PredicateKind::Clause(ClauseKind::Projection(self))).to_predicate(tcx)
From 3c69a107d0149a27c11490a0d67717c555eb1288 Mon Sep 17 00:00:00 2001
From: Ziru Niu <zirconium.n@gmail.com>
Date: Tue, 5 Sep 2023 07:21:38 +0800
Subject: [PATCH 2/9] remove `impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for
PolyProjectionPredicate<'tcx>`
---
.../src/check/compare_impl_item.rs | 10 +++++-----
compiler/rustc_middle/src/ty/mod.rs | 12 +++++-------
compiler/rustc_middle/src/ty/sty.rs | 2 +-
.../src/solve/project_goals.rs | 10 ++++++----
.../rustc_trait_selection/src/traits/project.rs | 2 +-
compiler/rustc_ty_utils/src/ty.rs | 13 +++++--------
6 files changed, 23 insertions(+), 26 deletions(-)
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index 92cc9759304fc..38f19aa09adf4 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -18,7 +18,7 @@ use rustc_middle::ty::util::ExplicitSelf;
use rustc_middle::ty::{
self, GenericArgs, Ty, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
};
-use rustc_middle::ty::{GenericParamDefKind, ToPredicate, TyCtxt};
+use rustc_middle::ty::{GenericParamDefKind, TyCtxt};
use rustc_span::{Span, DUMMY_SP};
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt;
use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
@@ -2196,16 +2196,16 @@ pub(super) fn check_type_bounds<'tcx>(
//
// impl<T> X for T where T: X { type Y = <T as X>::Y; }
}
- _ => predicates.push(
+ _ => predicates.push(ty::Clause::from_projection_clause(
+ tcx,
ty::Binder::bind_with_vars(
ty::ProjectionPredicate {
projection_ty: tcx.mk_alias_ty(trait_ty.def_id, rebased_args),
term: normalize_impl_ty.into(),
},
bound_vars,
- )
- .to_predicate(tcx),
- ),
+ ),
+ )),
};
ty::ParamEnv::new(tcx.mk_clauses(&predicates), Reveal::UserFacing)
};
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index d9bd9ad5543d0..0db48f2f7ecdd 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -566,6 +566,11 @@ impl rustc_errors::IntoDiagnosticArg for Clause<'_> {
pub struct Clause<'tcx>(Interned<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>);
impl<'tcx> Clause<'tcx> {
+ pub fn from_projection_clause(tcx: TyCtxt<'tcx>, pred: PolyProjectionPredicate<'tcx>) -> Self {
+ let pred: Predicate<'tcx> = pred.to_predicate(tcx);
+ pred.expect_clause()
+ }
+
pub fn as_predicate(self) -> Predicate<'tcx> {
Predicate(self.0)
}
@@ -1323,13 +1328,6 @@ impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for ProjectionPredicate<'tcx> {
}
}
-impl<'tcx> ToPredicate<'tcx, Clause<'tcx>> for PolyProjectionPredicate<'tcx> {
- fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Clause<'tcx> {
- let p: Predicate<'tcx> = self.to_predicate(tcx);
- p.expect_clause()
- }
-}
-
impl<'tcx> ToPredicate<'tcx> for TraitPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
PredicateKind::Clause(ClauseKind::Trait(self)).to_predicate(tcx)
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index a14d09bbb7006..e3e014a3b2a81 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -725,7 +725,7 @@ impl<'tcx> PolyExistentialPredicate<'tcx> {
self.rebind(tr).with_self_ty(tcx, self_ty).to_predicate(tcx)
}
ExistentialPredicate::Projection(p) => {
- self.rebind(p.with_self_ty(tcx, self_ty)).to_predicate(tcx)
+ ty::Clause::from_projection_clause(tcx, self.rebind(p.with_self_ty(tcx, self_ty)))
}
ExistentialPredicate::AutoTrait(did) => {
let generics = tcx.generics_of(did);
diff --git a/compiler/rustc_trait_selection/src/solve/project_goals.rs b/compiler/rustc_trait_selection/src/solve/project_goals.rs
index 3fe914e50be11..f6e781b87ba7f 100644
--- a/compiler/rustc_trait_selection/src/solve/project_goals.rs
+++ b/compiler/rustc_trait_selection/src/solve/project_goals.rs
@@ -346,13 +346,15 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
ty::TraitRef::from_lang_item(tcx, LangItem::Sized, DUMMY_SP, [output])
});
- let pred = tupled_inputs_and_output
- .map_bound(|(inputs, output)| ty::ProjectionPredicate {
+ let pred = ty::Clause::from_projection_clause(
+ tcx,
+ tupled_inputs_and_output.map_bound(|(inputs, output)| ty::ProjectionPredicate {
projection_ty: tcx
.mk_alias_ty(goal.predicate.def_id(), [goal.predicate.self_ty(), inputs]),
term: output.into(),
- })
- .to_predicate(tcx);
+ }),
+ );
+
// A built-in `Fn` impl only holds if the output is sized.
// (FIXME: technically we only need to check this if the type is a fn ptr...)
Self::consider_implied_clause(ecx, goal, pred, [goal.with(tcx, output_is_sized_pred)])
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 6444c01a67b51..93e8e1f4bb1ef 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1644,7 +1644,7 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
let env_predicates = data
.projection_bounds()
.filter(|bound| bound.item_def_id() == obligation.predicate.def_id)
- .map(|p| p.with_self_ty(tcx, object_ty).to_predicate(tcx));
+ .map(|p| ty::Clause::from_projection_clause(tcx, p.with_self_ty(tcx, object_ty)));
assemble_candidates_from_predicates(
selcx,
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index ba0258b63cb62..2288d36df17bd 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -4,7 +4,7 @@ use rustc_hir::def::DefKind;
use rustc_index::bit_set::BitSet;
use rustc_middle::query::Providers;
use rustc_middle::ty::{
- self, EarlyBinder, ToPredicate, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor,
+ self, EarlyBinder, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor,
};
use rustc_span::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
use rustc_span::DUMMY_SP;
@@ -220,13 +220,10 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
// strategy, then just reinterpret the associated type like an opaque :^)
let default_ty = self.tcx.type_of(shifted_alias_ty.def_id).instantiate(self.tcx, shifted_alias_ty.args);
- self.predicates.push(
- ty::Binder::bind_with_vars(
- ty::ProjectionPredicate { projection_ty: shifted_alias_ty, term: default_ty.into() },
- self.bound_vars,
- )
- .to_predicate(self.tcx),
- );
+ self.predicates.push(ty::Clause::from_projection_clause(self.tcx, ty::Binder::bind_with_vars(
+ ty::ProjectionPredicate { projection_ty: shifted_alias_ty, term: default_ty.into() },
+ self.bound_vars,
+ )));
// We walk the *un-shifted* alias ty, because we're tracking the de bruijn
// binder depth, and if we were to walk `shifted_alias_ty` instead, we'd
From 9fbee7dcc556cf731e00298f9ed0bbe22f57e7bb Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 19 Sep 2023 19:40:36 -0700
Subject: [PATCH 3/9] rustdoc: add test cases, and fix, search tabs
---
src/librustdoc/html/static/css/rustdoc.css | 12 ++-
src/librustdoc/html/static/js/search.js | 9 ++-
tests/rustdoc-gui/search-tab.goml | 86 +++++++++++++++++++++-
3 files changed, 100 insertions(+), 7 deletions(-)
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 3b23664133761..47f9e65028118 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1355,6 +1355,7 @@ a.tooltip:hover::after {
#search-tabs .count {
font-size: 1rem;
+ font-variant-numeric: tabular-nums;
color: var(--search-tab-title-count-color);
}
@@ -1637,6 +1638,13 @@ However, it's not needed with smaller screen width because the doc/code block is
/* Media Queries */
+/* Make sure all the buttons line wrap at the same time */
+@media (max-width: 850px) {
+ #search-tabs .count {
+ display: block;
+ }
+}
+
/*
WARNING: RUSTDOC_MOBILE_BREAKPOINT MEDIA QUERY
If you update this line, then you also need to update the line with the same warning
@@ -1764,10 +1772,6 @@ in src-script.js
display: none !important;
}
- #search-tabs .count {
- display: block;
- }
-
#main-content > details.toggle > summary::before,
#main-content > div > details.toggle > summary::before {
left: -11px;
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 407bf5f2c5fe1..3dd60296e81e0 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -2334,11 +2334,16 @@ ${item.displayPath}<span class="${type}">${name}</span>\
}
function makeTabHeader(tabNb, text, nbElems) {
+ // https://blog.horizon-eda.org/misc/2020/02/19/ui.html
+ const fmtNbElems =
+ nbElems < 10 ? `\u{2007}(${nbElems})\u{2007}\u{2007}` :
+ nbElems < 100 ? `\u{2007}(${nbElems})\u{2007}` :
+ `\u{2007}(${nbElems})`;
if (searchState.currentTab === tabNb) {
return "<button class=\"selected\">" + text +
- " <span class=\"count\">(" + nbElems + ")</span></button>";
+ "<span class=\"count\">" + fmtNbElems + "</span></button>";
}
- return "<button>" + text + " <span class=\"count\">(" + nbElems + ")</span></button>";
+ return "<button>" + text + "<span class=\"count\">" + fmtNbElems + "</span></button>";
}
/**
diff --git a/tests/rustdoc-gui/search-tab.goml b/tests/rustdoc-gui/search-tab.goml
index 7bbde3ec23d3c..427201e1b5da4 100644
--- a/tests/rustdoc-gui/search-tab.goml
+++ b/tests/rustdoc-gui/search-tab.goml
@@ -1,5 +1,5 @@
// Checking the colors of the search tab headers.
-go-to: "file://" + |DOC_PATH| + "/test_docs/fn.foo.html?search=something"
+go-to: "file://" + |DOC_PATH| + "/test_docs/fn.foo.html?search=foo"
show-text: true
define-function: (
@@ -74,3 +74,87 @@ call-function: ("check-colors", {
"border_top_selected": "2px solid #0089ff",
"border_top_hover": "2px solid #0089ff",
})
+
+// set size wide enough that the text is in a single row
+set-window-size: (851, 600)
+
+// Check the size and count in tabs
+assert-text: ("#search-tabs > button:nth-child(1) > .count", " (23) ")
+assert-text: ("#search-tabs > button:nth-child(2) > .count", " (4) ")
+assert-text: ("#search-tabs > button:nth-child(3) > .count", " (0) ")
+store-property: ("#search-tabs > button:nth-child(1)", {"offsetWidth": buttonWidth})
+assert-property: ("#search-tabs > button:nth-child(2)", {"offsetWidth": |buttonWidth|})
+assert-property: ("#search-tabs > button:nth-child(3)", {"offsetWidth": |buttonWidth|})
+store-property: ("#search-tabs > button:nth-child(1) > .count", {"offsetWidth": countWidth})
+assert-property: ("#search-tabs > button:nth-child(2) > .count", {"offsetWidth": |countWidth|})
+assert-property: ("#search-tabs > button:nth-child(3) > .count", {"offsetWidth": |countWidth|})
+
+// Check that counts are in a row with each other
+compare-elements-position: (
+ "#search-tabs > button:nth-child(1) > .count",
+ "#search-tabs > button:nth-child(2) > .count",
+ ("y")
+)
+compare-elements-position: (
+ "#search-tabs > button:nth-child(2) > .count",
+ "#search-tabs > button:nth-child(3) > .count",
+ ("y")
+)
+// Check that counts are beside the titles and haven't wrapped
+compare-elements-position-near: (
+ "#search-tabs > button:nth-child(1)",
+ "#search-tabs > button:nth-child(1) > .count",
+ {"y": 8}
+)
+compare-elements-position-near: (
+ "#search-tabs > button:nth-child(2)",
+ "#search-tabs > button:nth-child(2) > .count",
+ {"y": 8}
+)
+compare-elements-position-near: (
+ "#search-tabs > button:nth-child(2)",
+ "#search-tabs > button:nth-child(2) > .count",
+ {"y": 8}
+)
+
+// Set size narrow enough that they wrap.
+// When I tested it, it wrapped at 811px, but I added some fudge factor to ensure it
+// doesn't prematurely wrap with slightly different font kerning or whatever, with a
+// @media query
+set-window-size: (850, 600)
+
+// all counts and buttons still have same size
+store-property: ("#search-tabs > button:nth-child(1)", {"offsetWidth": buttonWidth})
+assert-property: ("#search-tabs > button:nth-child(2)", {"offsetWidth": |buttonWidth|})
+assert-property: ("#search-tabs > button:nth-child(3)", {"offsetWidth": |buttonWidth|})
+store-property: ("#search-tabs > button:nth-child(1) > .count", {"offsetWidth": countWidth})
+assert-property: ("#search-tabs > button:nth-child(2) > .count", {"offsetWidth": |countWidth|})
+assert-property: ("#search-tabs > button:nth-child(3) > .count", {"offsetWidth": |countWidth|})
+
+// Check that counts are still in a row with each other
+compare-elements-position: (
+ "#search-tabs > button:nth-child(1) > .count",
+ "#search-tabs > button:nth-child(2) > .count",
+ ("y")
+)
+compare-elements-position: (
+ "#search-tabs > button:nth-child(2) > .count",
+ "#search-tabs > button:nth-child(3) > .count",
+ ("y")
+)
+// Check that counts are NOT beside the titles; now they have wrapped
+compare-elements-position-near-false: (
+ "#search-tabs > button:nth-child(1)",
+ "#search-tabs > button:nth-child(1) > .count",
+ {"y": 8}
+)
+compare-elements-position-near-false: (
+ "#search-tabs > button:nth-child(2)",
+ "#search-tabs > button:nth-child(2) > .count",
+ {"y": 8}
+)
+compare-elements-position-near-false: (
+ "#search-tabs > button:nth-child(2)",
+ "#search-tabs > button:nth-child(2) > .count",
+ {"y": 8}
+)
From 670631dd2606e7cb7cc488a2f7a7331e9dfd39af Mon Sep 17 00:00:00 2001
From: Lukas Wirth <lukas.wirth@ferrous-systems.com>
Date: Wed, 20 Sep 2023 08:31:33 +0200
Subject: [PATCH 4/9] Ensure `build/tmp` exists in `rustdoc_themes::get_themes`
---
src/tools/rustdoc-themes/main.rs | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/tools/rustdoc-themes/main.rs b/src/tools/rustdoc-themes/main.rs
index cc13df1f5ba4e..1eba83a80572f 100644
--- a/src/tools/rustdoc-themes/main.rs
+++ b/src/tools/rustdoc-themes/main.rs
@@ -1,5 +1,5 @@
use std::env::args;
-use std::fs::File;
+use std::fs::{create_dir_all, File};
use std::io::{BufRead, BufReader, BufWriter, Write};
use std::path::Path;
use std::process::{exit, Command};
@@ -14,6 +14,7 @@ fn get_themes<P: AsRef<Path>>(style_path: P) -> Vec<String> {
std::time::SystemTime::UNIX_EPOCH.elapsed().expect("time is after UNIX epoch").as_millis();
let mut in_theme = None;
+ create_dir_all("build/tmp").expect("failed to create temporary test directory");
for line in BufReader::new(File::open(style_path).expect("read rustdoc.css failed")).lines() {
let line = line.expect("read line from rustdoc.css failed");
let line = line.trim();
From 3d66513fe4eaa754f868f435334acfd78e48337c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 19 Sep 2023 20:26:23 +1000
Subject: [PATCH 5/9] coverage: Remove debug code from the instrumentor
---
.../src/coverage/counters.rs | 42 +-
.../rustc_mir_transform/src/coverage/debug.rs | 797 ------------------
.../rustc_mir_transform/src/coverage/graph.rs | 7 -
.../rustc_mir_transform/src/coverage/mod.rs | 107 +--
.../rustc_mir_transform/src/coverage/spans.rs | 49 --
compiler/rustc_session/src/options.rs | 7 +-
...rage_graphviz.bar.InstrumentCoverage.0.dot | 6 -
...age_graphviz.main.InstrumentCoverage.0.dot | 13 -
tests/mir-opt/coverage_graphviz.rs | 20 -
9 files changed, 18 insertions(+), 1030 deletions(-)
delete mode 100644 compiler/rustc_mir_transform/src/coverage/debug.rs
delete mode 100644 tests/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot
delete mode 100644 tests/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot
delete mode 100644 tests/mir-opt/coverage_graphviz.rs
diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs
index 3d442e5dca9f9..b3a33ebae15b0 100644
--- a/compiler/rustc_mir_transform/src/coverage/counters.rs
+++ b/compiler/rustc_mir_transform/src/coverage/counters.rs
@@ -1,10 +1,8 @@
use super::Error;
-use super::debug;
use super::graph;
use super::spans;
-use debug::{DebugCounters, NESTED_INDENT};
use graph::{BasicCoverageBlock, BcbBranch, CoverageGraph, TraverseCoverageGraphWithLoops};
use spans::CoverageSpan;
@@ -16,6 +14,8 @@ use rustc_middle::mir::coverage::*;
use std::fmt::{self, Debug};
+const NESTED_INDENT: &str = " ";
+
/// The coverage counter or counter expression associated with a particular
/// BCB node or BCB edge.
#[derive(Clone)]
@@ -75,8 +75,6 @@ pub(super) struct CoverageCounters {
/// BCB/edge, but are needed as operands to more complex expressions.
/// These are always [`BcbCounter::Expression`].
pub(super) intermediate_expressions: Vec<BcbCounter>,
-
- pub debug_counters: DebugCounters,
}
impl CoverageCounters {
@@ -91,17 +89,9 @@ impl CoverageCounters {
bcb_edge_counters: FxHashMap::default(),
bcb_has_incoming_edge_counters: BitSet::new_empty(num_bcbs),
intermediate_expressions: Vec::new(),
-
- debug_counters: DebugCounters::new(),
}
}
- /// Activate the `DebugCounters` data structures, to provide additional debug formatting
- /// features when formatting [`BcbCounter`] (counter) values.
- pub fn enable_debug(&mut self) {
- self.debug_counters.enable();
- }
-
/// Makes [`BcbCounter`] `Counter`s and `Expressions` for the `BasicCoverageBlock`s directly or
/// indirectly associated with `CoverageSpans`, and accumulates additional `Expression`s
/// representing intermediate values.
@@ -113,15 +103,12 @@ impl CoverageCounters {
MakeBcbCounters::new(self, basic_coverage_blocks).make_bcb_counters(coverage_spans)
}
- fn make_counter<F>(&mut self, debug_block_label_fn: F) -> BcbCounter
+ fn make_counter<F>(&mut self, _debug_block_label_fn: F) -> BcbCounter
where
F: Fn() -> Option<String>,
{
- let counter = BcbCounter::Counter { id: self.next_counter() };
- if self.debug_counters.is_enabled() {
- self.debug_counters.add_counter(&counter, (debug_block_label_fn)());
- }
- counter
+ let id = self.next_counter();
+ BcbCounter::Counter { id }
}
fn make_expression<F>(
@@ -129,28 +116,17 @@ impl CoverageCounters {
lhs: Operand,
op: Op,
rhs: Operand,
- debug_block_label_fn: F,
+ _debug_block_label_fn: F,
) -> BcbCounter
where
F: Fn() -> Option<String>,
{
let id = self.next_expression();
- let expression = BcbCounter::Expression { id, lhs, op, rhs };
- if self.debug_counters.is_enabled() {
- self.debug_counters.add_counter(&expression, (debug_block_label_fn)());
- }
- expression
+ BcbCounter::Expression { id, lhs, op, rhs }
}
pub fn make_identity_counter(&mut self, counter_operand: Operand) -> BcbCounter {
- let some_debug_block_label = if self.debug_counters.is_enabled() {
- self.debug_counters.some_block_label(counter_operand).cloned()
- } else {
- None
- };
- self.make_expression(counter_operand, Op::Add, Operand::Zero, || {
- some_debug_block_label.clone()
- })
+ self.make_expression(counter_operand, Op::Add, Operand::Zero, || unreachable!())
}
/// Counter IDs start from one and go up.
@@ -713,6 +689,6 @@ impl<'a> MakeBcbCounters<'a> {
#[inline]
fn format_counter(&self, counter_kind: &BcbCounter) -> String {
- self.coverage_counters.debug_counters.format_counter(counter_kind)
+ format!("{counter_kind:?}")
}
}
diff --git a/compiler/rustc_mir_transform/src/coverage/debug.rs b/compiler/rustc_mir_transform/src/coverage/debug.rs
deleted file mode 100644
index bb1f16aa8befa..0000000000000
--- a/compiler/rustc_mir_transform/src/coverage/debug.rs
+++ /dev/null
@@ -1,797 +0,0 @@
-//! The `InstrumentCoverage` MIR pass implementation includes debugging tools and options
-//! to help developers understand and/or improve the analysis and instrumentation of a MIR.
-//!
-//! To enable coverage, include the rustc command line option:
-//!
-//! * `-C instrument-coverage`
-//!
-//! MIR Dump Files, with additional `CoverageGraph` graphviz and `CoverageSpan` spanview
-//! ------------------------------------------------------------------------------------
-//!
-//! Additional debugging options include:
-//!
-//! * `-Z dump-mir=InstrumentCoverage` - Generate `.mir` files showing the state of the MIR,
-//! before and after the `InstrumentCoverage` pass, for each compiled function.
-//!
-//! * `-Z dump-mir-graphviz` - If `-Z dump-mir` is also enabled for the current MIR node path,
-//! each MIR dump is accompanied by a before-and-after graphical view of the MIR, in Graphviz
-//! `.dot` file format (which can be visually rendered as a graph using any of a number of free
-//! Graphviz viewers and IDE extensions).
-//!
-//! For the `InstrumentCoverage` pass, this option also enables generation of an additional
-//! Graphviz `.dot` file for each function, rendering the `CoverageGraph`: the control flow
-//! graph (CFG) of `BasicCoverageBlocks` (BCBs), as nodes, internally labeled to show the
-//! `CoverageSpan`-based MIR elements each BCB represents (`BasicBlock`s, `Statement`s and
-//! `Terminator`s), assigned coverage counters and/or expressions, and edge counters, as needed.
-//!
-//! (Note the additional option, `-Z graphviz-dark-mode`, can be added, to change the rendered
-//! output from its default black-on-white background to a dark color theme, if desired.)
-//!
-//! * `-Z dump-mir-spanview` - If `-Z dump-mir` is also enabled for the current MIR node path,
-//! each MIR dump is accompanied by a before-and-after `.html` document showing the function's
-//! original source code, highlighted by it's MIR spans, at the `statement`-level (by default),
-//! `terminator` only, or encompassing span for the `Terminator` plus all `Statement`s, in each
-//! `block` (`BasicBlock`).
-//!
-//! For the `InstrumentCoverage` pass, this option also enables generation of an additional
-//! spanview `.html` file for each function, showing the aggregated `CoverageSpan`s that will
-//! require counters (or counter expressions) for accurate coverage analysis.
-//!
-//! Debug Logging
-//! -------------
-//!
-//! The `InstrumentCoverage` pass includes debug logging messages at various phases and decision
-//! points, which can be enabled via environment variable:
-//!
-//! ```shell
-//! RUSTC_LOG=rustc_mir_transform::coverage=debug
-//! ```
-//!
-//! Other module paths with coverage-related debug logs may also be of interest, particularly for
-//! debugging the coverage map data, injected as global variables in the LLVM IR (during rustc's
-//! code generation pass). For example:
-//!
-//! ```shell
-//! RUSTC_LOG=rustc_mir_transform::coverage,rustc_codegen_llvm::coverageinfo=debug
-//! ```
-//!
-//! Coverage Debug Options
-//! ---------------------------------
-//!
-//! Additional debugging options can be enabled using the environment variable:
-//!
-//! ```shell
-//! RUSTC_COVERAGE_DEBUG_OPTIONS=<options>
-//! ```
-//!
-//! These options are comma-separated, and specified in the format `option-name=value`. For example:
-//!
-//! ```shell
-//! $ RUSTC_COVERAGE_DEBUG_OPTIONS=counter-format=id+operation,allow-unused-expressions=yes cargo build
-//! ```
-//!
-//! Coverage debug options include:
-//!
-//! * `allow-unused-expressions=yes` or `no` (default: `no`)
-//!
-//! The `InstrumentCoverage` algorithms _should_ only create and assign expressions to a
-//! `BasicCoverageBlock`, or an incoming edge, if that expression is either (a) required to
-//! count a `CoverageSpan`, or (b) a dependency of some other required counter expression.
-//!
-//! If an expression is generated that does not map to a `CoverageSpan` or dependency, this
-//! probably indicates there was a bug in the algorithm that creates and assigns counters
-//! and expressions.
-//!
-//! When this kind of bug is encountered, the rustc compiler will panic by default. Setting:
-//! `allow-unused-expressions=yes` will log a warning message instead of panicking (effectively
-//! ignoring the unused expressions), which may be helpful when debugging the root cause of
-//! the problem.
-//!
-//! * `counter-format=<choices>`, where `<choices>` can be any plus-separated combination of `id`,
-//! `block`, and/or `operation` (default: `block+operation`)
-//!
-//! This option effects both the `CoverageGraph` (graphviz `.dot` files) and debug logging, when
-//! generating labels for counters and expressions.
-//!
-//! Depending on the values and combinations, counters can be labeled by:
-//!
-//! * `id` - counter or expression ID (ascending counter IDs, starting at 1, or descending
-//! expression IDs, starting at `u32:MAX`)
-//! * `block` - the `BasicCoverageBlock` label (for example, `bcb0`) or edge label (for
-//! example `bcb0->bcb1`), for counters or expressions assigned to count a
-//! `BasicCoverageBlock` or edge. Intermediate expressions (not directly associated with
-//! a BCB or edge) will be labeled by their expression ID, unless `operation` is also
-//! specified.
-//! * `operation` - applied to expressions only, labels include the left-hand-side counter
-//! or expression label (lhs operand), the operator (`+` or `-`), and the right-hand-side
-//! counter or expression (rhs operand). Expression operand labels are generated
-//! recursively, generating labels with nested operations, enclosed in parentheses
-//! (for example: `bcb2 + (bcb0 - bcb1)`).
-
-use std::iter;
-use std::ops::Deref;
-use std::sync::OnceLock;
-
-use itertools::Itertools;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_middle::mir::coverage::*;
-use rustc_middle::mir::create_dump_file;
-use rustc_middle::mir::generic_graphviz::GraphvizWriter;
-use rustc_middle::mir::spanview::{self, SpanViewable};
-use rustc_middle::mir::{self, BasicBlock};
-use rustc_middle::ty::TyCtxt;
-use rustc_span::Span;
-
-use super::counters::{BcbCounter, CoverageCounters};
-use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph};
-use super::spans::CoverageSpan;
-
-pub const NESTED_INDENT: &str = " ";
-
-const RUSTC_COVERAGE_DEBUG_OPTIONS: &str = "RUSTC_COVERAGE_DEBUG_OPTIONS";
-
-pub(super) fn debug_options<'a>() -> &'a DebugOptions {
- static DEBUG_OPTIONS: OnceLock<DebugOptions> = OnceLock::new();
-
- &DEBUG_OPTIONS.get_or_init(DebugOptions::from_env)
-}
-
-/// Parses and maintains coverage-specific debug options captured from the environment variable
-/// "RUSTC_COVERAGE_DEBUG_OPTIONS", if set.
-#[derive(Debug, Clone)]
-pub(super) struct DebugOptions {
- pub allow_unused_expressions: bool,
- counter_format: ExpressionFormat,
-}
-
-impl DebugOptions {
- fn from_env() -> Self {
- let mut allow_unused_expressions = true;
- let mut counter_format = ExpressionFormat::default();
-
- if let Ok(env_debug_options) = std::env::var(RUSTC_COVERAGE_DEBUG_OPTIONS) {
- for setting_str in env_debug_options.replace(' ', "").replace('-', "_").split(',') {
- let (option, value) = match setting_str.split_once('=') {
- None => (setting_str, None),
- Some((k, v)) => (k, Some(v)),
- };
- match option {
- "allow_unused_expressions" => {
- allow_unused_expressions = bool_option_val(option, value);
- debug!(
- "{} env option `allow_unused_expressions` is set to {}",
- RUSTC_COVERAGE_DEBUG_OPTIONS, allow_unused_expressions
- );
- }
- "counter_format" => {
- match value {
- None => {
- bug!(
- "`{}` option in environment variable {} requires one or more \
- plus-separated choices (a non-empty subset of \
- `id+block+operation`)",
- option,
- RUSTC_COVERAGE_DEBUG_OPTIONS
- );
- }
- Some(val) => {
- counter_format = counter_format_option_val(val);
- debug!(
- "{} env option `counter_format` is set to {:?}",
- RUSTC_COVERAGE_DEBUG_OPTIONS, counter_format
- );
- }
- };
- }
- _ => bug!(
- "Unsupported setting `{}` in environment variable {}",
- option,
- RUSTC_COVERAGE_DEBUG_OPTIONS
- ),
- };
- }
- }
-
- Self { allow_unused_expressions, counter_format }
- }
-}
-
-fn bool_option_val(option: &str, some_strval: Option<&str>) -> bool {
- if let Some(val) = some_strval {
- if ["yes", "y", "on", "true"].contains(&val) {
- true
- } else if ["no", "n", "off", "false"].contains(&val) {
- false
- } else {
- bug!(
- "Unsupported value `{}` for option `{}` in environment variable {}",
- option,
- val,
- RUSTC_COVERAGE_DEBUG_OPTIONS
- )
- }
- } else {
- true
- }
-}
-
-fn counter_format_option_val(strval: &str) -> ExpressionFormat {
- let mut counter_format = ExpressionFormat { id: false, block: false, operation: false };
- let components = strval.splitn(3, '+');
- for component in components {
- match component {
- "id" => counter_format.id = true,
- "block" => counter_format.block = true,
- "operation" => counter_format.operation = true,
- _ => bug!(
- "Unsupported counter_format choice `{}` in environment variable {}",
- component,
- RUSTC_COVERAGE_DEBUG_OPTIONS
- ),
- }
- }
- counter_format
-}
-
-#[derive(Debug, Clone)]
-struct ExpressionFormat {
- id: bool,
- block: bool,
- operation: bool,
-}
-
-impl Default for ExpressionFormat {
- fn default() -> Self {
- Self { id: false, block: true, operation: true }
- }
-}
-
-/// If enabled, this struct maintains a map from `BcbCounter` IDs (as `Operand`) to
-/// the `BcbCounter` data and optional label (normally, the counter's associated
-/// `BasicCoverageBlock` format string, if any).
-///
-/// Use `format_counter` to convert one of these `BcbCounter` counters to a debug output string,
-/// as directed by the `DebugOptions`. This allows the format of counter labels in logs and dump
-/// files (including the `CoverageGraph` graphviz file) to be changed at runtime, via environment
-/// variable.
-///
-/// `DebugCounters` supports a recursive rendering of `Expression` counters, so they can be
-/// presented as nested expressions such as `(bcb3 - (bcb0 + bcb1))`.
-pub(super) struct DebugCounters {
- state: Option<DebugCountersState>,
-}
-
-#[derive(Default)]
-struct DebugCountersState {
- counters: FxHashMap<Operand, DebugCounter>,
-}
-
-impl DebugCounters {
- pub fn new() -> Self {
- Self { state: None }
- }
-
- pub fn enable(&mut self) {
- debug_assert!(!self.is_enabled());
- self.state = Some(DebugCountersState::default());
- }
-
- pub fn is_enabled(&self) -> bool {
- self.state.is_some()
- }
-
- pub fn add_counter(&mut self, counter_kind: &BcbCounter, some_block_label: Option<String>) {
- let Some(state) = &mut self.state else { return };
-
- let id = counter_kind.as_operand();
- state
- .counters
- .try_insert(id, DebugCounter::new(counter_kind.clone(), some_block_label))
- .expect("attempt to add the same counter_kind to DebugCounters more than once");
- }
-
- pub fn some_block_label(&self, operand: Operand) -> Option<&String> {
- let Some(state) = &self.state else { return None };
-
- state.counters.get(&operand)?.some_block_label.as_ref()
- }
-
- pub fn format_counter(&self, counter_kind: &BcbCounter) -> String {
- match *counter_kind {
- BcbCounter::Counter { .. } => {
- format!("Counter({})", self.format_counter_kind(counter_kind))
- }
- BcbCounter::Expression { .. } => {
- format!("Expression({})", self.format_counter_kind(counter_kind))
- }
- }
- }
-
- fn format_counter_kind(&self, counter_kind: &BcbCounter) -> String {
- let counter_format = &debug_options().counter_format;
- if let BcbCounter::Expression { id, lhs, op, rhs } = *counter_kind {
- if counter_format.operation {
- return format!(
- "{}{} {} {}",
- if counter_format.id || !self.is_enabled() {
- format!("#{} = ", id.index())
- } else {
- String::new()
- },
- self.format_operand(lhs),
- match op {
- Op::Add => "+",
- Op::Subtract => "-",
- },
- self.format_operand(rhs),
- );
- }
- }
-
- let id = counter_kind.as_operand();
- if let Some(state) = &self.state && (counter_format.block || !counter_format.id) {
- if let Some(DebugCounter { some_block_label: Some(block_label), .. }) =
- state.counters.get(&id)
- {
- return if counter_format.id {
- format!("{}#{:?}", block_label, id)
- } else {
- block_label.to_string()
- };
- }
- }
- format!("#{:?}", id)
- }
-
- fn format_operand(&self, operand: Operand) -> String {
- if matches!(operand, Operand::Zero) {
- return String::from("0");
- }
- if let Some(state) = &self.state {
- if let Some(DebugCounter { counter_kind, some_block_label }) =
- state.counters.get(&operand)
- {
- if let BcbCounter::Expression { .. } = counter_kind {
- if let Some(label) = some_block_label && debug_options().counter_format.block {
- return format!(
- "{}:({})",
- label,
- self.format_counter_kind(counter_kind)
- );
- }
- return format!("({})", self.format_counter_kind(counter_kind));
- }
- return self.format_counter_kind(counter_kind);
- }
- }
- format!("#{:?}", operand)
- }
-}
-
-/// A non-public support class to `DebugCounters`.
-#[derive(Debug)]
-struct DebugCounter {
- counter_kind: BcbCounter,
- some_block_label: Option<String>,
-}
-
-impl DebugCounter {
- fn new(counter_kind: BcbCounter, some_block_label: Option<String>) -> Self {
- Self { counter_kind, some_block_label }
- }
-}
-
-/// If enabled, this data structure captures additional debugging information used when generating
-/// a Graphviz (.dot file) representation of the `CoverageGraph`, for debugging purposes.
-pub(super) struct GraphvizData {
- state: Option<GraphvizDataState>,
-}
-
-#[derive(Default)]
-struct GraphvizDataState {
- bcb_to_coverage_spans_with_counters:
- FxHashMap<BasicCoverageBlock, Vec<(CoverageSpan, BcbCounter)>>,
- bcb_to_dependency_counters: FxHashMap<BasicCoverageBlock, Vec<BcbCounter>>,
- edge_to_counter: FxHashMap<(BasicCoverageBlock, BasicBlock), BcbCounter>,
-}
-
-impl GraphvizData {
- pub fn new() -> Self {
- Self { state: None }
- }
-
- pub fn enable(&mut self) {
- debug_assert!(!self.is_enabled());
- self.state = Some(GraphvizDataState::default());
- }
-
- pub fn is_enabled(&self) -> bool {
- self.state.is_some()
- }
-
- pub fn add_bcb_coverage_span_with_counter(
- &mut self,
- bcb: BasicCoverageBlock,
- coverage_span: &CoverageSpan,
- counter_kind: &BcbCounter,
- ) {
- let Some(state) = &mut self.state else { return };
-
- state
- .bcb_to_coverage_spans_with_counters
- .entry(bcb)
- .or_insert_with(Vec::new)
- .push((coverage_span.clone(), counter_kind.clone()));
- }
-
- pub fn get_bcb_coverage_spans_with_counters(
- &self,
- bcb: BasicCoverageBlock,
- ) -> Option<&[(CoverageSpan, BcbCounter)]> {
- let Some(state) = &self.state else { return None };
-
- state.bcb_to_coverage_spans_with_counters.get(&bcb).map(Deref::deref)
- }
-
- pub fn add_bcb_dependency_counter(
- &mut self,
- bcb: BasicCoverageBlock,
- counter_kind: &BcbCounter,
- ) {
- let Some(state) = &mut self.state else { return };
-
- state
- .bcb_to_dependency_counters
- .entry(bcb)
- .or_insert_with(Vec::new)
- .push(counter_kind.clone());
- }
-
- pub fn get_bcb_dependency_counters(&self, bcb: BasicCoverageBlock) -> Option<&[BcbCounter]> {
- let Some(state) = &self.state else { return None };
-
- state.bcb_to_dependency_counters.get(&bcb).map(Deref::deref)
- }
-
- pub fn set_edge_counter(
- &mut self,
- from_bcb: BasicCoverageBlock,
- to_bb: BasicBlock,
- counter_kind: &BcbCounter,
- ) {
- let Some(state) = &mut self.state else { return };
-
- state
- .edge_to_counter
- .try_insert((from_bcb, to_bb), counter_kind.clone())
- .expect("invalid attempt to insert more than one edge counter for the same edge");
- }
-
- pub fn get_edge_counter(
- &self,
- from_bcb: BasicCoverageBlock,
- to_bb: BasicBlock,
- ) -> Option<&BcbCounter> {
- let Some(state) = &self.state else { return None };
-
- state.edge_to_counter.get(&(from_bcb, to_bb))
- }
-}
-
-/// If enabled, this struct captures additional data used to track whether expressions were used,
-/// directly or indirectly, to compute the coverage counts for all `CoverageSpan`s, and any that are
-/// _not_ used are retained in the `unused_expressions` Vec, to be included in debug output (logs
-/// and/or a `CoverageGraph` graphviz output).
-pub(super) struct UsedExpressions {
- state: Option<UsedExpressionsState>,
-}
-
-#[derive(Default)]
-struct UsedExpressionsState {
- used_expression_operands: FxHashSet<Operand>,
- unused_expressions: Vec<(BcbCounter, Option<BasicCoverageBlock>, BasicCoverageBlock)>,
-}
-
-impl UsedExpressions {
- pub fn new() -> Self {
- Self { state: None }
- }
-
- pub fn enable(&mut self) {
- debug_assert!(!self.is_enabled());
- self.state = Some(UsedExpressionsState::default())
- }
-
- pub fn is_enabled(&self) -> bool {
- self.state.is_some()
- }
-
- pub fn add_expression_operands(&mut self, expression: &BcbCounter) {
- let Some(state) = &mut self.state else { return };
-
- if let BcbCounter::Expression { lhs, rhs, .. } = *expression {
- state.used_expression_operands.insert(lhs);
- state.used_expression_operands.insert(rhs);
- }
- }
-
- pub fn expression_is_used(&self, expression: &BcbCounter) -> bool {
- let Some(state) = &self.state else { return false };
-
- state.used_expression_operands.contains(&expression.as_operand())
- }
-
- pub fn add_unused_expression_if_not_found(
- &mut self,
- expression: &BcbCounter,
- edge_from_bcb: Option<BasicCoverageBlock>,
- target_bcb: BasicCoverageBlock,
- ) {
- let Some(state) = &mut self.state else { return };
-
- if !state.used_expression_operands.contains(&expression.as_operand()) {
- state.unused_expressions.push((expression.clone(), edge_from_bcb, target_bcb));
- }
- }
-
- /// Return the list of unused counters (if any) as a tuple with the counter (`BcbCounter`),
- /// optional `from_bcb` (if it was an edge counter), and `target_bcb`.
- pub fn get_unused_expressions(
- &self,
- ) -> Vec<(BcbCounter, Option<BasicCoverageBlock>, BasicCoverageBlock)> {
- let Some(state) = &self.state else { return Vec::new() };
-
- state.unused_expressions.clone()
- }
-
- /// If enabled, validate that every BCB or edge counter not directly associated with a coverage
- /// span is at least indirectly associated (it is a dependency of a BCB counter that _is_
- /// associated with a coverage span).
- pub fn validate(
- &mut self,
- bcb_counters_without_direct_coverage_spans: &[(
- Option<BasicCoverageBlock>,
- BasicCoverageBlock,
- BcbCounter,
- )],
- ) {
- if !self.is_enabled() {
- return;
- }
-
- let mut not_validated = bcb_counters_without_direct_coverage_spans
- .iter()
- .map(|(_, _, counter_kind)| counter_kind)
- .collect::<Vec<_>>();
- let mut validating_count = 0;
- while not_validated.len() != validating_count {
- let to_validate = not_validated.split_off(0);
- validating_count = to_validate.len();
- for counter_kind in to_validate {
- if self.expression_is_used(counter_kind) {
- self.add_expression_operands(counter_kind);
- } else {
- not_validated.push(counter_kind);
- }
- }
- }
- }
-
- pub fn alert_on_unused_expressions(&self, debug_counters: &DebugCounters) {
- let Some(state) = &self.state else { return };
-
- for (counter_kind, edge_from_bcb, target_bcb) in &state.unused_expressions {
- let unused_counter_message = if let Some(from_bcb) = edge_from_bcb.as_ref() {
- format!(
- "non-coverage edge counter found without a dependent expression, in \
- {:?}->{:?}; counter={}",
- from_bcb,
- target_bcb,
- debug_counters.format_counter(&counter_kind),
- )
- } else {
- format!(
- "non-coverage counter found without a dependent expression, in {:?}; \
- counter={}",
- target_bcb,
- debug_counters.format_counter(&counter_kind),
- )
- };
-
- if debug_options().allow_unused_expressions {
- debug!("WARNING: {}", unused_counter_message);
- } else {
- bug!("{}", unused_counter_message);
- }
- }
- }
-}
-
-/// Generates the MIR pass `CoverageSpan`-specific spanview dump file.
-pub(super) fn dump_coverage_spanview<'tcx>(
- tcx: TyCtxt<'tcx>,
- mir_body: &mir::Body<'tcx>,
- basic_coverage_blocks: &CoverageGraph,
- pass_name: &str,
- body_span: Span,
- coverage_spans: &[CoverageSpan],
-) {
- let mir_source = mir_body.source;
- let def_id = mir_source.def_id();
-
- let span_viewables = span_viewables(tcx, mir_body, basic_coverage_blocks, &coverage_spans);
- let mut file = create_dump_file(tcx, "html", false, pass_name, &0i32, mir_body)
- .expect("Unexpected error creating MIR spanview HTML file");
- let crate_name = tcx.crate_name(def_id.krate);
- let item_name = tcx.def_path(def_id).to_filename_friendly_no_crate();
- let title = format!("{crate_name}.{item_name} - Coverage Spans");
- spanview::write_document(tcx, body_span, span_viewables, &title, &mut file)
- .expect("Unexpected IO error dumping coverage spans as HTML");
-}
-
-/// Converts the computed `BasicCoverageBlockData`s into `SpanViewable`s.
-fn span_viewables<'tcx>(
- tcx: TyCtxt<'tcx>,
- mir_body: &mir::Body<'tcx>,
- basic_coverage_blocks: &CoverageGraph,
- coverage_spans: &[CoverageSpan],
-) -> Vec<SpanViewable> {
- let mut span_viewables = Vec::new();
- for coverage_span in coverage_spans {
- let tooltip = coverage_span.format_coverage_statements(tcx, mir_body);
- let CoverageSpan { span, bcb, .. } = coverage_span;
- let bcb_data = &basic_coverage_blocks[*bcb];
- let id = bcb_data.id();
- let leader_bb = bcb_data.leader_bb();
- span_viewables.push(SpanViewable { bb: leader_bb, span: *span, id, tooltip });
- }
- span_viewables
-}
-
-/// Generates the MIR pass coverage-specific graphviz dump file.
-pub(super) fn dump_coverage_graphviz<'tcx>(
- tcx: TyCtxt<'tcx>,
- mir_body: &mir::Body<'tcx>,
- pass_name: &str,
- basic_coverage_blocks: &CoverageGraph,
- coverage_counters: &CoverageCounters,
- graphviz_data: &GraphvizData,
- intermediate_expressions: &[BcbCounter],
- debug_used_expressions: &UsedExpressions,
-) {
- let debug_counters = &coverage_counters.debug_counters;
-
- let mir_source = mir_body.source;
- let def_id = mir_source.def_id();
- let node_content = |bcb| {
- bcb_to_string_sections(
- tcx,
- mir_body,
- coverage_counters,
- bcb,
- &basic_coverage_blocks[bcb],
- graphviz_data.get_bcb_coverage_spans_with_counters(bcb),
- graphviz_data.get_bcb_dependency_counters(bcb),
- // intermediate_expressions are injected into the mir::START_BLOCK, so
- // include them in the first BCB.
- if bcb.index() == 0 { Some(&intermediate_expressions) } else { None },
- )
- };
- let edge_labels = |from_bcb| {
- let from_bcb_data = &basic_coverage_blocks[from_bcb];
- let from_terminator = from_bcb_data.terminator(mir_body);
- let mut edge_labels = from_terminator.kind.fmt_successor_labels();
- edge_labels.retain(|label| label != "unreachable");
- let edge_counters = from_terminator
- .successors()
- .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 {
- format!("{}\n{}", label, debug_counters.format_counter(counter))
- } else {
- label.to_string()
- }
- })
- .collect::<Vec<_>>()
- };
- let graphviz_name = format!("Cov_{}_{}", def_id.krate.index(), def_id.index.index());
- let mut graphviz_writer =
- GraphvizWriter::new(basic_coverage_blocks, &graphviz_name, node_content, edge_labels);
- let unused_expressions = debug_used_expressions.get_unused_expressions();
- if unused_expressions.len() > 0 {
- graphviz_writer.set_graph_label(&format!(
- "Unused expressions:\n {}",
- unused_expressions
- .as_slice()
- .iter()
- .map(|(counter_kind, edge_from_bcb, target_bcb)| {
- if let Some(from_bcb) = edge_from_bcb.as_ref() {
- format!(
- "{:?}->{:?}: {}",
- from_bcb,
- target_bcb,
- debug_counters.format_counter(&counter_kind),
- )
- } else {
- format!(
- "{:?}: {}",
- target_bcb,
- debug_counters.format_counter(&counter_kind),
- )
- }
- })
- .join("\n ")
- ));
- }
- let mut file = create_dump_file(tcx, "dot", false, pass_name, &0i32, mir_body)
- .expect("Unexpected error creating BasicCoverageBlock graphviz DOT file");
- graphviz_writer
- .write_graphviz(tcx, &mut file)
- .expect("Unexpected error writing BasicCoverageBlock graphviz DOT file");
-}
-
-fn bcb_to_string_sections<'tcx>(
- tcx: TyCtxt<'tcx>,
- mir_body: &mir::Body<'tcx>,
- coverage_counters: &CoverageCounters,
- bcb: BasicCoverageBlock,
- bcb_data: &BasicCoverageBlockData,
- some_coverage_spans_with_counters: Option<&[(CoverageSpan, BcbCounter)]>,
- some_dependency_counters: Option<&[BcbCounter]>,
- some_intermediate_expressions: Option<&[BcbCounter]>,
-) -> Vec<String> {
- let debug_counters = &coverage_counters.debug_counters;
-
- let len = bcb_data.basic_blocks.len();
- let mut sections = Vec::new();
- if let Some(collect_intermediate_expressions) = some_intermediate_expressions {
- sections.push(
- collect_intermediate_expressions
- .iter()
- .map(|expression| {
- format!("Intermediate {}", debug_counters.format_counter(expression))
- })
- .join("\n"),
- );
- }
- if let Some(coverage_spans_with_counters) = some_coverage_spans_with_counters {
- sections.push(
- coverage_spans_with_counters
- .iter()
- .map(|(covspan, counter)| {
- format!(
- "{} at {}",
- debug_counters.format_counter(counter),
- covspan.format(tcx, mir_body)
- )
- })
- .join("\n"),
- );
- }
- if let Some(dependency_counters) = some_dependency_counters {
- sections.push(format!(
- "Non-coverage counters:\n {}",
- dependency_counters
- .iter()
- .map(|counter| debug_counters.format_counter(counter))
- .join(" \n"),
- ));
- }
- if let Some(counter_kind) = coverage_counters.bcb_counter(bcb) {
- sections.push(format!("{counter_kind:?}"));
- }
- let non_term_blocks = bcb_data.basic_blocks[0..len - 1]
- .iter()
- .map(|&bb| format!("{:?}: {}", bb, mir_body[bb].terminator().kind.name()))
- .collect::<Vec<_>>();
- if non_term_blocks.len() > 0 {
- sections.push(non_term_blocks.join("\n"));
- }
- sections.push(format!(
- "{:?}: {}",
- bcb_data.basic_blocks.last().unwrap(),
- bcb_data.terminator(mir_body).kind.name(),
- ));
- sections
-}
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
index b6b0463614d02..ff2254d6941e6 100644
--- a/compiler/rustc_mir_transform/src/coverage/graph.rs
+++ b/compiler/rustc_mir_transform/src/coverage/graph.rs
@@ -1,4 +1,3 @@
-use itertools::Itertools;
use rustc_data_structures::graph::dominators::{self, Dominators};
use rustc_data_structures::graph::{self, GraphSuccessors, WithNumNodes, WithStartNode};
use rustc_index::bit_set::BitSet;
@@ -8,8 +7,6 @@ use rustc_middle::mir::{self, BasicBlock, BasicBlockData, Terminator, Terminator
use std::cmp::Ordering;
use std::ops::{Index, IndexMut};
-const ID_SEPARATOR: &str = ",";
-
/// A coverage-specific simplification of the MIR control flow graph (CFG). The `CoverageGraph`s
/// nodes are `BasicCoverageBlock`s, which encompass one or more MIR `BasicBlock`s.
#[derive(Debug)]
@@ -324,10 +321,6 @@ impl BasicCoverageBlockData {
pub fn terminator<'a, 'tcx>(&self, mir_body: &'a mir::Body<'tcx>) -> &'a Terminator<'tcx> {
&mir_body[self.last_bb()].terminator()
}
-
- pub fn id(&self) -> String {
- format!("@{}", self.basic_blocks.iter().map(|bb| bb.index().to_string()).join(ID_SEPARATOR))
- }
}
/// Represents a successor from a branching BasicCoverageBlock (such as the arms of a `SwitchInt`)
diff --git a/compiler/rustc_mir_transform/src/coverage/mod.rs b/compiler/rustc_mir_transform/src/coverage/mod.rs
index d0b28eb2f5d80..80c6d08fe0d05 100644
--- a/compiler/rustc_mir_transform/src/coverage/mod.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mod.rs
@@ -1,7 +1,6 @@
pub mod query;
mod counters;
-mod debug;
mod graph;
mod spans;
@@ -20,7 +19,6 @@ use rustc_index::IndexVec;
use rustc_middle::hir;
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir::coverage::*;
-use rustc_middle::mir::dump_enabled;
use rustc_middle::mir::{
self, BasicBlock, BasicBlockData, Coverage, SourceInfo, Statement, StatementKind, Terminator,
TerminatorKind,
@@ -94,13 +92,12 @@ impl<'tcx> MirPass<'tcx> for InstrumentCoverage {
}
trace!("InstrumentCoverage starting for {:?}", mir_source.def_id());
- Instrumentor::new(&self.name(), tcx, mir_body).inject_counters();
+ Instrumentor::new(tcx, mir_body).inject_counters();
trace!("InstrumentCoverage done for {:?}", mir_source.def_id());
}
}
struct Instrumentor<'a, 'tcx> {
- pass_name: &'a str,
tcx: TyCtxt<'tcx>,
mir_body: &'a mut mir::Body<'tcx>,
source_file: Lrc<SourceFile>,
@@ -112,7 +109,7 @@ struct Instrumentor<'a, 'tcx> {
}
impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
- fn new(pass_name: &'a str, tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self {
+ fn new(tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self {
let source_map = tcx.sess.source_map();
let def_id = mir_body.source.def_id();
let (some_fn_sig, hir_body) = fn_sig_and_body(tcx, def_id);
@@ -141,7 +138,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
let coverage_counters = CoverageCounters::new(&basic_coverage_blocks);
Self {
- pass_name,
tcx,
mir_body,
source_file,
@@ -154,28 +150,9 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
}
fn inject_counters(&'a mut self) {
- let tcx = self.tcx;
- let mir_source = self.mir_body.source;
- let def_id = mir_source.def_id();
let fn_sig_span = self.fn_sig_span;
let body_span = self.body_span;
- let mut graphviz_data = debug::GraphvizData::new();
- let mut debug_used_expressions = debug::UsedExpressions::new();
-
- let dump_mir = dump_enabled(tcx, self.pass_name, def_id);
- let dump_graphviz = dump_mir && tcx.sess.opts.unstable_opts.dump_mir_graphviz;
- let dump_spanview = dump_mir && tcx.sess.opts.unstable_opts.dump_mir_spanview.is_some();
-
- if dump_graphviz {
- graphviz_data.enable();
- self.coverage_counters.enable_debug();
- }
-
- if dump_graphviz || level_enabled!(tracing::Level::DEBUG) {
- debug_used_expressions.enable();
- }
-
////////////////////////////////////////////////////
// Compute `CoverageSpan`s from the `CoverageGraph`.
let coverage_spans = CoverageSpans::generate_coverage_spans(
@@ -185,17 +162,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
&self.basic_coverage_blocks,
);
- if dump_spanview {
- debug::dump_coverage_spanview(
- tcx,
- self.mir_body,
- &self.basic_coverage_blocks,
- self.pass_name,
- body_span,
- &coverage_spans,
- );
- }
-
////////////////////////////////////////////////////
// Create an optimized mix of `Counter`s and `Expression`s for the `CoverageGraph`. Ensure
// every `CoverageSpan` has a `Counter` or `Expression` assigned to its `BasicCoverageBlock`
@@ -209,14 +175,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
.make_bcb_counters(&mut self.basic_coverage_blocks, &coverage_spans);
if let Ok(()) = result {
- // If debugging, add any intermediate expressions (which are not associated with any
- // BCB) to the `debug_used_expressions` map.
- if debug_used_expressions.is_enabled() {
- for intermediate_expression in &self.coverage_counters.intermediate_expressions {
- debug_used_expressions.add_expression_operands(intermediate_expression);
- }
- }
-
////////////////////////////////////////////////////
// Remove the counter or edge counter from of each `CoverageSpan`s associated
// `BasicCoverageBlock`, and inject a `Coverage` statement into the MIR.
@@ -227,11 +185,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
// These `CoverageSpan`-associated counters are removed from their associated
// `BasicCoverageBlock`s so that the only remaining counters in the `CoverageGraph`
// are indirect counters (to be injected next, without associated code regions).
- self.inject_coverage_span_counters(
- coverage_spans,
- &mut graphviz_data,
- &mut debug_used_expressions,
- );
+ self.inject_coverage_span_counters(coverage_spans);
////////////////////////////////////////////////////
// For any remaining `BasicCoverageBlock` counters (that were not associated with
@@ -239,37 +193,17 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
// to ensure `BasicCoverageBlock` counters that other `Expression`s may depend on
// are in fact counted, even though they don't directly contribute to counting
// their own independent code region's coverage.
- self.inject_indirect_counters(&mut graphviz_data, &mut debug_used_expressions);
+ self.inject_indirect_counters();
// Intermediate expressions will be injected as the final step, after generating
// debug output, if any.
////////////////////////////////////////////////////
};
- if graphviz_data.is_enabled() {
- // Even if there was an error, a partial CoverageGraph can still generate a useful
- // graphviz output.
- debug::dump_coverage_graphviz(
- tcx,
- self.mir_body,
- self.pass_name,
- &self.basic_coverage_blocks,
- &self.coverage_counters,
- &graphviz_data,
- &self.coverage_counters.intermediate_expressions,
- &debug_used_expressions,
- );
- }
-
if let Err(e) = result {
bug!("Error processing: {:?}: {:?}", self.mir_body.source.def_id(), e.message)
};
- // Depending on current `debug_options()`, `alert_on_unused_expressions()` could panic, so
- // this check is performed as late as possible, to allow other debug output (logs and dump
- // files), which might be helpful in analyzing unused expressions, to still be generated.
- debug_used_expressions.alert_on_unused_expressions(&self.coverage_counters.debug_counters);
-
////////////////////////////////////////////////////
// Finally, inject the intermediate expressions collected along the way.
for intermediate_expression in &self.coverage_counters.intermediate_expressions {
@@ -285,15 +219,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
/// `bcb` to its `Counter`, when injected. Subsequent `CoverageSpan`s for a BCB that already has
/// a `Counter` will inject an `Expression` instead, and compute its value by adding `ZERO` to
/// the BCB `Counter` value.
- ///
- /// If debugging, add every BCB `Expression` associated with a `CoverageSpan`s to the
- /// `used_expression_operands` map.
- fn inject_coverage_span_counters(
- &mut self,
- coverage_spans: Vec<CoverageSpan>,
- graphviz_data: &mut debug::GraphvizData,
- debug_used_expressions: &mut debug::UsedExpressions,
- ) {
+ fn inject_coverage_span_counters(&mut self, coverage_spans: Vec<CoverageSpan>) {
let tcx = self.tcx;
let source_map = tcx.sess.source_map();
let body_span = self.body_span;
@@ -307,12 +233,10 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
self.coverage_counters.make_identity_counter(counter_operand)
} else if let Some(counter_kind) = self.coverage_counters.take_bcb_counter(bcb) {
bcb_counters[bcb] = Some(counter_kind.as_operand());
- debug_used_expressions.add_expression_operands(&counter_kind);
counter_kind
} else {
bug!("Every BasicCoverageBlock should have a Counter or Expression");
};
- graphviz_data.add_bcb_coverage_span_with_counter(bcb, &covspan, &counter_kind);
let code_region = make_code_region(source_map, file_name, span, body_span);
@@ -333,11 +257,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
/// associated with a `CoverageSpan`, should only exist if the counter is an `Expression`
/// dependency (one of the expression operands). Collect them, and inject the additional
/// counters into the MIR, without a reportable coverage span.
- fn inject_indirect_counters(
- &mut self,
- graphviz_data: &mut debug::GraphvizData,
- debug_used_expressions: &mut debug::UsedExpressions,
- ) {
+ fn inject_indirect_counters(&mut self) {
let mut bcb_counters_without_direct_coverage_spans = Vec::new();
for (target_bcb, counter_kind) in self.coverage_counters.drain_bcb_counters() {
bcb_counters_without_direct_coverage_spans.push((None, target_bcb, counter_kind));
@@ -352,19 +272,8 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
));
}
- // If debug is enabled, validate that every BCB or edge counter not directly associated
- // with a coverage span is at least indirectly associated (it is a dependency of a BCB
- // counter that _is_ associated with a coverage span).
- debug_used_expressions.validate(&bcb_counters_without_direct_coverage_spans);
-
for (edge_from_bcb, target_bcb, counter_kind) in bcb_counters_without_direct_coverage_spans
{
- debug_used_expressions.add_unused_expression_if_not_found(
- &counter_kind,
- edge_from_bcb,
- target_bcb,
- );
-
match counter_kind {
BcbCounter::Counter { .. } => {
let inject_to_bb = if let Some(from_bcb) = edge_from_bcb {
@@ -375,7 +284,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
let to_bb = self.bcb_leader_bb(target_bcb);
let new_bb = inject_edge_counter_basic_block(self.mir_body, from_bb, to_bb);
- graphviz_data.set_edge_counter(from_bcb, new_bb, &counter_kind);
debug!(
"Edge {:?} (last {:?}) -> {:?} (leader {:?}) requires a new MIR \
BasicBlock {:?}, for unclaimed edge counter {}",
@@ -389,7 +297,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
new_bb
} else {
let target_bb = self.bcb_last_bb(target_bcb);
- graphviz_data.add_bcb_dependency_counter(target_bcb, &counter_kind);
debug!(
"{:?} ({:?}) gets a new Coverage statement for unclaimed counter {}",
target_bcb,
@@ -431,7 +338,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
#[inline]
fn format_counter(&self, counter_kind: &BcbCounter) -> String {
- self.coverage_counters.debug_counters.format_counter(counter_kind)
+ format!("{counter_kind:?}")
}
fn make_mir_coverage_kind(&self, counter_kind: &BcbCounter) -> CoverageKind {
diff --git a/compiler/rustc_mir_transform/src/coverage/spans.rs b/compiler/rustc_mir_transform/src/coverage/spans.rs
index 32e8ca25d31f9..5b24fa10beae8 100644
--- a/compiler/rustc_mir_transform/src/coverage/spans.rs
+++ b/compiler/rustc_mir_transform/src/coverage/spans.rs
@@ -1,13 +1,10 @@
use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph, START_BCB};
-use itertools::Itertools;
use rustc_data_structures::graph::WithNumNodes;
-use rustc_middle::mir::spanview::source_range_no_file;
use rustc_middle::mir::{
self, AggregateKind, BasicBlock, FakeReadCause, Rvalue, Statement, StatementKind, Terminator,
TerminatorKind,
};
-use rustc_middle::ty::TyCtxt;
use rustc_span::source_map::original_sp;
use rustc_span::{BytePos, ExpnKind, MacroKind, Span, Symbol};
@@ -20,31 +17,6 @@ pub(super) enum CoverageStatement {
}
impl CoverageStatement {
- pub fn format<'tcx>(&self, tcx: TyCtxt<'tcx>, mir_body: &mir::Body<'tcx>) -> String {
- match *self {
- Self::Statement(bb, span, stmt_index) => {
- let stmt = &mir_body[bb].statements[stmt_index];
- format!(
- "{}: @{}[{}]: {:?}",
- source_range_no_file(tcx, span),
- bb.index(),
- stmt_index,
- stmt
- )
- }
- Self::Terminator(bb, span) => {
- let term = mir_body[bb].terminator();
- format!(
- "{}: @{}.{}: {:?}",
- source_range_no_file(tcx, span),
- bb.index(),
- term.kind.name(),
- term.kind
- )
- }
- }
- }
-
pub fn span(&self) -> Span {
match self {
Self::Statement(_, span, _) | Self::Terminator(_, span) => *span,
@@ -150,27 +122,6 @@ impl CoverageSpan {
self.bcb == other.bcb
}
- pub fn format<'tcx>(&self, tcx: TyCtxt<'tcx>, mir_body: &mir::Body<'tcx>) -> String {
- format!(
- "{}\n {}",
- source_range_no_file(tcx, self.span),
- self.format_coverage_statements(tcx, mir_body).replace('\n', "\n "),
- )
- }
-
- pub fn format_coverage_statements<'tcx>(
- &self,
- tcx: TyCtxt<'tcx>,
- mir_body: &mir::Body<'tcx>,
- ) -> String {
- let mut sorted_coverage_statements = self.coverage_statements.clone();
- sorted_coverage_statements.sort_unstable_by_key(|covstmt| match *covstmt {
- CoverageStatement::Statement(bb, _, index) => (bb, index),
- CoverageStatement::Terminator(bb, _) => (bb, usize::MAX),
- });
- sorted_coverage_statements.iter().map(|covstmt| covstmt.format(tcx, mir_body)).join("\n")
- }
-
/// If the span is part of a macro, returns the macro name symbol.
pub fn current_macro(&self) -> Option<Symbol> {
self.current_macro_or_none
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index f2c8f0bc19894..5a6def1958bd0 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -1478,15 +1478,12 @@ options! {
dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
"exclude the pass number when dumping MIR (used in tests) (default: no)"),
dump_mir_graphviz: bool = (false, parse_bool, [UNTRACKED],
- "in addition to `.mir` files, create graphviz `.dot` files (and with \
- `-Z instrument-coverage`, also create a `.dot` file for the MIR-derived \
- coverage graph) (default: no)"),
+ "in addition to `.mir` files, create graphviz `.dot` files (default: no)"),
dump_mir_spanview: Option<MirSpanview> = (None, parse_mir_spanview, [UNTRACKED],
"in addition to `.mir` files, create `.html` files to view spans for \
all `statement`s (including terminators), only `terminator` spans, or \
computed `block` spans (one span encompassing a block's terminator and \
- all statements). If `-Z instrument-coverage` is also enabled, create \
- an additional `.html` file showing the computed coverage spans."),
+ all statements)."),
dump_mono_stats: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
parse_switch_with_opt_path, [UNTRACKED],
"output statistics about monomorphization collection"),
diff --git a/tests/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot b/tests/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot
deleted file mode 100644
index 3b90aaeae4236..0000000000000
--- a/tests/mir-opt/coverage_graphviz.bar.InstrumentCoverage.0.dot
+++ /dev/null
@@ -1,6 +0,0 @@
-digraph Cov_0_4 {
- graph [fontname="Courier, monospace"];
- node [fontname="Courier, monospace"];
- edge [fontname="Courier, monospace"];
- bcb0__Cov_0_4 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">bcb0</td></tr><tr><td align="left" balign="left"></td></tr><tr><td align="left" balign="left">Counter(bcb0) at 18:1-20:2<br align="left"/> 19:5-19:9: @0[0]: Coverage::Counter(0) for $DIR/coverage_graphviz.rs:18:1 - 20:2<br align="left"/> 20:2-20:2: @0.Return: return</td></tr><tr><td align="left" balign="left">bb0: Return</td></tr></table>>];
-}
diff --git a/tests/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot b/tests/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot
deleted file mode 100644
index 19c220e2e1d8e..0000000000000
--- a/tests/mir-opt/coverage_graphviz.main.InstrumentCoverage.0.dot
+++ /dev/null
@@ -1,13 +0,0 @@
-digraph Cov_0_3 {
- graph [fontname="Courier, monospace"];
- node [fontname="Courier, monospace"];
- edge [fontname="Courier, monospace"];
- bcb3__Cov_0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">bcb3</td></tr><tr><td align="left" balign="left">Counter(bcb3) at 13:10-13:10<br align="left"/> 13:10-13:10: @5[0]: Coverage::Counter(1) for $DIR/coverage_graphviz.rs:13:10 - 13:11</td></tr><tr><td align="left" balign="left">bb5: Goto</td></tr></table>>];
- bcb2__Cov_0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">bcb2</td></tr><tr><td align="left" balign="left">Expression(bcb1:(bcb0 + bcb3) - bcb3) at 12:13-12:18<br align="left"/> 12:13-12:18: @4[0]: Coverage::Expression(2) = Expression(1) + Zero for $DIR/coverage_graphviz.rs:15:1 - 15:2<br align="left"/>Expression(bcb2:(bcb1:(bcb0 + bcb3) - bcb3) + 0) at 15:2-15:2<br align="left"/> 15:2-15:2: @4.Return: return</td></tr><tr><td align="left" balign="left">bb4: Return</td></tr></table>>];
- bcb1__Cov_0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">bcb1</td></tr><tr><td align="left" balign="left">Expression(bcb0 + bcb3) at 10:5-11:17<br align="left"/> 11:12-11:17: @2.Call: _2 = bar() -> [return: bb3, unwind: bb6]</td></tr><tr><td align="left" balign="left">bb1: FalseUnwind<br align="left"/>bb2: Call</td></tr><tr><td align="left" balign="left">bb3: SwitchInt</td></tr></table>>];
- bcb0__Cov_0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">bcb0</td></tr><tr><td align="left" balign="left"></td></tr><tr><td align="left" balign="left">Counter(bcb0) at 9:1-9:11<br align="left"/> </td></tr><tr><td align="left" balign="left">bb0: Goto</td></tr></table>>];
- bcb3__Cov_0_3 -> bcb1__Cov_0_3 [label=<>];
- bcb1__Cov_0_3 -> bcb3__Cov_0_3 [label=<0>];
- bcb1__Cov_0_3 -> bcb2__Cov_0_3 [label=<otherwise>];
- bcb0__Cov_0_3 -> bcb1__Cov_0_3 [label=<>];
-}
diff --git a/tests/mir-opt/coverage_graphviz.rs b/tests/mir-opt/coverage_graphviz.rs
deleted file mode 100644
index 09403bb3a7926..0000000000000
--- a/tests/mir-opt/coverage_graphviz.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Test that `-C instrument-coverage` with `-Z dump-mir-graphviz` generates a graphviz (.dot file)
-// rendering of the `BasicCoverageBlock` coverage control flow graph, with counters and
-// expressions.
-
-// needs-profiler-support
-// compile-flags: -C instrument-coverage -Z dump-mir-graphviz
-// EMIT_MIR coverage_graphviz.main.InstrumentCoverage.0.dot
-// EMIT_MIR coverage_graphviz.bar.InstrumentCoverage.0.dot
-fn main() {
- loop {
- if bar() {
- break;
- }
- }
-}
-
-#[inline(never)]
-fn bar() -> bool {
- true
-}
From bbd347409fdba70e1827ba0b07a4b84588387c62 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 19 Sep 2023 20:29:47 +1000
Subject: [PATCH 6/9] coverage: Remove vestigial `format_counter` methods
---
.../src/coverage/counters.rs | 40 ++++++++-----------
.../rustc_mir_transform/src/coverage/mod.rs | 20 ++--------
2 files changed, 20 insertions(+), 40 deletions(-)
diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs
index b3a33ebae15b0..972165f02d98a 100644
--- a/compiler/rustc_mir_transform/src/coverage/counters.rs
+++ b/compiler/rustc_mir_transform/src/coverage/counters.rs
@@ -345,10 +345,7 @@ impl<'a> MakeBcbCounters<'a> {
sumup_counter_operand,
|| None,
);
- debug!(
- " [new intermediate expression: {}]",
- self.format_counter(&intermediate_expression)
- );
+ debug!(" [new intermediate expression: {:?}]", intermediate_expression);
let intermediate_expression_operand = intermediate_expression.as_operand();
self.coverage_counters.intermediate_expressions.push(intermediate_expression);
some_sumup_counter_operand.replace(intermediate_expression_operand);
@@ -372,7 +369,7 @@ impl<'a> MakeBcbCounters<'a> {
sumup_counter_operand,
|| Some(format!("{expression_branch:?}")),
);
- debug!("{:?} gets an expression: {}", expression_branch, self.format_counter(&expression));
+ debug!("{:?} gets an expression: {:?}", expression_branch, expression);
let bcb = expression_branch.target_bcb;
if expression_branch.is_only_path_to_target() {
self.coverage_counters.set_bcb_counter(bcb, expression)?;
@@ -394,10 +391,10 @@ impl<'a> MakeBcbCounters<'a> {
// If the BCB already has a counter, return it.
if let Some(counter_kind) = &self.coverage_counters.bcb_counters[bcb] {
debug!(
- "{}{:?} already has a counter: {}",
+ "{}{:?} already has a counter: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
bcb,
- self.format_counter(counter_kind),
+ counter_kind,
);
return Ok(counter_kind.as_operand());
}
@@ -410,19 +407,19 @@ impl<'a> MakeBcbCounters<'a> {
let counter_kind = self.coverage_counters.make_counter(|| Some(format!("{bcb:?}")));
if one_path_to_target {
debug!(
- "{}{:?} gets a new counter: {}",
+ "{}{:?} gets a new counter: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
bcb,
- self.format_counter(&counter_kind),
+ counter_kind,
);
} else {
debug!(
"{}{:?} has itself as its own predecessor. It can't be part of its own \
- Expression sum, so it will get its own new counter: {}. (Note, the compiled \
+ Expression sum, so it will get its own new counter: {:?}. (Note, the compiled \
code will generate an infinite loop.)",
NESTED_INDENT.repeat(debug_indent_level),
bcb,
- self.format_counter(&counter_kind),
+ counter_kind,
);
}
return self.coverage_counters.set_bcb_counter(bcb, counter_kind);
@@ -460,9 +457,9 @@ impl<'a> MakeBcbCounters<'a> {
|| None,
);
debug!(
- "{}new intermediate expression: {}",
+ "{}new intermediate expression: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
- self.format_counter(&intermediate_expression)
+ intermediate_expression
);
let intermediate_expression_operand = intermediate_expression.as_operand();
self.coverage_counters.intermediate_expressions.push(intermediate_expression);
@@ -476,10 +473,10 @@ impl<'a> MakeBcbCounters<'a> {
|| Some(format!("{bcb:?}")),
);
debug!(
- "{}{:?} gets a new counter (sum of predecessor counters): {}",
+ "{}{:?} gets a new counter (sum of predecessor counters): {:?}",
NESTED_INDENT.repeat(debug_indent_level),
bcb,
- self.format_counter(&counter_kind)
+ counter_kind
);
self.coverage_counters.set_bcb_counter(bcb, counter_kind)
}
@@ -510,11 +507,11 @@ impl<'a> MakeBcbCounters<'a> {
self.coverage_counters.bcb_edge_counters.get(&(from_bcb, to_bcb))
{
debug!(
- "{}Edge {:?}->{:?} already has a counter: {}",
+ "{}Edge {:?}->{:?} already has a counter: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
from_bcb,
to_bcb,
- self.format_counter(counter_kind)
+ counter_kind
);
return Ok(counter_kind.as_operand());
}
@@ -523,11 +520,11 @@ impl<'a> MakeBcbCounters<'a> {
let counter_kind =
self.coverage_counters.make_counter(|| Some(format!("{from_bcb:?}->{to_bcb:?}")));
debug!(
- "{}Edge {:?}->{:?} gets a new counter: {}",
+ "{}Edge {:?}->{:?} gets a new counter: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
from_bcb,
to_bcb,
- self.format_counter(&counter_kind)
+ counter_kind
);
self.coverage_counters.set_bcb_edge_counter(from_bcb, to_bcb, counter_kind)
}
@@ -686,9 +683,4 @@ impl<'a> MakeBcbCounters<'a> {
fn bcb_dominates(&self, dom: BasicCoverageBlock, node: BasicCoverageBlock) -> bool {
self.basic_coverage_blocks.dominates(dom, node)
}
-
- #[inline]
- fn format_counter(&self, counter_kind: &BcbCounter) -> String {
- format!("{counter_kind:?}")
- }
}
diff --git a/compiler/rustc_mir_transform/src/coverage/mod.rs b/compiler/rustc_mir_transform/src/coverage/mod.rs
index 80c6d08fe0d05..c75d33eeb315f 100644
--- a/compiler/rustc_mir_transform/src/coverage/mod.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mod.rs
@@ -286,22 +286,15 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
let new_bb = inject_edge_counter_basic_block(self.mir_body, from_bb, to_bb);
debug!(
"Edge {:?} (last {:?}) -> {:?} (leader {:?}) requires a new MIR \
- BasicBlock {:?}, for unclaimed edge counter {}",
- edge_from_bcb,
- from_bb,
- target_bcb,
- to_bb,
- new_bb,
- self.format_counter(&counter_kind),
+ BasicBlock {:?}, for unclaimed edge counter {:?}",
+ edge_from_bcb, from_bb, target_bcb, to_bb, new_bb, counter_kind,
);
new_bb
} else {
let target_bb = self.bcb_last_bb(target_bcb);
debug!(
- "{:?} ({:?}) gets a new Coverage statement for unclaimed counter {}",
- target_bcb,
- target_bb,
- self.format_counter(&counter_kind),
+ "{:?} ({:?}) gets a new Coverage statement for unclaimed counter {:?}",
+ target_bcb, target_bb, counter_kind,
);
target_bb
};
@@ -336,11 +329,6 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
&self.basic_coverage_blocks[bcb]
}
- #[inline]
- fn format_counter(&self, counter_kind: &BcbCounter) -> String {
- format!("{counter_kind:?}")
- }
-
fn make_mir_coverage_kind(&self, counter_kind: &BcbCounter) -> CoverageKind {
match *counter_kind {
BcbCounter::Counter { id } => {
From e015f5a3706a365d12ebd12c1e3b4a54631ddac8 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 19 Sep 2023 20:34:52 +1000
Subject: [PATCH 7/9] coverage: Remove vestigial counter/expression debug
labels
---
.../src/coverage/counters.rs | 27 ++++---------------
1 file changed, 5 insertions(+), 22 deletions(-)
diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs
index 972165f02d98a..d56d4ad4f1e7b 100644
--- a/compiler/rustc_mir_transform/src/coverage/counters.rs
+++ b/compiler/rustc_mir_transform/src/coverage/counters.rs
@@ -103,30 +103,18 @@ impl CoverageCounters {
MakeBcbCounters::new(self, basic_coverage_blocks).make_bcb_counters(coverage_spans)
}
- fn make_counter<F>(&mut self, _debug_block_label_fn: F) -> BcbCounter
- where
- F: Fn() -> Option<String>,
- {
+ fn make_counter(&mut self) -> BcbCounter {
let id = self.next_counter();
BcbCounter::Counter { id }
}
- fn make_expression<F>(
- &mut self,
- lhs: Operand,
- op: Op,
- rhs: Operand,
- _debug_block_label_fn: F,
- ) -> BcbCounter
- where
- F: Fn() -> Option<String>,
- {
+ fn make_expression(&mut self, lhs: Operand, op: Op, rhs: Operand) -> BcbCounter {
let id = self.next_expression();
BcbCounter::Expression { id, lhs, op, rhs }
}
pub fn make_identity_counter(&mut self, counter_operand: Operand) -> BcbCounter {
- self.make_expression(counter_operand, Op::Add, Operand::Zero, || unreachable!())
+ self.make_expression(counter_operand, Op::Add, Operand::Zero)
}
/// Counter IDs start from one and go up.
@@ -343,7 +331,6 @@ impl<'a> MakeBcbCounters<'a> {
branch_counter_operand,
Op::Add,
sumup_counter_operand,
- || None,
);
debug!(" [new intermediate expression: {:?}]", intermediate_expression);
let intermediate_expression_operand = intermediate_expression.as_operand();
@@ -367,7 +354,6 @@ impl<'a> MakeBcbCounters<'a> {
branching_counter_operand,
Op::Subtract,
sumup_counter_operand,
- || Some(format!("{expression_branch:?}")),
);
debug!("{:?} gets an expression: {:?}", expression_branch, expression);
let bcb = expression_branch.target_bcb;
@@ -404,7 +390,7 @@ impl<'a> MakeBcbCounters<'a> {
// program results in a tight infinite loop, but it should still compile.
let one_path_to_target = self.bcb_has_one_path_to_target(bcb);
if one_path_to_target || self.bcb_predecessors(bcb).contains(&bcb) {
- let counter_kind = self.coverage_counters.make_counter(|| Some(format!("{bcb:?}")));
+ let counter_kind = self.coverage_counters.make_counter();
if one_path_to_target {
debug!(
"{}{:?} gets a new counter: {:?}",
@@ -454,7 +440,6 @@ impl<'a> MakeBcbCounters<'a> {
sumup_edge_counter_operand,
Op::Add,
edge_counter_operand,
- || None,
);
debug!(
"{}new intermediate expression: {:?}",
@@ -470,7 +455,6 @@ impl<'a> MakeBcbCounters<'a> {
first_edge_counter_operand,
Op::Add,
some_sumup_edge_counter_operand.unwrap(),
- || Some(format!("{bcb:?}")),
);
debug!(
"{}{:?} gets a new counter (sum of predecessor counters): {:?}",
@@ -517,8 +501,7 @@ impl<'a> MakeBcbCounters<'a> {
}
// Make a new counter to count this edge.
- let counter_kind =
- self.coverage_counters.make_counter(|| Some(format!("{from_bcb:?}->{to_bcb:?}")));
+ let counter_kind = self.coverage_counters.make_counter();
debug!(
"{}Edge {:?}->{:?} gets a new counter: {:?}",
NESTED_INDENT.repeat(debug_indent_level),
From 31e8981fa998a339fe091ec303a8a1414c5d1936 Mon Sep 17 00:00:00 2001
From: Tobias Bieniek <tobias@bieniek.cloud>
Date: Wed, 20 Sep 2023 11:21:39 +0200
Subject: [PATCH 8/9] RELEASES.md: Add missing patch releases
This was copy-pasted from the current state of the `stable` branch
---
RELEASES.md | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/RELEASES.md b/RELEASES.md
index ba11234b990aa..d390f2b7f5ea8 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -113,6 +113,16 @@ Compatibility Notes
to a registry.
[#12291](https://github.com/rust-lang/cargo/pull/12291)
+Version 1.71.1 (2023-08-03)
+===========================
+
+- [Fix CVE-2023-38497: Cargo did not respect the umask when extracting dependencies](https://github.com/rust-lang/cargo/security/advisories/GHSA-j3xp-wfr4-hx87)
+- [Fix bash completion for users of Rustup](https://github.com/rust-lang/rust/pull/113579)
+- [Do not show `suspicious_double_ref_op` lint when calling `borrow()`](https://github.com/rust-lang/rust/pull/112517)
+- [Fix ICE: substitute types before checking inlining compatibility](https://github.com/rust-lang/rust/pull/113802)
+- [Fix ICE: don't use `can_eq` in `derive(..)` suggestion for missing method](https://github.com/rust-lang/rust/pull/111516)
+- [Fix building Rust 1.71.0 from the source tarball](https://github.com/rust-lang/rust/issues/113678)
+
Version 1.71.0 (2023-07-13)
==========================
From 66e0483a654a998cdc480b8e9a15d8d30aa4515b Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Wed, 20 Sep 2023 07:51:30 -0700
Subject: [PATCH 9/9] rustdoc: add comment about numeric spacing
---
src/librustdoc/html/static/js/search.js | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 3dd60296e81e0..2f0cae0a48e21 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -2335,6 +2335,10 @@ ${item.displayPath}<span class="${type}">${name}</span>\
function makeTabHeader(tabNb, text, nbElems) {
// https://blog.horizon-eda.org/misc/2020/02/19/ui.html
+ //
+ // CSS runs with `font-variant-numeric: tabular-nums` to ensure all
+ // digits are the same width. \u{2007} is a Unicode space character
+ // that is defined to be the same width as a digit.
const fmtNbElems =
nbElems < 10 ? `\u{2007}(${nbElems})\u{2007}\u{2007}` :
nbElems < 100 ? `\u{2007}(${nbElems})\u{2007}` :