why fail?

Author: AndyJado

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -151,28 +151,29 @@ impl<'tcx> BorrowExplanation<'tcx> {
                         }
                     }
                 }
-                let (dtor_desc, type_desc) = match ty.kind() {
+                let (dtor_code, type_code, type_desc) = match ty.kind() {
                     // If type is an ADT that implements Drop, then
                     // simplify output by reporting just the ADT name.
                     ty::Adt(adt, _substs) if adt.has_dtor(tcx) && !adt.is_box() => {
-                        ("`Drop` code", format!("type `{}`", tcx.def_path_str(adt.did())))
+                        (0, 0, format!(" `{}`", tcx.def_path_str(adt.did()).to_string()))
                     }
 
                     // Otherwise, just report the whole type (and use
                     // the intentionally fuzzy phrase "destructor")
-                    ty::Closure(..) => ("destructor", "closure".to_owned()),
-                    ty::Generator(..) => ("destructor", "generator".to_owned()),
+                    ty::Closure(..) => (1, 1, "".to_owned()),
+                    ty::Generator(..) => (1, 2, "".to_owned()),
 
-                    _ => ("destructor", format!("type `{}`", local_decl.ty)),
+                    _ => (1, 0, format!(" `{}`", local_decl.ty.to_string())),
                 };
 
                 match local_names[dropped_local] {
                     Some(local_name) if !local_decl.from_compiler_desugaring() => {
                         err.subdiagnostic(UsedLaterDropped::UsedHere {
                             borrow_desc: br_desc,
                             local_name,
-                            type_desc: &type_desc,
-                            dtor_desc,
+                            type_desc,
+                            type_code,
+                            dtor_code,
                             span: body.source_info(drop_loc).span,
                         });
                         if should_note_order {
@@ -186,8 +187,9 @@ impl<'tcx> BorrowExplanation<'tcx> {
                         });
                         err.subdiagnostic(UsedLaterDropped::MightUsedHere {
                             borrow_desc: br_desc,
-                            type_desc: &type_desc,
-                            dtor_desc,
+                            type_desc,
+                            type_code,
+                            dtor_code,
                             span: body.source_info(drop_loc).span,
                         });
                         if let Some(info) = &local_decl.is_block_tail {

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -189,8 +189,9 @@ pub(crate) enum UsedLaterDropped<'a> {
     UsedHere {
         borrow_desc: &'a str,
         local_name: Symbol,
-        type_desc: &'a str,
-        dtor_desc: &'a str,
+        dtor_code: u8,
+        type_code: u8,
+        type_desc: String,
         #[primary_span]
         span: Span,
     },
@@ -205,8 +206,9 @@ pub(crate) enum UsedLaterDropped<'a> {
     #[label(borrowck::drop_temporary_might_cause_borrow_use)]
     MightUsedHere {
         borrow_desc: &'a str,
-        type_desc: &'a str,
-        dtor_desc: &'a str,
+        dtor_code: u8,
+        type_code: u8,
+        type_desc: String,
         #[primary_span]
         span: Span,
     },

compiler/rustc_error_messages/locales/en-US/borrowck.ftl

@@ -92,7 +92,14 @@ borrowck_drop_local_might_cause_borrow =
         [immutable] immutable {""}
         [first] first {""}
         *[other] {""}
-    }borrow might be used here, when `{$local_name}` is dropped and runs the {$dtor_desc} for {$type_desc}
+    }borrow might be used here, when `{$local_name}` is dropped and runs the {$dtor_code ->
+        [0] `Drop` code
+        *[1] destructor
+    } for {$type_code ->
+        [1] closure
+        [2] generator
+        *[0] type
+    }{$type_desc}
 
 borrowck_var_dropped_in_wrong_order =
     values in a scope are dropped in the opposite order they are defined
@@ -110,7 +117,14 @@ borrowck_drop_temporary_might_cause_borrow_use = ... and the {$borrow_desc ->
         [immutable] immutable {""}
         [first] first {""}
         *[other] {""}
-    }borrow might be used here, when that temporary is dropped and runs the {$dtor_desc} for {$type_desc}
+    }borrow might be used here, when that temporary is dropped and runs the {$dtor_code ->
+        [0] `Drop` code
+        *[1] destructor
+    } for {$type_code ->
+        [1] closure
+        [2] generator
+        *[0] type
+    }{$type_desc}
 
 borrowck_consider_add_semicolon =
     consider adding semicolon after the expression so its temporaries are dropped sooner, before the local variables declared by the block are dropped