From c9008c6c8b551616d6e96942e519a2d872cdf1bc Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 30 Nov 2023 16:05:50 +1100
Subject: [PATCH] Rename `Handler::delay_good_path_bug` as
`Handler::good_path_delayed_bug`.
In line with the previous commits.
---
.../src/interpret/eval_context.rs | 10 ++++----
compiler/rustc_errors/src/lib.rs | 24 +++++++++----------
.../src/infer/error_reporting/mod.rs | 2 +-
compiler/rustc_middle/src/ty/print/pretty.rs | 2 +-
compiler/rustc_session/src/config.rs | 9 ++++---
compiler/rustc_session/src/session.rs | 6 ++---
6 files changed, 28 insertions(+), 25 deletions(-)
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 3bdfc1db913..dd8f06df6d7 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -284,9 +284,9 @@ impl<'tcx> fmt::Display for FrameInfo<'tcx> {
{
write!(f, "inside closure")
} else {
- // Note: this triggers a `good_path_bug` state, which means that if we ever get here
- // we must emit a diagnostic. We should never display a `FrameInfo` unless we
- // actually want to emit a warning or error to the user.
+ // Note: this triggers a `good_path_delayed_bug` state, which means that if we ever
+ // get here we must emit a diagnostic. We should never display a `FrameInfo` unless
+ // we actually want to emit a warning or error to the user.
write!(f, "inside `{}`", self.instance)
}
})
@@ -300,8 +300,8 @@ impl<'tcx> FrameInfo<'tcx> {
errors::FrameNote { where_: "closure", span, instance: String::new(), times: 0 }
} else {
let instance = format!("{}", self.instance);
- // Note: this triggers a `good_path_bug` state, which means that if we ever get here
- // we must emit a diagnostic. We should never display a `FrameInfo` unless we
+ // Note: this triggers a `good_path_delayed_bug` state, which means that if we ever get
+ // here we must emit a diagnostic. We should never display a `FrameInfo` unless we
// actually want to emit a warning or error to the user.
errors::FrameNote { where_: "instance", span, instance, times: 0 }
}
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 70c435a1bcc..85c521b0743 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -432,9 +432,9 @@ struct HandlerInner {
deduplicated_err_count: usize,
emitter: Box<DynEmitter>,
span_delayed_bugs: Vec<DelayedDiagnostic>,
- delayed_good_path_bugs: Vec<DelayedDiagnostic>,
+ good_path_delayed_bugs: Vec<DelayedDiagnostic>,
/// This flag indicates that an expected diagnostic was emitted and suppressed.
- /// This is used for the `delayed_good_path_bugs` check.
+ /// This is used for the `good_path_delayed_bugs` check.
suppressed_expected_diag: bool,
/// This set contains the `DiagnosticId` of all emitted diagnostics to avoid
@@ -549,16 +549,16 @@ impl Drop for HandlerInner {
self.flush_delayed(bugs, "no errors encountered even though `span_delayed_bug` issued");
}
- // FIXME(eddyb) this explains what `delayed_good_path_bugs` are!
+ // FIXME(eddyb) this explains what `good_path_delayed_bugs` are!
// They're `span_delayed_bugs` but for "require some diagnostic happened"
// instead of "require some error happened". Sadly that isn't ideal, as
// lints can be `#[allow]`'d, potentially leading to this triggering.
// Also, "good path" should be replaced with a better naming.
if !self.has_any_message() && !self.suppressed_expected_diag && !std::thread::panicking() {
- let bugs = std::mem::replace(&mut self.delayed_good_path_bugs, Vec::new());
+ let bugs = std::mem::replace(&mut self.good_path_delayed_bugs, Vec::new());
self.flush_delayed(
bugs,
- "no warnings or errors encountered even though `delayed_good_path_bugs` issued",
+ "no warnings or errors encountered even though `good_path_delayed_bugs` issued",
);
}
@@ -610,7 +610,7 @@ impl Handler {
deduplicated_warn_count: 0,
emitter,
span_delayed_bugs: Vec::new(),
- delayed_good_path_bugs: Vec::new(),
+ good_path_delayed_bugs: Vec::new(),
suppressed_expected_diag: false,
taught_diagnostics: Default::default(),
emitted_diagnostic_codes: Default::default(),
@@ -665,7 +665,7 @@ impl Handler {
// actually free the underlying memory (which `clear` would not do)
inner.span_delayed_bugs = Default::default();
- inner.delayed_good_path_bugs = Default::default();
+ inner.good_path_delayed_bugs = Default::default();
inner.taught_diagnostics = Default::default();
inner.emitted_diagnostic_codes = Default::default();
inner.emitted_diagnostics = Default::default();
@@ -1008,8 +1008,8 @@ impl Handler {
// FIXME(eddyb) note the comment inside `impl Drop for HandlerInner`, that's
// where the explanation of what "good path" is (also, it should be renamed).
- pub fn delay_good_path_bug(&self, msg: impl Into<DiagnosticMessage>) {
- self.inner.borrow_mut().delay_good_path_bug(msg)
+ pub fn good_path_delayed_bug(&self, msg: impl Into<DiagnosticMessage>) {
+ self.inner.borrow_mut().good_path_delayed_bug(msg)
}
#[track_caller]
@@ -1444,7 +1444,7 @@ impl HandlerInner {
}
fn delayed_bug_count(&self) -> usize {
- self.span_delayed_bugs.len() + self.delayed_good_path_bugs.len()
+ self.span_delayed_bugs.len() + self.good_path_delayed_bugs.len()
}
fn print_error_count(&mut self, registry: &Registry) {
@@ -1620,13 +1620,13 @@ impl HandlerInner {
// FIXME(eddyb) note the comment inside `impl Drop for HandlerInner`, that's
// where the explanation of what "good path" is (also, it should be renamed).
- fn delay_good_path_bug(&mut self, msg: impl Into<DiagnosticMessage>) {
+ fn good_path_delayed_bug(&mut self, msg: impl Into<DiagnosticMessage>) {
let mut diagnostic = Diagnostic::new(Level::DelayedBug, msg);
if self.flags.report_delayed_bugs {
self.emit_diagnostic(&mut diagnostic);
}
let backtrace = std::backtrace::Backtrace::capture();
- self.delayed_good_path_bugs.push(DelayedDiagnostic::with_backtrace(diagnostic, backtrace));
+ self.good_path_delayed_bugs.push(DelayedDiagnostic::with_backtrace(diagnostic, backtrace));
}
fn failure_note(&mut self, msg: impl Into<DiagnosticMessage>) {
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index a36b93f4a44..9cdf78484d4 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -137,7 +137,7 @@ impl Drop for TypeErrCtxt<'_, '_> {
self.infcx
.tcx
.sess
- .delay_good_path_bug("used a `TypeErrCtxt` without raising an error or lint");
+ .good_path_delayed_bug("used a `TypeErrCtxt` without raising an error or lint");
}
}
}
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index d50743bc207..68dd8dee87c 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3025,7 +3025,7 @@ pub fn trimmed_def_paths(tcx: TyCtxt<'_>, (): ()) -> FxHashMap<DefId, Symbol> {
//
// For good paths causing this bug, the `rustc_middle::ty::print::with_no_trimmed_paths`
// wrapper can be used to suppress this query, in exchange for full paths being formatted.
- tcx.sess.delay_good_path_bug(
+ tcx.sess.good_path_delayed_bug(
"trimmed_def_paths constructed but no error emitted; use `DelayDm` for lints or `with_no_trimmed_paths` for debugging",
);
}
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index efc75eb3118..e694e150b31 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -551,12 +551,15 @@ impl Default for ErrorOutputType {
/// Parameter to control path trimming.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum TrimmedDefPaths {
- /// `try_print_trimmed_def_path` never prints a trimmed path and never calls the expensive query
+ /// `try_print_trimmed_def_path` never prints a trimmed path and never calls the expensive
+ /// query.
#[default]
Never,
- /// `try_print_trimmed_def_path` calls the expensive query, the query doesn't call `delay_good_path_bug`
+ /// `try_print_trimmed_def_path` calls the expensive query, the query doesn't call
+ /// `good_path_delayed_bug`.
Always,
- /// `try_print_trimmed_def_path` calls the expensive query, the query calls `delay_good_path_bug`
+ /// `try_print_trimmed_def_path` calls the expensive query, the query calls
+ /// `good_path_delayed_bug`.
GoodPath,
}
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index da044a98fed..60139f5d18b 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -640,7 +640,7 @@ impl Session {
/// Used for code paths of expensive computations that should only take place when
/// warnings or errors are emitted. If no messages are emitted ("good path"), then
/// it's likely a bug.
- pub fn delay_good_path_bug(&self, msg: impl Into<DiagnosticMessage>) {
+ pub fn good_path_delayed_bug(&self, msg: impl Into<DiagnosticMessage>) {
if self.opts.unstable_opts.print_type_sizes
|| self.opts.unstable_opts.query_dep_graph
|| self.opts.unstable_opts.dump_mir.is_some()
@@ -651,7 +651,7 @@ impl Session {
return;
}
- self.diagnostic().delay_good_path_bug(msg)
+ self.diagnostic().good_path_delayed_bug(msg)
}
#[rustc_lint_diagnostics]
@@ -883,7 +883,7 @@ impl Session {
if fuel.remaining == 0 && !fuel.out_of_fuel {
if self.diagnostic().can_emit_warnings() {
// We only call `msg` in case we can actually emit warnings.
- // Otherwise, this could cause a `delay_good_path_bug` to
+ // Otherwise, this could cause a `good_path_delayed_bug` to
// trigger (issue #79546).
self.emit_warning(errors::OptimisationFuelExhausted { msg: msg() });
}