don't peel ADTs the pattern could match

This is the use for the previous commits' refactors; see the messages
there for more information.

Author: dianne

compiler/rustc_hir_typeck/src/pat.rs

@@ -16,7 +16,7 @@ use rustc_hir::{
 };
 use rustc_infer::infer;
 use rustc_middle::traits::PatternOriginExpr;
-use rustc_middle::ty::{self, Ty, TypeVisitableExt};
+use rustc_middle::ty::{self, AdtDef, Ty, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_session::parse::feature_err;
@@ -160,10 +160,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
 /// Mode for adjusting the expected type and binding mode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum AdjustMode {
+enum AdjustMode<'tcx> {
     /// Peel off all immediate reference types. If the `deref_patterns` feature is enabled, this
     /// also peels library-defined smart pointer ADTs.
-    Peel { kind: PeelKind },
+    Peel { kind: PeelKind<'tcx> },
     /// Reset binding mode to the initial mode.
     /// Used for destructuring assignment, where we don't want any match ergonomics.
     Reset,
@@ -173,14 +173,22 @@ enum AdjustMode {
 
 /// Restrictions on what types to peel when adjusting the expected type and binding mode.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum PeelKind {
+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.
-    // TODO: add `ResolvedPat` and `until_adt`.
-    Overloaded,
+    Overloaded { 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 } }
+    }
+    const fn peel_all() -> AdjustMode<'tcx> {
+        AdjustMode::peel_until_adt(None)
+    }
 }
 
 /// `ref mut` bindings (explicit or match-ergonomics) are not allowed behind an `&` reference.
@@ -282,7 +290,7 @@ enum ResolvedPatKind<'tcx> {
 }
 
 impl<'tcx> ResolvedPat<'tcx> {
-    fn adjust_mode(&self) -> AdjustMode {
+    fn adjust_mode(&self) -> AdjustMode<'tcx> {
         if let ResolvedPatKind::Path { res, .. } = self.kind
             && matches!(res, Res::Def(DefKind::Const | DefKind::AssocConst, _))
         {
@@ -294,7 +302,7 @@ impl<'tcx> ResolvedPat<'tcx> {
             // The remaining possible resolutions for path, struct, and tuple struct patterns are
             // ADT constructors. As such, we may peel references freely, but we must not peel the
             // ADT itself from the scrutinee if it's a smart pointer.
-            AdjustMode::Peel { kind: PeelKind::Overloaded }
+            AdjustMode::peel_until_adt(self.ty.ty_adt_def())
         }
     }
 }
@@ -533,7 +541,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         pat: &'tcx Pat<'tcx>,
         expected: Ty<'tcx>,
         def_br: ByRef,
-        adjust_mode: AdjustMode,
+        adjust_mode: AdjustMode<'tcx>,
         max_ref_mutbl: MutblCap,
     ) -> (Ty<'tcx>, ByRef, MutblCap) {
         #[cfg(debug_assertions)]
@@ -559,7 +567,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         pat: &'tcx Pat<'tcx>,
         opt_resolved_pat: Option<&ResolvedPat<'tcx>>,
-    ) -> AdjustMode {
+    ) -> AdjustMode<'tcx> {
         // When we perform destructuring assignment, we disable default match bindings, which are
         // unintuitive in this context.
         if !pat.default_binding_modes {
@@ -568,21 +576,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match &pat.kind {
             // Type checking these product-like types successfully always require
             // that the expected type be of those types and not reference types.
-            PatKind::Struct(..)
-            | PatKind::TupleStruct(..)
-            | PatKind::Tuple(..)
+            PatKind::Tuple(..)
             | PatKind::Range(..)
-            | PatKind::Slice(..) => AdjustMode::Peel { kind: PeelKind::Overloaded },
+            | PatKind::Slice(..) => AdjustMode::peel_all(),
             // 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 { kind: PeelKind::Overloaded },
+            PatKind::Never => AdjustMode::peel_all(),
             // For patterns with paths, how we peel the scrutinee depends on the path's resolution.
-            PatKind::Expr(PatExpr { kind: PatExprKind::Path(_), .. }) => {
-                opt_resolved_pat.map_or(AdjustMode::Peel { kind: PeelKind::Overloaded }, ResolvedPat::adjust_mode)
+            PatKind::Struct(..)
+            | PatKind::TupleStruct(..)
+            | PatKind::Expr(PatExpr { kind: PatExprKind::Path(_), .. }) => {
+                opt_resolved_pat.map_or(AdjustMode::peel_all(), ResolvedPat::adjust_mode)
             }
 
             // String and byte-string literals result in types `&str` and `&[u8]` respectively.
@@ -592,7 +600,13 @@ 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 { kind: PeelKind::Overloaded },
+                // If an inline const pattern has a library-defined pointer-like type and
+                // `deref_patterns` is enabled, don't implicitly add deref patterns for its ADT.
+                // Nothing in the library that implements `DerefPure` supports structural equality,
+                // but we don't check that until `const_to_pat` in THIR construction. By avoiding
+                // type errors here, we can get a more meaningful error there.
+                ty::Adt(adt, _) => AdjustMode::peel_until_adt(Some(*adt)),
+                _ => AdjustMode::peel_all()
             },
 
             // Ref patterns are complicated, we handle them in `check_pat_ref`.
@@ -622,7 +636,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn peel_off_references(
         &self,
         pat: &'tcx Pat<'tcx>,
-        peel_kind: PeelKind,
+        peel_kind: PeelKind<'tcx>,
         expected: Ty<'tcx>,
         mut def_br: ByRef,
         mut max_ref_mutbl: MutblCap,
@@ -656,13 +670,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 });
                 inner_ty
             } else if deref_patterns
