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

…27533)

Instead of hard erroring, we now surface module not found errors as
TypeScript diagnostics (we have yet to show the source code of the
error, but something we can improve over time).

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,