X-Git-Url: https://git.chrismorgan.info/anymap/blobdiff_plain/b549457d628fb178f6d700d85800f3ab63482d63..b07b62fd4d84fe1eedaba6c89c15990ced5089e6:/src/any.rs diff --git a/src/any.rs b/src/any.rs index 976f768..8404cd4 100644 --- a/src/any.rs +++ b/src/any.rs @@ -8,85 +8,36 @@ use std::any::Any as StdAny; #[doc(hidden)] pub trait CloneToAny { - /// Clone `self` into a new `Box` object. - fn clone_to_any(&self) -> Box; - - /// Clone `self` into a new `Box` object. - fn clone_to_any_send(&self) -> Box where Self: Send; - - /// Clone `self` into a new `Box` object. - fn clone_to_any_sync(&self) -> Box where Self: Sync; - - /// Clone `self` into a new `Box` object. - fn clone_to_any_send_sync(&self) -> Box where Self: Send + Sync; + /// Clone `self` into a new `Box` object. + fn clone_to_any(&self) -> Box; } impl CloneToAny for T { #[inline] - fn clone_to_any(&self) -> Box { - Box::new(self.clone()) - } - - #[inline] - fn clone_to_any_send(&self) -> Box where Self: Send { - Box::new(self.clone()) - } - - #[inline] - fn clone_to_any_sync(&self) -> Box where Self: Sync { - Box::new(self.clone()) - } - - #[inline] - fn clone_to_any_send_sync(&self) -> Box where Self: Send + Sync { + fn clone_to_any(&self) -> Box { 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 - /// Send and - /// Sync. - /// - define!($t trait); - }; - (CloneAny trait) => { - /// See also [`Any`](trait.Any.html) for a version without the `Clone` requirement. - pub trait CloneAny: Any + CloneToAny { } - impl CloneAny for T { } - }; - (Any trait) => { - /// See also [`CloneAny`](trait.CloneAny.html) for a cloneable version of this trait. - pub trait Any: StdAny { } - impl Any for T { } - }; -} - macro_rules! impl_clone { - ($t:ty, $method:ident) => { + ($t:ty) => { 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 = (**self).clone_to_any(); + let raw: *mut dyn CloneAny = Box::into_raw(clone); + unsafe { Box::from_raw(raw as *mut $t) } } } } @@ -108,14 +59,14 @@ pub trait IntoBox: 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)* { + impl UncheckedAnyExt for dyn $base $(+ $bounds)* { #[inline] unsafe fn downcast_ref_unchecked(&self) -> &T { &*(self as *const Self as *const T) @@ -132,27 +83,57 @@ macro_rules! implement { } } - impl IntoBox<$base $(+ $bounds)*> for T { + impl IntoBox for T { #[inline] - fn into_box(self) -> Box<$base $(+ $bounds)*> { + fn into_box(self) -> Box { 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 +/// Send and +/// Sync. +/// +/// See also [`CloneAny`](trait.CloneAny.html) for a cloneable version of this trait. +pub trait Any: StdAny { } +impl 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 +/// Send and +/// Sync. +/// +/// See also [`Any`](trait.Any.html) for a version without the `Clone` requirement. +pub trait CloneAny: Any + CloneToAny { } +impl 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); +impl_clone!(dyn CloneAny + Send); +impl_clone!(dyn CloneAny + Sync); +impl_clone!(dyn CloneAny + Send + Sync);