refactor: use deno_graph for npm specifiers (#17858)

This changes npm specifiers to be handled by deno_graph and resolved to
an npm package name and version when the specifier is encountered. It
also slightly changes how npm specifier resolution occurs—previously it
would collect all the npm specifiers and resolve them all at once, but
now it resolves them on the fly as they are encountered in the module
graph.

https://github.com/denoland/deno_graph/pull/232

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

1 files changed, 47 insertions, 0 deletions

diff --git a/cli/npm/resolution/graph.rs b/cli/npm/resolution/graph.rs
index 966e1f010..87579dad3 100644
--- a/cli/npm/resolution/graph.rs
+++ b/cli/npm/resolution/graph.rs
@@ -159,6 +159,9 @@ impl ResolvedNodeIds {
   }
 }
 
+// todo(dsherret): for some reason the lsp errors when using an Rc<RefCell<NodeId>> here
+// instead of an Arc<Mutex<NodeId>>. We should investigate and fix.
+
 /// A pointer to a specific node in a graph path. The underlying node id
 /// may change as peer dependencies are created.
 #[derive(Clone, Debug)]
@@ -297,6 +300,8 @@ pub struct Graph {
   // This will be set when creating from a snapshot, then
   // inform the final snapshot creation.
   packages_to_copy_index: HashMap<NpmPackageId, usize>,
+  /// Packages that the resolver should resolve first.
+  pending_unresolved_packages: Vec<NpmPackageNv>,
 }
 
 impl Graph {
@@ -359,6 +364,7 @@ impl Graph {
         .map(|(id, p)| (id.clone(), p.copy_index))
         .collect(),
       package_reqs: snapshot.package_reqs,
+      pending_unresolved_packages: snapshot.pending_unresolved_packages,
       ..Default::default()
     };
     let mut created_package_ids =
@@ -375,10 +381,18 @@ impl Graph {
     Ok(graph)
   }
 
+  pub fn take_pending_unresolved(&mut self) -> Vec<NpmPackageNv> {
+    std::mem::take(&mut self.pending_unresolved_packages)
+  }
+
   pub fn has_package_req(&self, req: &NpmPackageReq) -> bool {
     self.package_reqs.contains_key(req)
   }
 
+  pub fn has_root_package(&self, id: &NpmPackageNv) -> bool {
+    self.root_packages.contains_key(id)
+  }
+
   fn get_npm_pkg_id(&self, node_id: NodeId) -> NpmPackageId {
     let resolved_id = self.resolved_node_ids.get(node_id).unwrap();
     self.get_npm_pkg_id_from_resolved_id(resolved_id, HashSet::new())
@@ -596,6 +610,7 @@ impl Graph {
         .collect(),
       packages,
       package_reqs: self.package_reqs,
+      pending_unresolved_packages: self.pending_unresolved_packages,
     })
   }
 
@@ -714,11 +729,43 @@ impl<'a> GraphDependencyResolver<'a> {
     }
   }
 
+  pub fn add_root_package(
+    &mut self,
+    package_nv: &NpmPackageNv,
+    package_info: &NpmPackageInfo,
+  ) -> Result<(), AnyError> {
+    if self.graph.root_packages.contains_key(package_nv) {
+      return Ok(()); // already added
+    }
+
+    // todo(dsherret): using a version requirement here is a temporary hack
+    // to reuse code in a large refactor. We should resolve the node directly
+    // from the package name and version
+    let version_req =
+      VersionReq::parse_from_specifier(&format!("{}", package_nv.version))
+        .unwrap();
+    let (pkg_id, node_id) = self.resolve_node_from_info(
+      &package_nv.name,
+      &version_req,
+      package_info,
+      None,
+    )?;
+    self.graph.root_packages.insert(pkg_id.clone(), node_id);
+    self
+      .pending_unresolved_nodes
+      .push_back(GraphPath::for_root(node_id, pkg_id));
+    Ok(())
+  }
+
   pub fn add_package_req(
     &mut self,
     package_req: &NpmPackageReq,
     package_info: &NpmPackageInfo,
   ) -> Result<(), AnyError> {
+    if self.graph.package_reqs.contains_key(package_req) {
+      return Ok(()); // already added
+    }
+
     let (pkg_id, node_id) = self.resolve_node_from_info(
       &package_req.name,
       package_req