mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename Handler::delay_good_path_bug as Handler::good_path_delayed_bug.

Browse Source 
In line with the previous commits.
This commit is contained in:
Nicholas Nethercote 2023-11-30 16:05:50 +11:00
parent 2c337a072c
commit c9008c6c8b
6 changed files with 28 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_const_eval/src/interpret/eval_context.rs
View File

@ -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 }
}

24
compiler/rustc_errors/src/lib.rs
View File

@ -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>) {

2
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -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");
}
}
}

2
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -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",
);
}

9
compiler/rustc_session/src/config.rs
View File

@ -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,
}

6
compiler/rustc_session/src/session.rs
View File

@ -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() });
}