turbo_tasks/
magic_any.rs

1use core::fmt;
2use std::{
3    any::{Any, TypeId},
4    fmt::Debug,
5    hash::{Hash, Hasher},
6    ops::DerefMut,
7    sync::Arc,
8};
9
10use serde::{Deserialize, Serialize, de::DeserializeSeed};
11
12use crate::trace::{TraceRawVcs, TraceRawVcsContext};
13
14pub trait MagicAny: mopa::Any + Send + Sync {
15    fn magic_any_arc(self: Arc<Self>) -> Arc<dyn Any + Sync + Send>;
16
17    fn magic_debug(&self, f: &mut fmt::Formatter) -> fmt::Result;
18
19    fn magic_eq(&self, other: &dyn MagicAny) -> bool;
20
21    fn magic_hash(&self, hasher: &mut dyn Hasher);
22
23    fn magic_trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext);
24
25    #[cfg(debug_assertions)]
26    fn magic_type_name(&self) -> &'static str;
27}
28
29#[allow(clippy::transmute_ptr_to_ref)] // can't fix as it's in the macro
30mod clippy {
31    use mopa::mopafy;
32
33    use super::MagicAny;
34
35    mopafy!(MagicAny);
36}
37
38impl<T: Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static> MagicAny for T {
39    fn magic_any_arc(self: Arc<Self>) -> Arc<dyn Any + Sync + Send> {
40        self
41    }
42
43    fn magic_debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
44        let mut d = f.debug_tuple("MagicAny");
45        d.field(&TypeId::of::<Self>());
46
47        #[cfg(debug_assertions)]
48        d.field(&std::any::type_name::<Self>());
49
50        d.field(&(self as &Self));
51        d.finish()
52    }
53
54    fn magic_eq(&self, other: &dyn MagicAny) -> bool {
55        match other.downcast_ref::<Self>() {
56            None => false,
57            Some(other) => self == other,
58        }
59    }
60
61    fn magic_hash(&self, hasher: &mut dyn Hasher) {
62        Hash::hash(&(TypeId::of::<Self>(), self), &mut HasherMut(hasher))
63    }
64
65    fn magic_trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext) {
66        self.trace_raw_vcs(trace_context);
67    }
68
69    #[cfg(debug_assertions)]
70    fn magic_type_name(&self) -> &'static str {
71        std::any::type_name::<T>()
72    }
73}
74
75impl fmt::Debug for dyn MagicAny {
76    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
77        self.magic_debug(f)
78    }
79}
80
81impl PartialEq for dyn MagicAny {
82    fn eq(&self, other: &Self) -> bool {
83        self.magic_eq(other)
84    }
85}
86
87impl Eq for dyn MagicAny {}
88
89impl Hash for dyn MagicAny {
90    fn hash<H: Hasher>(&self, hasher: &mut H) {
91        self.magic_hash(hasher)
92    }
93}
94
95pub struct HasherMut<H: ?Sized>(pub H);
96
97impl<H: DerefMut + ?Sized> Hasher for HasherMut<H>
98where
99    H::Target: Hasher,
100{
101    fn finish(&self) -> u64 {
102        self.0.finish()
103    }
104
105    fn write(&mut self, bytes: &[u8]) {
106        self.0.write(bytes)
107    }
108}
109
110impl TraceRawVcs for dyn MagicAny {
111    fn trace_raw_vcs(&self, trace_context: &mut TraceRawVcsContext) {
112        self.magic_trace_raw_vcs(trace_context)
113    }
114}
115
116impl dyn MagicAny {
117    pub fn as_serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>(
118        &self,
119    ) -> &dyn erased_serde::Serialize {
120        if let Some(r) = self.downcast_ref::<T>() {
121            r
122        } else {
123            #[cfg(debug_assertions)]
124            panic!(
125                "MagicAny::as_serializable broken: got {} but expected {}",
126                self.magic_type_name(),
127                std::any::type_name::<T>()
128            );
129            #[cfg(not(debug_assertions))]
130            panic!("MagicAny::as_serializable bug");
131        }
132    }
133}
134
135type MagicAnySerializeFunctor = fn(&dyn MagicAny) -> &dyn erased_serde::Serialize;
136
137#[derive(Clone, Copy)]
138pub struct MagicAnySerializeSeed {
139    functor: MagicAnySerializeFunctor,
140}
141
142impl MagicAnySerializeSeed {
143    pub fn new<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>() -> Self {
144        fn serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>(
145            value: &dyn MagicAny,
146        ) -> &dyn erased_serde::Serialize {
147            value.as_serialize::<T>()
148        }
149        Self {
150            functor: serialize::<T>,
151        }
152    }
153
154    pub fn as_serialize<'a>(&self, value: &'a dyn MagicAny) -> &'a dyn erased_serde::Serialize {
155        (self.functor)(value)
156    }
157}
158
159type MagicAnyDeserializeSeedFunctor =
160    fn(&mut dyn erased_serde::Deserializer<'_>) -> Result<Box<dyn MagicAny>, erased_serde::Error>;
161
162#[derive(Clone, Copy)]
163pub struct MagicAnyDeserializeSeed {
164    functor: MagicAnyDeserializeSeedFunctor,
165}
166
167impl MagicAnyDeserializeSeed {
168    pub fn new<T>() -> Self
169    where
170        T: for<'de> Deserialize<'de> + Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
171    {
172        fn deserialize<T>(
173            deserializer: &mut dyn erased_serde::Deserializer<'_>,
174        ) -> Result<Box<dyn MagicAny>, erased_serde::Error>
175        where
176            T: for<'de> Deserialize<'de> + Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
177        {
178            let value: T = erased_serde::deserialize(deserializer)?;
179            Ok(Box::new(value))
180        }
181        Self {
182            functor: deserialize::<T>,
183        }
184    }
185}
186
187impl<'de> DeserializeSeed<'de> for MagicAnyDeserializeSeed {
188    type Value = Box<dyn MagicAny>;
189
190    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
191    where
192        D: serde::Deserializer<'de>,
193    {
194        let mut deserializer = <dyn erased_serde::Deserializer>::erase(deserializer);
195        (self.functor)(&mut deserializer).map_err(serde::de::Error::custom)
196    }
197}
198
199type AnyDeserializeSeedFunctor = fn(
200    &mut dyn erased_serde::Deserializer<'_>,
201) -> Result<Box<dyn Any + Sync + Send>, erased_serde::Error>;
202
203#[derive(Clone, Copy)]
204pub struct AnyDeserializeSeed {
205    functor: AnyDeserializeSeedFunctor,
206}
207
208impl AnyDeserializeSeed {
209    pub fn new<T>() -> Self
210    where
211        T: for<'de> Deserialize<'de> + Any + Send + Sync + 'static,
212    {
213        fn deserialize<T: Any + for<'de> Deserialize<'de> + Send + Sync + 'static>(
214            deserializer: &mut dyn erased_serde::Deserializer<'_>,
215        ) -> Result<Box<dyn Any + Sync + Send>, erased_serde::Error> {
216            let value: T = erased_serde::deserialize(deserializer)?;
217            Ok(Box::new(value))
218        }
219        Self {
220            functor: deserialize::<T>,
221        }
222    }
223}
224
225impl<'de> DeserializeSeed<'de> for AnyDeserializeSeed {
226    type Value = Box<dyn Any + Sync + Send>;
227
228    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
229    where
230        D: serde::Deserializer<'de>,
231    {
232        let mut deserializer = <dyn erased_serde::Deserializer>::erase(deserializer);
233        (self.functor)(&mut deserializer).map_err(serde::de::Error::custom)
234    }
235}
turbo_tasks/magic_any.rs

turbo_tasks/
magic_any.rs
