Auto merge of #142973 - compiler-errors:quick-coerce-2, r=<try>

[perf] Fast path for coercions of TY == TY

Author: bors

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -780,8 +780,10 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                     } else {
                         LaterUseKind::FakeLetRead
                     }
-                } else if self.was_captured_by_trait_object(borrow) {
-                    LaterUseKind::TraitCapture
+                } else if let Some(unsize_span) = self.was_captured_by_trait_object(borrow) {
+                    // We drilled down the span to the actual location of the unsize, rather
+                    // than the location of the borrow.
+                    return (LaterUseKind::TraitCapture, unsize_span, None);
                 } else if location.statement_index == block.statements.len() {
                     if let TerminatorKind::Call { func, call_source: CallSource::Normal, .. } =
                         &block.terminator().kind
@@ -818,7 +820,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
     /// Checks if a borrowed value was captured by a trait object. We do this by
     /// looking forward in the MIR from the reserve location and checking if we see
     /// an unsized cast to a trait object on our data.
-    fn was_captured_by_trait_object(&self, borrow: &BorrowData<'tcx>) -> bool {
+    fn was_captured_by_trait_object(&self, borrow: &BorrowData<'tcx>) -> Option<Span> {
         // Start at the reserve location, find the place that we want to see cast to a trait object.
         let location = borrow.reserve_location;
         let block = &self.body[location.block];
@@ -834,10 +836,10 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                 if let Some(local) = place.as_local() {
                     local
                 } else {
-                    return false;
+                    return None;
                 }
             } else {
-                return false;
+                return None;
             };
 
         debug!("was_captured_by_trait: target={:?} queue={:?}", target, queue);
@@ -884,7 +886,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                                         if from == target {
                                             debug!("was_captured_by_trait_object: ty={:?}", ty);
                                             // Check the type for a trait object.
-                                            return match ty.kind() {
+                                            let matches = match ty.kind() {
                                                 // `&dyn Trait`
                                                 ty::Ref(_, ty, _) if ty.is_trait() => true,
                                                 // `Box<dyn Trait>`
@@ -897,11 +899,16 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                                                 // Anything else.
                                                 _ => false,
                                             };
+                                            if matches {
+                                                return Some(stmt.source_info.span);
+                                            } else {
+                                                return None;
+                                            }
                                         }
                                     }
-                                    return false;
+                                    return None;
                                 }
-                                _ => return false,
+                                _ => return None,
                             }
                         }
                         _ => {}
@@ -925,7 +932,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
                         );
                         // Check if one of the arguments to this function is the target place.
                         let found_target = args.iter().any(|arg| {
-                            if let Operand::Move(place) = arg.node {
+                            if let Operand::Move(place) | Operand::Copy(place) = arg.node {
                                 if let Some(potential) = place.as_local() {
                                     potential == target
                                 } else {
@@ -949,6 +956,6 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
         }
 
         // We didn't find anything and ran out of locations to check.
-        false
+        None
     }
 }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -205,6 +205,30 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             return self.coerce_from_inference_variable(a, b);
         }
 
+        // No coercion needed; types are identical. The only exception is when we have
+        // a mutable reference, which needs a pair of reborrow adjustments inserted.
+        if a == b {
+            if let ty::Ref(_, pointee, ty::Mutability::Mut) = *a.kind() {
+                return Ok(InferOk {
+                    value: (
+                        vec![
+                            Adjustment { kind: Adjust::Deref(None), target: pointee },
+                            Adjustment {
+                                kind: Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::Mut {
+                                    allow_two_phase_borrow: AllowTwoPhase::No,
+                                })),
+                                target: a,
+                            },
+                        ],
+                        a,
+                    ),
+                    obligations: Default::default(),
+                });
+            } else {
+                return Ok(InferOk { value: (vec![], a), obligations: Default::default() });
+            }
+        }
+
         // Consider coercing the subtype to a DST
         //
         // NOTE: this is wrapped in a `commit_if_ok` because it creates

tests/ui/span/regions-close-over-type-parameter-2.stderr

@@ -6,7 +6,6 @@ LL |         let tmp0 = 3;
 LL |         let tmp1 = &tmp0;
    |                    ^^^^^ borrowed value does not live long enough
 LL |         repeater3(tmp1)
-   |         --------------- borrow later captured here by trait object
 LL |     };
    |     - `tmp0` dropped here while still borrowed