feat: add warning-aware import diagnostics

Cargo.toml

@@ -34,6 +34,7 @@ anyhow = "1.0.79"
 if_chain = "1.0.2"
 phf = { version = "0.11.2", features = ["macros"] }
 deno_semver = "0.9.0"
+jsonc-parser = { version = "0.31.0", features = ["cst", "serde"] }
 
 [dev-dependencies]
 ansi_term = "0.12.1"

examples/dlint/diagnostics.rs

@@ -1,7 +1,7 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
 use deno_ast::diagnostics::Diagnostic;
-use deno_lint::diagnostic::LintDiagnostic;
+use deno_lint::diagnostic::{LintDiagnostic, LintDiagnosticSeverity};
 
 pub fn display_diagnostics(
   diagnostics: &[LintDiagnostic],
@@ -21,10 +21,11 @@ fn print_compact(diagnostics: &[LintDiagnostic]) {
         let display_index =
           range.text_info.line_and_column_display(range.range.start);
         eprintln!(
-          "{}: line {}, col {}, Error - {} ({})",
+          "{}: line {}, col {}, {} - {} ({})",
           diagnostic.specifier,
           display_index.line_number,
           display_index.column_number,
+          severity_label(diagnostic.severity()),
           diagnostic.details.message,
           diagnostic.details.code
         )
@@ -46,3 +47,10 @@ fn print_pretty(diagnostics: &[LintDiagnostic]) {
     eprintln!("{}\n", diagnostic.display());
   }
 }
+
+fn severity_label(severity: LintDiagnosticSeverity) -> &'static str {
+  match severity {
+    LintDiagnosticSeverity::Error => "Error",
+    LintDiagnosticSeverity::Warning => "Warning",
+  }
+}

examples/dlint/main.rs

@@ -8,6 +8,7 @@ use core::panic;
 use deno_ast::diagnostics::Diagnostic;
 use deno_ast::MediaType;
 use deno_ast::ModuleSpecifier;
+use deno_lint::diagnostic::LintDiagnosticSeverity;
 use deno_lint::linter::LintConfig;
 use deno_lint::linter::LintFileOptions;
 use deno_lint::linter::Linter;
@@ -86,7 +87,8 @@ fn run_linter(
     paths.extend(config.get_files()?);
   }
 
-  let error_counts = Arc::new(AtomicUsize::new(0));
+  let error_count = Arc::new(AtomicUsize::new(0));
+  let warning_count = Arc::new(AtomicUsize::new(0));
 
   let all_rules = get_all_rules();
   let all_rule_codes = all_rules
@@ -138,7 +140,18 @@ fn run_linter(
         external_linter: None,
       })?;
 
-      let mut number_of_errors = diagnostics.len();
+      let mut number_of_errors = diagnostics
+        .iter()
+        .filter(|diagnostic| {
+          diagnostic.severity() == LintDiagnosticSeverity::Error
+        })
+        .count();
+      let number_of_warnings = diagnostics
+        .iter()
+        .filter(|diagnostic| {
+          diagnostic.severity() == LintDiagnosticSeverity::Warning
+        })
+        .count();
       if !parsed_source.diagnostics().is_empty() {
         number_of_errors += parsed_source.diagnostics().to_vec().len();
         parsed_source.diagnostics().to_vec().iter().for_each(
@@ -148,7 +161,8 @@ fn run_linter(
         );
       }
 
-      error_counts.fetch_add(number_of_errors, Ordering::Relaxed);
+      error_count.fetch_add(number_of_errors, Ordering::Relaxed);
+      warning_count.fetch_add(number_of_warnings, Ordering::Relaxed);
 
       let mut lock = file_diagnostics.lock().unwrap();
 
@@ -161,19 +175,50 @@ fn run_linter(
     diagnostics::display_diagnostics(d, format);
   }
 
-  let err_count = error_counts.load(Ordering::Relaxed);
+  let err_count = error_count.load(Ordering::Relaxed);
+  let warn_count = warning_count.load(Ordering::Relaxed);
+  if err_count > 0 || warn_count > 0 {
+    eprintln!("{}", format_problem_counts(err_count, warn_count));
+  }
   if err_count > 0 {
-    eprintln!(
-      "Found {} problem{}",
-      err_count,
-      if err_count == 1 { "" } else { "s" }
-    );
     std::process::exit(1);
   }
 
   Ok(())
 }
 
