6 files changed, 618 insertions, 0 deletions
diff --git a/serde_v8/src/magic/buffer.rs b/serde_v8/src/magic/buffer.rs
new file mode 100644
index 000000000..ef1f395fe
--- /dev/null
+++ b/serde_v8/src/magic/buffer.rs
@@ -0,0 +1,146 @@
+use rusty_v8 as v8;
+
+use std::fmt;
+use std::ops::Deref;
+use std::ops::DerefMut;
+use std::sync::Mutex;
+
+use super::zero_copy_buf::ZeroCopyBuf;
+
+// An asymmetric wrapper around ZeroCopyBuf,
+// allowing us to use a single type for familiarity
+pub enum MagicBuffer {
+  FromV8(ZeroCopyBuf),
+  ToV8(Mutex<Option<Box<[u8]>>>),
+}
+
+impl MagicBuffer {
+  pub fn new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Self {
+    Self::try_new(scope, view).unwrap()
+  }
+
+  pub fn try_new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Result<Self, v8::DataError> {
+    Ok(Self::FromV8(ZeroCopyBuf::try_new(scope, view)?))
+  }
+
+  pub fn empty() -> Self {
+    MagicBuffer::ToV8(Mutex::new(Some(vec![0_u8; 0].into_boxed_slice())))
+  }
+}
+
+impl Clone for MagicBuffer {
+  fn clone(&self) -> Self {
+    match self {
+      Self::FromV8(zbuf) => Self::FromV8(zbuf.clone()),
+      Self::ToV8(_) => panic!("Don't Clone a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl AsRef<[u8]> for MagicBuffer {
+  fn as_ref(&self) -> &[u8] {
+    &*self
+  }
+}
+
+impl AsMut<[u8]> for MagicBuffer {
+  fn as_mut(&mut self) -> &mut [u8] {
+    &mut *self
+  }
+}
+
+impl Deref for MagicBuffer {
+  type Target = [u8];
+  fn deref(&self) -> &[u8] {
+    match self {
+      Self::FromV8(buf) => &*buf,
+      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl DerefMut for MagicBuffer {
+  fn deref_mut(&mut self) -> &mut [u8] {
+    match self {
+      Self::FromV8(buf) => &mut *buf,
+      Self::ToV8(_) => panic!("Don't Deref a MagicBuffer sent to v8"),
+    }
+  }
+}
+
+impl From<Box<[u8]>> for MagicBuffer {
+  fn from(buf: Box<[u8]>) -> Self {
+    MagicBuffer::ToV8(Mutex::new(Some(buf)))
+  }
+}
+
+impl From<Vec<u8>> for MagicBuffer {
+  fn from(vec: Vec<u8>) -> Self {
+    vec.into_boxed_slice().into()
+  }
+}
+
+pub const BUF_NAME: &str = "$__v8_magic_Buffer";
+pub const BUF_FIELD_1: &str = "$__v8_magic_buffer_1";
+pub const BUF_FIELD_2: &str = "$__v8_magic_buffer_2";
+
+impl serde::Serialize for MagicBuffer {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: serde::Serializer,
+  {
+    use serde::ser::SerializeStruct;
+
+    let mut s = serializer.serialize_struct(BUF_NAME, 1)?;
+    let boxed: Box<[u8]> = match self {
+      Self::FromV8(buf) => {
+        let value: &[u8] = buf;
+        value.into()
+      }
+      Self::ToV8(x) => x.lock().unwrap().take().expect("MagicBuffer was empty"),
+    };
+    let hack: [usize; 2] = unsafe { std::mem::transmute(boxed) };
+    let f1: u64 = hack[0] as u64;
+    let f2: u64 = hack[1] as u64;
+    s.serialize_field(BUF_FIELD_1, &f1)?;
+    s.serialize_field(BUF_FIELD_2, &f2)?;
+    s.end()
+  }
+}
+
+impl<'de, 's> serde::Deserialize<'de> for MagicBuffer {
+  fn deserialize<D>(deserializer: D) -> Result<MagicBuffer, D::Error>
+  where
+    D: serde::Deserializer<'de>,
+  {
+    struct ValueVisitor {}
+
+    impl<'de> serde::de::Visitor<'de> for ValueVisitor {
+      type Value = MagicBuffer;
+
+      fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a serde_v8::MagicBuffer")
+      }
+
+      fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+      where
+        E: serde::de::Error,
+      {
+        let p1: &[usize] = unsafe { &*(v as *const [u8] as *const [usize]) };
+        let p2: [usize; 4] = [p1[0], p1[1], p1[2], p1[3]];
+        let zero_copy: ZeroCopyBuf = unsafe { std::mem::transmute(p2) };
+        Ok(MagicBuffer::FromV8(zero_copy))
+      }
+    }
+
+    static FIELDS: [&str; 0] = [];
+    let visitor = ValueVisitor {};
+    deserializer.deserialize_struct(BUF_NAME, &FIELDS, visitor)
+  }
+}
diff --git a/serde_v8/src/magic/bytestring.rs b/serde_v8/src/magic/bytestring.rs
new file mode 100644
index 000000000..e90b7528e
--- /dev/null
+++ b/serde_v8/src/magic/bytestring.rs
@@ -0,0 +1,125 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+use std::ops::{Deref, DerefMut};
+
+use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
+
+pub const NAME: &str = "$__v8_magic_bytestring";
+pub const FIELD_PTR: &str = "$__v8_magic_bytestring_ptr";
+pub const FIELD_LEN: &str = "$__v8_magic_bytestring_len";
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ByteString(pub Vec<u8>);
+
+impl ByteString {
+  pub fn new() -> ByteString {
+    ByteString(Vec::new())
+  }
+
+  pub fn with_capacity(capacity: usize) -> ByteString {
+    ByteString(Vec::with_capacity(capacity))
+  }
+
+  pub fn capacity(&self) -> usize {
+    self.0.capacity()
+  }
+
+  pub fn reserve(&mut self, additional: usize) {
+    self.0.reserve(additional)
+  }
+
+  pub fn reserve_exact(&mut self, additional: usize) {
+    self.0.reserve_exact(additional)
+  }
+
+  pub fn shrink_to_fit(&mut self) {
+    self.0.shrink_to_fit()
+  }
+
+  pub fn truncate(&mut self, len: usize) {
+    self.0.truncate(len)
+  }
+
+  pub fn push(&mut self, value: u8) {
+    self.0.push(value)
+  }
+
+  pub fn pop(&mut self) -> Option<u8> {
+    self.0.pop()
+  }
+}
+
+impl Default for ByteString {
+  fn default() -> Self {
+    ByteString::new()
+  }
+}
+
+impl Deref for ByteString {
+  type Target = [u8];
+
+  fn deref(&self) -> &[u8] {
+    self.0.deref()
+  }
+}
+
+impl DerefMut for ByteString {
+  fn deref_mut(&mut self) -> &mut [u8] {
+    self.0.deref_mut()
+  }
+}
+
+impl AsRef<[u8]> for ByteString {
+  fn as_ref(&self) -> &[u8] {
+    self.0.as_ref()
+  }
+}
+
+impl AsMut<[u8]> for ByteString {
+  fn as_mut(&mut self) -> &mut [u8] {
+    self.0.as_mut()
+  }
+}
+
+impl Serialize for ByteString {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    use serde::ser::SerializeStruct;
+
+    let mut s = serializer.serialize_struct(NAME, 1)?;
+    s.serialize_field(FIELD_PTR, &(self.0.as_ptr() as usize))?;
+    s.serialize_field(FIELD_LEN, &self.0.len())?;
+    s.end()
+  }
+}
+
+impl<'de> Deserialize<'de> for ByteString {
+  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+  where
+    D: Deserializer<'de>,
+  {
+    struct ValueVisitor {}
+
+    impl<'de> Visitor<'de> for ValueVisitor {
+      type Value = ByteString;
+
+      fn expecting(
+        &self,
+        formatter: &mut std::fmt::Formatter,
+      ) -> std::fmt::Result {
+        formatter.write_str("a serde_v8::ByteString")
+      }
+
+      fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+      where
+        E: serde::de::Error,
+      {
+        Ok(ByteString(v))
+      }
+    }
+
+    deserializer.deserialize_struct(NAME, &[], ValueVisitor {})
+  }
+}
diff --git a/serde_v8/src/magic/field.rs b/serde_v8/src/magic/field.rs
new file mode 100644
index 000000000..e6bb9ee54
--- /dev/null
+++ b/serde_v8/src/magic/field.rs
@@ -0,0 +1,144 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+use crate::error::{Error, Result};
+use serde::ser::{Impossible, Serialize, Serializer};
+
+/// All serde_v8 "magic" values are reduced to structs with 1 or 2 u64 fields
+/// assuming usize==u64, most types are simply a pointer or pointer+len (e.g: Box<T>)
+pub type TransmutedField = u64;
+pub type FieldResult = Result<TransmutedField>;
+
+macro_rules! not_reachable {
+    ($($name:ident($ty:ty);)*) => {
+        $(fn $name(self, _v: $ty) -> FieldResult {
+            unreachable!();
+        })*
+    };
+}
+
+/// FieldSerializer is a simple serde::Serializer that only returns u64s
+/// it allows the "magic" struct serializers to obtain the transmuted field values
+pub struct FieldSerializer {}
+
+impl Serializer for FieldSerializer {
+  type Ok = TransmutedField;
+  type Error = Error;
+
+  type SerializeSeq = Impossible<TransmutedField, Error>;
+  type SerializeTuple = Impossible<TransmutedField, Error>;
+  type SerializeTupleStruct = Impossible<TransmutedField, Error>;
+  type SerializeTupleVariant = Impossible<TransmutedField, Error>;
+  type SerializeMap = Impossible<TransmutedField, Error>;
+  type SerializeStruct = Impossible<TransmutedField, Error>;
+  type SerializeStructVariant = Impossible<TransmutedField, Error>;
+
+  fn serialize_u64(self, transmuted_field: u64) -> FieldResult {
+    Ok(transmuted_field)
+  }
+
+  not_reachable! {
+      serialize_i8(i8);
+      serialize_i16(i16);
+      serialize_i32(i32);
+      serialize_i64(i64);
+      serialize_u8(u8);
+      serialize_u16(u16);
+      serialize_u32(u32);
+      // serialize_u64(TransmutedField); the chosen one
+      serialize_f32(f32);
+      serialize_f64(f64);
+      serialize_bool(bool);
+      serialize_char(char);
+      serialize_str(&str);
+      serialize_bytes(&[u8]);
+  }
+
+  fn serialize_none(self) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_unit(self) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_unit_struct(self, _name: &'static str) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_unit_variant(
+    self,
+    _name: &'static str,
+    _variant_index: u32,
+    _variant: &'static str,
+  ) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_newtype_struct<T: ?Sized + Serialize>(
+    self,
+    _name: &'static str,
+    _value: &T,
+  ) -> FieldResult {
+    unreachable!();
+  }
+
+  fn serialize_newtype_variant<T: ?Sized + Serialize>(
+    self,
+    _name: &'static str,
+    _variant_index: u32,
+    _variant: &'static str,
+    _value: &T,
+  ) -> FieldResult {
+    unreachable!();
+  }
+  fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+    unreachable!();
+  }
+
+  fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+    unreachable!();
+  }
+
+  fn serialize_tuple_struct(
+    self,
+    _name: &'static str,
+    _len: usize,
+  ) -> Result<Self::SerializeTupleStruct> {
+    unreachable!();
+  }
+
+  fn serialize_tuple_variant(
+    self,
+    _name: &'static str,
+    _variant_index: u32,
+    _variant: &'static str,
+    _len: usize,
+  ) -> Result<Self::SerializeTupleVariant> {
+    unreachable!();
+  }
+
+  fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+    unreachable!();
+  }
+
+  fn serialize_struct(
+    self,
+    _name: &'static str,
+    _len: usize,
+  ) -> Result<Self::SerializeStruct> {
+    unreachable!();
+  }
+
+  fn serialize_struct_variant(
+    self,
+    _name: &'static str,
+    _variant_index: u32,
+    _variant: &'static str,
+    _len: usize,
+  ) -> Result<Self::SerializeStructVariant> {
+    unreachable!();
+  }
+}
diff --git a/serde_v8/src/magic/mod.rs b/serde_v8/src/magic/mod.rs
new file mode 100644
index 000000000..00c06fd4c
--- /dev/null
+++ b/serde_v8/src/magic/mod.rs
@@ -0,0 +1,9 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+pub mod buffer;
+pub mod bytestring;
+mod field;
+mod value;
+pub mod zero_copy_buf;
+
+pub use field::FieldSerializer;
+pub use value::{Value, FIELD, NAME};
diff --git a/serde_v8/src/magic/value.rs b/serde_v8/src/magic/value.rs
new file mode 100644
index 000000000..2cb622466
--- /dev/null
+++ b/serde_v8/src/magic/value.rs
@@ -0,0 +1,79 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+use rusty_v8 as v8;
+
+use std::fmt;
+use std::marker::PhantomData;
+
+pub const FIELD: &str = "$__v8_magic_value";
+pub const NAME: &str = "$__v8_magic_Value";
+
+/// serde_v8::Value allows passing through `v8::Value`s untouched
+/// when encoding/decoding and allows mixing rust & v8 values in
+/// structs, tuples...
+/// The implementation mainly breaks down to:
+/// 1. Transmuting between u64 <> serde_v8::Value
+/// 2. Using special struct/field names to detect these values
+/// 3. Then serde "boilerplate"
+pub struct Value<'s> {
+  pub v8_value: v8::Local<'s, v8::Value>,
+}
+
+impl<'s> From<v8::Local<'s, v8::Value>> for Value<'s> {
+  fn from(v8_value: v8::Local<'s, v8::Value>) -> Self {
+    Self { v8_value }
+  }
+}
+
+impl<'s> From<Value<'s>> for v8::Local<'s, v8::Value> {
+  fn from(v: Value<'s>) -> Self {
+    v.v8_value
+  }
+}
+
+impl serde::Serialize for Value<'_> {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: serde::Serializer,
+  {
+    use serde::ser::SerializeStruct;
+
+    let mut s = serializer.serialize_struct(NAME, 1)?;
+    let mv = Value {
+      v8_value: self.v8_value,
+    };
+    let hack: u64 = unsafe { std::mem::transmute(mv) };
+    s.serialize_field(FIELD, &hack)?;
+    s.end()
+  }
+}
+
+impl<'de, 's> serde::Deserialize<'de> for Value<'s> {
+  fn deserialize<D>(deserializer: D) -> Result<Value<'s>, D::Error>
+  where
+    D: serde::Deserializer<'de>,
+  {
+    struct ValueVisitor<'s> {
+      p1: PhantomData<&'s ()>,
+    }
+
+    impl<'de, 's> serde::de::Visitor<'de> for ValueVisitor<'s> {
+      type Value = Value<'s>;
+
+      fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a v8::Value")
+      }
+
+      fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+      where
+        E: serde::de::Error,
+      {
+        let mv: Value<'s> = unsafe { std::mem::transmute(v) };
+        Ok(mv)
+      }
+    }
+
+    static FIELDS: [&str; 1] = [FIELD];
+    let visitor = ValueVisitor { p1: PhantomData };
+    deserializer.deserialize_struct(NAME, &FIELDS, visitor)
+  }
+}
diff --git a/serde_v8/src/magic/zero_copy_buf.rs b/serde_v8/src/magic/zero_copy_buf.rs
new file mode 100644
index 000000000..1e911c329
--- /dev/null
+++ b/serde_v8/src/magic/zero_copy_buf.rs
@@ -0,0 +1,115 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+use rusty_v8 as v8;
+use std::cell::Cell;
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+/// A ZeroCopyBuf encapsulates a slice that's been borrowed from a JavaScript
+/// ArrayBuffer object. JavaScript objects can normally be garbage collected,
+/// but the existence of a ZeroCopyBuf inhibits this until it is dropped. It
+/// behaves much like an Arc<[u8]>.
+///
+/// # Cloning
+/// Cloning a ZeroCopyBuf does not clone the contents of the buffer,
+/// it creates a new reference to that buffer.
+///
+/// To actually clone the contents of the buffer do
+/// `let copy = Vec::from(&*zero_copy_buf);`
+#[derive(Clone)]
+pub struct ZeroCopyBuf {
+  backing_store: v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+}
+
+unsafe impl Send for ZeroCopyBuf {}
+
+impl ZeroCopyBuf {
+  pub fn new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Self {
+    Self::try_new(scope, view).unwrap()
+  }
+
+  pub fn try_new<'s>(
+    scope: &mut v8::HandleScope<'s>,
+    view: v8::Local<v8::ArrayBufferView>,
+  ) -> Result<Self, v8::DataError> {
+    let backing_store = view.buffer(scope).unwrap().get_backing_store();
+    if backing_store.is_shared() {
+      return Err(v8::DataError::BadType {
+        actual: "shared ArrayBufferView",
+        expected: "non-shared ArrayBufferView",
+      });
+    }
+    let byte_offset = view.byte_offset();
+    let byte_length = view.byte_length();
+    Ok(Self {
+      backing_store,
+      byte_offset,
+      byte_length,
+    })
+  }
+}
+
+impl Deref for ZeroCopyBuf {
+  type Target = [u8];
+  fn deref(&self) -> &[u8] {
+    unsafe {
+      get_backing_store_slice(
+        &self.backing_store,
+        self.byte_offset,
+        self.byte_length,
+      )
+    }
+  }
+}
+
+impl DerefMut for ZeroCopyBuf {
+  fn deref_mut(&mut self) -> &mut [u8] {
+    unsafe {
+      get_backing_store_slice_mut(
+        &self.backing_store,
+        self.byte_offset,
+        self.byte_length,
+      )
+    }
+  }
+}
+
+impl AsRef<[u8]> for ZeroCopyBuf {
+  fn as_ref(&self) -> &[u8] {
+    &*self
+  }
+}
+
+impl AsMut<[u8]> for ZeroCopyBuf {
+  fn as_mut(&mut self) -> &mut [u8] {
+    &mut *self
+  }
+}
+
+unsafe fn get_backing_store_slice(
+  backing_store: &v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+) -> &[u8] {
+  let cells: *const [Cell<u8>] =
+    &backing_store[byte_offset..byte_offset + byte_length];
+  let bytes = cells as *const [u8];
+  &*bytes
+}
+
+#[allow(clippy::mut_from_ref)]
+unsafe fn get_backing_store_slice_mut(
+  backing_store: &v8::SharedRef<v8::BackingStore>,
+  byte_offset: usize,
+  byte_length: usize,
+) -> &mut [u8] {
+  let cells: *const [Cell<u8>] =
+    &backing_store[byte_offset..byte_offset + byte_length];
+  let bytes = cells as *const _ as *mut [u8];
+  &mut *bytes
+}