Merge branch 'main' into patch-repl-1

Author: CyanChanges

ext/fetch/dns.rs

@@ -3,6 +3,7 @@ use std::future::Future;
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
+use std::sync::Arc;
 use std::task::Poll;
 use std::task::{self};
 use std::vec;
@@ -19,6 +20,24 @@ pub enum Resolver {
   Gai(GaiResolver),
   /// hickory-resolver's userspace resolver.
   Hickory(hickory_resolver::Resolver<TokioConnectionProvider>),
+  /// A custom resolver that implements `Resolve`.
+  Custom(Arc<dyn Resolve>),
+}
+
+/// Alias for the `Future` type returned by a custom DNS resolver.
+// The future has to be `Send` as `tokio::spawn` is used to execute the future.
+pub type Resolving =
+  Pin<Box<dyn Future<Output = Result<SocketAddrs, io::Error>> + Send>>;
+
+/// A trait for customizing DNS resolution in ext/fetch.
+// The resolver needs to be `Send` and `Sync` for two reasons. One is it is
+// wrapped inside an `Arc` and will be cloned and moved to an async block to
+// perfrom DNS resolution. That async block will be executed by `tokio::spawn`,
+// so to make that async block `Send`, `Arc<dyn Resolve>` needs to be
+// `Send`. The other is `Resolver` needs to be `Send` to make the wrapping
+// `HttpConnector` `Send`.
+pub trait Resolve: Send + Sync + std::fmt::Debug {
+  fn resolve(&self, name: Name) -> Resolving;
 }
 
 impl Default for Resolver {
@@ -107,7 +126,43 @@ impl Service<Name> for Resolver {
           Ok(iter)
         })
       }
+      Resolver::Custom(resolver) => {
+        let resolver = resolver.clone();
+        tokio::spawn(async move { resolver.resolve(name).await })
+      }
     };
     ResolveFut { inner: task }
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use std::str::FromStr;
+
+  use super::*;
+
+  // A resolver that resolves any name into the same address.
+  #[derive(Debug)]
+  struct DebugResolver(SocketAddr);
+
+  impl Resolve for DebugResolver {
+    fn resolve(&self, _name: Name) -> Resolving {
+      let addr = self.0;
+      Box::pin(async move { Ok(vec![addr].into_iter()) })
+    }
+  }
+
+  #[tokio::test]
+  async fn custom_dns_resolver() {
+    let mut resolver = Resolver::Custom(Arc::new(DebugResolver(
+      "127.0.0.1:8080".parse().unwrap(),
+    )));
+    let mut addr = resolver
+      .call(Name::from_str("foo.com").unwrap())
+      .await
+      .unwrap();
+
+    let addr = addr.next().unwrap();
+    assert_eq!(addr, "127.0.0.1:8080".parse().unwrap());
+  }
+}

ext/net/01_net.js

@@ -27,6 +27,7 @@ import {
   op_net_recv_unixpacket,
   op_net_send_udp,
   op_net_send_unixpacket,
+  op_net_set_broadcast_udp,
   op_net_set_multi_loopback_udp,
   op_net_set_multi_ttl_udp,
   op_set_keepalive,
@@ -377,6 +378,12 @@ class Listener {
   }
 }
 
