upvar inference for implicit deref patterns

There's a bit of a hack here, which I don't love, but the other ways I
could think of doing this were substantially messier. I'll be saving
that for a separate commit to reduce the noise in this one. I also
haven't written that separate commit yet though, since I'm not convinced
the alternatives I've thought of are better than this. Please let me
know if one of these (or better yet, something else) sounds good:

- The callback argument to `cat_pattern` could take a
`PatOrAdjust<'hir>` enum instead of a `Pat<'hir>`, which would
correspond either to a (potentially scrutinee-borrowing) pattern or a
(currently definitely scrutinee-borrowing) implicit overloaded deref.
Matching on `PatOrAdjust` is really noisy, unfortunately, and would
require a separate `cat_pattern_unadjusted` helper that bypasses it to
avoid reindenting `maybe_read_scrutinee`.

- `cat_pattern` could invoke the delegate's `borrow` callback directly.
This results in some repeated work between `walk_pat` and
`maybe_read_scrutinee` for refutable patterns (but hopefully that
wouldn't have correctness implications..?). `cat_pattern` would also
need to take the `HirId` of the top-level scrutinee expression as an
argument for use in diagnostics.

Author: dianne

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -999,6 +999,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     // determines whether to borrow *at the level of the deref pattern* rather than
                     // borrowing the bound place (since that inner place is inside the temporary that
                     // stores the result of calling `deref()`/`deref_mut()` so can't be captured).
+                    // HACK: this could be a fake pattern corresponding to a deref inserted by match
+                    // ergonomics, in which case `pat.hir_id` will be the id of the subpattern.
                     let mutable = self.cx.typeck_results().pat_has_ref_mut_binding(subpattern);
                     let mutability =
                         if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
@@ -1674,12 +1676,30 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         // Then we see that to get the same result, we must start with
         // `deref { deref { place_foo }}` instead of `place_foo` since the pattern is now `Some(x,)`
         // and not `&&Some(x,)`, even though its assigned type is that of `&&Some(x,)`.
-        for _ in
-            0..self.cx.typeck_results().pat_adjustments().get(pat.hir_id).map_or(0, |v| v.len())
-        {
+        let typeck_results = self.cx.typeck_results();
+        let adjustments: &[Ty<'tcx>] =
+            typeck_results.pat_adjustments().get(pat.hir_id).map_or(&[], |v| &**v);
+        let mut ref_tys = adjustments.iter().peekable();
+        while let Some(ref_ty) = ref_tys.next() {
             debug!("applying adjustment to place_with_id={:?}", place_with_id);
-            place_with_id = self.cat_deref(pat.hir_id, place_with_id)?;
+            place_with_id = if ref_ty.is_ref() {
+                self.cat_deref(pat.hir_id, place_with_id)?
+            } else {
+                // This adjustment corresponds to an overloaded deref; it borrows the scrutinee to
+                // call `Deref::deref` or `DerefMut::deref_mut`. Invoke the callback before setting
+                // `place_with_id` to the temporary storing the result of the deref.
+                // HACK(dianne): giving the callback a fake deref pattern makes sure it behaves the
+                // same as it would if this were an explicit deref pattern.
+                op(&place_with_id, &hir::Pat { kind: PatKind::Deref(pat), ..*pat })?;
+                let target_ty = match ref_tys.peek() {
+                    Some(&&target_ty) => target_ty,
+                    // At the end of the deref chain, we get `pat`'s scrutinee.
+                    None => self.pat_ty_unadjusted(pat)?,
+                };
+                self.pat_deref_temp(pat.hir_id, pat, target_ty)?
+            };
         }
+        drop(typeck_results); // explicitly release borrow of typeck results, just in case.
         let place_with_id = place_with_id; // lose mutability
         debug!("applied adjustment derefs to get place_with_id={:?}", place_with_id);
 
@@ -1782,14 +1802,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 self.cat_pattern(subplace, subpat, op)?;
             }
             PatKind::Deref(subpat) => {
-                let mutable = self.cx.typeck_results().pat_has_ref_mut_binding(subpat);
-                let mutability = if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
-                let re_erased = self.cx.tcx().lifetimes.re_erased;
                 let ty = self.pat_ty_adjusted(subpat)?;
-                let ty = Ty::new_ref(self.cx.tcx(), re_erased, ty, mutability);
-                // A deref pattern generates a temporary.
-                let base = self.cat_rvalue(pat.hir_id, ty);
-                let place = self.cat_deref(pat.hir_id, base)?;
+                let place = self.pat_deref_temp(pat.hir_id, subpat, ty)?;
                 self.cat_pattern(place, subpat, op)?;
             }
 
@@ -1841,6 +1855,23 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         Ok(())
     }
 
+    /// Represents the place of the temp that stores the scrutinee of a deref pattern's interior.
+    fn pat_deref_temp(
+        &self,
+        hir_id: HirId,
+        inner: &hir::Pat<'_>,
+        target_ty: Ty<'tcx>,
+    ) -> Result<PlaceWithHirId<'tcx>, Cx::Error> {
+        let mutable = self.cx.typeck_results().pat_has_ref_mut_binding(inner);
+        let mutability = if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
+        let re_erased = self.cx.tcx().lifetimes.re_erased;
+        let ty = Ty::new_ref(self.cx.tcx(), re_erased, target_ty, mutability);
+        // A deref pattern stores the result of `Deref::deref` or `DerefMut::deref_mut` ...
+        let base = self.cat_rvalue(hir_id, ty);
+        // ... and the inner pattern matches on the place behind that reference.
+        self.cat_deref(hir_id, base)
+    }
+
     fn is_multivariant_adt(&self, ty: Ty<'tcx>, span: Span) -> bool {
         if let ty::Adt(def, _) = self.cx.try_structurally_resolve_type(span, ty).kind() {
             // Note that if a non-exhaustive SingleVariant is defined in another crate, we need

tests/ui/pattern/deref-patterns/closure_capture.rs

@@ -11,11 +11,38 @@ fn main() {
     assert_eq!(b.len(), 3);
     f();
 
+    let v = vec![1, 2, 3];
+    let f = || {
+        // this should count as a borrow of `v` as a whole
+        let [.., x] = v else { unreachable!() };
+        assert_eq!(x, 3);
+    };
+    assert_eq!(v, [1, 2, 3]);
+    f();
+
     let mut b = Box::new("aaa".to_string());
     let mut f = || {
         let deref!(ref mut s) = b else { unreachable!() };
         s.push_str("aa");
     };
     f();
     assert_eq!(b.len(), 5);
+
+    let mut v = vec![1, 2, 3];
+    let mut f = || {
+        // this should count as a mutable borrow of `v` as a whole
+        let [.., ref mut x] = v else { unreachable!() };
+        *x = 4;
+    };
+    f();
+    assert_eq!(v, [1, 2, 4]);
+
+    let mut v = vec![1, 2, 3];
+    let mut f = || {
+        // here, `[.., x]` is adjusted by both an overloaded deref and a builtin deref
+        let [.., x] = &mut v else { unreachable!() };
+        *x = 4;
+    };
+    f();
+    assert_eq!(v, [1, 2, 4]);
 }