diff options
| -rw-r--r-- | cli/worker.rs | 2 | ||||
| -rw-r--r-- | core/bindings.rs | 549 | ||||
| -rw-r--r-- | core/isolate.rs | 896 | ||||
| -rw-r--r-- | core/lib.rs | 1 | ||||
| -rw-r--r-- | core/libdeno.rs | 1589 | ||||
| -rw-r--r-- | core/modules.rs | 4 | ||||
| -rw-r--r-- | deno_typescript/lib.rs | 4 |
7 files changed, 1400 insertions, 1645 deletions
diff --git a/cli/worker.rs b/cli/worker.rs index c2e480c1f..e25aa8018 100644 --- a/cli/worker.rs +++ b/cli/worker.rs @@ -35,7 +35,7 @@ pub struct WorkerChannels { #[derive(Clone)] pub struct Worker { pub name: String, - isolate: Arc<Mutex<deno_core::Isolate>>, + isolate: Arc<Mutex<Box<deno_core::Isolate>>>, pub state: ThreadSafeState, external_channels: Arc<Mutex<WorkerChannels>>, } diff --git a/core/bindings.rs b/core/bindings.rs new file mode 100644 index 000000000..516bb5531 --- /dev/null +++ b/core/bindings.rs @@ -0,0 +1,549 @@ +// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. + +#![allow(mutable_transmutes)] +#![allow(clippy::transmute_ptr_to_ptr)] + +use crate::isolate::Isolate; +use crate::libdeno::deno_buf; +use crate::libdeno::script_origin; +use crate::libdeno::PinnedBuf; + +use rusty_v8 as v8; +use v8::InIsolate; + +use libc::c_char; +use libc::c_void; +use std::convert::TryFrom; +use std::ffi::CString; +use std::option::Option; + +pub extern "C" fn host_import_module_dynamically_callback( + context: v8::Local<v8::Context>, + referrer: v8::Local<v8::ScriptOrModule>, + specifier: v8::Local<v8::String>, +) -> *mut v8::Promise { + let mut cbs = v8::CallbackScope::new(context); + let mut hs = v8::EscapableHandleScope::new(cbs.enter()); + let scope = hs.enter(); + let isolate = scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + + // NOTE(bartlomieju): will crash for non-UTF-8 specifier + let specifier_str = specifier + .to_string(scope) + .unwrap() + .to_rust_string_lossy(scope); + let referrer_name = referrer.get_resource_name(); + let referrer_name_str = referrer_name + .to_string(scope) + .unwrap() + .to_rust_string_lossy(scope); + + // TODO(ry) I'm not sure what HostDefinedOptions is for or if we're ever going + // to use it. For now we check that it is not used. This check may need to be + // changed in the future. + let host_defined_options = referrer.get_host_defined_options(); + assert_eq!(host_defined_options.length(), 0); + + let mut resolver = v8::PromiseResolver::new(scope, context).unwrap(); + let promise = resolver.get_promise(scope); + + let mut resolver_handle = v8::Global::new(); + resolver_handle.set(scope, resolver); + + let import_id = deno_isolate.next_dyn_import_id_; + deno_isolate.next_dyn_import_id_ += 1; + deno_isolate + .dyn_import_map_ + .insert(import_id, resolver_handle); + + deno_isolate.dyn_import_cb(&specifier_str, &referrer_name_str, import_id); + + &mut *scope.escape(promise) +} + +pub extern "C" fn host_initialize_import_meta_object_callback( + context: v8::Local<v8::Context>, + module: v8::Local<v8::Module>, + meta: v8::Local<v8::Object>, +) { + let mut cbs = v8::CallbackScope::new(context); + let mut hs = v8::HandleScope::new(cbs.enter()); + let scope = hs.enter(); + let isolate = scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + + let id = module.get_identity_hash(); + assert_ne!(id, 0); + + let info = deno_isolate.get_module_info(id).expect("Module not found"); + + meta.create_data_property( + context, + v8::String::new(scope, "url").unwrap().into(), + v8::String::new(scope, &info.name).unwrap().into(), + ); + meta.create_data_property( + context, + v8::String::new(scope, "main").unwrap().into(), + v8::Boolean::new(scope, info.main).into(), + ); +} + +pub extern "C" fn message_callback( + message: v8::Local<v8::Message>, + _exception: v8::Local<v8::Value>, +) { + let mut message: v8::Local<v8::Message> = + unsafe { std::mem::transmute(message) }; + let isolate = message.get_isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + assert!(!deno_isolate.context_.is_empty()); + let context = deno_isolate.context_.get(scope).unwrap(); + + // TerminateExecution was called + if isolate.is_execution_terminating() { + let u = v8::new_undefined(scope); + deno_isolate.handle_exception(scope, context, u.into()); + return; + } + + let json_str = deno_isolate.encode_message_as_json(scope, context, message); + deno_isolate.last_exception_ = Some(json_str); +} + +pub extern "C" fn promise_reject_callback(msg: v8::PromiseRejectMessage) { + #[allow(mutable_transmutes)] + let mut msg: v8::PromiseRejectMessage = unsafe { std::mem::transmute(msg) }; + let isolate = msg.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + let mut locker = v8::Locker::new(isolate); + assert!(!deno_isolate.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let mut context = deno_isolate.context_.get(scope).unwrap(); + context.enter(); + + let promise = msg.get_promise(); + let promise_id = promise.get_identity_hash(); + + match msg.get_event() { + v8::PromiseRejectEvent::PromiseRejectWithNoHandler => { + let error = msg.get_value(); + let mut error_global = v8::Global::<v8::Value>::new(); + error_global.set(scope, error); + deno_isolate + .pending_promise_map_ + .insert(promise_id, error_global); + } + v8::PromiseRejectEvent::PromiseHandlerAddedAfterReject => { + if let Some(mut handle) = + deno_isolate.pending_promise_map_.remove(&promise_id) + { + handle.reset(scope); + } + } + v8::PromiseRejectEvent::PromiseRejectAfterResolved => {} + v8::PromiseRejectEvent::PromiseResolveAfterResolved => { + // Should not warn. See #1272 + } + }; + + context.exit(); +} + +pub extern "C" fn print(info: &v8::FunctionCallbackInfo) { + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + + let arg_len = info.length(); + assert!(arg_len >= 0 && arg_len <= 2); + + let obj = info.get_argument(0); + let is_err_arg = info.get_argument(1); + + let mut hs = v8::HandleScope::new(info); + let scope = hs.enter(); + + let mut is_err = false; + if arg_len == 2 { + let int_val = is_err_arg + .integer_value(scope) + .expect("Unable to convert to integer"); + is_err = int_val != 0; + }; + let mut try_catch = v8::TryCatch::new(scope); + let _tc = try_catch.enter(); + let str_ = match obj.to_string(scope) { + Some(s) => s, + None => v8::String::new(scope, "").unwrap(), + }; + if is_err { + eprint!("{}", str_.to_rust_string_lossy(scope)); + } else { + print!("{}", str_.to_rust_string_lossy(scope)); + } +} + +pub extern "C" fn recv(info: &v8::FunctionCallbackInfo) { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + assert_eq!(info.length(), 1); + let isolate = info.get_isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + let mut locker = v8::Locker::new(&isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + + if !deno_isolate.recv_.is_empty() { + let msg = v8::String::new(scope, "Deno.core.recv already called.").unwrap(); + isolate.throw_exception(msg.into()); + return; + } + + let recv_fn = + v8::Local::<v8::Function>::try_from(info.get_argument(0)).unwrap(); + deno_isolate.recv_.set(scope, recv_fn); +} + +pub extern "C" fn send(info: &v8::FunctionCallbackInfo) { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + + let mut hs = v8::HandleScope::new(info); + let scope = hs.enter(); + let isolate = scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + assert!(!deno_isolate.context_.is_empty()); + + let op_id = v8::Local::<v8::Uint32>::try_from(info.get_argument(0)) + .unwrap() + .value() as u32; + + let control = + v8::Local::<v8::ArrayBufferView>::try_from(info.get_argument(1)) + .map(|view| { + let mut backing_store = view.buffer().unwrap().get_backing_store(); + let backing_store_ptr = backing_store.data() as *mut _ as *mut u8; + let view_ptr = unsafe { backing_store_ptr.add(view.byte_offset()) }; + let view_len = view.byte_length(); + unsafe { deno_buf::from_raw_parts(view_ptr, view_len) } + }) + .unwrap_or_else(|_| deno_buf::empty()); + + let zero_copy: Option<PinnedBuf> = + v8::Local::<v8::ArrayBufferView>::try_from(info.get_argument(2)) + .map(PinnedBuf::new) + .ok(); + + // TODO: what's the point of this again? + // DCHECK_NULL(d->current_args_); + // d->current_args_ = &args; + assert!(deno_isolate.current_args_.is_null()); + deno_isolate.current_args_ = info; + + deno_isolate.pre_dispatch(op_id, control, zero_copy); + + if deno_isolate.current_args_.is_null() { + // This indicates that deno_repond() was called already. + } else { + // Asynchronous. + deno_isolate.current_args_ = std::ptr::null(); + } +} + +pub extern "C" fn eval_context(info: &v8::FunctionCallbackInfo) { + let rv = &mut info.get_return_value(); + + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + let arg0 = info.get_argument(0); + + let mut hs = v8::HandleScope::new(info); + let scope = hs.enter(); + let isolate = scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + assert!(!deno_isolate.context_.is_empty()); + let context = deno_isolate.context_.get(scope).unwrap(); + + let source = match v8::Local::<v8::String>::try_from(arg0) { + Ok(s) => s, + Err(_) => { + let msg = v8::String::new(scope, "Invalid argument").unwrap(); + let exception = v8::type_error(scope, msg); + scope.isolate().throw_exception(exception); + return; + } + }; + + let output = v8::Array::new(scope, 2); + /* + output[0] = result + output[1] = ErrorInfo | null + ErrorInfo = { + thrown: Error | any, + isNativeError: boolean, + isCompileError: boolean, + } + */ + let mut try_catch = v8::TryCatch::new(scope); + let tc = try_catch.enter(); + let name = v8::String::new(scope, "<unknown>").unwrap(); + let origin = script_origin(scope, name); + let maybe_script = v8::Script::compile(scope, context, source, Some(&origin)); + + if maybe_script.is_none() { + assert!(tc.has_caught()); + let exception = tc.exception().unwrap(); + + output.set( + context, + v8::Integer::new(scope, 0).into(), + v8::new_null(scope).into(), + ); + + let errinfo_obj = v8::Object::new(scope); + errinfo_obj.set( + context, + v8::String::new(scope, "isCompileError").unwrap().into(), + v8::Boolean::new(scope, true).into(), + ); + + errinfo_obj.set( + context, + v8::String::new(scope, "isNativeError").unwrap().into(), + v8::Boolean::new(scope, exception.is_native_error()).into(), + ); + + errinfo_obj.set( + context, + v8::String::new(scope, "thrown").unwrap().into(), + exception, + ); + + output.set( + context, + v8::Integer::new(scope, 1).into(), + errinfo_obj.into(), + ); + + rv.set(output.into()); + return; + } + + let result = maybe_script.unwrap().run(scope, context); + + if result.is_none() { + assert!(tc.has_caught()); + let exception = tc.exception().unwrap(); + + output.set( + context, + v8::Integer::new(scope, 0).into(), + v8::new_null(scope).into(), + ); + + let errinfo_obj = v8::Object::new(scope); + errinfo_obj.set( + context, + v8::String::new(scope, "isCompileError").unwrap().into(), + v8::Boolean::new(scope, false).into(), + ); + + let is_native_error = if exception.is_native_error() { + v8::Boolean::new(scope, true) + } else { + v8::Boolean::new(scope, false) + }; + + errinfo_obj.set( + context, + v8::String::new(scope, "isNativeError").unwrap().into(), + is_native_error.into(), + ); + + errinfo_obj.set( + context, + v8::String::new(scope, "thrown").unwrap().into(), + exception, + ); + + output.set( + context, + v8::Integer::new(scope, 1).into(), + errinfo_obj.into(), + ); + + rv.set(output.into()); + return; + } + + output.set(context, v8::Integer::new(scope, 0).into(), result.unwrap()); + output.set( + context, + v8::Integer::new(scope, 1).into(), + v8::new_null(scope).into(), + ); + rv.set(output.into()); +} + +pub extern "C" fn error_to_json(info: &v8::FunctionCallbackInfo) { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + assert_eq!(info.length(), 1); + // <Boilerplate> + let isolate = info.get_isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + let mut locker = v8::Locker::new(&isolate); + assert!(!deno_isolate.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let context = deno_isolate.context_.get(scope).unwrap(); + // </Boilerplate> + let exception = info.get_argument(0); + let json_string = + deno_isolate.encode_exception_as_json(scope, context, exception); + let s = v8::String::new(scope, &json_string).unwrap(); + let mut rv = info.get_return_value(); + rv.set(s.into()); +} + +pub extern "C" fn queue_microtask(info: &v8::FunctionCallbackInfo) { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::FunctionCallbackInfo = + unsafe { std::mem::transmute(info) }; + assert_eq!(info.length(), 1); + let arg0 = info.get_argument(0); + let isolate = info.get_isolate(); + let mut locker = v8::Locker::new(&isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + + match v8::Local::<v8::Function>::try_from(arg0) { + Ok(f) => isolate.enqueue_microtask(f), + Err(_) => { + let msg = v8::String::new(scope, "Invalid argument").unwrap(); + let exception = v8::type_error(scope, msg); + isolate.throw_exception(exception); + } + }; +} + +pub extern "C" fn shared_getter( + _name: v8::Local<v8::Name>, + info: &v8::PropertyCallbackInfo, +) { + let shared_ab = { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let info: &mut v8::PropertyCallbackInfo = + unsafe { std::mem::transmute(info) }; + + let mut hs = v8::EscapableHandleScope::new(info); + let scope = hs.enter(); + let isolate = scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + + if deno_isolate.shared_.data_ptr.is_null() { + return; + } + + // Lazily initialize the persistent external ArrayBuffer. + if deno_isolate.shared_ab_.is_empty() { + #[allow(mutable_transmutes)] + #[allow(clippy::transmute_ptr_to_ptr)] + let data_ptr: *mut u8 = + unsafe { std::mem::transmute(deno_isolate.shared_.data_ptr) }; + let ab = unsafe { + v8::SharedArrayBuffer::new_DEPRECATED( + scope, + data_ptr as *mut c_void, + deno_isolate.shared_.data_len, + ) + }; + deno_isolate.shared_ab_.set(scope, ab); + } + + let shared_ab = deno_isolate.shared_ab_.get(scope).unwrap(); + scope.escape(shared_ab) + }; + + let rv = &mut info.get_return_value(); + rv.set(shared_ab.into()); +} + +pub fn module_resolve_callback( + context: v8::Local<v8::Context>, + specifier: v8::Local<v8::String>, + referrer: v8::Local<v8::Module>, +) -> *mut v8::Module { + let mut cbs = v8::CallbackScope::new(context); + let cb_scope = cbs.enter(); + let isolate = cb_scope.isolate(); + let deno_isolate: &mut Isolate = + unsafe { &mut *(isolate.get_data(0) as *mut Isolate) }; + + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::EscapableHandleScope::new(&mut locker); + let scope = hs.enter(); + + let referrer_id = referrer.get_identity_hash(); + let referrer_info = deno_isolate + .get_module_info(referrer_id) + .expect("ModuleInfo not found"); + let len_ = referrer.get_module_requests_length(); + + let specifier_str = specifier.to_rust_string_lossy(scope); + + for i in 0..len_ { + let req = referrer.get_module_request(i); + let req_str = req.to_rust_string_lossy(scope); + + if req_str == specifier_str { + let resolve_cb = deno_isolate.resolve_cb_.unwrap(); + let c_str = CString::new(req_str.to_string()).unwrap(); + let c_req_str: *const c_char = c_str.as_ptr() as *const c_char; + let id = unsafe { + resolve_cb(deno_isolate.resolve_context_, c_req_str, referrer_id) + }; + let maybe_info = deno_isolate.get_module_info(id); + + if maybe_info.is_none() { + let msg = format!( + "Cannot resolve module \"{}\" from \"{}\"", + req_str, referrer_info.name + ); + let msg = v8::String::new(scope, &msg).unwrap(); + isolate.throw_exception(msg.into()); + break; + } + + let child_mod = + maybe_info.unwrap().handle.get(scope).expect("Empty handle"); + return &mut *scope.escape(child_mod); + } + } + + std::ptr::null_mut() +} diff --git a/core/isolate.rs b/core/isolate.rs index 9d1b5bb8b..7386aad14 100644 --- a/core/isolate.rs +++ b/core/isolate.rs @@ -5,6 +5,17 @@ // Isolate struct from becoming too bloating for users who do not need // asynchronous module loading. +#![allow(mutable_transmutes)] +#![allow(clippy::transmute_ptr_to_ptr)] + +use crate::bindings; + +use rusty_v8 as v8; + +use std::collections::HashMap; +use std::convert::From; +use std::option::Option; + use crate::any_error::ErrBox; use crate::js_errors::CoreJSError; use crate::js_errors::V8Exception; @@ -12,8 +23,11 @@ use crate::libdeno; use crate::libdeno::deno_buf; use crate::libdeno::deno_dyn_import_id; use crate::libdeno::deno_mod; +use crate::libdeno::deno_resolve_cb; +use crate::libdeno::ModuleInfo; use crate::libdeno::PinnedBuf; use crate::libdeno::Snapshot1; +use crate::libdeno::SnapshotConfig; use crate::ops::*; use crate::shared_queue::SharedQueue; use crate::shared_queue::RECOMMENDED_SIZE; @@ -163,9 +177,35 @@ type IsolateErrorHandleFn = dyn FnMut(ErrBox) -> Result<(), ErrBox>; /// Ops are created in JavaScript by calling Deno.core.dispatch(), and in Rust /// by implementing dispatcher function that takes control buffer and optional zero copy buffer /// as arguments. An async Op corresponds exactly to a Promise in JavaScript. +#[allow(unused)] pub struct Isolate { - libdeno_isolate: Box<libdeno::DenoIsolate>, - shared_libdeno_isolate: Arc<Mutex<Option<*mut libdeno::DenoIsolate>>>, + // TODO: Fields moved from libdeno, to be refactored + isolate_: Option<v8::OwnedIsolate>, + pub last_exception_: Option<String>, + pub last_exception_handle_: v8::Global<v8::Value>, + pub context_: v8::Global<v8::Context>, + mods_: HashMap<deno_mod, ModuleInfo>, + mods_by_name_: HashMap<String, deno_mod>, + locker_: Option<v8::Locker>, + pub shared_: deno_buf, + pub shared_ab_: v8::Global<v8::SharedArrayBuffer>, + pub resolve_cb_: Option<deno_resolve_cb>, + pub recv_: v8::Global<v8::Function>, + pub current_args_: *const v8::FunctionCallbackInfo, + snapshot_creator_: Option<v8::SnapshotCreator>, + has_snapshotted_: bool, + snapshot_: Option<SnapshotConfig>, + pub next_dyn_import_id_: deno_dyn_import_id, + pub dyn_import_map_: + HashMap<deno_dyn_import_id, v8::Global<v8::PromiseResolver>>, + pub pending_promise_map_: HashMap<i32, v8::Global<v8::Value>>, + // Used in deno_mod_instantiate + pub resolve_context_: *mut c_void, + + // TODO: These two fields were not yet ported from libdeno + // void* global_import_buf_ptr_; + // v8::Persistent<v8::ArrayBuffer> global_import_buf_; + shared_isolate_handle: Arc<Mutex<Option<*mut v8::Isolate>>>, dyn_import: Option<Arc<DynImportFn>>, js_error_create: Arc<JSErrorCreateFn>, needs_init: bool, @@ -184,7 +224,46 @@ unsafe impl Send for Isolate {} impl Drop for Isolate { fn drop(&mut self) { // remove shared_libdeno_isolate reference - *self.shared_libdeno_isolate.lock().unwrap() = None; + *self.shared_isolate_handle.lock().unwrap() = None; + + // TODO Too much boiler plate. + // <Boilerplate> + let isolate = self.isolate_.take().unwrap(); + { + let mut locker = v8::Locker::new(&isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + // </Boilerplate> + self.context_.reset(scope); + self.shared_ab_.reset(scope); + self.last_exception_handle_.reset(scope); + self.recv_.reset(scope); + for (_key, module) in self.mods_.iter_mut() { + module.handle.reset(scope); + } + for (_key, handle) in self.dyn_import_map_.iter_mut() { + handle.reset(scope); + } + for (_key, handle) in self.pending_promise_map_.iter_mut() { + handle.reset(scope); + } + } + if let Some(locker_) = self.locker_.take() { + drop(locker_); + } + if let Some(creator) = self.snapshot_creator_.take() { + // TODO(ry) V8 has a strange assert which prevents a SnapshotCreator from + // being deallocated if it hasn't created a snapshot yet. + // https://github.com/v8/v8/blob/73212783fbd534fac76cc4b66aac899c13f71fc8/src/api.cc#L603 + // If that assert is removed, this if guard could be removed. + // WARNING: There may be false positive LSAN errors here. + std::mem::forget(isolate); + if self.has_snapshotted_ { + drop(creator); + } + } else { + drop(isolate); + } } } @@ -193,23 +272,12 @@ static DENO_INIT: Once = Once::new(); impl Isolate { /// startup_data defines the snapshot or script used at startup to initialize /// the isolate. - pub fn new(startup_data: StartupData, will_snapshot: bool) -> Self { + pub fn new(startup_data: StartupData, will_snapshot: bool) -> Box<Self> { DENO_INIT.call_once(|| { unsafe { libdeno::deno_init() }; }); - let shared = SharedQueue::new(RECOMMENDED_SIZE); - - let needs_init = true; - - let mut libdeno_config = libdeno::deno_config { - will_snapshot: will_snapshot.into(), - load_snapshot: None, - shared: shared.as_deno_buf(), - recv_cb: Self::pre_dispatch, - dyn_import_cb: Self::dyn_import, - }; - + let mut load_snapshot: Option<SnapshotConfig> = None; let mut startup_script: Option<OwnedScript> = None; // Separate into Option values for each startup type @@ -218,21 +286,88 @@ impl Isolate { startup_script = Some(d.into()); } StartupData::Snapshot(d) => { - libdeno_config.load_snapshot = Some(d.into()); + load_snapshot = Some(d.into()); } StartupData::LibdenoSnapshot(d) => { - libdeno_config.load_snapshot = Some(d.into()); + load_snapshot = Some(d.into()); } StartupData::None => {} }; - let libdeno_isolate = unsafe { libdeno::deno_new(libdeno_config) }; - let shared_libdeno_isolate = Arc::new(Mutex::new(Some(libdeno_isolate))); - let libdeno_isolate = unsafe { Box::from_raw(libdeno_isolate) }; + let mut context_ = v8::Global::<v8::Context>::new(); + let (mut isolate, maybe_snapshot_creator) = if will_snapshot { + // TODO(ry) Support loading snapshots before snapshotting. + assert!(load_snapshot.is_none()); + let mut creator = + v8::SnapshotCreator::new(Some(&libdeno::EXTERNAL_REFERENCES)); + let isolate = unsafe { creator.get_owned_isolate() }; + let isolate = Isolate::setup_isolate(isolate); - Self { - libdeno_isolate, - shared_libdeno_isolate, + let mut locker = v8::Locker::new(&isolate); + { + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let context = v8::Context::new(scope); + // context.enter(); + context_.set(scope, context); + creator.set_default_context(context); + libdeno::initialize_context(scope, context); + // context.exit(); + } + + (isolate, Some(creator)) + } else { + let mut params = v8::Isolate::create_params(); + params.set_array_buffer_allocator(v8::new_default_allocator()); + params.set_external_references(&libdeno::EXTERNAL_REFERENCES); + if let Some(ref mut snapshot) = load_snapshot { + params.set_snapshot_blob(snapshot); + } + + let load_snapshot_is_null = load_snapshot.is_none(); + let isolate = v8::Isolate::new(params); + let isolate = Isolate::setup_isolate(isolate); + + { + let mut locker = v8::Locker::new(&isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let context = v8::Context::new(scope); + + if load_snapshot_is_null { + // If no snapshot is provided, we initialize the context with empty + // main source code and source maps. + libdeno::initialize_context(scope, context); + } + context_.set(scope, context); + } + (isolate, None) + }; + + let shared = SharedQueue::new(RECOMMENDED_SIZE); + let needs_init = true; + + let core_isolate = Self { + isolate_: None, + last_exception_: None, + last_exception_handle_: v8::Global::<v8::Value>::new(), + context_, + mods_: HashMap::new(), + mods_by_name_: HashMap::new(), + pending_promise_map_: HashMap::new(), + locker_: None, + shared_: shared.as_deno_buf(), + shared_ab_: v8::Global::<v8::SharedArrayBuffer>::new(), + resolve_cb_: Some(Isolate::resolve_cb), + recv_: v8::Global::<v8::Function>::new(), + current_args_: std::ptr::null(), + snapshot_creator_: maybe_snapshot_creator, + snapshot_: load_snapshot, + has_snapshotted_: false, + next_dyn_import_id_: 0, + dyn_import_map_: HashMap::new(), + resolve_context_: std::ptr::null_mut(), + shared_isolate_handle: Arc::new(Mutex::new(None)), dyn_import: None, js_error_create: Arc::new(CoreJSError::from_v8_exception), shared, @@ -244,9 +379,349 @@ impl Isolate { op_registry: Arc::new(OpRegistry::new()), waker: AtomicWaker::new(), error_handler: None, + }; + + let mut boxed_isolate = Box::new(core_isolate); + { + let core_isolate_ptr: *mut Self = Box::into_raw(boxed_isolate); + unsafe { isolate.set_data(0, core_isolate_ptr as *mut c_void) }; + boxed_isolate = unsafe { Box::from_raw(core_isolate_ptr) }; + let shared_handle_ptr = &mut *isolate; + *boxed_isolate.shared_isolate_handle.lock().unwrap() = + Some(shared_handle_ptr); + boxed_isolate.isolate_ = Some(isolate); } + + boxed_isolate + } + + // Methods ported from libdeno, to be refactored + pub fn setup_isolate(mut isolate: v8::OwnedIsolate) -> v8::OwnedIsolate { + isolate.set_capture_stack_trace_for_uncaught_exceptions(true, 10); + isolate.set_promise_reject_callback(bindings::promise_reject_callback); + isolate.add_message_listener(bindings::message_callback); + isolate.set_host_initialize_import_meta_object_callback( + bindings::host_initialize_import_meta_object_callback, + ); + isolate.set_host_import_module_dynamically_callback( + bindings::host_import_module_dynamically_callback, + ); + isolate + } + + pub fn register_module( + &mut self, + main: bool, + name: &str, + source: &str, + ) -> deno_mod { + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(&isolate); + + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + assert!(!self.context_.is_empty()); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + + let name_str = v8::String::new(scope, name).unwrap(); + let source_str = v8::String::new(scope, source).unwrap(); + + let origin = libdeno::module_origin(scope, name_str); + let source = v8::script_compiler::Source::new(source_str, &origin); + + let mut try_catch = v8::TryCatch::new(scope); + let tc = try_catch.enter(); + + let maybe_module = v8::script_compiler::compile_module(&isolate, source); + + if tc.has_caught() { + assert!(maybe_module.is_none()); + self.handle_exception(scope, context, tc.exception().unwrap()); + context.exit(); + return 0; + } + let module = maybe_module.unwrap(); + let id = module.get_identity_hash(); + + let mut import_specifiers: Vec<String> = vec![]; + for i in 0..module.get_module_requests_length() { + let specifier = module.get_module_request(i); + import_specifiers.push(specifier.to_rust_string_lossy(scope)); + } + + let mut handle = v8::Global::<v8::Module>::new(); + handle.set(scope, module); + self.mods_.insert( + id, + ModuleInfo { + main, + name: name.to_string(), + import_specifiers, + handle, + }, + ); + self.mods_by_name_.insert(name.to_string(), id); + context.exit(); + id + } + + pub fn get_module_info(&self, id: deno_mod) -> Option<&ModuleInfo> { + if id == 0 { + return None; + } + self.mods_.get(&id) + } + + pub fn handle_exception<'a>( + &mut self, + s: &mut impl v8::ToLocal<'a>, + mut context: v8::Local<'a, v8::Context>, + exception: v8::Local<'a, v8::Value>, + ) { + let isolate = context.get_isolate(); + // TerminateExecution was called + if isolate.is_execution_terminating() { + // cancel exception termination so that the exception can be created + isolate.cancel_terminate_execution(); + + // maybe make a new exception object + let exception = if exception.is_null_or_undefined() { + let exception_str = v8::String::new(s, "execution terminated").unwrap(); + isolate.enter(); + let e = v8::error(s, exception_str); + isolate.exit(); + e + } else { + exception + }; + + // handle the exception as if it is a regular exception + self.handle_exception(s, context, exception); + + // re-enable exception termination + context.get_isolate().terminate_execution(); + return; + } + + let json_str = self.encode_exception_as_json(s, context, exception); + self.last_exception_ = Some(json_str); + self.last_exception_handle_.set(s, exception); + } + + pub fn encode_exception_as_json<'a>( + &mut self, + s: &mut impl v8::ToLocal<'a>, + context: v8::Local<'a, v8::Context>, + exception: v8::Local<'a, v8::Value>, + ) -> String { + let message = v8::create_message(s, exception); + self.encode_message_as_json(s, context, message) + } + + pub fn encode_message_as_json<'a>( + &mut self, + s: &mut impl v8::ToLocal<'a>, + context: v8::Local<v8::Context>, + message: v8::Local<v8::Message>, + ) -> String { + let json_obj = self.encode_message_as_object(s, context, message); + let json_string = v8::json::stringify(context, json_obj.into()).unwrap(); + json_string.to_rust_string_lossy(s) + } + + fn encode_message_as_object<'a>( + &mut self, + s: &mut impl v8::ToLocal<'a>, + context: v8::Local<v8::Context>, + message: v8::Local<v8::Message>, + ) -> v8::Local<'a, v8::Object> { + let json_obj = v8::Object::new(s); + + let exception_str = message.get(s); + json_obj.set( + context, + v8::String::new(s, "message").unwrap().into(), + exception_str.into(), + ); + + let script_resource_name = message + .get_script_resource_name(s) + .expect("Missing ScriptResourceName"); + json_obj.set( + context, + v8::String::new(s, "scriptResourceName").unwrap().into(), + script_resource_name, + ); + + let source_line = message + .get_source_line(s, context) + .expect("Missing SourceLine"); + json_obj.set( + context, + v8::String::new(s, "sourceLine").unwrap().into(), + source_line.into(), + ); + + let line_number = message + .get_line_number(context) + .expect("Missing LineNumber"); + json_obj.set( + context, + v8::String::new(s, "lineNumber").unwrap().into(), + v8::Integer::new(s, line_number as i32).into(), + ); + + json_obj.set( + context, + v8::String::new(s, "startPosition").unwrap().into(), + v8::Integer::new(s, message.get_start_position() as i32).into(), + ); + + json_obj.set( + context, + v8::String::new(s, "endPosition").unwrap().into(), + v8::Integer::new(s, message.get_end_position() as i32).into(), + ); + + json_obj.set( + context, + v8::String::new(s, "errorLevel").unwrap().into(), + v8::Integer::new(s, message.error_level() as i32).into(), + ); + + json_obj.set( + context, + v8::String::new(s, "startColumn").unwrap().into(), + v8::Integer::new(s, message.get_start_column() as i32).into(), + ); + + json_obj.set( + context, + v8::String::new(s, "endColumn").unwrap().into(), + v8::Integer::new(s, message.get_end_column() as i32).into(), + ); + + let is_shared_cross_origin = + v8::Boolean::new(s, message.is_shared_cross_origin()); + + json_obj.set( + context, + v8::String::new(s, "isSharedCrossOrigin").unwrap().into(), + is_shared_cross_origin.into(), + ); + + let is_opaque = v8::Boolean::new(s, message.is_opaque()); + + json_obj.set( + context, + v8::String::new(s, "isOpaque").unwrap().into(), + is_opaque.into(), + ); + + let frames = if let Some(stack_trace) = message.get_stack_trace(s) { + let count = stack_trace.get_frame_count() as i32; + let frames = v8::Array::new(s, count); + + for i in 0..count { + let frame = stack_trace + .get_frame(s, i as usize) + .expect("No frame found"); + let frame_obj = v8::Object::new(s); + frames.set(context, v8::Integer::new(s, i).into(), frame_obj.into()); + frame_obj.set( + context, + v8::String::new(s, "line").unwrap().into(), + v8::Integer::new(s, frame.get_line_number() as i32).into(), + ); + frame_obj.set( + context, + v8::String::new(s, "column").unwrap().into(), + v8::Integer::new(s, frame.get_column() as i32).into(), + ); + + if let Some(function_name) = frame.get_function_name(s) { + frame_obj.set( + context, + v8::String::new(s, "functionName").unwrap().into(), + function_name.into(), + ); + } + + let script_name = match frame.get_script_name_or_source_url(s) { + Some(name) => name, + None => v8::String::new(s, "<unknown>").unwrap(), + }; + frame_obj.set( + context, + v8::String::new(s, "scriptName").unwrap().into(), + script_name.into(), + ); + + frame_obj.set( + context, + v8::String::new(s, "isEval").unwrap().into(), + v8::Boolean::new(s, frame.is_eval()).into(), + ); + + frame_obj.set( + context, + v8::String::new(s, "isConstructor").unwrap().into(), + v8::Boolean::new(s, frame.is_constructor()).into(), + ); + + frame_obj.set( + context, + v8::String::new(s, "isWasm").unwrap().into(), + v8::Boolean::new(s, frame.is_wasm()).into(), + ); + } + + frames + } else { + // No stack trace. We only have one stack frame of info.. + let frames = v8::Array::new(s, 1); + let frame_obj = v8::Object::new(s); + frames.set(context, v8::Integer::new(s, 0).into(), frame_obj.into()); + + frame_obj.set( + context, + v8::String::new(s, "scriptResourceName").unwrap().into(), + script_resource_name, + ); + frame_obj.set( + context, + v8::String::new(s, "line").unwrap().into(), + v8::Integer::new(s, line_number as i32).into(), + ); + frame_obj.set( + context, + v8::String::new(s, "column").unwrap().into(), + v8::Integer::new(s, message.get_start_column() as i32).into(), + ); + + frames + }; + + json_obj.set( + context, + v8::String::new(s, "frames").unwrap().into(), + frames.into(), + ); + + json_obj } + #[allow(dead_code)] + pub fn run_microtasks(&mut self) { + let isolate = self.isolate_.as_mut().unwrap(); + let mut locker = v8::Locker::new(isolate); + isolate.enter(); + isolate.run_microtasks(); + isolate.exit(); + } + // End of methods from libdeno + pub fn set_error_handler(&mut self, handler: Box<IsolateErrorHandleFn>) { self.error_handler = Some(handler); } @@ -286,7 +761,7 @@ impl Isolate { /// Get a thread safe handle on the isolate. pub fn shared_isolate_handle(&mut self) -> IsolateHandle { IsolateHandle { - shared_libdeno_isolate: self.shared_libdeno_isolate.clone(), + shared_isolate: self.shared_isolate_handle.clone(), } } @@ -304,21 +779,19 @@ impl Isolate { } } - fn dyn_import( - user_data: *mut c_void, + pub fn dyn_import_cb( + &mut self, specifier: &str, referrer: &str, id: deno_dyn_import_id, ) { - assert_ne!(user_data, std::ptr::null_mut()); - let isolate = unsafe { Isolate::from_raw_ptr(user_data) }; debug!("dyn_import specifier {} referrer {} ", specifier, referrer); - if let Some(ref f) = isolate.dyn_import { + if let Some(ref f) = self.dyn_import { let inner = f(id, specifier, referrer); let stream = DynImport { inner, id }; - isolate.waker.wake(); - isolate + self.waker.wake(); + self .pending_dyn_imports .push(stream.into_stream().into_future()); } else { @@ -326,33 +799,31 @@ impl Isolate { } } - fn pre_dispatch( - user_data: *mut c_void, + pub fn pre_dispatch( + &mut self, op_id: OpId, control_buf: deno_buf, zero_copy_buf: Option<PinnedBuf>, ) { - let isolate = unsafe { Isolate::from_raw_ptr(user_data) }; - let maybe_op = - isolate + self .op_registry .call(op_id, control_buf.as_ref(), zero_copy_buf); let op = match maybe_op { Some(op) => op, None => { - return isolate.throw_exception(&format!("Unknown op id: {}", op_id)) + return self.throw_exception(&format!("Unknown op id: {}", op_id)) } }; - debug_assert_eq!(isolate.shared.size(), 0); + debug_assert_eq!(self.shared.size(), 0); match op { Op::Sync(buf) => { // For sync messages, we always return the response via Deno.core.send's // return value. Sync messages ignore the op_id. let op_id = 0; - isolate + self .respond(Some((op_id, &buf))) // Because this is a sync op, deno_respond() does not actually call // into JavaScript. We should not get an error here. @@ -360,21 +831,37 @@ impl Isolate { } Op::Async(fut) => { let fut2 = fut.map_ok(move |buf| (op_id, buf)); - isolate.pending_ops.push(fut2.boxed()); - isolate.have_unpolled_ops = true; + self.pending_ops.push(fut2.boxed()); + self.have_unpolled_ops = true; } } } - #[inline] - unsafe fn from_raw_ptr<'a>(ptr: *const c_void) -> &'a mut Self { - let ptr = ptr as *mut _; - &mut *ptr - } - - #[inline] - fn as_raw_ptr(&self) -> *const c_void { - self as *const _ as *const c_void + fn libdeno_execute<'a>( + &mut self, + s: &mut impl v8::ToLocal<'a>, + context: v8::Local<'a, v8::Context>, + js_filename: &str, + js_source: &str, + ) -> bool { + let mut hs = v8::HandleScope::new(s); + let s = hs.enter(); + let source = v8::String::new(s, js_source).unwrap(); + let name = v8::String::new(s, js_filename).unwrap(); + let mut try_catch = v8::TryCatch::new(s); + let tc = try_catch.enter(); + let origin = libdeno::script_origin(s, name); + let mut script = + v8::Script::compile(s, context, source, Some(&origin)).unwrap(); + let result = script.run(s, context); + if result.is_none() { + assert!(tc.has_caught()); + let exception = tc.exception().unwrap(); + self.handle_exception(s, context, exception); + false + } else { + true + } } /// Executes traditional JavaScript code (traditional = not ES modules) @@ -388,21 +875,27 @@ impl Isolate { js_source: &str, ) -> Result<(), ErrBox> { self.shared_init(); - let core_i = self as *mut _ as *mut c_void; - let libdeno_i = &mut self.libdeno_isolate; - unsafe { libdeno::deno_execute(libdeno_i, core_i, js_filename, js_source) }; + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + assert!(!self.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + self.libdeno_execute(scope, context, js_filename, js_source); + context.exit(); self.check_last_exception() } fn check_last_exception(&mut self) -> Result<(), ErrBox> { - let maybe_err = self.libdeno_isolate.last_exception_.clone(); + let maybe_err = self.last_exception_.clone(); match maybe_err { None => Ok(()), Some(json_str) => { let js_error_create = &*self.js_error_create; if self.error_handler.is_some() { // We need to clear last exception to avoid double handling. - self.libdeno_isolate.last_exception_ = None; + self.last_exception_ = None; let v8_exception = V8Exception::from_json(&json_str).unwrap(); let js_error = js_error_create(v8_exception); let handler = self.error_handler.as_mut().unwrap(); @@ -417,15 +910,102 @@ impl Isolate { } fn check_promise_errors(&mut self) { - unsafe { - libdeno::deno_check_promise_errors(&mut self.libdeno_isolate); + let isolate = self.isolate_.as_ref().unwrap(); + + if self.pending_promise_map_.is_empty() { + return; + } + + let mut locker = v8::Locker::new(isolate); + assert!(!self.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + + let pending_promises: Vec<(i32, v8::Global<v8::Value>)> = + self.pending_promise_map_.drain().collect(); + for (_promise_id, mut handle) in pending_promises { + let error = handle.get(scope).expect("Empty error handle"); + self.handle_exception(scope, context, error); + handle.reset(scope); } + + context.exit(); } - fn throw_exception(&mut self, exception_text: &str) { - unsafe { - libdeno::deno_throw_exception(&mut self.libdeno_isolate, exception_text) + fn throw_exception(&mut self, text: &str) { + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let msg = v8::String::new(scope, text).unwrap(); + isolate.throw_exception(msg.into()); + } + + fn libdeno_respond(&mut self, op_id: OpId, buf: deno_buf) { + if !self.current_args_.is_null() { + // Synchronous response. + // Note op_id is not passed back in the case of synchronous response. + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + assert!(!self.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + + if !buf.data_ptr.is_null() && buf.data_len > 0 { + let ab = unsafe { libdeno::deno_import_buf(scope, buf) }; + let info: &v8::FunctionCallbackInfo = unsafe { &*self.current_args_ }; + let rv = &mut info.get_return_value(); + rv.set(ab.into()) + } + + self.current_args_ = std::ptr::null(); + return; + } + + let isolate = self.isolate_.as_ref().unwrap(); + // println!("deno_execute -> Isolate ptr {:?}", isolate); + let mut locker = v8::Locker::new(isolate); + assert!(!self.context_.is_empty()); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + + let mut try_catch = v8::TryCatch::new(scope); + let tc = try_catch.enter(); + + let recv_ = self.recv_.get(scope); + + if recv_.is_none() { + let msg = "Deno.core.recv has not been called.".to_string(); + self.last_exception_ = Some(msg); + return; } + + let mut argc = 0; + let mut args: Vec<v8::Local<v8::Value>> = vec![]; + + if !buf.data_ptr.is_null() { + argc = 2; + let op_id = v8::Integer::new(scope, op_id as i32); + args.push(op_id.into()); + let buf = unsafe { libdeno::deno_import_buf(scope, buf) }; + args.push(buf.into()); + } + + let global = context.global(scope); + let maybe_value = + recv_ + .unwrap() + .call(scope, context, global.into(), argc, args); + + if tc.has_caught() { + assert!(maybe_value.is_none()); + self.handle_exception(scope, context, tc.exception().unwrap()); + } + context.exit(); } fn respond( @@ -436,9 +1016,7 @@ impl Isolate { None => (0, deno_buf::empty()), Some((op_id, r)) => (op_id, deno_buf::from(r)), }; - let core_i = self.as_raw_ptr(); - let libdeno_i = &mut self.libdeno_isolate; - unsafe { libdeno::deno_respond(libdeno_i, core_i, op_id, buf) } + self.libdeno_respond(op_id, buf); self.check_last_exception() } @@ -449,16 +1027,16 @@ impl Isolate { name: &str, source: &str, ) -> Result<deno_mod, ErrBox> { - let id = self.libdeno_isolate.register_module(main, name, source); + let id = self.register_module(main, name, source); self.check_last_exception().map(|_| id) } pub fn mod_get_imports(&self, id: deno_mod) -> Vec<String> { - let info = self.libdeno_isolate.get_module_info(id).unwrap(); + let info = self.get_module_info(id).unwrap(); let len = info.import_specifiers.len(); let mut out = Vec::new(); for i in 0..len { - let info = self.libdeno_isolate.get_module_info(id).unwrap(); + let info = self.get_module_info(id).unwrap(); let specifier = info.import_specifiers.get(i).unwrap().to_string(); out.push(specifier); } @@ -472,7 +1050,25 @@ impl Isolate { /// the V8 exception. By default this type is CoreJSError, however it may be a /// different type if Isolate::set_js_error_create() has been used. pub fn snapshot(&mut self) -> Result<Snapshot1, ErrBox> { - let snapshot = libdeno::deno_snapshot_new(&mut self.libdeno_isolate); + assert!(self.snapshot_creator_.is_some()); + + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + + for (_key, module) in self.mods_.iter_mut() { + module.handle.reset(scope); + } + self.mods_.clear(); + self.mods_by_name_.clear(); + self.context_.reset(scope); + + let snapshot_creator = self.snapshot_creator_.as_mut().unwrap(); + let snapshot = snapshot_creator + .create_blob(v8::FunctionCodeHandling::Keep) + .unwrap(); + self.has_snapshotted_ = true; match self.check_last_exception() { Ok(..) => Ok(snapshot), Err(err) => Err(err), @@ -490,18 +1086,55 @@ impl Isolate { Err(None) => (0, None), Err(Some(err_str)) => (0, Some(err_str)), }; - let core_i = self.as_raw_ptr(); - let libdeno_i = &mut self.libdeno_isolate; - - unsafe { - libdeno::deno_dyn_import_done( - libdeno_i, - core_i, - id, - mod_id, - maybe_err_str, - ) - }; + + assert!( + (mod_id == 0 && maybe_err_str.is_some()) + || (mod_id != 0 && maybe_err_str.is_none()) + || (mod_id == 0 && !self.last_exception_handle_.is_empty()) + ); + + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + assert!(!self.context_.is_empty()); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + + // TODO(ry) error on bad import_id. + let mut resolver_handle = self.dyn_import_map_.remove(&id).unwrap(); + // Resolve. + let mut resolver = resolver_handle.get(scope).unwrap(); + resolver_handle.reset(scope); + + let maybe_info = self.get_module_info(mod_id); + + if let Some(info) = maybe_info { + // Resolution success + let mut module = info.handle.get(scope).unwrap(); + assert_eq!(module.get_status(), v8::ModuleStatus::Evaluated); + let module_namespace = module.get_module_namespace(); + resolver.resolve(context, module_namespace).unwrap(); + } else { + // Resolution error. + if let Some(error_str) = maybe_err_str { + let msg = v8::String::new(scope, &error_str).unwrap(); + let isolate = context.get_isolate(); + isolate.enter(); + let e = v8::type_error(scope, msg); + isolate.exit(); + resolver.reject(context, e).unwrap(); + } else { + let e = self.last_exception_handle_.get(scope).unwrap(); + self.last_exception_handle_.reset(scope); + self.last_exception_.take(); + resolver.reject(context, e).unwrap(); + } + } + + isolate.run_microtasks(); + + context.exit(); self.check_last_exception() } @@ -571,6 +1204,46 @@ impl<'a> ResolveContext<'a> { } impl Isolate { + fn libdeno_mod_instantiate( + &mut self, + mut ctx: ResolveContext<'_>, + id: deno_mod, + ) { + self.resolve_context_ = ctx.as_raw_ptr(); + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + assert!(!self.context_.is_empty()); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + let mut try_catch = v8::TryCatch::new(scope); + let tc = try_catch.enter(); + + let maybe_info = self.get_module_info(id); + + if maybe_info.is_none() { + return; + } + + let module_handle = &maybe_info.unwrap().handle; + let mut module = module_handle.get(scope).unwrap(); + + if module.get_status() == v8::ModuleStatus::Errored { + return; + } + + let maybe_ok = + module.instantiate_module(context, bindings::module_resolve_callback); + assert!(maybe_ok.is_some() || tc.has_caught()); + + if tc.has_caught() { + self.handle_exception(scope, context, tc.exception().unwrap()); + } + + context.exit(); + self.resolve_context_ = std::ptr::null_mut(); + } /// Instanciates a ES module /// /// ErrBox can be downcast to a type that exposes additional information about @@ -581,15 +1254,8 @@ impl Isolate { id: deno_mod, resolve_fn: &mut ResolveFn, ) -> Result<(), ErrBox> { - let mut ctx = ResolveContext { resolve_fn }; - unsafe { - libdeno::deno_mod_instantiate( - &mut self.libdeno_isolate, - ctx.as_raw_ptr(), - id, - Self::resolve_cb, - ) - }; + let ctx = ResolveContext { resolve_fn }; + self.libdeno_mod_instantiate(ctx, id); self.check_last_exception() } @@ -614,9 +1280,45 @@ impl Isolate { /// different type if Isolate::set_js_error_create() has been used. pub fn mod_evaluate(&mut self, id: deno_mod) -> Result<(), ErrBox> { self.shared_init(); - let core_i = self.as_raw_ptr(); - let libdeno_i = &mut self.libdeno_isolate; - unsafe { libdeno::deno_mod_evaluate(libdeno_i, core_i, id) }; + let isolate = self.isolate_.as_ref().unwrap(); + let mut locker = v8::Locker::new(isolate); + let mut hs = v8::HandleScope::new(&mut locker); + let scope = hs.enter(); + assert!(!self.context_.is_empty()); + let mut context = self.context_.get(scope).unwrap(); + context.enter(); + + let info = self.get_module_info(id).expect("ModuleInfo not found"); + let mut module = info.handle.get(scope).expect("Empty module handle"); + let mut status = module.get_status(); + + if status == v8::ModuleStatus::Instantiated { + let ok = module.evaluate(scope, context).is_some(); + // Update status after evaluating. + status = module.get_status(); + if ok { + assert!( + status == v8::ModuleStatus::Evaluated + || status == v8::ModuleStatus::Errored + ); + } else { + assert!(status == v8::ModuleStatus::Errored); + } + } + + match status { + v8::ModuleStatus::Evaluated => { + self.last_exception_handle_.reset(scope); + self.last_exception_.take(); + } + v8::ModuleStatus::Errored => { + self.handle_exception(scope, context, module.get_exception()); + } + other => panic!("Unexpected module status {:?}", other), + }; + + context.exit(); + self.check_last_exception() } } @@ -689,7 +1391,7 @@ impl Future for Isolate { /// IsolateHandle is a thread safe handle on an Isolate. It exposed thread safe V8 functions. #[derive(Clone)] pub struct IsolateHandle { - shared_libdeno_isolate: Arc<Mutex<Option<*mut libdeno::DenoIsolate>>>, + shared_isolate: Arc<Mutex<Option<*mut v8::Isolate>>>, } unsafe impl Send for IsolateHandle {} @@ -699,8 +1401,9 @@ impl IsolateHandle { /// After terminating execution it is probably not wise to continue using /// the isolate. pub fn terminate_execution(&self) { - if let Some(isolate) = *self.shared_libdeno_isolate.lock().unwrap() { - unsafe { libdeno::deno_terminate_execution(isolate) } + if let Some(isolate) = *self.shared_isolate.lock().unwrap() { + let isolate = unsafe { &mut *isolate }; + isolate.terminate_execution(); } } } @@ -752,7 +1455,7 @@ pub mod tests { OverflowResAsync, } - pub fn setup(mode: Mode) -> (Isolate, Arc<AtomicUsize>) { + pub fn setup(mode: Mode) -> (Box<Isolate>, Arc<AtomicUsize>) { let dispatch_count = Arc::new(AtomicUsize::new(0)); let dispatch_count_ = dispatch_count.clone(); @@ -851,7 +1554,6 @@ pub mod tests { let imports = isolate.mod_get_imports(mod_a); assert_eq!(imports, vec!["b.js".to_string()]); - let mod_b = isolate .mod_new(false, "b.js", "export function b() { return 'b' }") .unwrap(); diff --git a/core/lib.rs b/core/lib.rs index b6e94c7d5..20f3dba86 100644 --- a/core/lib.rs +++ b/core/lib.rs @@ -10,6 +10,7 @@ extern crate rusty_v8; extern crate lazy_static; mod any_error; +mod bindings; mod flags; mod isolate; mod js_errors; diff --git a/core/libdeno.rs b/core/libdeno.rs index eea8cfd41..92d77a38c 100644 --- a/core/libdeno.rs +++ b/core/libdeno.rs @@ -1,32 +1,23 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -#![allow(unused)] + #![allow(mutable_transmutes)] #![allow(clippy::transmute_ptr_to_ptr)] +use crate::bindings; + use rusty_v8 as v8; -use v8::InIsolate; use libc::c_char; -use libc::c_int; use libc::c_void; -use libc::size_t; -use std::collections::HashMap; use std::convert::From; -use std::convert::TryFrom; -use std::convert::TryInto; -use std::ffi::CString; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use std::option::Option; use std::ptr::null; use std::ptr::NonNull; use std::slice; pub type OpId = u32; -#[allow(non_camel_case_types)] -pub type isolate = DenoIsolate; - pub struct ModuleInfo { pub main: bool, pub name: String, @@ -34,455 +25,7 @@ pub struct ModuleInfo { pub import_specifiers: Vec<String>, } -pub struct DenoIsolate { - isolate_: Option<v8::OwnedIsolate>, - pub last_exception_: Option<String>, - last_exception_handle_: v8::Global<v8::Value>, - context_: v8::Global<v8::Context>, - mods_: HashMap<deno_mod, ModuleInfo>, - mods_by_name_: HashMap<String, deno_mod>, - locker_: Option<v8::Locker>, - shared_: deno_buf, - shared_ab_: v8::Global<v8::SharedArrayBuffer>, - resolve_cb_: Option<deno_resolve_cb>, - recv_: v8::Global<v8::Function>, - current_args_: *const v8::FunctionCallbackInfo, - recv_cb_: deno_recv_cb, - snapshot_creator_: Option<v8::SnapshotCreator>, - has_snapshotted_: bool, - snapshot_: Option<SnapshotConfig>, - next_dyn_import_id_: deno_dyn_import_id, - dyn_import_cb_: deno_dyn_import_cb, - dyn_import_map_: HashMap<deno_dyn_import_id, v8::Global<v8::PromiseResolver>>, - pending_promise_map_: HashMap<i32, v8::Global<v8::Value>>, - // Used in deno_mod_instantiate - resolve_context_: *mut c_void, - // Used in deno_mod_evaluate - core_isolate_: *mut c_void, - /* - void* global_import_buf_ptr_; - v8::Persistent<v8::ArrayBuffer> global_import_buf_; - */ -} - -impl Drop for DenoIsolate { - fn drop(&mut self) { - // TODO Too much boiler plate. - // <Boilerplate> - let mut isolate = self.isolate_.take().unwrap(); - { - let mut locker = v8::Locker::new(&isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - // </Boilerplate> - self.context_.reset(scope); - self.shared_ab_.reset(scope); - self.last_exception_handle_.reset(scope); - self.recv_.reset(scope); - for (key, module) in self.mods_.iter_mut() { - module.handle.reset(scope); - } - for (key, handle) in self.dyn_import_map_.iter_mut() { - handle.reset(scope); - } - for (key, handle) in self.pending_promise_map_.iter_mut() { - handle.reset(scope); - } - } - if let Some(locker_) = self.locker_.take() { - drop(locker_); - } - if let Some(creator) = self.snapshot_creator_.take() { - // TODO(ry) V8 has a strange assert which prevents a SnapshotCreator from - // being deallocated if it hasn't created a snapshot yet. - // https://github.com/v8/v8/blob/73212783fbd534fac76cc4b66aac899c13f71fc8/src/api.cc#L603 - // If that assert is removed, this if guard could be removed. - // WARNING: There may be false positive LSAN errors here. - std::mem::forget(isolate); - if self.has_snapshotted_ { - drop(creator); - } - } else { - drop(isolate); - } - } -} - -impl DenoIsolate { - pub fn new(config: deno_config) -> Self { - Self { - isolate_: None, - last_exception_: None, - last_exception_handle_: v8::Global::<v8::Value>::new(), - context_: v8::Global::<v8::Context>::new(), - mods_: HashMap::new(), - mods_by_name_: HashMap::new(), - pending_promise_map_: HashMap::new(), - locker_: None, - shared_: config.shared, - shared_ab_: v8::Global::<v8::SharedArrayBuffer>::new(), - resolve_cb_: None, - recv_: v8::Global::<v8::Function>::new(), - current_args_: std::ptr::null(), - recv_cb_: config.recv_cb, - snapshot_creator_: None, - snapshot_: config.load_snapshot, - has_snapshotted_: false, - next_dyn_import_id_: 0, - dyn_import_cb_: config.dyn_import_cb, - dyn_import_map_: HashMap::new(), - resolve_context_: std::ptr::null_mut(), - core_isolate_: std::ptr::null_mut(), - } - } - - pub fn add_isolate(&mut self, mut isolate: v8::OwnedIsolate) { - isolate.set_capture_stack_trace_for_uncaught_exceptions(true, 10); - isolate.set_promise_reject_callback(promise_reject_callback); - isolate.add_message_listener(message_callback); - isolate.set_host_initialize_import_meta_object_callback( - host_initialize_import_meta_object_callback, - ); - isolate.set_host_import_module_dynamically_callback( - host_import_module_dynamically_callback, - ); - let self_ptr: *mut Self = self; - unsafe { isolate.set_data(0, self_ptr as *mut c_void) }; - self.isolate_ = Some(isolate); - } - - pub fn register_module( - &mut self, - main: bool, - name: &str, - source: &str, - ) -> deno_mod { - let isolate = self.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(&isolate); - - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = v8::Context::new(scope); - context.enter(); - - let name_str = v8::String::new(scope, name).unwrap(); - let source_str = v8::String::new(scope, source).unwrap(); - - let origin = module_origin(scope, name_str); - let source = v8::script_compiler::Source::new(source_str, &origin); - - let mut try_catch = v8::TryCatch::new(scope); - let tc = try_catch.enter(); - - let mut maybe_module = - v8::script_compiler::compile_module(&isolate, source); - - if tc.has_caught() { - assert!(maybe_module.is_none()); - self.handle_exception(scope, context, tc.exception().unwrap()); - context.exit(); - return 0; - } - let module = maybe_module.unwrap(); - let id = module.get_identity_hash(); - - let mut import_specifiers: Vec<String> = vec![]; - for i in 0..module.get_module_requests_length() { - let specifier = module.get_module_request(i); - import_specifiers.push(specifier.to_rust_string_lossy(scope)); - } - - let mut handle = v8::Global::<v8::Module>::new(); - handle.set(scope, module); - self.mods_.insert( - id, - ModuleInfo { - main, - name: name.to_string(), - import_specifiers, - handle, - }, - ); - self.mods_by_name_.insert(name.to_string(), id); - context.exit(); - id - } - - pub fn get_module_info(&self, id: deno_mod) -> Option<&ModuleInfo> { - if id == 0 { - return None; - } - self.mods_.get(&id) - } - - fn execute<'a>( - &mut self, - s: &mut impl v8::ToLocal<'a>, - mut context: v8::Local<'a, v8::Context>, - js_filename: &str, - js_source: &str, - ) -> bool { - let mut hs = v8::HandleScope::new(s); - let s = hs.enter(); - let source = v8::String::new(s, js_source).unwrap(); - let name = v8::String::new(s, js_filename).unwrap(); - let mut try_catch = v8::TryCatch::new(s); - let tc = try_catch.enter(); - let origin = script_origin(s, name); - let mut script = - v8::Script::compile(s, context, source, Some(&origin)).unwrap(); - let result = script.run(s, context); - if result.is_none() { - assert!(tc.has_caught()); - let exception = tc.exception().unwrap(); - self.handle_exception(s, context, exception); - false - } else { - true - } - } - - fn handle_exception<'a>( - &mut self, - s: &mut impl v8::ToLocal<'a>, - mut context: v8::Local<'a, v8::Context>, - exception: v8::Local<'a, v8::Value>, - ) { - let isolate = context.get_isolate(); - // TerminateExecution was called - if isolate.is_execution_terminating() { - // cancel exception termination so that the exception can be created - isolate.cancel_terminate_execution(); - - // maybe make a new exception object - let exception = if (exception.is_null_or_undefined()) { - let exception_str = v8::String::new(s, "execution terminated").unwrap(); - isolate.enter(); - let e = v8::error(s, exception_str); - isolate.exit(); - e - } else { - exception - }; - - // handle the exception as if it is a regular exception - self.handle_exception(s, context, exception); - - // re-enable exception termination - context.get_isolate().terminate_execution(); - return; - } - - let json_str = self.encode_exception_as_json(s, context, exception); - self.last_exception_ = Some(json_str); - self.last_exception_handle_.set(s, exception); - } - - fn encode_exception_as_json<'a>( - &mut self, - s: &mut impl v8::ToLocal<'a>, - mut context: v8::Local<'a, v8::Context>, - exception: v8::Local<'a, v8::Value>, - ) -> String { - let message = v8::create_message(s, exception); - self.encode_message_as_json(s, context, message) - } - - fn encode_message_as_json<'a>( - &mut self, - s: &mut impl v8::ToLocal<'a>, - mut context: v8::Local<v8::Context>, - message: v8::Local<v8::Message>, - ) -> String { - let json_obj = self.encode_message_as_object(s, context, message); - let json_string = v8::json::stringify(context, json_obj.into()).unwrap(); - json_string.to_rust_string_lossy(s) - } - - fn encode_message_as_object<'a>( - &mut self, - s: &mut impl v8::ToLocal<'a>, - mut context: v8::Local<v8::Context>, - message: v8::Local<v8::Message>, - ) -> v8::Local<'a, v8::Object> { - let json_obj = v8::Object::new(s); - - let exception_str = message.get(s); - json_obj.set( - context, - v8::String::new(s, "message").unwrap().into(), - exception_str.into(), - ); - - let script_resource_name = message - .get_script_resource_name(s) - .expect("Missing ScriptResourceName"); - json_obj.set( - context, - v8::String::new(s, "scriptResourceName").unwrap().into(), - script_resource_name, - ); - - let source_line = message - .get_source_line(s, context) - .expect("Missing SourceLine"); - json_obj.set( - context, - v8::String::new(s, "sourceLine").unwrap().into(), - source_line.into(), - ); - - let line_number = message - .get_line_number(context) - .expect("Missing LineNumber"); - json_obj.set( - context, - v8::String::new(s, "lineNumber").unwrap().into(), - v8::Integer::new(s, line_number as i32).into(), - ); - - json_obj.set( - context, - v8::String::new(s, "startPosition").unwrap().into(), - v8::Integer::new(s, message.get_start_position() as i32).into(), - ); - - json_obj.set( - context, - v8::String::new(s, "endPosition").unwrap().into(), - v8::Integer::new(s, message.get_end_position() as i32).into(), - ); - - json_obj.set( - context, - v8::String::new(s, "errorLevel").unwrap().into(), - v8::Integer::new(s, message.error_level() as i32).into(), - ); - - json_obj.set( - context, - v8::String::new(s, "startColumn").unwrap().into(), - v8::Integer::new(s, message.get_start_column() as i32).into(), - ); - - json_obj.set( - context, - v8::String::new(s, "endColumn").unwrap().into(), - v8::Integer::new(s, message.get_end_column() as i32).into(), - ); - - let is_shared_cross_origin = - v8::Boolean::new(s, message.is_shared_cross_origin()); - - json_obj.set( - context, - v8::String::new(s, "isSharedCrossOrigin").unwrap().into(), - is_shared_cross_origin.into(), - ); - - let is_opaque = v8::Boolean::new(s, message.is_opaque()); - - json_obj.set( - context, - v8::String::new(s, "isOpaque").unwrap().into(), - is_opaque.into(), - ); - - let frames = if let Some(stack_trace) = message.get_stack_trace(s) { - let count = stack_trace.get_frame_count() as i32; - let frames = v8::Array::new(s, count); - - for i in 0..count { - let frame = stack_trace - .get_frame(s, i as usize) - .expect("No frame found"); - let frame_obj = v8::Object::new(s); - frames.set(context, v8::Integer::new(s, i).into(), frame_obj.into()); - frame_obj.set( - context, - v8::String::new(s, "line").unwrap().into(), - v8::Integer::new(s, frame.get_line_number() as i32).into(), - ); - frame_obj.set( - context, - v8::String::new(s, "column").unwrap().into(), - v8::Integer::new(s, frame.get_column() as i32).into(), - ); - - if let Some(function_name) = frame.get_function_name(s) { - frame_obj.set( - context, - v8::String::new(s, "functionName").unwrap().into(), - function_name.into(), - ); - } - - let script_name = match frame.get_script_name_or_source_url(s) { - Some(name) => name, - None => v8::String::new(s, "<unknown>").unwrap(), - }; - frame_obj.set( - context, - v8::String::new(s, "scriptName").unwrap().into(), - script_name.into(), - ); - - frame_obj.set( - context, - v8::String::new(s, "isEval").unwrap().into(), - v8::Boolean::new(s, frame.is_eval()).into(), - ); - - frame_obj.set( - context, - v8::String::new(s, "isConstructor").unwrap().into(), - v8::Boolean::new(s, frame.is_constructor()).into(), - ); - - frame_obj.set( - context, - v8::String::new(s, "isWasm").unwrap().into(), - v8::Boolean::new(s, frame.is_wasm()).into(), - ); - } - - frames - } else { - // No stack trace. We only have one stack frame of info.. - let frames = v8::Array::new(s, 1); - let frame_obj = v8::Object::new(s); - frames.set(context, v8::Integer::new(s, 0).into(), frame_obj.into()); - - frame_obj.set( - context, - v8::String::new(s, "scriptResourceName").unwrap().into(), - script_resource_name, - ); - frame_obj.set( - context, - v8::String::new(s, "line").unwrap().into(), - v8::Integer::new(s, line_number as i32).into(), - ); - frame_obj.set( - context, - v8::String::new(s, "column").unwrap().into(), - v8::Integer::new(s, message.get_start_column() as i32).into(), - ); - - frames - }; - - json_obj.set( - context, - v8::String::new(s, "frames").unwrap().into(), - frames.into(), - ); - - json_obj - } -} - -fn script_origin<'a>( +pub fn script_origin<'a>( s: &mut impl v8::ToLocal<'a>, resource_name: v8::Local<'a, v8::String>, ) -> v8::ScriptOrigin<'a> { @@ -507,7 +50,7 @@ fn script_origin<'a>( ) } -fn module_origin<'a>( +pub fn module_origin<'a>( s: &mut impl v8::ToLocal<'a>, resource_name: v8::Local<'a, v8::String>, ) -> v8::ScriptOrigin<'a> { @@ -532,159 +75,11 @@ fn module_origin<'a>( ) } -extern "C" fn host_import_module_dynamically_callback( - context: v8::Local<v8::Context>, - referrer: v8::Local<v8::ScriptOrModule>, - specifier: v8::Local<v8::String>, -) -> *mut v8::Promise { - let mut cbs = v8::CallbackScope::new(context); - let mut hs = v8::EscapableHandleScope::new(cbs.enter()); - let scope = hs.enter(); - let mut isolate = scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - - // NOTE(bartlomieju): will crash for non-UTF-8 specifier - let specifier_str = specifier - .to_string(scope) - .unwrap() - .to_rust_string_lossy(scope); - let referrer_name = referrer.get_resource_name(); - let referrer_name_str = referrer_name - .to_string(scope) - .unwrap() - .to_rust_string_lossy(scope); - - // TODO(ry) I'm not sure what HostDefinedOptions is for or if we're ever going - // to use it. For now we check that it is not used. This check may need to be - // changed in the future. - let host_defined_options = referrer.get_host_defined_options(); - assert_eq!(host_defined_options.length(), 0); - - let mut resolver = v8::PromiseResolver::new(scope, context).unwrap(); - let promise = resolver.get_promise(scope); - - let mut resolver_handle = v8::Global::new(); - resolver_handle.set(scope, resolver); - - let import_id = deno_isolate.next_dyn_import_id_; - deno_isolate.next_dyn_import_id_ += 1; - deno_isolate - .dyn_import_map_ - .insert(import_id, resolver_handle); - - let cb = deno_isolate.dyn_import_cb_; - cb( - deno_isolate.core_isolate_, - &specifier_str, - &referrer_name_str, - import_id, - ); - - &mut *scope.escape(promise) -} - -extern "C" fn host_initialize_import_meta_object_callback( - context: v8::Local<v8::Context>, - module: v8::Local<v8::Module>, - meta: v8::Local<v8::Object>, -) { - let mut cbs = v8::CallbackScope::new(context); - let mut hs = v8::HandleScope::new(cbs.enter()); - let scope = hs.enter(); - let mut isolate = scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - - let id = module.get_identity_hash(); - assert_ne!(id, 0); - - let info = deno_isolate.get_module_info(id).expect("Module not found"); - - meta.create_data_property( - context, - v8::String::new(scope, "url").unwrap().into(), - v8::String::new(scope, &info.name).unwrap().into(), - ); - meta.create_data_property( - context, - v8::String::new(scope, "main").unwrap().into(), - v8::Boolean::new(scope, info.main).into(), - ); -} - -extern "C" fn message_callback( - message: v8::Local<v8::Message>, - exception: v8::Local<v8::Value>, -) { - let mut message: v8::Local<v8::Message> = - unsafe { std::mem::transmute(message) }; - let isolate = message.get_isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - assert!(!deno_isolate.context_.is_empty()); - let mut context = deno_isolate.context_.get(scope).unwrap(); - - // TerminateExecution was called - if isolate.is_execution_terminating() { - let u = v8::new_undefined(scope); - deno_isolate.handle_exception(scope, context, u.into()); - return; - } - - let json_str = deno_isolate.encode_message_as_json(scope, context, message); - deno_isolate.last_exception_ = Some(json_str); -} - -extern "C" fn promise_reject_callback(msg: v8::PromiseRejectMessage) { - #[allow(mutable_transmutes)] - let mut msg: v8::PromiseRejectMessage = unsafe { std::mem::transmute(msg) }; - let mut isolate = msg.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - let mut locker = v8::Locker::new(isolate); - assert!(!deno_isolate.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = deno_isolate.context_.get(scope).unwrap(); - context.enter(); - - let promise = msg.get_promise(); - let promise_id = promise.get_identity_hash(); - - match msg.get_event() { - v8::PromiseRejectEvent::PromiseRejectWithNoHandler => { - let error = msg.get_value(); - let mut error_global = v8::Global::<v8::Value>::new(); - error_global.set(scope, error); - deno_isolate - .pending_promise_map_ - .insert(promise_id, error_global); - } - v8::PromiseRejectEvent::PromiseHandlerAddedAfterReject => { - if let Some(mut handle) = - deno_isolate.pending_promise_map_.remove(&promise_id) - { - handle.reset(scope); - } - } - v8::PromiseRejectEvent::PromiseRejectAfterResolved => {} - v8::PromiseRejectEvent::PromiseResolveAfterResolved => { - // Should not warn. See #1272 - } - }; - - context.exit(); -} - /// This type represents a borrowed slice. #[repr(C)] pub struct deno_buf { - data_ptr: *const u8, - data_len: usize, + pub data_ptr: *const u8, + pub data_len: usize, } /// `deno_buf` can not clone, and there is no interior mutability. @@ -750,6 +145,7 @@ impl AsRef<[u8]> for deno_buf { /// but the existence of a PinnedBuf inhibits this until it is dropped. It /// behaves much like an Arc<[u8]>, although a PinnedBuf currently can't be /// cloned. +#[allow(unused)] pub struct PinnedBuf { data_ptr: NonNull<u8>, data_len: usize, @@ -798,6 +194,7 @@ impl AsMut<[u8]> for PinnedBuf { } #[repr(C)] +#[allow(unused)] pub struct deno_snapshot<'a> { pub data_ptr: *const u8, pub data_len: usize, @@ -814,28 +211,6 @@ unsafe impl Send for deno_snapshot<'_> {} /// The type returned from deno_snapshot_new. Needs to be dropped. pub type Snapshot1 = v8::OwnedStartupData; -/// The type created from slice. Used for loading. -pub type Snapshot2<'a> = v8::StartupData<'a>; - -#[allow(non_camel_case_types)] -type deno_recv_cb = unsafe fn( - user_data: *mut c_void, - op_id: OpId, - control_buf: deno_buf, - zero_copy_buf: Option<PinnedBuf>, -); - -/// Called when dynamic import is called in JS: import('foo') -/// Embedder must call deno_dyn_import_done() with the specified id and -/// the module. -#[allow(non_camel_case_types)] -type deno_dyn_import_cb = fn( - user_data: *mut c_void, - specifier: &str, - referrer: &str, - id: deno_dyn_import_id, -); - #[allow(non_camel_case_types)] pub type deno_mod = i32; @@ -843,7 +218,7 @@ pub type deno_mod = i32; pub type deno_dyn_import_id = i32; #[allow(non_camel_case_types)] -type deno_resolve_cb = unsafe extern "C" fn( +pub type deno_resolve_cb = unsafe extern "C" fn( resolve_context: *mut c_void, specifier: *const c_char, referrer: deno_mod, @@ -876,15 +251,6 @@ impl Deref for SnapshotConfig { } } -#[repr(C)] -pub struct deno_config { - pub will_snapshot: c_int, - pub load_snapshot: Option<SnapshotConfig>, - pub shared: deno_buf, - pub recv_cb: deno_recv_cb, - pub dyn_import_cb: deno_dyn_import_cb, -} - pub unsafe fn deno_init() { let platform = v8::platform::new_default_platform(); v8::V8::initialize_platform(platform); @@ -902,401 +268,36 @@ pub unsafe fn deno_init() { } lazy_static! { - static ref EXTERNAL_REFERENCES: v8::ExternalReferences = + pub static ref EXTERNAL_REFERENCES: v8::ExternalReferences = v8::ExternalReferences::new(&[ - v8::ExternalReference { function: print }, - v8::ExternalReference { function: recv }, - v8::ExternalReference { function: send }, v8::ExternalReference { - function: eval_context + function: bindings::print }, v8::ExternalReference { - function: error_to_json + function: bindings::recv }, v8::ExternalReference { - getter: shared_getter + function: bindings::send }, v8::ExternalReference { - message: message_callback + function: bindings::eval_context }, v8::ExternalReference { - function: queue_microtask + function: bindings::error_to_json + }, + v8::ExternalReference { + getter: bindings::shared_getter + }, + v8::ExternalReference { + message: bindings::message_callback + }, + v8::ExternalReference { + function: bindings::queue_microtask }, ]); } -pub unsafe fn deno_new_snapshotter(config: deno_config) -> *mut DenoIsolate { - assert_ne!(config.will_snapshot, 0); - // TODO(ry) Support loading snapshots before snapshotting. - assert!(config.load_snapshot.is_none()); - let mut creator = v8::SnapshotCreator::new(Some(&EXTERNAL_REFERENCES)); - - let mut d = Box::new(DenoIsolate::new(config)); - let isolate = creator.get_owned_isolate(); - - let mut locker = v8::Locker::new(&isolate); - { - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = v8::Context::new(scope); - // context.enter(); - d.context_.set(scope, context); - creator.set_default_context(context); - initialize_context(scope, context); - // context.exit(); - } - d.add_isolate(isolate); - - d.snapshot_creator_ = Some(creator); - - Box::into_raw(d) -} - -extern "C" fn print(info: &v8::FunctionCallbackInfo) { - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - - let arg_len = info.length(); - assert!(arg_len >= 0 && arg_len <= 2); - - let obj = info.get_argument(0); - let is_err_arg = info.get_argument(1); - - let mut hs = v8::HandleScope::new(info); - let scope = hs.enter(); - - let mut is_err = false; - if arg_len == 2 { - let int_val = is_err_arg - .integer_value(scope) - .expect("Unable to convert to integer"); - is_err = int_val != 0; - }; - let mut isolate = scope.isolate(); - let mut try_catch = v8::TryCatch::new(scope); - let tc = try_catch.enter(); - let str_ = match obj.to_string(scope) { - Some(s) => s, - None => v8::String::new(scope, "").unwrap(), - }; - if is_err { - eprint!("{}", str_.to_rust_string_lossy(scope)); - } else { - print!("{}", str_.to_rust_string_lossy(scope)); - } -} - -extern "C" fn recv(info: &v8::FunctionCallbackInfo) { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - assert_eq!(info.length(), 1); - let mut isolate = info.get_isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - let mut locker = v8::Locker::new(&isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - - if !deno_isolate.recv_.is_empty() { - let msg = v8::String::new(scope, "Deno.core.recv already called.").unwrap(); - isolate.throw_exception(msg.into()); - return; - } - - let recv_fn = - v8::Local::<v8::Function>::try_from(info.get_argument(0)).unwrap(); - deno_isolate.recv_.set(scope, recv_fn); -} - -extern "C" fn send(info: &v8::FunctionCallbackInfo) { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - - let mut hs = v8::HandleScope::new(info); - let scope = hs.enter(); - let mut isolate = scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - assert!(!deno_isolate.context_.is_empty()); - - let op_id = v8::Local::<v8::Uint32>::try_from(info.get_argument(0)) - .unwrap() - .value() as u32; - - let control = - v8::Local::<v8::ArrayBufferView>::try_from(info.get_argument(1)) - .map(|view| { - let mut backing_store = view.buffer().unwrap().get_backing_store(); - let backing_store_ptr = backing_store.data() as *mut _ as *mut u8; - let view_ptr = unsafe { backing_store_ptr.add(view.byte_offset()) }; - let view_len = view.byte_length(); - unsafe { deno_buf::from_raw_parts(view_ptr, view_len) } - }) - .unwrap_or_else(|_| deno_buf::empty()); - - let zero_copy: Option<PinnedBuf> = - v8::Local::<v8::ArrayBufferView>::try_from(info.get_argument(2)) - .map(PinnedBuf::new) - .ok(); - - // TODO: what's the point of this again? - // DCHECK_NULL(d->current_args_); - // d->current_args_ = &args; - assert!(deno_isolate.current_args_.is_null()); - deno_isolate.current_args_ = info; - - unsafe { - (deno_isolate.recv_cb_)( - deno_isolate.core_isolate_, - op_id, - control, - zero_copy, - ); - } - - if deno_isolate.current_args_.is_null() { - // This indicates that deno_repond() was called already. - } else { - // Asynchronous. - deno_isolate.current_args_ = null(); - } -} - -extern "C" fn eval_context(info: &v8::FunctionCallbackInfo) { - let rv = &mut info.get_return_value(); - - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - let arg0 = info.get_argument(0); - - let mut hs = v8::HandleScope::new(info); - let scope = hs.enter(); - let mut isolate = scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - assert!(!deno_isolate.context_.is_empty()); - let mut context = deno_isolate.context_.get(scope).unwrap(); - - let source = match v8::Local::<v8::String>::try_from(arg0) { - Ok(s) => s, - Err(_) => { - let msg = v8::String::new(scope, "Invalid argument").unwrap(); - let exception = v8::type_error(scope, msg); - scope.isolate().throw_exception(exception); - return; - } - }; - - let output = v8::Array::new(scope, 2); - /** - * output[0] = result - * output[1] = ErrorInfo | null - * ErrorInfo = { - * thrown: Error | any, - * isNativeError: boolean, - * isCompileError: boolean, - * } - */ - let mut try_catch = v8::TryCatch::new(scope); - let tc = try_catch.enter(); - let name = v8::String::new(scope, "<unknown>").unwrap(); - let origin = script_origin(scope, name); - let maybe_script = v8::Script::compile(scope, context, source, Some(&origin)); - - if maybe_script.is_none() { - assert!(tc.has_caught()); - let exception = tc.exception().unwrap(); - - output.set( - context, - v8::Integer::new(scope, 0).into(), - v8::new_null(scope).into(), - ); - - let errinfo_obj = v8::Object::new(scope); - errinfo_obj.set( - context, - v8::String::new(scope, "isCompileError").unwrap().into(), - v8::Boolean::new(scope, true).into(), - ); - - errinfo_obj.set( - context, - v8::String::new(scope, "isNativeError").unwrap().into(), - v8::Boolean::new(scope, exception.is_native_error()).into(), - ); - - errinfo_obj.set( - context, - v8::String::new(scope, "thrown").unwrap().into(), - exception, - ); - - output.set( - context, - v8::Integer::new(scope, 1).into(), - errinfo_obj.into(), - ); - - rv.set(output.into()); - return; - } - - let result = maybe_script.unwrap().run(scope, context); - - if result.is_none() { - assert!(tc.has_caught()); - let exception = tc.exception().unwrap(); - - output.set( - context, - v8::Integer::new(scope, 0).into(), - v8::new_null(scope).into(), - ); - - let errinfo_obj = v8::Object::new(scope); - errinfo_obj.set( - context, - v8::String::new(scope, "isCompileError").unwrap().into(), - v8::Boolean::new(scope, false).into(), - ); - - let is_native_error = if exception.is_native_error() { - v8::Boolean::new(scope, true) - } else { - v8::Boolean::new(scope, false) - }; - - errinfo_obj.set( - context, - v8::String::new(scope, "isNativeError").unwrap().into(), - is_native_error.into(), - ); - - errinfo_obj.set( - context, - v8::String::new(scope, "thrown").unwrap().into(), - exception, - ); - - output.set( - context, - v8::Integer::new(scope, 1).into(), - errinfo_obj.into(), - ); - - rv.set(output.into()); - return; - } - - output.set(context, v8::Integer::new(scope, 0).into(), result.unwrap()); - output.set( - context, - v8::Integer::new(scope, 1).into(), - v8::new_null(scope).into(), - ); - rv.set(output.into()); -} - -extern "C" fn error_to_json(info: &v8::FunctionCallbackInfo) { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - assert_eq!(info.length(), 1); - // <Boilerplate> - let mut isolate = info.get_isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - let mut locker = v8::Locker::new(&isolate); - assert!(!deno_isolate.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = deno_isolate.context_.get(scope).unwrap(); - // </Boilerplate> - let exception = info.get_argument(0); - let json_string = - deno_isolate.encode_exception_as_json(scope, context, exception); - let s = v8::String::new(scope, &json_string).unwrap(); - let mut rv = info.get_return_value(); - rv.set(s.into()); -} - -extern "C" fn queue_microtask(info: &v8::FunctionCallbackInfo) { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::FunctionCallbackInfo = - unsafe { std::mem::transmute(info) }; - assert_eq!(info.length(), 1); - let arg0 = info.get_argument(0); - let mut isolate = info.get_isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - let mut locker = v8::Locker::new(&isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - - match v8::Local::<v8::Function>::try_from(arg0) { - Ok(f) => isolate.enqueue_microtask(f), - Err(_) => { - let msg = v8::String::new(scope, "Invalid argument").unwrap(); - let exception = v8::type_error(scope, msg); - isolate.throw_exception(exception); - } - }; -} - -extern "C" fn shared_getter( - name: v8::Local<v8::Name>, - info: &v8::PropertyCallbackInfo, -) { - let shared_ab = { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let info: &mut v8::PropertyCallbackInfo = - unsafe { std::mem::transmute(info) }; - - let mut hs = v8::EscapableHandleScope::new(info); - let scope = hs.enter(); - let mut isolate = scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - - if deno_isolate.shared_.data_ptr.is_null() { - return; - } - - // Lazily initialize the persistent external ArrayBuffer. - if deno_isolate.shared_ab_.is_empty() { - #[allow(mutable_transmutes)] - #[allow(clippy::transmute_ptr_to_ptr)] - let data_ptr: *mut u8 = - unsafe { std::mem::transmute(deno_isolate.shared_.data_ptr) }; - let ab = unsafe { - v8::SharedArrayBuffer::new_DEPRECATED( - scope, - data_ptr as *mut c_void, - deno_isolate.shared_.data_len, - ) - }; - deno_isolate.shared_ab_.set(scope, ab); - } - - let shared_ab = deno_isolate.shared_ab_.get(scope).unwrap(); - scope.escape(shared_ab) - }; - - let rv = &mut info.get_return_value(); - rv.set(shared_ab.into()); -} - -fn initialize_context<'a>( +pub fn initialize_context<'a>( scope: &mut impl v8::ToLocal<'a>, mut context: v8::Local<v8::Context>, ) { @@ -1320,32 +321,33 @@ fn initialize_context<'a>( core_val.into(), ); - let mut print_tmpl = v8::FunctionTemplate::new(scope, print); - let mut print_val = print_tmpl.get_function(scope, context).unwrap(); + let mut print_tmpl = v8::FunctionTemplate::new(scope, bindings::print); + let print_val = print_tmpl.get_function(scope, context).unwrap(); core_val.set( context, v8::String::new(scope, "print").unwrap().into(), print_val.into(), ); - let mut recv_tmpl = v8::FunctionTemplate::new(scope, recv); - let mut recv_val = recv_tmpl.get_function(scope, context).unwrap(); + let mut recv_tmpl = v8::FunctionTemplate::new(scope, bindings::recv); + let recv_val = recv_tmpl.get_function(scope, context).unwrap(); core_val.set( context, v8::String::new(scope, "recv").unwrap().into(), recv_val.into(), ); - let mut send_tmpl = v8::FunctionTemplate::new(scope, send); - let mut send_val = send_tmpl.get_function(scope, context).unwrap(); + let mut send_tmpl = v8::FunctionTemplate::new(scope, bindings::send); + let send_val = send_tmpl.get_function(scope, context).unwrap(); core_val.set( context, v8::String::new(scope, "send").unwrap().into(), send_val.into(), ); - let mut eval_context_tmpl = v8::FunctionTemplate::new(scope, eval_context); - let mut eval_context_val = + let mut eval_context_tmpl = + v8::FunctionTemplate::new(scope, bindings::eval_context); + let eval_context_val = eval_context_tmpl.get_function(scope, context).unwrap(); core_val.set( context, @@ -1353,8 +355,9 @@ fn initialize_context<'a>( eval_context_val.into(), ); - let mut error_to_json_tmpl = v8::FunctionTemplate::new(scope, error_to_json); - let mut error_to_json_val = + let mut error_to_json_tmpl = + v8::FunctionTemplate::new(scope, bindings::error_to_json); + let error_to_json_val = error_to_json_tmpl.get_function(scope, context).unwrap(); core_val.set( context, @@ -1365,13 +368,13 @@ fn initialize_context<'a>( core_val.set_accessor( context, v8::String::new(scope, "shared").unwrap().into(), - shared_getter, + bindings::shared_getter, ); // Direct bindings on `window`. let mut queue_microtask_tmpl = - v8::FunctionTemplate::new(scope, queue_microtask); - let mut queue_microtask_val = + v8::FunctionTemplate::new(scope, bindings::queue_microtask); + let queue_microtask_val = queue_microtask_tmpl.get_function(scope, context).unwrap(); global.set( context, @@ -1382,91 +385,6 @@ fn initialize_context<'a>( context.exit(); } -pub unsafe fn deno_new(config: deno_config) -> *mut DenoIsolate { - if config.will_snapshot != 0 { - return deno_new_snapshotter(config); - } - - let load_snapshot_is_null = config.load_snapshot.is_none(); - - let mut d = Box::new(DenoIsolate::new(config)); - let mut params = v8::Isolate::create_params(); - params.set_array_buffer_allocator(v8::new_default_allocator()); - params.set_external_references(&EXTERNAL_REFERENCES); - if let Some(ref mut snapshot) = d.snapshot_ { - params.set_snapshot_blob(snapshot); - } - - let isolate = v8::Isolate::new(params); - d.add_isolate(isolate); - - let mut locker = v8::Locker::new(d.isolate_.as_ref().unwrap()); - { - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = v8::Context::new(scope); - - if load_snapshot_is_null { - // If no snapshot is provided, we initialize the context with empty - // main source code and source maps. - initialize_context(scope, context); - } - d.context_.set(scope, context); - } - Box::into_raw(d) -} - -pub unsafe fn deno_check_promise_errors(i_mut: &mut DenoIsolate) { - /* - if (d->pending_promise_map_.size() > 0) { - auto* isolate = d->isolate_; - v8::Locker locker(isolate); - v8::Isolate::Scope isolate_scope(isolate); - v8::HandleScope handle_scope(isolate); - auto context = d->context_.Get(d->isolate_); - v8::Context::Scope context_scope(context); - - auto it = d->pending_promise_map_.begin(); - while (it != d->pending_promise_map_.end()) { - auto error = it->second.Get(isolate); - deno::HandleException(context, error); - it = d->pending_promise_map_.erase(it); - } - } - */ - let isolate = i_mut.isolate_.as_ref().unwrap(); - - if i_mut.pending_promise_map_.is_empty() { - return; - } - - let mut locker = v8::Locker::new(isolate); - assert!(!i_mut.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = i_mut.context_.get(scope).unwrap(); - context.enter(); - - let pending_promises: Vec<(i32, v8::Global<v8::Value>)> = - i_mut.pending_promise_map_.drain().collect(); - for (promise_id, mut handle) in pending_promises { - let error = handle.get(scope).expect("Empty error handle"); - i_mut.handle_exception(scope, context, error); - handle.reset(scope); - } - - context.exit(); -} - -pub unsafe fn deno_throw_exception(i_mut: &mut DenoIsolate, text: &str) { - let isolate = i_mut.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let msg = v8::String::new(scope, text).unwrap(); - isolate.throw_exception(msg.into()); -} - pub unsafe fn deno_import_buf<'sc>( scope: &mut impl v8::ToLocal<'sc>, buf: deno_buf, @@ -1478,7 +396,7 @@ pub unsafe fn deno_import_buf<'sc>( */ if buf.data_ptr.is_null() { - let mut ab = v8::ArrayBuffer::new(scope, 0); + let ab = v8::ArrayBuffer::new(scope, 0); return v8::Uint8Array::new(ab, 0, 0).expect("Failed to create UintArray8"); } @@ -1514,433 +432,18 @@ pub unsafe fn deno_import_buf<'sc>( // TODO(bartlomieju): for now skipping part with `global_import_buf_` // and always creating new buffer - let mut ab = v8::ArrayBuffer::new(scope, buf.data_len); + let ab = v8::ArrayBuffer::new(scope, buf.data_len); let mut backing_store = ab.get_backing_store(); let data = backing_store.data(); - let data: *mut u8 = unsafe { data as *mut libc::c_void as *mut u8 }; + let data: *mut u8 = data as *mut libc::c_void as *mut u8; std::ptr::copy_nonoverlapping(buf.data_ptr, data, buf.data_len); v8::Uint8Array::new(ab, 0, buf.data_len).expect("Failed to create UintArray8") } -pub unsafe fn deno_respond( - deno_isolate: &mut DenoIsolate, - core_isolate: *const c_void, - op_id: OpId, - buf: deno_buf, -) { - /* - auto* d = deno::unwrap(d_); - if (d->current_args_ != nullptr) { - // Synchronous response. - // Note op_id is not passed back in the case of synchronous response. - if (buf.data_ptr != nullptr && buf.data_len > 0) { - auto ab = deno::ImportBuf(d, buf); - d->current_args_->GetReturnValue().Set(ab); - } - d->current_args_ = nullptr; - return; - } - */ - - if !deno_isolate.current_args_.is_null() { - // Synchronous response. - // Note op_id is not passed back in the case of synchronous response. - if !buf.data_ptr.is_null() && buf.data_len > 0 { - let isolate = deno_isolate.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - assert!(!deno_isolate.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let ab = deno_import_buf(scope, buf); - let info: &v8::FunctionCallbackInfo = - unsafe { &*deno_isolate.current_args_ }; - let rv = &mut info.get_return_value(); - rv.set(ab.into()) - } - deno_isolate.current_args_ = std::ptr::null(); - return; - } - - /* - // Asynchronous response. - deno::UserDataScope user_data_scope(d, user_data); - v8::Isolate::Scope isolate_scope(d->isolate_); - v8::HandleScope handle_scope(d->isolate_); - - auto context = d->context_.Get(d->isolate_); - v8::Context::Scope context_scope(context); - - v8::TryCatch try_catch(d->isolate_); - - auto recv_ = d->recv_.Get(d->isolate_); - if (recv_.IsEmpty()) { - d->last_exception_ = "Deno.core.recv has not been called."; - return; - } - - v8::Local<v8::Value> args[2]; - int argc = 0; - - if (buf.data_ptr != nullptr) { - args[0] = v8::Integer::New(d->isolate_, op_id); - args[1] = deno::ImportBuf(d, buf); - argc = 2; - } - - auto v = recv_->Call(context, context->Global(), argc, args); - - if (try_catch.HasCaught()) { - CHECK(v.IsEmpty()); - deno::HandleException(context, try_catch.Exception()); - } - */ - - let core_isolate: *mut c_void = unsafe { std::mem::transmute(core_isolate) }; - deno_isolate.core_isolate_ = core_isolate; - - let isolate = deno_isolate.isolate_.as_ref().unwrap(); - // println!("deno_execute -> Isolate ptr {:?}", isolate); - let mut locker = v8::Locker::new(isolate); - assert!(!deno_isolate.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = deno_isolate.context_.get(scope).unwrap(); - context.enter(); - - let mut try_catch = v8::TryCatch::new(scope); - let tc = try_catch.enter(); - - let recv_ = deno_isolate.recv_.get(scope); - - if recv_.is_none() { - let msg = "Deno.core.recv has not been called.".to_string(); - deno_isolate.last_exception_ = Some(msg); - return; - } - - let mut argc = 0; - let mut args: Vec<v8::Local<v8::Value>> = vec![]; - - if !buf.data_ptr.is_null() { - argc = 2; - let op_id = v8::Integer::new(scope, op_id as i32); - args.push(op_id.into()); - let buf = deno_import_buf(scope, buf); - args.push(buf.into()); - } - - let global = context.global(scope); - let maybe_value = - recv_ - .unwrap() - .call(scope, context, global.into(), argc, args); - - if tc.has_caught() { - assert!(maybe_value.is_none()); - deno_isolate.handle_exception(scope, context, tc.exception().unwrap()); - } - context.exit(); - deno_isolate.core_isolate_ = std::ptr::null_mut(); -} - -pub unsafe fn deno_execute( - i_mut: &mut DenoIsolate, - core_isolate: *mut c_void, - js_filename: &str, - js_source: &str, -) { - i_mut.core_isolate_ = core_isolate; - let isolate = i_mut.isolate_.as_ref().unwrap(); - // println!("deno_execute -> Isolate ptr {:?}", isolate); - let mut locker = v8::Locker::new(isolate); - assert!(!i_mut.context_.is_empty()); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - let mut context = i_mut.context_.get(scope).unwrap(); - context.enter(); - - i_mut.execute(scope, context, js_filename, js_source); - - context.exit(); - i_mut.core_isolate_ = std::ptr::null_mut(); - /* - auto* d = deno::unwrap(d_); - deno::UserDataScope user_data_scope(d, user_data); - auto* isolate = d->isolate_; - v8::Locker locker(isolate); - v8::Isolate::Scope isolate_scope(isolate); - v8::HandleScope handle_scope(isolate); - auto context = d->context_.Get(d->isolate_); - CHECK(!context.IsEmpty()); - execute(context, js_filename, js_source); - */ -} - -pub unsafe fn deno_terminate_execution(i: *mut DenoIsolate) { - /* - deno::DenoIsolate* d = reinterpret_cast<deno::DenoIsolate*>(d_); - d->isolate_->TerminateExecution(); - */ - let i_mut: &mut DenoIsolate = unsafe { &mut *i }; - let isolate = i_mut.isolate_.as_ref().unwrap(); - isolate.terminate_execution(); -} - -#[allow(dead_code)] -pub unsafe fn deno_run_microtasks(i: *mut isolate, core_isolate: *mut c_void) { - /* - deno::DenoIsolate* d = reinterpret_cast<deno::DenoIsolate*>(d_); - deno::UserDataScope user_data_scope(d, user_data); - v8::Locker locker(d->isolate_); - v8::Isolate::Scope isolate_scope(d->isolate_); - d->isolate_->RunMicrotasks(); - */ - let deno_isolate: &mut DenoIsolate = unsafe { &mut *i }; - deno_isolate.core_isolate_ = core_isolate; - let isolate = deno_isolate.isolate_.as_mut().unwrap(); - let mut locker = v8::Locker::new(isolate); - isolate.enter(); - isolate.run_microtasks(); - isolate.exit(); - deno_isolate.core_isolate_ = std::ptr::null_mut(); -} - -// Modules - -fn resolve_callback( - context: v8::Local<v8::Context>, - specifier: v8::Local<v8::String>, - referrer: v8::Local<v8::Module>, -) -> *mut v8::Module { - let mut cbs = v8::CallbackScope::new(context); - let cb_scope = cbs.enter(); - let isolate = cb_scope.isolate(); - let deno_isolate: &mut DenoIsolate = - unsafe { &mut *(isolate.get_data(0) as *mut DenoIsolate) }; - - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::EscapableHandleScope::new(&mut locker); - let scope = hs.enter(); - - let referrer_id = referrer.get_identity_hash(); - let referrer_info = deno_isolate - .get_module_info(referrer_id) - .expect("ModuleInfo not found"); - let len_ = referrer.get_module_requests_length(); - - let specifier_str = specifier.to_rust_string_lossy(scope); - - for i in 0..len_ { - let req = referrer.get_module_request(i); - let req_str = req.to_rust_string_lossy(scope); - - if req_str == specifier_str { - let resolve_cb = deno_isolate.resolve_cb_.unwrap(); - let c_str = CString::new(req_str.to_string()).unwrap(); - let c_req_str: *const c_char = c_str.as_ptr() as *const c_char; - let id = unsafe { - resolve_cb(deno_isolate.resolve_context_, c_req_str, referrer_id) - }; - let maybe_info = deno_isolate.get_module_info(id); - - if maybe_info.is_none() { - let msg = format!( - "Cannot resolve module \"{}\" from \"{}\"", - req_str, referrer_info.name - ); - let msg = v8::String::new(scope, &msg).unwrap(); - isolate.throw_exception(msg.into()); - break; - } - - let child_mod = - maybe_info.unwrap().handle.get(scope).expect("Empty handle"); - return &mut *scope.escape(child_mod); - } - } - - std::ptr::null_mut() -} - -pub unsafe fn deno_mod_instantiate( - i_mut: &mut DenoIsolate, - resolve_context: *mut c_void, - id: deno_mod, - resolve_cb: deno_resolve_cb, -) { - i_mut.resolve_context_ = resolve_context; - let isolate = i_mut.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - assert!(!i_mut.context_.is_empty()); - let mut context = i_mut.context_.get(scope).unwrap(); - context.enter(); - let mut try_catch = v8::TryCatch::new(scope); - let tc = try_catch.enter(); - - assert!(i_mut.resolve_cb_.is_none()); - i_mut.resolve_cb_ = Some(resolve_cb); - - let maybe_info = i_mut.get_module_info(id); - - if maybe_info.is_none() { - return; - } - - let module_handle = &maybe_info.unwrap().handle; - let mut module = module_handle.get(scope).unwrap(); - - if module.get_status() == v8::ModuleStatus::Errored { - return; - } - - let maybe_ok = module.instantiate_module(context, resolve_callback); - assert!(maybe_ok.is_some() || tc.has_caught()); - i_mut.resolve_cb_.take(); - - if tc.has_caught() { - i_mut.handle_exception(scope, context, tc.exception().unwrap()); - } - - context.exit(); - i_mut.resolve_context_ = std::ptr::null_mut(); -} - -pub unsafe fn deno_mod_evaluate( - deno_isolate: &mut DenoIsolate, - core_isolate: *const c_void, - id: deno_mod, -) { - let core_isolate: *mut c_void = unsafe { std::mem::transmute(core_isolate) }; - deno_isolate.core_isolate_ = core_isolate; - let isolate = deno_isolate.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - assert!(!deno_isolate.context_.is_empty()); - let mut context = deno_isolate.context_.get(scope).unwrap(); - context.enter(); - - let info = deno_isolate - .get_module_info(id) - .expect("ModuleInfo not found"); - let mut module = info.handle.get(scope).expect("Empty module handle"); - let mut status = module.get_status(); - - if status == v8::ModuleStatus::Instantiated { - let ok = module.evaluate(scope, context).is_some(); - // Update status after evaluating. - status = module.get_status(); - if ok { - assert!( - status == v8::ModuleStatus::Evaluated - || status == v8::ModuleStatus::Errored - ); - } else { - assert!(status == v8::ModuleStatus::Errored); - } - } - - match status { - v8::ModuleStatus::Evaluated => { - deno_isolate.last_exception_handle_.reset(scope); - deno_isolate.last_exception_.take(); - } - v8::ModuleStatus::Errored => { - deno_isolate.handle_exception(scope, context, module.get_exception()); - } - other => panic!("Unexpected module status {:?}", other), - }; - - context.exit(); - deno_isolate.core_isolate_ = std::ptr::null_mut(); -} - -/// Call exactly once for every deno_dyn_import_cb. -pub unsafe fn deno_dyn_import_done( - deno_isolate: &mut DenoIsolate, - core_isolate: *const c_void, - id: deno_dyn_import_id, - mod_id: deno_mod, - error_str: Option<String>, -) { - assert!( - (mod_id == 0 && error_str.is_some()) - || (mod_id != 0 && error_str.is_none()) - || (mod_id == 0 && !deno_isolate.last_exception_handle_.is_empty()) - ); - - let core_isolate: *mut c_void = unsafe { std::mem::transmute(core_isolate) }; - deno_isolate.core_isolate_ = core_isolate; - - let isolate = deno_isolate.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - assert!(!deno_isolate.context_.is_empty()); - let mut context = deno_isolate.context_.get(scope).unwrap(); - context.enter(); - - // TODO(ry) error on bad import_id. - let mut resolver_handle = deno_isolate.dyn_import_map_.remove(&id).unwrap(); - /// Resolve. - let mut resolver = resolver_handle.get(scope).unwrap(); - resolver_handle.reset(scope); - - let maybe_info = deno_isolate.get_module_info(mod_id); - - if let Some(info) = maybe_info { - // Resolution success - let mut module = info.handle.get(scope).unwrap(); - assert_eq!(module.get_status(), v8::ModuleStatus::Evaluated); - let module_namespace = module.get_module_namespace(); - resolver.resolve(context, module_namespace).unwrap(); - } else { - // Resolution error. - if let Some(error_str) = error_str { - let msg = v8::String::new(scope, &error_str).unwrap(); - let isolate = context.get_isolate(); - isolate.enter(); - let e = v8::type_error(scope, msg); - isolate.exit(); - resolver.reject(context, e).unwrap(); - } else { - let e = deno_isolate.last_exception_handle_.get(scope).unwrap(); - deno_isolate.last_exception_handle_.reset(scope); - deno_isolate.last_exception_.take(); - resolver.reject(context, e).unwrap(); - } - } - - isolate.run_microtasks(); - - context.exit(); - deno_isolate.core_isolate_ = std::ptr::null_mut(); -} - -pub fn deno_snapshot_new( - deno_isolate: &mut DenoIsolate, -) -> v8::OwnedStartupData { - assert!(deno_isolate.snapshot_creator_.is_some()); - - let isolate = deno_isolate.isolate_.as_ref().unwrap(); - let mut locker = v8::Locker::new(isolate); - let mut hs = v8::HandleScope::new(&mut locker); - let scope = hs.enter(); - - // d.clear_modules(); - deno_isolate.context_.reset(scope); - - let snapshot_creator = deno_isolate.snapshot_creator_.as_mut().unwrap(); - let startup_data = snapshot_creator - .create_blob(v8::FunctionCodeHandling::Keep) - .unwrap(); - deno_isolate.has_snapshotted_ = true; - startup_data -} +/* #[allow(dead_code)] pub unsafe fn deno_snapshot_delete(s: &mut deno_snapshot) { todo!() } +*/ diff --git a/core/modules.rs b/core/modules.rs index 0248e338d..68c500604 100644 --- a/core/modules.rs +++ b/core/modules.rs @@ -198,7 +198,7 @@ impl<L: Loader + Unpin> RecursiveLoad<L> { /// This future needs to take ownership of the isolate. pub fn get_future( self, - isolate: Arc<Mutex<Isolate>>, + isolate: Arc<Mutex<Box<Isolate>>>, ) -> impl Future<Output = Result<deno_mod, ErrBox>> { async move { let mut load = self; @@ -619,7 +619,7 @@ mod tests { struct MockLoader { pub loads: Arc<Mutex<Vec<String>>>, - pub isolate: Arc<Mutex<Isolate>>, + pub isolate: Arc<Mutex<Box<Isolate>>>, pub modules: Arc<Mutex<Modules>>, } diff --git a/deno_typescript/lib.rs b/deno_typescript/lib.rs index c7de33215..2d459f98f 100644 --- a/deno_typescript/lib.rs +++ b/deno_typescript/lib.rs @@ -62,7 +62,7 @@ where } pub struct TSIsolate { - isolate: Isolate, + isolate: Box<Isolate>, state: Arc<Mutex<TSState>>, } @@ -220,7 +220,7 @@ pub fn mksnapshot_bundle_ts( } fn write_snapshot( - mut runtime_isolate: Isolate, + mut runtime_isolate: Box<Isolate>, bundle: &Path, ) -> Result<(), ErrBox> { println!("creating snapshot..."); |