From a4b7ed7a42c716ab9f05e351f003d589124fd55d Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:18:58 +0200
Subject: Adding upstream version 1.68.2+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../let-else/let-else-deref-coercion-annotated.rs  | 77 ++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 tests/ui/let-else/let-else-deref-coercion-annotated.rs

(limited to 'tests/ui/let-else/let-else-deref-coercion-annotated.rs')

diff --git a/tests/ui/let-else/let-else-deref-coercion-annotated.rs b/tests/ui/let-else/let-else-deref-coercion-annotated.rs
new file mode 100644
index 000000000..60fdf825a
--- /dev/null
+++ b/tests/ui/let-else/let-else-deref-coercion-annotated.rs
@@ -0,0 +1,77 @@
+// check-pass
+//
+// Taken from https://github.com/rust-lang/rust/blob/6cc0a764e082d9c0abcf37a768d5889247ba13e2/compiler/rustc_typeck/src/check/_match.rs#L445-L462
+//
+// We attempt to `let Bar::Present(_): &mut Bar = foo else { ... }` where foo is meant to
+// Deref/DerefMut to Bar. You can do this with an irrefutable binding, so it should work with
+// let-else too.
+
+
+use std::ops::{Deref, DerefMut};
+
+struct Foo(Bar);
+
+enum Bar {
+    Present(u32),
+    Absent,
+}
+impl Deref for Foo {
+    type Target = Bar;
+    fn deref(&self) -> &Bar {
+        &self.0
+    }
+}
+impl DerefMut for Foo {
+    fn deref_mut(&mut self) -> &mut Bar {
+        &mut self.0
+    }
+}
+impl Bar {
+    fn bar(&self) -> Option<u32> {
+        let Bar::Present(z): &Bar = self else {
+            return None;
+        };
+        return Some(*z);
+    }
+}
+impl Foo {
+    fn set_bar_annotated(&mut self, value: u32) {
+        let Bar::Present(z): &mut Bar = self else { // OK
+            return;
+        };
+        *z = value;
+    }
+}
+
+fn main() {
+    let mut foo = Foo(Bar::Present(1));
+    foo.set_bar_annotated(42);
+    assert_eq!(foo.bar(), Some(42));
+    irrefutable::inner();
+}
+
+// The original, to show it works for irrefutable let decls
+mod irrefutable {
+    use std::ops::{Deref, DerefMut};
+    struct Foo(Bar);
+    struct Bar(u32);
+    impl Deref for Foo {
+        type Target = Bar;
+        fn deref(&self) -> &Bar {
+            &self.0
+        }
+    }
+    impl DerefMut for Foo {
+        fn deref_mut(&mut self) -> &mut Bar {
+            &mut self.0
+        }
+    }
+    fn foo(x: &mut Foo) {
+        let Bar(z): &mut Bar = x; // OK
+        *z = 42;
+        assert_eq!((x.0).0, 42);
+    }
+    pub fn inner() {
+        foo(&mut Foo(Bar(1)));
+    }
+}
-- 
cgit v1.2.3