refactor(resolver): move more resolution code into deno_resolver (#26873)

Follow-up to cjs refactor.

This moves most of the resolution code into the deno_resolver crate.
Still pending is the npm resolution code.

1 files changed, 66 insertions, 28 deletions

diff --git a/cli/factory.rs b/cli/factory.rs
index 5cb2dd7b3..7949a83a5 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -42,8 +42,9 @@ use crate::npm::CliNpmResolverCreateOptions;
 use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::npm::CreateInNpmPkgCheckerOptions;
 use crate::resolver::CjsTracker;
+use crate::resolver::CliDenoResolver;
 use crate::resolver::CliDenoResolverFs;
-use crate::resolver::CliNodeResolver;
+use crate::resolver::CliNpmReqResolver;
 use crate::resolver::CliResolver;
 use crate::resolver::CliResolverOptions;
 use crate::resolver::CliSloppyImportsResolver;
@@ -71,6 +72,9 @@ use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
 use deno_core::FeatureChecker;
 
+use deno_resolver::npm::NpmReqResolverOptions;
+use deno_resolver::DenoResolverOptions;
+use deno_resolver::NodeAndNpmReqResolver;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node::DenoFsNodeResolverEnv;
 use deno_runtime::deno_node::NodeResolver;
@@ -126,7 +130,7 @@ impl RootCertStoreProvider for CliRootCertStoreProvider {
   }
 }
 
