From 6d11ff38222bef2864ce78fc79dfb02ee20b34b9 Mon Sep 17 00:00:00 2001
From: Martin Fischer <martin@push-f.com>
Date: Wed, 18 Jan 2023 02:22:52 +0100
Subject: [PATCH] rule 6/8: Remove Serialize & Deserialize impls for Rule

---
 ruff_cli/src/printer.rs                | 25 +++++++++++++++++++++----
 ruff_macros/src/define_rule_mapping.rs |  2 --
 src/lib_wasm.rs                        | 23 ++++++++++++++++++++---
 3 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/ruff_cli/src/printer.rs b/ruff_cli/src/printer.rs
index 1674d02b1c..632a0d8bbc 100644
--- a/ruff_cli/src/printer.rs
+++ b/ruff_cli/src/printer.rs
@@ -11,7 +11,7 @@ use itertools::iterate;
 use ruff::fs::relativize_path;
 use ruff::logging::LogLevel;
 use ruff::message::{Location, Message};
-use ruff::registry::RuleCode;
+use ruff::registry::Rule;
 use ruff::settings::types::SerializationFormat;
 use ruff::{fix, notify_user};
 use serde::Serialize;
@@ -35,7 +35,7 @@ struct ExpandedFix<'a> {
 
 #[derive(Serialize)]
 struct ExpandedMessage<'a> {
-    code: &'a RuleCode,
+    code: SerializeRuleAsCode<'a>,
     message: String,
     fix: Option<ExpandedFix<'a>>,
     location: Location,
@@ -43,6 +43,23 @@ struct ExpandedMessage<'a> {
     filename: &'a str,
 }
 
+struct SerializeRuleAsCode<'a>(&'a Rule);
+
+impl Serialize for SerializeRuleAsCode<'_> {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.0.code())
+    }
+}
+
+impl<'a> From<&'a Rule> for SerializeRuleAsCode<'a> {
+    fn from(rule: &'a Rule) -> Self {
+        Self(rule)
+    }
+}
+
 pub struct Printer<'a> {
     format: &'a SerializationFormat,
     log_level: &'a LogLevel,
@@ -143,7 +160,7 @@ impl<'a> Printer<'a> {
                             .messages
                             .iter()
                             .map(|message| ExpandedMessage {
-                                code: message.kind.rule(),
+                                code: message.kind.rule().into(),
                                 message: message.kind.body(),
                                 fix: message.fix.as_ref().map(|fix| ExpandedFix {
                                     content: &fix.content,
@@ -280,7 +297,7 @@ impl<'a> Printer<'a> {
                                 json!({
                                     "description": format!("({}) {}", message.kind.rule().code(), message.kind.body()),
                                     "severity": "major",
-                                    "fingerprint": message.kind.rule(),
+                                    "fingerprint": message.kind.rule().code(),
                                     "location": {
                                         "path": message.filename,
                                         "lines": {
diff --git a/ruff_macros/src/define_rule_mapping.rs b/ruff_macros/src/define_rule_mapping.rs
index 5f375fb3b9..76faeb6b43 100644
--- a/ruff_macros/src/define_rule_mapping.rs
+++ b/ruff_macros/src/define_rule_mapping.rs
@@ -55,8 +55,6 @@ pub fn define_rule_mapping(mapping: &Mapping) -> proc_macro2::TokenStream {
             PartialEq,
             Eq,
             Clone,
-            Serialize,   // TODO(martin): Remove
-            Deserialize, // TODO(martin): Remove
             Hash,
             PartialOrd,
             Ord,
diff --git a/src/lib_wasm.rs b/src/lib_wasm.rs
index 0d76cafc06..31a891df91 100644
--- a/src/lib_wasm.rs
+++ b/src/lib_wasm.rs
@@ -51,13 +51,30 @@ export interface Diagnostic {
 
 #[derive(Serialize)]
 struct ExpandedMessage {
-    code: RuleCode,
+    code: SerializeRuleAsCode,
     message: String,
     location: Location,
     end_location: Location,
     fix: Option<ExpandedFix>,
 }
 
+struct SerializeRuleAsCode(RuleCode);
+
+impl Serialize for SerializeRuleAsCode {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(self.0.code())
+    }
+}
+
+impl From<Rule> for SerializeRuleAsCode {
+    fn from(rule: Rule) -> Self {
+        Self(rule)
+    }
+}
+
 #[derive(Serialize)]
 struct ExpandedFix {
     content: String,
@@ -182,7 +199,7 @@ pub fn check(contents: &str, options: JsValue) -> Result<JsValue, JsValue> {
     let messages: Vec<ExpandedMessage> = diagnostics
         .into_iter()
         .map(|diagnostic| ExpandedMessage {
-            code: diagnostic.kind.rule().clone(),
+            code: diagnostic.kind.rule().clone().into(),
             message: diagnostic.kind.body(),
             location: diagnostic.location,
             end_location: diagnostic.end_location,
@@ -224,7 +241,7 @@ mod test {
             "if (1, 2): pass",
             r#"{}"#,
             [ExpandedMessage {
-                code: RuleCode::F634,
+                code: RuleCode::F634.into(),
                 message: "If test is a tuple, which is always `True`".to_string(),
                 location: Location::new(1, 0),
                 end_location: Location::new(1, 15),