turbo_tasks/
magic_any.rs

1use std::{any::Any, fmt::Debug, hash::Hash};
2
3use serde::{Deserialize, Serialize, de::DeserializeSeed};
4use turbo_dyn_eq_hash::{
5    DynEq, DynHash, impl_eq_for_dyn, impl_hash_for_dyn, impl_partial_eq_for_dyn,
6};
7
8use crate::trace::TraceRawVcs;
9
10pub trait MagicAny: Debug + DynEq + DynHash + TraceRawVcs + Send + Sync + 'static {
11    #[cfg(debug_assertions)]
12    fn magic_type_name(&self) -> &'static str;
13}
14
15impl<T> MagicAny for T
16where
17    T: Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
18{
19    #[cfg(debug_assertions)]
20    fn magic_type_name(&self) -> &'static str {
21        std::any::type_name::<T>()
22    }
23}
24
25impl_partial_eq_for_dyn!(dyn MagicAny);
26impl_eq_for_dyn!(dyn MagicAny);
27impl_hash_for_dyn!(dyn MagicAny);
28
29impl dyn MagicAny {
30    pub fn as_serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>(
31        &self,
32    ) -> &dyn erased_serde::Serialize {
33        if let Some(r) = (self as &dyn Any).downcast_ref::<T>() {
34            r
35        } else {
36            #[cfg(debug_assertions)]
37            panic!(
38                "MagicAny::as_serializable broken: got {} but expected {}",
39                self.magic_type_name(),
40                std::any::type_name::<T>(),
41            );
42            #[cfg(not(debug_assertions))]
43            panic!("MagicAny::as_serializable bug");
44        }
45    }
46}
47
48type MagicAnySerializeFunctor = fn(&dyn MagicAny) -> &dyn erased_serde::Serialize;
49
50#[derive(Clone, Copy)]
51pub struct MagicAnySerializeSeed {
52    functor: MagicAnySerializeFunctor,
53}
54
55impl MagicAnySerializeSeed {
56    pub fn new<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>() -> Self {
57        fn serialize<T: Debug + Eq + Hash + Serialize + Send + Sync + TraceRawVcs + 'static>(
58            value: &dyn MagicAny,
59        ) -> &dyn erased_serde::Serialize {
60            value.as_serialize::<T>()
61        }
62        Self {
63            functor: serialize::<T>,
64        }
65    }
66
67    pub fn as_serialize<'a>(&self, value: &'a dyn MagicAny) -> &'a dyn erased_serde::Serialize {
68        (self.functor)(value)
69    }
70}
71
72type MagicAnyDeserializeSeedFunctor =
73    fn(&mut dyn erased_serde::Deserializer<'_>) -> Result<Box<dyn MagicAny>, erased_serde::Error>;
74
75#[derive(Clone, Copy)]
76pub struct MagicAnyDeserializeSeed {
77    functor: MagicAnyDeserializeSeedFunctor,
78}
79
80impl MagicAnyDeserializeSeed {
81    pub fn new<T>() -> Self
82    where
83        T: for<'de> Deserialize<'de> + Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
84    {
85        fn deserialize<T>(
86            deserializer: &mut dyn erased_serde::Deserializer<'_>,
87        ) -> Result<Box<dyn MagicAny>, erased_serde::Error>
88        where
89            T: for<'de> Deserialize<'de> + Debug + Eq + Hash + Send + Sync + TraceRawVcs + 'static,
90        {
91            let value: T = erased_serde::deserialize(deserializer)?;
92            Ok(Box::new(value))
93        }
94        Self {
95            functor: deserialize::<T>,
96        }
97    }
98}
99
100impl<'de> DeserializeSeed<'de> for MagicAnyDeserializeSeed {
101    type Value = Box<dyn MagicAny>;
102
103    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
104    where
105        D: serde::Deserializer<'de>,
106    {
107        let mut deserializer = <dyn erased_serde::Deserializer>::erase(deserializer);
108        (self.functor)(&mut deserializer).map_err(serde::de::Error::custom)
109    }
110}
111
112type AnyDeserializeSeedFunctor = fn(
113    &mut dyn erased_serde::Deserializer<'_>,
114) -> Result<Box<dyn Any + Sync + Send>, erased_serde::Error>;
115
116#[derive(Clone, Copy)]
117pub struct AnyDeserializeSeed {
118    functor: AnyDeserializeSeedFunctor,
119}
120
121impl AnyDeserializeSeed {
122    pub fn new<T>() -> Self
123    where
124        T: for<'de> Deserialize<'de> + Any + Send + Sync + 'static,
125    {
126        fn deserialize<T: Any + for<'de> Deserialize<'de> + Send + Sync + 'static>(
127            deserializer: &mut dyn erased_serde::Deserializer<'_>,
128        ) -> Result<Box<dyn Any + Sync + Send>, erased_serde::Error> {
129            let value: T = erased_serde::deserialize(deserializer)?;
130            Ok(Box::new(value))
131        }
132        Self {
133            functor: deserialize::<T>,
134        }
135    }
136}
137
138impl<'de> DeserializeSeed<'de> for AnyDeserializeSeed {
139    type Value = Box<dyn Any + Sync + Send>;
140
141    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
142    where
143        D: serde::Deserializer<'de>,
144    {
145        let mut deserializer = <dyn erased_serde::Deserializer>::erase(deserializer);
146        (self.functor)(&mut deserializer).map_err(serde::de::Error::custom)
147    }
148}
turbo_tasks/magic_any.rs

turbo_tasks/
magic_any.rs
