summaryrefslogtreecommitdiffstats
path: root/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch
diff options
context:
space:
mode:
Diffstat (limited to 'tests/ui/rfcs/rfc-2027-object-safe-for-dispatch')
-rw-r--r--tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/downcast-unsafe-trait-objects.rs23
-rw-r--r--tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/manual-self-impl-for-unsafe-obj.rs66
-rw-r--r--tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/static-dispatch-unsafe-object.rs37
3 files changed, 126 insertions, 0 deletions
diff --git a/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/downcast-unsafe-trait-objects.rs b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/downcast-unsafe-trait-objects.rs
new file mode 100644
index 000000000..fa04f4b12
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/downcast-unsafe-trait-objects.rs
@@ -0,0 +1,23 @@
+// Check that we if we get ahold of an object unsafe trait
+// object with auto traits and lifetimes, we can downcast it
+//
+// check-pass
+
+#![feature(object_safe_for_dispatch)]
+
+trait Trait: Sized {}
+
+fn downcast_auto(t: &(dyn Trait + Send)) -> &dyn Trait {
+ t
+}
+
+fn downcast_lifetime<'a, 'b, 't>(t: &'a (dyn Trait + 't))
+ -> &'b (dyn Trait + 't)
+where
+ 'a: 'b,
+ 't: 'a + 'b,
+{
+ t
+}
+
+fn main() {}
diff --git a/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/manual-self-impl-for-unsafe-obj.rs b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/manual-self-impl-for-unsafe-obj.rs
new file mode 100644
index 000000000..721890db4
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/manual-self-impl-for-unsafe-obj.rs
@@ -0,0 +1,66 @@
+// Check that we can manually implement an object-unsafe trait for its trait object.
+
+// run-pass
+
+#![feature(object_safe_for_dispatch)]
+
+trait Bad {
+ fn stat() -> char {
+ 'A'
+ }
+ fn virt(&self) -> char {
+ 'B'
+ }
+ fn indirect(&self) -> char {
+ Self::stat()
+ }
+}
+
+trait Good {
+ fn good_virt(&self) -> char {
+ panic!()
+ }
+ fn good_indirect(&self) -> char {
+ panic!()
+ }
+}
+
+impl<'a> Bad for dyn Bad + 'a {
+ fn stat() -> char {
+ 'C'
+ }
+ fn virt(&self) -> char {
+ 'D'
+ }
+}
+
+struct Struct {}
+
+impl Bad for Struct {}
+
+impl Good for Struct {}
+
+fn main() {
+ let s = Struct {};
+
+ let mut res = String::new();
+
+ // Directly call static.
+ res.push(Struct::stat()); // "A"
+ res.push(<dyn Bad>::stat()); // "AC"
+
+ let good: &dyn Good = &s;
+
+ // These look similar enough...
+ let bad = unsafe { std::mem::transmute::<&dyn Good, &dyn Bad>(good) };
+
+ // Call virtual.
+ res.push(s.virt()); // "ACB"
+ res.push(bad.virt()); // "ACBD"
+
+ // Indirectly call static.
+ res.push(s.indirect()); // "ACBDA"
+ res.push(bad.indirect()); // "ACBDAC"
+
+ assert_eq!(&res, "ACBDAC");
+}
diff --git a/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/static-dispatch-unsafe-object.rs b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/static-dispatch-unsafe-object.rs
new file mode 100644
index 000000000..df97d2c13
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2027-object-safe-for-dispatch/static-dispatch-unsafe-object.rs
@@ -0,0 +1,37 @@
+// Check that we can statically dispatch methods for object
+// unsafe trait objects, directly and indirectly
+//
+// check-pass
+
+#![feature(object_safe_for_dispatch)]
+
+trait Statics {
+ fn plain() {}
+ fn generic<T>() {}
+}
+
+trait Trait: Sized {}
+
+impl<'a> Statics for dyn Trait + 'a {}
+
+fn static_poly<T: Statics + ?Sized>() {
+ T::plain();
+ T::generic::<usize>();
+}
+
+fn inferred_poly<T: Statics + ?Sized>(t: &T) {
+ static_poly::<T>();
+ T::plain();
+ T::generic::<usize>();
+}
+
+fn call(t: &dyn Trait) {
+ static_poly::<dyn Trait>();
+ inferred_poly(t);
+}
+
+fn main() {
+ static_poly::<dyn Trait>();
+ <dyn Trait>::plain();
+ <dyn Trait>::generic::<usize>()
+}