refactor: simplify Diagnostic to enum, extract for_each_dep_table_mut

Replace flat Diagnostic struct (6 Option fields + CheckKind) with
DiagnosticKind enum carrying variant-specific data. Add mutable
variant of for_each_dep_table to eliminate duplicated iteration in
fix_member_dep.

Author: RomarQ

src/check.rs

@@ -1,6 +1,6 @@
 use std::collections::{BTreeMap, HashMap};
 
-use crate::diagnostic::{CheckKind, Diagnostic, Severity};
+use crate::diagnostic::{Diagnostic, DiagnosticKind, Severity};
 use crate::workspace::WorkspaceInfo;
 
 pub fn run_checks(workspace: &WorkspaceInfo, promotion_threshold: usize) -> Vec<Diagnostic> {
@@ -23,21 +23,29 @@ pub fn run_checks(workspace: &WorkspaceInfo, promotion_threshold: usize) -> Vec<
             let lookup_name = dep.package.as_deref().unwrap_or(&dep.name);
 
             if let Some(ws_dep) = workspace.workspace_deps.get(lookup_name) {
-                let check = match (&dep.version, &ws_dep.version) {
-                    (Some(dep_ver), Some(ws_ver)) if dep_ver == ws_ver => CheckKind::NotInherited,
-                    (Some(_), Some(_)) => CheckKind::VersionMismatch,
-                    _ => CheckKind::NotInherited,
+                let kind = match (&dep.version, &ws_dep.version) {
+                    (Some(dep_ver), Some(ws_ver)) if dep_ver == ws_ver => {
+                        DiagnosticKind::NotInherited {
+                            version: dep.version.clone(),
+                            member: member_rel.clone(),
+                            workspace_version: ws_dep.version.clone(),
+                        }
+                    }
+                    (Some(_), Some(_)) => DiagnosticKind::VersionMismatch {
+                        version: dep.version.clone(),
+                        member: member_rel.clone(),
+                        workspace_version: ws_dep.version.clone(),
+                    },
+                    _ => DiagnosticKind::NotInherited {
+                        version: dep.version.clone(),
+                        member: member_rel.clone(),
+                        workspace_version: ws_dep.version.clone(),
+                    },
                 };
                 diagnostics.push(Diagnostic {
                     severity: Severity::Error,
-                    check,
                     dependency: lookup_name.to_string(),
-                    version: dep.version.clone(),
-                    member: Some(member_rel.clone()),
-                    workspace_version: ws_dep.version.clone(),
-                    count: None,
-                    members: None,
-                    suggested_version: None,
+                    kind,
                 });
             } else {
                 dep_usage
@@ -63,14 +71,12 @@ pub fn run_checks(workspace: &WorkspaceInfo, promotion_threshold: usize) -> Vec<
 
             diagnostics.push(Diagnostic {
                 severity: Severity::Warning,
-                check: CheckKind::PromotionCandidate,
                 dependency: dep_name.clone(),
-                version: None,
-                member: None,
-                workspace_version: None,
-                count: Some(usages.len()),
-                members: Some(usages.iter().map(|(m, _)| m.clone()).collect()),
-                suggested_version,
+                kind: DiagnosticKind::PromotionCandidate {
+                    count: usages.len(),
+                    members: usages.iter().map(|(m, _)| m.clone()).collect(),
+                    suggested_version,
+                },
             });
         }
     }
@@ -97,7 +103,10 @@ mod tests {
         let diags = run_checks(&ws, 2);
         assert_eq!(diags.len(), 1);
         assert_eq!(diags[0].dependency, "serde");
-        assert!(matches!(diags[0].check, CheckKind::NotInherited));
+        assert!(matches!(
+            diags[0].kind,
+            DiagnosticKind::NotInherited { .. }
+        ));
     }
 
     #[test]
@@ -106,9 +115,19 @@ mod tests {
         let diags = run_checks(&ws, 2);
         assert_eq!(diags.len(), 1);
         assert_eq!(diags[0].dependency, "rand");
-        assert!(matches!(diags[0].check, CheckKind::VersionMismatch));
-        assert_eq!(diags[0].version.as_deref(), Some("0.7"));
-        assert_eq!(diags[0].workspace_version.as_deref(), Some("0.8"));
+        assert!(matches!(
+            diags[0].kind,
+            DiagnosticKind::VersionMismatch { .. }
+        ));
+        if let DiagnosticKind::VersionMismatch {
+            version,
+            workspace_version,
+            ..
+        } = &diags[0].kind
+        {
+            assert_eq!(version.as_deref(), Some("0.7"));
+            assert_eq!(workspace_version.as_deref(), Some("0.8"));
+        }
     }
 
     #[test]
@@ -117,8 +136,13 @@ mod tests {
         let diags = run_checks(&ws, 2);
         assert_eq!(diags.len(), 1);
         assert_eq!(diags[0].dependency, "serde_yaml");
-        assert!(matches!(diags[0].check, CheckKind::PromotionCandidate));
-        assert_eq!(diags[0].count, Some(2));
+        assert!(matches!(
+            diags[0].kind,
+            DiagnosticKind::PromotionCandidate { .. }
+        ));
+        if let DiagnosticKind::PromotionCandidate { count, .. } = &diags[0].kind {
+            assert_eq!(*count, 2);
+        }
     }
 
     #[test]
@@ -147,6 +171,9 @@ mod tests {
         let diags = run_checks(&ws, 2);
         assert_eq!(diags.len(), 1);
         assert_eq!(diags[0].dependency, "winapi");
-        assert!(matches!(diags[0].check, CheckKind::NotInherited));
+        assert!(matches!(
+            diags[0].kind,
+            DiagnosticKind::NotInherited { .. }
+        ));
     }
 }