+const _setBroadcast = Symbol("setBroadcast");
+
+function setDatagramBroadcast(conn, broadcast) {
+  return conn[_setBroadcast](broadcast);
+}
+
 class DatagramConn {
   #rid = 0;
   #addr = null;
@@ -393,6 +400,10 @@ class DatagramConn {
     return this.#addr;
   }
 
+  [_setBroadcast](broadcast) {
+    op_net_set_broadcast_udp(this.#rid, broadcast);
+  }
+
   async joinMulticastV4(addr, multiInterface) {
     await op_net_join_multi_v4_udp(
       this.#rid,
@@ -688,6 +699,7 @@ export {
   Listener,
   listenOptionApiName,
   resolveDns,
+  setDatagramBroadcast,
   TcpConn,
   UnixConn,
   UpgradedConn,

ext/net/lib.rs

@@ -156,6 +156,7 @@ deno_core::extension!(deno_net,
     ops::op_net_leave_multi_v6_udp,
     ops::op_net_set_multi_loopback_udp,
     ops::op_net_set_multi_ttl_udp,
+    ops::op_net_set_broadcast_udp,
     ops::op_dns_resolve<P>,
     ops::op_set_nodelay,
     ops::op_set_keepalive,

ext/net/ops.rs

@@ -390,6 +390,23 @@ pub async fn op_net_set_multi_ttl_udp(
   Ok(())
 }
 
+#[op2(async)]
+pub async fn op_net_set_broadcast_udp(
+  state: Rc<RefCell<OpState>>,
+  #[smi] rid: ResourceId,
+  broadcast: bool,
+) -> Result<(), NetError> {
+  let resource = state
+    .borrow_mut()
+    .resource_table
+    .get::<UdpSocketResource>(rid)
+    .map_err(|_| NetError::SocketClosed)?;
+  let socket = RcRef::map(&resource, |r| &r.socket).borrow().await;
+  socket.set_broadcast(broadcast)?;
+
+  Ok(())
+}
+
 /// If this token is present in op_net_connect_tcp call and
 /// the hostname matches with one of the resolved IPs, then
 /// the permission check is performed against the original hostname.

ext/node/lib.rs

@@ -458,6 +458,7 @@ deno_core::extension!(deno_node,
     ops::require::op_require_package_imports_resolve<P, TInNpmPackageChecker, TNpmPackageFolderResolver, TSys>,
     ops::require::op_require_break_on_next_statement,
     ops::util::op_node_guess_handle_type,
+    ops::util::op_node_view_has_buffer,
     ops::worker_threads::op_worker_threads_filename<P, TSys>,
     ops::ipc::op_node_child_ipc_pipe,
     ops::ipc::op_node_ipc_write,

ext/node/ops/util.rs

@@ -1,6 +1,7 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 
 use deno_core::op2;
+use deno_core::v8;
 use deno_core::OpState;
 use deno_core::ResourceHandle;
 use deno_core::ResourceHandleFd;
@@ -80,3 +81,8 @@ fn guess_handle_type(handle: ResourceHandleFd) -> HandleType {
     _ => HandleType::Unknown,
   }
 }
+
+#[op2(fast)]
+pub fn op_node_view_has_buffer(buffer: v8::Local<v8::ArrayBufferView>) -> bool {
+  buffer.has_buffer()
+}

ext/node/polyfills/internal_binding/udp_wrap.ts

@@ -300,8 +300,13 @@ export class UDP extends HandleWrap {
     return this.#doSend(req, bufs, count, args, AF_INET6);
   }
 
-  setBroadcast(_bool: 0 | 1): number {
-    notImplemented("udp.UDP.prototype.setBroadcast");
+  setBroadcast(bool: 0 | 1): number {
+    if (!this.#listener) {
+      return codeMap.get("EBADF")!;
+    }
+
+    net.setDatagramBroadcast(this.#listener, bool === 1);
+    return 0;
   }
 
   setMulticastInterface(_interfaceAddress: string): number {

ext/node/polyfills/internal_binding/util.ts

@@ -28,7 +28,10 @@
 // TODO(petamoriken): enable prefer-primordials for node polyfills
 // deno-lint-ignore-file prefer-primordials
 
-import { op_node_guess_handle_type } from "ext:core/ops";
+import {
+  op_node_guess_handle_type,
+  op_node_view_has_buffer,
+} from "ext:core/ops";
 
 const handleTypes = ["TCP", "TTY", "UDP", "FILE", "PIPE", "UNKNOWN"];
 export function guessHandleType(fd: number): string {
@@ -128,3 +131,9 @@ export function getOwnNonIndexProperties(
   }
   return result;
 }
+
+export function arrayBufferViewHasBuffer(
+  view: ArrayBufferView,
+): boolean {
+  return op_node_view_has_buffer(view);
+}

tests/node_compat/config.jsonc

@@ -24,6 +24,7 @@
       "test-blocklist.js",
       "test-buffer-alloc.js",
       "test-buffer-arraybuffer.js",
+      "test-buffer-backing-arraybuffer.js",
       "test-buffer-includes.js",
       "test-buffer-indexof.js",
       "test-buffer-tostring-range.js",
@@ -448,6 +449,7 @@
       "test-dgram-send-invalid-msg-type.js",
       "test-dgram-send-multi-buffer-copy.js",
       "test-dgram-send-multi-string-array.js",
+      "test-dgram-setBroadcast.js",
       "test-dgram-udp4.js",
       "test-dgram-udp6-send-default-host.js",
       "test-dgram-unref.js",

tests/node_compat/runner/TODO.md

@@ -1,7 +1,7 @@
 <!-- deno-fmt-ignore-file -->
 # Remaining Node Tests
 
-1163 tests out of 3993 have been ported from Node 23.9.0 (29.13% ported, 71.40% remaining).
+1164 tests out of 3993 have been ported from Node 23.9.0 (29.15% ported, 71.37% remaining).
 
 NOTE: This file should not be manually edited. Please edit `tests/node_compat/config.json` and run `deno task setup` in `tests/node_compat/runner` dir instead.
 
@@ -282,7 +282,6 @@ NOTE: This file should not be manually edited. Please edit `tests/node_compat/co
 - [parallel/test-blocklist-clone.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-blocklist-clone.js)
 - [parallel/test-bootstrap-modules.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-bootstrap-modules.js)
 - [parallel/test-broadcastchannel-custom-inspect.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-broadcastchannel-custom-inspect.js)
-- [parallel/test-buffer-backing-arraybuffer.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-buffer-backing-arraybuffer.js)
 - [parallel/test-buffer-compare.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-buffer-compare.js)
 - [parallel/test-buffer-constructor-deprecation-error.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-buffer-constructor-deprecation-error.js)
 - [parallel/test-buffer-constructor-node-modules-paths.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-buffer-constructor-node-modules-paths.js)
@@ -626,7 +625,6 @@ NOTE: This file should not be manually edited. Please edit `tests/node_compat/co
 - [parallel/test-dgram-send-empty-packet.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-send-empty-packet.js)
 - [parallel/test-dgram-send-queue-info.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-send-queue-info.js)
 - [parallel/test-dgram-sendto.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-sendto.js)
-- [parallel/test-dgram-setBroadcast.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-setBroadcast.js)
 - [parallel/test-dgram-setTTL.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-setTTL.js)
 - [parallel/test-dgram-udp6-link-local-address.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-udp6-link-local-address.js)
 - [parallel/test-dgram-unref-in-cluster.js](https://github.com/nodejs/node/tree/v23.9.0/test/parallel/test-dgram-unref-in-cluster.js)

tests/node_compat/test/parallel/test-buffer-backing-arraybuffer.js

@@ -0,0 +1,45 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// Taken from Node 23.9.0
+// This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
+
+// Flags: --expose-internals
+'use strict';
+require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const { arrayBufferViewHasBuffer } = internalBinding('util');
+
+// All ABs in Deno are not on heap.
+const tests = [
+  { length: 0, expectOnHeap: false },
+  { length: 48, expectOnHeap: false },
+  { length: 96, expectOnHeap: false },
+  { length: 1024, expectOnHeap: false },
+];
+
+for (const { length, expectOnHeap } of tests) {
+  const arrays = [
+    new Uint8Array(length),
+    new Uint16Array(length / 2),
+    new Uint32Array(length / 4),
+    new Float32Array(length / 4),
+    new Float64Array(length / 8),
+    Buffer.alloc(length),
+    Buffer.allocUnsafeSlow(length),
+    // Buffer.allocUnsafe() is missing because it may use pooled allocations.
+  ];
+
+  for (const array of arrays) {
+    const isOnHeap = !arrayBufferViewHasBuffer(array);
+    assert.strictEqual(isOnHeap, expectOnHeap,
+                       `mismatch: ${isOnHeap} vs ${expectOnHeap} ` +
+                       `for ${array.constructor.name}, length = ${length}`);
+
+    // Consistency check: Accessing .buffer should create it.
+    array.buffer; // eslint-disable-line no-unused-expressions
+    assert(arrayBufferViewHasBuffer(array));
+  }
+}

tests/node_compat/test/parallel/test-dgram-setBroadcast.js

@@ -0,0 +1,32 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// Taken from Node 23.9.0
+// This file is automatically generated by `tests/node_compat/runner/setup.ts`. Do not modify this file manually.
+
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const dgram = require('dgram');
+
+{
+  // Should throw EBADF if the socket is never bound.
+  const socket = dgram.createSocket('udp4');
+
+  assert.throws(() => {
+    socket.setBroadcast(true);
+  }, /^Error: setBroadcast EBADF$/);
+}
+
+{
+  // Can call setBroadcast() after binding the socket.
+  const socket = dgram.createSocket('udp4');
+
+  socket.bind(0, common.mustCall(() => {
+    socket.setBroadcast(true);
+    socket.setBroadcast(false);
+    socket.close();
+  }));
+}