fix(check): move module not found errors to typescript diagnostics

Cargo.toml

@@ -53,7 +53,7 @@ deno_core = { version = "0.327.0" }
 deno_bench_util = { version = "0.178.0", path = "./bench_util" }
 deno_config = { version = "=0.42.0", features = ["workspace", "sync"] }
 deno_lockfile = "=0.24.0"
-deno_media_type = { version = "0.2.0", features = ["module_specifier"] }
+deno_media_type = { version = "0.2.3", features = ["module_specifier"] }
 deno_npm = "=0.27.0"
 deno_path_util = "=0.3.0"
 deno_permissions = { version = "0.43.0", path = "./runtime/permissions" }

cli/Cargo.toml

@@ -74,7 +74,7 @@ deno_config.workspace = true
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_doc = { version = "=0.161.3", features = ["rust", "comrak"] }
 deno_error.workspace = true
-deno_graph = { version = "=0.86.6" }
+deno_graph = { version = "=0.86.7" }
 deno_lint = { version = "=0.68.2", features = ["docs"] }
 deno_lockfile.workspace = true
 deno_npm.workspace = true

cli/errors.rs

@@ -26,51 +26,55 @@ fn get_diagnostic_class(_: &ParseDiagnostic) -> &'static str {
   "SyntaxError"
 }
 
-fn get_module_graph_error_class(err: &ModuleGraphError) -> &'static str {
-  use deno_graph::JsrLoadError;
-  use deno_graph::NpmLoadError;
-
+pub fn get_module_graph_error_class(err: &ModuleGraphError) -> &'static str {
   match err {
     ModuleGraphError::ResolutionError(err)
     | ModuleGraphError::TypesResolutionError(err) => {
       get_resolution_error_class(err)
     }
-    ModuleGraphError::ModuleError(err) => match err {
-      ModuleError::InvalidTypeAssertion { .. } => "SyntaxError",
-      ModuleError::ParseErr(_, diagnostic) => get_diagnostic_class(diagnostic),
-      ModuleError::WasmParseErr(..) => "SyntaxError",
-      ModuleError::UnsupportedMediaType { .. }
-      | ModuleError::UnsupportedImportAttributeType { .. } => "TypeError",
-      ModuleError::Missing(_, _) | ModuleError::MissingDynamic(_, _) => {
-        "NotFound"
-      }
-      ModuleError::LoadingErr(_, _, err) => match err {
-        ModuleLoadError::Loader(err) => get_error_class_name(err.as_ref()),
-        ModuleLoadError::HttpsChecksumIntegrity(_)
-        | ModuleLoadError::TooManyRedirects => "Error",
-        ModuleLoadError::NodeUnknownBuiltinModule(_) => "NotFound",
-        ModuleLoadError::Decode(_) => "TypeError",
-        ModuleLoadError::Npm(err) => match err {
-          NpmLoadError::NotSupportedEnvironment
-          | NpmLoadError::PackageReqResolution(_)
-          | NpmLoadError::RegistryInfo(_) => "Error",
-          NpmLoadError::PackageReqReferenceParse(_) => "TypeError",
-        },
-        ModuleLoadError::Jsr(err) => match err {
-          JsrLoadError::UnsupportedManifestChecksum
-          | JsrLoadError::PackageFormat(_) => "TypeError",
-          JsrLoadError::ContentLoadExternalSpecifier
-          | JsrLoadError::ContentLoad(_)
-          | JsrLoadError::ContentChecksumIntegrity(_)
-          | JsrLoadError::PackageManifestLoad(_, _)
-          | JsrLoadError::PackageVersionManifestChecksumIntegrity(..)
-          | JsrLoadError::PackageVersionManifestLoad(_, _)
-          | JsrLoadError::RedirectInPackage(_) => "Error",
-          JsrLoadError::PackageNotFound(_)
-          | JsrLoadError::PackageReqNotFound(_)
-          | JsrLoadError::PackageVersionNotFound(_)
-          | JsrLoadError::UnknownExport { .. } => "NotFound",
-        },
+    ModuleGraphError::ModuleError(err) => get_module_error_class(err),
+  }
+}
+
+pub fn get_module_error_class(err: &ModuleError) -> &'static str {
+  use deno_graph::JsrLoadError;
+  use deno_graph::NpmLoadError;
+
+  match err {
+    ModuleError::InvalidTypeAssertion { .. } => "SyntaxError",
+    ModuleError::ParseErr(_, diagnostic) => get_diagnostic_class(diagnostic),
+    ModuleError::WasmParseErr(..) => "SyntaxError",
+    ModuleError::UnsupportedMediaType { .. }
+    | ModuleError::UnsupportedImportAttributeType { .. } => "TypeError",
+    ModuleError::Missing(_, _) | ModuleError::MissingDynamic(_, _) => {
+      "NotFound"
+    }
+    ModuleError::LoadingErr(_, _, err) => match err {
+      ModuleLoadError::Loader(err) => get_error_class_name(err.as_ref()),
+      ModuleLoadError::HttpsChecksumIntegrity(_)
+      | ModuleLoadError::TooManyRedirects => "Error",
+      ModuleLoadError::NodeUnknownBuiltinModule(_) => "NotFound",
+      ModuleLoadError::Decode(_) => "TypeError",
+      ModuleLoadError::Npm(err) => match err {
+        NpmLoadError::NotSupportedEnvironment
+        | NpmLoadError::PackageReqResolution(_)
+        | NpmLoadError::RegistryInfo(_) => "Error",
+        NpmLoadError::PackageReqReferenceParse(_) => "TypeError",
+      },
+      ModuleLoadError::Jsr(err) => match err {
+        JsrLoadError::UnsupportedManifestChecksum
+        | JsrLoadError::PackageFormat(_) => "TypeError",
+        JsrLoadError::ContentLoadExternalSpecifier
+        | JsrLoadError::ContentLoad(_)
+        | JsrLoadError::ContentChecksumIntegrity(_)
+        | JsrLoadError::PackageManifestLoad(_, _)
+        | JsrLoadError::PackageVersionManifestChecksumIntegrity(..)
+        | JsrLoadError::PackageVersionManifestLoad(_, _)
+        | JsrLoadError::RedirectInPackage(_) => "Error",
+        JsrLoadError::PackageNotFound(_)
+        | JsrLoadError::PackageReqNotFound(_)
+        | JsrLoadError::PackageVersionNotFound(_)
+        | JsrLoadError::UnknownExport { .. } => "NotFound",
       },
     },
   }

cli/factory.rs

@@ -753,6 +753,7 @@ impl CliFactory {
           self.module_graph_builder().await?.clone(),
           self.node_resolver().await?.clone(),
           self.npm_resolver().await?.clone(),
+          self.sys(),
         )))
       })
       .await

