From 9cf0ff26f82937a20d60a115cfb331e3f7a8c2d3 Mon Sep 17 00:00:00 2001
From: Giacomo Pasini <giacomo@status.im>
Date: Thu, 16 Feb 2023 23:14:04 +0100
Subject: use helper function for error reporting

---
 .../src/diagnostics/conflict_errors.rs             | 26 ++++++++++++++++++++++
 compiler/rustc_borrowck/src/lib.rs                 | 20 +++--------------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index cb97699d7d2..a622a215a2e 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1467,6 +1467,32 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
     /// Reports StorageDeadOrDrop of `place` conflicts with `borrow`.
     ///
+    /// Depending on the origin of the StorageDeadOrDrop, this may be
+    /// reported as either a drop or an illegal mutation of a borrowed value.
+    /// The latter is preferred when the this is a drop triggered by a
+    /// reassignment, as it's more user friendly to report a problem with the
+    /// explicit assignment than the implicit drop.
+    #[instrument(level = "debug", skip(self))]
+    pub(crate) fn report_storage_dead_or_drop_of_borrowed(
+        &mut self,
+        location: Location,
+        place_span: (Place<'tcx>, Span),
+        borrow: &BorrowData<'tcx>,
+    ) {
+        // It's sufficient to check the last desugaring as Replace is the last
+        // one to be applied.
+        if let Some(DesugaringKind::Replace) = place_span.1.desugaring_kind() {
+            self.report_illegal_mutation_of_borrowed(location, place_span, borrow)
+        } else {
+            self.report_borrowed_value_does_not_live_long_enough(
+                location,
+                borrow,
+                place_span,
+                Some(WriteKind::StorageDeadOrDrop),
+            )
+        }
+    }
+
     /// This means that some data referenced by `borrow` needs to live
     /// past the point where the StorageDeadOrDrop of `place` occurs.
     /// This is usually interpreted as meaning that `place` has too
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 11a746ffb0a..115e512a974 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -40,7 +40,7 @@ use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{self, CapturedPlace, ParamEnv, RegionVid, TyCtxt};
 use rustc_session::lint::builtin::UNUSED_MUT;
-use rustc_span::{DesugaringKind, Span, Symbol};
+use rustc_span::{Span, Symbol};
 
 use either::Either;
 use smallvec::SmallVec;
@@ -1184,22 +1184,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                                 this.report_conflicting_borrow(location, place_span, bk, borrow);
                             this.buffer_error(err);
                         }
-                        WriteKind::StorageDeadOrDrop => {
-                            if let Some(DesugaringKind::Replace) = place_span.1.desugaring_kind() {
-                                // If this is a drop triggered by a reassignment, it's more user friendly
-                                // to report a problem with the explicit assignment than the implicit drop.
-                                this.report_illegal_mutation_of_borrowed(
-                                    location, place_span, borrow,
-                                )
-                            } else {
-                                this.report_borrowed_value_does_not_live_long_enough(
-                                    location,
-                                    borrow,
-                                    place_span,
-                                    Some(kind),
-                                )
-                            }
-                        }
+                        WriteKind::StorageDeadOrDrop => this
+                            .report_storage_dead_or_drop_of_borrowed(location, place_span, borrow),
                         WriteKind::Mutate => {
                             this.report_illegal_mutation_of_borrowed(location, place_span, borrow)
                         }
-- 
cgit 1.4.1-3-g733a5