Merge 602d81e into 3e5a02b

Author: Alexendoo

.github/workflows/lintcheck.yml

@@ -0,0 +1,107 @@
+name: Lintcheck
+
+on: pull_request
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_INCREMENTAL: 0
+
+concurrency:
+  # For a given workflow, if we push to the same PR, cancel all previous builds on that PR.
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number}}"
+  cancel-in-progress: true
+
+jobs:
+  base:
+    runs-on: ubuntu-latest
+
+    outputs:
+      key: ${{ steps.key.outputs.key }}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Checkout merge base
+      run: git checkout ${{ github.event.pull_request.base.sha }}
+
+    - name: Checkout current lintcheck
+      run: |
+        rm -rf lintcheck
+        git checkout ${{ github.sha }} -- lintcheck
+
+    - name: Create cache key
+      id: key
+      run: echo "key=lintcheck-base-${{ hashfiles('lintcheck/**') }}-${{ github.event.pull_request.base.sha }}" >> "$GITHUB_OUTPUT"
+
+    - name: Cache results
+      id: cache
+      uses: actions/cache@v4
+      with:
+        path: lintcheck-logs/base.json
+        key: ${{ steps.key.outputs.key }}
+
+    - name: Run lintcheck
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: cargo lintcheck --json
+
+    - name: Rename JSON file
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: mv lintcheck-logs/lintcheck_crates_logs.json lintcheck-logs/base.json
+
+  head:
+    runs-on: ubuntu-latest
+
+    outputs:
+      key: ${{ steps.key.outputs.key }}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Create cache key
+      id: key
+      run: echo "key=lintcheck-head-${{ github.sha }}" >> "$GITHUB_OUTPUT"
+
+    - name: Cache results
+      id: cache
+      uses: actions/cache@v4
+      with:
+        path: lintcheck-logs/head.json
+        key: ${{ steps.key.outputs.key }}
+
+    - name: Run lintcheck
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: cargo lintcheck --json
+
+    - name: Rename JSON file
+      if: steps.cache.outputs.cache-hit != 'true'
+      run: mv lintcheck-logs/lintcheck_crates_logs.json lintcheck-logs/head.json
+
+  diff:
+    runs-on: ubuntu-latest
+
+    needs: [base, head]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Restore base JSON
+      uses: actions/cache/restore@v4
+      with:
+        key: ${{ needs.base.outputs.key }}
+        path: lintcheck-logs/base.json
+        fail-on-cache-miss: true
+
+    - name: Restore head JSON
+      uses: actions/cache/restore@v4
+      with:
+        key: ${{ needs.head.outputs.key }}
+        path: lintcheck-logs/head.json
+        fail-on-cache-miss: true
+
+    - name: Diff results
+      run: cargo lintcheck diff lintcheck-logs/base.json lintcheck-logs/head.json >> $GITHUB_STEP_SUMMARY

clippy_lints/src/manual_is_ascii_check.rs

@@ -165,7 +165,7 @@ fn check_is_ascii(
         cx,
         MANUAL_IS_ASCII_CHECK,
         span,
-        "manual check for common ascii range",
+        "manual check for common ASCII range",
         |diag| {
             diag.multipart_suggestion("try", suggestion, app);
         },

clippy_lints/src/operators/identity_op.rs

@@ -239,13 +239,15 @@ fn span_ineffective_operation(
         Parens::Unneeded => expr_snippet,
     };
 
-    span_lint_and_sugg(
-        cx,
-        IDENTITY_OP,
-        span,
-        "this operation has no effect",
-        "consider reducing it to",
-        suggestion,
-        applicability,
-    );
+    if false {
+        span_lint_and_sugg(
+            cx,
+            IDENTITY_OP,
+            span,
+            "this operation has no effect",
+            "consider reducing it to",
+            suggestion,
+            applicability,
+        );
+    }
 }

lintcheck/Cargo.toml

@@ -16,11 +16,13 @@ cargo_metadata = "0.15.3"
 clap = { version = "4.4", features = ["derive", "env"] }
 crates_io_api = "0.8.1"
 crossbeam-channel = "0.5.6"
+diff = "0.1.13"
 flate2 = "1.0"
 indicatif = "0.17.3"
 rayon = "1.5.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.85"
+strip-ansi-escapes = "0.1.1"
 tar = "0.4"
 toml = "0.7.3"
 ureq = "2.2"

lintcheck/src/config.rs

@@ -1,8 +1,9 @@
-use clap::Parser;
+use clap::{Parser, Subcommand, ValueEnum};
 use std::num::NonZero;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Parser)]