+fn format_problem_counts(errors: usize, warnings: usize) -> String {
+  if warnings == 0 {
+    let total = errors;
+    return format!(
+      "Found {} problem{}",
+      total,
+      if total == 1 { "" } else { "s" }
+    );
+  }
+
+  if errors == 0 {
+    return format!(
+      "Found {} warning{}",
+      warnings,
+      if warnings == 1 { "" } else { "s" }
+    );
+  }
+
+  let mut parts = Vec::new();
+  parts.push(format!(
+    "{} error{}",
+    errors,
+    if errors == 1 { "" } else { "s" }
+  ));
+  parts.push(format!(
+    "{} warning{}",
+    warnings,
+    if warnings == 1 { "" } else { "s" }
+  ));
+  format!("Found {}", parts.join(", "))
+}
+
 fn main() -> Result<(), AnyError> {
   env_logger::init();
 

src/context.rs

@@ -2,8 +2,8 @@
 
 use crate::control_flow::ControlFlow;
 use crate::diagnostic::{
-  LintDiagnostic, LintDiagnosticDetails, LintDiagnosticRange, LintDocsUrl,
-  LintFix,
+  LintDiagnostic, LintDiagnosticDetails, LintDiagnosticRange,
+  LintDiagnosticSeverity, LintDocsUrl, LintFix,
 };
 use crate::ignore_directives::{
   parse_line_ignore_directives, CodeStatus, FileIgnoreDirective,
@@ -300,6 +300,7 @@ impl<'a> Context<'a> {
             format!("Ignore for code \"{}\" was not used.", unused_code),
             None,
             Vec::new(),
+            LintDiagnosticSeverity::Error,
           ),
         );
         diagnostics.push(d);
@@ -321,6 +322,7 @@ impl<'a> Context<'a> {
             format!("Ignore for code \"{}\" was not used.", unused_code),
             None,
             Vec::new(),
+            LintDiagnosticSeverity::Error,
           ),
         );
         diagnostics.push(d);
@@ -353,6 +355,7 @@ impl<'a> Context<'a> {
             format!("Unknown rule for code \"{}\"", unknown_rule_code),
             None,
             Vec::new(),
+            LintDiagnosticSeverity::Error,
           ),
         );
         diagnostics.push(d);
@@ -372,6 +375,7 @@ impl<'a> Context<'a> {
             format!("Unknown rule for code \"{}\"", unknown_rule_code),
             None,
             Vec::new(),
+            LintDiagnosticSeverity::Error,
           ),
         );
         diagnostics.push(d);
@@ -402,14 +406,13 @@ impl<'a> Context<'a> {
     code: impl ToString,
     message: impl ToString,
   ) {
-    self.add_diagnostic_details(
-      Some(self.create_diagnostic_range(range)),
-      self.create_diagnostic_details(
-        code,
-        message.to_string(),
-        None,
-        Vec::new(),
-      ),
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      None,
+      Vec::new(),
+      LintDiagnosticSeverity::Error,
     );
   }
 
@@ -420,14 +423,13 @@ impl<'a> Context<'a> {
     message: impl ToString,
     hint: impl ToString,
   ) {
-    self.add_diagnostic_details(
-      Some(self.create_diagnostic_range(range)),
-      self.create_diagnostic_details(
-        code,
-        message,
-        Some(hint.to_string()),
-        Vec::new(),
-      ),
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      Some(hint.to_string()),
+      Vec::new(),
+      LintDiagnosticSeverity::Error,
     );
   }
 
@@ -438,10 +440,80 @@ impl<'a> Context<'a> {
     message: impl ToString,
     hint: Option<String>,
     fixes: Vec<LintFix>,
+  ) {
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      hint,
+      fixes,
+      LintDiagnosticSeverity::Error,
+    );
+  }
+
+  pub fn add_warning(
+    &mut self,
+    range: SourceRange,
+    code: impl ToString,
+    message: impl ToString,
+  ) {
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      None,
+      Vec::new(),
+      LintDiagnosticSeverity::Warning,
+    );
+  }
+
+  pub fn add_warning_with_hint(
+    &mut self,
+    range: SourceRange,
+    code: impl ToString,
+    message: impl ToString,
+    hint: impl ToString,
+  ) {
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      Some(hint.to_string()),
+      Vec::new(),
+      LintDiagnosticSeverity::Warning,
+    );
+  }
+
+  pub fn add_warning_with_fixes(
+    &mut self,
+    range: SourceRange,
+    code: impl ToString,
+    message: impl ToString,
+    hint: Option<String>,
+    fixes: Vec<LintFix>,
+  ) {
+    self.add_diagnostic_with_hint_and_fixes(
+      range,
+      code,
+      message,
+      hint,
+      fixes,
+      LintDiagnosticSeverity::Warning,
+    );
+  }
+
+  fn add_diagnostic_with_hint_and_fixes(
+    &mut self,
+    range: SourceRange,
+    code: impl ToString,
+    message: impl ToString,
+    hint: Option<String>,
+    fixes: Vec<LintFix>,
+    severity: LintDiagnosticSeverity,
   ) {
     self.add_diagnostic_details(
       Some(self.create_diagnostic_range(range)),
-      self.create_diagnostic_details(code, message, hint, fixes),
+      self.create_diagnostic_details(code, message, hint, fixes, severity),
     );
   }
 
@@ -481,8 +553,10 @@ impl<'a> Context<'a> {
     message: impl ToString,
     maybe_hint: Option<String>,
     fixes: Vec<LintFix>,
+    severity: LintDiagnosticSeverity,
   ) -> LintDiagnosticDetails {
     LintDiagnosticDetails {
+      severity,
       message: message.to_string(),
       code: code.to_string(),
       hint: maybe_hint,