Skip to content

Commit 2903bbb

Browse files
nnethercotennethercote
committed
Convert bugs back to delayed_bugs.
This commit undoes some of the previous commit's mechanical changes, based on human judgment.
1 parent 010f394 commit 2903bbb

File tree

24 files changed

+87
-42
lines changed

24 files changed

+87
-42
lines changed

‎compiler/rustc_borrowck/src/diagnostics/region_name.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -626,8 +626,8 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
626626
| GenericArgKind::Const(_),
627627
_,
628628
) => {
629-
// HIR lowering sometimes doesn't catch this in erroneous
630-
// programs, so we need to use span_delayed_bug here. See #82126.
629+
// This was previously a `span_delayed_bug` and could be
630+
// reached by the test for #82126, but no longer.
631631
self.dcx().span_bug(
632632
hir_arg.span(),
633633
format!("unmatched arg and hir arg: found {kind:?} vs {hir_arg:?}"),

‎compiler/rustc_borrowck/src/type_check/free_region_relations.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -316,7 +316,11 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
316316
.and(type_op::normalize::Normalize::new(ty))
317317
.fully_perform(self.infcx, span)
318318
else {
319-
tcx.dcx().span_bug(span, format!("failed to normalize {ty:?}"));
319+
// Note: this path is currently not reached in any test, so
320+
// any example that triggers this would be worth minimizing
321+
// and converting into a test.
322+
tcx.dcx().span_delayed_bug(span, format!("failed to normalize {ty:?}"));
323+
continue;
320324
};
321325
constraints.extend(c);
322326

‎compiler/rustc_const_eval/src/const_eval/machine.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -622,7 +622,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
622622
);
623623
// If this was a hard error, don't bother continuing evaluation.
624624
if is_error {
625-
let guard: rustc_errors::ErrorGuaranteed = ecx
625+
let guard = ecx
626626
.tcx
627627
.dcx()
628628
.span_delayed_bug(span, "The deny lint should have already errored");

‎compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

+13-1
Original file line numberDiff line numberDiff line change
@@ -734,6 +734,10 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
734734
remapped_types.insert(def_id, ty::EarlyBinder::bind(ty));
735735
}
736736
Err(err) => {
737+
// This code path is not reached in any tests, but may be
738+
// reachable. If this is triggered, it should be converted to
739+
// `span_delayed_bug` and the triggering case turned into a
740+
// test.
737741
tcx.dcx()
738742
.span_bug(return_span, format!("could not fully resolve: {ty} => {err:?}"));
739743
}
@@ -914,7 +918,13 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
914918
.with_note(format!("hidden type inferred to be `{}`", self.ty))
915919
.emit()
916920
}
917-
_ => self.tcx.dcx().bug("should've been able to remap region"),
921+
_ => {
922+
// This code path is not reached in any tests, but may be
923+
// reachable. If this is triggered, it should be converted
924+
// to `delayed_bug` and the triggering case turned into a
925+
// test.
926+
self.tcx.dcx().bug("should've been able to remap region");
927+
}
918928
};
919929
return Err(guar);
920930
};
@@ -1273,6 +1283,8 @@ fn compare_number_of_generics<'tcx>(
12731283
// inheriting the generics from will also have mismatched arguments, and
12741284
// we'll report an error for that instead. Delay a bug for safety, though.
12751285
if trait_.is_impl_trait_in_trait() {
1286+
// FIXME: no tests trigger this. If you find example code that does
1287+
// trigger this, please add it to the test suite.
12761288
tcx.dcx()
12771289
.bug("errors comparing numbers of generics of trait/impl functions were not emitted");
12781290
}

‎compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