+#[allow(clippy::struct_excessive_bools)]
+#[derive(Parser, Clone, Debug)]
 pub(crate) struct LintcheckConfig {
     /// Number of threads to use (default: all unless --fix or --recursive)
     #[clap(
@@ -37,23 +38,60 @@ pub(crate) struct LintcheckConfig {
     pub lint_filter: Vec<String>,
     /// Change the reports table to use markdown links
     #[clap(long)]
-    pub markdown: bool,
+    markdown: bool,
+    /// Output the diagnostics as JSON
+    #[clap(long, conflicts_with("markdown"))]
+    json: bool,
+    #[clap(skip = OutputFormat::Text)]
+    pub format: OutputFormat,
     /// Run clippy on the dependencies of crates specified in crates-toml
     #[clap(long, conflicts_with("max_jobs"))]
     pub recursive: bool,
+    #[command(subcommand)]
+    pub subcommand: Option<Commands>,
+}
+
+#[derive(Subcommand, Clone, Debug)]
+pub(crate) enum Commands {
+    Diff { old: PathBuf, new: PathBuf },
+}
+
+#[derive(ValueEnum, Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum OutputFormat {
+    Text,
+    Markdown,
+    Json,
+}
+
+impl OutputFormat {
+    fn file_extension(self) -> &'static str {
+        match self {
+            OutputFormat::Text => "txt",
+            OutputFormat::Markdown => "md",
+            OutputFormat::Json => "json",
+        }
+    }
 }
 
 impl LintcheckConfig {
     pub fn new() -> Self {
         let mut config = LintcheckConfig::parse();
 
+        config.format = if config.markdown {
+            OutputFormat::Markdown
+        } else if config.json {
+            OutputFormat::Json
+        } else {
+            OutputFormat::Text
+        };
+
         // for the path where we save the lint results, get the filename without extension (so for
         // wasd.toml, use "wasd"...)
         let filename: PathBuf = config.sources_toml_path.file_stem().unwrap().into();
         config.lintcheck_results_path = PathBuf::from(format!(
             "lintcheck-logs/{}_logs.{}",
             filename.display(),
-            if config.markdown { "md" } else { "txt" }
+            config.format.file_extension(),
         ));
 
         // look at the --threads arg, if 0 is passed, use the threads count

lintcheck/src/json.rs

@@ -0,0 +1,122 @@
+use std::collections::HashMap;
+use std::fmt::Write;
+use std::fs;
+use std::hash::Hash;
+use std::path::Path;
+
+use crate::ClippyWarning;
+
+/// Creates the log file output for [`crate::config::OutputFormat::Json`]
+pub(crate) fn output(clippy_warnings: &[ClippyWarning]) -> String {
+    serde_json::to_string(&clippy_warnings).unwrap()
+}
+
+fn load_warnings(path: &Path) -> Vec<ClippyWarning> {
+    let file = fs::read(path).unwrap_or_else(|e| panic!("failed to read {}: {e}", path.display()));
+
+    serde_json::from_slice(&file).unwrap_or_else(|e| panic!("failed to deserialize {}: {e}", path.display()))
+}
+
+/// Group warnings by their primary span location + lint name
+fn create_map(warnings: &[ClippyWarning]) -> HashMap<impl Eq + Hash + '_, Vec<&ClippyWarning>> {
+    let mut map = HashMap::<_, Vec<_>>::with_capacity(warnings.len());
+
+    for warning in warnings {
+        let span = warning.span();
+        let key = (&warning.lint_type, &span.file_name, span.byte_start, span.byte_end);
+
+        map.entry(key).or_default().push(warning);
+    }
+
+    map
+}
+
+fn print_warnings(title: &str, warnings: &[&ClippyWarning]) {
+    if warnings.is_empty() {
+        return;
+    }
+
+    println!("### {title}");
+    println!("```");
+    for warning in warnings {
+        print!("{}", warning.diag);
+    }
+    println!("```");
+}
+
+fn print_changed_diff(changed: &[(&[&ClippyWarning], &[&ClippyWarning])]) {
+    fn render(warnings: &[&ClippyWarning]) -> String {
+        let mut rendered = String::new();
+        for warning in warnings {
+            write!(&mut rendered, "{}", warning.diag).unwrap();
+        }
+        rendered
+    }
+
+    if changed.is_empty() {
+        return;
+    }
+
+    println!("### Changed");
+    println!("```diff");
+    for &(old, new) in changed {
+        let old_rendered = render(old);
+        let new_rendered = render(new);
+
+        for change in diff::lines(&old_rendered, &new_rendered) {
+            use diff::Result::{Both, Left, Right};
+
+            match change {
+                Both(unchanged, _) => {
+                    println!(" {unchanged}");
+                },
+                Left(removed) => {
+                    println!("-{removed}");
+                },
+                Right(added) => {
+                    println!("+{added}");
+                },
+            }
+        }
+    }
+    println!("```");
+}
+
+pub(crate) fn diff(old_path: &Path, new_path: &Path) {
+    let old_warnings = load_warnings(old_path);
+    let new_warnings = load_warnings(new_path);
+
+    let old_map = create_map(&old_warnings);
+    let new_map = create_map(&new_warnings);
+
+    let mut added = Vec::new();
+    let mut removed = Vec::new();
+    let mut changed = Vec::new();
+
+    for (key, new) in &new_map {
+        if let Some(old) = old_map.get(key) {
+            if old != new {
+                changed.push((old.as_slice(), new.as_slice()));
+            }
+        } else {
+            added.extend(new);
+        }
+    }
+
+    for (key, old) in &old_map {
+        if !new_map.contains_key(key) {
+            removed.extend(old);
+        }
+    }
+
+    print!(
+        "{} added, {} removed, {} changed\n\n",
+        added.len(),
+        removed.len(),
+        changed.len()
+    );
+
+    print_warnings("Added", &added);
+    print_warnings("Removed", &removed);
+    print_changed_diff(&changed);
+}