Smaller nits

Author: MichaReiser

crates/ruff_linter/src/message/sarif.rs

@@ -117,14 +117,7 @@ impl Serialize for SarifRule<'_> {
     }
 }
 
-fn serialize_rule_code<S>(code: &RuleCode<'_>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    serializer.serialize_str(code.as_str())
-}
-
-#[derive(Debug, Serialize)]
+#[derive(Debug)]
 enum RuleCode<'a> {
     SecondaryCode(&'a SecondaryCode),
     LintId(&'a str),
@@ -146,6 +139,15 @@ impl RuleCode<'_> {
     }
 }
 
+impl Serialize for RuleCode<'_> {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.as_str())
+    }
+}
+
 impl<'a> From<&'a Diagnostic> for RuleCode<'a> {
     fn from(code: &'a Diagnostic) -> Self {
         match code.secondary_code() {
@@ -162,7 +164,6 @@ impl<'a> From<&'a Diagnostic> for RuleCode<'a> {
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct SarifResult<'a> {
-    #[serde(serialize_with = "serialize_rule_code")]
     rule_id: RuleCode<'a>,
     level: String,
     message: SarifMessage,
@@ -277,28 +278,8 @@ impl<'a> SarifResult<'a> {
             .collect()
     }
 
-    fn sarif_region(message: &'a Diagnostic) -> SarifRegion {
-        let start_location = message.expect_ruff_start_location();
-        let end_location = message.expect_ruff_end_location();
-        SarifRegion {
-            start_line: start_location.line,
-            start_column: start_location.column,
-            end_line: end_location.line,
-            end_column: end_location.column,
-        }
-    }
-
-    fn location(uri: String, region: SarifRegion) -> SarifLocation {
-        SarifLocation {
-            physical_location: SarifPhysicalLocation {
-                artifact_location: SarifArtifactLocation { uri },
-                region,
-            },
-        }
-    }
-
-    fn message_uri(message: &Diagnostic) -> Result<String> {
-        let path = normalize_path(&*message.expect_ruff_filename());
+    fn uri(diagnostic: &Diagnostic) -> Result<String> {
+        let path = normalize_path(&*diagnostic.expect_ruff_filename());
         #[cfg(not(target_arch = "wasm32"))]
         return url::Url::from_file_path(&path)
             .map_err(|()| anyhow::anyhow!("Failed to convert path to URL: {}", path.display()))
@@ -307,20 +288,31 @@ impl<'a> SarifResult<'a> {
         return Ok(format!("file://{}", path.display()));
     }
 
-    fn from_message(message: &'a Diagnostic) -> Result<Self> {
-        let sarif_region = Self::sarif_region(message);
-        let uri = Self::message_uri(message)?;
-        let fixes = Self::fixes(message, sarif_region, &uri);
-        let locations = vec![Self::location(uri, sarif_region)];
+    fn from_message(diagnostic: &'a Diagnostic) -> Result<Self> {
+        let start_location = diagnostic.expect_ruff_start_location();
+        let end_location = diagnostic.expect_ruff_end_location();
+        let region = SarifRegion {
+            start_line: start_location.line,
+            start_column: start_location.column,
+            end_line: end_location.line,
+            end_column: end_location.column,
+        };
+
+        let uri = Self::uri(diagnostic)?;
 
         Ok(Self {
-            rule_id: RuleCode::from(message),
+            rule_id: RuleCode::from(diagnostic),
             level: "error".to_string(),
             message: SarifMessage {
-                text: message.body().to_string(),
+                text: diagnostic.body().to_string(),
             },
-            locations,
-            fixes,
+            fixes: Self::fixes(diagnostic, region, &uri),
+            locations: vec![SarifLocation {
+                physical_location: SarifPhysicalLocation {
+                    artifact_location: SarifArtifactLocation { uri },
+                    region,
+                },
+            }],
         })
     }
 }