123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
use crate::error::is_instance_of_error;use crate::modules::get_asserted_module_type_from_assertions;use crate::modules::parse_import_assertions;use crate::modules::validate_import_assertions;use crate::modules::ImportAssertionsKind;use crate::modules::ModuleMap;use crate::ops::OpCtx;use crate::JsRealm;use crate::JsRuntime;use log::debug;use std::option::Option;use std::os::raw::c_void;use v8::fast_api::FastFunction;use v8::MapFnTo;
pub fn external_references(  ops: &[OpCtx],  snapshot_loaded: bool,) -> v8::ExternalReferences {  let mut references = vec![    v8::ExternalReference {      function: call_console.map_fn_to(),    },    v8::ExternalReference {      function: import_meta_resolve.map_fn_to(),    },    v8::ExternalReference {      function: catch_dynamic_import_promise_error.map_fn_to(),    },    v8::ExternalReference {      function: empty_fn.map_fn_to(),    },  ];
  for ctx in ops {    let ctx_ptr = ctx as *const OpCtx as _;    references.push(v8::ExternalReference { pointer: ctx_ptr });    references.push(v8::ExternalReference {      function: ctx.decl.v8_fn_ptr,    });    if snapshot_loaded {      if let Some(fast_fn) = &ctx.decl.fast_fn {        references.push(v8::ExternalReference {          pointer: fast_fn.function() as _,        });      }    }  }
  let refs = v8::ExternalReferences::new(&references);  // Leak, V8 takes ownership of the references.  std::mem::forget(references);  refs}
// TODO(nayeemrmn): Move to runtime and/or make `pub(crate)`.pub fn script_origin<'a>(  s: &mut v8::HandleScope<'a>,  resource_name: v8::Local<'a, v8::String>,) -> v8::ScriptOrigin<'a> {  let source_map_url = v8::String::new(s, "").unwrap();  v8::ScriptOrigin::new(    s,    resource_name.into(),    0,    0,    false,    123,    source_map_url.into(),    true,    false,    false,  )}
pub fn module_origin<'a>(  s: &mut v8::HandleScope<'a>,  resource_name: v8::Local<'a, v8::String>,) -> v8::ScriptOrigin<'a> {  let source_map_url = v8::String::new(s, "").unwrap();  v8::ScriptOrigin::new(    s,    resource_name.into(),    0,    0,    false,    123,    source_map_url.into(),    true,    false,    true,  )}
pub fn initialize_context<'s>(  scope: &mut v8::HandleScope<'s, ()>,  op_ctxs: &[OpCtx],  snapshot_loaded: bool,) -> v8::Local<'s, v8::Context> {  let scope = &mut v8::EscapableHandleScope::new(scope);
  let context = v8::Context::new(scope);  let global = context.global(scope);
  let scope = &mut v8::ContextScope::new(scope, context);
  // Snapshot already registered `Deno.core.ops` but  // extensions may provide ops that aren't part of the snapshot.  //  // TODO(@littledivy): This is extra complexity for  // a really weird usecase. Remove this once all  // tsc ops are static at snapshot time.  if snapshot_loaded {    // Grab the Deno.core.ops object & init it    let ops_obj = JsRuntime::grab_global::<v8::Object>(scope, "Deno.core.ops")      .expect("Deno.core.ops to exist");    initialize_ops(scope, ops_obj, op_ctxs, snapshot_loaded);
    return scope.escape(context);  }
  // global.Deno = { core: { } };  let core_val = JsRuntime::ensure_objs(scope, global, "Deno.core").unwrap();
  // Bind functions to Deno.core.*  set_func(scope, core_val, "callConsole", call_console);
  // Bind functions to Deno.core.ops.*  let ops_obj = JsRuntime::ensure_objs(scope, global, "Deno.core.ops").unwrap();
  initialize_ops(scope, ops_obj, op_ctxs, snapshot_loaded);  scope.escape(context)}
fn initialize_ops(  scope: &mut v8::HandleScope,  ops_obj: v8::Local<v8::Object>,  op_ctxs: &[OpCtx],  snapshot_loaded: bool,) {  for ctx in op_ctxs {    let ctx_ptr = ctx as *const OpCtx as *const c_void;
    // If this is a fast op, we don't want it to be in the snapshot.    // Only initialize once snapshot is loaded.    if ctx.decl.fast_fn.is_some() && snapshot_loaded {      let object_template = v8::ObjectTemplate::new(scope);      assert!(object_template.set_internal_field_count(        (crate::runtime::V8_WRAPPER_OBJECT_INDEX + 1) as usize      ));
      let method_obj = object_template.new_instance(scope).unwrap();      method_obj.set_aligned_pointer_in_internal_field(        crate::runtime::V8_WRAPPER_OBJECT_INDEX,        ctx_ptr,      );      set_func_raw(        scope,        method_obj,        "fast",        ctx.decl.v8_fn_ptr,        ctx_ptr,        &ctx.decl.fast_fn,        snapshot_loaded,      );      let method_key = v8::String::new(scope, ctx.decl.name).unwrap();      ops_obj.set(scope, method_key.into(), method_obj.into());    } else {      set_func_raw(        scope,        ops_obj,        ctx.decl.name,        ctx.decl.v8_fn_ptr,        ctx_ptr,        &None,        snapshot_loaded,      );    }  }}
