Merge pull request #198 from napi-rs/cleanup

Cleanup
This commit is contained in:
LongYinan 2020-09-26 23:28:38 +08:00 committed by GitHub
commit c668f8dd8e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 152 additions and 167 deletions

View file

@ -93,8 +93,7 @@ pub fn js_function(attr: TokenStream, input: TokenStream) -> TokenStream {
use std::ffi::CString; use std::ffi::CString;
use napi::{JsUnknown, Env, Error, Status, NapiValue, CallContext}; use napi::{JsUnknown, Env, Error, Status, NapiValue, CallContext};
let mut argc = #arg_len_span as usize; let mut argc = #arg_len_span as usize;
let mut raw_args = let mut raw_args: [napi::sys::napi_value; #arg_len_span] = [ptr::null_mut(); #arg_len_span];
unsafe { mem::MaybeUninit::<[napi::sys::napi_value; #arg_len_span as usize]>::uninit().assume_init() };
let mut raw_this = ptr::null_mut(); let mut raw_this = ptr::null_mut();
let mut has_error = false; let mut has_error = false;
@ -112,19 +111,19 @@ pub fn js_function(attr: TokenStream, input: TokenStream) -> TokenStream {
} }
let mut env = Env::from_raw(raw_env); let mut env = Env::from_raw(raw_env);
match CallContext::new(&mut env, cb_info, raw_this, &raw_args, #arg_len_span, argc as usize) let ctx = CallContext::new(&mut env, cb_info, raw_this, &raw_args, #arg_len_span, argc as usize);
.and_then(|ctx| panic::catch_unwind(AssertUnwindSafe(move || #new_fn_name(ctx))).map_err(|e| { match panic::catch_unwind(AssertUnwindSafe(move || #new_fn_name(ctx))).map_err(|e| {
let message = { let message = {
if let Some(string) = e.downcast_ref::<String>() { if let Some(string) = e.downcast_ref::<String>() {
string.clone() string.clone()
} else if let Some(string) = e.downcast_ref::<&str>() { } else if let Some(string) = e.downcast_ref::<&str>() {
string.to_string() string.to_string()
} else { } else {
format!("panic from Rust code: {:?}", e) format!("panic from Rust code: {:?}", e)
} }
}; };
Error::from_reason(message) Error::from_reason(message)
}).and_then(|v| v)) }).and_then(|v| v)
{ {
Ok(v) => v.raw_value(), Ok(v) => v.raw_value(),
Err(e) => { Err(e) => {

View file

@ -4,54 +4,76 @@ use std::ptr;
use crate::error::check_status; use crate::error::check_status;
use crate::js_values::NapiValue; use crate::js_values::NapiValue;
use crate::{sys, Env, Result, Task}; use crate::{sys, Env, JsObject, Result, Task};
pub struct AsyncWork<T: Task> { struct AsyncWork<T: Task> {
inner_task: T, inner_task: T,
deferred: sys::napi_deferred, deferred: sys::napi_deferred,
value: Result<*mut T::Output>, value: Result<mem::MaybeUninit<T::Output>>,
napi_async_work: sys::napi_async_work,
} }
impl<T: Task> AsyncWork<T> { #[derive(Debug)]
pub fn run(env: sys::napi_env, task: T, deferred: sys::napi_deferred) -> Result<()> { pub struct AsyncWorkPromise<'env> {
let mut raw_resource = ptr::null_mut(); napi_async_work: sys::napi_async_work,
check_status(unsafe { sys::napi_create_object(env, &mut raw_resource) })?; raw_promise: sys::napi_value,
let mut raw_name = ptr::null_mut(); env: &'env Env,
let s = "napi_rs_async"; }
check_status(unsafe {
sys::napi_create_string_utf8( impl<'env> AsyncWorkPromise<'env> {
env, #[inline(always)]
s.as_ptr() as *const c_char, pub fn promise_object(&self) -> JsObject {
s.len() as u64, JsObject::from_raw_unchecked(self.env.0, self.raw_promise)
&mut raw_name,
)
})?;
let result = AsyncWork {
inner_task: task,
deferred,
value: Ok(ptr::null_mut()),
};
let mut async_work = ptr::null_mut();
check_status(unsafe {
sys::napi_create_async_work(
env,
raw_resource,
raw_name,
Some(execute::<T> as unsafe extern "C" fn(env: sys::napi_env, data: *mut c_void)),
Some(
complete::<T>
as unsafe extern "C" fn(
env: sys::napi_env,
status: sys::napi_status,
data: *mut c_void,
),
),
Box::leak(Box::new(result)) as *mut _ as *mut c_void,
&mut async_work,
)
})?;
check_status(unsafe { sys::napi_queue_async_work(env, async_work) })
} }
pub fn cancel(self) -> Result<()> {
check_status(unsafe { sys::napi_cancel_async_work(self.env.0, self.napi_async_work) })
}
}
#[inline(always)]
pub fn run<'env, T: Task>(env: &'env Env, task: T) -> Result<AsyncWorkPromise<'env>> {
let mut raw_resource = ptr::null_mut();
check_status(unsafe { sys::napi_create_object(env.0, &mut raw_resource) })?;
let mut raw_promise = ptr::null_mut();
let mut deferred = ptr::null_mut();
check_status(unsafe { sys::napi_create_promise(env.0, &mut deferred, &mut raw_promise) })?;
let mut raw_name = ptr::null_mut();
let s = "napi_rs_async_work";
check_status(unsafe {
sys::napi_create_string_utf8(
env.0,
s.as_ptr() as *const c_char,
s.len() as u64,
&mut raw_name,
)
})?;
let result = Box::leak(Box::new(AsyncWork {
inner_task: task,
deferred,
value: Ok(mem::MaybeUninit::zeroed()),
napi_async_work: ptr::null_mut(),
}));
check_status(unsafe {
sys::napi_create_async_work(
env.0,
raw_resource,
raw_name,
Some(execute::<T> as unsafe extern "C" fn(env: sys::napi_env, data: *mut c_void)),
Some(
complete::<T>
as unsafe extern "C" fn(env: sys::napi_env, status: sys::napi_status, data: *mut c_void),
),
result as *mut _ as *mut c_void,
&mut result.napi_async_work,
)
})?;
check_status(unsafe { sys::napi_queue_async_work(env.0, result.napi_async_work) })?;
Ok(AsyncWorkPromise {
napi_async_work: result.napi_async_work,
raw_promise,
env,
})
} }
unsafe impl<T: Task> Send for AsyncWork<T> {} unsafe impl<T: Task> Send for AsyncWork<T> {}
@ -60,10 +82,10 @@ unsafe impl<T: Task> Sync for AsyncWork<T> {}
unsafe extern "C" fn execute<T: Task>(_env: sys::napi_env, data: *mut c_void) { unsafe extern "C" fn execute<T: Task>(_env: sys::napi_env, data: *mut c_void) {
let mut work = Box::from_raw(data as *mut AsyncWork<T>); let mut work = Box::from_raw(data as *mut AsyncWork<T>);
work.value = work let _ = mem::replace(
.inner_task &mut work.value,
.compute() work.inner_task.compute().map(|v| mem::MaybeUninit::new(v)),
.map(|v| Box::into_raw(Box::from(v))); );
Box::leak(work); Box::leak(work);
} }
@ -73,37 +95,26 @@ unsafe extern "C" fn complete<T: Task>(
data: *mut c_void, data: *mut c_void,
) { ) {
let mut work = Box::from_raw(data as *mut AsyncWork<T>); let mut work = Box::from_raw(data as *mut AsyncWork<T>);
let value_ptr = mem::replace(&mut work.value, Ok(ptr::null_mut())); let value_ptr = mem::replace(&mut work.value, Ok(mem::MaybeUninit::zeroed()));
let deferred = mem::replace(&mut work.deferred, ptr::null_mut()); let deferred = mem::replace(&mut work.deferred, ptr::null_mut());
let napi_async_work = mem::replace(&mut work.napi_async_work, ptr::null_mut());
let value = value_ptr.and_then(move |v| { let value = value_ptr.and_then(move |v| {
let mut env = Env::from_raw(env); let output = v.assume_init();
let output = ptr::read(v as *const _); work.inner_task.resolve(&mut Env::from_raw(env), output)
work.inner_task.resolve(&mut env, output)
}); });
let mut handle_scope = ptr::null_mut();
match check_status(status).and_then(move |_| value) { match check_status(status).and_then(move |_| value) {
Ok(v) => { Ok(v) => {
let open_handle_status = sys::napi_open_handle_scope(env, &mut handle_scope);
debug_assert!(
open_handle_status == sys::napi_status::napi_ok,
"OpenHandleScope failed"
);
let status = sys::napi_resolve_deferred(env, deferred, v.raw_value()); let status = sys::napi_resolve_deferred(env, deferred, v.raw_value());
debug_assert!(status == sys::napi_status::napi_ok, "Reject promise failed"); debug_assert!(status == sys::napi_status::napi_ok, "Reject promise failed");
} }
Err(e) => { Err(e) => {
let open_handle_status = sys::napi_open_handle_scope(env, &mut handle_scope);
debug_assert!(
open_handle_status == sys::napi_status::napi_ok,
"OpenHandleScope failed"
);
let status = sys::napi_reject_deferred(env, deferred, e.into_raw(env)); let status = sys::napi_reject_deferred(env, deferred, e.into_raw(env));
debug_assert!(status == sys::napi_status::napi_ok, "Reject promise failed"); debug_assert!(status == sys::napi_status::napi_ok, "Reject promise failed");
} }
}; };
let close_handle_scope_status = sys::napi_close_handle_scope(env, handle_scope); let delete_status = sys::napi_delete_async_work(env, napi_async_work);
debug_assert!( debug_assert!(
close_handle_scope_status == sys::napi_status::napi_ok, delete_status == sys::napi_status::napi_ok,
"Close handle scope failed" "Delete async work failed"
); );
} }

View file

@ -1,34 +1,34 @@
use std::ptr; use std::ptr;
use crate::error::check_status; use crate::error::check_status;
use crate::{sys, Either, Env, Error, JsUndefined, JsUnknown, NapiValue, Result, Status}; use crate::{sys, Either, Env, Error, JsUndefined, NapiValue, Result, Status};
pub struct CallContext<'env, T: NapiValue = JsUnknown> { pub struct CallContext<'env> {
pub env: &'env Env, pub env: &'env Env,
pub this: T, raw_this: sys::napi_value,
callback_info: sys::napi_callback_info, callback_info: sys::napi_callback_info,
args: &'env [sys::napi_value], args: &'env [sys::napi_value],
arg_len: usize, arg_len: usize,
actual_arg_length: usize, actual_arg_length: usize,
} }
impl<'env, T: NapiValue> CallContext<'env, T> { impl<'env> CallContext<'env> {
pub fn new( pub fn new(
env: &'env Env, env: &'env Env,
callback_info: sys::napi_callback_info, callback_info: sys::napi_callback_info,
this: sys::napi_value, raw_this: sys::napi_value,
args: &'env [sys::napi_value], args: &'env [sys::napi_value],
arg_len: usize, arg_len: usize,
actual_arg_length: usize, actual_arg_length: usize,
) -> Result<Self> { ) -> Self {
Ok(Self { Self {
env, env,
callback_info, callback_info,
this: T::from_raw(env.0, this)?, raw_this,
args, args,
arg_len, arg_len,
actual_arg_length, actual_arg_length,
}) }
} }
pub fn get<ArgType: NapiValue>(&self, index: usize) -> Result<ArgType> { pub fn get<ArgType: NapiValue>(&self, index: usize) -> Result<ArgType> {
@ -38,10 +38,7 @@ impl<'env, T: NapiValue> CallContext<'env, T> {
reason: "Arguments index out of range".to_owned(), reason: "Arguments index out of range".to_owned(),
}) })
} else { } else {
Ok(ArgType::from_raw_without_typecheck( Ok(ArgType::from_raw_unchecked(self.env.0, self.args[index]))
self.env.0,
self.args[index],
))
} }
} }
@ -68,4 +65,14 @@ impl<'env, T: NapiValue> CallContext<'env, T> {
check_status(unsafe { sys::napi_get_new_target(self.env.0, self.callback_info, &mut value) })?; check_status(unsafe { sys::napi_get_new_target(self.env.0, self.callback_info, &mut value) })?;
V::from_raw(self.env.0, value) V::from_raw(self.env.0, value)
} }
#[inline(always)]
pub fn this<T: NapiValue>(&self) -> Result<T> {
T::from_raw(self.env.0, self.raw_this)
}
#[inline(always)]
pub fn this_unchecked<T: NapiValue>(&self) -> T {
T::from_raw_unchecked(self.env.0, self.raw_this)
}
} }

