fix(check): ignore errors on ambient modules

cli/graph_util.rs

@@ -47,6 +47,7 @@ use crate::args::deno_json::TsConfigResolver;
 use crate::args::jsr_url;
 use crate::args::CliLockfile;
 use crate::args::CliOptions;
+use crate::args::DenoSubcommand;
 pub use crate::args::NpmCachingStrategy;
 use crate::cache;
 use crate::cache::FetchCacher;
@@ -77,6 +78,7 @@ pub struct GraphValidOptions<'a> {
   /// Otherwise, surfaces integrity errors as errors.
   pub exit_integrity_errors: bool,
   pub allow_unknown_media_types: bool,
+  pub ignore_graph_errors: bool,
 }
 
 /// Check if `roots` and their deps are available. Returns `Ok(())` if
@@ -104,6 +106,7 @@ pub fn graph_valid(
       check_js: options.check_js,
       kind: options.kind,
       allow_unknown_media_types: options.allow_unknown_media_types,
+      ignore_graph_errors: options.ignore_graph_errors,
     },
   );
   if let Some(error) = errors.next() {
@@ -143,6 +146,7 @@ pub fn fill_graph_from_lockfile(
 pub struct GraphWalkErrorsOptions<'a> {
   pub check_js: CheckJsOption<'a>,
   pub kind: GraphKind,
+  pub ignore_graph_errors: bool,
   pub allow_unknown_media_types: bool,
 }
 
@@ -154,10 +158,41 @@ pub fn graph_walk_errors<'a>(
   roots: &'a [ModuleSpecifier],
   options: GraphWalkErrorsOptions<'a>,
 ) -> impl Iterator<Item = JsErrorBox> + 'a {
+  fn should_ignore_resolution_error_for_types(err: &ResolutionError) -> bool {
+    match err {
+      ResolutionError::ResolverError { error, .. } => match error.as_ref() {
+        ResolveError::Specifier(_) => true,
+        ResolveError::ImportMap(err) => matches!(
+          err.as_kind(),
+          import_map::ImportMapErrorKind::UnmappedBareSpecifier { .. }
+        ),
+        ResolveError::Other(_) => false,
+      },
+      _ => false,
+    }
+  }
+
+  fn should_ignore_module_graph_error_for_types(
+    err: &ModuleGraphError,
+  ) -> bool {
+    match err {
+      ModuleGraphError::ResolutionError(err) => {
+        should_ignore_resolution_error_for_types(err)
+      }
+      ModuleGraphError::TypesResolutionError(err) => {
+        should_ignore_resolution_error_for_types(err)
+      }
+      ModuleGraphError::ModuleError(module_error) => {
+        matches!(module_error, ModuleError::Missing { .. })
+      }
+    }
+  }
+
   fn should_ignore_error(
     sys: &CliSys,
     graph_kind: GraphKind,
     allow_unknown_media_types: bool,
+    ignore_graph_errors: bool,
     error: &ModuleGraphError,
   ) -> bool {
     if (graph_kind == GraphKind::TypesOnly || allow_unknown_media_types)
@@ -169,6 +204,11 @@ pub fn graph_walk_errors<'a>(
       return true;
     }
 
+    if ignore_graph_errors && should_ignore_module_graph_error_for_types(error)
+    {
+      return true;
+    }
+
     // surface these as typescript diagnostics instead
     graph_kind.include_types()
       && has_module_graph_error_for_tsc_diagnostic(sys, error)
@@ -190,6 +230,7 @@ pub fn graph_walk_errors<'a>(
         sys,
         graph.graph_kind(),
         options.allow_unknown_media_types,
+        options.ignore_graph_errors,
         &error,
       ) {
         log::debug!("Ignoring: {}", error);
@@ -968,6 +1009,10 @@ impl ModuleGraphBuilder {
         check_js: CheckJsOption::Custom(self.tsconfig_resolver.as_ref()),
         exit_integrity_errors: true,
         allow_unknown_media_types,
+        ignore_graph_errors: matches!(
+          self.cli_options.sub_command(),
+          DenoSubcommand::Check { .. }
+        ),
       },
     )
   }

cli/lsp/diagnostics.rs

@@ -70,6 +70,7 @@ use crate::tools::lint::CliLinter;
 use crate::tools::lint::CliLinterOptions;
 use crate::tools::lint::LintRuleProvider;
 use crate::tsc::DiagnosticCategory;
+use crate::type_checker::ambient_modules_to_regex_string;
 use crate::util::path::to_percent_decoded_str;
 
 pub type ScopedAmbientModules = HashMap<Option<Arc<Url>>, MaybeAmbientModules>;
@@ -457,19 +458,8 @@ impl DeferredDiagnostics {
           ambient.regex = None;
           continue;
         }
