summaryrefslogtreecommitdiffstats
path: root/tests/ui/transmutability/visibility/assume
diff options
context:
space:
mode:
Diffstat (limited to 'tests/ui/transmutability/visibility/assume')
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_field.rs38
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_variant.rs39
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_tricky_unreachable_field.rs46
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.rs39
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.stderr12
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.rs40
-rw-r--r--tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr15
7 files changed, 229 insertions, 0 deletions
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_field.rs b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_field.rs
new file mode 100644
index 000000000..8a41669c6
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_field.rs
@@ -0,0 +1,38 @@
+// check-pass
+//! If visibility is assumed, a transmutation should be accepted even if the
+//! destination type contains a private field.
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(dead_code)]
+
+mod assert {
+ use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+ pub fn is_transmutable<Src, Dst, Context>()
+ where
+ Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
+ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
+ {}
+}
+
+mod src {
+ #[repr(C)] pub(self) struct Zst;
+
+ #[repr(C)] pub(in super) struct Src {
+ pub(self) field: Zst,
+ }
+}
+
+mod dst {
+ #[repr(C)] pub(in super) struct Zst;
+
+ #[repr(C)] pub(in super) struct Dst {
+ pub(self) field: Zst, // <- private field
+ }
+}
+
+fn test() {
+ struct Context;
+ assert::is_transmutable::<src::Src, dst::Dst, Context>();
+}
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_variant.rs b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_variant.rs
new file mode 100644
index 000000000..dd57b877d
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_private_variant.rs
@@ -0,0 +1,39 @@
+// check-pass
+//! If visibility is assumed, a transmutation should be accepted even if the
+//! destination type contains a private variant.
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(dead_code)]
+
+mod assert {
+ use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+ pub fn is_transmutable<Src, Dst, Context>()
+ where
+ Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
+ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
+ {}
+}
+
+mod src {
+ #[repr(C)] pub(self) struct Zst;
+
+ #[repr(C)] pub(in super) struct Src {
+ pub(self) field: Zst,
+ }
+}
+
+mod dst {
+ #[derive(Copy, Clone)]
+ #[repr(C)] pub(in super) struct Zst;
+
+ #[repr(C)] pub(in super) union Dst {
+ pub(self) field: Zst, // <- private variant
+ }
+}
+
+fn test() {
+ struct Context;
+ assert::is_transmutable::<src::Src, dst::Dst, Context>();
+}
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_tricky_unreachable_field.rs b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_tricky_unreachable_field.rs
new file mode 100644
index 000000000..ebce8ce87
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_tricky_unreachable_field.rs
@@ -0,0 +1,46 @@
+// check-pass
+//! Unless visibility is assumed, a transmutation should be rejected if the
+//! destination type contains an unreachable field (e.g., a public field with a
+//! private type). (This rule is distinct from type privacy, which still may
+//! forbid naming such types.)
+//!
+//! This test exercises a tricky-to-implement instance of this principle: the
+//! "pub-in-priv trick". In the below example, the type `dst::private::Zst` is
+//! unreachable from `Context`.
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(dead_code)]
+
+mod assert {
+ use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+ pub fn is_transmutable<Src, Dst, Context>()
+ where
+ Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
+ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
+ {}
+}
+
+mod src {
+ #[repr(C)] pub(in super) struct Zst;
+
+ #[repr(C)] pub(in super) struct Src {
+ pub(in super) field: Zst,
+ }
+}
+
+mod dst {
+ mod private {
+ #[repr(C)] pub struct Zst; // <- unreachable type
+ }
+
+ #[repr(C)] pub(in super) struct Dst {
+ pub(in super) field: private::Zst,
+ }
+}
+
+fn test() {
+ struct Context;
+ assert::is_transmutable::<src::Src, dst::Dst, Context>();
+}
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.rs b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.rs
new file mode 100644
index 000000000..546fcbaa3
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.rs
@@ -0,0 +1,39 @@
+//! If visibility is assumed, a transmutation should be accepted even if the
+//! destination type contains an unreachable field (e.g., a public field with a
+//! private type). (This rule is distinct from type privacy, which still may
+//! forbid naming such types.)
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(dead_code)]
+
+mod assert {
+ use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+ pub fn is_transmutable<Src, Dst, Context>()
+ where
+ Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
+ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
+ {}
+}
+
+mod src {
+ #[repr(C)] pub(self) struct Zst;
+
+ #[repr(C)] pub(in super) struct Src {
+ pub(self) field: Zst,
+ }
+}
+
+mod dst {
+ #[repr(C)] pub(self) struct Zst; // <- unreachable type
+
+ #[repr(C)] pub(in super) struct Dst {
+ pub(in super) field: Zst, //~ ERROR private type
+ }
+}
+
+fn test() {
+ struct Context;
+ assert::is_transmutable::<src::Src, dst::Dst, Context>();
+}
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.stderr b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.stderr
new file mode 100644
index 000000000..be83b7ce3
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_field.stderr
@@ -0,0 +1,12 @@
+error[E0446]: private type `dst::Zst` in public interface
+ --> $DIR/should_accept_if_dst_has_unreachable_field.rs:32:9
+ |
+LL | #[repr(C)] pub(self) struct Zst; // <- unreachable type
+ | -------------------- `dst::Zst` declared as private
+...
+LL | pub(in super) field: Zst,
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ can't leak private type
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0446`.
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.rs b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.rs
new file mode 100644
index 000000000..b9b74d183
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.rs
@@ -0,0 +1,40 @@
+//! If visibility is assumed, a transmutation should be accepted even if the
+//! destination type contains an unreachable field (e.g., a public field with a
+//! private type). (This rule is distinct from type privacy, which still may
+//! forbid naming such types.)
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(dead_code)]
+
+mod assert {
+ use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+ pub fn is_transmutable<Src, Dst, Context>()
+ where
+ Dst: BikeshedIntrinsicFrom<Src, Context, { Assume::SAFETY }>
+ // safety IS assumed --------------------^^^^^^^^^^^^^^^^^^
+ {}
+}
+
+mod src {
+ #[repr(C)] pub(self) struct Zst;
+
+ #[repr(C)] pub(in super) struct Src {
+ pub(self) field: Zst,
+ }
+}
+
+mod dst {
+ #[repr(C)] pub(in super) struct Zst;
+
+ // unreachable type
+ #[repr(C)] pub(self) struct Dst {
+ pub(in super) field: Zst,
+ }
+}
+
+fn test() {
+ struct Context;
+ assert::is_transmutable::<src::Src, dst::Dst, Context>(); //~ ERROR `Dst` is private
+}
diff --git a/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr
new file mode 100644
index 000000000..827df05de
--- /dev/null
+++ b/tests/ui/transmutability/visibility/assume/should_accept_if_dst_has_unreachable_ty.stderr
@@ -0,0 +1,15 @@
+error[E0603]: struct `Dst` is private
+ --> $DIR/should_accept_if_dst_has_unreachable_ty.rs:39:46
+ |
+LL | assert::is_transmutable::<src::Src, dst::Dst, Context>();
+ | ^^^ private struct
+ |
+note: the struct `Dst` is defined here
+ --> $DIR/should_accept_if_dst_has_unreachable_ty.rs:32:16
+ |
+LL | #[repr(C)] pub(self) struct Dst {
+ | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0603`.