pub fn set_func(  scope: &mut v8::HandleScope<'_>,  obj: v8::Local<v8::Object>,  name: &'static str,  callback: impl v8::MapFnTo<v8::FunctionCallback>,) {  let key = v8::String::new(scope, name).unwrap();  let val = v8::Function::new(scope, callback).unwrap();  val.set_name(key);  obj.set(scope, key.into(), val.into());}
// Register a raw v8::FunctionCallback// with some external data.pub fn set_func_raw(  scope: &mut v8::HandleScope<'_>,  obj: v8::Local<v8::Object>,  name: &'static str,  callback: v8::FunctionCallback,  external_data: *const c_void,  fast_function: &Option<Box<dyn FastFunction>>,  snapshot_loaded: bool,) {  let key = v8::String::new(scope, name).unwrap();  let external = v8::External::new(scope, external_data as *mut c_void);  let builder =    v8::FunctionTemplate::builder_raw(callback).data(external.into());  let templ = if let Some(fast_function) = fast_function {    // Don't initialize fast ops when snapshotting, the external references count mismatch.    if !snapshot_loaded {      builder.build(scope)    } else {      // TODO(@littledivy): Support fast api overloads in ops.      builder.build_fast(scope, &**fast_function, None)    }  } else {    builder.build(scope)  };  let val = templ.get_function(scope).unwrap();  val.set_name(key);  obj.set(scope, key.into(), val.into());}
pub extern "C" fn wasm_async_resolve_promise_callback(  _isolate: *mut v8::Isolate,  context: v8::Local<v8::Context>,  resolver: v8::Local<v8::PromiseResolver>,  compilation_result: v8::Local<v8::Value>,  success: v8::WasmAsyncSuccess,) {  // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`  let scope = &mut unsafe { v8::CallbackScope::new(context) };  if success == v8::WasmAsyncSuccess::Success {    resolver.resolve(scope, compilation_result).unwrap();  } else {    resolver.reject(scope, compilation_result).unwrap();  }}
pub extern "C" fn host_import_module_dynamically_callback(  context: v8::Local<v8::Context>,  _host_defined_options: v8::Local<v8::Data>,  resource_name: v8::Local<v8::Value>,  specifier: v8::Local<v8::String>,  import_assertions: v8::Local<v8::FixedArray>,) -> *mut v8::Promise {  // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`  let scope = &mut unsafe { v8::CallbackScope::new(context) };
  // 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_str = resource_name    .to_string(scope)    .unwrap()    .to_rust_string_lossy(scope);
  let resolver = v8::PromiseResolver::new(scope).unwrap();  let promise = resolver.get_promise(scope);
  let assertions = parse_import_assertions(    scope,    import_assertions,    ImportAssertionsKind::DynamicImport,  );
  {    let tc_scope = &mut v8::TryCatch::new(scope);    validate_import_assertions(tc_scope, &assertions);    if tc_scope.has_caught() {      let e = tc_scope.exception().unwrap();      resolver.reject(tc_scope, e);    }  }  let asserted_module_type =    get_asserted_module_type_from_assertions(&assertions);
  let resolver_handle = v8::Global::new(scope, resolver);  {    let state_rc = JsRuntime::state(scope);    let module_map_rc = JsRuntime::module_map(scope);
    debug!(      "dyn_import specifier {} referrer {} ",      specifier_str, referrer_name_str    );    ModuleMap::load_dynamic_import(      module_map_rc,      &specifier_str,      &referrer_name_str,      asserted_module_type,      resolver_handle,    );    state_rc.borrow_mut().notify_new_dynamic_import();  }
  // Map errors from module resolution (not JS errors from module execution) to  // ones rethrown from this scope, so they include the call stack of the  // dynamic import site. Error objects without any stack frames are assumed to  // be module resolution errors, other exception values are left as they are.  let builder = v8::FunctionBuilder::new(catch_dynamic_import_promise_error);
  let map_err =    v8::FunctionBuilder::<v8::Function>::build(builder, scope).unwrap();
  let promise = promise.catch(scope, map_err).unwrap();
  &*promise as *const _ as *mut _}
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>,) {  // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`  let scope = &mut unsafe { v8::CallbackScope::new(context) };  let module_map_rc = JsRuntime::module_map(scope);  let module_map = module_map_rc.borrow();
  let module_global = v8::Global::new(scope, module);  let info = module_map    .get_info(&module_global)    .expect("Module not found");
  let url_key = v8::String::new(scope, "url").unwrap();  let url_val = v8::String::new(scope, &info.name).unwrap();  meta.create_data_property(scope, url_key.into(), url_val.into());
  let main_key = v8::String::new(scope, "main").unwrap();  let main_val = v8::Boolean::new(scope, info.main);  meta.create_data_property(scope, main_key.into(), main_val.into());
  let builder =    v8::FunctionBuilder::new(import_meta_resolve).data(url_val.into());  let val = v8::FunctionBuilder::<v8::Function>::build(builder, scope).unwrap();  let resolve_key = v8::String::new(scope, "resolve").unwrap();  meta.set(scope, resolve_key.into(), val.into());}
