merge libdeno::DenoIsolate into core::Isolate (#3605)

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>>,
 }

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()
+}

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;

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>>,
   }
 

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...");