Feature: Add SARIF output support

crates/ruff_cli/src/lib.rs

@@ -424,7 +424,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         if cli.statistics {
             printer.write_statistics(&diagnostics, &mut summary_writer)?;
         } else {
-            printer.write_once(&diagnostics, &mut summary_writer)?;
+            printer.write_once(&diagnostics, &mut summary_writer, &pyproject_config)?;
         }
 
         if !cli.exit_zero {

crates/ruff_cli/src/printer.rs

@@ -7,13 +7,14 @@ use anyhow::Result;
 use bitflags::bitflags;
 use colored::Colorize;
 use itertools::{iterate, Itertools};
+use ruff_workspace::resolver::PyprojectConfig;
 use serde::Serialize;
 
 use ruff_linter::fs::relativize_path;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::message::{
     AzureEmitter, Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter,
-    JsonEmitter, JsonLinesEmitter, JunitEmitter, PylintEmitter, TextEmitter,
+    JsonEmitter, JsonLinesEmitter, JunitEmitter, PylintEmitter, SarifEmitter, TextEmitter,
 };
 use ruff_linter::notify_user;
 use ruff_linter::registry::{AsRule, Rule};
@@ -210,6 +211,7 @@ impl Printer {
         &self,
         diagnostics: &Diagnostics,
         writer: &mut dyn Write,
+        config: &PyprojectConfig,
     ) -> Result<()> {
         if matches!(self.log_level, LogLevel::Silent) {
             return Ok(());
@@ -291,6 +293,11 @@ impl Printer {
             SerializationFormat::Azure => {
                 AzureEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
+            SerializationFormat::Sarif => {
+                SarifEmitter::default()
+                    .with_applied_rules(config.settings.linter.rules)
+                    .emit(writer, &diagnostics.messages, &context)?;
+            }
         }
 
         writer.flush()?;

crates/ruff_linter/Cargo.toml

@@ -71,6 +71,7 @@ toml = { workspace = true }
 typed-arena = { version = "2.0.2" }
 unicode-width = { workspace = true }
 unicode_names2 = { workspace = true }
+url = { version = "2.2.2" }
 wsl = { version = "0.1.0" }
 
 [dev-dependencies]

crates/ruff_linter/src/codes.rs

@@ -4,13 +4,15 @@
 /// `--select`. For pylint this is e.g. C0414 and E0118 but also C and E01.
 use std::fmt::Formatter;
 
+use serde::Serialize;
+
 use crate::registry::{AsRule, Linter};
 use crate::rule_selector::is_single_rule_selector;
 use crate::rules;
 
 use strum_macros::{AsRefStr, EnumIter};
 
-#[derive(PartialEq, Eq, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Serialize)]
 pub struct NoqaCode(&'static str, &'static str);
 
 impl NoqaCode {

crates/ruff_linter/src/message/mod.rs

@@ -17,6 +17,7 @@ use ruff_diagnostics::{Diagnostic, DiagnosticKind, Fix};
 use ruff_notebook::NotebookIndex;
 use ruff_source_file::{SourceFile, SourceLocation};
 use ruff_text_size::{Ranged, TextRange, TextSize};
+pub use sarif::SarifEmitter;
 pub use text::TextEmitter;
 
 mod azure;
@@ -28,6 +29,7 @@ mod json;
 mod json_lines;
 mod junit;
 mod pylint;
+mod sarif;
 mod text;
 
 #[derive(Debug, PartialEq, Eq)]

crates/ruff_linter/src/message/sarif.rs

@@ -0,0 +1,205 @@
+use std::io::Write;
+use url::Url;
+
+use serde::{Serialize, Serializer};
+use serde_json::json;
+
+use ruff_source_file::OneIndexed;
+
+use crate::fs::normalize_path;
+use crate::message::{Emitter, EmitterContext, Message};
+use crate::registry::{AsRule, Linter, Rule, RuleNamespace};
+use crate::settings::rule_table::RuleTable;
+use crate::VERSION;
+
+#[derive(Default)]
+pub struct SarifEmitter<'a> {
+    applied_rules: Vec<SarifRule<'a>>,
+}
+
+impl SarifEmitter<'_> {
+    #[must_use]
+    pub fn with_applied_rules(mut self, rule_table: RuleTable) -> Self {
+        let mut applied_rules = Vec::new();
+
+        for rule in rule_table.iter_enabled() {
+            applied_rules.push(SarifRule::from_rule(rule));
+        }
+        self.applied_rules = applied_rules;
+        self
+    }
+}
+
+impl Emitter for SarifEmitter<'_> {
+    fn emit(
+        &mut self,
+        writer: &mut dyn Write,
+        messages: &[Message],
+        _context: &EmitterContext,
+    ) -> anyhow::Result<()> {
+        let results = messages
+            .iter()
+            .map(SarifResult::from_message)
+            .collect::<Vec<_>>();
+
+        let output = json!({
+            "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+            "version": "2.1.0",
+            "runs": [{
+                "tool": {
+                    "driver": {
+                        "name": "ruff",
+                        "informationUri": "https://github.com/astral-sh/ruff",
+                        "rules": self.applied_rules,
+                        "version": VERSION.to_string(),
+                    }
+                },
+                "results": results,
+            }],
+        });
+        serde_json::to_writer_pretty(writer, &output)?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+struct SarifRule<'a> {
+    name: &'a str,
+    code: String,
+    linter: &'a str,
+    summary: &'a str,
+    explanation: Option<&'a str>,
+    url: Option<String>,
+}
+
+impl<'a> SarifRule<'a> {
+    fn from_rule(rule: Rule) -> Self {
+        let code = rule.noqa_code().to_string();
+        let (linter, _) = Linter::parse_code(&code).unwrap();
+        Self {
+            name: rule.into(),
+            code,
+            linter: linter.name(),
+            summary: rule.message_formats()[0],
+            explanation: rule.explanation(),
+            url: rule.url(),
+        }
+    }
+}
+
+impl Serialize for SarifRule<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        json!({
+            "id": self.code,
+            "shortDescription": {
+                "text": self.summary,
+            },
+            "fullDescription": {
+                "text": self.explanation,
+            },
+            "helpUri": self.url,
+            "properties": {
+                "id": self.code,
+                "kind": self.linter,
+                "name": self.name,
+                "problem.severity": "error".to_string(),
+            },
+        })
+        .serialize(serializer)
+    }
+}
+
+#[derive(Debug)]
+struct SarifResult {
+    rule: Rule,
+    level: String,
+    message: String,
+    uri: String,
+    start_line: OneIndexed,
+    start_column: OneIndexed,
+}
+
+impl SarifResult {
+    #[cfg(not(target_arch = "wasm32"))]
+    fn from_message(message: &Message) -> Self {
+        let start_location = message.compute_start_location();
+        let abs_filepath = normalize_path(message.filename());
+        Self {
+            rule: message.kind.rule(),
+            level: "error".to_string(),
+            message: message.kind.name.clone(),
+            uri: Url::from_file_path(abs_filepath).unwrap().to_string(),
+            start_line: start_location.row,
+            start_column: start_location.column,
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    fn from_message(message: &Message) -> Self {
+        let start_location = message.compute_start_location();
+        let abs_filepath = normalize_path(message.filename());
+        Self {
+            rule: message.kind.rule(),
+            level: "error".to_string(),
+            message: message.kind.name.clone(),
+            uri: abs_filepath.display().to_string(),
+            start_line: start_location.row,
+            start_column: start_location.column,
+        }
+    }
+}
+
+impl Serialize for SarifResult {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        json!({
+            "level": self.level,
+            "message": {
+                "text": self.message,
+            },
+            "locations": [{
+                "physicalLocation": {
+                    "artifactLocation": {
+                        "uri": self.uri,
+                    },
+                    "region": {
+                        "startLine": self.start_line,
+                        "startColumn": self.start_column,
+                    }
+                }
+            }],
+            "ruleId": self.rule.noqa_code().to_string(),
+        })
+        .serialize(serializer)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use crate::message::tests::{capture_emitter_output, create_messages};
+    use crate::message::SarifEmitter;
+
+    fn get_output() -> String {
+        let mut emitter = SarifEmitter::default();
+        capture_emitter_output(&mut emitter, &create_messages())
+    }
+
+    #[test]
+    fn valid_json() {
+        let content = get_output();
+        serde_json::from_str::<serde_json::Value>(&content).unwrap();
+    }
+
+    #[test]
+    fn test_results() {
+        let content = get_output();
+        let sarif = serde_json::from_str::<serde_json::Value>(content.as_str()).unwrap();
+        let results = sarif["runs"][0]["results"].as_array().unwrap();
+        assert_eq!(results.len(), 3);
+    }
+}

crates/ruff_linter/src/registry/rule_set.rs

@@ -8,7 +8,7 @@ const RULESET_SIZE: usize = 12;
 /// A set of [`Rule`]s.
 ///
 /// Uses a bitset where a bit of one signals that the Rule with that [u16] is in this set.
-#[derive(Clone, Default, CacheKey, PartialEq, Eq)]
+#[derive(Clone, Default, CacheKey, PartialEq, Eq, Copy)]
 pub struct RuleSet([u64; RULESET_SIZE]);
 
 impl RuleSet {
@@ -257,7 +257,7 @@ impl RuleSet {
     /// ```
     pub fn iter(&self) -> RuleSetIterator {
         RuleSetIterator {
-            set: self.clone(),
+            set: *self,
             index: 0,
         }
     }

crates/ruff_linter/src/settings/rule_table.rs

@@ -5,7 +5,7 @@ use ruff_macros::CacheKey;
 use crate::registry::{Rule, RuleSet, RuleSetIterator};
 
 /// A table to keep track of which rules are enabled and whether they should be fixed.
-#[derive(Debug, CacheKey, Default)]
+#[derive(Debug, CacheKey, Default, Copy, Clone)]
 pub struct RuleTable {
     /// Maps rule codes to a boolean indicating if the rule should be fixed.
     enabled: RuleSet,
@@ -66,7 +66,7 @@ impl FromIterator<Rule> for RuleTable {
     fn from_iter<T: IntoIterator<Item = Rule>>(iter: T) -> Self {
         let rules = RuleSet::from_iter(iter);
         Self {
-            enabled: rules.clone(),
+            enabled: rules,
             should_fix: rules,
         }
     }

crates/ruff_linter/src/settings/types.rs

@@ -418,6 +418,7 @@ pub enum SerializationFormat {
     Gitlab,
     Pylint,
     Azure,
+    Sarif,
 }
 
 impl Default for SerializationFormat {

docs/configuration.md

@@ -481,7 +481,7 @@ Options:
       --ignore-noqa
           Ignore any `# noqa` comments
       --output-format <OUTPUT_FORMAT>
-          Output serialization format for violations [env: RUFF_OUTPUT_FORMAT=] [possible values: text, json, json-lines, junit, grouped, github, gitlab, pylint, azure]
+          Output serialization format for violations [env: RUFF_OUTPUT_FORMAT=] [possible values: text, json, json-lines, junit, grouped, github, gitlab, pylint, azure, sarif]
   -o, --output-file <OUTPUT_FILE>
           Specify file to write the linter output to (default: stdout)
       --target-version <TARGET_VERSION>