View file

@ -5,7 +5,7 @@ use std::mem;
use std::os::raw::{c_char, c_void}; use std::os::raw::{c_char, c_void};
use std::ptr; use std::ptr;
use crate::async_work::AsyncWork; use crate::async_work::{self, AsyncWorkPromise};
use crate::error::check_status; use crate::error::check_status;
use crate::js_values::*; use crate::js_values::*;
use crate::task::Task; use crate::task::Task;
@ -40,8 +40,7 @@ impl Env {
pub fn get_undefined(&self) -> Result<JsUndefined> { pub fn get_undefined(&self) -> Result<JsUndefined> {
let mut raw_value = ptr::null_mut(); let mut raw_value = ptr::null_mut();
let status = unsafe { sys::napi_get_undefined(self.0, &mut raw_value) }; check_status(unsafe { sys::napi_get_undefined(self.0, &mut raw_value) })?;
check_status(status)?;
Ok(JsUndefined::from_raw_unchecked(self.0, raw_value)) Ok(JsUndefined::from_raw_unchecked(self.0, raw_value))
} }
@ -220,7 +219,7 @@ impl Env {
Ok(JsObject::from_raw_unchecked(self.0, raw_value)) Ok(JsObject::from_raw_unchecked(self.0, raw_value))
} }
pub fn create_buffer(&self, length: u64) -> Result<JsBuffer> { pub fn create_buffer<'env, 'buffer>(&'env self, length: u64) -> Result<JsBuffer<'buffer>> {
let mut raw_value = ptr::null_mut(); let mut raw_value = ptr::null_mut();
let mut data = Vec::with_capacity(length as usize); let mut data = Vec::with_capacity(length as usize);
let mut data_ptr = data.as_mut_ptr(); let mut data_ptr = data.as_mut_ptr();
@ -229,7 +228,7 @@ impl Env {
})?; })?;
mem::forget(data); mem::forget(data);
Ok(JsBuffer::from_raw_unchecked( Ok(JsBuffer::new(
self.0, self.0,
raw_value, raw_value,
data_ptr as *mut u8, data_ptr as *mut u8,
@ -237,7 +236,10 @@ impl Env {
)) ))
} }
pub fn create_buffer_with_data(&self, mut data: Vec<u8>) -> Result<JsBuffer> { pub fn create_buffer_with_data<'env, 'buffer>(
&'env self,
mut data: Vec<u8>,
) -> Result<JsBuffer<'buffer>> {
let length = data.len() as u64; let length = data.len() as u64;
let mut raw_value = ptr::null_mut(); let mut raw_value = ptr::null_mut();
let data_ptr = data.as_mut_ptr(); let data_ptr = data.as_mut_ptr();
@ -254,12 +256,7 @@ impl Env {
let mut changed = 0; let mut changed = 0;
check_status(unsafe { sys::napi_adjust_external_memory(self.0, length as i64, &mut changed) })?; check_status(unsafe { sys::napi_adjust_external_memory(self.0, length as i64, &mut changed) })?;
mem::forget(data); mem::forget(data);
Ok(JsBuffer::from_raw_unchecked( Ok(JsBuffer::new(self.0, raw_value, data_ptr, length as usize))
self.0,
raw_value,
data_ptr,
length as usize,
))
} }
pub fn create_arraybuffer(&self, length: u64) -> Result<JsArrayBuffer> { pub fn create_arraybuffer(&self, length: u64) -> Result<JsArrayBuffer> {
@ -490,13 +487,8 @@ impl Env {
Ok(JsObject::from_raw_unchecked(self.0, result)) Ok(JsObject::from_raw_unchecked(self.0, result))
} }
pub fn spawn<T: 'static + Task>(&self, task: T) -> Result<JsObject> { pub fn spawn<T: 'static + Task>(&self, task: T) -> Result<AsyncWorkPromise> {
let mut raw_promise = ptr::null_mut(); async_work::run(self, task)
let mut raw_deferred = ptr::null_mut();
check_status(unsafe { sys::napi_create_promise(self.0, &mut raw_deferred, &mut raw_promise) })?;
AsyncWork::run(self.0, task, raw_deferred)?;
Ok(JsObject::from_raw_unchecked(self.0, raw_promise))
} }
pub fn get_global(&self) -> Result<JsObject> { pub fn get_global(&self) -> Result<JsObject> {

View file

@ -154,7 +154,7 @@ impl NapiValue for JsArrayBuffer {
}) })
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Self { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self {
let mut data = ptr::null_mut(); let mut data = ptr::null_mut();
let mut len: u64 = 0; let mut len: u64 = 0;
let status = unsafe { sys::napi_get_arraybuffer_info(env, value, &mut data, &mut len) }; let status = unsafe { sys::napi_get_arraybuffer_info(env, value, &mut data, &mut len) };

View file

@ -154,7 +154,7 @@ impl NapiValue for JsBigint {
}) })
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Self { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self {
let mut word_count: u64 = 0; let mut word_count: u64 = 0;
let status = unsafe { let status = unsafe {
sys::napi_get_value_bigint_words( sys::napi_get_value_bigint_words(

View file

@ -8,18 +8,13 @@ use crate::error::check_status;
use crate::{sys, Error, Result}; use crate::{sys, Error, Result};
#[derive(Debug)] #[derive(Debug)]
pub struct JsBuffer { pub struct JsBuffer<'buffer> {
pub value: JsObject, pub value: JsObject,
pub data: &'static [u8], pub data: &'buffer [u8],
} }
impl JsBuffer { impl<'buffer> JsBuffer<'buffer> {
pub(crate) fn from_raw_unchecked( pub(crate) fn new(env: sys::napi_env, value: sys::napi_value, data: *mut u8, len: usize) -> Self {
env: sys::napi_env,
value: sys::napi_value,
data: *mut u8,
len: usize,
) -> Self {
Self { Self {
value: JsObject(Value { value: JsObject(Value {
env, env,
@ -139,7 +134,7 @@ impl JsBuffer {
} }
} }
impl NapiValue for JsBuffer { impl<'buffer> NapiValue for JsBuffer<'buffer> {
fn raw_value(&self) -> sys::napi_value { fn raw_value(&self) -> sys::napi_value {
self.value.0.value self.value.0.value
} }
@ -158,7 +153,7 @@ impl NapiValue for JsBuffer {
}) })
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Self { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self {
let mut data = ptr::null_mut(); let mut data = ptr::null_mut();
let mut len: u64 = 0; let mut len: u64 = 0;
let status = unsafe { sys::napi_get_buffer_info(env, value, &mut data, &mut len) }; let status = unsafe { sys::napi_get_buffer_info(env, value, &mut data, &mut len) };
@ -177,13 +172,13 @@ impl NapiValue for JsBuffer {
} }
} }
impl AsRef<[u8]> for JsBuffer { impl<'buffer> AsRef<[u8]> for JsBuffer<'buffer> {
fn as_ref(&self) -> &[u8] { fn as_ref(&self) -> &[u8] {
self.data self.data
} }
} }
impl Deref for JsBuffer { impl<'buffer> Deref for JsBuffer<'buffer> {
type Target = [u8]; type Target = [u8];
fn deref(&self) -> &[u8] { fn deref(&self) -> &[u8] {
@ -191,9 +186,9 @@ impl Deref for JsBuffer {
} }
} }
impl TryFrom<JsUnknown> for JsBuffer { impl<'buffer> TryFrom<JsUnknown> for JsBuffer<'buffer> {
type Error = Error; type Error = Error;
fn try_from(value: JsUnknown) -> Result<JsBuffer> { fn try_from(value: JsUnknown) -> Result<JsBuffer<'buffer>> {
JsBuffer::from_raw(value.0.env, value.0.value) JsBuffer::from_raw(value.0.env, value.0.value)
} }
} }

View file

@ -22,7 +22,7 @@ impl<A: NapiValue, B: NapiValue> NapiValue for Either<A, B> {
.or_else(|_| B::from_raw(env, value).map(Self::B)) .or_else(|_| B::from_raw(env, value).map(Self::B))
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Either<A, B> { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Either<A, B> {
Self::from_raw(env, value).unwrap() Self::from_raw(env, value).unwrap()
} }

View file

@ -92,7 +92,7 @@ macro_rules! impl_napi_value_trait {
self.0.value self.0.value
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> $js_value { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> $js_value {
$js_value(Value { $js_value(Value {
env, env,
value, value,
@ -101,17 +101,6 @@ macro_rules! impl_napi_value_trait {
} }
} }
impl $js_value {
#[inline]
pub fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self {
Self(Value {
env,
value,
value_type: $value_type,
})
}
}
impl TryFrom<JsUnknown> for $js_value { impl TryFrom<JsUnknown> for $js_value {
type Error = Error; type Error = Error;
fn try_from(value: JsUnknown) -> Result<$js_value> { fn try_from(value: JsUnknown) -> Result<$js_value> {
@ -231,7 +220,7 @@ macro_rules! impl_js_value_methods {
pub trait NapiValue: Sized { pub trait NapiValue: Sized {
fn from_raw(env: sys::napi_env, value: sys::napi_value) -> Result<Self>; fn from_raw(env: sys::napi_env, value: sys::napi_value) -> Result<Self>;
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Self; fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self;
fn raw_value(&self) -> sys::napi_value; fn raw_value(&self) -> sys::napi_value;
} }
@ -268,7 +257,7 @@ impl NapiValue for JsUnknown {
})) }))
} }
fn from_raw_without_typecheck(env: sys::napi_env, value: sys::napi_value) -> Self { fn from_raw_unchecked(env: sys::napi_env, value: sys::napi_value) -> Self {
JsUnknown(Value { JsUnknown(Value {
env, env,
value, value,

View file

@ -12,24 +12,19 @@ fn create_test_class(ctx: CallContext) -> Result<JsFunction> {
} }
#[js_function(1)] #[js_function(1)]
fn test_class_constructor(mut ctx: CallContext<JsObject>) -> Result<JsUndefined> { fn test_class_constructor(ctx: CallContext) -> Result<JsUndefined> {
let count = ctx.get::<JsNumber>(0)?; let count = ctx.get::<JsNumber>(0)?;
ctx let mut this: JsObject = ctx.this_unchecked();
.this this.set_named_property("count", ctx.env.create_int32(count.try_into()?)?)?;
.set_named_property("count", ctx.env.create_int32(count.try_into()?)?)?;
ctx.env.get_undefined() ctx.env.get_undefined()
} }
#[js_function(1)] #[js_function(1)]
fn add_count(mut ctx: CallContext<JsObject>) -> Result<JsUndefined> { fn add_count(ctx: CallContext) -> Result<JsUndefined> {
let add: i32 = ctx.get::<JsNumber>(0)?.try_into()?; let add: i32 = ctx.get::<JsNumber>(0)?.try_into()?;
let count: i32 = ctx let mut this: JsObject = ctx.this_unchecked();
.this let count: i32 = this.get_named_property::<JsNumber>("count")?.try_into()?;
.get_named_property::<JsNumber>("count")? this.set_named_property("count", ctx.env.create_int32(count + add)?)?;
.try_into()?;
ctx
.this
.set_named_property("count", ctx.env.create_int32(count + add)?)?;
ctx.env.get_undefined() ctx.env.get_undefined()
} }

View file

@ -12,11 +12,11 @@ pub fn call_function(ctx: CallContext) -> Result<JsNull> {
} }
#[js_function(1)] #[js_function(1)]
pub fn call_function_with_this(ctx: CallContext<JsObject>) -> Result<JsNull> { pub fn call_function_with_this(ctx: CallContext) -> Result<JsNull> {
let js_this = &ctx.this; let js_this: JsObject = ctx.this_unchecked();
let js_func = ctx.get::<JsFunction>(0)?; let js_func = ctx.get::<JsFunction>(0)?;
js_func.call(Some(js_this), &[])?; js_func.call(Some(&js_this), &[])?;
ctx.env.get_null() ctx.env.get_null()
} }

View file

@ -139,15 +139,11 @@ fn test_define_properties(ctx: CallContext) -> Result<JsUndefined> {
} }
#[js_function(1)] #[js_function(1)]
fn add(mut ctx: CallContext<JsObject>) -> Result<JsUndefined> { fn add(ctx: CallContext) -> Result<JsUndefined> {
let count: i32 = ctx let mut this: JsObject = ctx.this_unchecked();
.this let count: i32 = this.get_named_property::<JsNumber>("count")?.try_into()?;
.get_named_property::<JsNumber>("count")?
.try_into()?;
let value_to_add: i32 = ctx.get::<JsNumber>(0)?.try_into()?; let value_to_add: i32 = ctx.get::<JsNumber>(0)?.try_into()?;
ctx this.set_named_property("count", ctx.env.create_int32(count + value_to_add)?)?;
.this
.set_named_property("count", ctx.env.create_int32(count + value_to_add)?)?;
ctx.env.get_undefined() ctx.env.get_undefined()
} }

View file

@ -37,7 +37,8 @@ fn fibonacci_native(n: u32) -> u32 {
fn test_spawn_thread(ctx: CallContext) -> Result<JsObject> { fn test_spawn_thread(ctx: CallContext) -> Result<JsObject> {
let n = ctx.get::<JsNumber>(0)?; let n = ctx.get::<JsNumber>(0)?;
let task = ComputeFib::new(n.try_into()?); let task = ComputeFib::new(n.try_into()?);
ctx.env.spawn(task) let async_promise = ctx.env.spawn(task)?;
Ok(async_promise.promise_object())
} }
pub fn register_js(module: &mut Module) -> Result<()> { pub fn register_js(module: &mut Module) -> Result<()> {