+9
Original file line numberDiff line numberDiff line change
@@ -154,6 +154,9 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
154154
trait_m_sig.inputs_and_output,
155155
));
156156
if !ocx.select_all_or_error().is_empty() {
157+
// This code path is not reached in any tests, but may be reachable. If
158+
// this is triggered, it should be converted to `delayed_bug` and the
159+
// triggering case turned into a test.
157160
tcx.dcx().bug("encountered errors when checking RPITIT refinement (selection)");
158161
}
159162
let outlives_env = OutlivesEnvironment::with_bounds(
@@ -162,10 +165,16 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
162165
);
163166
let errors = infcx.resolve_regions(&outlives_env);
164167
if !errors.is_empty() {
168+
// This code path is not reached in any tests, but may be reachable. If
169+
// this is triggered, it should be converted to `delayed_bug` and the
170+
// triggering case turned into a test.
165171
tcx.dcx().bug("encountered errors when checking RPITIT refinement (regions)");
166172
}
167173
// Resolve any lifetime variables that may have been introduced during normalization.
168174
let Ok((trait_bounds, impl_bounds)) = infcx.fully_resolve((trait_bounds, impl_bounds)) else {
175+
// This code path is not reached in any tests, but may be reachable. If
176+
// this is triggered, it should be converted to `delayed_bug` and the
177+
// triggering case turned into a test.
169178
tcx.dcx().bug("encountered errors when checking RPITIT refinement (resolution)");
170179
};
171180

‎compiler/rustc_hir_analysis/src/check/dropck.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -67,10 +67,11 @@ pub fn check_drop_impl(tcx: TyCtxt<'_>, drop_impl_did: DefId) -> Result<(), Erro
6767
// already checked by coherence, but compilation may
6868
// not have been terminated.
6969
let span = tcx.def_span(drop_impl_did);
70-
tcx.dcx().span_bug(
70+
let reported = tcx.dcx().span_delayed_bug(
7171
span,
7272
format!("should have been rejected by coherence check: {dtor_self_type}"),
7373
);
74+
Err(reported)
7475
}
7576
}
7677
}

‎compiler/rustc_hir_analysis/src/check/wfcheck.rs

+2-6
Original file line numberDiff line numberDiff line change
@@ -1087,12 +1087,8 @@ fn check_type_defn<'tcx>(
10871087
packed && {
10881088
let ty = tcx.type_of(variant.tail().did).instantiate_identity();
10891089
let ty = tcx.erase_regions(ty);
1090-
if ty.has_infer() {
1091-
// Unresolved type expression.
1092-
tcx.dcx().span_bug(item.span, format!("inference variables in {ty:?}"));
1093-
} else {
1094-
ty.needs_drop(tcx, tcx.param_env(item.owner_id))
1095-
}
1090+
assert!(!ty.has_infer());
1091+
ty.needs_drop(tcx, tcx.param_env(item.owner_id))
10961092
}
10971093
};
10981094
// All fields (except for possibly the last) should be sized.

‎compiler/rustc_hir_typeck/src/expr.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -1315,9 +1315,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13151315
// the LUB of the breaks (possibly ! if none); else, it
13161316
// is nil. This makes sense because infinite loops
13171317
// (which would have type !) are only possible iff we
1318-
// permit break with a value [1].
1318+
// permit break with a value.
13191319
if ctxt.coerce.is_none() && !ctxt.may_break {
1320-
// [1]
13211320
self.dcx().span_bug(body.span, "no coercion, but loop may not break");
13221321
}
13231322
ctxt.coerce.map(|c| c.complete(self)).unwrap_or_else(|| Ty::new_unit(self.tcx))

‎compiler/rustc_hir_typeck/src/intrinsicck.rs

+3
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
4848
let to = normalize(to);
4949
trace!(?from, ?to);
5050
if from.has_non_region_infer() || to.has_non_region_infer() {
51+
// Note: this path is currently not reached in any test, so any
52+
// example that triggers this would be worth minimizing and
53+
// converting into a test.
5154
tcx.dcx().span_bug(span, "argument to transmute has inference variables");
5255
}
5356
// Transmutes that are only changing lifetimes are always ok.

‎compiler/rustc_hir_typeck/src/method/suggest.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -924,7 +924,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
924924
span: item_span,
925925
..
926926
})) => {
927-
tcx.dcx().span_bug(
927+
tcx.dcx().span_delayed_bug(
928928
*item_span,
929929
"auto trait is invoked with no method error, but no error reported?",
930930
);

‎compiler/rustc_infer/src/infer/outlives/obligations.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -303,7 +303,7 @@ where
303303
// Ignore this, we presume it will yield an error later,
304304
// since if a type variable is not resolved by this point
305305
// it never will be.
306-
self.tcx.dcx().span_bug(
306+
self.tcx.dcx().span_delayed_bug(
307307
origin.span(),
308308
format!("unresolved inference variable in outlives: {v:?}"),
309309
);

‎compiler/rustc_infer/src/infer/outlives/verify.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -175,7 +175,11 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
175175
// Ignore this, we presume it will yield an error later, since
176176
// if a type variable is not resolved by this point it never
177177
// will be.
178-
self.tcx.dcx().bug(format!("unresolved inference variable in outlives: {v:?}"));
178+
self.tcx
179+
.dcx()
180+
.delayed_bug(format!("unresolved inference variable in outlives: {v:?}"));
181+
// Add a bound that never holds.
182+
VerifyBound::AnyBound(vec![])
179183
}
180184
}
181185
}

