Chris Morgan  ›  Git  ›  anymap  ›  commitdiff
Refactor to avoid a spurious compatibility warning
authorChris Morgan <me@chrismorgan.info>
committerChris Morgan <me@chrismorgan.info>
Explained in the SAFETY comment. I’m not happy about *doing* this, but
it will make *using* this crate easier, since future-compatibility lints
make noise on bin crate builds, so this was polluting other people’s
code and making life harder for users.

I have traded one evil (a spurious warning) for another (unsafe code).
CHANGELOG.md patch | blob | history
README.md patch | blob | history
src/any.rs patch | blob | history

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 04b57eec10a580113f04f341726d37367dbdfdda..72f127020926f3e816388048681452d5fb4a3e1a 100644 (file)
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,9 @@
 
 - Implement `Default` on `Map` (not just on `RawMap`)
 
 
 - Implement `Default` on `Map` (not just on `RawMap`)
 
+- Worked around the spurious `where_clauses_object_safety` future-compatibility lint that has been raised since mid-2018.
+  If you put `#![allow(where_clauses_object_safety)]` on your binary crates for this reason, you can remove it.
+
 I don’t plan for there to be any real changes from 0.12.1;
 it should be just a bit of housecleaning and a version bump.
 
 I don’t plan for there to be any real changes from 0.12.1;
 it should be just a bit of housecleaning and a version bump.
 
diff --git a/README.md b/README.md
index c4bbe6b8104adad6510ec9f3a4d4b5eb9d7e4422..9c2905c0df02d09a656d448263eb3422f8d51468 100644 (file)
--- a/README.md
+++ b/README.md
@@ -18,6 +18,8 @@ This library uses a fair bit of unsafe code for several reasons:
 
 - In the interests of performance, skipping various checks that are unnecessary because of the invariants of the data structure (no need to check the type ID when it’s been statically ensured by being used as the hash map key) and simplifying hashing (type IDs are already good hashes, no need to mangle them through SipHash).
 
 
 - In the interests of performance, skipping various checks that are unnecessary because of the invariants of the data structure (no need to check the type ID when it’s been statically ensured by being used as the hash map key) and simplifying hashing (type IDs are already good hashes, no need to mangle them through SipHash).
 
