feat: upgrade deno_core (denoland#868)

- use new fast call api which allows statically allocating CFunctionInfo
so we don't need to manually deallocate them
- remove unneeded v8_version function

Author: devsnek

Cargo.lock

@@ -24,7 +24,7 @@ deno_ops = { version = "0.179.0", path = "./ops" }
 serde_v8 = { version = "0.212.0", path = "./serde_v8" }
 deno_core_testing = { path = "./testing" }
 
-v8 = { version = "0.102.0", default-features = false }
+v8 = { version = "0.103.0", default-features = false }
 deno_ast = { version = "=0.40.0", features = ["transpiling"] }
 deno_unsync = "0.4.0"
 deno_core_icudata = "0.0.73"

Cargo.toml

@@ -10,7 +10,10 @@ use anyhow::Error;
 use std::borrow::Cow;
 use std::marker::PhantomData;
 use std::sync::Arc;
-use v8::fast_api::FastFunction;
+use v8::fast_api::CFunction;
+use v8::fast_api::CFunctionInfo;
+use v8::fast_api::Int64Representation;
+use v8::fast_api::Type;
 use v8::MapFnTo;
 
 #[derive(Clone)]
@@ -168,6 +171,11 @@ pub type GlobalObjectMiddlewareFn =
 
 extern "C" fn noop() {}
 
+const NOOP_FN: CFunction = CFunction::new(
+  noop as _,
+  &CFunctionInfo::new(Type::Void.scalar(), &[], Int64Representation::Number),
+);
+
 #[derive(Clone, Copy)]
 pub struct OpDecl {
   pub name: &'static str,
@@ -181,9 +189,9 @@ pub struct OpDecl {
   /// The slow dispatch call with metrics enabled. If metrics are enabled, the `v8::Function` is created with this callback.
   pub(crate) slow_fn_with_metrics: OpFnRef,
   /// The fast dispatch call. If metrics are disabled, the `v8::Function`'s fastcall is created with this callback.
-  pub(crate) fast_fn: Option<FastFunction>,
+  pub(crate) fast_fn: Option<CFunction>,
   /// The fast dispatch call with metrics enabled. If metrics are enabled, the `v8::Function`'s fastcall is created with this callback.
-  pub(crate) fast_fn_with_metrics: Option<FastFunction>,
+  pub(crate) fast_fn_with_metrics: Option<CFunction>,
   /// Any metadata associated with this op.
   pub metadata: OpMetadata,
 }
@@ -200,8 +208,8 @@ impl OpDecl {
     no_side_effects: bool,
     slow_fn: OpFnRef,
     slow_fn_with_metrics: OpFnRef,
-    fast_fn: Option<FastFunction>,
-    fast_fn_with_metrics: Option<FastFunction>,
+    fast_fn: Option<CFunction>,
+    fast_fn_with_metrics: Option<CFunction>,
     metadata: OpMetadata,
   ) -> Self {
     #[allow(deprecated)]
@@ -230,26 +238,8 @@ impl OpDecl {
       // ideally we would add a fallback that would throw, but it's unclear
       // if disabled op (that throws in JS) would ever get optimized to become
       // a fast function.
-      fast_fn: if self.fast_fn.is_some() {
-        Some(FastFunction {
-          args: &[],
-          function: noop as _,
-          repr: v8::fast_api::Int64Representation::Number,
-          return_type: v8::fast_api::CType::Void,
-        })
-      } else {
-        None
-      },
-      fast_fn_with_metrics: if self.fast_fn_with_metrics.is_some() {
-        Some(FastFunction {
-          args: &[],
-          function: noop as _,
-          repr: v8::fast_api::Int64Representation::Number,
-          return_type: v8::fast_api::CType::Void,
-        })
-      } else {
-        None
-      },
+      fast_fn: self.fast_fn.map(|_| NOOP_FN),
+      fast_fn_with_metrics: self.fast_fn_with_metrics.map(|_| NOOP_FN),
       ..self
     }
   }
@@ -265,15 +255,15 @@ impl OpDecl {
   }
 
   #[doc(hidden)]
-  pub const fn fast_fn(&self) -> FastFunction {
+  pub const fn fast_fn(&self) -> CFunction {
     let Some(f) = self.fast_fn else {
       panic!("Not a fast function");
     };
     f
   }
 
   #[doc(hidden)]
-  pub const fn fast_fn_with_metrics(&self) -> FastFunction {
+  pub const fn fast_fn_with_metrics(&self) -> CFunction {
     let Some(f) = self.fast_fn_with_metrics else {
       panic!("Not a fast function");
     };

core/extensions.rs

@@ -168,10 +168,6 @@ pub use crate::tasks::V8TaskSpawner;
 // Ensure we can use op2 in deno_core without any hackery.
 extern crate self as deno_core;
 
-pub fn v8_version() -> &'static str {
-  v8::V8::get_version()
-}
-
 /// An internal module re-exporting functions used by the #[op] (`deno_ops`) macro
 #[doc(hidden)]
 pub mod _ops {
@@ -241,11 +237,6 @@ mod tests {
     assert_eq!(&name[..expected.len()], expected);
   }
 
-  #[test]
-  fn test_v8_version() {
-    assert!(v8_version().len() > 3);
-  }
-
   // If the deno command is available, we ensure the async stubs are correctly rebuilt.
   #[test]
   fn test_rebuild_async_stubs() {

core/lib.rs

@@ -14,13 +14,11 @@ use std::cell::RefCell;
 use std::cell::UnsafeCell;
 use std::ops::Deref;
 use std::ops::DerefMut;
-use std::ptr::NonNull;
 use std::rc::Rc;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use v8::fast_api::CFunctionInfo;
-use v8::fast_api::CTypeInfo;
+use v8::fast_api::CFunction;
 use v8::Isolate;
 
 pub type PromiseId = i32;
@@ -74,12 +72,6 @@ impl OpMetadata {
   }
 }
 
-#[derive(Clone, Copy)]
-pub(crate) struct FastFunctionInfo {
-  pub(crate) fn_info: NonNull<CFunctionInfo>,
-  pub(crate) fn_sig: (NonNull<CTypeInfo>, NonNull<CTypeInfo>),
-}
-
 /// Per-op context.
 ///
 // Note: We don't worry too much about the size of this struct because it's allocated once per realm, and is
@@ -98,7 +90,7 @@ pub struct OpCtx {
   pub get_error_class_fn: GetErrorClassFn,
 
   pub(crate) decl: OpDecl,
-  pub(crate) fast_fn_info: Option<FastFunctionInfo>,
+  pub(crate) fast_fn_info: Option<CFunction>,
   pub(crate) metrics_fn: Option<OpMetricsFn>,
   /// If the last fast op failed, stores the error to be picked up by the slow op.
   pub(crate) last_fast_error: UnsafeCell<Option<AnyError>>,
@@ -120,35 +112,15 @@ impl OpCtx {
     metrics_fn: Option<OpMetricsFn>,
   ) -> Self {
     // If we want metrics for this function, create the fastcall `CFunctionInfo` from the metrics
-    // `FastFunction`. For some extremely fast ops, the parameter list may change for the metrics
+    // `CFunction`. For some extremely fast ops, the parameter list may change for the metrics
     // version and require a slightly different set of arguments (for example, it may need the fastcall
     // callback information to get the `OpCtx`).
-    let fast_fn = if metrics_fn.is_some() {
-      &decl.fast_fn_with_metrics
+    let fast_fn_info = if metrics_fn.is_some() {
+      decl.fast_fn_with_metrics
     } else {
-      &decl.fast_fn
+      decl.fast_fn
     };
 
-    let fast_fn_info = fast_fn.map(|fast_fn| {
-      let args = CTypeInfo::new_from_slice(fast_fn.args);
-      let ret = CTypeInfo::new(fast_fn.return_type);
-
-      // SAFETY: all arguments are coming from the trait and they have
-      // static lifetime
-      let c_fn = unsafe {
-        CFunctionInfo::new(
-          args.as_ptr(),
-          fast_fn.args.len(),
-          ret.as_ptr(),
-          fast_fn.repr,
-        )
-      };
-      FastFunctionInfo {
-        fn_info: c_fn,
-        fn_sig: (args, ret),
-      }
-    });
-
     Self {
       id,
       state,
@@ -190,13 +162,13 @@ impl OpCtx {
         function: self.decl.slow_fn_with_metrics,
       };
       if let (Some(fast_fn), Some(fast_fn_info)) =
-        (&self.decl.fast_fn_with_metrics, &self.fast_fn_info)
+        (self.decl.fast_fn_with_metrics, self.fast_fn_info)
       {
         let fast_fn = v8::ExternalReference {
-          pointer: fast_fn.function as _,
+          pointer: fast_fn.address() as _,
         };
         let fast_info = v8::ExternalReference {
-          pointer: fast_fn_info.fn_info.as_ptr() as _,
+          type_info: fast_fn_info.type_info(),
         };
         [ctx_ptr, slow_fn, fast_fn, fast_info]
       } else {
@@ -207,13 +179,13 @@ impl OpCtx {
         function: self.decl.slow_fn,
       };
       if let (Some(fast_fn), Some(fast_fn_info)) =
-        (&self.decl.fast_fn, &self.fast_fn_info)
+        (self.decl.fast_fn, self.fast_fn_info)
       {
         let fast_fn = v8::ExternalReference {
-          pointer: fast_fn.function as _,
+          pointer: fast_fn.address() as _,
         };
         let fast_info = v8::ExternalReference {
-          pointer: fast_fn_info.fn_info.as_ptr() as _,
+          type_info: fast_fn_info.type_info(),
         };
         [ctx_ptr, slow_fn, fast_fn, fast_info]
       } else {

core/ops.rs

@@ -392,14 +392,8 @@ fn op_ctx_function<'s>(
       })
       .length(op_ctx.decl.arg_count as i32);
 
-  let template = if let Some(fast_function) = &fast_fn {
-    builder.build_fast(
-      scope,
-      fast_function,
-      Some(op_ctx.fast_fn_info.unwrap().fn_info.as_ptr()),
-      None,
-      None,
-    )
+  let template = if let Some(fast_function) = fast_fn {
+    builder.build_fast(scope, &[fast_function])
   } else {
     builder.build(scope)
   };

core/runtime/bindings.rs

@@ -39,7 +39,6 @@ use crate::modules::ModuleMap;
 use crate::modules::ModuleName;
 use crate::modules::RequestedModuleType;
 use crate::modules::ValidateImportAttributesCb;
-use crate::ops::FastFunctionInfo;
 use crate::ops_metrics::dispatch_metrics_async;
 use crate::ops_metrics::OpMetricsFactoryFn;
 use crate::runtime::ContextState;
@@ -152,7 +151,6 @@ pub(crate) struct InnerIsolateState {
   main_realm: ManuallyDrop<JsRealm>,
   pub(crate) state: ManuallyDropRc<JsRuntimeState>,
   v8_isolate: ManuallyDrop<v8::OwnedIsolate>,
-  fast_fn_infos: Vec<FastFunctionInfo>,
 }
 
 impl InnerIsolateState {
@@ -220,20 +218,6 @@ impl Drop for InnerIsolateState {
         ManuallyDrop::drop(&mut self.v8_isolate);
       }
     }
-    // Free the fast function infos manually.
-    for FastFunctionInfo {
-      fn_info,
-      fn_sig: (args, ret),
-    } in std::mem::take(&mut self.fast_fn_infos)
-    {
-      // SAFETY: We logically own these, and there are no remaining references because we just destroyed the
-      // realm and isolate above.
-      unsafe {
-        std::ptr::drop_in_place(fn_info.as_ptr());
-        std::ptr::drop_in_place(args.as_ptr());
-        std::ptr::drop_in_place(ret.as_ptr());
-      }
-    }
   }
 }
 
@@ -942,13 +926,6 @@ impl JsRuntime {
     }
     op_state.borrow_mut().put(isolate_ptr);
 
-    let mut fast_fn_infos = Vec::with_capacity(op_ctxs.len());
-    for op_ctx in &*op_ctxs {
-      if let Some(fast_fn_info) = op_ctx.fast_fn_info {
-        fast_fn_infos.push(fast_fn_info);
-      }
-    }
-
     // ...once ops and isolate are set up, we can create a `ContextState`...
     let context_state = Rc::new(ContextState::new(
       op_driver.clone(),
@@ -1107,7 +1084,6 @@ impl JsRuntime {
         main_realm: ManuallyDrop::new(main_realm),
         state: ManuallyDropRc(ManuallyDrop::new(state_rc)),
         v8_isolate: ManuallyDrop::new(isolate),
-        fast_fn_infos,
       },
       allocations: isolate_allocations,
       files_loaded_from_fs_during_snapshot: vec![],

core/runtime/jsruntime.rs

@@ -271,7 +271,7 @@ async fn server(
   let json_version_response = json!({
     "Browser": name,
     "Protocol-Version": "1.3",
-    "V8-Version": deno_core::v8_version(),
+    "V8-Version": deno_core::v8::VERSION_STRING,
   });
 
   // Create the server manually so it can use the Local Executor