pattern typing for immutable implicit deref patterns

Author: dianne

compiler/rustc_hir_typeck/src/pat.rs

@@ -161,15 +161,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// Mode for adjusting the expected type and binding mode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum AdjustMode {
-    /// Peel off all immediate reference types.
-    Peel,
+    /// Peel off all immediate reference types. If the `deref_patterns` feature is enabled, this
+    /// also peels library-defined smart pointer ADTs.
+    Peel { kind: PeelKind },
     /// Reset binding mode to the initial mode.
     /// Used for destructuring assignment, where we don't want any match ergonomics.
     Reset,
     /// Pass on the input binding mode and expected type.
     Pass,
 }
 
+/// Restrictions on what types to peel when adjusting the expected type and binding mode.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum PeelKind {
+    /// 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.
+    // TODO: add `ResolvedPat` and `until_adt`.
+    Overloaded,
+}
+
 /// `ref mut` bindings (explicit or match-ergonomics) are not allowed behind an `&` reference.
 /// Normally, the borrow checker enforces this, but for (currently experimental) match ergonomics,
 /// we track this when typing patterns for two purposes:
@@ -457,7 +470,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match adjust_mode {
             AdjustMode::Pass => (expected, def_br, max_ref_mutbl),
             AdjustMode::Reset => (expected, ByRef::No, MutblCap::Mut),
-            AdjustMode::Peel => self.peel_off_references(pat, expected, def_br, max_ref_mutbl),
+            AdjustMode::Peel { kind } => {
+                self.peel_off_references(pat, kind, expected, def_br, max_ref_mutbl)
+            }
         }
     }
 
@@ -476,12 +491,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             PatKind::Struct(..)
             | PatKind::TupleStruct(..)
             | PatKind::Tuple(..)
-            | PatKind::Box(_)
-            | PatKind::Deref(_)
             | PatKind::Range(..)
-            | PatKind::Slice(..) => AdjustMode::Peel,
+            | PatKind::Slice(..) => AdjustMode::Peel { kind: PeelKind::Overloaded },
+            // When checking an explicit deref pattern, only peel reference types.
+            // 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 },
             // A never pattern behaves somewhat like a literal or unit variant.
-            PatKind::Never => AdjustMode::Peel,
+            PatKind::Never => AdjustMode::Peel { kind: PeelKind::Overloaded },
             PatKind::Expr(PatExpr { kind: PatExprKind::Path(_), .. }) => match opt_path_res.unwrap() {
                 // These constants can be of a reference type, e.g. `const X: &u8 = &0;`.
                 // Peeling the reference types too early will cause type checking failures.
@@ -491,7 +509,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // could successfully compile. The former being `Self` requires a unit struct.
                 // In either case, and unlike constants, the pattern itself cannot be
                 // a reference type wherefore peeling doesn't give up any expressiveness.
-                _ => AdjustMode::Peel,
+                _ => AdjustMode::Peel { kind: PeelKind::Overloaded },
             },
 
             // String and byte-string literals result in types `&str` and `&[u8]` respectively.
@@ -501,7 +519,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Call `resolve_vars_if_possible` here for inline const blocks.
             PatKind::Expr(lt) => match self.resolve_vars_if_possible(self.check_pat_expr_unadjusted(lt)).kind() {
                 ty::Ref(..) => AdjustMode::Pass,
-                _ => AdjustMode::Peel,
+                _ => AdjustMode::Peel { kind: PeelKind::Overloaded },
             },
 
             // Ref patterns are complicated, we handle them in `check_pat_ref`.
@@ -526,42 +544,83 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Peel off as many immediately nested `& mut?` from the expected type as possible
     /// and return the new expected type and binding default binding mode.
