neon: Relax the lifetime constraints on TypedArray borrows

The current lifetimes are overly restrictive. The reference is valid for as long as the handle is valid. Since the `Context` is always the
most narrow scope, it will be valid for at *least* as long as `Context`, even if the `Handle` type is dropped. This allows downcasting and
returning a borrow within the same function.

Author: kjvalencik

src/types/buffer/mod.rs

@@ -22,43 +22,40 @@ pub trait TypedArray: private::Sealed {
     ///
     /// This may not be used if a mutable borrow is in scope. For the dynamically
     /// checked variant see [`TypedArray::try_borrow`].
-    fn as_slice<'a: 'b, 'b, C>(&'b self, cx: &'b C) -> &'b [Self::Item]
+    fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
     where
-        C: Context<'a>;
+        C: Context<'cx>;
 
     /// Statically checked mutable borrow of binary data.
     ///
     /// This may not be used if any other borrow is in scope. For the dynamically
     /// checked variant see [`TypedArray::try_borrow_mut`].
-    fn as_mut_slice<'a: 'b, 'b, C>(&'b mut self, cx: &'b mut C) -> &'b mut [Self::Item]
+    fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::Item]
     where
-        C: Context<'a>;
+        C: Context<'cx>;
 
     /// Dynamically checked immutable borrow of binary data, returning an error if the
     /// the borrow would overlap with a mutable borrow.
     ///
     /// The borrow lasts until [`Ref`] exits scope.
     ///
     /// This is the dynamically checked version of [`TypedArray::as_slice`].
-    fn try_borrow<'a: 'b, 'b, C>(
-        &self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<Ref<'b, Self::Item>, BorrowError>
+    fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>;
+        C: Context<'cx>;
 
     /// Dynamically checked mutable borrow of binary data, returning an error if the
     /// the borrow would overlap with an active borrow.
     ///
     /// The borrow lasts until [`RefMut`] exits scope.
     ///
     /// This is the dynamically checked version of [`TypedArray::as_mut_slice`].
-    fn try_borrow_mut<'a: 'b, 'b, C>(
+    fn try_borrow_mut<'cx, 'a, C>(
         &mut self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<RefMut<'b, Self::Item>, BorrowError>
+        lock: &'a Lock<C>,
+    ) -> Result<RefMut<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>;
+        C: Context<'cx>;
 }
 
 #[derive(Debug)]

src/types/buffer/types.rs

@@ -89,39 +89,44 @@ impl private::Sealed for JsBuffer {}
 impl TypedArray for JsBuffer {
     type Item = u8;
 
-    fn as_slice<'a: 'b, 'b, C>(&'b self, cx: &'b C) -> &'b [Self::Item]
+    fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
+        // # Safety
+        // Only the `Context` with the *most* narrow scope is accessible because `compute_scoped`
+        // and `execute_scope` take an exclusive reference to `Context`. A handle is always
+        // associated with a `Context` and the value will not be garbage collected while that
+        // `Context` is in scope. This means that the referenced data is valid *at least* as long
+        // as `Context`, even if the `Handle` is dropped.
         unsafe { neon_runtime::buffer::as_mut_slice(cx.env().to_raw(), self.to_raw()) }
     }
 
-    fn as_mut_slice<'a: 'b, 'b, C>(&'b mut self, cx: &'b mut C) -> &'b mut [Self::Item]
+    fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
+        // # Safety
+        // See `as_slice`
         unsafe { neon_runtime::buffer::as_mut_slice(cx.env().to_raw(), self.to_raw()) }
     }
 
-    fn try_borrow<'a: 'b, 'b, C>(
-        &self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<Ref<'b, Self::Item>, BorrowError>
+    fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         // The borrowed data must be guarded by `Ledger` before returning
         Ledger::try_borrow(&lock.ledger, unsafe {
             neon_runtime::buffer::as_mut_slice(lock.cx.env().to_raw(), self.to_raw())
         })
     }
 
-    fn try_borrow_mut<'a: 'b, 'b, C>(
+    fn try_borrow_mut<'cx, 'a, C>(
         &mut self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<RefMut<'b, Self::Item>, BorrowError>
+        lock: &'a Lock<C>,
+    ) -> Result<RefMut<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         // The borrowed data must be guarded by `Ledger` before returning
         Ledger::try_borrow_mut(&lock.ledger, unsafe {
@@ -197,39 +202,36 @@ impl private::Sealed for JsArrayBuffer {}
 impl TypedArray for JsArrayBuffer {
     type Item = u8;
 
-    fn as_slice<'a: 'b, 'b, C>(&'b self, cx: &'b C) -> &'b [Self::Item]
+    fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe { neon_runtime::arraybuffer::as_mut_slice(cx.env().to_raw(), self.to_raw()) }
     }
 
-    fn as_mut_slice<'a: 'b, 'b, C>(&'b mut self, cx: &'b mut C) -> &'b mut [Self::Item]
+    fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe { neon_runtime::arraybuffer::as_mut_slice(cx.env().to_raw(), self.to_raw()) }
     }
 
-    fn try_borrow<'a: 'b, 'b, C>(
-        &self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<Ref<'b, Self::Item>, BorrowError>
+    fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         // The borrowed data must be guarded by `Ledger` before returning
         Ledger::try_borrow(&lock.ledger, unsafe {
             neon_runtime::arraybuffer::as_mut_slice(lock.cx.env().to_raw(), self.to_raw())
         })
     }
 