cli/graph_util.rs

@@ -50,6 +50,7 @@ use crate::cache::ModuleInfoCache;
 use crate::cache::ParsedSourceCache;
 use crate::colors;
 use crate::errors::get_error_class_name;
+use crate::errors::get_module_graph_error_class;
 use crate::file_fetcher::CliFileFetcher;
 use crate::npm::CliNpmResolver;
 use crate::resolver::CjsTracker;
@@ -164,29 +165,15 @@ pub fn graph_walk_errors<'a>(
           roots.contains(error.specifier())
         }
       };
-      let mut message = match &error {
-        ModuleGraphError::ResolutionError(resolution_error) => {
-          enhanced_resolution_error_message(resolution_error)
-        }
-        ModuleGraphError::TypesResolutionError(resolution_error) => {
-          format!(
-            "Failed resolving types. {}",
-            enhanced_resolution_error_message(resolution_error)
-          )
-        }
-        ModuleGraphError::ModuleError(error) => {
-          enhanced_integrity_error_message(error)
-            .or_else(|| enhanced_sloppy_imports_error_message(sys, error))
-            .unwrap_or_else(|| format_deno_graph_error(error))
-        }
-      };
-
-      if let Some(range) = error.maybe_range() {
-        if !is_root && !range.specifier.as_str().contains("/$deno$eval") {
-          message.push_str("\n    at ");
-          message.push_str(&format_range_with_colors(range));
-        }
-      }
+      let message = enhance_graph_error(
+        sys,
+        &error,
+        if is_root {
+          EnhanceGraphErrorMode::HideRange
+        } else {
+          EnhanceGraphErrorMode::ShowRange
+        },
+      );
 
       if graph.graph_kind() == GraphKind::TypesOnly
         && matches!(
@@ -198,10 +185,61 @@ pub fn graph_walk_errors<'a>(
         return None;
       }
 
