feat: add call_with_context to v8::Function (#1350)

src/function.rs

@@ -850,6 +850,7 @@ impl Function {
     Self::builder_raw(callback).build(scope)
   }
 
+  /// Call a function in a context scope.
   #[inline]
   pub fn call<'s>(
     &self,
@@ -867,6 +868,34 @@ impl Function {
     }
   }
 
+  /// Call a function in a given context.
+  #[inline]
+  pub fn call_with_context<'s>(
+    &self,
+    scope: &mut HandleScope<'s, ()>,
+    context: Local<Context>,
+    recv: Local<Value>,
+    args: &[Local<Value>],
+  ) -> Option<Local<'s, Value>> {
+    let args = Local::slice_into_raw(args);
+    let argc = int::try_from(args.len()).unwrap();
+    let argv = args.as_ptr();
+    unsafe {
+      let ret = v8__Function__Call(
+        self,
+        context.as_non_null().as_ptr(),
+        &*recv,
+        argc,
+        argv,
+      );
+      if ret.is_null() {
+        None
+      } else {
+        scope.cast_local(|_| ret)
+      }
+    }
+  }
+
   #[inline(always)]
   pub fn new_instance<'s>(
     &self,

tests/test_api.rs

@@ -3897,6 +3897,27 @@ fn function() {
     assert!(value.is_boolean());
     assert!(value.boolean_value(scope));
   }
+
+  {
+    let mut root_scope = v8::HandleScope::new(isolate);
+    let context = v8::Context::new(&mut root_scope);
+    let mut scope = v8::ContextScope::new(&mut root_scope, context);
+
+    let function: v8::Local<v8::Function> =
+      eval(&mut scope, "function a() { return 1; }; a")
+        .unwrap()
+        .try_into()
+        .unwrap();
+    drop(scope);
+
+    let recv = v8::undefined(&mut root_scope).into();
+    let ret = function
+      .call_with_context(&mut root_scope, context, recv, &[])
+      .unwrap();
+    let integer: v8::Local<v8::Integer> = ret.try_into().unwrap();
+    let mut scope = v8::ContextScope::new(&mut root_scope, context);
+    assert_eq!(integer.int32_value(&mut scope).unwrap(), 1);
+  }
 }
 
 #[test]