Split delayed bugs into has-errored and will-error halves.

compiler/rustc_abi/src/layout.rs

@@ -32,7 +32,7 @@ where
 pub trait LayoutCalculator {
     type TargetDataLayoutRef: Borrow<TargetDataLayout>;
 
-    fn delayed_bug(&self, txt: String);
+    fn assert_has_errors(&self, txt: String);
     fn current_data_layout(&self) -> Self::TargetDataLayoutRef;
 
     fn scalar_pair<FieldIdx: Idx, VariantIdx: Idx>(
@@ -259,7 +259,7 @@ pub trait LayoutCalculator {
         let only_variant = &variants[VariantIdx::new(0)];
         for field in only_variant {
             if field.is_unsized() {
-                self.delayed_bug("unsized field in union".to_string());
+                self.assert_has_errors("unsized field in union".to_string());
             }
 
             align = align.max(field.align);
@@ -1092,7 +1092,7 @@ fn univariant<
     for &i in &inverse_memory_index {
         let field = &fields[i];
         if !sized {
-            this.delayed_bug(format!(
+            this.assert_has_errors(format!(
                 "univariant: field #{} comes after unsized field",
                 offsets.len(),
             ));

compiler/rustc_ast_lowering/src/delegation.rs

@@ -112,7 +112,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         sig_id.ok_or_else(|| {
             self.tcx
                 .dcx()
-                .span_delayed_bug(span, "LoweringContext: couldn't resolve delegation item")
+                .span_assert_has_errors(span, "LoweringContext: couldn't resolve delegation item")
         })
     }
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -323,9 +323,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     )
                 }
                 ExprKind::Yield(opt_expr) => self.lower_expr_yield(e.span, opt_expr.as_deref()),
-                ExprKind::Err => {
-                    hir::ExprKind::Err(self.dcx().span_delayed_bug(e.span, "lowered ExprKind::Err"))
-                }
+                ExprKind::Err => hir::ExprKind::Err(
+                    self.dcx().span_assert_has_errors(e.span, "lowered ExprKind::Err"),
+                ),
                 ExprKind::Try(sub_expr) => self.lower_expr_try(e.span, sub_expr),
 
                 ExprKind::Paren(_) | ExprKind::ForLoop { .. } => {

compiler/rustc_ast_lowering/src/format.rs

@@ -267,7 +267,7 @@ fn make_count<'hir>(
                 ctx.expr(
                     sp,
                     hir::ExprKind::Err(
-                        ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count"),
+                        ctx.dcx().span_assert_has_errors(sp, "lowered bad format_args count"),
                     ),
                 )
             }
@@ -306,7 +306,9 @@ fn make_format_spec<'hir>(
         }
         Err(_) => ctx.expr(
             sp,
-            hir::ExprKind::Err(ctx.dcx().span_delayed_bug(sp, "lowered bad format_args count")),
+            hir::ExprKind::Err(
+                ctx.dcx().span_assert_has_errors(sp, "lowered bad format_args count"),
+            ),
         ),
     };
     let &FormatOptions {

compiler/rustc_ast_lowering/src/index.rs

@@ -61,7 +61,7 @@ pub(super) fn index_hir<'hir>(
         if let Node::Err(span) = node.node {
             let hir_id = HirId { owner: item.def_id(), local_id };
             let msg = format!("ID {hir_id} not encountered when visiting item HIR");
-            tcx.dcx().span_delayed_bug(*span, msg);
+            tcx.dcx().span_assert_has_errors(*span, msg);
         }
     }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -266,7 +266,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| match ty {
                         None => {
-                            let guar = this.dcx().span_delayed_bug(
+                            let guar = this.dcx().span_assert_has_errors(
                                 span,
                                 "expected to lower type alias type, but it was missing",
                             );
@@ -925,7 +925,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| match ty {
                         None => {
-                            let guar = this.dcx().span_delayed_bug(
+                            let guar = this.dcx().span_assert_has_errors(
                                 i.span,
                                 "expected to lower associated type, but it was missing",
                             );
@@ -1068,7 +1068,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_block_expr_opt(&mut self, span: Span, block: Option<&Block>) -> hir::Expr<'hir> {
         match block {
             Some(block) => self.lower_block_expr(block),
-            None => self.expr_err(span, self.dcx().span_delayed_bug(span, "no block")),
+            None => self.expr_err(span, self.dcx().span_assert_has_errors(span, "no block")),
         }
     }
 
@@ -1078,7 +1078,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 &[],
                 match expr {
                     Some(expr) => this.lower_expr_mut(expr),
-                    None => this.expr_err(span, this.dcx().span_delayed_bug(span, "no block")),
+                    None => {
+                        this.expr_err(span, this.dcx().span_assert_has_errors(span, "no block"))
+                    }
                 },
             )
         })

compiler/rustc_ast_lowering/src/lib.rs

@@ -747,7 +747,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let res = self.resolver.get_import_res(id).present_items();
         let res: SmallVec<_> = res.map(|res| self.lower_res(res)).collect();
         if res.is_empty() {
-            self.dcx().span_delayed_bug(span, "no resolution for an import");
+            self.dcx().span_assert_has_errors(span, "no resolution for an import");
             return smallvec![Res::Err];
         }
         res
@@ -1286,7 +1286,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let kind = match &t.kind {
             TyKind::Infer => hir::TyKind::Infer,
             TyKind::Err => {
-                hir::TyKind::Err(self.dcx().span_delayed_bug(t.span, "TyKind::Err lowered"))
+                hir::TyKind::Err(self.dcx().span_assert_has_errors(t.span, "TyKind::Err lowered"))
             }
             // Lower the anonymous structs or unions in a nested lowering context.
             //
@@ -1499,7 +1499,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
             TyKind::MacCall(_) => panic!("`TyKind::MacCall` should have been expanded by now"),
             TyKind::CVarArgs => {
-                let guar = self.dcx().span_delayed_bug(
+                let guar = self.dcx().span_assert_has_errors(
                     t.span,
                     "`TyKind::CVarArgs` should have been handled elsewhere",
                 );
@@ -1643,8 +1643,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     if let Some(old_def_id) = self.orig_opt_local_def_id(param) {
                         old_def_id
                     } else {
-                        self.dcx()
-                            .span_delayed_bug(lifetime.ident.span, "no def-id for fresh lifetime");
+                        self.dcx().span_assert_has_errors(
+                            lifetime.ident.span,
+                            "no def-id for fresh lifetime",
+                        );
                         continue;
                     }
                 }
@@ -2576,7 +2578,7 @@ impl<'hir> GenericArgsCtor<'hir> {
                 let span = lcx.lower_span(span);
 
                 let Some(host_param_id) = lcx.host_param_id else {
-                    lcx.dcx().span_delayed_bug(
+                    lcx.dcx().span_assert_has_errors(
                         span,
                         "no host param id for call in const yet no errors reported",
                     );

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -627,8 +627,8 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                     _,
                 ) => {
                     // HIR lowering sometimes doesn't catch this in erroneous
-                    // programs, so we need to use span_delayed_bug here. See #82126.
-                    self.dcx().span_delayed_bug(
+                    // programs, so we need to use span_assert_has_errors here. See #82126.
+                    self.dcx().span_assert_has_errors(
                         hir_arg.span(),
                         format!("unmatched arg and hir arg: found {kind:?} vs {hir_arg:?}"),
                     );

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -316,7 +316,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
                     .and(type_op::normalize::Normalize::new(ty))
                     .fully_perform(self.infcx, span)
                 else {
-                    tcx.dcx().span_delayed_bug(span, format!("failed to normalize {ty:?}"));
+                    tcx.dcx().span_assert_has_errors(span, format!("failed to normalize {ty:?}"));
                     continue;
                 };
                 constraints.extend(c);

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -152,9 +152,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         // Equate expected input tys with those in the MIR.
         for (argument_index, &normalized_input_ty) in normalized_input_tys.iter().enumerate() {
             if argument_index + 1 >= body.local_decls.len() {
-                self.tcx()
-                    .dcx()
-                    .span_delayed_bug(body.span, "found more normalized_input_ty than local_decls");
+                self.tcx().dcx().span_assert_has_errors(
+                    body.span,
+                    "found more normalized_input_ty than local_decls",
+                );
                 break;
             }
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -223,7 +223,7 @@ pub(crate) fn type_check<'mir, 'tcx>(
             let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type);
             trace!("finalized opaque type {:?} to {:#?}", opaque_type_key, hidden_type.ty.kind());
             if hidden_type.has_non_region_infer() {
-                let reported = infcx.dcx().span_delayed_bug(
+                let reported = infcx.dcx().span_assert_has_errors(
                     decl.hidden_type.span,
                     format!("could not resolve {:#?}", hidden_type.ty.kind()),
                 );
@@ -1089,7 +1089,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         );
 
         if result.is_err() {
-            self.infcx.dcx().span_delayed_bug(
+            self.infcx.dcx().span_assert_has_errors(
                 self.body.span,
                 "failed re-defining predefined opaques in mir typeck",
             );

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -90,8 +90,10 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
                 Some(tcx.fn_sig(did))
             } else {
-                tcx.dcx()
-                    .span_delayed_bug(attr.span, "this attribute can only be applied to functions");
+                tcx.dcx().span_assert_has_errors(
+                    attr.span,
+                    "this attribute can only be applied to functions",
+                );
                 None
             }
         };

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -388,10 +388,9 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                 if ecx.tcx.is_ctfe_mir_available(def) {
                     Ok(ecx.tcx.mir_for_ctfe(def))
                 } else if ecx.tcx.def_kind(def) == DefKind::AssocConst {
-                    let guar = ecx
-                        .tcx
-                        .dcx()
-                        .delayed_bug("This is likely a const item that is missing from its impl");
+                    let guar = ecx.tcx.dcx().assert_has_errors(
+                        "This is likely a const item that is missing from its impl",
+                    );
                     throw_inval!(AlreadyReported(guar.into()));
                 } else {
                     // `find_mir_or_eval_fn` checks that this is a const fn before even calling us,

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -217,7 +217,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
         // `async` functions cannot be `const fn`. This is checked during AST lowering, so there's
         // no need to emit duplicate errors here.
         if self.ccx.is_async() || body.coroutine.is_some() {
-            tcx.dcx().span_delayed_bug(body.span, "`async` functions cannot be `const fn`");
+            tcx.dcx().span_assert_has_errors(body.span, "`async` functions cannot be `const fn`");
             return;
         }
 
@@ -331,7 +331,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
         if self.tcx.is_thread_local_static(def_id) {
             self.tcx
                 .dcx()
-                .span_delayed_bug(span, "tls access is checked in `Rvalue::ThreadLocalRef`");
+                .span_assert_has_errors(span, "tls access is checked in `Rvalue::ThreadLocalRef`");
         }
         self.check_op_spanned(ops::StaticAccess, span)
     }

compiler/rustc_const_eval/src/transform/check_consts/mod.rs

@@ -117,7 +117,7 @@ pub fn is_const_stable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
         None if is_parent_const_stable_trait(tcx, def_id) => {
             // Remove this when `#![feature(const_trait_impl)]` is stabilized,
             // returning `true` unconditionally.
-            tcx.dcx().span_delayed_bug(
+            tcx.dcx().span_assert_has_errors(
                 tcx.def_span(def_id),
                 "trait implementations cannot be const stable yet",
             );

compiler/rustc_const_eval/src/transform/validate.rs

@@ -118,9 +118,9 @@ impl<'a, 'tcx> CfgChecker<'a, 'tcx> {
     #[track_caller]
     fn fail(&self, location: Location, msg: impl AsRef<str>) {
         let span = self.body.source_info(location).span;
-        // We use `span_delayed_bug` as we might see broken MIR when other errors have already
+        // We use `span_assert_has_errors` as we might see broken MIR when other errors have already
         // occurred.
-        self.tcx.dcx().span_delayed_bug(
+        self.tcx.dcx().span_assert_has_errors(
             span,
             format!(
                 "broken MIR in {:?} ({}) at {:?}:\n{}",
@@ -501,7 +501,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CfgChecker<'a, 'tcx> {
 
     fn visit_source_scope(&mut self, scope: SourceScope) {
         if self.body.source_scopes.get(scope).is_none() {
-            self.tcx.dcx().span_delayed_bug(
+            self.tcx.dcx().span_assert_has_errors(
                 self.body.span,
                 format!(
                     "broken MIR in {:?} ({}):\ninvalid source scope {:?}",