X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/764038fe6e3f5a28270a874bce2561924a316a20..93511917c3be355cf2696ca97fd21ff180dc5f47:/src/any.rs?ds=sidebyside

diff --git a/src/any.rs b/src/any.rs
index 453d7dd..636cb92 100644
--- a/src/any.rs
+++ b/src/any.rs
@@ -1,10 +1,7 @@
-//! The different types of `Any` for use in a map.
-//!
-//! 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::fmt;
-use std::any::Any;
+use core::fmt;
+use core::any::{Any, TypeId};
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
 
 #[doc(hidden)]
 pub trait CloneToAny {
@@ -31,7 +28,7 @@ macro_rules! impl_clone {
                 // 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.
+                // core::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
@@ -50,23 +47,61 @@ macro_rules! impl_clone {
     }
 }
 
-#[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;
-    unsafe fn downcast_mut_unchecked<T: Any>(&mut self) -> &mut T;
-    unsafe fn downcast_unchecked<T: Any>(self: Box<Self>) -> Box<T>;
+/// Methods for downcasting from an `Any`-like trait object.
+///
+/// This should only be implemented on trait objects for subtraits of `Any`, though you can
+/// implement it for other types and it’ll work fine, so long as your implementation is correct.
+pub trait Downcast {
+    /// Gets the `TypeId` of `self`.
+    fn type_id(&self) -> TypeId;
+
+    // Note the bound through these downcast methods is 'static, rather than the inexpressible
+    // concept of Self-but-as-a-trait (where Self is `dyn Trait`). This is sufficient, exceeding
+    // TypeId’s requirements. Sure, you *can* do CloneAny.downcast_unchecked::<NotClone>() and the
+    // type system won’t protect you, but that doesn’t introduce any unsafety: the method is
+    // already unsafe because you can specify the wrong type, and if this were exposing safe
+    // downcasting, CloneAny.downcast::<NotClone>() would just return an error, which is just as
+    // correct.
+    //
+    // Now in theory we could also add T: ?Sized, but that doesn’t play nicely with the common
+    // implementation, so I’m doing without it.
+
+    /// Downcast from `&Any` to `&T`, without checking the type matches.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `T` matches the trait object, on pain of *undefined behaviour*.
+    unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T;
+
+    /// Downcast from `&mut Any` to `&mut T`, without checking the type matches.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `T` matches the trait object, on pain of *undefined behaviour*.
+    unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T;
+
+    /// Downcast from `Box<Any>` to `Box<T>`, without checking the type matches.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `T` matches the trait object, on pain of *undefined behaviour*.
+    unsafe fn downcast_unchecked<T: 'static>(self: Box<Self>) -> Box<T>;
 }
 
-#[doc(hidden)]
 /// A trait for the conversion of an object into a boxed trait object.
-pub trait IntoBox<A: ?Sized + UncheckedAnyExt>: Any {
+pub trait IntoBox<A: ?Sized + Downcast>: Any {
     /// Convert self into the appropriate boxed form.
     fn into_box(self) -> Box<A>;
 }
 
 macro_rules! implement {
-    ($base:ident, $(+ $bounds:ident)*) => {
-        impl UncheckedAnyExt for dyn $base $(+ $bounds)* {
+    ($any_trait:ident $(+ $auto_traits:ident)*) => {
+        impl Downcast for dyn $any_trait $(+ $auto_traits)* {
+            #[inline]
+            fn type_id(&self) -> TypeId {
+                self.type_id()
+            }
+
             #[inline]
             unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {
                 &*(self as *const Self as *const T)
@@ -83,28 +118,28 @@ macro_rules! implement {
             }
         }
 
-        impl<T: $base $(+ $bounds)*> IntoBox<dyn $base $(+ $bounds)*> for T {
+        impl<T: $any_trait $(+ $auto_traits)*> IntoBox<dyn $any_trait $(+ $auto_traits)*> for T {
             #[inline]
-            fn into_box(self) -> Box<dyn $base $(+ $bounds)*> {
+            fn into_box(self) -> Box<dyn $any_trait $(+ $auto_traits)*> {
                 Box::new(self)
             }
         }
     }
 }
 
-implement!(Any,);
-implement!(Any, + Send);
-implement!(Any, + Send + Sync);
+implement!(Any);
+implement!(Any + Send);
+implement!(Any + Send + Sync);
 
 /// [`Any`], but with cloning.
 ///
 /// Every type with no non-`'static` references that implements `Clone` implements `CloneAny`.
-/// See [`std::any`] for more details on `Any` in general.
+/// See [`core::any`] for more details on `Any` in general.
 pub trait CloneAny: Any + CloneToAny { }
 impl<T: Any + Clone> CloneAny for T { }
-implement!(CloneAny,);
-implement!(CloneAny, + Send);
-implement!(CloneAny, + Send + Sync);
+implement!(CloneAny);
+implement!(CloneAny + Send);
+implement!(CloneAny + Send + Sync);
 impl_clone!(dyn CloneAny);
 impl_clone!(dyn CloneAny + Send);
 impl_clone!(dyn CloneAny + Send + Sync);