Introduce a ruff_diagnostics crate (#3409)

## Summary

This PR moves `Diagnostic`, `DiagnosticKind`, and `Fix` into their own crate, which will enable us to further split up Ruff, since sub-linter crates (which need to implement functions that return `Diagnostic`) can now depend on `ruff_diagnostics` rather than Ruff.

Cargo.lock

@@ -1982,6 +1982,7 @@ dependencies = [
  "regex",
  "result-like",
  "ruff_cache",
+ "ruff_diagnostics",
  "ruff_macros",
  "ruff_python_ast",
  "ruff_python_stdlib",
@@ -2042,6 +2043,7 @@ dependencies = [
  "regex",
  "ruff",
  "ruff_cache",
+ "ruff_diagnostics",
  "rustc-hash",
  "serde",
  "serde_json",
@@ -2067,6 +2069,7 @@ dependencies = [
  "regex",
  "ruff",
  "ruff_cli",
+ "ruff_diagnostics",
  "rustpython-common",
  "rustpython-parser",
  "schemars",
@@ -2076,6 +2079,15 @@ dependencies = [
  "textwrap",
 ]
 
+[[package]]
+name = "ruff_diagnostics"
+version = "0.0.0"
+dependencies = [
+ "ruff_python_ast",
+ "rustpython-parser",
+ "serde",
+]
+
 [[package]]
 name = "ruff_formatter"
 version = "0.0.0"

crates/ruff/Cargo.toml

@@ -17,6 +17,7 @@ doctest = false
 
 [dependencies]
 ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
 ruff_macros = { path = "../ruff_macros" }
 ruff_python_ast = { path = "../ruff_python_ast" }
 ruff_python_stdlib = { path = "../ruff_python_stdlib" }

crates/ruff/src/autofix/helpers.rs

@@ -6,15 +6,15 @@ use libcst_native::{
 use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
 use rustpython_parser::{lexer, Mode, Tok};
 
-use crate::cst::helpers::compose_module_path;
-use crate::cst::matchers::match_module;
-use crate::fix::Fix;
+use ruff_diagnostics::Fix;
 use ruff_python_ast::helpers;
 use ruff_python_ast::helpers::to_absolute;
 use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-
 use ruff_python_ast::whitespace::LinesWithTrailingNewline;
 
+use crate::cst::helpers::compose_module_path;
+use crate::cst::matchers::match_module;
+
 /// Determine if a body contains only a single statement, taking into account
 /// deleted.
 fn has_single_child(body: &[Stmt], deleted: &[&Stmt]) -> bool {
@@ -450,9 +450,10 @@ mod tests {
     use rustpython_parser as parser;
     use rustpython_parser::ast::Location;
 
-    use crate::autofix::helpers::{next_stmt_break, trailing_semicolon};
     use ruff_python_ast::source_code::Locator;
 
+    use crate::autofix::helpers::{next_stmt_break, trailing_semicolon};
+
     #[test]
     fn find_semicolon() -> Result<()> {
         let contents = "x = 1";

crates/ruff/src/autofix/mod.rs

@@ -4,12 +4,12 @@ use itertools::Itertools;
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::Location;
 
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 
-use crate::fix::Fix;
 use crate::linter::FixTable;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 
 pub mod helpers;
 
@@ -96,43 +96,38 @@ pub(crate) fn apply_fix(fix: &Fix, locator: &Locator) -> String {
 mod tests {
     use rustpython_parser::ast::Location;
 
+    use ruff_diagnostics::Diagnostic;
+    use ruff_diagnostics::Fix;
     use ruff_python_ast::source_code::Locator;
 
     use crate::autofix::{apply_fix, apply_fixes};
-    use crate::fix::Fix;
-    use crate::registry::Diagnostic;
     use crate::rules::pycodestyle::rules::NoNewLineAtEndOfFile;
 
-    #[test]
-    fn empty_file() {
-        let fixes: Vec<Diagnostic> = vec![];
-        let locator = Locator::new(r#""#);
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
-        assert_eq!(contents, "");
-        assert_eq!(fixed.values().sum::<usize>(), 0);
-    }
-
-    impl From<Fix> for Diagnostic {
-        fn from(fix: Fix) -> Self {
-            Diagnostic {
+    fn create_diagnostics(fixes: impl IntoIterator<Item = Fix>) -> Vec<Diagnostic> {
+        fixes
+            .into_iter()
+            .map(|fix| Diagnostic {
                 // The choice of rule here is arbitrary.
                 kind: NoNewLineAtEndOfFile.into(),
                 location: fix.location,
                 end_location: fix.end_location,
                 fix: Some(fix),
                 parent: None,
-            }
-        }
+            })
+            .collect()
+    }
+
+    #[test]
+    fn empty_file() {
+        let locator = Locator::new(r#""#);
+        let diagnostics = create_diagnostics([]);
+        let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
+        assert_eq!(contents, "");
+        assert_eq!(fixed.values().sum::<usize>(), 0);
     }
 
     #[test]
     fn apply_one_replacement() {
-        let fixes: Vec<Diagnostic> = vec![Fix {
-            content: "Bar".to_string(),
-            location: Location::new(1, 8),
-            end_location: Location::new(1, 14),
-        }
-        .into()];
         let locator = Locator::new(
             r#"
 class A(object):
@@ -140,7 +135,12 @@ class A(object):
 "#
             .trim(),
         );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        let diagnostics = create_diagnostics([Fix {
+            content: "Bar".to_string(),
+            location: Location::new(1, 8),
+            end_location: Location::new(1, 14),
+        }]);
+        let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
         assert_eq!(
             contents,
             r#"
@@ -154,12 +154,6 @@ class A(Bar):
 
     #[test]
     fn apply_one_removal() {
-        let fixes: Vec<Diagnostic> = vec![Fix {
-            content: String::new(),
-            location: Location::new(1, 7),
-            end_location: Location::new(1, 15),
-        }
-        .into()];
         let locator = Locator::new(
             r#"
 class A(object):
@@ -167,7 +161,12 @@ class A(object):
 "#
             .trim(),
         );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        let diagnostics = create_diagnostics([Fix {
+            content: String::new(),
+            location: Location::new(1, 7),
+            end_location: Location::new(1, 15),
+        }]);
+        let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
         assert_eq!(
             contents,
             r#"
@@ -181,20 +180,6 @@ class A:
 
     #[test]
     fn apply_two_removals() {
-        let fixes: Vec<Diagnostic> = vec![
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 7),
-                end_location: Location::new(1, 16),
-            }
-            .into(),
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 16),
-                end_location: Location::new(1, 23),
-            }
-            .into(),
-        ];
         let locator = Locator::new(
             r#"
 class A(object, object):
@@ -202,7 +187,19 @@ class A(object, object):
 "#
             .trim(),
         );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        let diagnostics = create_diagnostics([
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 16),
+            },
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 16),
+                end_location: Location::new(1, 23),
+            },
+        ]);
+        let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
 
         assert_eq!(
             contents,
@@ -217,20 +214,6 @@ class A:
 
     #[test]
     fn ignore_overlapping_fixes() {
-        let fixes: Vec<Diagnostic> = vec![
-            Fix {
-                content: String::new(),
-                location: Location::new(1, 7),
-                end_location: Location::new(1, 15),
-            }
-            .into(),
-            Fix {
-                content: "ignored".to_string(),
-                location: Location::new(1, 9),
-                end_location: Location::new(1, 11),
-            }
-            .into(),
-        ];
         let locator = Locator::new(
             r#"
 class A(object):
@@ -238,7 +221,19 @@ class A(object):
 "#
             .trim(),
         );
-        let (contents, fixed) = apply_fixes(fixes.iter(), &locator);
+        let diagnostics = create_diagnostics([
+            Fix {
+                content: String::new(),
+                location: Location::new(1, 7),
+                end_location: Location::new(1, 15),
+            },
+            Fix {
+                content: "ignored".to_string(),
+                location: Location::new(1, 9),
+                end_location: Location::new(1, 11),
+            },
+        ]);
+        let (contents, fixed) = apply_fixes(diagnostics.iter(), &locator);
         assert_eq!(
             contents,
             r#"

crates/ruff/src/checkers/ast/mod.rs

@@ -13,6 +13,7 @@ use rustpython_parser::ast::{
     Suite,
 };
 
+use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::context::Context;
 use ruff_python_ast::helpers::{
     binding_range, extract_handled_exceptions, to_module_path, Exceptions,
@@ -36,7 +37,7 @@ use crate::checkers::ast::deferred::Deferred;
 use crate::docstrings::definition::{
     transition_scope, Definition, DefinitionKind, Docstring, Documentable,
 };
-use crate::registry::{AsRule, Diagnostic, Rule};
+use crate::registry::{AsRule, Rule};
 use crate::rules::{
     flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except, flake8_boolean_trap,
     flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_datetimez, flake8_debugger,

crates/ruff/src/checkers/filesystem.rs

@@ -1,6 +1,8 @@
 use std::path::Path;
 
-use crate::registry::{Diagnostic, Rule};
+use ruff_diagnostics::Diagnostic;
+
+use crate::registry::Rule;
 use crate::rules::flake8_no_pep420::rules::implicit_namespace_package;
 use crate::rules::pep8_naming::rules::invalid_module_name;
 use crate::settings::Settings;

crates/ruff/src/checkers/imports.rs

@@ -4,13 +4,15 @@ use std::path::Path;
 
 use rustpython_parser::ast::Suite;
 
+use ruff_diagnostics::Diagnostic;
+use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
+use ruff_python_ast::visitor::Visitor;
+
 use crate::directives::IsortDirectives;
-use crate::registry::{Diagnostic, Rule};
+use crate::registry::Rule;
 use crate::rules::isort;
 use crate::rules::isort::track::{Block, ImportTracker};
 use crate::settings::{flags, Settings};
-use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-use ruff_python_ast::visitor::Visitor;
 
 #[allow(clippy::too_many_arguments)]
 pub fn check_imports(

crates/ruff/src/checkers/logical_lines.rs

@@ -5,7 +5,11 @@ use itertools::Itertools;
 use rustpython_parser::ast::Location;
 use rustpython_parser::lexer::LexResult;
 
-use crate::registry::{AsRule, Diagnostic, Rule};
+use ruff_diagnostics::Diagnostic;
+use ruff_python_ast::source_code::{Locator, Stylist};
+use ruff_python_ast::types::Range;
+
+use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle::logical_lines::{iter_logical_lines, TokenFlags};
 use crate::rules::pycodestyle::rules::{
     extraneous_whitespace, indentation, missing_whitespace, missing_whitespace_after_keyword,
@@ -14,8 +18,6 @@ use crate::rules::pycodestyle::rules::{
     whitespace_before_parameters,
 };
 use crate::settings::{flags, Settings};
-use ruff_python_ast::source_code::{Locator, Stylist};
-use ruff_python_ast::types::Range;
 
 /// Return the amount of indentation, expanding tabs to the next multiple of 8.
 fn expand_indent(mut line: &str) -> usize {
@@ -225,9 +227,10 @@ mod tests {
     use rustpython_parser::lexer::LexResult;
     use rustpython_parser::{lexer, Mode};
 
-    use crate::checkers::logical_lines::iter_logical_lines;
     use ruff_python_ast::source_code::Locator;
 
+    use crate::checkers::logical_lines::iter_logical_lines;
+
     #[test]
     fn split_logical_lines() {
         let contents = r#"

crates/ruff/src/checkers/noqa.rs

@@ -4,13 +4,13 @@ use log::warn;
 use nohash_hasher::IntMap;
 use rustpython_parser::ast::Location;
 
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_python_ast::types::Range;
 
 use crate::codes::NoqaCode;
-use crate::fix::Fix;
 use crate::noqa;
 use crate::noqa::{extract_file_exemption, Directive, Exemption};
-use crate::registry::{AsRule, Diagnostic, Rule};
+use crate::registry::{AsRule, Rule};
 use crate::rule_redirects::get_redirect_target;
 use crate::rules::ruff::rules::{UnusedCodes, UnusedNOQA};
 use crate::settings::{flags, Settings};

crates/ruff/src/checkers/physical_lines.rs

@@ -2,7 +2,10 @@
 
 use std::path::Path;
 
-use crate::registry::{Diagnostic, Rule};
+use ruff_diagnostics::Diagnostic;
+use ruff_python_ast::source_code::Stylist;
+
+use crate::registry::Rule;
 use crate::rules::flake8_executable::helpers::{extract_shebang, ShebangDirective};
 use crate::rules::flake8_executable::rules::{
     shebang_missing, shebang_newline, shebang_not_executable, shebang_python, shebang_whitespace,
@@ -15,7 +18,6 @@ use crate::rules::pygrep_hooks::rules::{blanket_noqa, blanket_type_ignore};
 use crate::rules::pylint;
 use crate::rules::pyupgrade::rules::unnecessary_coding_comment;
 use crate::settings::{flags, Settings};
-use ruff_python_ast::source_code::Stylist;
 
 pub fn check_physical_lines(
     path: &Path,
@@ -179,13 +181,14 @@ pub fn check_physical_lines(
 
 #[cfg(test)]
 mod tests {
-
     use std::path::Path;
 
-    use super::check_physical_lines;
+    use ruff_python_ast::source_code::{Locator, Stylist};
+
     use crate::registry::Rule;
     use crate::settings::{flags, Settings};
-    use ruff_python_ast::source_code::{Locator, Stylist};
+
+    use super::check_physical_lines;
 
     #[test]
     fn e501_non_ascii_char() {

crates/ruff/src/checkers/tokens.rs

@@ -4,13 +4,14 @@ use rustpython_parser::lexer::LexResult;
 use rustpython_parser::Tok;
 
 use crate::lex::docstring_detection::StateMachine;
-use crate::registry::{AsRule, Diagnostic, Rule};
+use crate::registry::{AsRule, Rule};
 use crate::rules::ruff::rules::Context;
 use crate::rules::{
     eradicate, flake8_commas, flake8_implicit_str_concat, flake8_pyi, flake8_quotes, pycodestyle,
     pyupgrade, ruff,
 };
 use crate::settings::{flags, Settings};
+use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::source_code::Locator;
 
 pub fn check_tokens(

crates/ruff/src/fix.rs

@@ -1,6 +1,3 @@
-use rustpython_parser::ast::Location;
-use serde::{Deserialize, Serialize};
-
 #[derive(Debug, Copy, Clone, Hash)]
 pub enum FixMode {
     Generate,
@@ -18,40 +15,3 @@ impl From<bool> for FixMode {
         }
     }
 }
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct Fix {
-    pub content: String,
-    pub location: Location,
-    pub end_location: Location,
-}
-
-impl Fix {
-    pub const fn deletion(start: Location, end: Location) -> Self {
-        Self {
-            content: String::new(),
-            location: start,
-            end_location: end,
-        }
-    }
-
-    pub fn replacement(content: String, start: Location, end: Location) -> Self {
-        debug_assert!(!content.is_empty(), "Prefer `Fix::deletion`");
-
-        Self {
-            content,
-            location: start,
-            end_location: end,
-        }
-    }
-
-    pub fn insertion(content: String, at: Location) -> Self {
-        debug_assert!(!content.is_empty(), "Insert content is empty");
-
-        Self {
-            content,
-            location: at,
-            end_location: at,
-        }
-    }
-}

crates/ruff/src/lib.rs

@@ -9,7 +9,6 @@ pub use ruff_python_ast::source_code::round_trip;
 pub use ruff_python_ast::types::Range;
 pub use rule_selector::RuleSelector;
 pub use rules::pycodestyle::rules::IOError;
-pub use violation::{AutofixKind, Availability as AutofixAvailability};
 
 mod autofix;
 mod checkers;
@@ -33,7 +32,6 @@ mod rule_redirects;
 mod rule_selector;
 pub mod rules;
 pub mod settings;
-mod violation;
 
 #[cfg(test)]
 mod test;

crates/ruff/src/linter.rs

@@ -4,11 +4,14 @@ use std::path::Path;
 use anyhow::{anyhow, Result};
 use colored::Colorize;
 use log::error;
-use ruff_python_stdlib::path::is_python_stub_file;
 use rustc_hash::FxHashMap;
 use rustpython_parser::lexer::LexResult;
 use rustpython_parser::ParseError;
 
+use ruff_diagnostics::Diagnostic;
+use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
+use ruff_python_stdlib::path::is_python_stub_file;
+
 use crate::autofix::fix_file;
 use crate::checkers::ast::check_ast;
 use crate::checkers::filesystem::check_file_path;
@@ -21,11 +24,10 @@ use crate::directives::Directives;
 use crate::doc_lines::{doc_lines_from_ast, doc_lines_from_tokens};
 use crate::message::{Message, Source};
 use crate::noqa::{add_noqa, rule_is_ignored};
-use crate::registry::{AsRule, Diagnostic, Rule};
+use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle;
 use crate::settings::{flags, Settings};
 use crate::{directives, fs};
-use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
 
 const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
 const CARGO_PKG_REPOSITORY: &str = env!("CARGO_PKG_REPOSITORY");

crates/ruff/src/message.rs

@@ -3,8 +3,7 @@ use std::cmp::Ordering;
 pub use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
 
-use crate::fix::Fix;
-use crate::registry::{Diagnostic, DiagnosticKind};
+use ruff_diagnostics::{Diagnostic, DiagnosticKind, Fix};
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 

crates/ruff/src/noqa.rs

@@ -11,11 +11,12 @@ use regex::Regex;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_parser::ast::Location;
 
+use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::source_code::{LineEnding, Locator};
 use ruff_python_ast::types::Range;
 
 use crate::codes::NoqaCode;
-use crate::registry::{AsRule, Diagnostic, Rule};
+use crate::registry::{AsRule, Rule};
 use crate::rule_redirects::get_redirect_target;
 
 static NOQA_LINE_REGEX: Lazy<Regex> = Lazy::new(|| {
@@ -333,11 +334,11 @@ mod tests {
     use nohash_hasher::IntMap;
     use rustpython_parser::ast::Location;
 
+    use ruff_diagnostics::Diagnostic;
     use ruff_python_ast::source_code::LineEnding;
     use ruff_python_ast::types::Range;
 
     use crate::noqa::{add_noqa_inner, NOQA_LINE_REGEX};
-    use crate::registry::Diagnostic;
     use crate::rules::pycodestyle::rules::AmbiguousVariableName;
     use crate::rules::pyflakes;
 

crates/ruff/src/registry.rs

@@ -1,16 +1,12 @@
-//! Registry of [`Rule`] to [`DiagnosticKind`] mappings.
+//! Registry of all [`Rule`] implementations.
 
-use rustpython_parser::ast::Location;
-use serde::{Deserialize, Serialize};
 use strum_macros::{AsRefStr, EnumIter};
 
+use ruff_diagnostics::Violation;
 use ruff_macros::RuleNamespace;
-use ruff_python_ast::types::Range;
 
 use crate::codes::{self, RuleCodePrefix};
-use crate::fix::Fix;
 use crate::rules;
-use crate::violation::Violation;
 
 ruff_macros::register_rules!(
     // pycodestyle errors
@@ -899,49 +895,6 @@ impl Rule {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct DiagnosticKind {
-    /// The identifier of the corresponding [`Rule`].
-    pub name: String,
-    /// The message body to display to the user, to explain the diagnostic.
-    pub body: String,
-    /// The message to display to the user, to explain the suggested fix.
-    pub suggestion: Option<String>,
-    /// Whether the diagnostic is automatically fixable.
-    pub fixable: bool,
-}
-
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Diagnostic {
-    pub kind: DiagnosticKind,
-    pub location: Location,
-    pub end_location: Location,
-    pub fix: Option<Fix>,
-    pub parent: Option<Location>,
-}
-
-impl Diagnostic {
-    pub fn new<K: Into<DiagnosticKind>>(kind: K, range: Range) -> Self {
-        Self {
-            kind: kind.into(),
-            location: range.location,
-            end_location: range.end_location,
-            fix: None,
-            parent: None,
-        }
-    }
-
-    pub fn amend(&mut self, fix: Fix) -> &mut Self {
-        self.fix = Some(fix);
-        self
-    }
-
-    pub fn parent(&mut self, parent: Location) -> &mut Self {
-        self.parent = Some(parent);
-        self
-    }
-}
-
 /// Pairs of checks that shouldn't be enabled together.
 pub const INCOMPATIBLE_CODES: &[(Rule, Rule, &str); 2] = &[
     (

crates/ruff/src/rules/eradicate/rules.rs

@@ -1,13 +1,12 @@
 use rustpython_parser::ast::Location;
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 
-use crate::fix::Fix;
-use crate::registry::{Diagnostic, Rule};
+use crate::registry::Rule;
 use crate::settings::{flags, Settings};
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::detection::comment_contains_code;
 

crates/ruff/src/rules/flake8_2020/rules.rs

@@ -1,12 +1,12 @@
 use num_bigint::BigInt;
 use rustpython_parser::ast::{Cmpop, Constant, Expr, ExprKind, Located};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{Diagnostic, Rule};
-use crate::violation::Violation;
+use crate::registry::Rule;
 
 #[violation]
 pub struct SysVersionSlice3Referenced;

crates/ruff/src/rules/flake8_annotations/fixes.rs

@@ -2,11 +2,10 @@ use anyhow::{bail, Result};
 use rustpython_parser::ast::Stmt;
 use rustpython_parser::{lexer, Mode, Tok};
 
+use ruff_diagnostics::Fix;
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 
-use crate::fix::Fix;
-
 /// ANN204
 pub fn add_return_none_annotation(locator: &Locator, stmt: &Stmt) -> Result<Fix> {
     let range = Range::from(stmt);

crates/ruff/src/rules/flake8_annotations/rules.rs

@@ -1,6 +1,7 @@
 use log::error;
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::ReturnStatementVisitor;
 use ruff_python_ast::types::Range;
@@ -11,8 +12,7 @@ use ruff_python_ast::{cast, helpers};
 
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
-use crate::registry::{AsRule, Diagnostic, Rule};
-use crate::violation::{AlwaysAutofixableViolation, Violation};
+use crate::registry::{AsRule, Rule};
 
 use super::fixes;
 use super::helpers::match_function_def;

crates/ruff/src/rules/flake8_bandit/rules/assert_used.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::Stmt;
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 #[violation]
 pub struct Assert;
 

crates/ruff/src/rules/flake8_bandit/rules/bad_file_permissions.rs

@@ -3,13 +3,12 @@ use once_cell::sync::Lazy;
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword, Operator};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::{compose_call_path, SimpleCallArgs};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct BadFilePermissions {

crates/ruff/src/rules/flake8_bandit/rules/exec_used.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 #[violation]
 pub struct ExecBuiltin;
 

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_bind_all_interfaces.rs

@@ -1,9 +1,7 @@
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 #[violation]
 pub struct HardcodedBindAllInterfaces;
 

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_default.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::{Arg, Arguments, Expr};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 use super::super::helpers::{matches_password_name, string_literal};
 
 #[violation]

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_func_arg.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::Keyword;
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 use super::super::helpers::{matches_password_name, string_literal};
 
 #[violation]

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_password_string.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 use super::super::helpers::{matches_password_name, string_literal};
 
 #[violation]

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_sql_expression.rs

@@ -2,13 +2,12 @@ use once_cell::sync::Lazy;
 use regex::Regex;
 use rustpython_parser::ast::{Expr, ExprKind, Operator};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::{any_over_expr, unparse_expr};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::super::helpers::string_literal;
 

crates/ruff/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::Expr;
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 #[violation]
 pub struct HardcodedTempFile {
     pub string: String,

crates/ruff/src/rules/flake8_bandit/rules/hashlib_insecure_hash_functions.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::super::helpers::string_literal;
 

crates/ruff/src/rules/flake8_bandit/rules/jinja2_autoescape_false.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct Jinja2AutoescapeFalse {

crates/ruff/src/rules/flake8_bandit/rules/logging_config_insecure_listen.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Expr, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct LoggingConfigInsecureListen;

crates/ruff/src/rules/flake8_bandit/rules/request_with_no_cert_validation.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct RequestWithNoCertValidation {

crates/ruff/src/rules/flake8_bandit/rules/request_without_timeout.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::{unparse_constant, SimpleCallArgs};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct RequestWithoutTimeout {

crates/ruff/src/rules/flake8_bandit/rules/snmp_insecure_version.rs

@@ -1,13 +1,12 @@
 use num_traits::{One, Zero};
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct SnmpInsecureVersion;

crates/ruff/src/rules/flake8_bandit/rules/snmp_weak_cryptography.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Expr, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct SnmpWeakCryptography;

crates/ruff/src/rules/flake8_bandit/rules/try_except_continue.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Excepthandler, Expr, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
 use crate::rules::flake8_bandit::helpers::is_untyped_exception;
-use crate::violation::Violation;
 
 #[violation]
 pub struct TryExceptContinue;

crates/ruff/src/rules/flake8_bandit/rules/try_except_pass.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Excepthandler, Expr, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
 use crate::rules::flake8_bandit::helpers::is_untyped_exception;
-use crate::violation::Violation;
 
 #[violation]
 pub struct TryExceptPass;

crates/ruff/src/rules/flake8_bandit/rules/unsafe_yaml_load.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::SimpleCallArgs;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UnsafeYAMLLoad {

crates/ruff/src/rules/flake8_blind_except/rules.rs

@@ -1,13 +1,12 @@
 use rustpython_parser::ast::{Expr, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers;
 use ruff_python_ast::helpers::{find_keyword, is_const_true};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct BlindExcept {

crates/ruff/src/rules/flake8_boolean_trap/rules.rs

@@ -1,12 +1,12 @@
 use rustpython_parser::ast::{Arguments, Constant, Expr, ExprKind};
 
+use ruff_diagnostics::Violation;
+use ruff_diagnostics::{Diagnostic, DiagnosticKind};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::collect_call_path;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{Diagnostic, DiagnosticKind};
-use crate::violation::Violation;
 
 #[violation]
 pub struct BooleanPositionalArgInFunctionDefinition;

crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs

@@ -1,12 +1,12 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 use ruff_python_ast::visibility::{is_abstract, is_overload};
 
 use crate::checkers::ast::Checker;
-use crate::registry::{Diagnostic, Rule};
-use crate::violation::Violation;
+use crate::registry::Rule;
 
 #[violation]
 pub struct AbstractBaseClassWithoutAbstractMethod {

crates/ruff/src/rules/flake8_bugbear/rules/assert_false.rs

@@ -1,13 +1,12 @@
 use rustpython_parser::ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::unparse_stmt;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic};
-use crate::violation::AlwaysAutofixableViolation;
+use crate::registry::AsRule;
 
 #[violation]
 pub struct AssertFalse;

crates/ruff/src/rules/flake8_bugbear/rules/assert_raises_exception.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{ExprKind, Stmt, Withitem};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 /// ## What it does
 /// Checks for `self.assertRaises(Exception)`.

crates/ruff/src/rules/flake8_bugbear/rules/assignment_to_os_environ.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct AssignmentToOsEnviron;

crates/ruff/src/rules/flake8_bugbear/rules/cached_instance_method.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::{Range, ScopeKind};
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct CachedInstanceMethod;

crates/ruff/src/rules/flake8_bugbear/rules/cannot_raise_literal.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct CannotRaiseLiteral;

crates/ruff/src/rules/flake8_bugbear/rules/duplicate_exceptions.rs

@@ -4,15 +4,15 @@ use rustpython_parser::ast::{
     Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind, Location,
 };
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Violation};
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers;
 use ruff_python_ast::helpers::unparse_expr;
 use ruff_python_ast::types::{CallPath, Range};
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic, Rule};
-use crate::violation::{AlwaysAutofixableViolation, Violation};
+use crate::registry::{AsRule, Rule};
 
 #[violation]
 pub struct DuplicateTryBlockException {

crates/ruff/src/rules/flake8_bugbear/rules/except_with_empty_tuple.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::Excepthandler;
 use rustpython_parser::ast::{ExcepthandlerKind, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct ExceptWithEmptyTuple;

crates/ruff/src/rules/flake8_bugbear/rules/except_with_non_exception_classes.rs

@@ -2,12 +2,11 @@ use std::collections::VecDeque;
 
 use rustpython_parser::ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct ExceptWithNonExceptionClasses;

crates/ruff/src/rules/flake8_bugbear/rules/f_string_docstring.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct FStringDocstring;

crates/ruff/src/rules/flake8_bugbear/rules/function_call_argument_default.rs

@@ -1,5 +1,7 @@
 use rustpython_parser::ast::{Arguments, Constant, Expr, ExprKind};
 
+use ruff_diagnostics::Violation;
+use ruff_diagnostics::{Diagnostic, DiagnosticKind};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::{compose_call_path, to_call_path};
 use ruff_python_ast::types::{CallPath, Range};
@@ -7,8 +9,6 @@ use ruff_python_ast::visitor;
 use ruff_python_ast::visitor::Visitor;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{Diagnostic, DiagnosticKind};
-use crate::violation::Violation;
 
 use super::mutable_argument_default::is_mutable_func;
 

crates/ruff/src/rules/flake8_bugbear/rules/function_uses_loop_variable.rs

@@ -1,6 +1,7 @@
 use rustc_hash::FxHashSet;
 use rustpython_parser::ast::{Comprehension, Expr, ExprContext, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::collect_arg_names;
 use ruff_python_ast::types::{Node, Range};
@@ -8,8 +9,6 @@ use ruff_python_ast::visitor;
 use ruff_python_ast::visitor::Visitor;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct FunctionUsesLoopVariable {

crates/ruff/src/rules/flake8_bugbear/rules/getattr_with_constant.rs

@@ -1,5 +1,6 @@
 use rustpython_parser::ast::{Constant, Expr, ExprContext, ExprKind, Location};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::unparse_expr;
 use ruff_python_ast::types::Range;
@@ -7,9 +8,7 @@ use ruff_python_stdlib::identifiers::{is_identifier, is_mangled_private};
 use ruff_python_stdlib::keyword::KWLIST;
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic};
-use crate::violation::AlwaysAutofixableViolation;
+use crate::registry::AsRule;
 
 #[violation]
 pub struct GetAttrWithConstant;

crates/ruff/src/rules/flake8_bugbear/rules/jump_statement_in_finally.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct JumpStatementInFinally {

crates/ruff/src/rules/flake8_bugbear/rules/loop_variable_overrides_iterator.rs

@@ -1,14 +1,13 @@
 use rustc_hash::FxHashMap;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 use ruff_python_ast::visitor;
 use ruff_python_ast::visitor::Visitor;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct LoopVariableOverridesIterator {

crates/ruff/src/rules/flake8_bugbear/rules/mutable_argument_default.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Arguments, Constant, Expr, ExprKind, Operator};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct MutableArgumentDefault;

crates/ruff/src/rules/flake8_bugbear/rules/raise_without_from_inside_except.rs

@@ -1,13 +1,12 @@
 use rustpython_parser::ast::{ExprKind, Stmt};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::RaiseStatementVisitor;
 use ruff_python_ast::visitor;
 use ruff_python_stdlib::str::is_lower;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct RaiseWithoutFromInsideExcept;

crates/ruff/src/rules/flake8_bugbear/rules/redundant_tuple_in_exception_handler.rs

@@ -1,13 +1,12 @@
 use rustpython_parser::ast::{Excepthandler, ExcepthandlerKind, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::unparse_expr;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic};
-use crate::violation::AlwaysAutofixableViolation;
+use crate::registry::AsRule;
 
 #[violation]
 pub struct RedundantTupleInExceptionHandler {

crates/ruff/src/rules/flake8_bugbear/rules/setattr_with_constant.rs

@@ -1,5 +1,6 @@
 use rustpython_parser::ast::{Constant, Expr, ExprContext, ExprKind, Location, Stmt, StmtKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::unparse_stmt;
 use ruff_python_ast::source_code::Stylist;
@@ -8,9 +9,7 @@ use ruff_python_stdlib::identifiers::{is_identifier, is_mangled_private};
 use ruff_python_stdlib::keyword::KWLIST;
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic};
-use crate::violation::AlwaysAutofixableViolation;
+use crate::registry::AsRule;
 
 #[violation]
 pub struct SetAttrWithConstant;

crates/ruff/src/rules/flake8_bugbear/rules/star_arg_unpacking_after_keyword_arg.rs

@@ -9,12 +9,11 @@
 
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct StarArgUnpackingAfterKeywordArg;

crates/ruff/src/rules/flake8_bugbear/rules/strip_with_multi_characters.rs

@@ -1,12 +1,11 @@
 use itertools::Itertools;
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct StripWithMultiCharacters;

crates/ruff/src/rules/flake8_bugbear/rules/unary_prefix_increment.rs

@@ -19,12 +19,11 @@
 
 use rustpython_parser::ast::{Expr, ExprKind, Unaryop};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UnaryPrefixIncrement;

crates/ruff/src/rules/flake8_bugbear/rules/unintentional_type_annotation.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind, Stmt};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 /// ## What it does
 /// Checks for the unintentional use of type annotations.

crates/ruff/src/rules/flake8_bugbear/rules/unreliable_callable_check.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UnreliableCallableCheck;

crates/ruff/src/rules/flake8_bugbear/rules/unused_loop_control_variable.rs

@@ -22,15 +22,14 @@ use rustc_hash::FxHashMap;
 use rustpython_parser::ast::{Expr, ExprKind, Stmt};
 use serde::{Deserialize, Serialize};
 
+use ruff_diagnostics::{AutofixKind, Availability, Diagnostic, Fix, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::{Range, RefEquality};
 use ruff_python_ast::visitor::Visitor;
 use ruff_python_ast::{helpers, visitor};
 
 use crate::checkers::ast::Checker;
-use crate::fix::Fix;
-use crate::registry::{AsRule, Diagnostic};
-use crate::violation::{AutofixKind, Availability, Violation};
+use crate::registry::AsRule;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, result_like::BoolLike)]
 pub enum Certainty {

crates/ruff/src/rules/flake8_bugbear/rules/useless_comparison.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UselessComparison;

crates/ruff/src/rules/flake8_bugbear/rules/useless_contextlib_suppress.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::Expr;
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UselessContextlibSuppress;

crates/ruff/src/rules/flake8_bugbear/rules/useless_expression.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Constant, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct UselessExpression;

crates/ruff/src/rules/flake8_bugbear/rules/zip_without_explicit_strict.rs

@@ -1,11 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct ZipWithoutExplicitStrict;

crates/ruff/src/rules/flake8_builtins/rules.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::Located;
 
+use ruff_diagnostics::Violation;
+use ruff_diagnostics::{Diagnostic, DiagnosticKind};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 use ruff_python_stdlib::builtins::BUILTINS;
 
-use crate::registry::{Diagnostic, DiagnosticKind};
-use crate::violation::Violation;
-
 use super::types::ShadowingType;
 
 /// ## What it does

crates/ruff/src/rules/flake8_commas/rules.rs

@@ -2,14 +2,14 @@ use itertools::Itertools;
 use rustpython_parser::lexer::{LexResult, Spanned};
 use rustpython_parser::Tok;
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Violation};
+use ruff_diagnostics::{Diagnostic, Fix};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::types::Range;
 
-use crate::fix::Fix;
-use crate::registry::{Diagnostic, Rule};
+use crate::registry::Rule;
 use crate::settings::{flags, Settings};
-use crate::violation::{AlwaysAutofixableViolation, Violation};
 
 /// Simplified token type.
 #[derive(Copy, Clone, PartialEq, Eq)]

crates/ruff/src/rules/flake8_comprehensions/fixes.rs

@@ -7,10 +7,10 @@ use libcst_native::{
     RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace, Tuple,
 };
 
+use ruff_diagnostics::Fix;
 use ruff_python_ast::source_code::{Locator, Stylist};
 
 use crate::cst::matchers::{match_expr, match_module};
-use crate::fix::Fix;
 
 fn match_call<'a, 'b>(expr: &'a mut Expr<'b>) -> Result<&'a mut Call<'b>> {
     if let Expression::Call(call) = &mut expr.value {

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_call_around_sorted.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_collection_call.rs

@@ -1,14 +1,14 @@
 use log::error;
 use rustpython_parser::ast::{Expr, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
 use crate::rules::flake8_comprehensions::settings::Settings;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_comprehension.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Comprehension, Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_double_cast_or_process.rs

@@ -1,12 +1,12 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_dict.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_list.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_generator_set.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_call.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_comprehension_dict.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_list_comprehension_set.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_dict.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_set.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_list_call.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_tuple_call.rs

@@ -1,13 +1,13 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::AlwaysAutofixableViolation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_map.rs

@@ -1,13 +1,14 @@
 use log::error;
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::Diagnostic;
+use ruff_diagnostics::{AutofixKind, Availability, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 use crate::rules::flake8_comprehensions::fixes;
-use crate::violation::{AutofixKind, Availability, Violation};
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_comprehensions/rules/unnecessary_subscript_reversal.rs

@@ -1,12 +1,11 @@
 use num_bigint::BigInt;
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Unaryop};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_datetimez/rules.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::{has_non_none_keyword, is_const_none};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 #[violation]
 pub struct CallDatetimeWithoutTzinfo;

crates/ruff/src/rules/flake8_debugger/rules.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Expr, Stmt};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::format_call_path;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::types::DebuggerUsingType;
 

crates/ruff/src/rules/flake8_django/rules/all_with_model_form.rs

@@ -1,11 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
+use crate::checkers::ast::Checker;
 use crate::rules::flake8_django::rules::helpers::is_model_form;
-use crate::violation::Violation;
-use crate::{checkers::ast::Checker, registry::Diagnostic};
 
 /// ## What it does
 /// Checks for the use of `fields = "__all__"` in Django `ModelForm`

crates/ruff/src/rules/flake8_django/rules/exclude_with_model_form.rs

@@ -1,11 +1,11 @@
 use rustpython_parser::ast::{Expr, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
+use crate::checkers::ast::Checker;
 use crate::rules::flake8_django::rules::helpers::is_model_form;
-use crate::violation::Violation;
-use crate::{checkers::ast::Checker, registry::Diagnostic};
 
 /// ## What it does
 /// Checks for the use of `exclude` in Django `ModelForm` classes.

crates/ruff/src/rules/flake8_django/rules/locals_in_render_function.rs

@@ -1,9 +1,10 @@
 use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::{checkers::ast::Checker, registry::Diagnostic, violation::Violation};
+use crate::checkers::ast::Checker;
 
 /// ## What it does
 /// Checks for the use of `locals()` in `render` functions.

crates/ruff/src/rules/flake8_django/rules/model_without_dunder_str.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, StmtKind};
 use rustpython_parser::ast::{ExprKind, Stmt};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_django/rules/non_leading_receiver_decorator.rs

@@ -1,11 +1,9 @@
 use rustpython_parser::ast::{Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::{CallPath, Range};
 
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
-
 /// ## What it does
 /// Checks that Django's `@receiver` decorator is listed first, prior to
 /// any other decorators.

crates/ruff/src/rules/flake8_django/rules/nullable_model_string_field.rs

@@ -1,12 +1,11 @@
 use rustpython_parser::ast::Constant::Bool;
 use rustpython_parser::ast::{Expr, ExprKind, Stmt, StmtKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::Diagnostic;
-use crate::violation::Violation;
 
 use super::helpers;
 

crates/ruff/src/rules/flake8_errmsg/rules.rs

@@ -1,11 +1,11 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
-use crate::registry::{Diagnostic, Rule};
-use crate::violation::Violation;
+use crate::registry::Rule;
 
 /// ## What it does
 /// Checks for the use of string literals in exception constructors.

crates/ruff/src/rules/flake8_executable/rules/shebang_missing.rs

@@ -2,13 +2,13 @@
 
 use std::path::Path;
 
+use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::types::Range;
 
-use crate::registry::{AsRule, Diagnostic};
+use crate::registry::AsRule;
 #[cfg(target_family = "unix")]
 use crate::rules::flake8_executable::helpers::is_executable;
-use crate::violation::Violation;
 
 #[violation]
 pub struct ShebangMissingExecutableFile;