use an enum to distinguish builtin/overloaded pat adjusts

This makes the existing code a little less fragile, but it's also
future-proofing. In another PR, I plan on lowering deref patterns on
boxes to THIR `PatKind::Deref` rather than `PatKind::DerefPattern`,
which should allow moving out of them when matching (like how box
patterns are implemented). Having an enum means we can change just
`Ty::pat_adjust_kind` to handle this for implicit deref patterns, rather
than checking for `ty.is_ref() || ty.is_box()` everywhere we were
checking `ty.is_ref()`.

This could maybe be made a bit more robust by introducing a
`PatAdjustment` struct analogous to `ty::adjustment::Adjustment`, but I
think that'd probably be too heavy-weight for how this is used. If there
were more kinds of or subtleties to pattern adjustments, that might be
helpful, though.

I'm not totally sure this belongs in `rustc_middle::ty::adjustment`, but
the only other place I could think of it was `rustc_middle::ty::util`. I
think this placement makes enough sense to avoid putting more things in
`ty::util`, even if it's not a perfect fit.

Author: dianne

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -1734,21 +1734,22 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         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 = 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)?
+            place_with_id = match ref_ty.pat_adjust_kind() {
+                adjustment::PatAdjust::BuiltinDeref => self.cat_deref(pat.hir_id, place_with_id)?,
+                adjustment::PatAdjust::OverloadedDeref => {
+                    // 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.

compiler/rustc_hir_typeck/src/pat.rs

@@ -30,6 +30,7 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
 use tracing::{debug, instrument, trace};
 use ty::VariantDef;
+use ty::adjustment::PatAdjust;
 
 use super::report_unexpected_variant_res;
 use crate::expectation::Expectation;
@@ -439,7 +440,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // If we implicitly inserted overloaded dereferences before matching, check the pattern to
         // see if the dereferenced types need `DerefMut` bounds.
         if let Some(derefed_tys) = self.typeck_results.borrow().pat_adjustments().get(pat.hir_id)
-            && derefed_tys.iter().any(|ty| !ty.is_ref())
+            && derefed_tys.iter().any(|ty| ty.pat_adjust_kind() == PatAdjust::OverloadedDeref)
         {
             self.register_deref_mut_bounds_if_needed(
                 pat.span,

compiler/rustc_middle/src/ty/adjustment.rs

@@ -214,3 +214,23 @@ pub enum CustomCoerceUnsized {
     /// Records the index of the field being coerced.
     Struct(FieldIdx),
 }
+
+/// Represents implicit coercions of patterns' types, rather than values' types.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum PatAdjust {
+    /// An implicit dereference before matching, such as when matching the pattern `0` against a
+    /// scrutinee of type `&u8` or `&mut u8`.
+    // FIXME(deref_patterns): this can also be used for boxes to allow moving out of them
+    BuiltinDeref,
+    /// An implicit call to `Deref(Mut)::deref(_mut)` before matching, such as when matching the
+    /// pattern `[..]` against a scrutinee of type `Vec<T>`.
+    OverloadedDeref,
+}
+
+impl<'tcx> Ty<'tcx> {
+    /// Given an adjusted pattern type (see [`ty::typeck_results::TypeckResults::pat_adjustments`]),
+    /// determine what operation dereferences it, e.g. for building the pattern's THIR.
+    pub fn pat_adjust_kind(self) -> PatAdjust {
+        if self.is_ref() { PatAdjust::BuiltinDeref } else { PatAdjust::OverloadedDeref }
+    }
+}

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -17,6 +17,7 @@ use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
     Ascription, FieldPat, LocalVarId, Pat, PatKind, PatRange, PatRangeBoundary,
 };
+use rustc_middle::ty::adjustment::PatAdjust;
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
@@ -106,13 +107,14 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         let adjusted_pat = adjustments.iter().rev().fold(unadjusted_pat, |thir_pat, ref_ty| {
             debug!("{:?}: wrapping pattern with type {:?}", thir_pat, ref_ty);
             let span = thir_pat.span;
-            // TODO: use an enum to distinguish between builtin and overloaded derefs
-            let kind = if ref_ty.is_ref() {
-                PatKind::Deref { subpattern: thir_pat }
-            } else {
-                let mutable = self.typeck_results.pat_has_ref_mut_binding(pat);
-                let mutability = if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
-                PatKind::DerefPattern { subpattern: thir_pat, mutability }
+            let kind = match ref_ty.pat_adjust_kind() {
+                PatAdjust::BuiltinDeref => PatKind::Deref { subpattern: thir_pat },
+                PatAdjust::OverloadedDeref => {
+                    let mutable = self.typeck_results.pat_has_ref_mut_binding(pat);
+                    let mutability =
+                        if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
+                    PatKind::DerefPattern { subpattern: thir_pat, mutability }
+                }
             };
             Box::new(Pat { span, ty: *ref_ty, kind })
         });