Account for selector specificity when merging extend_unsafe_fixes and override extend_safe_fixes (#8444)

## Summary

Prior to this change `extend_unsafe_fixes` took precedence over
`extend_safe_fixes` selectors, so any conflicts were resolved in favour
of `extend_unsafe_fixes`. Thanks to that ruff were conservatively
assuming that if configs conlict the fix corresponding to selected rule
will be treated as unsafe.

After this change we take into account Specificity of the selectors. For
conflicts between selectors of the same Specificity we will treat the
corresponding fixes as unsafe. But if the conflicting selectors are of
different specificity the more specific one will win.

## Test Plan

Tests were added for the `FixSafetyTable` struct. The
`check_extend_unsafe_fixes_conflict_with_extend_safe_fixes_by_specificity`
integration test was added to test conflicting rules of different
specificity.

Fixes #8404

---------

Co-authored-by: Zanie <contact@zanie.dev>

crates/ruff_linter/src/settings/fix_safety_table.rs

@@ -0,0 +1,188 @@
+use std::fmt::Debug;
+
+use ruff_diagnostics::Applicability;
+use ruff_macros::CacheKey;
+use rustc_hash::FxHashMap;
+use strum::IntoEnumIterator;
+
+use crate::{
+    registry::{Rule, RuleSet},
+    rule_selector::{PreviewOptions, Specificity},
+    RuleSelector,
+};
+
+/// A table to keep track of which rules fixes should have
+/// their safety overridden.
+#[derive(Debug, CacheKey, Default)]
+pub struct FixSafetyTable {
+    forced_safe: RuleSet,
+    forced_unsafe: RuleSet,
+}
+
+impl FixSafetyTable {
+    pub const fn resolve_applicability(
+        &self,
+        rule: Rule,
+        applicability: Applicability,
+    ) -> Applicability {
+        match applicability {
+            // If applicability is display-only we don't change it
+            Applicability::DisplayOnly => applicability,
+            Applicability::Safe | Applicability::Unsafe => {
+                if self.forced_unsafe.contains(rule) {
+                    Applicability::Unsafe
+                } else if self.forced_safe.contains(rule) {
+                    Applicability::Safe
+                } else {
+                    applicability
+                }
+            }
+        }
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.forced_safe.is_empty() && self.forced_unsafe.is_empty()
+    }
+
+    pub fn from_rule_selectors(
+        extend_safe_fixes: &[RuleSelector],
+        extend_unsafe_fixes: &[RuleSelector],
+        preview_options: &PreviewOptions,
+    ) -> Self {
+        enum Override {
+            Safe,
+            Unsafe,
+        }
+
+        let safety_override_map: FxHashMap<Rule, Override> = {
+            Specificity::iter()
+                .flat_map(|spec| {
+                    let safe_overrides = extend_safe_fixes
+                        .iter()
+                        .filter(|selector| selector.specificity() == spec)
+                        .flat_map(|selector| selector.rules(preview_options))
+                        .map(|rule| (rule, Override::Safe));
+
+                    let unsafe_overrides = extend_unsafe_fixes
+                        .iter()
+                        .filter(|selector| selector.specificity() == spec)
+                        .flat_map(|selector| selector.rules(preview_options))
+                        .map(|rule| (rule, Override::Unsafe));
+
+                    // Unsafe overrides take precedence over safe overrides
+                    safe_overrides.chain(unsafe_overrides).collect::<Vec<_>>()
+                })
+                // More specified selectors take precedence over less specified selectors
+                .collect()
+        };
+
+        FixSafetyTable {
+            forced_safe: safety_override_map
+                .iter()
+                .filter_map(|(rule, o)| match o {
+                    Override::Safe => Some(*rule),
+                    Override::Unsafe => None,
+                })
+                .collect(),
+            forced_unsafe: safety_override_map
+                .iter()
+                .filter_map(|(rule, o)| match o {
+                    Override::Unsafe => Some(*rule),
+                    Override::Safe => None,
+                })
+                .collect(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_resolve_applicability() {
+        let table = FixSafetyTable {
+            forced_safe: RuleSet::from_iter([Rule::RedefinedWhileUnused]),
+            forced_unsafe: RuleSet::from_iter([Rule::UnusedImport]),
+        };
+
+        for applicability in &[Applicability::Safe, Applicability::Unsafe] {
+            assert_eq!(
+                table.resolve_applicability(Rule::RedefinedWhileUnused, *applicability),
+                Applicability::Safe // It is forced to Safe
+            );
+        }
+        for applicability in &[Applicability::Safe, Applicability::Unsafe] {
+            assert_eq!(
+                table.resolve_applicability(Rule::UnusedImport, *applicability),
+                Applicability::Unsafe // It is forced to Unsafe
+            );
+        }
+        for applicability in &[Applicability::Safe, Applicability::Unsafe] {
+            assert_eq!(
+                table.resolve_applicability(Rule::UndefinedName, *applicability),
+                *applicability // Remains unchanged
+            );
+        }
+
+        for rule in &[
+            Rule::RedefinedWhileUnused,
+            Rule::UnusedImport,
+            Rule::UndefinedName,
+        ] {
+            assert_eq!(
+                table.resolve_applicability(*rule, Applicability::DisplayOnly),
+                Applicability::DisplayOnly // Display is never changed
+            );
+        }
+    }
+
+    fn mk_table(safe_fixes: &[&str], unsafe_fixes: &[&str]) -> FixSafetyTable {
+        FixSafetyTable::from_rule_selectors(
+            &safe_fixes
+                .iter()
+                .map(|s| s.parse().unwrap())
+                .collect::<Vec<_>>(),
+            &unsafe_fixes
+                .iter()
+                .map(|s| s.parse().unwrap())
+                .collect::<Vec<_>>(),
+            &PreviewOptions::default(),
+        )
+    }
+
+    fn assert_rules_safety(
+        table: &FixSafetyTable,
+        assertions: &[(&str, Applicability, Applicability)],
+    ) {
+        for (code, applicability, expected) in assertions {
+            assert_eq!(
+                table.resolve_applicability(Rule::from_code(code).unwrap(), *applicability),
+                *expected
+            );
+        }
+    }
+
+    #[test]
+    fn test_from_rule_selectors_specificity() {
+        use Applicability::{Safe, Unsafe};
+        let table = mk_table(&["UP"], &["ALL", "UP001"]);
+
+        assert_rules_safety(
+            &table,
+            &[
+                ("E101", Safe, Unsafe),
+                ("UP001", Safe, Unsafe),
+                ("UP003", Unsafe, Safe),
+            ],
+        );
+    }
+
+    #[test]
+    fn test_from_rule_selectors_unsafe_over_safe() {
+        use Applicability::{Safe, Unsafe};
+        let table = mk_table(&["UP"], &["UP"]);
+
+        assert_rules_safety(&table, &[("E101", Safe, Safe), ("UP001", Safe, Unsafe)]);
+    }
+}

crates/ruff_linter/src/settings/mod.rs

@@ -28,10 +28,12 @@ use crate::{codes, RuleSelector};
 
 use super::line_width::IndentWidth;
 
+use self::fix_safety_table::FixSafetyTable;
 use self::rule_table::RuleTable;
 use self::types::PreviewMode;
 use crate::rule_selector::PreviewOptions;
 
+pub mod fix_safety_table;
 pub mod flags;
 pub mod rule_table;
 pub mod types;
@@ -43,8 +45,7 @@ pub struct LinterSettings {
 
     pub rules: RuleTable,
     pub per_file_ignores: Vec<(GlobMatcher, GlobMatcher, RuleSet)>,
-    pub extend_unsafe_fixes: RuleSet,
-    pub extend_safe_fixes: RuleSet,
+    pub fix_safety: FixSafetyTable,
 
     pub target_version: PythonVersion,
     pub preview: PreviewMode,
@@ -151,8 +152,7 @@ impl LinterSettings {
             namespace_packages: vec![],
 
             per_file_ignores: vec![],
-            extend_safe_fixes: RuleSet::empty(),
-            extend_unsafe_fixes: RuleSet::empty(),
+            fix_safety: FixSafetyTable::default(),
 
             src: vec![path_dedot::CWD.clone()],
             // Needs duplicating