‎compiler/rustc_infer/src/infer/relate/nll.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -422,7 +422,7 @@ where
422422
// Forbid inference variables in the RHS.
423423
self.infcx
424424
.dcx()
425-
.span_bug(self.delegate.span(), format!("unexpected inference var {b:?}",));
425+
.span_bug(self.delegate.span(), format!("unexpected inference var {b:?}"));
426426
}
427427
// FIXME(invariance): see the related FIXME above.
428428
_ => self.infcx.super_combine_consts(self, a, b),

‎compiler/rustc_middle/src/ty/util.rs

+3-1
Original file line numberDiff line numberDiff line change
@@ -356,7 +356,9 @@ impl<'tcx> TyCtxt<'tcx> {
356356
}
357357

358358
let Some(item_id) = self.associated_item_def_ids(impl_did).first() else {
359-
self.dcx().span_bug(self.def_span(impl_did), "Drop impl without drop function");
359+
self.dcx()
360+
.span_delayed_bug(self.def_span(impl_did), "Drop impl without drop function");
361+
return;
360362
};
361363

362364
if let Some((old_item_id, _)) = dtor_candidate {

‎compiler/rustc_middle/src/util/bug.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ fn opt_span_bug_fmt<S: Into<MultiSpan>>(
4242
/// delayed bug, so what is the point of this? It exists to help us test the interaction of delayed
4343
/// bugs with the query system and incremental.
4444
pub fn trigger_delayed_bug(tcx: TyCtxt<'_>, key: rustc_hir::def_id::DefId) {
45-
tcx.dcx().span_bug(
45+
tcx.dcx().span_delayed_bug(
4646
tcx.def_span(key),
4747
"delayed bug triggered by #[rustc_error(delayed_bug_from_inside_query)]",
4848
);

‎compiler/rustc_mir_build/src/build/expr/as_constant.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -110,12 +110,12 @@ fn lit_to_mir_constant<'tcx>(
110110
let LitToConstInput { lit, ty, neg } = lit_input;
111111
let trunc = |n| {
112112
let param_ty = ty::ParamEnv::reveal_all().and(ty);
113-
let width = tcx
114-
.layout_of(param_ty)
115-
.map_err(|_| {
113+
let width = match tcx.layout_of(param_ty) {
114+
Ok(layout) => layout.size,
115+
Err(_) => {
116116
tcx.dcx().bug(format!("couldn't compute width of literal: {:?}", lit_input.lit))
117-
})?
118-
.size;
117+
}
118+
};
119119
trace!("trunc {} with size {} and shift {}", n, width.bits(), 128 - width.bits());
120120
let result = width.truncate(n);
121121
trace!("trunc result: {}", result);

‎compiler/rustc_mir_build/src/thir/constant.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,12 @@ pub(crate) fn lit_to_const<'tcx>(
1212

1313
let trunc = |n| {
1414
let param_ty = ParamEnv::reveal_all().and(ty);
15-
let width = tcx
16-
.layout_of(param_ty)
17-
.map_err(|_| {
15+
let width = match tcx.layout_of(param_ty) {
16+
Ok(layout) => layout.size,
17+
Err(_) => {
1818
tcx.dcx().bug(format!("couldn't compute width of literal: {:?}", lit_input.lit))
19-
})?
20-
.size;
19+
}
20+
};
2121
trace!("trunc {} with size {} and shift {}", n, width.bits(), 128 - width.bits());
2222
let result = width.truncate(n);
2323
trace!("trunc result: {}", result);

‎compiler/rustc_resolve/src/late.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -3681,9 +3681,9 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
36813681
None
36823682
}
36833683
Res::SelfCtor(_) => {
3684-
// njn: remove comment?
36853684
// We resolve `Self` in pattern position as an ident sometimes during recovery,
3686-
// so delay a bug instead of ICEing.
3685+
// so delay a bug instead of ICEing. (Note: is this no longer true? We now ICE. If
3686+
// this triggers, please convert to a delayed bug and add a test.)
36873687
self.r.dcx().span_bug(
36883688
ident.span,
36893689
"unexpected `SelfCtor` in pattern, expected identifier"

‎compiler/rustc_trait_selection/src/traits/const_evaluatable.rs

+4-5
Original file line numberDiff line numberDiff line change
@@ -62,11 +62,10 @@ pub fn is_const_evaluatable<'tcx>(
6262

6363
match unexpanded_ct.kind() {
6464
ty::ConstKind::Expr(_) => {
65-
// njn: ?
66-
// FIXME(generic_const_exprs): we have a `ConstKind::Expr` which is fully concrete,
67-
// but currently it is not possible to evaluate `ConstKind::Expr` so we are unable
68-
// to tell if it is evaluatable or not. For now we just ICE until this is
69-
// implemented.
65+
// FIXME(generic_const_exprs): we have a fully concrete `ConstKind::Expr`, but
66+
// haven't implemented evaluating `ConstKind::Expr` yet, so we are unable to tell
67+
// if it is evaluatable or not. As this is unreachable for now, we can simple ICE
68+
// here.
7069
tcx.dcx().span_bug(span, "evaluating `ConstKind::Expr` is not currently supported");
7170
}
7271
ty::ConstKind::Unevaluated(uv) => {

‎compiler/rustc_trait_selection/src/traits/mod.rs

+2
Original file line numberDiff line numberDiff line change
@@ -172,6 +172,8 @@ fn do_normalize_predicates<'tcx>(
172172
// the normalized predicates.
173173
let errors = infcx.resolve_regions(&outlives_env);
174174
if !errors.is_empty() {
175+
// @lcnr: Let's still ICE here for now. I want a test case
176+
// for that.
175177
tcx.dcx().span_bug(
176178
span,
177179
format!("failed region resolution while normalizing {elaborated_env:?}: {errors:?}"),

‎compiler/rustc_trait_selection/src/traits/project.rs

+3-4
Original file line numberDiff line numberDiff line change
@@ -647,9 +647,7 @@ pub fn compute_inherent_assoc_ty_args<'a, 'b, 'tcx>(
647647
Err(_) => {
648648
tcx.dcx().span_bug(
649649
cause.span,
650-
format!(
651-
"{self_ty:?} was a subtype of {impl_ty:?} during selection but now it is not"
652-
),
650+
format!("{self_ty:?} was equal to {impl_ty:?} during selection but now it is not"),
653651
);
654652
}
655653
}
@@ -1190,10 +1188,11 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
11901188
ImplSource::Builtin(BuiltinImplSource::TraitUpcasting { .. }, _)
11911189
| ImplSource::Builtin(BuiltinImplSource::TupleUnsizing, _) => {
11921190
// These traits have no associated types.
1193-
selcx.tcx().dcx().span_bug(
1191+
selcx.tcx().dcx().span_delayed_bug(
11941192
obligation.cause.span,
11951193
format!("Cannot project an associated type from `{impl_source:?}`"),
11961194
);
1195+
return Err(())
11971196
}
11981197
};
11991198

‎compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -82,7 +82,7 @@ where
8282
let value = infcx.commit_if_ok(|_| {
8383
let ocx = ObligationCtxt::new(infcx);
8484
let value = op(&ocx).map_err(|_| {
85-
infcx.dcx().span_bug(span, format!("error performing operation: {name}"))
85+
infcx.dcx().span_delayed_bug(span, format!("error performing operation: {name}"))
8686
})?;
8787
let errors = ocx.select_all_or_error();
8888
if errors.is_empty() {

‎tests/ui/drop/missing-drop-method.rs

+4
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
struct DropNoMethod;
2+
impl Drop for DropNoMethod {} //~ ERROR not all trait items implemented, missing: `drop`
3+
4+
fn main() {}

‎tests/ui/drop/missing-drop-method.stderr

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
error[E0046]: not all trait items implemented, missing: `drop`
2+
--> $DIR/missing-drop-method.rs:2:1
3+
|
4+
LL | impl Drop for DropNoMethod {}
5+
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `drop` in implementation
6+
|
7+
= help: implement the missing item: `fn drop(&mut self) { todo!() }`
8+
9+
error: aborting due to 1 previous error
10+
11+
For more information about this error, try `rustc --explain E0046`.

0 commit comments

Comments
 (0)