1 files changed, 598 insertions, 0 deletions
diff --git a/core/runtime/bindings.rs b/core/runtime/bindings.rs
new file mode 100644
index 000000000..4cc27592f
--- /dev/null
+++ b/core/runtime/bindings.rs
@@ -0,0 +1,598 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+use log::debug;
+use std::fmt::Write;
+use std::option::Option;
+use std::os::raw::c_void;
+use v8::MapFnTo;
+
+use crate::error::is_instance_of_error;
+use crate::error::JsStackFrame;
+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::modules::ResolutionKind;
+use crate::ops::OpCtx;
+use crate::runtime::InitMode;
+use crate::JsRealm;
+use crate::JsRuntime;
+
+pub(crate) fn external_references(ops: &[OpCtx]) -> v8::ExternalReferences {
+  // Overallocate a bit, it's better than having to resize the vector.
+  let mut references = Vec::with_capacity(4 + ops.len() * 4);
+
+  references.push(v8::ExternalReference {
+    function: call_console.map_fn_to(),
+  });
+  references.push(v8::ExternalReference {
+    function: import_meta_resolve.map_fn_to(),
+  });
+  references.push(v8::ExternalReference {
+    function: catch_dynamic_import_promise_error.map_fn_to(),
+  });
+  references.push(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 let Some(fast_fn) = &ctx.decl.fast_fn {
+      references.push(v8::ExternalReference {
+        pointer: fast_fn.function as _,
+      });
+      references.push(v8::ExternalReference {
+        pointer: ctx.fast_fn_c_info.unwrap().as_ptr() 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::empty(s);
+  v8::ScriptOrigin::new(
+    s,
+    resource_name.into(),
+    0,
+    0,
+    false,
+    123,
+    source_map_url.into(),
+    true,
+    false,
+    false,
+  )
+}
+
+fn get<'s, T>(
+  scope: &mut v8::HandleScope<'s>,
+  from: v8::Local<v8::Object>,
+  key: &'static [u8],
+  path: &'static str,
+) -> T
+where
+  v8::Local<'s, v8::Value>: TryInto<T>,
+{
+  let key = v8::String::new_external_onebyte_static(scope, key).unwrap();
+  from
+    .get(scope, key.into())
+    .unwrap_or_else(|| panic!("{path} exists"))
+    .try_into()
+    .unwrap_or_else(|_| panic!("unable to convert"))
+}
+
+pub(crate) fn initialize_context<'s>(
+  scope: &mut v8::HandleScope<'s>,
+  context: v8::Local<'s, v8::Context>,
+  op_ctxs: &[OpCtx],
+  init_mode: InitMode,
+) -> v8::Local<'s, v8::Context> {
+  let global = context.global(scope);
+
+  let mut codegen = String::with_capacity(op_ctxs.len() * 200);
+  codegen.push_str(include_str!("bindings.js"));
+  _ = writeln!(
+    codegen,
+    "Deno.__op__ = function(opFns, callConsole, console) {{"
+  );
+  if init_mode == InitMode::New {
+    _ = writeln!(codegen, "Deno.__op__console(callConsole, console);");
+  }
+  for op_ctx in op_ctxs {
+    if op_ctx.decl.enabled {
+      _ = writeln!(
+        codegen,
+        "Deno.__op__registerOp({}, opFns[{}], \"{}\");",
+        op_ctx.decl.is_async, op_ctx.id, op_ctx.decl.name
+      );
+    } else {
+      _ = writeln!(
+        codegen,
+        "Deno.__op__unregisterOp({}, \"{}\");",
+        op_ctx.decl.is_async, op_ctx.decl.name
+      );
+    }
+  }
+  codegen.push_str("Deno.__op__cleanup();");
+  _ = writeln!(codegen, "}}");
+
+  let script = v8::String::new_from_one_byte(
+    scope,
+    codegen.as_bytes(),
+    v8::NewStringType::Normal,
+  )
+  .unwrap();
+  let script = v8::Script::compile(scope, script, None).unwrap();
+  script.run(scope);
+
+  let deno = get(scope, global, b"Deno", "Deno");
+  let op_fn: v8::Local<v8::Function> =
+    get(scope, deno, b"__op__", "Deno.__op__");
+  let recv = v8::undefined(scope);
+  let op_fns = v8::Array::new(scope, op_ctxs.len() as i32);
+  for op_ctx in op_ctxs {
+    let op_fn = op_ctx_function(scope, op_ctx);
+    op_fns.set_index(scope, op_ctx.id as u32, op_fn.into());
+  }
+  if init_mode == InitMode::FromSnapshot {
+    op_fn.call(scope, recv.into(), &[op_fns.into()]);
+  } else {
+    // Bind functions to Deno.core.*
+    let call_console_fn = v8::Function::new(scope, call_console).unwrap();
+
+    // Bind v8 console object to Deno.core.console
+    let extra_binding_obj = context.get_extras_binding_object(scope);
+    let console_obj: v8::Local<v8::Object> = get(
+      scope,
+      extra_binding_obj,
+      b"console",
+      "ExtrasBindingObject.console",
+    );
+
+    op_fn.call(
+      scope,
+      recv.into(),
+      &[op_fns.into(), call_console_fn.into(), console_obj.into()],
+    );
+  }
+
+  context
+}
+
+fn op_ctx_function<'s>(
+  scope: &mut v8::HandleScope<'s>,
+  op_ctx: &OpCtx,
+) -> v8::Local<'s, v8::Function> {
+  let op_ctx_ptr = op_ctx as *const OpCtx as *const c_void;
+  let external = v8::External::new(scope, op_ctx_ptr as *mut c_void);
+  let v8name =
+    v8::String::new_external_onebyte_static(scope, op_ctx.decl.name.as_bytes())
+      .unwrap();
+  let builder: v8::FunctionBuilder<v8::FunctionTemplate> =
+    v8::FunctionTemplate::builder_raw(op_ctx.decl.v8_fn_ptr)
+      .data(external.into())
+      .length(op_ctx.decl.arg_count as i32);
+
+  let template = if let Some(fast_function) = &op_ctx.decl.fast_fn {
+    builder.build_fast(
+      scope,
+      fast_function,
+      Some(op_ctx.fast_fn_c_info.unwrap().as_ptr()),
+      None,
+      None,
+    )
+  } else {
+    builder.build(scope)
+  };
+
+  let v8fn = template.get_function(scope).unwrap();
+  v8fn.set_name(v8name);
+  v8fn
+}
+
+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 fn host_import_module_dynamically_callback<'s>(
+  scope: &mut v8::HandleScope<'s>,
+  _host_defined_options: v8::Local<'s, v8::Data>,
+  resource_name: v8::Local<'s, v8::Value>,
+  specifier: v8::Local<'s, v8::String>,
+  import_assertions: v8::Local<'s, v8::FixedArray>,
+) -> Option<v8::Local<'s, v8::Promise>> {
+  // 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_from(scope);
+    let module_map_rc = JsRuntime::module_map_from(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();
+
+  Some(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>,
+) {
+  // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`
+  let scope = &mut unsafe { v8::CallbackScope::new(context) };
+  let module_map_rc = JsRuntime::module_map_from(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_external_onebyte_static(scope, b"url").unwrap();
+  let url_val = info.name.v8(scope);
+  meta.create_data_property(scope, url_key.into(), url_val.into());
+
+  let main_key =
+    v8::String::new_external_onebyte_static(scope, b"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_external_onebyte_static(scope, b"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();
+    url_prop.to_rust_string_lossy(scope)
+  };
+  let module_map_rc = JsRuntime::module_map_from(scope);
+  let loader = module_map_rc.borrow().loader.clone();
+  let specifier_str = specifier.to_rust_string_lossy(scope);
+
+  if specifier_str.starts_with("npm:") {
+    throw_type_error(scope, "\"npm:\" specifiers are currently not supported in import.meta.resolve()");
+    return;
+  }
+
+  match loader.resolve(&specifier_str, &referrer, ResolutionKind::DynamicImport)
+  {
+    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 snapshots
+pub 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 msg = v8::Exception::create_message(scope, arg);
+    if msg.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_external_onebyte_static(scope, b"message").unwrap();
+      let message = arg.get(scope, message_key.into()).unwrap();
+      let mut message: v8::Local<v8::String> = message.try_into().unwrap();
+      if let Some(stack_frame) = JsStackFrame::from_v8_message(scope, msg) {
+        if let Some(location) = stack_frame.maybe_format_location() {
+          let str =
+            format!("{} at {location}", message.to_rust_string_lossy(scope));
+          message = v8::String::new(scope, &str).unwrap();
+        }
+      }
+      let exception = match name.as_str() {
+        "RangeError" => v8::Exception::range_error(scope, message),
+        "TypeError" => v8::Exception::type_error(scope, message),
+        "SyntaxError" => v8::Exception::syntax_error(scope, message),
+        "ReferenceError" => v8::Exception::reference_error(scope, message),
+        _ => v8::Exception::error(scope, message),
+      };
+      let code_key =
+        v8::String::new_external_onebyte_static(scope, b"code").unwrap();
+      let code_value =
+        v8::String::new_external_onebyte_static(scope, b"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 context_state_rc = JsRealm::state_from_scope(scope);
+  let mut context_state = context_state_rc.borrow_mut();
+
+  if let Some(js_promise_reject_cb) = context_state.js_promise_reject_cb.clone()
+  {
+    drop(context_state);
+
+    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_from(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 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);
+        context_state
+          .pending_promise_rejections
+          .push_back((promise_global, error_global));
+      }
+      PromiseHandlerAddedAfterReject => {
+        context_state
+          .pending_promise_rejections
+          .retain(|(key, _)| key != &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-L222
+fn 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_from(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.as_str();
+
+  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 "{specifier_str}" from "{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);
+}