+- In the `Clone` implementation of `dyn CloneAny` with `Send` and/or `Sync` auto traits added, an unsafe block is used where safe code used to be used in order to avoid a [spurious future-compatibility lint](https://github.com/rust-lang/rust/issues/51443#issuecomment-421988013).
+
 It’s not possible to remove all unsafety from this library without also removing some of the functionality. Still, at the cost of the `CloneAny` functionality, the raw interface and maybe the concurrency support, you can definitely remove all unsafe code. Here’s how you could do it:
 
 - Remove the genericness of it all;
 It’s not possible to remove all unsafety from this library without also removing some of the functionality. Still, at the cost of the `CloneAny` functionality, the raw interface and maybe the concurrency support, you can definitely remove all unsafe code. Here’s how you could do it:
 
 - Remove the genericness of it all;
diff --git a/src/any.rs b/src/any.rs
index e9cef36b51bd4a4fbd9b5449db03df4db61ab20b..8404cd40a61d8e66c5d675041c1ab1e609deb66a 100644 (file)
--- a/src/any.rs
+++ b/src/any.rs
@@ -10,15 +10,6 @@ use std::any::Any as StdAny;
 pub trait CloneToAny {
     /// Clone `self` into a new `Box<dyn CloneAny>` object.
     fn clone_to_any(&self) -> Box<dyn CloneAny>;
 pub trait CloneToAny {
     /// Clone `self` into a new `Box<dyn CloneAny>` object.
     fn clone_to_any(&self) -> Box<dyn CloneAny>;
-
-    /// Clone `self` into a new `Box<dyn CloneAny + Send>` object.
-    fn clone_to_any_send(&self) -> Box<dyn CloneAny + Send> where Self: Send;
-
-    /// Clone `self` into a new `Box<dyn CloneAny + Sync>` object.
-    fn clone_to_any_sync(&self) -> Box<dyn CloneAny + Sync> where Self: Sync;
-
-    /// Clone `self` into a new `Box<dyn CloneAny + Send + Sync>` object.
-    fn clone_to_any_send_sync(&self) -> Box<dyn CloneAny + Send + Sync> where Self: Send + Sync;
 }
 
 impl<T: Any + Clone> CloneToAny for T {
 }
 
 impl<T: Any + Clone> CloneToAny for T {
@@ -26,29 +17,27 @@ impl<T: Any + Clone> CloneToAny for T {
     fn clone_to_any(&self) -> Box<dyn CloneAny> {
         Box::new(self.clone())
     }
     fn clone_to_any(&self) -> Box<dyn CloneAny> {
         Box::new(self.clone())
     }
-
-    #[inline]
-    fn clone_to_any_send(&self) -> Box<dyn CloneAny + Send> where Self: Send {
-        Box::new(self.clone())
-    }
-
-    #[inline]
-    fn clone_to_any_sync(&self) -> Box<dyn CloneAny + Sync> where Self: Sync {
-        Box::new(self.clone())
-    }
-
-    #[inline]
-    fn clone_to_any_send_sync(&self) -> Box<dyn CloneAny + Send + Sync> where Self: Send + Sync {
-        Box::new(self.clone())
-    }
 }
 
 macro_rules! impl_clone {
 }
 
 macro_rules! impl_clone {
-    ($t:ty, $method:ident) => {
+    ($t:ty) => {
         impl Clone for Box<$t> {
             #[inline]
             fn clone(&self) -> Box<$t> {
         impl Clone for Box<$t> {
             #[inline]
             fn clone(&self) -> Box<$t> {
-                (**self).$method()
+                // SAFETY: this dance is to reapply any Send/Sync marker. I’m not happy about this
+                // approach, given that I used to do it in safe code, but then came a dodgy
+                // future-compatibility warning where_clauses_object_safety, which is spurious for
+                // auto traits but still super annoying (future-compatibility lints seem to mean
+                // your bin crate needs a corresponding allow!). Although I explained my plight¹
+                // and it was all explained and agreed upon, no action has been taken. So I finally
+                // caved and worked around it by doing it this way, which matches what’s done for
+                // std::any², so it’s probably not *too* bad.
+                //
+                // ¹ https://github.com/rust-lang/rust/issues/51443#issuecomment-421988013
+                // ² https://github.com/rust-lang/rust/blob/e7825f2b690c9a0d21b6f6d84c404bb53b151b38/library/alloc/src/boxed.rs#L1613-L1616
+                let clone: Box<dyn CloneAny> = (**self).clone_to_any();
+                let raw: *mut dyn CloneAny = Box::into_raw(clone);
+                unsafe { Box::from_raw(raw as *mut $t) }
             }
         }
     }
             }
         }
     }
@@ -144,7 +133,7 @@ implement!(CloneAny,);
 implement!(CloneAny, + Send);
 implement!(CloneAny, + Sync);
 implement!(CloneAny, + Send + Sync);
 implement!(CloneAny, + Send);
 implement!(CloneAny, + Sync);
 implement!(CloneAny, + Send + Sync);
-impl_clone!(dyn CloneAny, clone_to_any);
-impl_clone!(dyn CloneAny + Send, clone_to_any_send);
-impl_clone!(dyn CloneAny + Sync, clone_to_any_sync);
-impl_clone!(dyn CloneAny + Send + Sync, clone_to_any_send_sync);
+impl_clone!(dyn CloneAny);
+impl_clone!(dyn CloneAny + Send);
+impl_clone!(dyn CloneAny + Sync);
+impl_clone!(dyn CloneAny + Send + Sync);