Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 94 insertions, 0 deletions

diff --git a/src/test/ui/drop/drop-trait-enum.rs b/src/test/ui/drop/drop-trait-enum.rs
new file mode 100644
index 000000000..d2b77650a
--- /dev/null
+++ b/src/test/ui/drop/drop-trait-enum.rs
@@ -0,0 +1,94 @@
+// run-pass
+#![allow(dead_code)]
+#![allow(unused_assignments)]
+#![allow(unused_variables)]
+// ignore-emscripten no threads support
+// needs-unwind
+
+use std::thread;
+use std::sync::mpsc::{channel, Sender};
+
+#[derive(PartialEq, Debug)]
+enum Message {
+    Dropped,
+    DestructorRan
+}
+
+struct SendOnDrop {
+    sender: Sender<Message>
+}
+
+impl Drop for SendOnDrop {
+    fn drop(&mut self) {
+        self.sender.send(Message::Dropped).unwrap();
+    }
+}
+
+enum Foo {
+    SimpleVariant(Sender<Message>),
+    NestedVariant(Box<usize>, SendOnDrop, Sender<Message>),
+    FailingVariant { on_drop: SendOnDrop }
+}
+
+impl Drop for Foo {
+    fn drop(&mut self) {
+        match self {
+            &mut Foo::SimpleVariant(ref mut sender) => {
+                sender.send(Message::DestructorRan).unwrap();
+            }
+            &mut Foo::NestedVariant(_, _, ref mut sender) => {
+                sender.send(Message::DestructorRan).unwrap();
+            }
+            &mut Foo::FailingVariant { .. } => {
+                panic!("Failed");
+            }
+        }
+    }
+}
+
+pub fn main() {
+    let (sender, receiver) = channel();
+    {
+        let v = Foo::SimpleVariant(sender);
+    }
+    assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
+    assert_eq!(receiver.recv().ok(), None);
+
+    let (sender, receiver) = channel();
+    {
+        let v = Foo::NestedVariant(Box::new(42), SendOnDrop { sender: sender.clone() }, sender);
+    }
+    assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
+    assert_eq!(receiver.recv().unwrap(), Message::Dropped);
+    assert_eq!(receiver.recv().ok(), None);
+
+    let (sender, receiver) = channel();
+    let t = thread::spawn(move|| {
+        let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
+    });
+    assert_eq!(receiver.recv().unwrap(), Message::Dropped);
+    assert_eq!(receiver.recv().ok(), None);
+    drop(t.join());
+
+    let (sender, receiver) = channel();
+    let t = {
+        thread::spawn(move|| {
+            let mut v = Foo::NestedVariant(Box::new(42), SendOnDrop {
+                sender: sender.clone()
+            }, sender.clone());
+            v = Foo::NestedVariant(Box::new(42),
+                                   SendOnDrop { sender: sender.clone() },
+                                   sender.clone());
+            v = Foo::SimpleVariant(sender.clone());
+            v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
+        })
+    };
+    assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
+    assert_eq!(receiver.recv().unwrap(), Message::Dropped);
+    assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
+    assert_eq!(receiver.recv().unwrap(), Message::Dropped);
+    assert_eq!(receiver.recv().unwrap(), Message::DestructorRan);
+    assert_eq!(receiver.recv().unwrap(), Message::Dropped);
+    assert_eq!(receiver.recv().ok(), None);
+    drop(t.join());
+}