X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/7606e75aa4aac3580b1951fe68a18888dd0cae0e..0656f182894b8f7c5c172b6f762c922e1a8b4ed9:/src/any.rs

diff --git a/src/any.rs b/src/any.rs
index 45ad5cc..e9cef36 100644
--- a/src/any.rs
+++ b/src/any.rs
@@ -3,84 +3,50 @@
 //! 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())
     }
 }
 
-macro_rules! define {
-    (CloneAny) => {
-        /// A type to emulate dynamic typing.
-        ///
-        /// Every type with no non-`'static` references implements `Any`.
-        define!(CloneAny remainder);
-    };
-    (Any) => {
-        /// A type to emulate dynamic typing with cloning.
-        ///
-        /// Every type with no non-`'static` references that implements `Clone` implements `Any`.
-        define!(Any remainder);
-    };
-    ($t:ident remainder) => {
-        /// See the [`std::any` documentation](https://doc.rust-lang.org/std/any/index.html) for
-        /// more details on `Any` in general.
-        ///
-        /// This trait is not `std::any::Any` but rather a type extending that for this library’s
-        /// purposes so that it can be combined with marker traits like 
-        /// <code><a class=trait title=core::marker::Send
-        /// href=http://doc.rust-lang.org/std/marker/trait.Send.html>Send</a></code> and
-        /// <code><a class=trait title=core::marker::Sync
-        /// href=http://doc.rust-lang.org/std/marker/trait.Sync.html>Sync</a></code>.
-        ///
-        define!($t trait);
-    };
-    (CloneAny trait) => {
-        /// See also [`Any`](trait.Any.html) for a version without the `Clone` requirement.
-        pub trait CloneAny: Any + CloneToAny { }
-        impl<T: StdAny + Clone> CloneAny for T { }
-    };
-    (Any trait) => {
-        /// See also [`CloneAny`](trait.CloneAny.html) for a cloneable version of this trait.
-        pub trait Any: StdAny { }
-        impl<T: StdAny> Any for T { }
-    };
-}
-
 macro_rules! impl_clone {
     ($t:ty, $method:ident) => {
         impl Clone for Box<$t> {
+            #[inline]
             fn clone(&self) -> Box<$t> {
                 (**self).$method()
             }
@@ -88,18 +54,6 @@ macro_rules! impl_clone {
     }
 }
 
-#[cfg(feature = "nightly")]
-use std::raw::TraitObject;
-
-#[cfg(not(feature = "nightly"))]
-#[repr(C)]
-#[allow(raw_pointer_derive)]
-#[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;
@@ -116,52 +70,81 @@ pub trait IntoBox<A: ?Sized + UncheckedAnyExt>: Any {
 
 macro_rules! implement {
     ($base:ident, $(+ $bounds:ident)*) => {
-        impl<'a> fmt::Debug for &'a ($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<'a> fmt::Debug for Box<$base $(+ $bounds)*> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.pad(stringify!(Box<$base $(+ $bounds)*>))
-            }
-        }
-
-        impl UncheckedAnyExt for $base $(+ $bounds)* {
+        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)
             }
 
+            #[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)
             }
         }
     }
 }
 
-define!(Any);
+/// A type to emulate dynamic typing.
+///
+/// Every type with no non-`'static` references implements `Any`.
+/// See the [`std::any` documentation](https://doc.rust-lang.org/std/any/index.html) for
+/// more details on `Any` in general.
+///
+/// This trait is not `std::any::Any` but rather a type extending that for this library’s
+/// purposes so that it can be combined with marker traits like
+/// <code><a class=trait title=core::marker::Send
+/// href=http://doc.rust-lang.org/std/marker/trait.Send.html>Send</a></code> and
+/// <code><a class=trait title=core::marker::Sync
+/// href=http://doc.rust-lang.org/std/marker/trait.Sync.html>Sync</a></code>.
+///
+/// See also [`CloneAny`](trait.CloneAny.html) for a cloneable version of this trait.
+pub trait Any: StdAny { }
+impl<T: StdAny> Any for T { }
 implement!(Any,);
 implement!(Any, + Send);
 implement!(Any, + Sync);
 implement!(Any, + Send + Sync);
+
+/// A type to emulate dynamic typing with cloning.
+///
+/// Every type with no non-`'static` references that implements `Clone` implements `Any`.
+/// See the [`std::any` documentation](https://doc.rust-lang.org/std/any/index.html) for
+/// more details on `Any` in general.
+///
+/// This trait is not `std::any::Any` but rather a type extending that for this library’s
+/// purposes so that it can be combined with marker traits like
+/// <code><a class=trait title=core::marker::Send
+/// href=http://doc.rust-lang.org/std/marker/trait.Send.html>Send</a></code> and
+/// <code><a class=trait title=core::marker::Sync
+/// href=http://doc.rust-lang.org/std/marker/trait.Sync.html>Sync</a></code>.
+///
+/// See also [`Any`](trait.Any.html) for a version without the `Clone` requirement.
+pub trait CloneAny: Any + CloneToAny { }
+impl<T: StdAny + Clone> CloneAny for T { }
 implement!(CloneAny,);
 implement!(CloneAny, + Send);
 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);