How to pass JavaScript functions from V8 to Rust?

[adhamsalama]

Hello everyone

I am following this tutorial about how to write a custom JavaScript runtime using Deno and Rust
https://deno.com/blog/roll-your-own-javascript-runtime
and I'm stuck on implementing setTimeout, because I don't know how JavaScript functions are passed from V8 to Rust, so I don't know what op_set_timeout function signature would look like.

Can anyone help?

Thanks in advance!

[bartlomieju]

Example:

deno/core/ops_builtin_v8.rs

Lines 53 to 66 in 26f42a2

	#[op(v8)]
	fn op_set_promise_reject_callback<'a>(
	scope: &mut v8::HandleScope<'a>,
	cb: serde_v8::Value,
	) -> Result<Option<serde_v8::Value<'a>>, Error> {
	let cb = to_v8_fn(scope, cb)?;
	let context_state_rc = JsRealm::state_from_scope(scope);
	let old = context_state_rc
	.borrow_mut()
	.js_promise_reject_cb
	.replace(Rc::new(cb));
	let old = old.map(|v| v8::Local::new(scope, &*v));
	Ok(old.map(|v| from_v8(scope, v.into()).unwrap()))
	}

.

That said - this is limited to only synchronous ops. You won't be able to pass and call a JS function in an asynchronous op.

If you want to see how to implement setTimeout API watch this talk where I walked through it: https://www.youtube.com/watch?v=xJXQwuTB_7Y

[adhamsalama]

Sorry for the late reply, thanks for the answer and the video!

[adhamsalama]

@bartlomieju This is great, but can you tell how much more complex implementing setInterval is?
The thing with setInterval is that it returns and intervalId which can be used to cancel that interval using clearInterval.
So, how would that be implemented in a single Rust function?

[yuhr]

For future readers like me: node:inspector implementation will greatly help.

deno/ext/node/ops/inspector.rs

Lines 103 to 161 in d91658b

	#[op2(stack_trace)]
	#[cppgc]
	pub fn op_inspector_connect<'s, P>(
	isolate: *mut v8::Isolate,
	scope: &mut v8::HandleScope<'s>,
	state: &mut OpState,
	connect_to_main_thread: bool,
	callback: v8::Local<'s, v8::Function>,
	) -> Result<JSInspectorSession, InspectorConnectError>
	where
	P: NodePermissions + 'static,
	{
	state
	.borrow_mut::<P>()
	.check_sys("inspector", "inspector.Session.connect")?;
	if connect_to_main_thread {
	return Err(InspectorConnectError::ConnectToMainThreadUnsupported);
	}
	let context = scope.get_current_context();
	let context = v8::Global::new(scope, context);
	let callback = v8::Global::new(scope, callback);
	let inspector = state
	.borrow::<Rc<RefCell<JsRuntimeInspector>>>()
	.borrow_mut();
	let tx = inspector.create_raw_session(
	InspectorSessionOptions {
	kind: InspectorSessionKind::NonBlocking {
	wait_for_disconnect: false,
	},
	},
	// The inspector connection does not keep the event loop alive but
	// when the inspector sends a message to the frontend, the JS that
	// that runs may keep the event loop alive so we have to call back
	// synchronously, instead of using the usual LocalInspectorSession
	// UnboundedReceiver<InspectorMsg> API.
	Box::new(move |message| {
	// SAFETY: This function is called directly by the inspector, so
	// 1) The isolate is still valid
	// 2) We are on the same thread as the Isolate
	let scope = unsafe { &mut v8::CallbackScope::new(&mut *isolate) };
	let context = v8::Local::new(scope, context.clone());
	let scope = &mut v8::ContextScope::new(scope, context);
	let scope = &mut v8::TryCatch::new(scope);
	let recv = v8::undefined(scope);
	if let Some(message) = v8::String::new(scope, &message.content) {
	let callback = v8::Local::new(scope, callback.clone());
	callback.call(scope, recv.into(), &[message.into()]);
	}
	}),
	);
	Ok(JSInspectorSession {
	tx: RefCell::new(Some(tx)),
	})
	}

Asynchronous ops are also possible by using #[op2(async)] attribute, but pub async fn doesn't work for some reason, so use impl Future<Output = ...> return type instead. Rust edition 2024 also requires adding + use<> to the RPIT.

[adhamsalama]

You re-ignited my spark. I may try to have another go at this. Thanks!