Merge branch 'main' into f_cache_env_file

Author: marshallwalker

Cargo.lock

@@ -53,7 +53,7 @@ license = "MIT"
 repository = "https://github.com/denoland/deno"
 
 [workspace.dependencies]
-deno_ast = { version = "=0.46.6", features = ["transpiling"] }
+deno_ast = { version = "=0.46.7", features = ["transpiling"] }
 deno_core = { version = "0.346.0" }
 
 deno_cache_dir = "=0.20.0"

Cargo.toml

@@ -38,7 +38,6 @@ use deno_resolver::factory::DenoDirPathProviderOptions;
 use deno_resolver::factory::NpmProcessStateOptions;
 use deno_resolver::factory::ResolverFactoryOptions;
 use deno_resolver::factory::SpecifiedImportMapProvider;
-use deno_resolver::graph::FoundPackageJsonDepFlag;
 use deno_resolver::npm::managed::NpmResolutionCell;
 use deno_resolver::npm::DenoInNpmPackageChecker;
 use deno_resolver::workspace::WorkspaceResolver;
@@ -103,7 +102,6 @@ use crate::npm::NpmResolutionInitializer;
 use crate::npm::WorkspaceNpmPatchPackages;
 use crate::resolver::on_resolve_diagnostic;
 use crate::resolver::CliCjsTracker;
-use crate::resolver::CliDenoResolver;
 use crate::resolver::CliNpmGraphResolver;
 use crate::resolver::CliNpmReqResolver;
 use crate::resolver::CliResolver;