src/diagnostic.rs

@@ -1,13 +1,5 @@
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum CheckKind {
-    NotInherited,
-    VersionMismatch,
-    PromotionCandidate,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum Severity {
@@ -18,44 +10,63 @@ pub enum Severity {
 #[derive(Debug, Clone, Serialize)]
 pub struct Diagnostic {
     pub severity: Severity,
-    pub check: CheckKind,
     pub dependency: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub version: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub member: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub workspace_version: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub count: Option<usize>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub members: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub suggested_version: Option<String>,
+    #[serde(flatten)]
+    pub kind: DiagnosticKind,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "check", rename_all = "kebab-case")]
+pub enum DiagnosticKind {
+    NotInherited {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        version: Option<String>,
+        member: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        workspace_version: Option<String>,
+    },
+    VersionMismatch {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        version: Option<String>,
+        member: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        workspace_version: Option<String>,
+    },
+    PromotionCandidate {
+        count: usize,
+        members: Vec<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        suggested_version: Option<String>,
+    },
 }
 
 impl Diagnostic {
     pub fn format_human(&self) -> String {
-        match self.check {
-            CheckKind::NotInherited => {
-                let ver = self.version.as_deref().unwrap_or("?");
-                let member = self.member.as_deref().unwrap_or("?");
+        match &self.kind {
+            DiagnosticKind::NotInherited { version, member, .. } => {
+                let ver = version.as_deref().unwrap_or("?");
                 format!(
                     "error: `{dep} = \"{ver}\"` in {member} should use `{dep} = {{ workspace = true }}`",
                     dep = self.dependency,
                 )
             }
-            CheckKind::VersionMismatch => {
-                let ver = self.version.as_deref().unwrap_or("?");
-                let member = self.member.as_deref().unwrap_or("?");
-                let ws_ver = self.workspace_version.as_deref().unwrap_or("?");
+            DiagnosticKind::VersionMismatch {
+                version,
+                member,
+                workspace_version,
+            } => {
+                let ver = version.as_deref().unwrap_or("?");
+                let ws_ver = workspace_version.as_deref().unwrap_or("?");
                 format!(
                     "error: `{dep} = \"{ver}\"` in {member} has a different version than workspace `{dep} = \"{ws_ver}\"`",
                     dep = self.dependency,
                 )
             }
-            CheckKind::PromotionCandidate => {
-                let count = self.count.unwrap_or(0);
+            DiagnosticKind::PromotionCandidate {
+                count,
+                members,
+                suggested_version,
+            } => {
                 let severity = match self.severity {
                     Severity::Error => "error",
                     Severity::Warning => "warning",
@@ -64,12 +75,10 @@ impl Diagnostic {
                     "{severity}: `{}` appears in {count} crates but is not in [workspace.dependencies]",
                     self.dependency,
                 )];
-                if let Some(members) = &self.members {
-                    for m in members {
-                        lines.push(format!("  --> {m}"));
-                    }
+                for m in members {
+                    lines.push(format!("  --> {m}"));
                 }
-                if let Some(ver) = &self.suggested_version {
+                if let Some(ver) = suggested_version {
                     lines.push(format!(
                         "  hint: consider adding `{} = \"{}\"` to [workspace.dependencies]",
                         self.dependency, ver,
@@ -140,14 +149,12 @@ mod tests {
     fn test_not_inherited_human_format() {
         let d = Diagnostic {
             severity: Severity::Error,
-            check: CheckKind::NotInherited,
             dependency: "lru".into(),
-            version: Some("0.12".into()),
-            member: Some("crates/crypto/Cargo.toml".into()),
-            workspace_version: Some("0.12".into()),
-            count: None,
-            members: None,
-            suggested_version: None,
+            kind: DiagnosticKind::NotInherited {
+                version: Some("0.12".into()),
+                member: "crates/crypto/Cargo.toml".into(),
+                workspace_version: Some("0.12".into()),
+            },
         };
         let output = d.format_human();
         assert!(output.contains("error:"));
@@ -160,14 +167,12 @@ mod tests {
     fn test_version_mismatch_human_format() {
         let d = Diagnostic {
             severity: Severity::Error,
-            check: CheckKind::VersionMismatch,
             dependency: "rand".into(),
-            version: Some("0.7".into()),
-            member: Some("crates/utils/Cargo.toml".into()),
-            workspace_version: Some("0.8".into()),
-            count: None,
-            members: None,
-            suggested_version: None,
+            kind: DiagnosticKind::VersionMismatch {
+                version: Some("0.7".into()),
+                member: "crates/utils/Cargo.toml".into(),
+                workspace_version: Some("0.8".into()),
+            },
         };
         let output = d.format_human();
         assert!(output.contains("error:"));
@@ -180,17 +185,15 @@ mod tests {
     fn test_promotion_candidate_human_format() {
         let d = Diagnostic {
             severity: Severity::Warning,
-            check: CheckKind::PromotionCandidate,
             dependency: "serde_yaml".into(),
-            version: None,
-            member: None,
-            workspace_version: None,
-            count: Some(3),
-            members: Some(vec![
-                "crates/config/Cargo.toml".into(),
-                "crates/node/Cargo.toml".into(),
-            ]),
-            suggested_version: Some("0.9".into()),
+            kind: DiagnosticKind::PromotionCandidate {
+                count: 3,
+                members: vec![
+                    "crates/config/Cargo.toml".into(),
+                    "crates/node/Cargo.toml".into(),
+                ],
+                suggested_version: Some("0.9".into()),
+            },
         };
         let output = d.format_human();
         assert!(output.contains("warning:"));
@@ -203,14 +206,12 @@ mod tests {
     fn test_report_summary_human() {
         let report = DiagnosticReport::new(vec![Diagnostic {
             severity: Severity::Error,
-            check: CheckKind::NotInherited,
             dependency: "lru".into(),
-            version: Some("0.12".into()),
-            member: Some("crates/crypto/Cargo.toml".into()),
-            workspace_version: Some("0.12".into()),
-            count: None,
-            members: None,
-            suggested_version: None,
+            kind: DiagnosticKind::NotInherited {
+                version: Some("0.12".into()),
+                member: "crates/crypto/Cargo.toml".into(),
+                workspace_version: Some("0.12".into()),
+            },
         }]);
         let output = report.format_human();
         assert!(output.contains("1 error"));
@@ -220,14 +221,12 @@ mod tests {
     fn test_report_json() {
         let report = DiagnosticReport::new(vec![Diagnostic {
             severity: Severity::Error,
-            check: CheckKind::NotInherited,
             dependency: "lru".into(),
-            version: Some("0.12".into()),
-            member: Some("crates/crypto/Cargo.toml".into()),
-            workspace_version: Some("0.12".into()),
-            count: None,
-            members: None,
-            suggested_version: None,
+            kind: DiagnosticKind::NotInherited {
+                version: Some("0.12".into()),
+                member: "crates/crypto/Cargo.toml".into(),
+                workspace_version: Some("0.12".into()),
+            },
         }]);
         let json = report.format_json();
         let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();