hphp/hack/src/utils/arena_deserializer/impls.rs

   1 // Copyright (c) Facebook, Inc. and its affiliates.
   2 //
   3 // This source code is licensed under the MIT license found in the
   4 // LICENSE file in the "hack" directory of this source tree.
   5
   6 use std::fmt;
   7 use std::marker::PhantomData;
   8
   9 use bumpalo::collections::Vec as ArenaVec;
  10 use bumpalo::Bump;
  11 use ocamlrep_caml_builtins::Int64;
  12 use serde::de::Deserializer;
  13 use serde::de::SeqAccess;
  14 use serde::de::Visitor;
  15 use serde::Deserialize;
  16
  17 use crate::seed::ArenaSeed;
  18
  19 pub trait DeserializeInArena<'arena>: Sized {
  20     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
  21     where
  22         D: Deserializer<'arena>;
  23 }
  24
  25 #[macro_export]
  26 macro_rules! impl_deserialize_in_arena{
  27     ($ty:ident < $($lt:lifetime),* $(,)? $($tp:ident),* >) => {
  28             impl<'arena, $($tp : 'arena + $crate::DeserializeInArena<'arena>),*> $crate::DeserializeInArena<'arena> for $ty<$($lt,)* $($tp,)* > {
  29             fn deserialize_in_arena<__D>(
  30                 arena: &'arena $crate::bumpalo::Bump,
  31                 deserializer: __D,
  32             ) -> Result<Self, __D::Error>
  33             where
  34                 __D: $crate::serde::Deserializer<'arena>,
  35             {
  36                 let _ = arena;
  37                 $crate::serde::Deserialize::deserialize(deserializer)
  38             }
  39         }
  40
  41         impl<'arena, $($tp : $crate::DeserializeInArena<'arena>),*> $crate::DeserializeInArena<'arena> for &'arena $ty<$($lt,)* $($tp,)* > {
  42             fn deserialize_in_arena<__D>(
  43                 arena: &'arena $crate::bumpalo::Bump,
  44                 deserializer: __D,
  45             ) -> Result<Self, __D::Error>
  46             where
  47                 __D: $crate::serde::Deserializer<'arena>,
  48             {
  49                 let value = <$ty<$($tp,)*>>::deserialize_in_arena(arena, deserializer)?;
  50                 Ok(arena.alloc(value))
  51             }
  52         }
  53     };
  54     ($ty:ty) => {
  55         impl<'arena> $crate::DeserializeInArena<'arena> for $ty {
  56             fn deserialize_in_arena<__D>(
  57                 arena: &'arena $crate::bumpalo::Bump,
  58                 deserializer: __D,
  59             ) -> Result<Self, __D::Error>
  60             where
  61                 __D: $crate::serde::Deserializer<'arena>,
  62             {
  63                 let _ = arena;
  64                 $crate::serde::Deserialize::deserialize(deserializer)
  65             }
  66         }
  67
  68         impl<'arena> $crate::DeserializeInArena<'arena> for &'arena $ty {
  69             fn deserialize_in_arena<__D>(
  70                 arena: &'arena $crate::bumpalo::Bump,
  71                 deserializer: __D,
  72             ) -> Result<Self, __D::Error>
  73             where
  74                 __D: $crate::serde::Deserializer<'arena>,
  75             {
  76                 let value = <$ty>::deserialize(deserializer)?;
  77                 Ok(arena.alloc(value))
  78             }
  79         }
  80     };
  81 }
  82
  83 impl_deserialize_in_arena!(());
  84 impl_deserialize_in_arena!(bool);
  85 impl_deserialize_in_arena!(i8);
  86 impl_deserialize_in_arena!(i16);
  87 impl_deserialize_in_arena!(i32);
  88 impl_deserialize_in_arena!(i64);
  89 impl_deserialize_in_arena!(isize);
  90 impl_deserialize_in_arena!(u8);
  91 impl_deserialize_in_arena!(u16);
  92 impl_deserialize_in_arena!(u32);
  93 impl_deserialize_in_arena!(u64);
  94 impl_deserialize_in_arena!(usize);
  95 impl_deserialize_in_arena!(f32);
  96 impl_deserialize_in_arena!(f64);
  97 impl_deserialize_in_arena!(char);
  98 impl_deserialize_in_arena!(Int64);
  99
 100 impl<'arena> DeserializeInArena<'arena> for &'arena str {
 101     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 102     where
 103         D: Deserializer<'arena>,
 104     {
 105         struct StrInArena<'arena> {
 106             arena: &'arena Bump,
 107         }
 108
 109         impl<'arena, 'de> Visitor<'de> for StrInArena<'arena> {
 110             type Value = &'arena str;
 111
 112             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 113                 formatter.write_str("a string")
 114             }
 115
 116             fn visit_str<E>(self, string: &str) -> Result<Self::Value, E>
 117             where
 118                 E: serde::de::Error,
 119             {
 120                 Ok(self.arena.alloc_str(string))
 121             }
 122         }
 123
 124         deserializer.deserialize_str(StrInArena { arena })
 125     }
 126 }
 127
 128 impl<'arena> DeserializeInArena<'arena> for &'arena bstr::BStr {
 129     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 130     where
 131         D: Deserializer<'arena>,
 132     {
 133         struct BStrVisitor<'arena> {
 134             arena: &'arena Bump,
 135         }
 136
 137         impl<'arena, 'de> Visitor<'de> for BStrVisitor<'arena> {
 138             type Value = &'arena bstr::BStr;
 139
 140             fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 141                 f.write_str("a borrowed byte string")
 142             }
 143
 144             #[inline]
 145             fn visit_seq<V: SeqAccess<'de>>(self, mut visitor: V) -> Result<Self::Value, V::Error> {
 146                 let len = std::cmp::min(visitor.size_hint().unwrap_or(0), 256);
 147                 let mut bytes = ArenaVec::with_capacity_in(len, self.arena);
 148                 while let Some(v) = visitor.next_element()? {
 149                     bytes.push(v);
 150                 }
 151                 Ok(bytes.into_bump_slice().into())
 152             }
 153
 154             #[inline]
 155             fn visit_borrowed_bytes<E>(self, value: &'de [u8]) -> Result<Self::Value, E>
 156             where
 157                 E: serde::de::Error,
 158             {
 159                 Ok((self.arena.alloc_slice_copy(value) as &[u8]).into())
 160             }
 161
 162             #[inline]
 163             fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
 164             where
 165                 E: serde::de::Error,
 166             {
 167                 Ok((self.arena.alloc_str(value) as &str).into())
 168             }
 169
 170             #[inline]
 171             fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
 172             where
 173                 E: serde::de::Error,
 174             {
 175                 Ok((self.arena.alloc_slice_copy(value) as &[u8]).into())
 176             }
 177         }
 178
 179         deserializer.deserialize_bytes(BStrVisitor { arena })
 180     }
 181 }
 182
 183 impl<'arena, T> DeserializeInArena<'arena> for &'arena [T]
 184 where
 185     T: DeserializeInArena<'arena>,
 186 {
 187     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 188     where
 189         D: Deserializer<'arena>,
 190     {
 191         struct SliceInArena<'arena, T> {
 192             arena: &'arena Bump,
 193             marker: PhantomData<fn() -> T>,
 194         }
 195
 196         impl<'arena, T> Visitor<'arena> for SliceInArena<'arena, T>
 197         where
 198             T: DeserializeInArena<'arena> + 'arena,
 199         {
 200             type Value = &'arena [T];
 201
 202             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 203                 formatter.write_str("an array")
 204             }
 205
 206             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 207             where
 208                 A: SeqAccess<'arena>,
 209             {
 210                 let mut vec = Vec::with_capacity(seq.size_hint().unwrap_or(0));
 211                 let seed = ArenaSeed::new();
 212                 while let Some(value) = seq.next_element_seed(seed)? {
 213                     vec.push(value);
 214                 }
 215                 Ok(self.arena.alloc_slice_fill_iter(vec))
 216             }
 217         }
 218
 219         deserializer.deserialize_seq(SliceInArena {
 220             arena,
 221             marker: PhantomData,
 222         })
 223     }
 224 }
 225
 226 impl<'arena, T> DeserializeInArena<'arena> for Option<T>
 227 where
 228     T: DeserializeInArena<'arena>,
 229 {
 230     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 231     where
 232         D: Deserializer<'arena>,
 233     {
 234         struct OptionVisitor<'arena, T> {
 235             arena: &'arena Bump,
 236             marker: PhantomData<fn() -> T>,
 237         }
 238
 239         impl<'arena, T: DeserializeInArena<'arena>> Visitor<'arena> for OptionVisitor<'arena, T> {
 240             type Value = Option<T>;
 241
 242             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 243                 formatter.write_str("option")
 244             }
 245
 246             #[inline]
 247             fn visit_unit<E>(self) -> Result<Self::Value, E>
 248             where
 249                 E: serde::de::Error,
 250             {
 251                 Ok(None)
 252             }
 253
 254             #[inline]
 255             fn visit_none<E>(self) -> Result<Self::Value, E>
 256             where
 257                 E: serde::de::Error,
 258             {
 259                 Ok(None)
 260             }
 261
 262             #[inline]
 263             fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 264             where
 265                 D: Deserializer<'arena>,
 266             {
 267                 T::deserialize_in_arena(self.arena, deserializer).map(Some)
 268             }
 269         }
 270
 271         deserializer.deserialize_option(OptionVisitor {
 272             arena,
 273             marker: PhantomData,
 274         })
 275     }
 276 }
 277
 278 impl<'arena, T> DeserializeInArena<'arena> for &'arena Option<T>
 279 where
 280     T: DeserializeInArena<'arena>,
 281 {
 282     fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 283     where
 284         D: Deserializer<'arena>,
 285     {
 286         let v = <Option<T>>::deserialize_in_arena(arena, deserializer)?;
 287         Ok(arena.alloc(v))
 288     }
 289 }
 290
 291 macro_rules! tuple_impls {
 292     ($($len:tt => ($($n:tt $name:ident)+))+) => {
 293         $(
 294             impl<'arena, $($name: DeserializeInArena<'arena>),+> DeserializeInArena<'arena> for ($($name,)+) {
 295                 #[inline]
 296                 fn deserialize_in_arena<D>(_arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 297                 where
 298                     D: Deserializer<'arena>,
 299                 {
 300                     struct TupleVisitor<$($name,)+> {
 301                         marker: PhantomData<($($name,)+)>,
 302                     }
 303
 304                     impl<'arena, $($name: DeserializeInArena<'arena>),+> Visitor<'arena> for TupleVisitor<$($name,)+> {
 305                         type Value = ($($name,)+);
 306
 307                         fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 308                             formatter.write_str(concat!("a tuple of size ", $len))
 309                         }
 310
 311                         #[inline]
 312                         #[allow(non_snake_case)]
 313                         fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 314                         where
 315                             A: SeqAccess<'arena>,
 316                         {
 317                             $(
 318                                 let seed = ArenaSeed::new();
 319                                 let $name = match seq.next_element_seed(seed)? {
 320                                     Some(value) => value,
 321                                     None => return Err(serde::de::Error::invalid_length($n, &self)),
 322                                 };
 323                             )+
 324
 325                             Ok(($($name,)+))
 326                         }
 327                     }
 328
 329                     deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
 330                 }
 331             }
 332
 333             impl<'arena, $($name: DeserializeInArena<'arena>),+> DeserializeInArena<'arena> for &'arena ($($name,)+) {
 334                 #[inline]
 335                 fn deserialize_in_arena<D>(arena: &'arena Bump, deserializer: D) -> Result<Self, D::Error>
 336                 where
 337                     D: Deserializer<'arena>,
 338                 {
 339                     let v = <($($name,)+)>::deserialize_in_arena(arena, deserializer)?;
 340                     Ok(arena.alloc(v))
 341                 }
 342             }
 343         )+
 344     }
 345 }
 346
 347 tuple_impls! {
 348     1  => (0 T0)
 349     2  => (0 T0 1 T1)
 350     3  => (0 T0 1 T1 2 T2)
 351     4  => (0 T0 1 T1 2 T2 3 T3)
 352     5  => (0 T0 1 T1 2 T2 3 T3 4 T4)
 353     6  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
 354     7  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
 355     8  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
 356     9  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
 357     10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
 358     11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
 359     12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
 360     13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
 361     14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
 362     15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
 363     16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
 364 }