-        let mut regex_string = String::with_capacity(value.len() * 8);
-        regex_string.push('(');
-        let last = value.len() - 1;
-        for (idx, part) in value.into_iter().enumerate() {
-          let trimmed = part.trim_matches('"');
-          let escaped = regex::escape(trimmed);
-          let regex = escaped.replace("\\*", ".*");
-          regex_string.push_str(&regex);
-          if idx != last {
-            regex_string.push('|');
-          }
-        }
-        regex_string.push_str(")$");
+        let mut regex_string = ambient_modules_to_regex_string(&value);
+        regex_string.push('$');
         if let Ok(regex) = regex::Regex::new(&regex_string).inspect_err(|e| {
           lsp_warn!("failed to compile ambient modules pattern: {e} (pattern is {regex_string:?})");
         }) {

cli/lsp/language_server.rs

@@ -359,6 +359,7 @@ impl LanguageServer {
           check_js: CheckJsOption::False,
           exit_integrity_errors: false,
           allow_unknown_media_types: true,
+          ignore_graph_errors: true,
         },
       )?;
 

cli/tools/doc.rs

@@ -153,6 +153,7 @@ pub async fn doc(
           check_js: CheckJsOption::False,
           kind: GraphKind::TypesOnly,
           allow_unknown_media_types: false,
+          ignore_graph_errors: true,
         },
       );
       for error in errors {

cli/tsc/99_main_compiler.js

@@ -171,8 +171,10 @@ function exec({ config, debug: debugFlag, rootNames, localOnly }) {
 
   performanceProgram({ program });
 
+  const checker = program.getProgram().getTypeChecker();
   ops.op_respond({
     diagnostics: fromTypeScriptDiagnostics(diagnostics),
+    ambientModules: checker.getAmbientModules().map((symbol) => symbol.name),
     stats: performanceEnd(),
   });
   debug("<<< exec stop");

cli/tsc/diagnostics.rs

@@ -148,6 +148,8 @@ pub struct Diagnostic {
   pub reports_unnecessary: Option<bool>,
   #[serde(flatten)]
   pub other: deno_core::serde_json::Map<String, deno_core::serde_json::Value>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub missing_specifier: Option<String>,
 }
 
 impl Diagnostic {
@@ -180,6 +182,7 @@ impl Diagnostic {
       reports_deprecated: None,
       reports_unnecessary: None,
       other: Default::default(),
+      missing_specifier: Some(specifier.to_string()),
     }
   }
 

cli/tsc/mod.rs

@@ -476,6 +476,7 @@ pub struct Response {
   pub diagnostics: Diagnostics,
   /// If there was any build info associated with the exec request.
   pub maybe_tsbuildinfo: Option<String>,
+  pub ambient_modules: Vec<String>,
   /// Statistics from the check.
   pub stats: Stats,
 }
@@ -1209,8 +1210,10 @@ fn op_is_node_file(state: &mut OpState, #[string] path: &str) -> bool {
 }
 
 #[derive(Debug, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
 struct RespondArgs {
   pub diagnostics: Diagnostics,
+  pub ambient_modules: Vec<String>,
   pub stats: Stats,
 }
 
@@ -1449,11 +1452,13 @@ pub fn exec(
 
   if let Some(response) = state.maybe_response {
     let diagnostics = response.diagnostics;
+    let ambient_modules = response.ambient_modules;
     let maybe_tsbuildinfo = state.maybe_tsbuildinfo;
     let stats = response.stats;
 
     Ok(Response {
       diagnostics,
+      ambient_modules,
       maybe_tsbuildinfo,
       stats,
     })
@@ -1746,7 +1751,8 @@ mod tests {
           "code": 5023
         }
       ],
-      "stats": [["a", 12]]
+      "stats": [["a", 12]],
+      "ambientModules": []
     }))
     .unwrap();
     op_respond_inner(&mut state, args);
@@ -1771,7 +1777,9 @@ mod tests {
           reports_deprecated: None,
           reports_unnecessary: None,
           other: Default::default(),
+          missing_specifier: None,
         }]),
+        ambient_modules: vec![],
         stats: Stats(vec![("a".to_string(), 12)])
       })
     );

cli/type_checker.rs

@@ -424,6 +424,24 @@ impl Iterator for DiagnosticsByFolderRealIterator<'_> {
   }
 }
 