fn import_meta_resolve(  scope: &mut v8::HandleScope,  args: v8::FunctionCallbackArguments,  mut rv: v8::ReturnValue,) {  if args.length() > 1 {    return throw_type_error(scope, "Invalid arguments");  }
  let maybe_arg_str = args.get(0).to_string(scope);  if maybe_arg_str.is_none() {    return throw_type_error(scope, "Invalid arguments");  }  let specifier = maybe_arg_str.unwrap();  let referrer = {    let url_prop = args.data().unwrap();    url_prop.to_rust_string_lossy(scope)  };  let module_map_rc = JsRuntime::module_map(scope);  let loader = {    let module_map = module_map_rc.borrow();    module_map.loader.clone()  };  match loader.resolve(&specifier.to_rust_string_lossy(scope), &referrer, false)  {    Ok(resolved) => {      let resolved_val = serde_v8::to_v8(scope, resolved.as_str()).unwrap();      rv.set(resolved_val);    }    Err(err) => {      throw_type_error(scope, &err.to_string());    }  };}
fn empty_fn(  _scope: &mut v8::HandleScope,  _args: v8::FunctionCallbackArguments,  _rv: v8::ReturnValue,) {  //Do Nothing}
//It creates a reference to an empty function which can be mantained after the snapshotspub fn create_empty_fn<'s>(  scope: &mut v8::HandleScope<'s>,) -> Option<v8::Local<'s, v8::Function>> {  let empty_fn = v8::FunctionTemplate::new(scope, empty_fn);  empty_fn.get_function(scope)}
fn catch_dynamic_import_promise_error(  scope: &mut v8::HandleScope,  args: v8::FunctionCallbackArguments,  _rv: v8::ReturnValue,) {  let arg = args.get(0);  if is_instance_of_error(scope, arg) {    let e: crate::error::NativeJsError = serde_v8::from_v8(scope, arg).unwrap();    let name = e.name.unwrap_or_else(|| "Error".to_string());    let message = v8::Exception::create_message(scope, arg);    if message.get_stack_trace(scope).unwrap().get_frame_count() == 0 {      let arg: v8::Local<v8::Object> = arg.try_into().unwrap();      let message_key = v8::String::new(scope, "message").unwrap();      let message = arg.get(scope, message_key.into()).unwrap();      let exception = match name.as_str() {        "RangeError" => {          v8::Exception::range_error(scope, message.try_into().unwrap())        }        "TypeError" => {          v8::Exception::type_error(scope, message.try_into().unwrap())        }        "SyntaxError" => {          v8::Exception::syntax_error(scope, message.try_into().unwrap())        }        "ReferenceError" => {          v8::Exception::reference_error(scope, message.try_into().unwrap())        }        _ => v8::Exception::error(scope, message.try_into().unwrap()),      };      let code_key = v8::String::new(scope, "code").unwrap();      let code_value = v8::String::new(scope, "ERR_MODULE_NOT_FOUND").unwrap();      let exception_obj = exception.to_object(scope).unwrap();      exception_obj.set(scope, code_key.into(), code_value.into());      scope.throw_exception(exception);      return;    }  }  scope.throw_exception(arg);}
pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {  use v8::PromiseRejectEvent::*;
  // SAFETY: `CallbackScope` can be safely constructed from `&PromiseRejectMessage`  let scope = &mut unsafe { v8::CallbackScope::new(&message) };
  let realm_state_rc = JsRealm::state_from_scope(scope);
  if let Some(js_promise_reject_cb) =    realm_state_rc.borrow().js_promise_reject_cb.clone()  {    let tc_scope = &mut v8::TryCatch::new(scope);    let undefined: v8::Local<v8::Value> = v8::undefined(tc_scope).into();    let type_ = v8::Integer::new(tc_scope, message.get_event() as i32);    let promise = message.get_promise();
    let reason = match message.get_event() {      PromiseRejectWithNoHandler      | PromiseRejectAfterResolved      | PromiseResolveAfterResolved => message.get_value().unwrap_or(undefined),      PromiseHandlerAddedAfterReject => undefined,    };
    let promise_global = v8::Global::new(tc_scope, promise);    let args = &[type_.into(), promise.into(), reason];    let maybe_has_unhandled_rejection_handler = js_promise_reject_cb      .open(tc_scope)      .call(tc_scope, undefined, args);
    let has_unhandled_rejection_handler =      if let Some(value) = maybe_has_unhandled_rejection_handler {        value.is_true()      } else {        false      };
    if has_unhandled_rejection_handler {      let state_rc = JsRuntime::state(tc_scope);      let mut state = state_rc.borrow_mut();      if let Some(pending_mod_evaluate) = state.pending_mod_evaluate.as_mut() {        if !pending_mod_evaluate.has_evaluated {          pending_mod_evaluate            .handled_promise_rejections            .push(promise_global);        }      }    }  } else {    let state_rc = JsRuntime::state(scope);    let mut state = state_rc.borrow_mut();    let promise = message.get_promise();    let promise_global = v8::Global::new(scope, promise);    match message.get_event() {      PromiseRejectWithNoHandler => {        let error = message.get_value().unwrap();        let error_global = v8::Global::new(scope, error);        state          .pending_promise_exceptions          .insert(promise_global, error_global);      }      PromiseHandlerAddedAfterReject => {        state.pending_promise_exceptions.remove(&promise_global);      }      PromiseRejectAfterResolved => {}      PromiseResolveAfterResolved => {        // Should not warn. See #1272      }    }  };}
/// This binding should be used if there's a custom console implementation/// available. Using it will make sure that proper stack frames are displayed/// in the inspector console.////// Each method on console object should be bound to this function, eg:/// ```ignore/// function wrapConsole(consoleFromDeno, consoleFromV8) {///   const callConsole = core.callConsole;//////   for (const key of Object.keys(consoleFromV8)) {///     if (consoleFromDeno.hasOwnProperty(key)) {///       consoleFromDeno[key] = callConsole.bind(///         consoleFromDeno,///         consoleFromV8[key],///         consoleFromDeno[key],///       );///     }///   }/// }/// ```////// Inspired by:/// https://github.com/nodejs/node/blob/1317252dfe8824fd9cfee125d2aaa94004db2f3b/src/inspector_js_api.cc#L194-L222fn call_console(  scope: &mut v8::HandleScope,  args: v8::FunctionCallbackArguments,  _rv: v8::ReturnValue,) {  if args.length() < 2    || !args.get(0).is_function()    || !args.get(1).is_function()  {    return throw_type_error(scope, "Invalid arguments");  }
  let mut call_args = vec![];  for i in 2..args.length() {    call_args.push(args.get(i));  }
  let receiver = args.this();  let inspector_console_method =    v8::Local::<v8::Function>::try_from(args.get(0)).unwrap();  let deno_console_method =    v8::Local::<v8::Function>::try_from(args.get(1)).unwrap();
  inspector_console_method.call(scope, receiver.into(), &call_args);  deno_console_method.call(scope, receiver.into(), &call_args);}
/// Called by V8 during `JsRuntime::instantiate_module`.////// This function borrows `ModuleMap` from the isolate slot,/// so it is crucial to ensure there are no existing borrows/// of `ModuleMap` when `JsRuntime::instantiate_module` is called.pub fn module_resolve_callback<'s>(  context: v8::Local<'s, v8::Context>,  specifier: v8::Local<'s, v8::String>,  import_assertions: v8::Local<'s, v8::FixedArray>,  referrer: v8::Local<'s, v8::Module>,) -> Option<v8::Local<'s, v8::Module>> {  // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`  let scope = &mut unsafe { v8::CallbackScope::new(context) };
  let module_map_rc = JsRuntime::module_map(scope);  let module_map = module_map_rc.borrow();
  let referrer_global = v8::Global::new(scope, referrer);
  let referrer_info = module_map    .get_info(&referrer_global)    .expect("ModuleInfo not found");  let referrer_name = referrer_info.name.to_string();
  let specifier_str = specifier.to_rust_string_lossy(scope);
  let assertions = parse_import_assertions(    scope,    import_assertions,    ImportAssertionsKind::StaticImport,  );  let maybe_module = module_map.resolve_callback(    scope,    &specifier_str,    &referrer_name,    assertions,  );  if let Some(module) = maybe_module {    return Some(module);  }
  let msg = format!(    r#"Cannot resolve module "{}" from "{}""#,    specifier_str, referrer_name  );  throw_type_error(scope, msg);  None}
pub fn throw_type_error(scope: &mut v8::HandleScope, message: impl AsRef<str>) {  let message = v8::String::new(scope, message.as_ref()).unwrap();  let exception = v8::Exception::type_error(scope, message);  scope.throw_exception(exception);}