@@ -315,7 +313,6 @@ struct CliFactoryServices {
   eszip_module_loader_provider: Deferred<Arc<EszipModuleLoaderProvider>>,
   feature_checker: Deferred<Arc<FeatureChecker>>,
   file_fetcher: Deferred<Arc<CliFileFetcher>>,
-  found_pkg_json_dep_flag: Arc<FoundPackageJsonDepFlag>,
   fs: Deferred<Arc<dyn deno_fs::FileSystem>>,
   http_client_provider: Deferred<Arc<HttpClientProvider>>,
   main_graph_container: Deferred<Arc<MainModuleGraphContainer>>,
@@ -337,7 +334,6 @@ struct CliFactoryServices {
   parsed_source_cache: Deferred<Arc<ParsedSourceCache>>,
   permission_desc_parser:
     Deferred<Arc<RuntimePermissionDescriptorParser<CliSys>>>,
-  resolver: Deferred<Arc<CliResolver>>,
   resolver_factory: Deferred<Arc<CliResolverFactory>>,
   root_cert_store_provider: Deferred<Arc<dyn RootCertStoreProvider>>,
   root_permissions_container: Deferred<PermissionsContainer>,
@@ -615,7 +611,10 @@ impl CliFactory {
           let cli_options = self.cli_options()?;
           Ok(Arc::new(CliNpmGraphResolver::new(
             self.npm_installer_if_managed().await?.cloned(),
-            self.services.found_pkg_json_dep_flag.clone(),
+            self
+              .resolver_factory()?
+              .found_package_json_dep_flag()
+              .clone(),
             cli_options.default_npm_caching_strategy(),
           )))
         }
@@ -811,28 +810,11 @@ impl CliFactory {
     self.resolver_factory()?.workspace_resolver().await
   }
 
-  pub async fn deno_resolver(&self) -> Result<&Arc<CliDenoResolver>, AnyError> {
+  pub async fn resolver(&self) -> Result<&Arc<CliResolver>, AnyError> {
     self.initialize_npm_resolution_if_managed().await?;
     self.resolver_factory()?.deno_resolver().await
   }
 
-  pub async fn resolver(&self) -> Result<&Arc<CliResolver>, AnyError> {
-    self
-      .services
-      .resolver
-      .get_or_try_init_async(
-        async {
-          Ok(Arc::new(CliResolver::new(
-            self.deno_resolver().await?.clone(),
-            self.services.found_pkg_json_dep_flag.clone(),
-            Box::new(on_resolve_diagnostic),
-          )))
-        }
-        .boxed_local(),
-      )
-      .await
-  }
-
   pub fn maybe_file_watcher_reporter(&self) -> &Option<FileWatcherReporter> {
     let maybe_file_watcher_reporter = self
       .watcher_communicator
@@ -1418,6 +1400,9 @@ impl CliFactory {
           })),
           bare_node_builtins: self.flags.unstable_config.bare_node_builtins,
           unstable_sloppy_imports: self.flags.unstable_config.sloppy_imports,
+          on_mapped_resolution_diagnostic: Some(Arc::new(
+            on_resolve_diagnostic,
+          )),
           package_json_cache: Some(Arc::new(
             node_resolver::PackageJsonThreadLocalCache,
           )),

cli/factory.rs

@@ -77,7 +77,6 @@ use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::npm::NpmResolutionInitializer;
 use crate::npm::WorkspaceNpmPatchPackages;
 use crate::resolver::on_resolve_diagnostic;
-use crate::resolver::CliDenoResolver;
 use crate::resolver::CliIsCjsResolver;
 use crate::resolver::CliNpmReqResolver;
 use crate::resolver::CliResolver;
@@ -913,45 +912,49 @@ impl<'a> ResolverFactory<'a> {
   pub fn cli_resolver(&self) -> &Arc<CliResolver> {
     self.services.cli_resolver.get_or_init(|| {
       let npm_req_resolver = self.npm_pkg_req_resolver().cloned();
-      let deno_resolver = Arc::new(CliDenoResolver::new(DenoResolverOptions {
-        in_npm_pkg_checker: self.in_npm_pkg_checker().clone(),
-        node_and_req_resolver: match (self.node_resolver(), npm_req_resolver) {
-          (Some(node_resolver), Some(npm_req_resolver)) => {
-            Some(NodeAndNpmReqResolver {
-              node_resolver: node_resolver.clone(),
-              npm_req_resolver,
-            })
-          }
-          _ => None,
-        },
-        workspace_resolver: self
-          .config_data
-          .map(|d| d.resolver.clone())
-          .unwrap_or_else(|| {
-            Arc::new(WorkspaceResolver::new_raw(
-              // this is fine because this is only used before initialization
-              Arc::new(ModuleSpecifier::parse("file:///").unwrap()),
-              None,
-              Vec::new(),
-              Vec::new(),
-              PackageJsonDepResolution::Disabled,
-              Default::default(),
-              Default::default(),
-              Default::default(),
-              Default::default(),
-              self.sys.clone(),
-            ))
-          }),
-        bare_node_builtins: self
-          .config_data
-          .is_some_and(|d| d.unstable.contains("bare-node-builtins")),
-        is_byonm: self.config_data.map(|d| d.byonm).unwrap_or(false),
-        maybe_vendor_dir: self.config_data.and_then(|d| d.vendor_dir.as_ref()),
-      }));
+      let deno_resolver =
+        Arc::new(deno_resolver::RawDenoResolver::new(DenoResolverOptions {
+          in_npm_pkg_checker: self.in_npm_pkg_checker().clone(),
+          node_and_req_resolver: match (self.node_resolver(), npm_req_resolver)
+          {
+            (Some(node_resolver), Some(npm_req_resolver)) => {
+              Some(NodeAndNpmReqResolver {
+                node_resolver: node_resolver.clone(),
+                npm_req_resolver,
+              })
+            }
+            _ => None,
+          },
+          workspace_resolver: self
+            .config_data
+            .map(|d| d.resolver.clone())
+            .unwrap_or_else(|| {
+              Arc::new(WorkspaceResolver::new_raw(
+                // this is fine because this is only used before initialization
+                Arc::new(ModuleSpecifier::parse("file:///").unwrap()),
+                None,
+                Vec::new(),
+                Vec::new(),
+                PackageJsonDepResolution::Disabled,
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                Default::default(),
+                self.sys.clone(),
+              ))
+            }),
+          bare_node_builtins: self
+            .config_data
+            .is_some_and(|d| d.unstable.contains("bare-node-builtins")),
+          is_byonm: self.config_data.map(|d| d.byonm).unwrap_or(false),
+          maybe_vendor_dir: self
+            .config_data
+            .and_then(|d| d.vendor_dir.as_ref()),
+        }));
       Arc::new(CliResolver::new(
         deno_resolver,
         self.services.found_pkg_json_dep_flag.clone(),
-        Box::new(on_resolve_diagnostic),
+        Some(Arc::new(on_resolve_diagnostic)),
       ))
     })
   }

cli/lsp/resolver.rs

@@ -73,10 +73,10 @@ pub fn get_edits(a: &str, b: &str, line_index: &LineIndex) -> Vec<TextEdit> {
   if a == b {
     return vec![];
   }
-  // Heuristic to detect things like minified files. `diff()` is expensive.
-  if b.chars().filter(|c| *c == '\n').count()
-    > line_index.inner.utf8_offsets_len() * 3
-  {
+  // Heuristic to detect things like large JSON or minified files. `diff()` is
+  // expensive.
+  let b_lines = b.chars().filter(|c| *c == '\n').count();
+  if b_lines > 10000 || b_lines > line_index.inner.utf8_offsets_len() * 3 {
     return vec![TextEdit {
       range: lsp::Range {
         start: lsp::Position::new(0, 0),

cli/lsp/text.rs

@@ -4554,12 +4554,20 @@ fn op_load<'s>(
   } else {
     state.get_module(&specifier)
   };
-  let maybe_load_response = module.as_ref().map(|m| LoadResponse {
-    data: m.text.clone(),
-    script_kind: crate::tsc::as_ts_script_kind(m.media_type),
-    version: state.script_version(&specifier),
-    is_cjs: m.resolution_mode == ResolutionMode::Require,
-    is_classic_script: m.notebook_uri.is_some(),
+  let maybe_load_response = module.as_ref().map(|m| {
+    let data = if m.media_type == MediaType::Json && m.text.len() > 10_000_000 {
+      // VSCode's TS server types large JSON files this way.
+      DocumentText::Static("{}\n")
+    } else {
+      m.text.clone()
+    };
+    LoadResponse {
+      data,
+      script_kind: crate::tsc::as_ts_script_kind(m.media_type),
+      version: state.script_version(&specifier),
+      is_cjs: m.resolution_mode == ResolutionMode::Require,
+      is_classic_script: m.notebook_uri.is_some(),
+    }
   });
   let serialized = serde_v8::to_v8(scope, maybe_load_response)?;
   state.performance.measure(mark);

cli/lsp/tsc.rs

@@ -3,7 +3,6 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use deno_ast::ModuleSpecifier;
 use deno_error::JsErrorBox;
 use deno_graph::NpmLoadError;
 use deno_graph::NpmResolvePkgReqsResult;
@@ -23,36 +22,28 @@ pub type CliCjsTracker =
   deno_resolver::cjs::CjsTracker<DenoInNpmPackageChecker, CliSys>;
 pub type CliIsCjsResolver =
   deno_resolver::cjs::IsCjsResolver<DenoInNpmPackageChecker, CliSys>;
-pub type CliDenoResolver = deno_resolver::DenoResolver<
-  DenoInNpmPackageChecker,
-  DenoIsBuiltInNodeModuleChecker,
-  CliNpmResolver,
-  CliSys,
->;
 pub type CliNpmReqResolver = deno_resolver::npm::NpmReqResolver<
   DenoInNpmPackageChecker,
   DenoIsBuiltInNodeModuleChecker,
   CliNpmResolver,
   CliSys,
 >;
-pub type CliResolver = deno_resolver::graph::DenoGraphResolver<
+pub type CliResolver = deno_resolver::graph::DenoResolver<
   DenoInNpmPackageChecker,
   DenoIsBuiltInNodeModuleChecker,
   CliNpmResolver,
   CliSys,
 >;
 
 pub fn on_resolve_diagnostic(
-  diagnostic: &deno_resolver::workspace::MappedResolutionDiagnostic,
-  referrer: &ModuleSpecifier,
-  position: deno_graph::Position,
+  diagnostic: deno_resolver::graph::MappedResolutionDiagnosticWithPosition,
 ) {
   log::warn!(
     "{} {}\n    at {}:{}",
     deno_runtime::colors::yellow("Warning"),
-    diagnostic,
-    referrer,
-    position,
+    diagnostic.diagnostic,
+    diagnostic.referrer,
+    diagnostic.start
   );
 }
 

cli/resolver.rs

@@ -5671,7 +5671,7 @@ declare namespace Deno {
    * @category FFI
    */
   export type FromNativeType<T extends NativeType = NativeType> = T extends
-    NativeStructType ? Uint8Array
+    NativeStructType ? Uint8Array<ArrayBuffer>
     : T extends NativeNumberType ? T extends NativeU8Enum<infer U> ? U
       : T extends NativeI8Enum<infer U> ? U
       : T extends NativeU16Enum<infer U> ? U
@@ -5696,7 +5696,7 @@ declare namespace Deno {
    */
   export type FromNativeResultType<
     T extends NativeResultType = NativeResultType,
-  > = T extends NativeStructType ? Uint8Array
+  > = T extends NativeStructType ? Uint8Array<ArrayBuffer>
     : T extends NativeNumberType ? T extends NativeU8Enum<infer U> ? U
       : T extends NativeI8Enum<infer U> ? U
       : T extends NativeU16Enum<infer U> ? U

cli/tsc/dts/lib.deno.ns.d.ts

@@ -1,9 +1,6 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 // Copyright Node.js contributors. All rights reserved. MIT License.
 
-// TODO(petamoriken): enable prefer-primordials for node polyfills
-// deno-lint-ignore-file prefer-primordials
-
 import { TextDecoder, TextEncoder } from "ext:deno_web/08_text_encoding.js";
 import { existsSync } from "ext:deno_node/_fs/_fs_exists.ts";
 import { mkdir, mkdirSync } from "ext:deno_node/_fs/_fs_mkdir.ts";
@@ -12,6 +9,18 @@ import {
   ERR_INVALID_OPT_VALUE_ENCODING,
 } from "ext:deno_node/internal/errors.ts";
 import { promisify } from "ext:deno_node/internal/util.mjs";
+import { primordials } from "ext:core/mod.js";
+
+const {
+  ObjectPrototypeIsPrototypeOf,
+  Array,
+  SafeArrayIterator,
+  MathRandom,
+  MathFloor,
+  ArrayPrototypeJoin,
+  ArrayPrototypeMap,
+  ObjectPrototype,
+} = primordials;
 
 export type mkdtempCallback = (
   err: Error | null,
@@ -70,10 +79,13 @@ function parseEncoding(
   optionsOrCallback?: { encoding: string } | string | mkdtempCallback,
 ): string | undefined {
   let encoding: string | undefined;
-  if (typeof optionsOrCallback == "function") encoding = undefined;
-  else if (optionsOrCallback instanceof Object) {
-    encoding = optionsOrCallback?.encoding;
-  } else encoding = optionsOrCallback;
+  if (typeof optionsOrCallback === "function") {
+    encoding = undefined;
+  } else if (isOptionsObject(optionsOrCallback)) {
+    encoding = optionsOrCallback.encoding;
+  } else {
+    encoding = optionsOrCallback;
+  }
 
   if (encoding) {
     try {
@@ -97,9 +109,13 @@ function decode(str: string, encoding?: string): string {
 
 const CHARS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 function randomName(): string {
-  return [...Array(6)].map(() =>
-    CHARS[Math.floor(Math.random() * CHARS.length)]
-  ).join("");
+  return ArrayPrototypeJoin(
+    ArrayPrototypeMap(
+      [...new SafeArrayIterator(Array(6))],
+      () => CHARS[MathFloor(MathRandom() * CHARS.length)],
+    ),
+    "",
+  );
 }
 
 function tempDirPath(prefix: string): string {
@@ -110,3 +126,11 @@ function tempDirPath(prefix: string): string {
 
   return path;
 }
+
+function isOptionsObject(value: unknown): value is { encoding: string } {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    ObjectPrototypeIsPrototypeOf(ObjectPrototype, value)
+  );
+}