Introduce context::ffi

Author: branchseer

src/context/ffi.rs

@@ -0,0 +1,45 @@
+use super::internal::{ContextInternal, Env, Scope, ScopeMetadata};
+use super::Context;
+use neon_runtime::raw;
+
+/// Opaque type representing the underlying env of a context
+///
+/// See `Context::with_raw_env` for details.
+#[repr(C)]
+pub struct RawEnv {
+    // Create opaque type as suggested in https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
+
+impl RawEnv {
+    /// Creates a context in the env
+    pub fn with_context<T, F>(&mut self, f: F) -> T
+    where
+        F: for<'b> FnOnce(RawContext<'b>) -> T,
+    {
+        let env = unsafe { std::mem::transmute(self) };
+        RawContext::with(env, f)
+    }
+}
+
+pub struct RawContext<'a> {
+    scope: Scope<'a, raw::HandleScope>,
+}
+
+impl<'a> ContextInternal<'a> for RawContext<'a> {
+    fn scope_metadata(&self) -> &ScopeMetadata {
+        &self.scope.metadata
+    }
+}
+
+impl<'a> Context<'a> for RawContext<'a> {}
+
+impl<'a> RawContext<'a> {
+    fn with<T, F>(env: Env, f: F) -> T
+    where
+        F: for<'b> FnOnce(RawContext<'b>) -> T,
+    {
+        Scope::with(env, |scope| f(RawContext { scope }))
+    }
+}

src/context/mod.rs

@@ -146,6 +146,8 @@
 //! [iterator]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators
 //! [question-mark]: https://doc.rust-lang.org/edition-guide/rust-2018/error-handling-and-panics/the-question-mark-operator-for-easier-error-handling.html
 
+#[cfg(feature = "napi-1")]
+pub mod ffi;
 pub(crate) mod internal;
 
 use crate::borrow::internal::Ledger;
@@ -181,6 +183,8 @@ use std::marker::PhantomData;
 use std::os::raw::c_void;
 use std::panic::UnwindSafe;
 
+#[cfg(feature = "napi-1")]
+use self::ffi::RawEnv;
 use self::internal::{ContextInternal, Scope, ScopeMetadata};
 
 #[repr(C)]
@@ -294,10 +298,21 @@ impl<'a> Lock<'a> {
 ///
 /// A context has a lifetime `'a`, which ensures the safety of handles managed by the JS garbage collector. All handles created during the lifetime of a context are kept alive for that duration and cannot outlive the context.
 pub trait Context<'a>: ContextInternal<'a> {
-    /// Get the underlying `napi-env` of the context
+    /// Gets the underlying env handle of the context
+    ///
+    /// RawEnv is an opaque C struct, so `&mut RawEnv` is allowed to be converted to a `*mut void`, passed
+    /// across FFI boundaries, and converted back to `&mut RawEnv`.
     #[cfg(feature = "napi-1")]
-    fn as_mut_ptr(&mut self) -> *mut c_void {
-        self.env().to_raw() as *mut c_void
+    fn with_raw_env<T, F>(&mut self, f: F) -> T
+    where
+        F: for<'b> FnOnce(&'b mut RawEnv) -> T,
+    {
+        self.check_active();
+        self.deactivate();
+        let raw_env = unsafe { &mut *(self.env().to_raw().cast::<RawEnv>()) };
+        let result = f(raw_env);
+        self.activate();
+        result
     }
 
     /// Lock the JavaScript engine, returning an RAII guard that keeps the lock active as long as the guard is alive.
@@ -824,20 +839,7 @@ impl<'a> TaskContext<'a> {
         Scope::with(env, |scope| f(TaskContext { scope }))
     }
 
-    /// Constructs a context from a raw pointer.
-    ///
-    /// # Safety
-    /// The raw pointer `env` must be a `napi_env` that remains valid during the call of this method.
-    #[cfg(feature = "napi-1")]
-    pub unsafe fn with_raw_env<T, F: for<'b> FnOnce(TaskContext<'b>) -> T>(
-        env: *mut c_void,
-        f: F,
-    ) -> T {
-        let env = std::mem::transmute(env);
-        Self::with_context(env, f)
-    }
-
-    #[cfg(feature = "napi-1")]
+    #[cfg(all(feature = "napi-4", feature = "channel-api"))]
     pub(crate) fn with_context<T, F: for<'b> FnOnce(TaskContext<'b>) -> T>(env: Env, f: F) -> T {
         Scope::with(env, |scope| f(TaskContext { scope }))
     }

test/napi/src/lib.rs

@@ -25,6 +25,8 @@ use js::objects::*;
 use js::strings::*;
 use js::threads::*;
 use js::types::*;
+use neon::context::ffi::RawEnv;
+use std::os::raw::c_void;
 
 #[neon::main]
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
@@ -107,13 +109,15 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
         .collect::<Result<Vec<_>, _>>()?;
     assert_eq!(property_names, &["0", "a", "whatever"]);
 
-    let raw_env = cx.as_mut_ptr();
-    let forty_two = unsafe {
-        TaskContext::with_raw_env(raw_env, |mut cx| {
-            let forty_two = cx.number(42);
-            forty_two.value(&mut cx) as u8
+    let forty_two = cx.with_raw_env(|mut env| {
+        let env_ptr = env as *mut RawEnv as *mut c_void;
+        let env = unsafe { &mut *(env_ptr.cast::<RawEnv>()) };
+        env.with_context(|mut cx| {
+            let num = cx.number(42);
+            num.value(&mut cx) as u8
         })
-    };
+    });
+
     assert_eq!(forty_two, 42);
 
     cx.export_value("rustCreated", rust_created)?;