-      Some(custom_error(get_error_class_name(&error.into()), message))
+      if graph.graph_kind().include_types()
+        && (message.contains(RUN_WITH_SLOPPY_IMPORTS_MSG)
+          || matches!(
+            error,
+            ModuleGraphError::ModuleError(ModuleError::Missing(..))
+          ))
+      {
+        // ignore and let typescript surface this as a diagnostic instead
+        log::debug!("Ignoring: {}", message);
+        return None;
+      }
+
+      Some(custom_error(get_module_graph_error_class(&error), message))
     })
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum EnhanceGraphErrorMode {
+  ShowRange,
+  HideRange,
+}
+
+pub fn enhance_graph_error(
+  sys: &CliSys,
+  error: &ModuleGraphError,
+  mode: EnhanceGraphErrorMode,
+) -> String {
+  let mut message = match &error {
+    ModuleGraphError::ResolutionError(resolution_error) => {
+      enhanced_resolution_error_message(resolution_error)
+    }
+    ModuleGraphError::TypesResolutionError(resolution_error) => {
+      format!(
+        "Failed resolving types. {}",
+        enhanced_resolution_error_message(resolution_error)
+      )
+    }
+    ModuleGraphError::ModuleError(error) => {
+      enhanced_integrity_error_message(error)
+        .or_else(|| enhanced_sloppy_imports_error_message(sys, error))
+        .unwrap_or_else(|| format_deno_graph_error(error))
+    }
+  };
+
+  if let Some(range) = error.maybe_range() {
+    if mode == EnhanceGraphErrorMode::ShowRange
+      && !range.specifier.as_str().contains("/$deno$eval")
+    {
+      message.push_str("\n    at ");
+      message.push_str(&format_range_with_colors(range));
+    }
+  }
+  message
+}
+
 pub fn graph_exit_integrity_errors(graph: &ModuleGraph) {
   for error in graph.module_errors() {
     exit_for_integrity_error(error);
@@ -835,18 +873,19 @@ pub fn enhanced_resolution_error_message(error: &ResolutionError) -> String {
   message
 }
 
+static RUN_WITH_SLOPPY_IMPORTS_MSG: &str =
+  "or run with --unstable-sloppy-imports";
+
 fn enhanced_sloppy_imports_error_message(
   sys: &CliSys,
   error: &ModuleError,
 ) -> Option<String> {
   match error {
     ModuleError::LoadingErr(specifier, _, ModuleLoadError::Loader(_)) // ex. "Is a directory" error
     | ModuleError::Missing(specifier, _) => {
-      let additional_message = CliSloppyImportsResolver::new(SloppyImportsCachedFs::new(sys.clone()))
-        .resolve(specifier, SloppyImportsResolutionKind::Execution)?
-        .as_suggestion_message();
+      let additional_message = maybe_additional_sloppy_imports_message(sys, specifier)?;
       Some(format!(
-        "{} {} or run with --unstable-sloppy-imports",
+        "{} {}",
         error,
         additional_message,
       ))
@@ -855,6 +894,19 @@ fn enhanced_sloppy_imports_error_message(
   }
 }
 
+pub fn maybe_additional_sloppy_imports_message(
+  sys: &CliSys,
+  specifier: &ModuleSpecifier,
+) -> Option<String> {
+  Some(format!(
+    "{} {}",
+    CliSloppyImportsResolver::new(SloppyImportsCachedFs::new(sys.clone()))
+      .resolve(specifier, SloppyImportsResolutionKind::Execution)?
+      .as_suggestion_message(),
+    RUN_WITH_SLOPPY_IMPORTS_MSG
+  ))
+}
+
 fn enhanced_integrity_error_message(err: &ModuleError) -> Option<String> {
   match err {
     ModuleError::LoadingErr(

cli/module_loader.rs

@@ -36,6 +36,7 @@ use deno_graph::JsModule;
 use deno_graph::JsonModule;
 use deno_graph::Module;
 use deno_graph::ModuleGraph;
+use deno_graph::ModuleGraphError;
 use deno_graph::Resolution;
 use deno_graph::WasmModule;
 use deno_runtime::code_cache;
@@ -58,10 +59,13 @@ use crate::cache::CodeCache;
 use crate::cache::FastInsecureHasher;
 use crate::cache::ParsedSourceCache;
 use crate::emit::Emitter;
+use crate::errors::get_module_error_class;
 use crate::graph_container::MainModuleGraphContainer;
 use crate::graph_container::ModuleGraphContainer;
 use crate::graph_container::ModuleGraphUpdatePermit;
+use crate::graph_util::enhance_graph_error;
 use crate::graph_util::CreateGraphOptions;
+use crate::graph_util::EnhanceGraphErrorMode;
 use crate::graph_util::ModuleGraphBuilder;
 use crate::node::CliNodeCodeTranslator;
 use crate::node::CliNodeResolver;
@@ -703,7 +707,21 @@ impl<TGraphContainer: ModuleGraphContainer>
       unreachable!("Deno bug. {} was misconfigured internally.", specifier);
     }
 
-    match graph.get(specifier) {
+    let maybe_module = match graph.try_get(specifier) {
+      Ok(module) => module,
+      Err(err) => {
+        return Err(custom_error(
+          get_module_error_class(err),
+          enhance_graph_error(
+            &self.shared.sys,
+            &ModuleGraphError::ModuleError(err.clone()),
+            EnhanceGraphErrorMode::ShowRange,
+          ),
+        ))
+      }
+    };
+
+    match maybe_module {
       Some(deno_graph::Module::Json(JsonModule {
         source,
         media_type,