track never type fallback specifically

the only diagnostic that was using this field specifically сares for the
never type fallback, not the integer fallback.

Author: WaffleLapkin

compiler/rustc_hir_typeck/src/fallback.rs

@@ -31,8 +31,8 @@ pub(crate) enum DivergingFallbackBehavior {
 }
 
 impl<'tcx> FnCtxt<'_, 'tcx> {
-    /// Performs type inference fallback, setting `FnCtxt::fallback_has_occurred`
-    /// if fallback has occurred.
+    /// Performs type inference fallback, setting [`FnCtxt::diverging_fallback_has_occurred`]
+    /// if the never type fallback has occurred.
     pub(super) fn type_inference_fallback(&self) {
         debug!(
             "type-inference-fallback start obligations: {:#?}",
@@ -115,8 +115,8 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
     /// Fallback becomes very dubious if we have encountered
     /// type-checking errors. In that case, fallback to Error.
     ///
-    /// Sets [`FnCtxt::fallback_has_occurred`] if fallback is performed
-    /// during this call.
+    /// Sets [`FnCtxt::diverging_fallback_has_occurred`] if never type fallback
+    /// is performed during this call.
     fn fallback_if_possible(
         &self,
         ty: Ty<'tcx>,
@@ -145,15 +145,17 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
             ty::Infer(ty::IntVar(_)) => self.tcx.types.i32,
             ty::Infer(ty::FloatVar(_)) => self.tcx.types.f64,
             _ => match diverging_fallback.get(&ty) {
-                Some(&fallback_ty) => fallback_ty,
+                Some(&fallback_ty) => {
+                    self.diverging_fallback_has_occurred.set(true);
+                    fallback_ty
+                }
                 None => return false,
             },
         };
         debug!("fallback_if_possible(ty={:?}): defaulting to `{:?}`", ty, fallback);
 
         let span = ty.ty_vid().map_or(DUMMY_SP, |vid| self.infcx.type_var_origin(vid).span);
         self.demand_eqtype(span, ty, fallback);
-        self.fallback_has_occurred.set(true);
         true
     }
 

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -115,7 +115,9 @@ pub(crate) struct FnCtxt<'a, 'tcx> {
 
     pub(super) root_ctxt: &'a TypeckRootCtxt<'tcx>,
 
-    pub(super) fallback_has_occurred: Cell<bool>,
+    /// True if a divirging inference variable has been set to `()`/`!` because
+    /// of never type fallback. This is only used for diagnostics.
+    pub(super) diverging_fallback_has_occurred: Cell<bool>,
 
     pub(super) diverging_fallback_behavior: DivergingFallbackBehavior,
     pub(super) diverging_block_behavior: DivergingBlockBehavior,
@@ -153,7 +155,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 by_id: Default::default(),
             }),
             root_ctxt,
-            fallback_has_occurred: Cell::new(false),
+            diverging_fallback_has_occurred: Cell::new(false),
             diverging_fallback_behavior,
             diverging_block_behavior,
             trait_ascriptions: Default::default(),
@@ -190,7 +192,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         TypeErrCtxt {
             infcx: &self.infcx,
             typeck_results: Some(self.typeck_results.borrow()),
-            fallback_has_occurred: self.fallback_has_occurred.get(),
+            diverging_fallback_has_occurred: self.diverging_fallback_has_occurred.get(),
             normalize_fn_sig: Box::new(|fn_sig| {
                 if fn_sig.has_escaping_bound_vars() {
                     return fn_sig;

compiler/rustc_trait_selection/src/error_reporting/mod.rs

@@ -21,7 +21,7 @@ pub struct TypeErrCtxt<'a, 'tcx> {
     pub infcx: &'a InferCtxt<'tcx>,
 
     pub typeck_results: Option<std::cell::Ref<'a, ty::TypeckResults<'tcx>>>,
-    pub fallback_has_occurred: bool,
+    pub diverging_fallback_has_occurred: bool,
 
     pub normalize_fn_sig: Box<dyn Fn(ty::PolyFnSig<'tcx>) -> ty::PolyFnSig<'tcx> + 'a>,
 
@@ -36,7 +36,7 @@ impl<'tcx> InferCtxt<'tcx> {
         TypeErrCtxt {
             infcx: self,
             typeck_results: None,
-            fallback_has_occurred: false,
+            diverging_fallback_has_occurred: false,
             normalize_fn_sig: Box::new(|fn_sig| fn_sig),
             autoderef_steps: Box::new(|ty| {
                 debug_assert!(false, "shouldn't be using autoderef_steps outside of typeck");

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -541,7 +541,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         // variable that used to fallback to `()` now falling back to `!`. Issue a
                         // note informing about the change in behaviour.
                         if leaf_trait_predicate.skip_binder().self_ty().is_never()
-                            && self.fallback_has_occurred
+                            && self.diverging_fallback_has_occurred
                         {
                             let predicate = leaf_trait_predicate.map_bound(|trait_pred| {
                                 trait_pred.with_replaced_self_ty(self.tcx, tcx.types.unit)