delay_bug_unless_*

Author: compiler-errors

compiler/rustc_ast_lowering/src/lib.rs

@@ -1404,7 +1404,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
             TyKind::MacCall(_) => panic!("`TyKind::MacCall` should have been expanded by now"),
             TyKind::CVarArgs => {
-                self.tcx.sess.delay_span_bug(
+                self.tcx.sess.delay_bug_unless_error(
                     t.span,
                     "`TyKind::CVarArgs` should have been handled elsewhere",
                 );

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -102,7 +102,7 @@ impl<'a> PostExpansionVisitor<'a> {
             }
             Err(abi::AbiDisabled::Unrecognized) => {
                 if self.sess.opts.pretty.map_or(true, |ppm| ppm.needs_hir()) {
-                    self.sess.parse_sess.span_diagnostic.delay_span_bug(
+                    self.sess.parse_sess.span_diagnostic.delay_bug_unless_error(
                         span,
                         &format!(
                             "unrecognized ABI not caught in lowering: {}",

compiler/rustc_attr/src/builtin.rs

@@ -1092,9 +1092,10 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
                 // Not a word we recognize. This will be caught and reported by
                 // the `check_mod_attrs` pass, but this pass doesn't always run
                 // (e.g. if we only pretty-print the source), so we have to gate
-                // the `delay_span_bug` call as follows:
+                // the `delay_bug_unless_error` call as follows:
                 if sess.opts.pretty.map_or(true, |pp| pp.needs_analysis()) {
-                    diagnostic.delay_span_bug(item.span(), "unrecognized representation hint");
+                    diagnostic
+                        .delay_bug_unless_error(item.span(), "unrecognized representation hint");
                 }
             }
         }

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -380,7 +380,7 @@ fn try_extract_error_from_fulfill_cx<'tcx>(
     error_region: Option<ty::Region<'tcx>>,
 ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
     // We generally shouldn't have errors here because the query was
-    // already run, but there's no point using `delay_span_bug`
+    // already run, but there's no point using `delay_bug_unless_error`
     // when we're going to emit an error here anyway.
     let _errors = ocx.select_all_or_error();
     let region_constraints = ocx.infcx.with_region_constraints(|r| r.clone());

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -84,7 +84,7 @@ impl<'tcx> RegionErrors<'tcx> {
     #[track_caller]
     pub fn push(&mut self, val: impl Into<RegionErrorKind<'tcx>>) {
         let val = val.into();
-        self.1.sess.delay_span_bug(DUMMY_SP, format!("{val:?}"));
+        self.1.sess.delay_bug_unless_error(DUMMY_SP, format!("{val:?}"));
         self.0.push(val);
     }
     pub fn is_empty(&self) -> bool {

compiler/rustc_borrowck/src/diagnostics/region_name.rs

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

compiler/rustc_borrowck/src/lib.rs

@@ -2054,11 +2054,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                     && !self.has_buffered_errors()
                 {
                     // rust-lang/rust#46908: In pure NLL mode this code path should be
-                    // unreachable, but we use `delay_span_bug` because we can hit this when
+                    // unreachable, but we use `delay_bug_unless_error` because we can hit this when
                     // dereferencing a non-Copy raw pointer *and* have `-Ztreat-err-as-bug`
                     // enabled. We don't want to ICE for that case, as other errors will have
                     // been emitted (#52262).
-                    self.infcx.tcx.sess.delay_span_bug(
+                    self.infcx.tcx.sess.delay_bug_unless_error(
                         span,
                         &format!(
                             "Accessing `{:?}` with the kind `{:?}` shouldn't be possible",
@@ -2354,11 +2354,11 @@ mod error {
 
         pub fn buffer_error(&mut self, t: DiagnosticBuilder<'_, ErrorGuaranteed>) {
             if let None = self.tainted_by_errors {
-                self.tainted_by_errors = Some(
-                    self.tcx
-                        .sess
-                        .delay_span_bug(t.span.clone(), "diagnostic buffered but not emitted"),
-                )
+                self.tainted_by_errors =
+                    Some(self.tcx.sess.delay_bug_unless_error(
+                        t.span.clone(),
+                        "diagnostic buffered but not emitted",
+                    ))
             }
             t.buffer(&mut self.buffered);
         }

compiler/rustc_borrowck/src/nll.rs

@@ -303,7 +303,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
 
     if !nll_errors.is_empty() {
         // Suppress unhelpful extra errors in `infer_opaque_types`.
-        infcx.set_tainted_by_errors(infcx.tcx.sess.delay_span_bug(
+        infcx.set_tainted_by_errors(infcx.tcx.sess.delay_bug_unless_error(
             body.span,
             "`compute_regions` tainted `infcx` with errors but did not emit any errors",
         ));

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -274,7 +274,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
                         .infcx
                         .tcx
                         .sess
-                        .delay_span_bug(span, &format!("failed to normalize {:?}", ty));
+                        .delay_bug_unless_error(span, &format!("failed to normalize {:?}", ty));
                     TypeOpOutput {
                         output: self.infcx.tcx.ty_error(guar),
                         constraints: None,

compiler/rustc_borrowck/src/type_check/input_output.rs

@@ -80,9 +80,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()
-                    .sess
-                    .delay_span_bug(body.span, "found more normalized_input_ty than local_decls");
+                self.tcx().sess.delay_bug_unless_error(
+                    body.span,
+                    "found more normalized_input_ty than local_decls",
+                );
                 break;
             }
 
@@ -106,10 +107,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         );
 
         // We will not have a universal_regions.yield_ty if we yield (by accident)
-        // outside of a generator and return an `impl Trait`, so emit a delay_span_bug
+        // outside of a generator and return an `impl Trait`, so emit a delay_bug_unless_error
         // because we don't want to panic in an assert here if we've already got errors.
         if body.yield_ty().is_some() != universal_regions.yield_ty.is_some() {
-            self.tcx().sess.delay_span_bug(
+            self.tcx().sess.delay_bug_unless_error(
                 body.span,
                 &format!(
                     "Expected body to have yield_ty ({:?}) iff we have a UR yield_ty ({:?})",