+/// Converts the list of ambient module names to regex string
+pub fn ambient_modules_to_regex_string(ambient_modules: &[String]) -> String {
+  let mut regex_string = String::with_capacity(ambient_modules.len() * 8);
+  regex_string.push('(');
+  let last = ambient_modules.len() - 1;
+  for (idx, part) in ambient_modules.iter().enumerate() {
+    let trimmed = part.trim_matches('"');
+    let escaped = regex::escape(trimmed);
+    let regex = escaped.replace("\\*", ".*");
+    regex_string.push_str(&regex);
+    if idx != last {
+      regex_string.push('|');
+    }
+  }
+  regex_string.push(')');
+  regex_string
+}
+
 impl<'a> DiagnosticsByFolderRealIterator<'a> {
   #[allow(clippy::too_many_arguments)]
   fn check_diagnostics_in_folder(
@@ -533,11 +551,31 @@ impl<'a> DiagnosticsByFolderRealIterator<'a> {
       code_cache,
     )?;
 
+    let ambient_modules = response.ambient_modules;
+    log::debug!("Ambient Modules: {:?}", ambient_modules);
+
+    let ambient_modules_regex = if ambient_modules.is_empty() {
+      None
+    } else {
+      regex::Regex::new(&ambient_modules_to_regex_string(&ambient_modules))
+        .inspect_err(|e| {
+          log::warn!("Failed to create regex for ambient modules: {}", e);
+        })
+        .ok()
+    };
+
     let mut response_diagnostics = response.diagnostics.filter(|d| {
       self.should_include_diagnostic(self.options.type_check_mode, d)
     });
     response_diagnostics.apply_fast_check_source_maps(&self.graph);
-    let mut diagnostics = missing_diagnostics;
+    let mut diagnostics = missing_diagnostics.filter(|d| {
+      if let Some(ambient_modules_regex) = &ambient_modules_regex {
+        if let Some(missing_specifier) = &d.missing_specifier {
+          return !ambient_modules_regex.is_match(missing_specifier);
+        }
+      }
+      true
+    });
     diagnostics.extend(response_diagnostics);
 
     if let Some(tsbuildinfo) = response.maybe_tsbuildinfo {
@@ -1005,6 +1043,7 @@ fn get_leading_comments(file_text: &str) -> Vec<String> {
 mod test {
   use deno_ast::MediaType;
 
+  use super::ambient_modules_to_regex_string;
   use super::get_leading_comments;
   use super::has_ts_check;
 
@@ -1050,4 +1089,14 @@ mod test {
       "// ts-check\nconsole.log(5);"
     ));
   }
+
+  #[test]
+  fn ambient_modules_to_regex_string_test() {
+    let result = ambient_modules_to_regex_string(&[
+      "foo".to_string(),
+      "*.css".to_string(),
+      "$virtual/module".to_string(),
+    ]);
+    assert_eq!(result, r"(foo|.*\.css|\$virtual/module)");
+  }
 }

tests/specs/check/ambient_modules/__test__.jsonc

@@ -0,0 +1,22 @@
+{
+  "steps": [{
+    "args": "check foo.ts",
+    "output": "foo.out"
+  }, {
+    "args": "check bar.ts",
+    "output": "bar.out",
+    "exitCode": 1
+  }, {
+    "args": "run foo.ts",
+    "output": "run.out",
+    "exitCode": 1
+  }, {
+    "args": "run bar.ts",
+    "output": "run.out",
+    "exitCode": 1
+  }, {
+    "args": "check bare_specifier.ts",
+    "output": "bare_specifier.out",
+    "exitCode": 1
+  }]
+}

tests/specs/check/ambient_modules/bar.out

@@ -0,0 +1,5 @@
+Check file:///[WILDLINE]/ambient_modules/bar.ts
+TS2307 [ERROR]: Cannot find module 'file:///[WILDLINE]logo.svg'.
+    at file:///[WILDLINE]/ambient_modules/bar.ts:1:18
+
+error: Type checking failed.

tests/specs/check/ambient_modules/bar.ts

@@ -0,0 +1,2 @@
+import logo from "/logo.svg";
+console.log(logo);

tests/specs/check/ambient_modules/bare_specifier.out

@@ -0,0 +1,3 @@
+error: Relative import path "foo" not prefixed with / or ./ or ../
+  hint: If you want to use a JSR or npm package, try running `deno add jsr:foo` or `deno add npm:foo`
+    at file:///[WILDLINE]bare_specifier.ts:1:8

tests/specs/check/ambient_modules/bare_specifier.ts

@@ -0,0 +1 @@
+import "foo";

tests/specs/check/ambient_modules/foo.out

@@ -0,0 +1 @@
+Check file:///[WILDLINE]/ambient_modules/foo.ts

tests/specs/check/ambient_modules/foo.ts

@@ -0,0 +1,5 @@
+/// <reference types="./modules.d.ts" />
+import logo from "/logo.svg";
+import "./global.css";
+import styles from "./styles.module.css";
+console.log(logo, styles.classes);

tests/specs/check/ambient_modules/modules.d.ts

@@ -0,0 +1,9 @@
+declare module "*.svg" {
+  const content: string;
+  export default content;
+}
+declare module "*.module.css" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module "*.css" {}

tests/specs/check/ambient_modules/run.out

@@ -0,0 +1,2 @@
+error: Module not found "file:///[WILDLINE]logo.svg".
+    at file:///[WILDLINE]/ambient_modules/[WILDLINE].ts:[WILDLINE]