From 2691083fa864200830bf9dce7fc890f594e3e402 Mon Sep 17 00:00:00 2001
From: Kornel <kornel@geekhood.net>
Date: Sun, 14 Jun 2020 13:26:38 +0100
Subject: [PATCH] Use Plain trait for ComponentBytes soundness

---
 Cargo.toml            |  1 +
 src/alt.rs            |  8 ++++++--
 src/internal/pixel.rs | 13 ++++++++++++-
 src/internal/rgb.rs   |  6 +++++-
 src/internal/rgba.rs  | 12 +++++++++++-
 src/lib.rs            |  6 ++++++
 6 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index eeb20cc..5099b22 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ travis-ci = { repository = "kornelski/rust-rgb" }
 
 [dependencies]
 serde = { version = "1.0", optional = true, features = ["derive"] }
+plain = "0.2.3"
 
 [dev-dependencies]
 serde_json = "1.0"
diff --git a/src/alt.rs b/src/alt.rs
index 34e0dd5..a585f2c 100644
--- a/src/alt.rs
+++ b/src/alt.rs
@@ -1,3 +1,4 @@
+use plain::Plain;
 use crate::internal::pixel::*;
 use core::mem;
 use core::ops;
@@ -113,6 +114,9 @@ pub struct GrayAlpha<ComponentType, AlphaComponentType = ComponentType>(
     pub AlphaComponentType,
 );
 
+unsafe impl<T> Plain for Gray<T> where T: Plain {}
+unsafe impl<T, A> Plain for GrayAlpha<T, A> where T: Plain, A: Plain {}
+
 /// 8-bit gray
 pub type GRAY8 = Gray<u8>;
 
@@ -219,7 +223,7 @@ impl<T> ComponentSlice<T> for [GrayAlpha<T>] {
     }
 }
 
-impl<T: Copy + Send + Sync + 'static> ComponentBytes<T> for [GrayAlpha<T>] {}
+impl<T: Plain> ComponentBytes<T> for [GrayAlpha<T>] {}
 
 impl<T> ComponentSlice<T> for Gray<T> {
     #[inline(always)]
@@ -252,7 +256,7 @@ impl<T> ComponentSlice<T> for [Gray<T>] {
     }
 }
 
-impl<T: Copy + Send + Sync + 'static> ComponentBytes<T> for [Gray<T>] {}
+impl<T: Plain> ComponentBytes<T> for [Gray<T>] {}
 
 /// Assumes 255 is opaque
 impl<T: Copy> From<Gray<T>> for GrayAlpha<T, u8> {
diff --git a/src/internal/pixel.rs b/src/internal/pixel.rs
index 143dc1c..6b052c5 100644
--- a/src/internal/pixel.rs
+++ b/src/internal/pixel.rs
@@ -1,3 +1,4 @@
+use plain::Plain;
 use core;
 
 /// Casting the struct to slices of its components
@@ -14,7 +15,17 @@ pub trait ComponentSlice<T> {
 }
 
 /// Casting a slice of `RGB/A` values to a slice of `u8`
-pub trait ComponentBytes<T: Copy + Send + Sync + 'static> where Self: ComponentSlice<T> {
+///
+/// If instead of `RGB8` you use `RGB<MyCustomType>`, and you want to cast from/to that custom type,
+/// implement the `Plain` trait for it:
+///
+/// ```rust
+/// # struct MyCustomType;
+/// unsafe impl rgb::plain::Plain for MyCustomType {}
+/// ```
+///
+/// Plain types are not allowed to contain struct padding, booleans, chars, enums, references or pointers.
+pub trait ComponentBytes<T: Plain> where Self: ComponentSlice<T> {
     /// The components interpreted as raw bytes, in machine's native endian. In `RGB` bytes of the red component are first.
     #[inline]
     fn as_bytes(&self) -> &[u8] {
diff --git a/src/internal/rgb.rs b/src/internal/rgb.rs
index d74f42c..1ae9371 100644
--- a/src/internal/rgb.rs
+++ b/src/internal/rgb.rs
@@ -1,3 +1,4 @@
+use plain::Plain;
 use super::pixel::*;
 use crate::alt::BGR;
 use crate::alt::BGRA;
@@ -25,6 +26,9 @@ impl<T> BGR<T> {
     }
 }
 
+unsafe impl<T> Plain for RGB<T> where T: Plain {}
+unsafe impl<T> Plain for BGR<T> where T: Plain {}
+
 macro_rules! impl_rgb {
     ($RGB:ident, $RGBA:ident) => {
         impl<T: Clone> $RGB<T> {
@@ -101,7 +105,7 @@ macro_rules! impl_rgb {
             }
         }
 
-        impl<T: Copy + Send + Sync + 'static> ComponentBytes<T> for [$RGB<T>] {}
+        impl<T: Plain> ComponentBytes<T> for [$RGB<T>] {}
     }
 }
 
diff --git a/src/internal/rgba.rs b/src/internal/rgba.rs
index 77669ed..92d3b54 100644
--- a/src/internal/rgba.rs
+++ b/src/internal/rgba.rs
@@ -43,6 +43,9 @@ impl<T, A> BGRA<T,A> {
     }
 }
 
+unsafe impl<T, A> plain::Plain for RGBA<T, A> where T: plain::Plain, A: plain::Plain {}
+unsafe impl<T, A> plain::Plain for BGRA<T, A> where T: plain::Plain, A: plain::Plain {}
+
 #[cfg(feature = "argb")]
 impl<T> ARGB<T> {
     #[inline(always)]
@@ -87,6 +90,11 @@ impl<T, A> ABGR<T,A> {
     }
 }
 
+#[cfg(feature = "argb")]
+unsafe impl<T, A> plain::Plain for ARGB<T, A> where T: plain::Plain, A: plain::Plain {}
+#[cfg(feature = "argb")]
+unsafe impl<T, A> plain::Plain for ABGR<T, A> where T: plain::Plain, A: plain::Plain {}
+
 macro_rules! impl_rgba {
     ($RGBA:ident) => {
         impl<T: Clone> $RGBA<T> {
@@ -188,7 +196,7 @@ macro_rules! impl_rgba {
             }
         }
 
-        impl<T: Copy + Send + Sync + 'static> ComponentBytes<T> for [$RGBA<T>] {}
+        impl<T: plain::Plain> ComponentBytes<T> for [$RGBA<T>] {}
     }
 }
 
@@ -364,6 +372,8 @@ fn abgr_test() {
 #[allow(deprecated)]
 fn bgra_test() {
     let neg = BGRA::new(1, 2, 3i32, 1000).map(|x| -x);
+    let _ = neg.as_slice();
+    let _ = [neg].as_bytes();
     assert_eq!(neg.r, -1);
     assert_eq!(neg.bgr().r, -1);
     assert_eq!(neg.g, -2);
diff --git a/src/lib.rs b/src/lib.rs
index 02dc6e1..3c3e5fc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -47,6 +47,12 @@ mod internal {
 /// BGR might be useful for some Windows or OpenGL APIs.
 pub mod alt;
 
+/// Re-export from `plain` crate
+pub mod plain {
+    // wrapped in mod to prevent `use rgb::*` picking it
+    pub use plain::Plain;
+}
+
 pub use crate::internal::convert::*;
 pub use crate::internal::ops::*;
 pub use crate::internal::pixel::*;