make str literal patterns usable in deref patterns

Specifically, this allows string literal patterns to be used where a
`str` is expected when `deref_patterns` is enabled.

compiler/rustc_hir_typeck/src/pat.rs

@@ -775,6 +775,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
+        // When `deref_patterns` is enabled, in order to allow `deref!("..."): String`, we allow
+        // string literal patterns to have type `str`. This is accounted for when lowering to MIR.
+        if self.tcx.features().deref_patterns()
+            && let hir::PatExprKind::Lit {
+                lit: Spanned { node: ast::LitKind::Str(..), .. }, ..
+            } = lt.kind
+            && self.try_structurally_resolve_type(span, expected).is_str()
+        {
+            pat_ty = self.tcx.types.str_;
+        }
+
         if self.tcx.features().string_deref_patterns()
             && let hir::PatExprKind::Lit {
                 lit: Spanned { node: ast::LitKind::Str(..), .. }, ..

compiler/rustc_mir_build/src/builder/matches/test.rs

@@ -146,6 +146,29 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let mut place = place;
                 let mut block = block;
                 match ty.kind() {
+                    ty::Str => {
+                        // String literal patterns may have type `str` if `deref_patterns` is
+                        // enabled, in order to allow `deref!("..."): String`. In this case, `value`
+                        // is of type `&str`, so we compare it to `&place`.
+                        if !tcx.features().deref_patterns() {
+                            span_bug!(
+                                test.span,
+                                "matching on `str` went through without enabling deref_patterns"
+                            );
+                        }
+                        let re_erased = tcx.lifetimes.re_erased;
+                        let ref_str_ty = Ty::new_imm_ref(tcx, re_erased, tcx.types.str_);
+                        let ref_place = self.temp(ref_str_ty, test.span);
+                        // `let ref_place: &str = &place;`
+                        self.cfg.push_assign(
+                            block,
+                            self.source_info(test.span),
+                            ref_place,
+                            Rvalue::Ref(re_erased, BorrowKind::Shared, place),
+                        );
+                        place = ref_place;
+                        ty = ref_str_ty;
+                    }
                     ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::String) => {
                         if !tcx.features().string_deref_patterns() {
                             span_bug!(

compiler/rustc_mir_build/src/thir/constant.rs

@@ -37,6 +37,12 @@ pub(crate) fn lit_to_const<'tcx>(
             let str_bytes = s.as_str().as_bytes();
             ty::ValTree::from_raw_bytes(tcx, str_bytes)
         }
+        (ast::LitKind::Str(s, _), ty::Str) if tcx.features().deref_patterns() => {
+            // String literal patterns may have type `str` if `deref_patterns` is enabled, in order
+            // to allow `deref!("..."): String`.
+            let str_bytes = s.as_str().as_bytes();
+            ty::ValTree::from_raw_bytes(tcx, str_bytes)
+        }
         (ast::LitKind::ByteStr(data, _), ty::Ref(_, inner_ty, _))
             if matches!(inner_ty.kind(), ty::Slice(_)) =>
         {

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

@@ -280,6 +280,16 @@ impl<'tcx> ConstToPat<'tcx> {
                 slice: None,
                 suffix: Box::new([]),
             },
+            ty::Str => {
+                // String literal patterns may have type `str` if `deref_patterns` is enabled, in
+                // order to allow `deref!("..."): String`. Since we need a `&str` for the comparison
+                // when lowering to MIR in `Builder::perform_test`, treat the constant as a `&str`.
+                // This works because `str` and `&str` have the same valtree representation.
+                let ref_str_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, ty);
+                PatKind::Constant {
+                    value: mir::Const::Ty(ref_str_ty, ty::Const::new_value(tcx, cv, ref_str_ty)),
+                }
+            }
             ty::Ref(_, pointee_ty, ..) => match *pointee_ty.kind() {
                 // `&str` is represented as a valtree, let's keep using this
                 // optimization for now.

tests/ui/pattern/deref-patterns/needs-gate.rs

@@ -12,4 +12,11 @@ fn main() {
         //~^ ERROR: mismatched types
         _ => {}
     }
+
+    // `deref_patterns` allows string and byte string literals to have non-ref types.
+    match *"test" {
+        "test" => {}
+        //~^ ERROR: mismatched types
+        _ => {}
+    }
 }

tests/ui/pattern/deref-patterns/needs-gate.stderr

@@ -23,7 +23,15 @@ help: consider dereferencing to access the inner value using the Deref trait
 LL |     match *Box::new(0) {
    |           +
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/needs-gate.rs:18:9
+   |
+LL |     match *"test" {
+   |           ------- this expression has type `str`
+LL |         "test" => {}
+   |         ^^^^^^ expected `str`, found `&str`
+
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0308, E0658.
 For more information about an error, try `rustc --explain E0308`.

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

@@ -0,0 +1,32 @@
+//@ run-pass
+//! Test deref patterns using string and bytestring literals.
+
+#![feature(deref_patterns)]
+#![allow(incomplete_features)]
+
+fn main() {
+    for (test_in, test_expect) in [("zero", 0), ("one", 1), ("two", 2)] {
+        // Test string literal patterns having type `str`.
+        let test_actual = match *test_in {
+            "zero" => 0,
+            "one" => 1,
+            _ => 2,
+        };
+        assert_eq!(test_actual, test_expect);
+
+        // Test string literals in explicit `deref!(_)` patterns.
+        let test_actual = match test_in.to_string() {
+            deref!("zero") => 0,
+            deref!("one") => 1,
+            _ => 2,
+        };
+        assert_eq!(test_actual, test_expect);
+    }
+
+    // Test that we can still mutate in the match arm after using a literal to test equality:
+    let mut test = "test".to_string();
+    if let deref!(s @ "test") = &mut test {
+        s.make_ascii_uppercase();
+    }
+    assert_eq!(test, "TEST");
+}

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

@@ -2,18 +2,14 @@
 #![allow(incomplete_features)]
 
 fn main() {
-    // FIXME(deref_patterns): fails to typecheck because `"foo"` has type &str but deref creates a
-    // place of type `str`.
+    // FIXME(deref_patterns): fails to typecheck because string literal patterns don't peel
+    // references from the scrutinee.
     match "foo".to_string() {
-        deref!("foo") => {}
-        //~^ ERROR: mismatched types
         "foo" => {}
         //~^ ERROR: mismatched types
         _ => {}
     }
     match &"foo".to_string() {
-        deref!("foo") => {}
-        //~^ ERROR: mismatched types
         "foo" => {}
         //~^ ERROR: mismatched types
         _ => {}

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

@@ -1,42 +1,24 @@
 error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:8:16
+  --> $DIR/typeck_fail.rs:8:9
    |
 LL |     match "foo".to_string() {
    |           ----------------- this expression has type `String`
-LL |         deref!("foo") => {}
-   |                ^^^^^ expected `str`, found `&str`
-
-error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:10:9
-   |
-LL |     match "foo".to_string() {
-   |           ----------------- this expression has type `String`
-...
 LL |         "foo" => {}
    |         ^^^^^ expected `String`, found `&str`
 
 error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:15:16
-   |
-LL |     match &"foo".to_string() {
-   |           ------------------ this expression has type `&String`
-LL |         deref!("foo") => {}
-   |                ^^^^^ expected `str`, found `&str`
-
-error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:17:9
+  --> $DIR/typeck_fail.rs:13:9
    |
 LL |     match &"foo".to_string() {
    |           ------------------ this expression has type `&String`
-...
 LL |         "foo" => {}
    |         ^^^^^ expected `&String`, found `&str`
    |
    = note: expected reference `&String`
               found reference `&'static str`
 
 error[E0308]: mismatched types
-  --> $DIR/typeck_fail.rs:24:9
+  --> $DIR/typeck_fail.rs:20:9
    |
 LL |     match Some(0) {
    |           ------- this expression has type `Option<{integer}>`
@@ -46,6 +28,6 @@ LL |         Ok(0) => {}
    = note: expected enum `Option<{integer}>`
               found enum `Result<_, _>`
 
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0308`.