+    /// If the `deref_patterns` feature is enabled, also peel library-defined pointer-like types.
     /// The adjustments vector, if non-empty is stored in a table.
     fn peel_off_references(
         &self,
         pat: &'tcx Pat<'tcx>,
+        peel_kind: PeelKind,
         expected: Ty<'tcx>,
         mut def_br: ByRef,
         mut max_ref_mutbl: MutblCap,
     ) -> (Ty<'tcx>, ByRef, MutblCap) {
+        let deref_patterns = self.tcx.features().deref_patterns();
         let mut expected = self.try_structurally_resolve_type(pat.span, expected);
         // Peel off as many `&` or `&mut` from the scrutinee type as possible. For example,
         // for `match &&&mut Some(5)` the loop runs three times, aborting when it reaches
         // the `Some(5)` which is not of type Ref.
         //
         // 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.
         //
-        // See the examples in `ui/match-defbm*.rs`.
+        // See the examples in `tests/ui/rfcs/rfc-2005-default-binding-mode/` and
+        // `tests/ui/pattern/deref-patterns/`.
         let mut pat_adjustments = vec![];
-        while let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind() {
-            debug!("inspecting {:?}", expected);
+        loop {
+            // TODO: check # of iterations against tcx's recursion limit, so we don't loop until OOM
+            // if someone tries matching on a type with a cyclic `Deref` impl.
+            let inner_ty = if let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind() {
+                def_br = ByRef::Yes(match def_br {
+                    // If default binding mode is by value, make it `ref` or `ref mut`
+                    // (depending on whether we observe `&` or `&mut`).
+                    ByRef::No |
+                    // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`).
+                    ByRef::Yes(Mutability::Mut) => inner_mutability,
+                    // Once a `ref`, always a `ref`.
+                    // This is because a `& &mut` cannot mutate the underlying value.
+                    ByRef::Yes(Mutability::Not) => Mutability::Not,
+                });
+                inner_ty
+            } else if deref_patterns
+                && peel_kind == PeelKind::Overloaded
+                // 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
+                // inference vars definitely should be stopped. Figure out what makes most sense.
+                // TODO: stop peeling if the pattern is a constructor for the scrutinee type
+                && expected.is_adt()
+            {
+                // At this point, the pattern isn't able to match `expected` without peeling. Check
+                // that it implements `Deref` before assuming it's a smart pointer, to get a normal
+                // type error instead of a missing impl error if not. This only checks for `Deref`,
+                // not `DerefPure`: we require that too, but we want a trait error if it's missing.
+                if let Some(deref_trait) = self.tcx.lang_items().deref_trait()
+                    && self
+                        .type_implements_trait(deref_trait, [expected], self.param_env)
+                        .may_apply()
+                {
+                    // The scrutinee is a smart pointer; implicitly dereference it. This adds a
+                    // requirement that `expected: DerefPure`.
+                    self.deref_pat_target(pat.span, expected)
+                    // Once we've checked `pat`, we'll add a `DerefMut` bound if it contains any
+                    // `ref mut` bindings. TODO: implement that, then reference here.
+                } else {
+                    // Bail, so we get a normal type error.
+                    break;
+                }
+            } else {
+                // The scrutinee is a non-reference type and either `deref_patterns` isn't enabled
+                // or `pat` could possibly already match it; stop implicitly dereferencing.
+                break;
+            };
 
-            debug!("current discriminant is Ref, inserting implicit deref");
+            debug!("inspecting {:?}", expected);
+            debug!("current discriminant can be dereferenced, inserting implicit deref");
             // Preserve the reference type. We'll need it later during THIR lowering.
             pat_adjustments.push(expected);
 
             expected = self.try_structurally_resolve_type(pat.span, inner_ty);
-            def_br = ByRef::Yes(match def_br {
-                // If default binding mode is by value, make it `ref` or `ref mut`
-                // (depending on whether we observe `&` or `&mut`).
-                ByRef::No |
-                // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`).
-                ByRef::Yes(Mutability::Mut) => inner_mutability,
-                // Once a `ref`, always a `ref`.
-                // This is because a `& &mut` cannot mutate the underlying value.
-                ByRef::Yes(Mutability::Not) => Mutability::Not,
-            });
         }
 
         if self.downgrade_mut_inside_shared() {
@@ -2287,38 +2346,43 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected: Ty<'tcx>,
         pat_info: PatInfo<'tcx>,
     ) -> Ty<'tcx> {
-        let tcx = self.tcx;
-        // Register a `DerefPure` bound, which is required by all `deref!()` pats.
-        self.register_bound(
-            expected,
-            tcx.require_lang_item(hir::LangItem::DerefPure, Some(span)),
-            self.misc(span),
-        );
-        // <expected as Deref>::Target
-        let ty = Ty::new_projection(
-            tcx,
-            tcx.require_lang_item(hir::LangItem::DerefTarget, Some(span)),
-            [expected],
-        );
-        let ty = self.normalize(span, ty);
-        let ty = self.try_structurally_resolve_type(span, ty);
-        self.check_pat(inner, ty, pat_info);
+        let target_ty = self.deref_pat_target(span, expected);
+        self.check_pat(inner, target_ty, pat_info);
 
         // Check if the pattern has any `ref mut` bindings, which would require
         // `DerefMut` to be emitted in MIR building instead of just `Deref`.
         // We do this *after* checking the inner pattern, since we want to make
         // sure to apply any match-ergonomics adjustments.
+        // TODO: move this to a separate definition to share it with implicit deref pats
         if self.typeck_results.borrow().pat_has_ref_mut_binding(inner) {
             self.register_bound(
                 expected,
-                tcx.require_lang_item(hir::LangItem::DerefMut, Some(span)),
+                self.tcx.require_lang_item(hir::LangItem::DerefMut, Some(span)),
                 self.misc(span),
             );
         }
 
         expected
     }
 
+    fn deref_pat_target(&self, span: Span, source_ty: Ty<'tcx>) -> Ty<'tcx> {
+        // Register a `DerefPure` bound, which is required by all `deref!()` pats.
+        let tcx = self.tcx;
+        self.register_bound(
+            source_ty,
+            tcx.require_lang_item(hir::LangItem::DerefPure, Some(span)),
+            self.misc(span),
+        );
+        // The expected type for the deref pat's inner pattern is `<expected as Deref>::Target`.
+        let target_ty = Ty::new_projection(
+            tcx,
+            tcx.require_lang_item(hir::LangItem::DerefTarget, Some(span)),
+            [source_ty],
+        );
+        let target_ty = self.normalize(span, target_ty);
+        self.try_structurally_resolve_type(span, target_ty)
+    }
+
     // Precondition: Pat is Ref(inner)
     fn check_pat_ref(
         &self,

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

@@ -1,7 +1,9 @@
+//@ revisions: explicit implicit
 //@ run-pass
 #![feature(deref_patterns)]
 #![allow(incomplete_features)]
 
+#[cfg(explicit)]
 fn simple_vec(vec: Vec<u32>) -> u32 {
     match vec {
         deref!([]) => 100,
@@ -13,6 +15,19 @@ fn simple_vec(vec: Vec<u32>) -> u32 {
     }
 }
 
+#[cfg(implicit)]
+fn simple_vec(vec: Vec<u32>) -> u32 {
+    match vec {
+        [] => 100,
+        [x] if x == 4 => x + 4,
+        [x] => x,
+        [1, x] => x + 200,
+        deref!(ref slice) => slice.iter().sum(),
+        _ => 2000,
+    }
+}
+
+#[cfg(explicit)]
 fn nested_vec(vecvec: Vec<Vec<u32>>) -> u32 {
     match vecvec {
         deref!([]) => 0,
@@ -24,6 +39,18 @@ fn nested_vec(vecvec: Vec<Vec<u32>>) -> u32 {
     }
 }
 
+#[cfg(implicit)]
+fn nested_vec(vecvec: Vec<Vec<u32>>) -> u32 {
+    match vecvec {
+        [] => 0,
+        [[x]] => x,
+        [[0, x] | [1, x]] => x,
+        [ref x] => x.iter().sum(),
+        [[], [1, x, y]] => y - x,
+        _ => 2000,
+    }
+}
+
 fn ref_mut(val: u32) -> u32 {
     let mut b = Box::new(0u32);
     match &mut b {

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

@@ -1,8 +1,10 @@
+//@ revisions: explicit implicit
 //@ run-pass
 // Test the execution of deref patterns.
 #![feature(deref_patterns)]
 #![allow(incomplete_features)]
 
+#[cfg(explicit)]
 fn branch(vec: Vec<u32>) -> u32 {
     match vec {
         deref!([]) => 0,
@@ -12,6 +14,17 @@ fn branch(vec: Vec<u32>) -> u32 {
     }
 }
 
+#[cfg(implicit)]
+fn branch(vec: Vec<u32>) -> u32 {
+    match vec {
+        [] => 0,
+        [1, _, 3] => 1,
+        [2, ..] => 2,
+        _ => 1000,
+    }
+}
+
+#[cfg(explicit)]
 fn nested(vec: Vec<Vec<u32>>) -> u32 {
     match vec {
         deref!([deref!([]), ..]) => 1,
@@ -20,6 +33,15 @@ fn nested(vec: Vec<Vec<u32>>) -> u32 {
     }
 }
 
+#[cfg(implicit)]
+fn nested(vec: Vec<Vec<u32>>) -> u32 {
+    match vec {
+        [[], ..] => 1,
+        [[0, ..], [1, ..]] => 2,
+        _ => 1000,
+    }
+}
+
 fn main() {
     assert!(matches!(Vec::<u32>::new(), deref!([])));
     assert!(matches!(vec![1], deref!([1])));

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

@@ -21,4 +21,22 @@ fn cant_move_out_rc(rc: Rc<Struct>) -> Struct {
     }
 }
 
+struct Container(Struct);
+
+fn cant_move_out_box_implicit(b: Box<Container>) -> Struct {
+    match b {
+        //~^ ERROR: cannot move out of a shared reference
+        Container(x) => x,
+        _ => unreachable!(),
+    }
+}
+
+fn cant_move_out_rc_implicit(rc: Rc<Container>) -> Struct {
+    match rc {
+        //~^ ERROR: cannot move out of a shared reference
+        Container(x) => x,
+        _ => unreachable!(),
+    }
+}
+
 fn main() {}

tests/ui/pattern/deref-patterns/cant_move_out_of_pattern.stderr

@@ -32,6 +32,40 @@ help: consider borrowing the pattern binding
 LL |         deref!(ref x) => x,
    |                +++
 
-error: aborting due to 2 previous errors
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/cant_move_out_of_pattern.rs:27:11
+   |
+LL |     match b {
+   |           ^
+LL |
+LL |         Container(x) => x,
+   |                   -
+   |                   |
+   |                   data moved here
+   |                   move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |         Container(ref x) => x,
+   |                   +++
+
+error[E0507]: cannot move out of a shared reference
+  --> $DIR/cant_move_out_of_pattern.rs:35:11
+   |
+LL |     match rc {
+   |           ^^
+LL |
+LL |         Container(x) => x,
+   |                   -
+   |                   |
+   |                   data moved here
+   |                   move occurs because `x` has type `Struct`, which does not implement the `Copy` trait
+   |
+help: consider borrowing the pattern binding
+   |
+LL |         Container(ref x) => x,
+   |                   +++
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0507`.