-struct Deferred<T>(once_cell::unsync::OnceCell<T>);
+pub struct Deferred<T>(once_cell::unsync::OnceCell<T>);
 
 impl<T> Default for Deferred<T> {
   fn default() -> Self {
@@ -175,9 +179,9 @@ struct CliFactoryServices {
   blob_store: Deferred<Arc<BlobStore>>,
   caches: Deferred<Arc<Caches>>,
   cjs_tracker: Deferred<Arc<CjsTracker>>,
-  cli_node_resolver: Deferred<Arc<CliNodeResolver>>,
   cli_options: Deferred<Arc<CliOptions>>,
   code_cache: Deferred<Arc<CodeCache>>,
+  deno_resolver: Deferred<Arc<CliDenoResolver>>,
   emit_cache: Deferred<Arc<EmitCache>>,
   emitter: Deferred<Arc<Emitter>>,
   feature_checker: Deferred<Arc<FeatureChecker>>,
@@ -197,6 +201,7 @@ struct CliFactoryServices {
   node_code_translator: Deferred<Arc<CliNodeCodeTranslator>>,
   node_resolver: Deferred<Arc<NodeResolver>>,
   npm_cache_dir: Deferred<Arc<NpmCacheDir>>,
+  npm_req_resolver: Deferred<Arc<CliNpmReqResolver>>,
   npm_resolver: Deferred<Arc<dyn CliNpmResolver>>,
   parsed_source_cache: Deferred<Arc<ParsedSourceCache>>,
   permission_desc_parser: Deferred<Arc<RuntimePermissionDescriptorParser>>,
@@ -523,6 +528,31 @@ impl CliFactory {
       .await
   }
 
+  pub async fn deno_resolver(&self) -> Result<&Arc<CliDenoResolver>, AnyError> {
+    self
+      .services
+      .deno_resolver
+      .get_or_try_init_async(async {
+        let cli_options = self.cli_options()?;
+        Ok(Arc::new(CliDenoResolver::new(DenoResolverOptions {
+          in_npm_pkg_checker: self.in_npm_pkg_checker()?.clone(),
+          node_and_req_resolver: if cli_options.no_npm() {
+            None
+          } else {
+            Some(NodeAndNpmReqResolver {
+              node_resolver: self.node_resolver().await?.clone(),
+              npm_req_resolver: self.npm_req_resolver().await?.clone(),
+            })
+          },
+          sloppy_imports_resolver: self.sloppy_imports_resolver()?.cloned(),
+          workspace_resolver: self.workspace_resolver().await?.clone(),
+          is_byonm: cli_options.use_byonm(),
+          maybe_vendor_dir: cli_options.vendor_dir_path(),
+        })))
+      })
+      .await
+  }
+
   pub async fn resolver(&self) -> Result<&Arc<CliResolver>, AnyError> {
     self
       .services
@@ -531,17 +561,14 @@ impl CliFactory {
         async {
           let cli_options = self.cli_options()?;
           Ok(Arc::new(CliResolver::new(CliResolverOptions {
-            sloppy_imports_resolver: self.sloppy_imports_resolver()?.cloned(),
-            node_resolver: Some(self.cli_node_resolver().await?.clone()),
             npm_resolver: if cli_options.no_npm() {
               None
             } else {
               Some(self.npm_resolver().await?.clone())
             },
-            workspace_resolver: self.workspace_resolver().await?.clone(),
             bare_node_builtins_enabled: cli_options
               .unstable_bare_node_builtins(),
-            maybe_vendor_dir: cli_options.vendor_dir_path(),
+            deno_resolver: self.deno_resolver().await?.clone(),
           })))
         }
         .boxed_local(),
@@ -624,7 +651,11 @@ impl CliFactory {
           Ok(Arc::new(NodeResolver::new(
             DenoFsNodeResolverEnv::new(self.fs().clone()),
             self.in_npm_pkg_checker()?.clone(),
-            self.npm_resolver().await?.clone().into_npm_resolver(),
+            self
+              .npm_resolver()
+              .await?
+              .clone()
+              .into_npm_pkg_folder_resolver(),
             self.pkg_json_resolver().clone(),
           )))
         }
@@ -656,13 +687,36 @@ impl CliFactory {
           DenoFsNodeResolverEnv::new(self.fs().clone()),
           self.in_npm_pkg_checker()?.clone(),
           node_resolver,
-          self.npm_resolver().await?.clone().into_npm_resolver(),
+          self
+            .npm_resolver()
+            .await?
+            .clone()
+            .into_npm_pkg_folder_resolver(),
           self.pkg_json_resolver().clone(),
         )))
       })
       .await
   }
 
+  pub async fn npm_req_resolver(
+    &self,
+  ) -> Result<&Arc<CliNpmReqResolver>, AnyError> {
+    self
+      .services
+      .npm_req_resolver
+      .get_or_try_init_async(async {
+        let npm_resolver = self.npm_resolver().await?;
+        Ok(Arc::new(CliNpmReqResolver::new(NpmReqResolverOptions {
+          byonm_resolver: (npm_resolver.clone()).into_maybe_byonm(),
+          fs: CliDenoResolverFs(self.fs().clone()),
+          in_npm_pkg_checker: self.in_npm_pkg_checker()?.clone(),
+          node_resolver: self.node_resolver().await?.clone(),
+          npm_req_resolver: npm_resolver.clone().into_npm_req_resolver(),
+        })))
+      })
+      .await
+  }
+
   pub fn pkg_json_resolver(&self) -> &Arc<PackageJsonResolver> {
     self.services.pkg_json_resolver.get_or_init(|| {
       Arc::new(PackageJsonResolver::new(DenoFsNodeResolverEnv::new(
@@ -799,23 +853,6 @@ impl CliFactory {
     })
   }
 
-  pub async fn cli_node_resolver(
-    &self,
-  ) -> Result<&Arc<CliNodeResolver>, AnyError> {
-    self
-      .services
-      .cli_node_resolver
-      .get_or_try_init_async(async {
-        Ok(Arc::new(CliNodeResolver::new(
-          self.fs().clone(),
-          self.in_npm_pkg_checker()?.clone(),
-          self.node_resolver().await?.clone(),
-          self.npm_resolver().await?.clone(),
-        )))
-      })
-      .await
-  }
-
   pub fn permission_desc_parser(
     &self,
   ) -> Result<&Arc<RuntimePermissionDescriptorParser>, AnyError> {
@@ -880,7 +917,6 @@ impl CliFactory {
     let fs = self.fs();
     let node_resolver = self.node_resolver().await?;
     let npm_resolver = self.npm_resolver().await?;
-    let cli_node_resolver = self.cli_node_resolver().await?;
     let cli_npm_resolver = self.npm_resolver().await?.clone();
     let in_npm_pkg_checker = self.in_npm_pkg_checker()?;
     let maybe_file_watcher_communicator = if cli_options.has_hmr() {
@@ -891,6 +927,7 @@ impl CliFactory {
     let node_code_translator = self.node_code_translator().await?;
     let cjs_tracker = self.cjs_tracker()?.clone();
     let pkg_json_resolver = self.pkg_json_resolver().clone();
+    let npm_req_resolver = self.npm_req_resolver().await?;
 
     Ok(CliMainWorkerFactory::new(
       self.blob_store().clone(),
@@ -918,7 +955,8 @@ impl CliFactory {
         self.main_module_graph_container().await?.clone(),
         self.module_load_preparer().await?.clone(),
         node_code_translator.clone(),
-        cli_node_resolver.clone(),
+        node_resolver.clone(),
+        npm_req_resolver.clone(),
         cli_npm_resolver.clone(),
         NpmModuleLoader::new(
           self.cjs_tracker()?.clone(),