summaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/00_primordials.js18
-rw-r--r--core/01_core.js77
-rw-r--r--core/02_error.js2
-rw-r--r--core/bindings.rs1159
-rw-r--r--core/encode_decode_test.js20
-rw-r--r--core/lib.rs1
-rw-r--r--core/ops.rs2
-rw-r--r--core/ops_builtin.rs8
-rw-r--r--core/ops_builtin_v8.rs788
-rw-r--r--core/runtime.rs58
-rw-r--r--core/serialize_deserialize_test.js20
11 files changed, 909 insertions, 1244 deletions
diff --git a/core/00_primordials.js b/core/00_primordials.js
index 908278e21..4ca7ce073 100644
--- a/core/00_primordials.js
+++ b/core/00_primordials.js
@@ -170,9 +170,6 @@
// Create copy of isNaN
primordials[isNaN.name] = isNaN;
- // Create copy of queueMicrotask
- primordials["queueMicrotask"] = queueMicrotask;
-
// Create copies of URI handling functions
[
decodeURI,
@@ -280,6 +277,7 @@
ArrayPrototypeForEach,
FunctionPrototypeCall,
Map,
+ ObjectDefineProperty,
ObjectFreeze,
ObjectSetPrototypeOf,
Promise,
@@ -456,6 +454,20 @@
.then(a, b)
);
+ // Create getter and setter for `queueMicrotask`, it hasn't been bound yet.
+ let queueMicrotask = undefined;
+ ObjectDefineProperty(primordials, "queueMicrotask", {
+ get() {
+ return queueMicrotask;
+ },
+ });
+ primordials.setQueueMicrotask = (value) => {
+ if (queueMicrotask !== undefined) {
+ throw new Error("queueMicrotask is already defined");
+ }
+ queueMicrotask = value;
+ };
+
ObjectSetPrototypeOf(primordials, null);
ObjectFreeze(primordials);
diff --git a/core/01_core.js b/core/01_core.js
index d48424288..9337c0231 100644
--- a/core/01_core.js
+++ b/core/01_core.js
@@ -24,12 +24,10 @@
StringPrototypeSlice,
ObjectAssign,
SymbolFor,
+ setQueueMicrotask,
} = window.__bootstrap.primordials;
const ops = window.Deno.core.ops;
- // Available on start due to bindings.
- const { refOp_, unrefOp_ } = window.Deno.core;
-
const errorMap = {};
// Builtin v8 / JS errors
registerErrorClass("Error", Error);
@@ -176,53 +174,33 @@
if (!hasPromise(promiseId)) {
return;
}
- refOp_(promiseId);
+ opSync("op_ref_op", promiseId);
}
function unrefOp(promiseId) {
if (!hasPromise(promiseId)) {
return;
}
- unrefOp_(promiseId);
+ opSync("op_unref_op", promiseId);
}
function resources() {
return ObjectFromEntries(opSync("op_resources"));
}
- function read(rid, buf) {
- return opAsync("op_read", rid, buf);
- }
-
- function write(rid, buf) {
- return opAsync("op_write", rid, buf);
- }
-
- function shutdown(rid) {
- return opAsync("op_shutdown", rid);
- }
-
- function close(rid) {
- opSync("op_close", rid);
- }
-
- function tryClose(rid) {
- opSync("op_try_close", rid);
- }
-
- function print(str, isErr = false) {
- opSync("op_print", str, isErr);
- }
-
function metrics() {
const [aggregate, perOps] = opSync("op_metrics");
aggregate.ops = ObjectFromEntries(ArrayPrototypeMap(
- core.opNames(),
+ core.opSync("op_op_names"),
(opName, opId) => [opName, perOps[opId]],
));
return aggregate;
}
+ function queueMicrotask(...args) {
+ return opSync("op_queue_microtask", ...args);
+ }
+
// Some "extensions" rely on "BadResource" and "Interrupted" errors in the
// JS code (eg. "deno_net") so they are provided in "Deno.core" but later
// reexported on "Deno.errors"
@@ -246,12 +224,6 @@
const core = ObjectAssign(globalThis.Deno.core, {
opAsync,
opSync,
- close,
- tryClose,
- read,
- write,
- shutdown,
- print,
resources,
metrics,
registerErrorBuilder,
@@ -266,8 +238,41 @@
opCallTraces,
refOp,
unrefOp,
+ close: opSync.bind(null, "op_close"),
+ tryClose: opSync.bind(null, "op_try_close"),
+ read: opAsync.bind(null, "op_read"),
+ write: opAsync.bind(null, "op_write"),
+ shutdown: opAsync.bind(null, "op_shutdown"),
+ print: opSync.bind(null, "op_print"),
+ setMacrotaskCallback: opSync.bind(null, "op_set_macrotask_callback"),
+ setNextTickCallback: opSync.bind(null, "op_set_next_tick_callback"),
+ runMicrotasks: opSync.bind(null, "op_run_microtasks"),
+ hasTickScheduled: opSync.bind(null, "op_has_tick_scheduled"),
+ setHasTickScheduled: opSync.bind(null, "op_set_has_tick_scheduled"),
+ evalContext: opSync.bind(null, "op_eval_context"),
+ createHostObject: opSync.bind(null, "op_create_host_object"),
+ encode: opSync.bind(null, "op_encode"),
+ decode: opSync.bind(null, "op_decode"),
+ serialize: opSync.bind(null, "op_serialize"),
+ deserialize: opSync.bind(null, "op_deserialize"),
+ getPromiseDetails: opSync.bind(null, "op_get_promise_details"),
+ getProxyDetails: opSync.bind(null, "op_get_proxy_details"),
+ isProxy: opSync.bind(null, "op_is_proxy"),
+ memoryUsage: opSync.bind(null, "op_memory_usage"),
+ setWasmStreamingCallback: opSync.bind(
+ null,
+ "op_set_wasm_streaming_callback",
+ ),
+ abortWasmStreaming: opSync.bind(null, "op_abort_wasm_streaming"),
+ destructureError: opSync.bind(null, "op_destructure_error"),
+ terminate: opSync.bind(null, "op_terminate"),
+ opNames: opSync.bind(null, "op_op_names"),
});
ObjectAssign(globalThis.__bootstrap, { core });
ObjectAssign(globalThis.Deno, { core });
+
+ // Direct bindings on `globalThis`
+ ObjectAssign(globalThis, { queueMicrotask });
+ setQueueMicrotask(queueMicrotask);
})(globalThis);
diff --git a/core/02_error.js b/core/02_error.js
index a7d5d0ee2..85c287102 100644
--- a/core/02_error.js
+++ b/core/02_error.js
@@ -201,7 +201,7 @@
if (fileName && lineNumber != null && columnNumber != null) {
return patchCallSite(
callSite,
- core.applySourceMap({
+ core.opSync("op_apply_source_map", {
fileName,
lineNumber,
columnNumber,
diff --git a/core/bindings.rs b/core/bindings.rs
index 48e9a4561..5681ded31 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -1,128 +1,27 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
use crate::error::is_instance_of_error;
-use crate::error::JsError;
use crate::modules::get_asserted_module_type_from_assertions;
use crate::modules::parse_import_assertions;
use crate::modules::validate_import_assertions;
use crate::modules::ImportAssertionsKind;
use crate::modules::ModuleMap;
use crate::ops::OpCtx;
-use crate::ops_builtin::WasmStreamingResource;
-use crate::resolve_url_or_path;
-use crate::source_map::apply_source_map as apply_source_map_;
use crate::JsRuntime;
-use crate::PromiseId;
-use crate::ResourceId;
-use crate::ZeroCopyBuf;
-use anyhow::Error;
use log::debug;
use once_cell::sync::Lazy;
-use serde::Deserialize;
-use serde::Serialize;
-use serde_v8::to_v8;
-use std::cell::RefCell;
-use std::collections::HashMap;
use std::option::Option;
use std::os::raw::c_void;
-use url::Url;
-use v8::HandleScope;
-use v8::Local;
use v8::MapFnTo;
-use v8::SharedArrayBuffer;
-use v8::ValueDeserializerHelper;
-use v8::ValueSerializerHelper;
pub static EXTERNAL_REFERENCES: Lazy<v8::ExternalReferences> =
Lazy::new(|| {
- v8::ExternalReferences::new(&[
- v8::ExternalReference {
- function: ref_op.map_fn_to(),
- },
- v8::ExternalReference {
- function: unref_op.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_macrotask_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_nexttick_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_promise_reject_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_uncaught_exception_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_format_exception_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: run_microtasks.map_fn_to(),
- },
- v8::ExternalReference {
- function: has_tick_scheduled.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_has_tick_scheduled.map_fn_to(),
- },
- v8::ExternalReference {
- function: eval_context.map_fn_to(),
- },
- v8::ExternalReference {
- function: queue_microtask.map_fn_to(),
- },
- v8::ExternalReference {
- function: create_host_object.map_fn_to(),
- },
- v8::ExternalReference {
- function: encode.map_fn_to(),
- },
- v8::ExternalReference {
- function: decode.map_fn_to(),
- },
- v8::ExternalReference {
- function: serialize.map_fn_to(),
- },
- v8::ExternalReference {
- function: deserialize.map_fn_to(),
- },
- v8::ExternalReference {
- function: get_promise_details.map_fn_to(),
- },
- v8::ExternalReference {
- function: get_proxy_details.map_fn_to(),
- },
- v8::ExternalReference {
- function: is_proxy.map_fn_to(),
- },
- v8::ExternalReference {
- function: memory_usage.map_fn_to(),
- },
- v8::ExternalReference {
- function: call_console.map_fn_to(),
- },
- v8::ExternalReference {
- function: set_wasm_streaming_callback.map_fn_to(),
- },
- v8::ExternalReference {
- function: abort_wasm_streaming.map_fn_to(),
- },
- v8::ExternalReference {
- function: destructure_error.map_fn_to(),
- },
- v8::ExternalReference {
- function: terminate.map_fn_to(),
- },
- v8::ExternalReference {
- function: apply_source_map.map_fn_to(),
- },
- v8::ExternalReference {
- function: op_names.map_fn_to(),
- },
- ])
+ v8::ExternalReferences::new(&[v8::ExternalReference {
+ function: call_console.map_fn_to(),
+ }])
});
+// TODO(nayeemrmn): Move to runtime and/or make `pub(crate)`.
pub fn script_origin<'a>(
s: &mut v8::HandleScope<'a>,
resource_name: v8::Local<'a, v8::String>,
@@ -191,71 +90,7 @@ pub fn initialize_context<'s>(
let core_val = JsRuntime::ensure_objs(scope, global, "Deno.core").unwrap();
// Bind functions to Deno.core.*
- set_func(scope, core_val, "refOp_", ref_op);
- set_func(scope, core_val, "unrefOp_", unref_op);
- set_func(
- scope,
- core_val,
- "setMacrotaskCallback",
- set_macrotask_callback,
- );
- set_func(
- scope,
- core_val,
- "setNextTickCallback",
- set_nexttick_callback,
- );
- set_func(
- scope,
- core_val,
- "setPromiseRejectCallback",
- set_promise_reject_callback,
- );
- set_func(
- scope,
- core_val,
- "setUncaughtExceptionCallback",
- set_uncaught_exception_callback,
- );
- set_func(
- scope,
- core_val,
- "setFormatExceptionCallback",
- set_format_exception_callback,
- );
- set_func(scope, core_val, "runMicrotasks", run_microtasks);
- set_func(scope, core_val, "hasTickScheduled", has_tick_scheduled);
- set_func(
- scope,
- core_val,
- "setHasTickScheduled",
- set_has_tick_scheduled,
- );
- set_func(scope, core_val, "evalContext", eval_context);
- set_func(scope, core_val, "encode", encode);
- set_func(scope, core_val, "decode", decode);
- set_func(scope, core_val, "serialize", serialize);
- set_func(scope, core_val, "deserialize", deserialize);
- set_func(scope, core_val, "getPromiseDetails", get_promise_details);
- set_func(scope, core_val, "getProxyDetails", get_proxy_details);
- set_func(scope, core_val, "isProxy", is_proxy);
- set_func(scope, core_val, "memoryUsage", memory_usage);
set_func(scope, core_val, "callConsole", call_console);
- set_func(scope, core_val, "createHostObject", create_host_object);
- set_func(
- scope,
- core_val,
- "setWasmStreamingCallback",
- set_wasm_streaming_callback,
- );
- set_func(scope, core_val, "abortWasmStreaming", abort_wasm_streaming);
- set_func(scope, core_val, "destructureError", destructure_error);
- set_func(scope, core_val, "terminate", terminate);
- set_func(scope, core_val, "applySourceMap", apply_source_map);
- set_func(scope, core_val, "opNames", op_names);
-
- // Direct bindings on `window`.
- set_func(scope, global, "queueMicrotask", queue_microtask);
// Bind functions to Deno.core.ops.*
let ops_obj = JsRuntime::ensure_objs(scope, global, "Deno.core.ops").unwrap();
@@ -522,249 +357,6 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
}
}
-fn ref_op<'s>(
- scope: &mut v8::HandleScope<'s>,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let mut state = state_rc.borrow_mut();
-
- let promise_id = match v8::Local::<v8::Integer>::try_from(args.get(0))
- .map(|l| l.value() as PromiseId)
- .map_err(Error::from)
- {
- Ok(promise_id) => promise_id,
- Err(err) => {
- throw_type_error(scope, format!("invalid promise id: {}", err));
- return;
- }
- };
-
- state.unrefed_ops.remove(&promise_id);
-}
-
-fn unref_op<'s>(
- scope: &mut v8::HandleScope<'s>,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let mut state = state_rc.borrow_mut();
-
- let promise_id = match v8::Local::<v8::Integer>::try_from(args.get(0))
- .map(|l| l.value() as PromiseId)
- .map_err(Error::from)
- {
- Ok(promise_id) => promise_id,
- Err(err) => {
- throw_type_error(scope, format!("invalid promise id: {}", err));
- return;
- }
- };
-
- state.unrefed_ops.insert(promise_id);
-}
-
-fn has_tick_scheduled(
- scope: &mut v8::HandleScope,
- _args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow();
- rv.set(to_v8(scope, state.has_tick_scheduled).unwrap());
-}
-
-fn set_has_tick_scheduled(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let mut state = state_rc.borrow_mut();
-
- state.has_tick_scheduled = args.get(0).is_true();
-}
-
-fn run_microtasks(
- scope: &mut v8::HandleScope,
- _args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- scope.perform_microtask_checkpoint();
-}
-
-fn set_nexttick_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- if let Ok(cb) = arg0_to_cb(scope, args) {
- JsRuntime::state(scope)
- .borrow_mut()
- .js_nexttick_cbs
- .push(cb);
- }
-}
-
-fn set_macrotask_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- if let Ok(cb) = arg0_to_cb(scope, args) {
- JsRuntime::state(scope)
- .borrow_mut()
- .js_macrotask_cbs
- .push(cb);
- }
-}
-
-fn set_promise_reject_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- if let Ok(new) = arg0_to_cb(scope, args) {
- if let Some(old) = JsRuntime::state(scope)
- .borrow_mut()
- .js_promise_reject_cb
- .replace(new)
- {
- let old = v8::Local::new(scope, old);
- rv.set(old.into());
- }
- }
-}
-
-fn set_uncaught_exception_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- if let Ok(new) = arg0_to_cb(scope, args) {
- if let Some(old) = JsRuntime::state(scope)
- .borrow_mut()
- .js_uncaught_exception_cb
- .replace(new)
- {
- let old = v8::Local::new(scope, old);
- rv.set(old.into());
- }
- }
-}
-
-/// Set a callback which formats exception messages as stored in
-/// `JsError::exception_message`. The callback is passed the error value and
-/// should return a string or `null`. If no callback is set or the callback
-/// returns `null`, the built-in default formatting will be used.
-fn set_format_exception_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- if let Ok(new) = arg0_to_cb(scope, args) {
- if let Some(old) = JsRuntime::state(scope)
- .borrow_mut()
- .js_format_exception_cb
- .replace(new)
- {
- let old = v8::Local::new(scope, old);
- rv.set(old.into());
- }
- }
-}
-
-fn arg0_to_cb(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
-) -> Result<v8::Global<v8::Function>, ()> {
- v8::Local::<v8::Function>::try_from(args.get(0))
- .map(|cb| v8::Global::new(scope, cb))
- .map_err(|err| throw_type_error(scope, err.to_string()))
-}
-
-fn eval_context(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let source = match v8::Local::<v8::String>::try_from(args.get(0)) {
- Ok(s) => s,
- Err(_) => {
- throw_type_error(scope, "Missing first argument");
- return;
- }
- };
-
- let url = match v8::Local::<v8::String>::try_from(args.get(1)) {
- Ok(s) => match resolve_url_or_path(&s.to_rust_string_lossy(scope)) {
- Ok(s) => Some(s),
- Err(err) => {
- throw_type_error(scope, &format!("Invalid specifier: {}", err));
- return;
- }
- },
- Err(_) => None,
- };
-
- #[derive(Serialize)]
- struct Output<'s>(Option<serde_v8::Value<'s>>, Option<ErrInfo<'s>>);
-
- #[derive(Serialize)]
- #[serde(rename_all = "camelCase")]
- struct ErrInfo<'s> {
- thrown: serde_v8::Value<'s>,
- is_native_error: bool,
- is_compile_error: bool,
- }
-
- let tc_scope = &mut v8::TryCatch::new(scope);
- let name = v8::String::new(
- tc_scope,
- url.as_ref().map_or(crate::DUMMY_SPECIFIER, Url::as_str),
- )
- .unwrap();
- let origin = script_origin(tc_scope, name);
- let maybe_script = v8::Script::compile(tc_scope, source, Some(&origin));
-
- if maybe_script.is_none() {
- assert!(tc_scope.has_caught());
- let exception = tc_scope.exception().unwrap();
- let output = Output(
- None,
- Some(ErrInfo {
- thrown: exception.into(),
- is_native_error: is_instance_of_error(tc_scope, exception),
- is_compile_error: true,
- }),
- );
- rv.set(to_v8(tc_scope, output).unwrap());
- return;
- }
-
- let result = maybe_script.unwrap().run(tc_scope);
-
- if result.is_none() {
- assert!(tc_scope.has_caught());
- let exception = tc_scope.exception().unwrap();
- let output = Output(
- None,
- Some(ErrInfo {
- thrown: exception.into(),
- is_native_error: is_instance_of_error(tc_scope, exception),
- is_compile_error: false,
- }),
- );
- rv.set(to_v8(tc_scope, output).unwrap());
- return;
- }
-
- let output = Output(Some(result.unwrap().into()), None);
- rv.set(to_v8(tc_scope, output).unwrap());
-}
-
/// This binding should be used if there's a custom console implementation
/// available. Using it will make sure that proper stack frames are displayed
/// in the inspector console.
@@ -815,617 +407,6 @@ fn call_console(
deno_console_method.call(scope, receiver.into(), &call_args);
}
-fn set_wasm_streaming_callback(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let cb = match arg0_to_cb(scope, args) {
- Ok(cb) => cb,
- Err(()) => return,
- };
-
- let state_rc = JsRuntime::state(scope);
- let mut state = state_rc.borrow_mut();
-
- // The callback to pass to the v8 API has to be a unit type, so it can't
- // borrow or move any local variables. Therefore, we're storing the JS
- // callback in a JsRuntimeState slot.
- if let slot @ None = &mut state.js_wasm_streaming_cb {
- slot.replace(cb);
- } else {
- return throw_type_error(
- scope,
- "Deno.core.setWasmStreamingCallback() already called",
- );
- }
-
- scope.set_wasm_streaming_callback(|scope, arg, wasm_streaming| {
- let (cb_handle, streaming_rid) = {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow();
- let cb_handle = state.js_wasm_streaming_cb.as_ref().unwrap().clone();
- let streaming_rid = state
- .op_state
- .borrow_mut()
- .resource_table
- .add(WasmStreamingResource(RefCell::new(wasm_streaming)));
- (cb_handle, streaming_rid)
- };
-
- let undefined = v8::undefined(scope);
- let rid = serde_v8::to_v8(scope, streaming_rid).unwrap();
- cb_handle
- .open(scope)
- .call(scope, undefined.into(), &[arg, rid]);
- });
-}
-
-fn abort_wasm_streaming(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let rid: ResourceId = match serde_v8::from_v8(scope, args.get(0)) {
- Ok(rid) => rid,
- Err(_) => return throw_type_error(scope, "Invalid argument"),
- };
- let exception = args.get(1);
-
- let wasm_streaming = {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow();
- let wsr = state
- .op_state
- .borrow_mut()
- .resource_table
- .take::<WasmStreamingResource>(rid);
- match wsr {
- Ok(wasm_streaming) => wasm_streaming,
- Err(err) => {
- let message = v8::String::new(scope, &err.to_string()).unwrap();
- let v8_error = v8::Exception::error(scope, message);
- scope.throw_exception(v8_error);
- return;
- }
- }
- };
-
- // At this point there are no clones of Rc<WasmStreamingResource> on the
- // resource table, and no one should own a reference because we're never
- // cloning them. So we can be sure `wasm_streaming` is the only reference.
- if let Ok(wsr) = std::rc::Rc::try_unwrap(wasm_streaming) {
- // NOTE: v8::WasmStreaming::abort can't be called while `state` is borrowed;
- // see https://github.com/denoland/deno/issues/13917
- wsr.0.into_inner().abort(Some(exception));
- } else {
- panic!("Couldn't consume WasmStreamingResource.");
- }
-}
-
-fn encode(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let text = match v8::Local::<v8::String>::try_from(args.get(0)) {
- Ok(s) => s,
- Err(_) => {
- throw_type_error(scope, "Invalid argument");
- return;
- }
- };
- let text_str = serde_v8::to_utf8(text, scope);
- let bytes = text_str.into_bytes();
- let len = bytes.len();
- let backing_store =
- v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
- let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
- let u8array = v8::Uint8Array::new(scope, buffer, 0, len).unwrap();
- rv.set(u8array.into())
-}
-
-fn decode(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let zero_copy: ZeroCopyBuf = match serde_v8::from_v8(scope, args.get(0)) {
- Ok(zbuf) => zbuf,
- Err(_) => {
- throw_type_error(scope, "Invalid argument");
- return;
- }
- };
- let buf = &zero_copy;
-
- // Strip BOM
- let buf =
- if buf.len() >= 3 && buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf {
- &buf[3..]
- } else {
- buf
- };
-
- // If `String::new_from_utf8()` returns `None`, this means that the
- // length of the decoded string would be longer than what V8 can
- // handle. In this case we return `RangeError`.
- //
- // For more details see:
- // - https://encoding.spec.whatwg.org/#dom-textdecoder-decode
- // - https://github.com/denoland/deno/issues/6649
- // - https://github.com/v8/v8/blob/d68fb4733e39525f9ff0a9222107c02c28096e2a/include/v8.h#L3277-L3278
- match v8::String::new_from_utf8(scope, buf, v8::NewStringType::Normal) {
- Some(text) => rv.set(text.into()),
- None => {
- let msg = v8::String::new(scope, "string too long").unwrap();
- let exception = v8::Exception::range_error(scope, msg);
- scope.throw_exception(exception);
- }
- };
-}
-
-struct SerializeDeserialize<'a> {
- host_objects: Option<v8::Local<'a, v8::Array>>,
- error_callback: Option<v8::Local<'a, v8::Function>>,
-}
-
-impl<'a> v8::ValueSerializerImpl for SerializeDeserialize<'a> {
- #[allow(unused_variables)]
- fn throw_data_clone_error<'s>(
- &mut self,
- scope: &mut v8::HandleScope<'s>,
- message: v8::Local<'s, v8::String>,
- ) {
- if let Some(cb) = self.error_callback {
- let scope = &mut v8::TryCatch::new(scope);
- let undefined = v8::undefined(scope).into();
- cb.call(scope, undefined, &[message.into()]);
- if scope.has_caught() || scope.has_terminated() {
- scope.rethrow();
- return;
- };
- }
- let error = v8::Exception::type_error(scope, message);
- scope.throw_exception(error);
- }
-
- fn get_shared_array_buffer_id<'s>(
- &mut self,
- scope: &mut HandleScope<'s>,
- shared_array_buffer: Local<'s, SharedArrayBuffer>,
- ) -> Option<u32> {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
- let backing_store = shared_array_buffer.get_backing_store();
- let id = shared_array_buffer_store.insert(backing_store);
- Some(id)
- } else {
- None
- }
- }
-
- fn get_wasm_module_transfer_id(
- &mut self,
- scope: &mut HandleScope<'_>,
- module: Local<v8::WasmModuleObject>,
- ) -> Option<u32> {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- if let Some(compiled_wasm_module_store) = &state.compiled_wasm_module_store
- {
- let compiled_wasm_module = module.get_compiled_module();
- let id = compiled_wasm_module_store.insert(compiled_wasm_module);
- Some(id)
- } else {
- None
- }
- }
-
- fn write_host_object<'s>(
- &mut self,
- scope: &mut v8::HandleScope<'s>,
- object: v8::Local<'s, v8::Object>,
- value_serializer: &mut dyn v8::ValueSerializerHelper,
- ) -> Option<bool> {
- if let Some(host_objects) = self.host_objects {
- for i in 0..host_objects.length() {
- let value = host_objects.get_index(scope, i).unwrap();
- if value == object {
- value_serializer.write_uint32(i);
- return Some(true);
- }
- }
- }
- let message = v8::String::new(scope, "Unsupported object type").unwrap();
- self.throw_data_clone_error(scope, message);
- None
- }
-}
-
-impl<'a> v8::ValueDeserializerImpl for SerializeDeserialize<'a> {
- fn get_shared_array_buffer_from_id<'s>(
- &mut self,
- scope: &mut HandleScope<'s>,
- transfer_id: u32,
- ) -> Option<Local<'s, SharedArrayBuffer>> {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
- let backing_store = shared_array_buffer_store.take(transfer_id)?;
- let shared_array_buffer =
- v8::SharedArrayBuffer::with_backing_store(scope, &backing_store);
- Some(shared_array_buffer)
- } else {
- None
- }
- }
-
- fn get_wasm_module_from_id<'s>(
- &mut self,
- scope: &mut HandleScope<'s>,
- clone_id: u32,
- ) -> Option<Local<'s, v8::WasmModuleObject>> {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- if let Some(compiled_wasm_module_store) = &state.compiled_wasm_module_store
- {
- let compiled_module = compiled_wasm_module_store.take(clone_id)?;
- v8::WasmModuleObject::from_compiled_module(scope, &compiled_module)
- } else {
- None
- }
- }
-
- fn read_host_object<'s>(
- &mut self,
- scope: &mut v8::HandleScope<'s>,
- value_deserializer: &mut dyn v8::ValueDeserializerHelper,
- ) -> Option<v8::Local<'s, v8::Object>> {
- if let Some(host_objects) = self.host_objects {
- let mut i = 0;
- if !value_deserializer.read_uint32(&mut i) {
- return None;
- }
- let maybe_value = host_objects.get_index(scope, i);
- if let Some(value) = maybe_value {
- return value.to_object(scope);
- }
- }
-
- let message =
- v8::String::new(scope, "Failed to deserialize host object").unwrap();
- let error = v8::Exception::error(scope, message);
- scope.throw_exception(error);
- None
- }
-}
-
-fn serialize(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let value = args.get(0);
-
- let options: Option<SerializeDeserializeOptions> =
- match serde_v8::from_v8(scope, args.get(1)) {
- Ok(opts) => opts,
- Err(_) => {
- throw_type_error(scope, "Invalid argument 2");
- return;
- }
- };
-
- let arg2_to_error_callback = match !args.get(2).is_undefined() {
- true => match v8::Local::<v8::Function>::try_from(args.get(2)) {
- Ok(cb) => Some(v8::Local::new(scope, cb)),
- Err(_) => {
- throw_type_error(scope, "Invalid argument 3");
- return;
- }
- },
- false => None,
- };
-
- let options = options.unwrap_or(SerializeDeserializeOptions {
- host_objects: None,
- transfered_array_buffers: None,
- });
-
- let host_objects = match options.host_objects {
- Some(value) => match v8::Local::<v8::Array>::try_from(value.v8_value) {
- Ok(host_objects) => Some(host_objects),
- Err(_) => {
- throw_type_error(scope, "host_objects not an array");
- return;
- }
- },
- None => None,
- };
-
- let transfered_array_buffers = match options.transfered_array_buffers {
- Some(value) => match v8::Local::<v8::Array>::try_from(value.v8_value) {
- Ok(transfered_array_buffers) => Some(transfered_array_buffers),
- Err(_) => {
- throw_type_error(scope, "transfered_array_buffers not an array");
- return;
- }
- },
- None => None,
- };
-
- let serialize_deserialize = Box::new(SerializeDeserialize {
- host_objects,
- error_callback: arg2_to_error_callback,
- });
-
- let mut value_serializer =
- v8::ValueSerializer::new(scope, serialize_deserialize);
-
- value_serializer.write_header();
-
- if let Some(transfered_array_buffers) = transfered_array_buffers {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- for i in 0..transfered_array_buffers.length() {
- let i = v8::Number::new(scope, i as f64).into();
- let buf = transfered_array_buffers.get(scope, i).unwrap();
- let buf = match v8::Local::<v8::ArrayBuffer>::try_from(buf) {
- Ok(buf) => buf,
- Err(_) => {
- throw_type_error(
- scope,
- "item in transfered_array_buffers not an ArrayBuffer",
- );
- return;
- }
- };
- if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store
- {
- // TODO(lucacasonato): we need to check here that the buffer is not
- // already detached. We can not do that because V8 does not provide
- // a way to check if a buffer is already detached.
- if !buf.is_detachable() {
- throw_type_error(
- scope,
- "item in transfered_array_buffers is not transferable",
- );
- return;
- }
- let backing_store = buf.get_backing_store();
- buf.detach();
- let id = shared_array_buffer_store.insert(backing_store);
- value_serializer.transfer_array_buffer(id, buf);
- let id = v8::Number::new(scope, id as f64).into();
- transfered_array_buffers.set(scope, i, id);
- }
- }
- }
-
- let must_throw = {
- let scope = &mut v8::TryCatch::new(scope);
- let ret = value_serializer.write_value(scope.get_current_context(), value);
- if scope.has_caught() || scope.has_terminated() {
- scope.rethrow();
- false
- } else if let Some(true) = ret {
- let vector = value_serializer.release();
- let zbuf: ZeroCopyBuf = vector.into();
- rv.set(to_v8(scope, zbuf).unwrap());
- false
- } else {
- // We throw the TypeError outside of the v8::TryCatch scope.
- true
- }
- };
-
- if must_throw {
- throw_type_error(scope, "Failed to serialize response");
- }
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct SerializeDeserializeOptions<'a> {
- host_objects: Option<serde_v8::Value<'a>>,
- transfered_array_buffers: Option<serde_v8::Value<'a>>,
-}
-
-fn deserialize(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let zero_copy: ZeroCopyBuf = match serde_v8::from_v8(scope, args.get(0)) {
- Ok(zbuf) => zbuf,
- Err(_) => {
- throw_type_error(scope, "Invalid argument 1");
- return;
- }
- };
-
- let options: Option<SerializeDeserializeOptions> =
- match serde_v8::from_v8(scope, args.get(1)) {
- Ok(opts) => opts,
- Err(_) => {
- throw_type_error(scope, "Invalid argument 2");
- return;
- }
- };
-
- let options = options.unwrap_or(SerializeDeserializeOptions {
- host_objects: None,
- transfered_array_buffers: None,
- });
-
- let host_objects = match options.host_objects {
- Some(value) => match v8::Local::<v8::Array>::try_from(value.v8_value) {
- Ok(host_objects) => Some(host_objects),
- Err(_) => {
- throw_type_error(scope, "host_objects not an array");
- return;
- }
- },
- None => None,
- };
-
- let transfered_array_buffers = match options.transfered_array_buffers {
- Some(value) => match v8::Local::<v8::Array>::try_from(value.v8_value) {
- Ok(transfered_array_buffers) => Some(transfered_array_buffers),
- Err(_) => {
- throw_type_error(scope, "transfered_array_buffers not an array");
- return;
- }
- },
- None => None,
- };
-
- let serialize_deserialize = Box::new(SerializeDeserialize {
- host_objects,
- error_callback: None,
- });
- let mut value_deserializer =
- v8::ValueDeserializer::new(scope, serialize_deserialize, &zero_copy);
-
- let parsed_header = value_deserializer
- .read_header(scope.get_current_context())
- .unwrap_or_default();
- if !parsed_header {
- let msg = v8::String::new(scope, "could not deserialize value").unwrap();
- let exception = v8::Exception::range_error(scope, msg);
- scope.throw_exception(exception);
- return;
- }
-
- if let Some(transfered_array_buffers) = transfered_array_buffers {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow_mut();
- if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
- for i in 0..transfered_array_buffers.length() {
- let i = v8::Number::new(scope, i as f64).into();
- let id_val = transfered_array_buffers.get(scope, i).unwrap();
- let id = match id_val.number_value(scope) {
- Some(id) => id as u32,
- None => {
- throw_type_error(
- scope,
- "item in transfered_array_buffers not number",
- );
- return;
- }
- };
- if let Some(backing_store) = shared_array_buffer_store.take(id) {
- let array_buffer =
- v8::ArrayBuffer::with_backing_store(scope, &backing_store);
- value_deserializer.transfer_array_buffer(id, array_buffer);
- transfered_array_buffers.set(scope, id_val, array_buffer.into());
- } else {
- throw_type_error(
- scope,
- "transfered array buffer not present in shared_array_buffer_store",
- );
- return;
- }
- }
- }
- }
-
- let value = value_deserializer.read_value(scope.get_current_context());
-
- match value {
- Some(deserialized) => rv.set(deserialized),
- None => {
- let msg = v8::String::new(scope, "could not deserialize value").unwrap();
- let exception = v8::Exception::range_error(scope, msg);
- scope.throw_exception(exception);
- }
- };
-}
-
-fn queue_microtask(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- match v8::Local::<v8::Function>::try_from(args.get(0)) {
- Ok(f) => scope.enqueue_microtask(f),
- Err(_) => {
- throw_type_error(scope, "Invalid argument");
- }
- };
-}
-
-fn destructure_error(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let js_error = JsError::from_v8_exception(scope, args.get(0));
- let object = serde_v8::to_v8(scope, js_error).unwrap();
- rv.set(object);
-}
-
-fn terminate(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- _rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let mut state = state_rc.borrow_mut();
- state.explicit_terminate_exception =
- Some(v8::Global::new(scope, args.get(0)));
- scope.terminate_execution();
-}
-
-fn apply_source_map(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- #[derive(Deserialize, Serialize)]
- #[serde(rename_all = "camelCase")]
- struct Location {
- file_name: String,
- line_number: u32,
- column_number: u32,
- }
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow();
- if let Some(source_map_getter) = &state.source_map_getter {
- let mut location = match serde_v8::from_v8::<Location>(scope, args.get(0)) {
- Ok(location) => location,
- Err(error) => return throw_type_error(scope, error.to_string()),
- };
- let (f, l, c, _) = apply_source_map_(
- location.file_name,
- location.line_number.into(),
- location.column_number.into(),
- &mut HashMap::new(),
- source_map_getter.as_ref(),
- );
- location.file_name = f;
- location.line_number = l as u32;
- location.column_number = c as u32;
- rv.set(serde_v8::to_v8(scope, location).unwrap());
- } else {
- rv.set(args.get(0));
- }
-}
-
-fn create_host_object(
- scope: &mut v8::HandleScope,
- _args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let template = v8::ObjectTemplate::new(scope);
- template.set_internal_field_count(1);
- if let Some(obj) = template.new_instance(scope) {
- rv.set(obj.into());
- };
-}
-
/// Called by V8 during `JsRuntime::instantiate_module`.
///
/// This function borrows `ModuleMap` from the isolate slot,
@@ -1474,140 +455,8 @@ pub fn module_resolve_callback<'s>(
None
}
-// Returns promise details or throw TypeError, if argument passed isn't a Promise.
-// Promise details is a js_two elements array.
-// promise_details = [State, Result]
-// State = enum { Pending = 0, Fulfilled = 1, Rejected = 2}
-// Result = PromiseResult<T> | PromiseError
-fn get_promise_details(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let promise = match v8::Local::<v8::Promise>::try_from(args.get(0)) {
- Ok(val) => val,
- Err(_) => {
- throw_type_error(scope, "Invalid argument");
- return;
- }
- };
-
- #[derive(Serialize)]
- struct PromiseDetails<'s>(u32, Option<serde_v8::Value<'s>>);
-
- match promise.state() {
- v8::PromiseState::Pending => {
- rv.set(to_v8(scope, PromiseDetails(0, None)).unwrap());
- }
- v8::PromiseState::Fulfilled => {
- let promise_result = promise.result(scope);
- rv.set(
- to_v8(scope, PromiseDetails(1, Some(promise_result.into()))).unwrap(),
- );
- }
- v8::PromiseState::Rejected => {
- let promise_result = promise.result(scope);
- rv.set(
- to_v8(scope, PromiseDetails(2, Some(promise_result.into()))).unwrap(),
- );
- }
- }
-}
-
-// Based on https://github.com/nodejs/node/blob/1e470510ff74391d7d4ec382909ea8960d2d2fbc/src/node_util.cc
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-fn get_proxy_details(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- // Return undefined if it's not a proxy.
- let proxy = match v8::Local::<v8::Proxy>::try_from(args.get(0)) {
- Ok(val) => val,
- Err(_) => {
- return;
- }
- };
-
- let target = proxy.get_target(scope);
- let handler = proxy.get_handler(scope);
- let p: (serde_v8::Value, serde_v8::Value) = (target.into(), handler.into());
- rv.set(to_v8(scope, p).unwrap());
-}
-
-fn is_proxy(
- scope: &mut v8::HandleScope,
- args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- rv.set(v8::Boolean::new(scope, args.get(0).is_proxy()).into())
-}
-
pub fn throw_type_error(scope: &mut v8::HandleScope, message: impl AsRef<str>) {
let message = v8::String::new(scope, message.as_ref()).unwrap();
let exception = v8::Exception::type_error(scope, message);
scope.throw_exception(exception);
}
-
-fn memory_usage(
- scope: &mut v8::HandleScope,
- _args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let stats = get_memory_usage(scope);
- rv.set(to_v8(scope, stats).unwrap());
-}
-
-// HeapStats stores values from a isolate.get_heap_statistics() call
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct MemoryUsage {
- rss: usize,
- heap_total: usize,
- heap_used: usize,
- external: usize,
- // TODO: track ArrayBuffers, would require using a custom allocator to track
- // but it's otherwise a subset of external so can be indirectly tracked
- // array_buffers: usize,
-}
-fn get_memory_usage(isolate: &mut v8::Isolate) -> MemoryUsage {
- let mut s = v8::HeapStatistics::default();
- isolate.get_heap_statistics(&mut s);
-
- MemoryUsage {
- rss: s.total_physical_size(),
- heap_total: s.total_heap_size(),
- heap_used: s.used_heap_size(),
- external: s.external_memory(),
- }
-}
-
-fn op_names(
- scope: &mut v8::HandleScope,
- _args: v8::FunctionCallbackArguments,
- mut rv: v8::ReturnValue,
-) {
- let state_rc = JsRuntime::state(scope);
- let state = state_rc.borrow();
- let names: Vec<_> = state.op_ctxs.iter().map(|o| o.decl.name).collect();
- rv.set(serde_v8::to_v8(scope, names).unwrap());
-}
diff --git a/core/encode_decode_test.js b/core/encode_decode_test.js
index 94a65dad4..5165b196c 100644
--- a/core/encode_decode_test.js
+++ b/core/encode_decode_test.js
@@ -33,25 +33,31 @@ function main() {
108, 100
];
- const empty = Deno.core.encode("");
+ const empty = Deno.core.opSync("op_encode", "");
if (empty.length !== 0) throw new Error("assert");
- assertArrayEquals(Array.from(Deno.core.encode("𝓽𝓮𝔁𝓽")), fixture1);
assertArrayEquals(
- Array.from(Deno.core.encode("Hello \udc12\ud834 World")),
+ Array.from(Deno.core.opSync("op_encode", "𝓽𝓮𝔁𝓽")),
+ fixture1,
+ );
+ assertArrayEquals(
+ Array.from(Deno.core.opSync("op_encode", "Hello \udc12\ud834 World")),
fixture2,
);
- const emptyBuf = Deno.core.decode(new Uint8Array(0));
+ const emptyBuf = Deno.core.opSync("op_decode", new Uint8Array(0));
if (emptyBuf !== "") throw new Error("assert");
- assert(Deno.core.decode(new Uint8Array(fixture1)) === "𝓽𝓮𝔁𝓽");
- assert(Deno.core.decode(new Uint8Array(fixture2)) === "Hello �� World");
+ assert(Deno.core.opSync("op_decode", new Uint8Array(fixture1)) === "𝓽𝓮𝔁𝓽");
+ assert(
+ Deno.core.opSync("op_decode", new Uint8Array(fixture2)) ===
+ "Hello �� World",
+ );
// See https://github.com/denoland/deno/issues/6649
let thrown = false;
try {
- Deno.core.decode(new Uint8Array(2 ** 29));
+ Deno.core.opSync("op_decode", new Uint8Array(2 ** 29));
} catch (e) {
thrown = true;
assert(e instanceof RangeError);
diff --git a/core/lib.rs b/core/lib.rs
index 1b59be186..064c15fc1 100644
--- a/core/lib.rs
+++ b/core/lib.rs
@@ -13,6 +13,7 @@ mod modules;
mod normalize_path;
mod ops;
mod ops_builtin;
+mod ops_builtin_v8;
mod ops_metrics;
mod resources;
mod runtime;
diff --git a/core/ops.rs b/core/ops.rs
index b936fc726..a2833e811 100644
--- a/core/ops.rs
+++ b/core/ops.rs
@@ -108,7 +108,7 @@ impl OpResult {
}
}
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OpError {
#[serde(rename = "$err_class_name")]
diff --git a/core/ops_builtin.rs b/core/ops_builtin.rs
index 234c0b104..a42c0bae8 100644
--- a/core/ops_builtin.rs
+++ b/core/ops_builtin.rs
@@ -1,3 +1,4 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
use crate::error::format_file_name;
use crate::error::type_error;
use crate::include_js_files;
@@ -36,7 +37,9 @@ pub(crate) fn init_builtins() -> Extension {
op_shutdown::decl(),
op_metrics::decl(),
op_format_file_name::decl(),
+ op_is_proxy::decl(),
])
+ .ops(crate::ops_builtin_v8::init_builtins_v8())
.build()
}
@@ -181,3 +184,8 @@ async fn op_shutdown(
fn op_format_file_name(file_name: String) -> String {
format_file_name(&file_name)
}
+
+#[op]
+fn op_is_proxy(value: serde_v8::Value) -> bool {
+ value.v8_value.is_proxy()
+}
diff --git a/core/ops_builtin_v8.rs b/core/ops_builtin_v8.rs
new file mode 100644
index 000000000..7b7cfcc45
--- /dev/null
+++ b/core/ops_builtin_v8.rs
@@ -0,0 +1,788 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+use crate::bindings::script_origin;
+use crate::error::is_instance_of_error;
+use crate::error::range_error;
+use crate::error::type_error;
+use crate::error::JsError;
+use crate::ops_builtin::WasmStreamingResource;
+use crate::resolve_url_or_path;
+use crate::serde_v8::from_v8;
+use crate::source_map::apply_source_map as apply_source_map_;
+use crate::JsRuntime;
+use crate::OpDecl;
+use crate::ZeroCopyBuf;
+use anyhow::Error;
+use deno_ops::op;
+use serde::Deserialize;
+use serde::Serialize;
+use std::cell::RefCell;
+use v8::ValueDeserializerHelper;
+use v8::ValueSerializerHelper;
+
+pub(crate) fn init_builtins_v8() -> Vec<OpDecl> {
+ vec![
+ op_ref_op::decl(),
+ op_unref_op::decl(),
+ op_set_macrotask_callback::decl(),
+ op_set_next_tick_callback::decl(),
+ op_set_promise_reject_callback::decl(),
+ op_set_uncaught_exception_callback::decl(),
+ op_run_microtasks::decl(),
+ op_has_tick_scheduled::decl(),
+ op_set_has_tick_scheduled::decl(),
+ op_eval_context::decl(),
+ op_queue_microtask::decl(),
+ op_create_host_object::decl(),
+ op_encode::decl(),
+ op_decode::decl(),
+ op_serialize::decl(),
+ op_deserialize::decl(),
+ op_get_promise_details::decl(),
+ op_get_proxy_details::decl(),
+ op_memory_usage::decl(),
+ op_set_wasm_streaming_callback::decl(),
+ op_abort_wasm_streaming::decl(),
+ op_destructure_error::decl(),
+ op_terminate::decl(),
+ op_op_names::decl(),
+ op_apply_source_map::decl(),
+ op_set_format_exception_callback::decl(),
+ ]
+}
+
+fn to_v8_fn(
+ scope: &mut v8::HandleScope,
+ value: serde_v8::Value,
+) -> Result<v8::Global<v8::Function>, Error> {
+ v8::Local::<v8::Function>::try_from(value.v8_value)
+ .map(|cb| v8::Global::new(scope, cb))
+ .map_err(|err| type_error(err.to_string()))
+}
+
+#[op(v8)]
+fn op_ref_op(scope: &mut v8::HandleScope, promise_id: i32) {
+ let state_rc = JsRuntime::state(scope);
+ state_rc.borrow_mut().unrefed_ops.remove(&promise_id);
+}
+
+#[op(v8)]
+fn op_unref_op(scope: &mut v8::HandleScope, promise_id: i32) {
+ let state_rc = JsRuntime::state(scope);
+ state_rc.borrow_mut().unrefed_ops.insert(promise_id);
+}
+
+#[op(v8)]
+fn op_set_macrotask_callback(
+ scope: &mut v8::HandleScope,
+ cb: serde_v8::Value,
+) -> Result<(), Error> {
+ let cb = to_v8_fn(scope, cb)?;
+ let state_rc = JsRuntime::state(scope);
+ state_rc.borrow_mut().js_macrotask_cbs.push(cb);
+ Ok(())
+}
+
+#[op(v8)]
+fn op_set_next_tick_callback(
+ scope: &mut v8::HandleScope,
+ cb: serde_v8::Value,
+) -> Result<(), Error> {
+ let cb = to_v8_fn(scope, cb)?;
+ let state_rc = JsRuntime::state(scope);
+ state_rc.borrow_mut().js_nexttick_cbs.push(cb);
+ Ok(())
+}
+
+#[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 state_rc = JsRuntime::state(scope);
+ let old = state_rc.borrow_mut().js_promise_reject_cb.replace(cb);
+ let old = old.map(|v| v8::Local::new(scope, v));
+ Ok(old.map(|v| from_v8(scope, v.into()).unwrap()))
+}
+
+#[op(v8)]
+fn op_set_uncaught_exception_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 state_rc = JsRuntime::state(scope);
+ let old = state_rc.borrow_mut().js_uncaught_exception_cb.replace(cb);
+ let old = old.map(|v| v8::Local::new(scope, v));
+ Ok(old.map(|v| from_v8(scope, v.into()).unwrap()))
+}
+
+#[op(v8)]
+fn op_run_microtasks(scope: &mut v8::HandleScope) {
+ scope.perform_microtask_checkpoint();
+}
+
+#[op(v8)]
+fn op_has_tick_scheduled(scope: &mut v8::HandleScope) -> bool {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow();
+ state.has_tick_scheduled
+}
+
+#[op(v8)]
+fn op_set_has_tick_scheduled(scope: &mut v8::HandleScope, v: bool) {
+ let state_rc = JsRuntime::state(scope);
+ state_rc.borrow_mut().has_tick_scheduled = v;
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct EvalContextError<'s> {
+ thrown: serde_v8::Value<'s>,
+ is_native_error: bool,
+ is_compile_error: bool,
+}
+
+#[derive(Serialize)]
+struct EvalContextResult<'s>(
+ Option<serde_v8::Value<'s>>,
+ Option<EvalContextError<'s>>,
+);
+
+#[op(v8)]
+fn op_eval_context<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ source: serde_v8::Value<'a>,
+ specifier: Option<String>,
+) -> Result<EvalContextResult<'a>, Error> {
+ let tc_scope = &mut v8::TryCatch::new(scope);
+ let source = v8::Local::<v8::String>::try_from(source.v8_value)
+ .map_err(|_| type_error("Invalid source"))?;
+ let specifier = match specifier {
+ Some(s) => resolve_url_or_path(&s)?.to_string(),
+ None => crate::DUMMY_SPECIFIER.to_string(),
+ };
+ let specifier = v8::String::new(tc_scope, &specifier).unwrap();
+ let origin = script_origin(tc_scope, specifier);
+
+ let script = match v8::Script::compile(tc_scope, source, Some(&origin)) {
+ Some(s) => s,
+ None => {
+ assert!(tc_scope.has_caught());
+ let exception = tc_scope.exception().unwrap();
+ return Ok(EvalContextResult(
+ None,
+ Some(EvalContextError {
+ thrown: exception.into(),
+ is_native_error: is_instance_of_error(tc_scope, exception),
+ is_compile_error: true,
+ }),
+ ));
+ }
+ };
+
+ match script.run(tc_scope) {
+ Some(result) => Ok(EvalContextResult(Some(result.into()), None)),
+ None => {
+ assert!(tc_scope.has_caught());
+ let exception = tc_scope.exception().unwrap();
+ Ok(EvalContextResult(
+ None,
+ Some(EvalContextError {
+ thrown: exception.into(),
+ is_native_error: is_instance_of_error(tc_scope, exception),
+ is_compile_error: false,
+ }),
+ ))
+ }
+ }
+}
+
+#[op(v8)]
+fn op_queue_microtask(
+ scope: &mut v8::HandleScope,
+ cb: serde_v8::Value,
+) -> Result<(), Error> {
+ let cb = to_v8_fn(scope, cb)?;
+ let cb = v8::Local::new(scope, cb);
+ scope.enqueue_microtask(cb);
+ Ok(())
+}
+
+#[op(v8)]
+fn op_create_host_object<'a>(
+ scope: &mut v8::HandleScope<'a>,
+) -> serde_v8::Value<'a> {
+ let template = v8::ObjectTemplate::new(scope);
+ template.set_internal_field_count(1);
+ let object = template.new_instance(scope).unwrap();
+ from_v8(scope, object.into()).unwrap()
+}
+
+#[op(v8)]
+fn op_encode<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ text: serde_v8::Value<'a>,
+) -> Result<serde_v8::Value<'a>, Error> {
+ let text = v8::Local::<v8::String>::try_from(text.v8_value)
+ .map_err(|_| type_error("Invalid argument"))?;
+ let text_str = serde_v8::to_utf8(text, scope);
+ let bytes = text_str.into_bytes();
+ let len = bytes.len();
+ let backing_store =
+ v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
+ let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing_store);
+ let u8array = v8::Uint8Array::new(scope, buffer, 0, len).unwrap();
+ Ok((from_v8(scope, u8array.into()))?)
+}
+
+#[op(v8)]
+fn op_decode<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ zero_copy: ZeroCopyBuf,
+) -> Result<serde_v8::Value<'a>, Error> {
+ let buf = &zero_copy;
+
+ // Strip BOM
+ let buf =
+ if buf.len() >= 3 && buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf {
+ &buf[3..]
+ } else {
+ buf
+ };
+
+ // If `String::new_from_utf8()` returns `None`, this means that the
+ // length of the decoded string would be longer than what V8 can
+ // handle. In this case we return `RangeError`.
+ //
+ // For more details see:
+ // - https://encoding.spec.whatwg.org/#dom-textdecoder-decode
+ // - https://github.com/denoland/deno/issues/6649
+ // - https://github.com/v8/v8/blob/d68fb4733e39525f9ff0a9222107c02c28096e2a/include/v8.h#L3277-L3278
+ match v8::String::new_from_utf8(scope, buf, v8::NewStringType::Normal) {
+ Some(text) => Ok(from_v8(scope, text.into())?),
+ None => Err(range_error("string too long")),
+ }
+}
+
+struct SerializeDeserialize<'a> {
+ host_objects: Option<v8::Local<'a, v8::Array>>,
+ error_callback: Option<v8::Local<'a, v8::Function>>,
+}
+
+impl<'a> v8::ValueSerializerImpl for SerializeDeserialize<'a> {
+ #[allow(unused_variables)]
+ fn throw_data_clone_error<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ message: v8::Local<'s, v8::String>,
+ ) {
+ if let Some(cb) = self.error_callback {
+ let scope = &mut v8::TryCatch::new(scope);
+ let undefined = v8::undefined(scope).into();
+ cb.call(scope, undefined, &[message.into()]);
+ if scope.has_caught() || scope.has_terminated() {
+ scope.rethrow();
+ return;
+ };
+ }
+ let error = v8::Exception::type_error(scope, message);
+ scope.throw_exception(error);
+ }
+
+ fn get_shared_array_buffer_id<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ shared_array_buffer: v8::Local<'s, v8::SharedArrayBuffer>,
+ ) -> Option<u32> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
+ let backing_store = shared_array_buffer.get_backing_store();
+ let id = shared_array_buffer_store.insert(backing_store);
+ Some(id)
+ } else {
+ None
+ }
+ }
+
+ fn get_wasm_module_transfer_id(
+ &mut self,
+ scope: &mut v8::HandleScope<'_>,
+ module: v8::Local<v8::WasmModuleObject>,
+ ) -> Option<u32> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ if let Some(compiled_wasm_module_store) = &state.compiled_wasm_module_store
+ {
+ let compiled_wasm_module = module.get_compiled_module();
+ let id = compiled_wasm_module_store.insert(compiled_wasm_module);
+ Some(id)
+ } else {
+ None
+ }
+ }
+
+ fn write_host_object<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ object: v8::Local<'s, v8::Object>,
+ value_serializer: &mut dyn v8::ValueSerializerHelper,
+ ) -> Option<bool> {
+ if let Some(host_objects) = self.host_objects {
+ for i in 0..host_objects.length() {
+ let value = host_objects.get_index(scope, i).unwrap();
+ if value == object {
+ value_serializer.write_uint32(i);
+ return Some(true);
+ }
+ }
+ }
+ let message = v8::String::new(scope, "Unsupported object type").unwrap();
+ self.throw_data_clone_error(scope, message);
+ None
+ }
+}
+
+impl<'a> v8::ValueDeserializerImpl for SerializeDeserialize<'a> {
+ fn get_shared_array_buffer_from_id<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ transfer_id: u32,
+ ) -> Option<v8::Local<'s, v8::SharedArrayBuffer>> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
+ let backing_store = shared_array_buffer_store.take(transfer_id)?;
+ let shared_array_buffer =
+ v8::SharedArrayBuffer::with_backing_store(scope, &backing_store);
+ Some(shared_array_buffer)
+ } else {
+ None
+ }
+ }
+
+ fn get_wasm_module_from_id<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ clone_id: u32,
+ ) -> Option<v8::Local<'s, v8::WasmModuleObject>> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ if let Some(compiled_wasm_module_store) = &state.compiled_wasm_module_store
+ {
+ let compiled_module = compiled_wasm_module_store.take(clone_id)?;
+ v8::WasmModuleObject::from_compiled_module(scope, &compiled_module)
+ } else {
+ None
+ }
+ }
+
+ fn read_host_object<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ value_deserializer: &mut dyn v8::ValueDeserializerHelper,
+ ) -> Option<v8::Local<'s, v8::Object>> {
+ if let Some(host_objects) = self.host_objects {
+ let mut i = 0;
+ if !value_deserializer.read_uint32(&mut i) {
+ return None;
+ }
+ let maybe_value = host_objects.get_index(scope, i);
+ if let Some(value) = maybe_value {
+ return value.to_object(scope);
+ }
+ }
+
+ let message =
+ v8::String::new(scope, "Failed to deserialize host object").unwrap();
+ let error = v8::Exception::error(scope, message);
+ scope.throw_exception(error);
+ None
+ }
+}
+
+#[derive(Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct SerializeDeserializeOptions<'a> {
+ host_objects: Option<serde_v8::Value<'a>>,
+ transferred_array_buffers: Option<serde_v8::Value<'a>>,
+}
+
+#[op(v8)]
+fn op_serialize(
+ scope: &mut v8::HandleScope,
+ value: serde_v8::Value,
+ options: Option<SerializeDeserializeOptions>,
+ error_callback: Option<serde_v8::Value>,
+) -> Result<ZeroCopyBuf, Error> {
+ let options = options.unwrap_or_default();
+ let error_callback = match error_callback {
+ Some(cb) => Some(
+ v8::Local::<v8::Function>::try_from(cb.v8_value)
+ .map_err(|_| type_error("Invalid error callback"))?,
+ ),
+ None => None,
+ };
+ let host_objects = match options.host_objects {
+ Some(value) => Some(
+ v8::Local::<v8::Array>::try_from(value.v8_value)
+ .map_err(|_| type_error("hostObjects not an array"))?,
+ ),
+ None => None,
+ };
+ let transferred_array_buffers = match options.transferred_array_buffers {
+ Some(value) => Some(
+ v8::Local::<v8::Array>::try_from(value.v8_value)
+ .map_err(|_| type_error("transferredArrayBuffers not an array"))?,
+ ),
+ None => None,
+ };
+
+ let serialize_deserialize = Box::new(SerializeDeserialize {
+ host_objects,
+ error_callback,
+ });
+ let mut value_serializer =
+ v8::ValueSerializer::new(scope, serialize_deserialize);
+ value_serializer.write_header();
+
+ if let Some(transferred_array_buffers) = transferred_array_buffers {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ for i in 0..transferred_array_buffers.length() {
+ let i = v8::Number::new(scope, i as f64).into();
+ let buf = transferred_array_buffers.get(scope, i).unwrap();
+ let buf = v8::Local::<v8::ArrayBuffer>::try_from(buf).map_err(|_| {
+ type_error("item in transferredArrayBuffers not an ArrayBuffer")
+ })?;
+ if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store
+ {
+ // TODO(lucacasonato): we need to check here that the buffer is not
+ // already detached. We can not do that because V8 does not provide
+ // a way to check if a buffer is already detached.
+ if !buf.is_detachable() {
+ return Err(type_error(
+ "item in transferredArrayBuffers is not transferable",
+ ));
+ }
+ let backing_store = buf.get_backing_store();
+ buf.detach();
+ let id = shared_array_buffer_store.insert(backing_store);
+ value_serializer.transfer_array_buffer(id, buf);
+ let id = v8::Number::new(scope, id as f64).into();
+ transferred_array_buffers.set(scope, i, id);
+ }
+ }
+ }
+
+ let scope = &mut v8::TryCatch::new(scope);
+ let ret =
+ value_serializer.write_value(scope.get_current_context(), value.v8_value);
+ if scope.has_caught() || scope.has_terminated() {
+ scope.rethrow();
+ Err(type_error("unreachable"))
+ } else if let Some(true) = ret {
+ let vector = value_serializer.release();
+ Ok(vector.into())
+ } else {
+ Err(type_error("Failed to serialize response"))
+ }
+}
+
+#[op(v8)]
+fn op_deserialize<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ zero_copy: ZeroCopyBuf,
+ options: Option<SerializeDeserializeOptions>,
+) -> Result<serde_v8::Value<'a>, Error> {
+ let options = options.unwrap_or_default();
+ let host_objects = match options.host_objects {
+ Some(value) => Some(
+ v8::Local::<v8::Array>::try_from(value.v8_value)
+ .map_err(|_| type_error("hostObjects not an array"))?,
+ ),
+ None => None,
+ };
+ let transferred_array_buffers = match options.transferred_array_buffers {
+ Some(value) => Some(
+ v8::Local::<v8::Array>::try_from(value.v8_value)
+ .map_err(|_| type_error("transferredArrayBuffers not an array"))?,
+ ),
+ None => None,
+ };
+
+ let serialize_deserialize = Box::new(SerializeDeserialize {
+ host_objects,
+ error_callback: None,
+ });
+ let mut value_deserializer =
+ v8::ValueDeserializer::new(scope, serialize_deserialize, &zero_copy);
+ let parsed_header = value_deserializer
+ .read_header(scope.get_current_context())
+ .unwrap_or_default();
+ if !parsed_header {
+ return Err(range_error("could not deserialize value"));
+ }
+
+ if let Some(transferred_array_buffers) = transferred_array_buffers {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow_mut();
+ if let Some(shared_array_buffer_store) = &state.shared_array_buffer_store {
+ for i in 0..transferred_array_buffers.length() {
+ let i = v8::Number::new(scope, i as f64).into();
+ let id_val = transferred_array_buffers.get(scope, i).unwrap();
+ let id = match id_val.number_value(scope) {
+ Some(id) => id as u32,
+ None => {
+ return Err(type_error(
+ "item in transferredArrayBuffers not number",
+ ))
+ }
+ };
+ if let Some(backing_store) = shared_array_buffer_store.take(id) {
+ let array_buffer =
+ v8::ArrayBuffer::with_backing_store(scope, &backing_store);
+ value_deserializer.transfer_array_buffer(id, array_buffer);
+ transferred_array_buffers.set(scope, id_val, array_buffer.into());
+ } else {
+ return Err(type_error(
+ "transferred array buffer not present in shared_array_buffer_store",
+ ));
+ }
+ }
+ }
+ }
+
+ let value = value_deserializer.read_value(scope.get_current_context());
+ match value {
+ Some(deserialized) => Ok(deserialized.into()),
+ None => Err(range_error("could not deserialize value")),
+ }
+}
+
+#[derive(Serialize)]
+struct PromiseDetails<'s>(u32, Option<serde_v8::Value<'s>>);
+
+#[op(v8)]
+fn op_get_promise_details<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ promise: serde_v8::Value<'a>,
+) -> Result<PromiseDetails<'a>, Error> {
+ let promise = v8::Local::<v8::Promise>::try_from(promise.v8_value)
+ .map_err(|_| type_error("Invalid argument"))?;
+ match promise.state() {
+ v8::PromiseState::Pending => Ok(PromiseDetails(0, None)),
+ v8::PromiseState::Fulfilled => {
+ Ok(PromiseDetails(1, Some(promise.result(scope).into())))
+ }
+ v8::PromiseState::Rejected => {
+ Ok(PromiseDetails(2, Some(promise.result(scope).into())))
+ }
+ }
+}
+
+// Based on https://github.com/nodejs/node/blob/1e470510ff74391d7d4ec382909ea8960d2d2fbc/src/node_util.cc
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+#[op(v8)]
+fn op_get_proxy_details<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ proxy: serde_v8::Value<'a>,
+) -> Option<(serde_v8::Value<'a>, serde_v8::Value<'a>)> {
+ let proxy = match v8::Local::<v8::Proxy>::try_from(proxy.v8_value) {
+ Ok(proxy) => proxy,
+ Err(_) => return None,
+ };
+ let target = proxy.get_target(scope);
+ let handler = proxy.get_handler(scope);
+ Some((target.into(), handler.into()))
+}
+
+// HeapStats stores values from a isolate.get_heap_statistics() call
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct MemoryUsage {
+ rss: usize,
+ heap_total: usize,
+ heap_used: usize,
+ external: usize,
+ // TODO: track ArrayBuffers, would require using a custom allocator to track
+ // but it's otherwise a subset of external so can be indirectly tracked
+ // array_buffers: usize,
+}
+
+#[op(v8)]
+fn op_memory_usage(scope: &mut v8::HandleScope) -> MemoryUsage {
+ let mut s = v8::HeapStatistics::default();
+ scope.get_heap_statistics(&mut s);
+ MemoryUsage {
+ rss: s.total_physical_size(),
+ heap_total: s.total_heap_size(),
+ heap_used: s.used_heap_size(),
+ external: s.external_memory(),
+ }
+}
+
+#[op(v8)]
+fn op_set_wasm_streaming_callback(
+ scope: &mut v8::HandleScope,
+ cb: serde_v8::Value,
+) -> Result<(), Error> {
+ let cb = to_v8_fn(scope, cb)?;
+ let state_rc = JsRuntime::state(scope);
+ let mut state = state_rc.borrow_mut();
+ // The callback to pass to the v8 API has to be a unit type, so it can't
+ // borrow or move any local variables. Therefore, we're storing the JS
+ // callback in a JsRuntimeState slot.
+ if state.js_wasm_streaming_cb.is_some() {
+ return Err(type_error("op_set_wasm_streaming_callback already called"));
+ }
+ state.js_wasm_streaming_cb = Some(cb);
+
+ scope.set_wasm_streaming_callback(|scope, arg, wasm_streaming| {
+ let (cb_handle, streaming_rid) = {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow();
+ let cb_handle = state.js_wasm_streaming_cb.as_ref().unwrap().clone();
+ let streaming_rid = state
+ .op_state
+ .borrow_mut()
+ .resource_table
+ .add(WasmStreamingResource(RefCell::new(wasm_streaming)));
+ (cb_handle, streaming_rid)
+ };
+
+ let undefined = v8::undefined(scope);
+ let rid = serde_v8::to_v8(scope, streaming_rid).unwrap();
+ cb_handle
+ .open(scope)
+ .call(scope, undefined.into(), &[arg, rid]);
+ });
+ Ok(())
+}
+
+#[op(v8)]
+fn op_abort_wasm_streaming(
+ scope: &mut v8::HandleScope,
+ rid: u32,
+ error: serde_v8::Value,
+) -> Result<(), Error> {
+ let wasm_streaming = {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow();
+ let wsr = state
+ .op_state
+ .borrow_mut()
+ .resource_table
+ .take::<WasmStreamingResource>(rid)?;
+ wsr
+ };
+
+ // At this point there are no clones of Rc<WasmStreamingResource> on the
+ // resource table, and no one should own a reference because we're never
+ // cloning them. So we can be sure `wasm_streaming` is the only reference.
+ if let Ok(wsr) = std::rc::Rc::try_unwrap(wasm_streaming) {
+ // NOTE: v8::WasmStreaming::abort can't be called while `state` is borrowed;
+ // see https://github.com/denoland/deno/issues/13917
+ wsr.0.into_inner().abort(Some(error.v8_value));
+ } else {
+ panic!("Couldn't consume WasmStreamingResource.");
+ }
+ Ok(())
+}
+
+#[op(v8)]
+fn op_destructure_error(
+ scope: &mut v8::HandleScope,
+ error: serde_v8::Value,
+) -> JsError {
+ JsError::from_v8_exception(scope, error.v8_value)
+}
+
+#[op(v8)]
+fn op_terminate(scope: &mut v8::HandleScope, exception: serde_v8::Value) {
+ let state_rc = JsRuntime::state(scope);
+ let mut state = state_rc.borrow_mut();
+ state.explicit_terminate_exception =
+ Some(v8::Global::new(scope, exception.v8_value));
+ scope.terminate_execution();
+}
+
+#[op(v8)]
+fn op_op_names(scope: &mut v8::HandleScope) -> Vec<String> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow();
+ state
+ .op_ctxs
+ .iter()
+ .map(|o| o.decl.name.to_string())
+ .collect()
+}
+
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct Location {
+ file_name: String,
+ line_number: u32,
+ column_number: u32,
+}
+
+#[op(v8)]
+fn op_apply_source_map(
+ scope: &mut v8::HandleScope,
+ location: Location,
+) -> Result<Location, Error> {
+ let state_rc = JsRuntime::state(scope);
+ let state = state_rc.borrow();
+ if let Some(source_map_getter) = &state.source_map_getter {
+ let mut location = location;
+ let (f, l, c, _) = apply_source_map_(
+ location.file_name,
+ location.line_number.into(),
+ location.column_number.into(),
+ &mut Default::default(),
+ source_map_getter.as_ref(),
+ );
+ location.file_name = f;
+ location.line_number = l as u32;
+ location.column_number = c as u32;
+ Ok(location)
+ } else {
+ Ok(location)
+ }
+}
+
+/// Set a callback which formats exception messages as stored in
+/// `JsError::exception_message`. The callback is passed the error value and
+/// should return a string or `null`. If no callback is set or the callback
+/// returns `null`, the built-in default formatting will be used.
+#[op(v8)]
+fn op_set_format_exception_callback<'a>(
+ scope: &mut v8::HandleScope<'a>,
+ cb: serde_v8::Value<'a>,
+) -> Result<Option<serde_v8::Value<'a>>, Error> {
+ let cb = to_v8_fn(scope, cb)?;
+ let state_rc = JsRuntime::state(scope);
+ let old = state_rc.borrow_mut().js_format_exception_cb.replace(cb);
+ let old = old.map(|v| v8::Local::new(scope, v));
+ Ok(old.map(|v| from_v8(scope, v.into()).unwrap()))
+}
diff --git a/core/runtime.rs b/core/runtime.rs
index 66d28226e..6cc638122 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -1990,6 +1990,9 @@ pub mod tests {
.build();
let mut runtime = JsRuntime::new(RuntimeOptions {
extensions: vec![ext],
+ get_error_class_fn: Some(&|error| {
+ crate::error::get_custom_error_class(error).unwrap()
+ }),
..Default::default()
});
@@ -2068,8 +2071,8 @@ pub mod tests {
.execute_script(
"filename.js",
r#"
- Deno.core.unrefOp(p1[promiseIdSymbol]);
- Deno.core.unrefOp(p2[promiseIdSymbol]);
+ Deno.core.opSync("op_unref_op", p1[promiseIdSymbol]);
+ Deno.core.opSync("op_unref_op", p2[promiseIdSymbol]);
"#,
)
.unwrap();
@@ -2084,8 +2087,8 @@ pub mod tests {
.execute_script(
"filename.js",
r#"
- Deno.core.refOp(p1[promiseIdSymbol]);
- Deno.core.refOp(p2[promiseIdSymbol]);
+ Deno.core.opSync("op_ref_op", p1[promiseIdSymbol]);
+ Deno.core.opSync("op_ref_op", p2[promiseIdSymbol]);
"#,
)
.unwrap();
@@ -2790,10 +2793,9 @@ assertEquals(1, notify_return_value);
"is_proxy.js",
r#"
(function () {
- const { isProxy } = Deno.core;
const o = { a: 1, b: 2};
const p = new Proxy(o, {});
- return isProxy(p) && !isProxy(o) && !isProxy(42);
+ return Deno.core.opSync("op_is_proxy", p) && !Deno.core.opSync("op_is_proxy", o) && !Deno.core.opSync("op_is_proxy", 42);
})()
"#,
)
@@ -2803,20 +2805,6 @@ assertEquals(1, notify_return_value);
assert!(all_true.is_true());
}
- #[test]
- fn test_binding_names() {
- let mut runtime = JsRuntime::new(RuntimeOptions::default());
- let all_true: v8::Global<v8::Value> = runtime
- .execute_script(
- "binding_names.js",
- "Deno.core.encode.toString() === 'function encode() { [native code] }'",
- )
- .unwrap();
- let mut scope = runtime.handle_scope();
- let all_true = v8::Local::<v8::Value>::new(&mut scope, &all_true);
- assert!(all_true.is_true());
- }
-
#[tokio::test]
async fn test_async_opstate_borrow() {
struct InnerState(u64);
@@ -2884,16 +2872,16 @@ assertEquals(1, notify_return_value);
r#"
(async function () {
const results = [];
- Deno.core.setMacrotaskCallback(() => {
+ Deno.core.opSync("op_set_macrotask_callback", () => {
results.push("macrotask");
return true;
});
- Deno.core.setNextTickCallback(() => {
+ Deno.core.opSync("op_set_next_tick_callback", () => {
results.push("nextTick");
- Deno.core.setHasTickScheduled(false);
+ Deno.core.opSync("op_set_has_tick_scheduled", false);
});
- Deno.core.setHasTickScheduled(true);
+ Deno.core.opSync("op_set_has_tick_scheduled", true);
await Deno.core.opAsync('op_async_sleep');
if (results[0] != "nextTick") {
throw new Error(`expected nextTick, got: ${results[0]}`);
@@ -2916,10 +2904,10 @@ assertEquals(1, notify_return_value);
.execute_script(
"multiple_macrotasks_and_nextticks.js",
r#"
- Deno.core.setMacrotaskCallback(() => { return true; });
- Deno.core.setMacrotaskCallback(() => { return true; });
- Deno.core.setNextTickCallback(() => {});
- Deno.core.setNextTickCallback(() => {});
+ Deno.core.opSync("op_set_macrotask_callback", () => { return true; });
+ Deno.core.opSync("op_set_macrotask_callback", () => { return true; });
+ Deno.core.opSync("op_set_next_tick_callback", () => {});
+ Deno.core.opSync("op_set_next_tick_callback", () => {});
"#,
)
.unwrap();
@@ -2962,12 +2950,12 @@ assertEquals(1, notify_return_value);
.execute_script(
"has_tick_scheduled.js",
r#"
- Deno.core.setMacrotaskCallback(() => {
+ Deno.core.opSync("op_set_macrotask_callback", () => {
Deno.core.opSync("op_macrotask");
return true; // We're done.
});
- Deno.core.setNextTickCallback(() => Deno.core.opSync("op_next_tick"));
- Deno.core.setHasTickScheduled(true);
+ Deno.core.opSync("op_set_next_tick_callback", () => Deno.core.opSync("op_next_tick"));
+ Deno.core.opSync("op_set_has_tick_scheduled", true);
"#,
)
.unwrap();
@@ -3103,7 +3091,7 @@ assertEquals(1, notify_return_value);
"promise_reject_callback.js",
r#"
// Note: |promise| is not the promise created below, it's a child.
- Deno.core.setPromiseRejectCallback((type, promise, reason) => {
+ Deno.core.opSync("op_set_promise_reject_callback", (type, promise, reason) => {
if (type !== /* PromiseRejectWithNoHandler */ 0) {
throw Error("unexpected type: " + type);
}
@@ -3114,7 +3102,7 @@ assertEquals(1, notify_return_value);
throw Error("promiseReject"); // Triggers uncaughtException handler.
});
- Deno.core.setUncaughtExceptionCallback((err) => {
+ Deno.core.opSync("op_set_uncaught_exception_callback", (err) => {
if (err.message !== "promiseReject") throw err;
Deno.core.opSync("op_uncaught_exception");
});
@@ -3133,13 +3121,13 @@ assertEquals(1, notify_return_value);
"promise_reject_callback.js",
r#"
{
- const prev = Deno.core.setPromiseRejectCallback((...args) => {
+ const prev = Deno.core.opSync("op_set_promise_reject_callback", (...args) => {
prev(...args);
});
}
{
- const prev = Deno.core.setUncaughtExceptionCallback((...args) => {
+ const prev = Deno.core.opSync("op_set_uncaught_exception_callback", (...args) => {
prev(...args);
throw Error("fail");
});
diff --git a/core/serialize_deserialize_test.js b/core/serialize_deserialize_test.js
index f15fc04e8..cd7aa69b1 100644
--- a/core/serialize_deserialize_test.js
+++ b/core/serialize_deserialize_test.js
@@ -20,9 +20,15 @@ function assertArrayEquals(a1, a2) {
function main() {
const emptyString = "";
const emptyStringSerialized = [255, 15, 34, 0];
- assertArrayEquals(Deno.core.serialize(emptyString), emptyStringSerialized);
+ assertArrayEquals(
+ Deno.core.opSync("op_serialize", emptyString),
+ emptyStringSerialized,
+ );
assert(
- Deno.core.deserialize(new Uint8Array(emptyStringSerialized)) ===
+ Deno.core.opSync(
+ "op_deserialize",
+ new Uint8Array(emptyStringSerialized),
+ ) ===
emptyString,
);
@@ -33,12 +39,13 @@ function main() {
34, 1, 97, 48, 95, 36, 0, 4,
];
assertArrayEquals(
- Deno.core.serialize(primitiveValueArray),
+ Deno.core.opSync("op_serialize", primitiveValueArray),
primitiveValueArraySerialized,
);
assertArrayEquals(
- Deno.core.deserialize(
+ Deno.core.opSync(
+ "op_deserialize",
new Uint8Array(primitiveValueArraySerialized),
),
primitiveValueArray,
@@ -56,11 +63,12 @@ function main() {
];
assertArrayEquals(
- Deno.core.serialize(circularObject),
+ Deno.core.opSync("op_serialize", circularObject),
circularObjectSerialized,
);
- const deserializedCircularObject = Deno.core.deserialize(
+ const deserializedCircularObject = Deno.core.opSync(
+ "op_deserialize",
new Uint8Array(circularObjectSerialized),
);
assert(deserializedCircularObject.test == deserializedCircularObject);
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-24 20:20:57 +0000