feat: V8 14.0

Cargo.toml

@@ -61,7 +61,7 @@ repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
 deno_ast = { version = "=0.50.0", features = ["transpiling"] }
-deno_core = { version = "0.356.0" }
+deno_core = { path = "../deno_core/core" }
 
 deno_cache_dir = "=0.25.0"
 deno_doc = "=0.183.0"

ext/ffi/dlfcn.rs

@@ -258,7 +258,9 @@ struct FunctionData {
   turbocall: Option<Turbocall>,
 }
 
-impl GarbageCollected for FunctionData {
+unsafe impl GarbageCollected for FunctionData {
+  fn trace(&self, _visitor: &mut v8::cppgc::Visitor) {}
+
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"FunctionData"
   }
@@ -315,6 +317,7 @@ fn sync_fn_impl<'s>(
     args.data(),
   )
   .unwrap();
+  let data = unsafe { data.as_ref() };
   let out_buffer = match data.symbol.result_type {
     NativeType::Struct(_) => {
       let argc = args.length();

ext/ffi/turbocall.rs

@@ -335,6 +335,9 @@ pub(crate) struct Turbocall {
   pub c_function_info: Box<fast_api::CFunctionInfo>,
 }
 
+unsafe impl Send for Turbocall {}
+unsafe impl Sync for Turbocall {}
+
 pub(crate) fn make_template(sym: &Symbol, trampoline: Trampoline) -> Turbocall {
   let param_info = std::iter::once(fast_api::Type::V8Value.as_info()) // Receiver
     .chain(sym.parameter_types.iter().map(|t| t.into()))

ext/net/ops.rs

@@ -452,7 +452,9 @@ pub struct NetPermToken {
   pub resolved_ips: Vec<String>,
 }
 
-impl deno_core::GarbageCollected for NetPermToken {
+unsafe impl deno_core::GarbageCollected for NetPermToken {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
+
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"NetPermToken"
   }

ext/net/quic.rs

@@ -31,6 +31,8 @@ use deno_core::ResourceId;
 use deno_core::WriteOutcome;
 use deno_core::error::ResourceError;
 use deno_core::op2;
+use deno_core::v8;
+use deno_core::v8::cppgc::GcCell;
 use deno_error::JsError;
 use deno_error::JsErrorBox;
 use deno_permissions::PermissionCheckError;
@@ -216,7 +218,8 @@ struct EndpointResource {
   session_store: Arc<dyn ClientSessionStore>,
 }
 
-impl GarbageCollected for EndpointResource {
+unsafe impl GarbageCollected for EndpointResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"EndpointResource"
   }
@@ -301,7 +304,8 @@ impl Drop for ListenerResource {
   }
 }
 
-impl GarbageCollected for ListenerResource {
+unsafe impl GarbageCollected for ListenerResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"ListenerResource"
   }
@@ -353,21 +357,20 @@ pub(crate) fn op_quic_endpoint_listen(
 
 struct ConnectionResource(
   quinn::Connection,
-  RefCell<Option<quinn::ZeroRttAccepted>>,
+  GcCell<Option<quinn::ZeroRttAccepted>>,
 );
 
-impl GarbageCollected for ConnectionResource {
+unsafe impl GarbageCollected for ConnectionResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"ConnectionResource"
   }
 }
 
-struct IncomingResource(
-  RefCell<Option<quinn::Incoming>>,
-  Arc<QuicServerConfig>,
-);
+struct IncomingResource(GcCell<Option<quinn::Incoming>>, Arc<QuicServerConfig>);
 
-impl GarbageCollected for IncomingResource {
+unsafe impl GarbageCollected for IncomingResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"IncomingResource"
   }
@@ -380,7 +383,7 @@ pub(crate) async fn op_quic_listener_accept(
 ) -> Result<IncomingResource, QuicError> {
   match resource.0.accept().await {
     Some(incoming) => Ok(IncomingResource(
-      RefCell::new(Some(incoming)),
+      GcCell::new(Some(incoming)),
       resource.1.clone(),
     )),
     None => Err(QuicError::BadResource("QuicListener")),
@@ -395,9 +398,10 @@ pub(crate) fn op_quic_listener_stop(#[cppgc] resource: &ListenerResource) {
 #[op2]
 #[string]
 pub(crate) fn op_quic_incoming_local_ip(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming_resource: &IncomingResource,
 ) -> Result<Option<String>, QuicError> {
-  let Some(incoming) = incoming_resource.0.borrow_mut().take() else {
+  let Some(incoming) = incoming_resource.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   Ok(incoming.local_ip().map(|ip| ip.to_string()))
@@ -406,9 +410,10 @@ pub(crate) fn op_quic_incoming_local_ip(
 #[op2]
 #[serde]
 pub(crate) fn op_quic_incoming_remote_addr(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming_resource: &IncomingResource,
 ) -> Result<Addr, QuicError> {
-  let Some(incoming) = incoming_resource.0.borrow_mut().take() else {
+  let Some(incoming) = incoming_resource.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   let addr = incoming.remote_address();
@@ -420,19 +425,21 @@ pub(crate) fn op_quic_incoming_remote_addr(
 
 #[op2(fast)]
 pub(crate) fn op_quic_incoming_remote_addr_validated(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming_resource: &IncomingResource,
 ) -> Result<bool, QuicError> {
-  let Some(incoming) = incoming_resource.0.borrow_mut().take() else {
+  let Some(incoming) = incoming_resource.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   Ok(incoming.remote_address_validated())
 }
 
 fn quic_incoming_accept(
+  isolate: &mut v8::Isolate,
   incoming_resource: &IncomingResource,
   transport_config: Option<TransportConfig>,
 ) -> Result<quinn::Connecting, QuicError> {
-  let Some(incoming) = incoming_resource.0.borrow_mut().take() else {
+  let Some(incoming) = incoming_resource.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   match transport_config {
@@ -449,24 +456,28 @@ fn quic_incoming_accept(
 #[op2(async)]
 #[cppgc]
 pub(crate) async fn op_quic_incoming_accept(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming_resource: &IncomingResource,
   #[serde] transport_config: Option<TransportConfig>,
 ) -> Result<ConnectionResource, QuicError> {
-  let connecting = quic_incoming_accept(incoming_resource, transport_config)?;
+  let connecting =
+    quic_incoming_accept(isolate, incoming_resource, transport_config)?;
   let conn = connecting.await?;
-  Ok(ConnectionResource(conn, RefCell::new(None)))
+  Ok(ConnectionResource(conn, GcCell::new(None)))
 }
 
 #[op2]
 #[cppgc]
 pub(crate) fn op_quic_incoming_accept_0rtt(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming_resource: &IncomingResource,
   #[serde] transport_config: Option<TransportConfig>,
 ) -> Result<ConnectionResource, QuicError> {
-  let connecting = quic_incoming_accept(incoming_resource, transport_config)?;
+  let connecting =
+    quic_incoming_accept(isolate, incoming_resource, transport_config)?;
   match connecting.into_0rtt() {
     Ok((conn, zrtt_accepted)) => {
-      Ok(ConnectionResource(conn, RefCell::new(Some(zrtt_accepted))))
+      Ok(ConnectionResource(conn, GcCell::new(Some(zrtt_accepted))))
     }
     Err(_connecting) => {
       unreachable!("0.5-RTT always succeeds");
@@ -477,9 +488,10 @@ pub(crate) fn op_quic_incoming_accept_0rtt(
 #[op2]
 #[serde]
 pub(crate) fn op_quic_incoming_refuse(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming: &IncomingResource,
 ) -> Result<(), QuicError> {
-  let Some(incoming) = incoming.0.borrow_mut().take() else {
+  let Some(incoming) = incoming.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   incoming.refuse();
@@ -489,18 +501,20 @@ pub(crate) fn op_quic_incoming_refuse(
 #[op2]
 #[serde]
 pub(crate) fn op_quic_incoming_ignore(
+  isolate: &mut v8::Isolate,
   #[cppgc] incoming: &IncomingResource,
 ) -> Result<(), QuicError> {
-  let Some(incoming) = incoming.0.borrow_mut().take() else {
+  let Some(incoming) = incoming.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicIncoming"));
   };
   incoming.ignore();
   Ok(())
 }
 
-struct ConnectingResource(RefCell<Option<quinn::Connecting>>);
+struct ConnectingResource(GcCell<Option<quinn::Connecting>>);
 
-impl GarbageCollected for ConnectingResource {
+unsafe impl GarbageCollected for ConnectingResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"ConnectingResource"
   }
@@ -604,33 +618,35 @@ where
     &args.server_name.unwrap_or(args.addr.hostname),
   )?;
 
-  Ok(ConnectingResource(RefCell::new(Some(connecting))))
+  Ok(ConnectingResource(GcCell::new(Some(connecting))))
 }
 
 #[op2(async)]
 #[cppgc]
 pub(crate) async fn op_quic_connecting_1rtt(
+  isolate: &mut v8::Isolate,
   #[cppgc] connecting: &ConnectingResource,
 ) -> Result<ConnectionResource, QuicError> {
-  let Some(connecting) = connecting.0.borrow_mut().take() else {
+  let Some(connecting) = connecting.0.get_mut(isolate).take() else {
     return Err(QuicError::BadResource("QuicConnecting"));
   };
   let conn = connecting.await?;
-  Ok(ConnectionResource(conn, RefCell::new(None)))
+  Ok(ConnectionResource(conn, GcCell::new(None)))
 }
 
 #[op2]
 #[cppgc]
 pub(crate) fn op_quic_connecting_0rtt(
+  isolate: &mut v8::Isolate,
   #[cppgc] connecting_res: &ConnectingResource,
 ) -> Option<ConnectionResource> {
-  let connecting = connecting_res.0.borrow_mut().take()?;
+  let connecting = connecting_res.0.get_mut(isolate).take()?;
   match connecting.into_0rtt() {
     Ok((conn, zrtt_accepted)) => {
-      Some(ConnectionResource(conn, RefCell::new(Some(zrtt_accepted))))
+      Some(ConnectionResource(conn, GcCell::new(Some(zrtt_accepted))))
     }
     Err(connecting) => {
-      *connecting_res.0.borrow_mut() = Some(connecting);
+      *connecting_res.0.get_mut(isolate) = Some(connecting);
       None
     }
   }
@@ -706,9 +722,10 @@ pub(crate) async fn op_quic_connection_closed(
 
 #[op2(async)]
 pub(crate) async fn op_quic_connection_handshake(
+  isolate: &mut v8::Isolate,
   #[cppgc] connection: &ConnectionResource,
 ) {
-  let Some(zrtt_accepted) = connection.1.borrow_mut().take() else {
+  let Some(zrtt_accepted) = connection.1.get_mut(isolate).take() else {
     return;
   };
   zrtt_accepted.await;

ext/node/ops/blocklist.rs

@@ -9,16 +9,19 @@ use std::net::SocketAddr;
 
 use deno_core::OpState;
 use deno_core::op2;
+use deno_core::v8;
+use deno_core::v8::cppgc::GcCell;
 use ipnetwork::IpNetwork;
 use ipnetwork::Ipv4Network;
 use ipnetwork::Ipv6Network;
 use serde::Serialize;
 
 pub struct BlockListResource {
-  blocklist: RefCell<BlockList>,
+  blocklist: GcCell<BlockList>,
 }
 
-impl deno_core::GarbageCollected for BlockListResource {
+unsafe impl deno_core::GarbageCollected for BlockListResource {
+  fn trace(&self, _visitor: &mut deno_core::v8::cppgc::Visitor) {}
   fn get_name(&self) -> &'static std::ffi::CStr {
     c"BlockListResource"
   }
@@ -82,43 +85,47 @@ pub fn op_socket_address_get_serialization(
 pub fn op_blocklist_new() -> BlockListResource {
   let blocklist = BlockList::new();
   BlockListResource {
-    blocklist: RefCell::new(blocklist),
+    blocklist: GcCell::new(blocklist),
   }
 }
 
 #[op2(fast)]
 pub fn op_blocklist_add_address(
+  isolate: &mut v8::Isolate,
   #[cppgc] wrap: &BlockListResource,
   #[string] addr: &str,
 ) -> Result<(), BlocklistError> {
-  wrap.blocklist.borrow_mut().add_address(addr)
+  wrap.blocklist.get_mut(isolate).add_address(addr)
 }
 
 #[op2(fast)]
 pub fn op_blocklist_add_range(
+  isolate: &mut v8::Isolate,
   #[cppgc] wrap: &BlockListResource,
   #[string] start: &str,
   #[string] end: &str,
 ) -> Result<bool, BlocklistError> {
-  wrap.blocklist.borrow_mut().add_range(start, end)
+  wrap.blocklist.get_mut(isolate).add_range(start, end)
 }
 
 #[op2(fast)]
 pub fn op_blocklist_add_subnet(
+  isolate: &mut v8::Isolate,
   #[cppgc] wrap: &BlockListResource,
   #[string] addr: &str,
   #[smi] prefix: u8,
 ) -> Result<(), BlocklistError> {
-  wrap.blocklist.borrow_mut().add_subnet(addr, prefix)
+  wrap.blocklist.get_mut(isolate).add_subnet(addr, prefix)
 }
 
 #[op2(fast)]
 pub fn op_blocklist_check(
+  isolate: &v8::Isolate,
   #[cppgc] wrap: &BlockListResource,
   #[string] addr: &str,
   #[string] r#type: &str,
 ) -> Result<bool, BlocklistError> {
-  wrap.blocklist.borrow().check(addr, r#type)
+  wrap.blocklist.get(isolate).check(addr, r#type)
 }
 
 struct BlockList {