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

This commit adds new `{span_,}assert_has_errors` methods implementing
the simpler has-errored cases, and leaves the existing
`{span_,}delayed_bug` methods for the will-error cases.

It also converts as many cases as possible to has-errored. I did this by
converting every case to has-errored, then running tests and converting
back to will-error every case that caused an assertion in the test
suite. The test suite doesn't have perfect coverage so it's possible
that there are a few more has-errored cases that will need conversion
back to will-error. Also, some of the will-error cases might actually be
a mixture of has-errored and will-error. But it's hard to do this
perfectly without carefully going through every individual case, which
would be painful, and an imperfect split still gets most of the
benefits.

Author: nnethercote

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