Lintcheck: Limit output to 200 warnings per lint

Author: xFrednet

lintcheck/src/json.rs

@@ -1,3 +1,4 @@
+use std::fmt::Write;
 use std::fs;
 use std::path::Path;
 
@@ -52,11 +53,13 @@ fn load_warnings(path: &Path) -> Vec<LintJson> {
     serde_json::from_slice(&file).unwrap_or_else(|e| panic!("failed to deserialize {}: {e}", path.display()))
 }
 
-fn print_warnings(title: &str, warnings: &[LintJson]) {
+fn print_warnings(title: &str, mut warnings: Vec<LintJson>) {
     if warnings.is_empty() {
         return;
     }
 
+    let redacted_msg = limit_by_lint(&mut warnings, |lint| &lint.lint);
+
     //We have to use HTML here to be able to manually add an id.
     println!(r#"<h3 id="{title}">{title}</h3>"#);
     println!();
@@ -68,13 +71,19 @@ fn print_warnings(title: &str, warnings: &[LintJson]) {
         println!("```");
         println!();
     }
+
+    if let Some(redacted_msg) = redacted_msg {
+        println!("{redacted_msg}");
+    }
 }
 
-fn print_changed_diff(changed: &[(LintJson, LintJson)]) {
+fn print_changed_diff(mut changed: Vec<(LintJson, LintJson)>) {
     if changed.is_empty() {
         return;
     }
 
+    let redacted_msg = limit_by_lint(&mut changed, |(lint, _)| &lint.lint);
+
     //We have to use HTML here to be able to manually add an id.
     println!(r#"<h3 id="changed">Changed</h3>"#);
     println!();
@@ -99,6 +108,10 @@ fn print_changed_diff(changed: &[(LintJson, LintJson)]) {
         }
         println!("```");
     }
+
+    if let Some(redacted_msg) = redacted_msg {
+        println!("{redacted_msg}");
+    }
 }
 
 pub(crate) fn diff(old_path: &Path, new_path: &Path) {
@@ -130,9 +143,65 @@ pub(crate) fn diff(old_path: &Path, new_path: &Path) {
     println!();
     println!();
 
-    print_warnings("Added", &added);
-    print_warnings("Removed", &removed);
-    print_changed_diff(&changed);
+    print_warnings("Added", added);
+    print_warnings("Removed", removed);
+    print_changed_diff(changed);
+}
+
+/// This function limits the number of lints in the collection if needed.
+///
+/// It's honestly amazing that a function like this is needed. But some restriction
+/// lints (Looking at you `implicit_return` and `if_then_some_else_none`) trigger a lot
+/// like 60'000+ times in our CI.
+///
+/// Each lint in the list will be limited to 200 messages
+fn limit_by_lint<T, F>(list: &mut Vec<T>, lint_key: F) -> Option<String>
+where
+    F: Fn(&T) -> &str,
+{
+    const PER_LINT_LIMIT: usize = 200;
+
+    // Everything is fine, nothing to see here.
+    if list.len() < PER_LINT_LIMIT {
+        return None;
+    }
+
+    let mut keyed_list: Vec<_> = list
+        .drain(..)
+        .map(|warning| (lint_key(&warning).to_string(), warning))
+        .collect();
+
+    keyed_list.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
+
+    let last_idx = keyed_list.len() - 1;
+    let mut current_key = keyed_list[0].0.clone();
+    let mut current_ctn = 0;
+    let mut limit_message = String::new();
+    keyed_list
+        .drain(..)
+        .enumerate()
+        .filter_map(|(idx, (key, warning))| {
+            if key != current_key || idx == last_idx {
+                if current_ctn >= PER_LINT_LIMIT {
+                    writeln!(
+                        &mut limit_message,
+                        "* Hid {} messages for `{}`",
+                        current_ctn - PER_LINT_LIMIT,
+                        key
+                    )
+                    .unwrap();
+                }
+                current_key = key;
+                current_ctn = 0;
+            }
+
+            current_ctn += 1;
+
+            (current_ctn < PER_LINT_LIMIT).then_some(warning)
+        })
+        .collect_into(list);
+
+    Some(limit_message)
 }
 
 /// This generates the `x added` string for the start of the job summery.