-                && peel_kind == PeelKind::Overloaded
+                && let PeelKind::Overloaded { 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
                 // 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()
+                && let ty::Adt(scrutinee_adt, _) = *expected.kind()
+                // Don't peel if the pattern type already matches the scrutinee. E.g., stop here if
+                // matching on a `Cow<'a, T>` scrutinee with a `Cow::Owned(_)` pattern.
+                && until_adt != Some(scrutinee_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

tests/ui/pattern/deref-patterns/implicit-const-deref.rs

@@ -0,0 +1,19 @@
+//! Test that we get an error about structural equality rather than a type error when attempting to
+//! use const patterns of library pointer types. Currently there aren't any smart pointers that can
+//! be used in constant patterns, but we still need to make sure we don't implicitly dereference the
+//! scrutinee and end up with a type error; this would prevent us from reporting that only constants
+//! supporting structural equality can be used as patterns.
+#![feature(deref_patterns)]
+#![allow(incomplete_features)]
+
+const EMPTY: Vec<()> = Vec::new();
+
+fn main() {
+    // FIXME(inline_const_pat): if `inline_const_pat` is reinstated, there should be a case here for
+    // inline const block patterns as well; they're checked differently than named constants.
+    match vec![()] {
+        EMPTY => {}
+        //~^ ERROR: constant of non-structural type `Vec<()>` in a pattern
+        _ => {}
+    }
+}

tests/ui/pattern/deref-patterns/implicit-const-deref.stderr

@@ -0,0 +1,16 @@
+error: constant of non-structural type `Vec<()>` in a pattern
+  --> $DIR/implicit-const-deref.rs:15:9
+   |
+LL | const EMPTY: Vec<()> = Vec::new();
+   | -------------------- constant defined here
+...
+LL |         EMPTY => {}
+   |         ^^^^^ constant of non-structural type
+  --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
+   |
+   = note: `Vec<()>` must be annotated with `#[derive(PartialEq)]` to be usable in patterns
+   |
+   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
+
+error: aborting due to 1 previous error
+

tests/ui/pattern/deref-patterns/implicit-cow-deref.rs

@@ -0,0 +1,44 @@
+//@ run-pass
+//! Test that implicit deref patterns interact as expected with `Cow` constructor patterns.
+#![feature(deref_patterns)]
+#![allow(incomplete_features)]
+
+use std::borrow::Cow;
+
+fn main() {
+    let cow: Cow<'static, [u8]> = Cow::from(&[1, 2, 3]);
+
+    match cow {
+        [..] => {}
+        _ => unreachable!(),
+    }
+
+    match cow {
+        Cow::Borrowed(_) => {}
+        Cow::Owned(_) => unreachable!(),
+    }
+
+    match Box::new(&cow) {
+        Cow::Borrowed { 0: _ } => {}
+        Cow::Owned { 0: _ } => unreachable!(),
+        _ => unreachable!(),
+    }
+
+    let cow_of_cow: Cow<'_, Cow<'static, [u8]>> = Cow::Owned(cow);
+
+    match cow_of_cow {
+        [..] => {}
+        _ => unreachable!(),
+    }
+
+    match cow_of_cow {
+        Cow::Borrowed(_) => unreachable!(),
+        Cow::Owned(_) => {}
+    }
+
+    match Box::new(&cow_of_cow) {
+        Cow::Borrowed { 0: _ } => unreachable!(),
+        Cow::Owned { 0: _ } => {}
+        _ => unreachable!(),
+    }
+}