Remove DiagnosticBuilder::delay_as_bug_without_consuming.

nnethercote · nnethercote · commit 4752a923af2a · 2024-01-08T16:07:14.000+11:00
The existing uses are replaced in one of three ways.
- In a function that also has calls to `emit`, just rearrange the code
  so that exactly one of `delay_as_bug` or `emit` is called on every
  path.
- In a function returning a `DiagnosticBuilder`, use
  `downgrade_to_delayed_bug`. That's good enough because it will get
  emitted later anyway.
- In `unclosed_delim_err`, one set of errors is being replaced with
  another set, so just cancel the original errors.
diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs
@@ -366,13 +366,6 @@ impl<'a, G: EmissionGuarantee> DiagnosticBuilder<'a, G> {
         self.emit()
     }
 
-    /// Non-consuming variant of `delay_as_bug`.
-    #[track_caller]
-    pub fn delay_as_bug_without_consuming(&mut self) -> G::EmitResult {
-        self.downgrade_to_delayed_bug();
-        G::emit_producing_guarantee(self)
-    }
-
     forward!((span_label, span_label_mv)(
         span: Span,
         label: impl Into<SubdiagnosticMessage>,
diff --git a/compiler/rustc_hir_typeck/src/intrinsicck.rs b/compiler/rustc_hir_typeck/src/intrinsicck.rs
@@ -121,15 +121,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
         if from == to {
             err.note(format!("`{from}` does not have a fixed size"));
+            err.emit();
         } else {
             err.note(format!("source type: `{}` ({})", from, skeleton_string(from, sk_from)))
                 .note(format!("target type: `{}` ({})", to, skeleton_string(to, sk_to)));
             if let Err(LayoutError::ReferencesError(_)) = sk_from {
-                err.delay_as_bug_without_consuming();
+                err.delay_as_bug();
             } else if let Err(LayoutError::ReferencesError(_)) = sk_to {
-                err.delay_as_bug_without_consuming();
+                err.delay_as_bug();
+            } else {
+                err.emit();
             }
         }
-        err.emit();
     }
 }
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
@@ -385,7 +385,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     && let hir::ExprKind::Assign(..) = expr.kind
                 {
                     // We defer to the later error produced by `check_lhs_assignable`.
-                    err.delay_as_bug_without_consuming();
+                    err.downgrade_to_delayed_bug();
                 }
 
                 let suggest_deref_binop =
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -361,7 +361,7 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
             );
         }
         ty::ReError(_) => {
-            err.delay_as_bug_without_consuming();
+            err.downgrade_to_delayed_bug();
         }
         _ => {
             // Ugh. This is a painful case: the hidden region is not one
diff --git a/compiler/rustc_infer/src/infer/error_reporting/note.rs b/compiler/rustc_infer/src/infer/error_reporting/note.rs
@@ -281,7 +281,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             }
         };
         if sub.is_error() || sup.is_error() {
-            err.delay_as_bug_without_consuming();
+            err.downgrade_to_delayed_bug();
         }
         err
     }
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
@@ -67,7 +67,7 @@ pub(crate) fn parse_token_trees<'a>(
     let (stream, res, unmatched_delims) =
         tokentrees::TokenTreesReader::parse_all_token_trees(string_reader);
     match res {
-        Ok(_open_spacing) if unmatched_delims.is_empty() => Ok(stream),
+        Ok(()) if unmatched_delims.is_empty() => Ok(stream),
         _ => {
             // Return error if there are unmatched delimiters or unclosed delimiters.
             // We emit delimiter mismatch errors first, then emit the unclosing delimiter mismatch
diff --git a/compiler/rustc_parse/src/lexer/tokentrees.rs b/compiler/rustc_parse/src/lexer/tokentrees.rs
@@ -277,9 +277,9 @@ impl<'a> TokenTreesReader<'a> {
             parser.bump();
         }
         if !diff_errs.is_empty() {
-            errs.iter_mut().for_each(|err| {
-                err.delay_as_bug_without_consuming();
-            });
+            for err in errs {
+                err.cancel();
+            }
             return diff_errs;
         }
         return errs;
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
@@ -242,7 +242,7 @@ impl<'a> Parser<'a> {
                 Some(TopLevelOrPatternNotAllowedSugg::WrapInParens { span, pat })
             };
 
-            let mut err = self.dcx().create_err(match syntax_loc {
+            let err = self.dcx().create_err(match syntax_loc {
                 PatternLocation::LetBinding => {
                     TopLevelOrPatternNotAllowed::LetBinding { span, sub }
                 }
@@ -251,9 +251,10 @@ impl<'a> Parser<'a> {
                 }
             });
             if trailing_vert {
-                err.delay_as_bug_without_consuming();
+                err.delay_as_bug();
+            } else {
+                err.emit();
             }
-            err.emit();
         }
 
         Ok((pat, colon))
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
@@ -1040,7 +1040,7 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'_, G> for BreakNonLoop<'a> {
                     // This error is redundant, we will have already emitted a
                     // suggestion to use the label when `segment` wasn't found
                     // (hence the `Res::Err` check).
-                    diag.delay_as_bug_without_consuming();
+                    diag.downgrade_to_delayed_bug();
                 }
                 _ => {
                     diag.span_suggestion(
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -2088,7 +2088,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                     let ty = self.resolve_vars_if_possible(returned_ty);
                     if ty.references_error() {
                         // don't print out the [type error] here
-                        err.delay_as_bug_without_consuming();
+                        err.downgrade_to_delayed_bug();
                     } else {
                         err.span_label(expr.span, format!("this returned value is of type `{ty}`"));
                     }

Original file line number	Diff line number	Diff line change
`@@ -121,15 +121,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`121`	`121`	`);`
`122`	`122`	`if from == to {`
`123`	`123`	err.note(format!("`{from}` does not have a fixed size"));
	`124`	`+ err.emit();`
`124`	`125`	`} else {`
`125`	`126`	err.note(format!("source type: `{}` ({})", from, skeleton_string(from, sk_from)))
`126`	`127`	.note(format!("target type: `{}` ({})", to, skeleton_string(to, sk_to)));
`127`	`128`	`if let Err(LayoutError::ReferencesError(_)) = sk_from {`
`128`		`- err.delay_as_bug_without_consuming();`
	`129`	`+ err.delay_as_bug();`
`129`	`130`	`} else if let Err(LayoutError::ReferencesError(_)) = sk_to {`
`130`		`- err.delay_as_bug_without_consuming();`
	`131`	`+ err.delay_as_bug();`
	`132`	`+ } else {`
	`133`	`+ err.emit();`
`131`	`134`	`}`
`132`	`135`	`}`
`133`		`- err.emit();`
`134`	`136`	`}`
`135`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -385,7 +385,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`385`	`385`	`&& let hir::ExprKind::Assign(..) = expr.kind`
`386`	`386`	`{`
`387`	`387`	// We defer to the later error produced by `check_lhs_assignable`.
`388`		`- err.delay_as_bug_without_consuming();`
	`388`	`+ err.downgrade_to_delayed_bug();`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`let suggest_deref_binop =`
Original file line number	Diff line number	Diff line change
`@@ -361,7 +361,7 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(`
`361`	`361`	`);`
`362`	`362`	`}`
`363`	`363`	`ty::ReError(_) => {`
`364`		`- err.delay_as_bug_without_consuming();`
	`364`	`+ err.downgrade_to_delayed_bug();`
`365`	`365`	`}`
`366`	`366`	`_ => {`
`367`	`367`	`// Ugh. This is a painful case: the hidden region is not one`
Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`281`	`281`	`}`
`282`	`282`	`};`
`283`	`283`	`if sub.is_error() \|\| sup.is_error() {`
`284`		`- err.delay_as_bug_without_consuming();`
	`284`	`+ err.downgrade_to_delayed_bug();`
`285`	`285`	`}`
`286`	`286`	`err`
`287`	`287`	`}`
Original file line number	Diff line number	Diff line change
`@@ -277,9 +277,9 @@ impl<'a> TokenTreesReader<'a> {`
`277`	`277`	`parser.bump();`
`278`	`278`	`}`
`279`	`279`	`if !diff_errs.is_empty() {`
`280`		`- errs.iter_mut().for_each(\|err\| {`
`281`		`- err.delay_as_bug_without_consuming();`
`282`		`- });`
	`280`	`+ for err in errs {`
	`281`	`+ err.cancel();`
	`282`	`+ }`
`283`	`283`	`return diff_errs;`
`284`	`284`	`}`
`285`	`285`	`return errs;`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ impl<'a> Parser<'a> {`
`242`	`242`	`Some(TopLevelOrPatternNotAllowedSugg::WrapInParens { span, pat })`
`243`	`243`	`};`
`244`	`244`
`245`		`- let mut err = self.dcx().create_err(match syntax_loc {`
	`245`	`+ let err = self.dcx().create_err(match syntax_loc {`
`246`	`246`	`PatternLocation::LetBinding => {`
`247`	`247`	`TopLevelOrPatternNotAllowed::LetBinding { span, sub }`
`248`	`248`	`}`
`@@ -251,9 +251,10 @@ impl<'a> Parser<'a> {`
`251`	`251`	`}`
`252`	`252`	`});`
`253`	`253`	`if trailing_vert {`
`254`		`- err.delay_as_bug_without_consuming();`
	`254`	`+ err.delay_as_bug();`
	`255`	`+ } else {`
	`256`	`+ err.emit();`
`255`	`257`	`}`
`256`		`- err.emit();`
`257`	`258`	`}`
`258`	`259`
`259`	`260`	`Ok((pat, colon))`
Original file line number	Diff line number	Diff line change
`@@ -1040,7 +1040,7 @@ impl<'a, G: EmissionGuarantee> IntoDiagnostic<'_, G> for BreakNonLoop<'a> {`
`1040`	`1040`	`// This error is redundant, we will have already emitted a`
`1041`	`1041`	// suggestion to use the label when `segment` wasn't found
`1042`	`1042`	// (hence the `Res::Err` check).
`1043`		`- diag.delay_as_bug_without_consuming();`
	`1043`	`+ diag.downgrade_to_delayed_bug();`
`1044`	`1044`	`}`
`1045`	`1045`	`_ => {`
`1046`	`1046`	`diag.span_suggestion(`
Original file line number	Diff line number	Diff line change
`@@ -2088,7 +2088,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {`
`2088`	`2088`	`let ty = self.resolve_vars_if_possible(returned_ty);`
`2089`	`2089`	`if ty.references_error() {`
`2090`	`2090`	`// don't print out the [type error] here`
`2091`		`- err.delay_as_bug_without_consuming();`
	`2091`	`+ err.downgrade_to_delayed_bug();`
`2092`	`2092`	`} else {`
`2093`	`2093`	err.span_label(expr.span, format!("this returned value is of type `{ty}`"));
`2094`	`2094`	`}`