apply comment/naming suggestions

Author: dianne

Diff for: compiler/rustc_hir_typeck/src/pat.rs

@@ -176,17 +176,19 @@ enum AdjustMode<'tcx> {
 /// Restrictions on what types to peel when adjusting the expected type and binding mode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum PeelKind<'tcx> {
-    /// Only peel reference types. This is used for explicit deref patterns.
-    RefOnly,
-    /// If `deref_patterns` is enabled, this also peels library-defined smart pointer ADTs, except
-    /// for `until_adt` if the pattern is a constructor. Otherwise this is the same as `RefOnly`.
-    /// See [`ResolvedPat`] for more information.
-    Overloaded { until_adt: Option<AdtDef<'tcx>> },
+    /// Only peel reference types. This is used for explicit `deref!(_)` patterns, which dereference
+    /// any number of `&`/`&mut` references, plus a single smart pointer.
+    ExplicitDerefPat,
+    /// Implicitly peel any number of references, and if `deref_patterns` is enabled, smart pointer
+    /// ADTs. In order to peel only as much as necessary for the pattern to match, the `until_adt`
+    /// field contains the ADT def that the pattern is a constructor for, if applicable, so that we
+    /// don't peel it. See [`ResolvedPat`] for more information.
+    Implicit { until_adt: Option<AdtDef<'tcx>> },
 }
 
 impl<'tcx> AdjustMode<'tcx> {
     const fn peel_until_adt(opt_adt_def: Option<AdtDef<'tcx>>) -> AdjustMode<'tcx> {
-        AdjustMode::Peel { kind: PeelKind::Overloaded { until_adt: opt_adt_def } }
+        AdjustMode::Peel { kind: PeelKind::Implicit { until_adt: opt_adt_def } }
     }
     const fn peel_all() -> AdjustMode<'tcx> {
         AdjustMode::peel_until_adt(None)
@@ -585,7 +587,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // FIXME(deref_patterns): If box patterns and deref patterns need to coexist, box
             // patterns may want `PeelKind::Overloaded`, stopping on encountering a box.
             | PatKind::Box(_)
-            | PatKind::Deref(_) => AdjustMode::Peel { kind: PeelKind::RefOnly },
+            | PatKind::Deref(_) => AdjustMode::Peel { kind: PeelKind::ExplicitDerefPat },
             // A never pattern behaves somewhat like a literal or unit variant.
             PatKind::Never => AdjustMode::peel_all(),
             // For patterns with paths, how we peel the scrutinee depends on the path's resolution.
@@ -651,7 +653,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         //
         // For each ampersand peeled off, update the binding mode and push the original
         // type into the adjustments vector.
-        // When peeling a library-defined type, the default binding mode is not updated.
+        // When peeling a smart pointer, the default binding mode is not updated.
         //
         // See the examples in `tests/ui/rfcs/rfc-2005-default-binding-mode/` and
         // `tests/ui/pattern/deref-patterns/`.
@@ -670,7 +672,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 });
                 inner_ty
             } else if deref_patterns
-                && let PeelKind::Overloaded { until_adt } = peel_kind
+                && let PeelKind::Implicit { until_adt } = peel_kind
                 // For simplicity, only apply overloaded derefs if `expected` is a known ADT.
                 // FIXME(deref_patterns): we'll get better diagnostics for users trying to
                 // implicitly deref generics if we allow them here, but primitives, tuples, and

Diff for: compiler/rustc_mir_build/src/thir/pattern/migration.rs

@@ -86,14 +86,16 @@ impl<'a> PatMigration<'a> {
     }
 
     /// Tracks when we're lowering a pattern that implicitly dereferences the scrutinee.
-    /// This should only be called when the pattern type adjustments list `adjustments` is
-    /// non-empty. Returns the prior default binding mode; this should be followed by a call to
-    /// [`PatMigration::leave_ref`] to restore it when we leave the pattern.
+    /// This should only be called when the pattern type adjustments list `adjustments` contains an
+    /// implicit deref of a reference type. Returns the prior default binding mode; this should be
+    /// followed by a call to [`PatMigration::leave_ref`] to restore it when we leave the pattern.
     pub(super) fn visit_implicit_derefs<'tcx>(
         &mut self,
         pat_span: Span,
         adjustments: &[Ty<'tcx>],
     ) -> Option<(Span, Mutability)> {
+        // Implicitly dereferencing references changes the default binding mode, but implicit derefs
+        // of smart pointers do not. Thus, we only consider implicit derefs of reference types.
         let implicit_deref_mutbls = adjustments.iter().filter_map(|ref_ty| {
             if let &ty::Ref(_, _, mutbl) = ref_ty.kind() { Some(mutbl) } else { None }
         });