diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e1a421f6a4..53f4a5ea1b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -235,7 +235,7 @@ jobs: ~/.cargo/registry/index ~/.cargo/registry/cache ~/.cargo/git/db - key: 14-cargo-home-${{ matrix.os }}-${{ hashFiles('Cargo.lock') }} + key: 15-cargo-home-${{ matrix.os }}-${{ hashFiles('Cargo.lock') }} # In main branch, always creates fresh cache - name: Cache build output (main) @@ -251,7 +251,7 @@ jobs: !./target/*/*.zip !./target/*/*.tar.gz key: | - 14-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-${{ github.sha }} + 15-cargo-target-${{ matrix.os }}-${{ matrix.profile }}-${{ github.sha }} # Restore cache from the latest 'main' branch build. - name: Cache build output (PR) @@ -267,7 +267,7 @@ jobs: !./target/*/*.tar.gz key: never_saved restore-keys: | - 14-cargo-target-${{ matrix.os }}-${{ matrix.profile }}- + 15-cargo-target-${{ matrix.os }}-${{ matrix.profile }}- # Don't save cache after building PRs or branches other than 'main'. - name: Skip save cache (PR) diff --git a/cli/tests/testdata/eval_context_throw_with_conflicting_source.ts.out b/cli/tests/testdata/eval_context_throw_with_conflicting_source.ts.out index 37219ba865..8dfbd0431c 100644 --- a/cli/tests/testdata/eval_context_throw_with_conflicting_source.ts.out +++ b/cli/tests/testdata/eval_context_throw_with_conflicting_source.ts.out @@ -1,4 +1,5 @@ [WILDCARD]error: Uncaught Error: foo Warning Couldn't format source line: Column 31 is out of bounds (source may have changed at runtime) at file:///[WILDCARD]/eval_context_conflicting_source.ts:1:31 + at [WILDCARD] at file:///[WILDCARD]/eval_context_throw_with_conflicting_source.ts:[WILDCARD] diff --git a/core/00_primordials.js b/core/00_primordials.js index 908278e210..4ca7ce0730 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 d484242883..9337c02314 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 a7d5d0ee2b..85c287102f 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 48e9a4561e..5681ded31c 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 = 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::::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::::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::Local::::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::::try_from(args.get(0)) { - Ok(s) => s, - Err(_) => { - throw_type_error(scope, "Missing first argument"); - return; - } - }; - - let url = match v8::Local::::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>, Option>); - - #[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::(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 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::::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>, - error_callback: Option>, -} - -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 { - 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, - ) -> Option { - 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 { - 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> { - 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> { - 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> { - 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 = - 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::::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::::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::::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::::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>, - transfered_array_buffers: Option>, -} - -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 = - 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::::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::::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::::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::(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 | PromiseError -fn get_promise_details( - scope: &mut v8::HandleScope, - args: v8::FunctionCallbackArguments, - mut rv: v8::ReturnValue, -) { - let promise = match v8::Local::::try_from(args.get(0)) { - Ok(val) => val, - Err(_) => { - throw_type_error(scope, "Invalid argument"); - return; - } - }; - - #[derive(Serialize)] - struct PromiseDetails<'s>(u32, Option>); - - 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::::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) { 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 94a65dad43..5165b196c9 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 1b59be1868..064c15fc13 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 b936fc7268..a2833e8112 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 234c0b1044..a42c0bae88 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 0000000000..7b7cfcc45e --- /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 { + 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, Error> { + v8::Local::::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>, 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>, 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>, + Option>, +); + +#[op(v8)] +fn op_eval_context<'a>( + scope: &mut v8::HandleScope<'a>, + source: serde_v8::Value<'a>, + specifier: Option, +) -> Result, Error> { + let tc_scope = &mut v8::TryCatch::new(scope); + let source = v8::Local::::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, Error> { + let text = v8::Local::::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, 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>, + error_callback: Option>, +} + +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 { + 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, + ) -> Option { + 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 { + 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> { + 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> { + 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> { + 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>, + transferred_array_buffers: Option>, +} + +#[op(v8)] +fn op_serialize( + scope: &mut v8::HandleScope, + value: serde_v8::Value, + options: Option, + error_callback: Option, +) -> Result { + let options = options.unwrap_or_default(); + let error_callback = match error_callback { + Some(cb) => Some( + v8::Local::::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::::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::::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::::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, +) -> Result, Error> { + let options = options.unwrap_or_default(); + let host_objects = match options.host_objects { + Some(value) => Some( + v8::Local::::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::::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>); + +#[op(v8)] +fn op_get_promise_details<'a>( + scope: &mut v8::HandleScope<'a>, + promise: serde_v8::Value<'a>, +) -> Result, Error> { + let promise = v8::Local::::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::::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::(rid)?; + wsr + }; + + // At this point there are no clones of Rc 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 { + 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 { + 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>, 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 66d28226ea..6cc6381229 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 = 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::::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 f15fc04e8e..cd7aa69b1d 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); diff --git a/ext/web/13_message_port.js b/ext/web/13_message_port.js index 01ed92d9ab..19aa0a93bd 100644 --- a/ext/web/13_message_port.js +++ b/ext/web/13_message_port.js @@ -205,7 +205,7 @@ const transferables = []; const hostObjects = []; const arrayBufferIdsInTransferables = []; - const transferedArrayBuffers = []; + const transferredArrayBuffers = []; for (const transferable of messageData.transferables) { switch (transferable.kind) { @@ -216,7 +216,7 @@ break; } case "arrayBuffer": { - ArrayPrototypePush(transferedArrayBuffers, transferable.data); + ArrayPrototypePush(transferredArrayBuffers, transferable.data); const i = ArrayPrototypePush(transferables, null); ArrayPrototypePush(arrayBufferIdsInTransferables, i); break; @@ -228,12 +228,12 @@ const data = core.deserialize(messageData.data, { hostObjects, - transferedArrayBuffers, + transferredArrayBuffers, }); for (const i in arrayBufferIdsInTransferables) { const id = arrayBufferIdsInTransferables[i]; - transferables[id] = transferedArrayBuffers[i]; + transferables[id] = transferredArrayBuffers[i]; } return [data, transferables]; @@ -247,12 +247,12 @@ * @returns {globalThis.__bootstrap.messagePort.MessageData} */ function serializeJsMessageData(data, transferables) { - const transferedArrayBuffers = ArrayPrototypeFilter( + const transferredArrayBuffers = ArrayPrototypeFilter( transferables, (a) => ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, a), ); - for (const arrayBuffer of transferedArrayBuffers) { + for (const arrayBuffer of transferredArrayBuffers) { // This is hacky with both false positives and false negatives for // detecting detached array buffers. V8 needs to add a way to tell if a // buffer is detached or not. @@ -270,7 +270,7 @@ transferables, (a) => ObjectPrototypeIsPrototypeOf(MessagePortPrototype, a), ), - transferedArrayBuffers, + transferredArrayBuffers, }, (err) => { throw new DOMException(err, "DataCloneError"); }); @@ -299,7 +299,7 @@ ) { ArrayPrototypePush(serializedTransferables, { kind: "arrayBuffer", - data: transferedArrayBuffers[arrayBufferI], + data: transferredArrayBuffers[arrayBufferI], }); arrayBufferI++; } else { diff --git a/ext/web/lib.deno_web.d.ts b/ext/web/lib.deno_web.d.ts index 220a3cc602..00b494684a 100644 --- a/ext/web/lib.deno_web.d.ts +++ b/ext/web/lib.deno_web.d.ts @@ -730,7 +730,7 @@ declare class MessageEvent extends Event { */ readonly lastEventId: string; /** - * Returns transfered ports. + * Returns transferred ports. */ readonly ports: ReadonlyArray; constructor(type: string, eventInitDict?: MessageEventInit); diff --git a/ops/lib.rs b/ops/lib.rs index 01548ad5fa..7fb618425f 100644 --- a/ops/lib.rs +++ b/ops/lib.rs @@ -6,7 +6,10 @@ use proc_macro_crate::crate_name; use proc_macro_crate::FoundCrate; use quote::quote; use quote::ToTokens; +use syn::punctuated::Punctuated; +use syn::token::Comma; use syn::FnArg; +use syn::GenericParam; use syn::Ident; // Identifier to the `deno_core` crate. @@ -71,7 +74,7 @@ pub fn op(attr: TokenStream, item: TokenStream) -> TokenStream { let func = syn::parse::(item).expect("expected a function"); let name = &func.sig.ident; let generics = &func.sig.generics; - let type_params = &func.sig.generics.params; + let type_params = exclude_lifetime_params(&func.sig.generics.params); let where_clause = &func.sig.generics.where_clause; // Preserve the original func as op_foo::call() @@ -152,7 +155,7 @@ fn codegen_v8_async( }; let rust_i0 = if uses_opstate { 1 } else { 0 }; let (arg_decls, args_tail) = codegen_args(core, f, rust_i0, 1); - let type_params = &f.sig.generics.params; + let type_params = exclude_lifetime_params(&f.sig.generics.params); let result_wrapper = match is_result(&f.sig.output) { true => quote! {}, @@ -234,7 +237,7 @@ fn codegen_v8_sync( let (arg_decls, args_tail) = codegen_args(core, f, rust_i0, 0); let ret = codegen_sync_ret(core, &f.sig.output); - let type_params = &f.sig.generics.params; + let type_params = exclude_lifetime_params(&f.sig.generics.params); quote! { // SAFETY: #core guarantees args.data() is a v8 External pointing to an OpCtx for the isolates lifetime @@ -379,9 +382,21 @@ fn is_rc_refcell_opstate(arg: &syn::FnArg) -> bool { fn is_handle_scope(arg: &syn::FnArg) -> bool { tokens(arg).ends_with(": & mut v8 :: HandleScope") + || tokens(arg).ends_with(": & mut v8 :: HandleScope < 'a >") || tokens(arg).ends_with(": & mut deno_core :: v8 :: HandleScope") + || tokens(arg).ends_with(": & mut deno_core :: v8 :: HandleScope < 'a >") } fn tokens(x: impl ToTokens) -> String { x.to_token_stream().to_string() } + +fn exclude_lifetime_params( + generic_params: &Punctuated, +) -> Punctuated { + generic_params + .iter() + .filter(|t| !tokens(t).starts_with('\'')) + .cloned() + .collect::>() +} diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js index 0bacaf58cd..ae0de39371 100644 --- a/runtime/js/99_main.js +++ b/runtime/js/99_main.js @@ -231,7 +231,7 @@ delete Object.prototype.__proto__; function runtimeStart(runtimeOptions, source) { core.setMacrotaskCallback(timers.handleTimerMacrotask); core.setWasmStreamingCallback(fetch.handleWasmStreaming); - core.setFormatExceptionCallback(formatException); + core.opSync("op_set_format_exception_callback", formatException); version.setVersions( runtimeOptions.denoVersion, runtimeOptions.v8Version,