-    fn try_borrow_mut<'a: 'b, 'b, C>(
+    fn try_borrow_mut<'cx, 'a, C>(
         &mut self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<RefMut<'b, Self::Item>, BorrowError>
+        lock: &'a Lock<C>,
+    ) -> Result<RefMut<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         // The borrowed data must be guarded by `Ledger` before returning
         Ledger::try_borrow_mut(&lock.ledger, unsafe {
@@ -272,9 +274,9 @@ impl<T> Managed for JsTypedArray<T> {
 impl<T: Copy> TypedArray for JsTypedArray<T> {
     type Item = T;
 
-    fn as_slice<'a: 'b, 'b, C>(&'b self, cx: &'b C) -> &'b [Self::Item]
+    fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe {
             let env = cx.env().to_raw();
@@ -285,9 +287,9 @@ impl<T: Copy> TypedArray for JsTypedArray<T> {
         }
     }
 
-    fn as_mut_slice<'a: 'b, 'b, C>(&'b mut self, cx: &'b mut C) -> &'b mut [Self::Item]
+    fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::Item]
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe {
             let env = cx.env().to_raw();
@@ -298,12 +300,12 @@ impl<T: Copy> TypedArray for JsTypedArray<T> {
         }
     }
 
-    fn try_borrow<'a: 'b, 'b, C>(
+    fn try_borrow<'cx, 'b, C>(
         &self,
         lock: &'b Lock<'b, C>,
     ) -> Result<Ref<'b, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe {
             let env = lock.cx.env().to_raw();
@@ -318,12 +320,12 @@ impl<T: Copy> TypedArray for JsTypedArray<T> {
         }
     }
 
-    fn try_borrow_mut<'a: 'b, 'b, C>(
+    fn try_borrow_mut<'cx, 'a, C>(
         &mut self,
-        lock: &'b Lock<'b, C>,
-    ) -> Result<RefMut<'b, Self::Item>, BorrowError>
+        lock: &'a Lock<'a, C>,
+    ) -> Result<RefMut<'a, Self::Item>, BorrowError>
     where
-        C: Context<'a>,
+        C: Context<'cx>,
     {
         unsafe {
             let env = lock.cx.env().to_raw();

test/napi/lib/objects.js

@@ -233,4 +233,12 @@ describe("JsObject", function () {
     );
     assert.equal(addon.get_own_property_names(object).length, 1);
   });
+
+  it("data borrowed on the heap can be held longer than the handle", function () {
+    const msg = "Hello, World!";
+    const buf = Buffer.from(msg);
+
+    assert.strictEqual(addon.byte_length(msg), buf.length);
+    assert.strictEqual(addon.byte_length(buf), buf.length);
+  });
 });

test/napi/src/js/objects.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use neon::prelude::*;
 use neon::types::buffer::TypedArray;
 
@@ -189,3 +191,31 @@ pub fn write_buffer_with_borrow_mut(mut cx: FunctionContext) -> JsResult<JsUndef
 
     Ok(cx.undefined())
 }
+
+// Accepts either a `JsString` or `JsBuffer` and returns the contents as
+// as bytes; avoids copying.
+fn get_bytes<'cx, 'a, C>(cx: &'a mut C, v: Handle<JsValue>) -> NeonResult<Cow<'a, [u8]>>
+where
+    C: Context<'cx>,
+{
+    if let Ok(v) = v.downcast::<JsString, _>(cx) {
+        return Ok(Cow::Owned(v.value(cx).into_bytes()));
+    }
+
+    if let Ok(v) = v.downcast::<JsBuffer, _>(cx) {
+        return Ok(Cow::Borrowed(v.as_slice(cx)));
+    }
+
+    cx.throw_type_error("Value must be a string or Buffer")
+}
+
+pub fn byte_length(mut cx: FunctionContext) -> JsResult<JsNumber> {
+    let v = cx.argument::<JsValue>(0)?;
+    let bytes = get_bytes(&mut cx, v)?;
+
+    // `v` is dropped here, but `bytes` is still valid since the data is on the V8 heap
+
+    let len = bytes.len();
+
+    Ok(cx.number(len as f64))
+}

test/napi/src/lib.rs

@@ -242,6 +242,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("read_buffer_with_borrow", read_buffer_with_borrow)?;
     cx.export_function("write_buffer_with_lock", write_buffer_with_lock)?;
     cx.export_function("write_buffer_with_borrow_mut", write_buffer_with_borrow_mut)?;
+    cx.export_function("byte_length", byte_length)?;
 
     cx.export_function("create_date", create_date)?;
     cx.export_function("get_date_value", get_date_value)?;