chore: upgrade rusty_v8 to 0.67.0

Cargo.toml

@@ -43,7 +43,7 @@ license = "MIT"
 repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
-v8 = { version = "0.66.0", default-features = false }
+v8 = { version = "0.67.0", default-features = false }
 deno_ast = { version = "0.25.0", features = ["transpiling"] }
 
 deno_core = { version = "0.177.0", path = "./core" }

core/bindings.rs

@@ -44,7 +44,7 @@ pub(crate) fn external_references(ops: &[OpCtx]) -> v8::ExternalReferences {
     });
     if let Some(fast_fn) = &ctx.decl.fast_fn {
       references.push(v8::ExternalReference {
-        pointer: fast_fn.function() as _,
+        pointer: fast_fn.function as _,
       });
       references.push(v8::ExternalReference {
         pointer: ctx.fast_fn_c_info.unwrap().as_ptr() as _,
@@ -218,7 +218,7 @@ fn add_op_to_deno_core_ops(
   let templ = if let Some(fast_function) = &op_ctx.decl.fast_fn {
     builder.build_fast(
       scope,
-      &**fast_function,
+      fast_function,
       Some(op_ctx.fast_fn_c_info.unwrap().as_ptr()),
       None,
       None,

core/extensions.rs

@@ -72,8 +72,8 @@ pub struct OpDecl {
   pub is_async: bool,
   pub is_unstable: bool,
   pub is_v8: bool,
-  pub fast_fn: Option<Box<dyn FastFunction>>,
   pub force_registration: bool,
+  pub fast_fn: Option<FastFunction>,
 }
 
 impl OpDecl {

core/ops.rs

@@ -175,13 +175,13 @@ impl OpCtx {
     let mut fast_fn_c_info = None;
 
     if let Some(fast_fn) = &decl.fast_fn {
-      let args = CTypeInfo::new_from_slice(fast_fn.args());
-      let ret = CTypeInfo::new(fast_fn.return_type());
+      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())
+        CFunctionInfo::new(args.as_ptr(), fast_fn.args.len(), ret.as_ptr())
       };
       fast_fn_c_info = Some(c_fn);
     }

core/runtime.rs

@@ -793,8 +793,8 @@ impl JsRuntime {
         true => op,
         false => OpDecl {
           v8_fn_ptr: match op.is_async {
-            true => op_void_async::v8_fn_ptr(),
-            false => op_void_sync::v8_fn_ptr(),
+            true => op_void_async::v8_fn_ptr as _,
+            false => op_void_sync::v8_fn_ptr as _,
           },
           ..op
         },

ext/ffi/turbocall.rs

@@ -40,26 +40,29 @@ pub(crate) fn compile_trampoline(sym: &Symbol) -> Trampoline {
   }
 }
 
-pub(crate) fn make_template(sym: &Symbol, trampoline: &Trampoline) -> Template {
+pub(crate) fn make_template(
+  sym: &Symbol,
+  trampoline: &Trampoline,
+) -> fast_api::FastFunction {
   let mut params = once(fast_api::Type::V8Value) // Receiver
     .chain(sym.parameter_types.iter().map(|t| t.into()))
     .collect::<Vec<_>>();
 
   let ret = if needs_unwrap(&sym.result_type) {
     params.push(fast_api::Type::TypedArray(fast_api::CType::Int32));
-    fast_api::Type::Void
+    fast_api::CType::Void
   } else if sym.result_type == NativeType::Buffer {
     // Buffer can be used as a return type and converts differently than in parameters.
-    fast_api::Type::Pointer
+    fast_api::CType::Pointer
   } else {
-    fast_api::Type::from(&sym.result_type)
+    fast_api::CType::from(&fast_api::Type::from(&sym.result_type))
   };
 
-  Template {
-    args: params.into_boxed_slice(),
-    ret: (&ret).into(),
-    symbol_ptr: trampoline.ptr(),
-  }
+  fast_api::FastFunction::new(
+    Box::leak(params.into_boxed_slice()),
+    ret,
+    trampoline.ptr(),
+  )
 }
 
 /// Trampoline for fast-call FFI functions
@@ -73,26 +76,6 @@ impl Trampoline {
   }
 }
 
-pub(crate) struct Template {
-  pub args: Box<[fast_api::Type]>,
-  pub ret: fast_api::CType,
-  pub symbol_ptr: *const c_void,
-}
-
-impl fast_api::FastFunction for Template {
-  fn function(&self) -> *const c_void {
-    self.symbol_ptr
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    Box::leak(self.args.clone())
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    self.ret
-  }
-}
-
 impl From<&NativeType> for fast_api::Type {
   fn from(native_type: &NativeType) -> Self {
     match native_type {

ext/flash/lib.rs

@@ -316,26 +316,16 @@ async fn op_flash_write_resource(
   Ok(())
 }
 
-pub struct RespondFast;
-
-impl fast_api::FastFunction for RespondFast {
-  fn function(&self) -> *const c_void {
-    op_flash_respond_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[
-      fast_api::Type::V8Value,
-      fast_api::Type::Uint32,
-      fast_api::Type::TypedArray(fast_api::CType::Uint8),
-      fast_api::Type::Bool,
-    ]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+pub const RESPOND_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[
+    fast_api::Type::V8Value,
+    fast_api::Type::Uint32,
+    fast_api::Type::TypedArray(fast_api::CType::Uint8),
+    fast_api::Type::Bool,
+  ],
+  fast_api::CType::Uint32,
+  op_flash_respond_fast as *const c_void,
+);
 
 fn flash_respond(
   ctx: &mut ServerContext,
@@ -468,21 +458,11 @@ fn next_request_sync(ctx: &mut ServerContext) -> u32 {
   ctx.next_token - offset
 }
 
-pub struct NextRequestFast;
-
-impl fast_api::FastFunction for NextRequestFast {
-  fn function(&self) -> *const c_void {
-    op_flash_next_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[fast_api::Type::V8Value]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+const NEXT_REQUEST_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[fast_api::Type::V8Value],
+  fast_api::CType::Uint32,
+  op_flash_next_fast as *const c_void,
+);
 
 unsafe fn op_flash_next_fast(recv: v8::Local<v8::Object>) -> u32 {
   let ptr =
@@ -491,21 +471,11 @@ unsafe fn op_flash_next_fast(recv: v8::Local<v8::Object>) -> u32 {
   next_request_sync(ctx)
 }
 
-pub struct GetMethodFast;
-
-impl fast_api::FastFunction for GetMethodFast {
-  fn function(&self) -> *const c_void {
-    op_flash_get_method_fast as *const c_void
-  }
-
-  fn args(&self) -> &'static [fast_api::Type] {
-    &[fast_api::Type::V8Value, fast_api::Type::Uint32]
-  }
-
-  fn return_type(&self) -> fast_api::CType {
-    fast_api::CType::Uint32
-  }
-}
+const GET_METHOD_FAST: fast_api::FastFunction = fast_api::FastFunction::new(
+  &[fast_api::Type::V8Value, fast_api::Type::Uint32],
+  fast_api::CType::Uint32,
+  op_flash_get_method_fast as *const c_void,
+);
 
 unsafe fn op_flash_get_method_fast(
   recv: v8::Local<v8::Object>,
@@ -549,7 +519,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &NextRequestFast, None, None, None);
+    let func = builder.build_fast(scope, &NEXT_REQUEST_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "nextRequest").unwrap();
@@ -572,7 +542,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &GetMethodFast, None, None, None);
+    let func = builder.build_fast(scope, &GET_METHOD_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "getMethod").unwrap();
@@ -610,7 +580,7 @@ fn op_flash_make_request<'scope>(
     )
     .data(v8::External::new(scope, ctx as *mut _).into());
 
-    let func = builder.build_fast(scope, &RespondFast, None, None, None);
+    let func = builder.build_fast(scope, &RESPOND_FAST, None, None, None);
     let func: v8::Local<v8::Value> = func.get_function(scope).unwrap().into();
 
     let key = v8::String::new(scope, "respond").unwrap();