X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/f38113a9cfc9aa6f29224ae0020f0fd3bffe2818..bf29e608d91175d0fca2108fd1b5d75596a4a796:/src/any.rs

diff --git a/src/any.rs b/src/any.rs
index 16955ad..4045889 100644
--- a/src/any.rs
+++ b/src/any.rs
@@ -3,39 +3,42 @@
 //! This stuff is all based on `std::any`, but goes a little further, with `CloneAny` being a
 //! cloneable `Any` and with the `Send` and `Sync` bounds possible on both `Any` and `CloneAny`.
 
-use std::mem;
 use std::fmt;
 use std::any::Any as StdAny;
 
 #[doc(hidden)]
 pub trait CloneToAny {
-    /// Clone `self` into a new `Box<CloneAny>` object.
-    fn clone_to_any(&self) -> Box<CloneAny>;
+    /// Clone `self` into a new `Box<dyn CloneAny>` object.
+    fn clone_to_any(&self) -> Box<dyn CloneAny>;
 
-    /// Clone `self` into a new `Box<CloneAny + Send>` object.
-    fn clone_to_any_send(&self) -> Box<CloneAny + Send> where Self: Send;
+    /// 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<CloneAny + Sync>` object.
-    fn clone_to_any_sync(&self) -> Box<CloneAny + Sync> where Self: Sync;
+    /// 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<CloneAny + Send + Sync>` object.
-    fn clone_to_any_send_sync(&self) -> Box<CloneAny + Send + Sync> where Self: Send + 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 {
-    fn clone_to_any(&self) -> Box<CloneAny> {
+    #[inline]
+    fn clone_to_any(&self) -> Box<dyn CloneAny> {
         Box::new(self.clone())
     }
 
-    fn clone_to_any_send(&self) -> Box<CloneAny + Send> where Self: Send {
+    #[inline]
+    fn clone_to_any_send(&self) -> Box<dyn CloneAny + Send> where Self: Send {
         Box::new(self.clone())
     }
 
-    fn clone_to_any_sync(&self) -> Box<CloneAny + Sync> where Self: Sync {
+    #[inline]
+    fn clone_to_any_sync(&self) -> Box<dyn CloneAny + Sync> where Self: Sync {
         Box::new(self.clone())
     }
 
-    fn clone_to_any_send_sync(&self) -> Box<CloneAny + Send + Sync> where Self: Send + Sync {
+    #[inline]
+    fn clone_to_any_send_sync(&self) -> Box<dyn CloneAny + Send + Sync> where Self: Send + Sync {
         Box::new(self.clone())
     }
 }
@@ -81,6 +84,7 @@ macro_rules! define {
 macro_rules! impl_clone {
     ($t:ty, $method:ident) => {
         impl Clone for Box<$t> {
+            #[inline]
             fn clone(&self) -> Box<$t> {
                 (**self).$method()
             }
@@ -88,17 +92,6 @@ macro_rules! impl_clone {
     }
 }
 
-#[cfg(feature = "unstable")]
-use std::raw::TraitObject;
-
-#[cfg(not(feature = "unstable"))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-struct TraitObject {
-    pub data: *mut (),
-    pub vtable: *mut (),
-}
-
 #[allow(missing_docs)]  // Bogus warning (it’s not public outside the crate), ☹
 pub trait UncheckedAnyExt: Any {
     unsafe fn downcast_ref_unchecked<T: Any>(&self) -> &T;
@@ -115,30 +108,33 @@ pub trait IntoBox<A: ?Sized + UncheckedAnyExt>: Any {
 
 macro_rules! implement {
     ($base:ident, $(+ $bounds:ident)*) => {
-        impl fmt::Debug for $base $(+ $bounds)* {
+        impl fmt::Debug for dyn $base $(+ $bounds)* {
+            #[inline]
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.pad(stringify!($base $(+ $bounds)*))
+                f.pad(stringify!(dyn $base $(+ $bounds)*))
             }
         }
 
-        impl UncheckedAnyExt for $base $(+ $bounds)* {
-            #[allow(transmute_ptr_to_ref)]
+        impl UncheckedAnyExt for dyn $base $(+ $bounds)* {
+            #[inline]
             unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {
-                mem::transmute(mem::transmute::<_, TraitObject>(self).data)
+                &*(self as *const Self as *const T)
             }
 
-            #[allow(transmute_ptr_to_ref)]
+            #[inline]
             unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T {
-                mem::transmute(mem::transmute::<_, TraitObject>(self).data)
+                &mut *(self as *mut Self as *mut T)
             }
 
+            #[inline]
             unsafe fn downcast_unchecked<T: 'static>(self: Box<Self>) -> Box<T> {
-                mem::transmute(mem::transmute::<_, TraitObject>(self).data)
+                Box::from_raw(Box::into_raw(self) as *mut T)
             }
         }
 
-        impl<T: $base $(+ $bounds)*> IntoBox<$base $(+ $bounds)*> for T {
-            fn into_box(self) -> Box<$base $(+ $bounds)*> {
+        impl<T: $base $(+ $bounds)*> IntoBox<dyn $base $(+ $bounds)*> for T {
+            #[inline]
+            fn into_box(self) -> Box<dyn $base $(+ $bounds)*> {
                 Box::new(self)
             }
         }
@@ -156,7 +152,7 @@ implement!(CloneAny, + Sync);
 implement!(CloneAny, + Send + Sync);
 
 define!(CloneAny);
-impl_clone!(CloneAny, clone_to_any);
-impl_clone!((CloneAny + Send), clone_to_any_send);
-impl_clone!((CloneAny + Sync), clone_to_any_sync);
-impl_clone!((CloneAny + Send + Sync), clone_to_any_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);