Merge branch 'main' into f_cache_env_file

Author: marshallwalker

cli/lsp/diagnostics.rs

@@ -25,6 +25,7 @@ use deno_core::unsync::spawn_blocking;
 use deno_core::unsync::JoinHandle;
 use deno_core::url::Url;
 use deno_core::ModuleSpecifier;
+use deno_graph::source::ResolutionKind;
 use deno_graph::source::ResolveError;
 use deno_graph::Resolution;
 use deno_graph::ResolutionError;
@@ -40,6 +41,7 @@ use import_map::ImportMap;
 use import_map::ImportMapErrorKind;
 use log::error;
 use lsp_types::Uri;
+use node_resolver::NodeResolutionKind;
 use tokio::sync::mpsc;
 use tokio::sync::Mutex as AsyncMutex;
 use tokio::time::Duration;
@@ -1577,10 +1579,12 @@ fn maybe_ambient_specifier_resolution_err(
   }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn diagnose_resolution(
   snapshot: &language_server::StateSnapshot,
   dependency_key: &str,
   resolution: &Resolution,
+  resolution_kind: ResolutionKind,
   is_dynamic: bool,
   maybe_assert_type: Option<&str>,
   referrer_module: &DocumentModule,
@@ -1647,6 +1651,7 @@ fn diagnose_resolution(
             .npm_to_file_url(
               &pkg_ref,
               &referrer_module.specifier,
+              NodeResolutionKind::from_deno_graph(resolution_kind),
               referrer_module.resolution_mode,
             )
             .is_none()
@@ -1774,22 +1779,27 @@ fn diagnose_dependency(
         .includes(i.specifier_range.range.start)
         .is_some()
     });
-
+  let resolution;
+  let resolution_kind;
+  if dependency.maybe_code.is_none()
+  // If not @ts-types, diagnose the types if the code errored because
+  // it's likely resolving into the node_modules folder, which might be
+  // erroring correctly due to resolution only being for bundlers. Let this
+  // fail at runtime if necessary, but don't bother erroring in the editor
+  || !is_types_deno_types && matches!(dependency.maybe_type, Resolution::Ok(_))
+    && matches!(dependency.maybe_code, Resolution::Err(_))
+  {
+    resolution = &dependency.maybe_type;
+    resolution_kind = ResolutionKind::Types;
+  } else {
+    resolution = &dependency.maybe_code;
+    resolution_kind = ResolutionKind::Execution;
+  };
   let (resolution_diagnostics, deferred) = diagnose_resolution(
     snapshot,
     dependency_key,
-    if dependency.maybe_code.is_none()
-        // If not @ts-types, diagnose the types if the code errored because
-        // it's likely resolving into the node_modules folder, which might be
-        // erroring correctly due to resolution only being for bundlers. Let this
-        // fail at runtime if necessary, but don't bother erroring in the editor
-        || !is_types_deno_types && matches!(dependency.maybe_type, Resolution::Ok(_))
-          && matches!(dependency.maybe_code, Resolution::Err(_))
-    {
-      &dependency.maybe_type
-    } else {
-      &dependency.maybe_code
-    },
+    resolution,
+    resolution_kind,
     dependency.is_dynamic,
     dependency.maybe_attribute_type.as_deref(),
     referrer_module,
@@ -1825,6 +1835,7 @@ fn diagnose_dependency(
       snapshot,
       dependency_key,
       &dependency.maybe_type,
+      ResolutionKind::Types,
       dependency.is_dynamic,
       dependency.maybe_attribute_type.as_deref(),
       referrer_module,

cli/lsp/documents.rs

@@ -1633,8 +1633,12 @@ impl DocumentModules {
     let mut media_type = None;
     if let Ok(npm_ref) = NpmPackageReqReference::from_specifier(&specifier) {
       let scoped_resolver = self.resolver.get_scoped_resolver(scope);
-      let (s, mt) =
-        scoped_resolver.npm_to_file_url(&npm_ref, referrer, resolution_mode)?;
+      let (s, mt) = scoped_resolver.npm_to_file_url(
+        &npm_ref,
+        referrer,
+        NodeResolutionKind::Types,
+        resolution_mode,
+      )?;
       specifier = s;
       media_type = Some(mt);
     }

cli/lsp/resolver.rs

@@ -353,6 +353,7 @@ impl LspScopedResolver {
     &self,
     req_ref: &NpmPackageReqReference,
     referrer: &ModuleSpecifier,
+    resolution_kind: NodeResolutionKind,
     resolution_mode: ResolutionMode,
   ) -> Option<(ModuleSpecifier, MediaType)> {
     let npm_pkg_req_resolver = self.npm_pkg_req_resolver.as_ref()?;
@@ -363,7 +364,7 @@ impl LspScopedResolver {
           req_ref,
           referrer,
           resolution_mode,
-          NodeResolutionKind::Types,
+          resolution_kind,
         )
         .ok()?
         .into_url()

cli/lsp/tsc.rs

@@ -52,6 +52,7 @@ use lazy_regex::lazy_regex;
 use log::error;
 use lsp_types::Uri;
 use node_resolver::cache::NodeResolutionThreadLocalCache;
+use node_resolver::NodeResolutionKind;
 use node_resolver::ResolutionMode;
 use once_cell::sync::Lazy;
 use regex::Captures;
@@ -4875,6 +4876,7 @@ fn op_script_names(state: &mut OpState) -> ScriptNames {
           let Some((resolved, _)) = scoped_resolver.npm_to_file_url(
             &req_ref,
             scope,
+            NodeResolutionKind::Types,
             ResolutionMode::Import,
           ) else {
             lsp_log!("failed to resolve {req_ref} to file URL");

ext/canvas/01_image.js

@@ -250,7 +250,9 @@ function createImageBitmap(
     if (isBlob) {
       imageBitmapSource = 0;
       buf = new Uint8Array(await image.arrayBuffer());
-      const mimeTypeString = sniffImage(image.type);
+      // NOTE: The MIME type of image/svg+xml can't support
+      // https://github.com/whatwg/html/pull/10172
+      const mimeTypeString = sniffImage(null, buf);
 
       if (mimeTypeString === "image/png") {
         mimeType = 1;
@@ -280,17 +282,6 @@ function createImageBitmap(
             "InvalidStateError",
           ),
         );
-      } else if (mimeTypeString === "") {
-        return PromiseReject(
-          new DOMException(
-            `The MIME type of source image is not specified\n
-hint: When you want to get a "Blob" from "fetch", make sure to go through a file server that returns the appropriate content-type response header,
-      and specify the URL to the file server like "await(await fetch('http://localhost:8000/sample.png').blob()".
-      Alternatively, if you are reading a local file using 'Deno.readFile' etc.,
-      set the appropriate MIME type like "new Blob([await Deno.readFile('sample.png')], { type: 'image/png' })".\n`,
-            "InvalidStateError",
-          ),
-        );
       } else {
         return PromiseReject(
           new DOMException(

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/dgram.ts

@@ -20,9 +20,6 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-// TODO(petamoriken): enable prefer-primordials for node polyfills
-// deno-lint-ignore-file prefer-primordials
-
 import { lookup as defaultLookup } from "node:dns";
 import {
   isInt32,
@@ -33,6 +30,8 @@ import { ERR_SOCKET_BAD_TYPE } from "ext:deno_node/internal/errors.ts";
 import { UDP } from "ext:deno_node/internal_binding/udp_wrap.ts";
 import { guessHandleType } from "ext:deno_node/internal_binding/util.ts";
 import { codeMap } from "ext:deno_node/internal_binding/uv.ts";
+import { primordials } from "ext:core/mod.js";
+const { FunctionPrototypeBind, MapPrototypeGet, Symbol } = primordials;
 
 export type SocketType = "udp4" | "udp6";
 
@@ -75,15 +74,15 @@ export function newHandle(
   if (type === "udp4") {
     const handle = new UDP();
 
-    handle.lookup = lookup4.bind(handle, lookup);
+    handle.lookup = FunctionPrototypeBind(lookup4, handle, lookup);
 
     return handle;
   }
 
   if (type === "udp6") {
     const handle = new UDP();
 
-    handle.lookup = lookup6.bind(handle, lookup);
+    handle.lookup = FunctionPrototypeBind(lookup6, handle, lookup);
     handle.bind = handle.bind6;
     handle.connect = handle.connect6;
     handle.send = handle.send6;
@@ -108,11 +107,12 @@ export function _createSocketHandle(
     const type = guessHandleType(fd);
 
     if (type !== "UDP") {
-      err = codeMap.get("EINVAL")!;
+      err = MapPrototypeGet(codeMap, "EINVAL")!;
     } else {
       err = handle.open(fd);
     }
   } else if (port || address) {
+    // deno-lint-ignore prefer-primordials
     err = handle.bind(address, port || 0, flags);
   }