feat(neon): Implement typed array extractors with a trait

Author: kjvalencik

crates/neon/src/types_impl/extract/buffer.rs

@@ -1,13 +1,13 @@
+use std::marker::PhantomData;
+
 use crate::{
     context::Cx,
     handle::Handle,
     result::{JsResult, NeonResult},
     types::{
-        buffer::{Binary, TypedArray},
+        buffer::{Binary, TypedArray as _},
         extract::{private, TryFromJs, TryIntoJs, TypeExpected},
-        JsArrayBuffer, JsBigInt64Array, JsBigUint64Array, JsBuffer, JsFloat32Array, JsFloat64Array,
-        JsInt16Array, JsInt32Array, JsInt8Array, JsTypedArray, JsUint16Array, JsUint32Array,
-        JsUint8Array, JsValue, Value,
+        JsArrayBuffer, JsBuffer, JsTypedArray, JsValue, Value,
     },
 };
 
@@ -177,64 +177,109 @@ where
 {
 }
 
-macro_rules! typed_array {
-    ($js:ident, $name:ident, $type:ty) => {
-        #[doc = concat!(
-            "Wrapper for converting between a Rust `[",
-            stringify!($type),
-            "]` array type and a [`",
-            stringify!($js),
-            "`]",
-        )]
-        pub struct $name<T>(pub T);
-
-        impl<'cx, T> TryIntoJs<'cx> for $name<T>
-        where
-            T: AsRef<[$type]>,
-        {
-            type Value = $js;
-
-            fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
-                $js::from_slice(cx, self.0.as_ref())
-            }
-        }
-
-        impl<'cx, T> TryFromJs<'cx> for $name<T>
-        where
-            for<'a> T: From<&'a [$type]>,
-        {
-            type Error = TypeExpected<$js>;
-
-            fn try_from_js(
-                cx: &mut Cx<'cx>,
-                v: Handle<'cx, JsValue>,
-            ) -> NeonResult<Result<Self, Self::Error>> {
-                let v = match v.downcast::<$js, _>(cx) {
-                    Ok(v) => v,
-                    Err(_) => return Ok(Err(TypeExpected::new())),
-                };
-
-                Ok(Ok(Self(T::from(v.as_slice(cx)))))
-            }
-        }
-
-        impl<T> private::Sealed for $name<T> {}
-    };
-
-    ($(($js:ident, $name:ident, $type:ty),)*) => {
-        $(typed_array!($js, $name, $type);)*
-    };
-}
-
-typed_array![
-    (JsInt8Array, Int8Array, i8),
-    (JsUint8Array, Uint8Array, u8),
-    (JsInt16Array, Int16Array, i16),
-    (JsUint16Array, Uint16Array, u16),
-    (JsInt32Array, Int32Array, i32),
-    (JsUint32Array, Uint32Array, u32),
-    (JsFloat32Array, Float32Array, f32),
-    (JsFloat64Array, Float64Array, f64),
-    (JsBigInt64Array, BigInt64Array, i64),
-    (JsBigUint64Array, BigUint64Array, u64),
-];
+/// Describes the type of [`JsTypedArray`] associated with a container
+///
+/// Only implemented for [`TypedArrayMarker`].
+pub trait TypedArrayExtract: private::Sealed {
+    type Container;
+    type Item: Binary;
+}
+
+/// Marker type used to describe the type of [`JsTypedArray`] and associated container
+///
+/// See [`TypedArray`] for usage.
+// N.B.: This is used as an alternative to `PhantomData` to allow single field
+// destructuring and constructing without a call to `new`.
+pub struct TypedArrayMarker<C, I>(PhantomData<C>, PhantomData<I>);
+
+impl<C, I> TypedArrayExtract for TypedArrayMarker<C, I>
+where
+    I: Binary,
+{
+    type Container = C;
+    type Item = I;
+}
+
+impl<C, I> private::Sealed for TypedArrayMarker<C, I> {}
+
+/// ```
+/// # mod bytes { pub type Bytes = Vec<u8>; }
+/// use bytes::Bytes;
+/// use neon::types::extract::{TypedArray, Uint8Array};
+///
+/// #[neon::export]
+/// fn example(TypedArray(buf): Uint8Array<Bytes>) -> Uint8Array<Bytes> {
+///     let buf = Bytes::from(b"Hello, World!");
+///
+///     TypedArray(buf)
+/// }
+/// ```
+pub struct TypedArray<T>(pub T::Container)
+where
+    T: TypedArrayExtract;
+
+impl<'cx, T> TryIntoJs<'cx> for TypedArray<T>
+where
+    T: TypedArrayExtract,
+    T::Container: AsRef<[T::Item]>,
+    JsTypedArray<T::Item>: Value,
+{
+    type Value = JsTypedArray<T::Item>;
+
+    fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
+        JsTypedArray::from_slice(cx, self.0.as_ref())
+    }
+}
+
+impl<'cx, T> TryFromJs<'cx> for TypedArray<T>
+where
+    T: TypedArrayExtract,
+    for<'a> T::Container: From<&'a [T::Item]>,
+    JsTypedArray<T::Item>: Value,
+{
+    type Error = TypeExpected<JsTypedArray<T::Item>>;
+
+    fn try_from_js(
+        cx: &mut Cx<'cx>,
+        v: Handle<'cx, JsValue>,
+    ) -> NeonResult<Result<Self, Self::Error>> {
+        let v = match v.downcast::<JsTypedArray<T::Item>, _>(cx) {
+            Ok(v) => v,
+            Err(_) => return Ok(Err(Self::Error::new())),
+        };
+
+        Ok(Ok(Self(T::Container::from(v.as_slice(cx)))))
+    }
+}
+
+impl<T> private::Sealed for TypedArray<T> where T: TypedArrayExtract {}
+
+/// Extractor for [`JsInt8Array`](crate::types::JsInt8Array)
+pub type Int8Array<T> = TypedArray<TypedArrayMarker<T, i8>>;
+
+/// Extractor for [`JsUint8Array`](crate::types::JsUint8Array)
+pub type Uint8Array<T> = TypedArray<TypedArrayMarker<T, u8>>;
+
+/// Extractor for [`JsInt16Array`](crate::types::JsInt16Array)
+pub type Int16Array<T> = TypedArray<TypedArrayMarker<T, i16>>;
+
+/// Extractor for [`JsUint16Array`](crate::types::JsUint16Array)
+pub type Uint16Array<T> = TypedArray<TypedArrayMarker<T, u16>>;
+
+/// Extractor for [`JsInt32Array`](crate::types::JsInt32Array)
+pub type Int32Array<T> = TypedArray<TypedArrayMarker<T, i32>>;
+
+/// Extractor for [`JsUint32Array`](crate::types::JsUint32Array)
+pub type Uint32Array<T> = TypedArray<TypedArrayMarker<T, u32>>;
+
+/// Extractor for [`JsFloat32Array`](crate::types::JsFloat32Array)
+pub type Float32Array<T> = TypedArray<TypedArrayMarker<T, f32>>;
+
+/// Extractor for [`JsFloat64Array`](crate::types::JsFloat64Array)
+pub type Float64Array<T> = TypedArray<TypedArrayMarker<T, f64>>;
+
+/// Extractor for [`JsBigInt64Array`](crate::types::JsBigInt64Array)
+pub type BigInt64Array<T> = TypedArray<TypedArrayMarker<T, i64>>;
+
+/// Extractor for [`JsBigUint64Array`](crate::types::JsBigUint64Array)
+pub type BigUint64Array<T> = TypedArray<TypedArrayMarker<T, u64>>;

crates/neon/src/types_impl/extract/mod.rs

@@ -110,7 +110,8 @@ pub use self::{
     boxed::Boxed,
     buffer::{
         ArrayBuffer, BigInt64Array, BigUint64Array, Buffer, Float32Array, Float64Array, Int16Array,
-        Int32Array, Int8Array, Uint16Array, Uint32Array, Uint8Array,
+        Int32Array, Int8Array, TypedArray, TypedArrayExtract, TypedArrayMarker, Uint16Array,
+        Uint32Array, Uint8Array,
     },
     error::{Error, TypeExpected},
     with::With,