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