refactor: deno_graph 0.43 upgrade (#17692)

1 files changed, 55 insertions, 76 deletions

diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs
index d9f1bad9b..c9ff4668a 100644
--- a/cli/tsc/mod.rs
+++ b/cli/tsc/mod.rs
@@ -1,8 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
 use crate::args::TsConfig;
-use crate::graph_util::GraphData;
-use crate::graph_util::ModuleEntry;
 use crate::node;
 use crate::node::node_resolve_npm_reference;
 use crate::node::NodeResolution;
@@ -16,7 +14,6 @@ use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::located_script_name;
 use deno_core::op;
-use deno_core::parking_lot::RwLock;
 use deno_core::resolve_url_or_path;
 use deno_core::serde::Deserialize;
 use deno_core::serde::Deserializer;
@@ -32,7 +29,9 @@ use deno_core::ModuleSpecifier;
 use deno_core::OpState;
 use deno_core::RuntimeOptions;
 use deno_core::Snapshot;
-use deno_graph::Resolved;
+use deno_graph::ModuleGraph;
+use deno_graph::ModuleKind;
+use deno_graph::ResolutionResolved;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::permissions::PermissionsContainer;
 use once_cell::sync::Lazy;
@@ -342,7 +341,7 @@ pub struct Request {
   pub config: TsConfig,
   /// Indicates to the tsc runtime if debug logging should occur.
   pub debug: bool,
-  pub graph_data: Arc<RwLock<GraphData>>,
+  pub graph: Arc<ModuleGraph>,
   pub hash_data: Vec<Vec<u8>>,
   pub maybe_config_specifier: Option<ModuleSpecifier>,
   pub maybe_npm_resolver: Option<NpmPackageResolver>,
@@ -365,7 +364,7 @@ pub struct Response {
 #[derive(Debug, Default)]
 struct State {
   hash_data: Vec<Vec<u8>>,
-  graph_data: Arc<RwLock<GraphData>>,
+  graph: Arc<ModuleGraph>,
   maybe_config_specifier: Option<ModuleSpecifier>,
   maybe_tsbuildinfo: Option<String>,
   maybe_response: Option<RespondArgs>,
@@ -376,7 +375,7 @@ struct State {
 
 impl State {
   pub fn new(
-    graph_data: Arc<RwLock<GraphData>>,
+    graph: Arc<ModuleGraph>,
     hash_data: Vec<Vec<u8>>,
     maybe_config_specifier: Option<ModuleSpecifier>,
     maybe_npm_resolver: Option<NpmPackageResolver>,
@@ -386,7 +385,7 @@ impl State {
   ) -> Self {
     State {
       hash_data,
-      graph_data,
+      graph,
       maybe_config_specifier,
       maybe_npm_resolver,
       maybe_tsbuildinfo,
@@ -466,15 +465,12 @@ struct ExistsArgs {
 #[op]
 fn op_exists(state: &mut OpState, args: ExistsArgs) -> bool {
   let state = state.borrow_mut::<State>();
-  let graph_data = state.graph_data.read();
+  let graph = &state.graph;
   if let Ok(specifier) = normalize_specifier(&args.specifier) {
     if specifier.scheme() == "asset" || specifier.scheme() == "data" {
       true
     } else {
-      matches!(
-        graph_data.get(&graph_data.follow_redirect(&specifier)),
-        Some(ModuleEntry::Module { .. })
-      )
+      graph.get(&specifier).is_some()
     }
   } else {
     false
@@ -517,7 +513,7 @@ fn op_load(state: &mut OpState, args: Value) -> Result<Value, AnyError> {
     .context("Error converting a string module specifier for \"op_load\".")?;
   let mut hash: Option<String> = None;
   let mut media_type = MediaType::Unknown;
-  let graph_data = state.graph_data.read();
+  let graph = &state.graph;
   let data = if &v.specifier == "internal:///.tsbuildinfo" {
     state.maybe_tsbuildinfo.as_deref().map(Cow::Borrowed)
   // in certain situations we return a "blank" module to tsc and we need to
@@ -541,15 +537,9 @@ fn op_load(state: &mut OpState, args: Value) -> Result<Value, AnyError> {
     } else {
       &specifier
     };
-    let maybe_source = if let Some(ModuleEntry::Module {
-      code,
-      media_type: mt,
-      ..
-    }) =
-      graph_data.get(&graph_data.follow_redirect(specifier))
-    {
-      media_type = *mt;
-      Some(Cow::Borrowed(code as &str))
+    let maybe_source = if let Some(module) = graph.get(specifier) {
+      media_type = module.media_type;
+      module.maybe_source.as_ref().map(|s| Cow::Borrowed(&**s))
     } else if state
       .maybe_npm_resolver
       .as_ref()
@@ -623,40 +613,40 @@ fn op_resolve(
       continue;
     }
 
-    let graph_data = state.graph_data.read();
-    let resolved_dep = match graph_data.get_dependencies(&referrer) {
-      Some(dependencies) => dependencies.get(&specifier).map(|d| {
-        if matches!(d.maybe_type, Resolved::Ok { .. }) {
-          &d.maybe_type
+    let graph = &state.graph;
+    let resolved_dep = match graph.get(&referrer).map(|m| &m.dependencies) {
+      Some(dependencies) => dependencies.get(&specifier).and_then(|d| {
+        if let Some(type_resolution) = d.maybe_type.ok() {
+          Some(type_resolution)
+        } else if let Some(code_resolution) = d.maybe_code.ok() {
+          Some(code_resolution)
         } else {
-          &d.maybe_code
+          None
         }
       }),
       None => None,
     };
+
     let maybe_result = match resolved_dep {
-      Some(Resolved::Ok { specifier, .. }) => {
-        let specifier = graph_data.follow_redirect(specifier);
-        match graph_data.get(&specifier) {
-          Some(ModuleEntry::Module {
-            media_type,
-            maybe_types,
-            ..
-          }) => match maybe_types {
-            Some(Resolved::Ok { specifier, .. }) => {
-              let types = graph_data.follow_redirect(specifier);
-              match graph_data.get(&types) {
-                Some(ModuleEntry::Module { media_type, .. }) => {
-                  Some((types, *media_type))
-                }
-                _ => None,
-              }
+      Some(ResolutionResolved { specifier, .. }) => {
+        let module = match graph.get(specifier) {
+          Some(module) => {
+            let maybe_types_dep = module
+              .maybe_types_dependency
+              .as_ref()
+              .map(|d| &d.dependency);
+            match maybe_types_dep.and_then(|d| d.maybe_specifier()) {
+              Some(specifier) => graph.get(specifier),
+              _ => Some(module),
             }
-            _ => Some((specifier, *media_type)),
-          },
-          _ => {
+          }
+          _ => None,
+        };
+        if let Some(module) = module {
+          if module.kind == ModuleKind::External {
             // handle npm:<package> urls
-            if let Ok(npm_ref) = NpmPackageReference::from_specifier(&specifier)
+            if let Ok(npm_ref) =
+              NpmPackageReference::from_specifier(&module.specifier)
             {
               if let Some(npm_resolver) = &state.maybe_npm_resolver {
                 Some(resolve_npm_package_reference_types(
@@ -669,7 +659,11 @@ fn op_resolve(
             } else {
               None
             }
+          } else {
+            Some((module.specifier.clone(), module.media_type))
           }
+        } else {
+          None
         }
       }
       _ => {
@@ -817,7 +811,7 @@ pub fn exec(request: Request) -> Result<Response, AnyError> {
       .ops(get_tsc_ops())
       .state(move |state| {
         state.put(State::new(
-          request.graph_data.clone(),
+          request.graph.clone(),
           request.hash_data.clone(),
           request.maybe_config_specifier.clone(),
           request.maybe_npm_resolver.clone(),
@@ -885,6 +879,7 @@ mod tests {
   use crate::args::TsConfig;
   use deno_core::futures::future;
   use deno_core::OpState;
+  use deno_graph::ModuleGraph;
   use std::fs;
 
   #[derive(Debug, Default)]
@@ -927,20 +922,12 @@ mod tests {
     let hash_data = maybe_hash_data.unwrap_or_else(|| vec![b"".to_vec()]);
     let fixtures = test_util::testdata_path().join("tsc2");
     let mut loader = MockLoader { fixtures };
-    let graph = deno_graph::create_graph(
-      vec![specifier],
-      &mut loader,
-      deno_graph::GraphOptions {
-        is_dynamic: false,
-        imports: None,
-        resolver: None,
-        module_analyzer: None,
-        reporter: None,
-      },
-    )
-    .await;
+    let mut graph = ModuleGraph::default();
+    graph
+      .build(vec![specifier], &mut loader, Default::default())
+      .await;
     let state = State::new(
-      Arc::new(RwLock::new((&graph).into())),
+      Arc::new(graph),
       hash_data,
       None,
       None,
@@ -959,18 +946,10 @@ mod tests {
     let hash_data = vec![b"something".to_vec()];
     let fixtures = test_util::testdata_path().join("tsc2");
     let mut loader = MockLoader { fixtures };
-    let graph = deno_graph::create_graph(
-      vec![specifier.clone()],
-      &mut loader,
-      deno_graph::GraphOptions {
-        is_dynamic: false,
-        imports: None,
-        resolver: None,
-        module_analyzer: None,
-        reporter: None,
-      },
-    )
-    .await;
+    let mut graph = ModuleGraph::default();
+    graph
+      .build(vec![specifier.clone()], &mut loader, Default::default())
+      .await;
     let config = TsConfig::new(json!({
       "allowJs": true,
       "checkJs": false,
@@ -991,7 +970,7 @@ mod tests {
     let request = Request {
       config,
       debug: false,
-      graph_data: Arc::new(RwLock::new((&graph).into())),
+      graph: Arc::new(graph),
       hash_data,
       maybe_config_specifier: None,
       maybe_npm_resolver: None,