Filter off-by-default RUF014 out of schema (#5832)

**Summary** Previously, `RUF014` would be part of ruff.schema.json
depending on whether or not the `unreachable-code` feature was active.
This caused problems for contributors who got unrelated RUF014 changes
when updating the schema without the feature active.

An alternative would be to always add `RUF014`.

**Test plan** `cargo dev generate-all` and `cargo run --bin ruff_dev
--features unreachable-code -- generate-all` now have the same effect.

crates/ruff/src/codes.rs

@@ -782,7 +782,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "011") => (RuleGroup::Unspecified, rules::ruff::rules::StaticKeyDictComprehension),
         (Ruff, "012") => (RuleGroup::Unspecified, rules::ruff::rules::MutableClassDefault),
         (Ruff, "013") => (RuleGroup::Unspecified, rules::ruff::rules::ImplicitOptional),
-        #[cfg(feature = "unreachable-code")]
+        #[cfg(feature = "unreachable-code")] // When removing this feature gate, also update rules_selector.rs
         (Ruff, "014") => (RuleGroup::Nursery, rules::ruff::rules::UnreachableCode),
         (Ruff, "015") => (RuleGroup::Unspecified, rules::ruff::rules::UnnecessaryIterableAllocationForFirstElement),
         (Ruff, "016") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidIndexType),

crates/ruff/src/rule_selector.rs

@@ -249,6 +249,9 @@ mod schema {
                                 (!prefix.is_empty()).then(|| prefix.to_string())
                             })),
                     )
+                    // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
+                    // off-by-default
+                    .filter(|prefix| prefix != "RUF014")
                     .sorted()
                     .map(Value::String)
                     .collect(),
@@ -342,24 +345,33 @@ mod clap_completion {
                             let prefix = l.common_prefix();
                             (!prefix.is_empty()).then(|| PossibleValue::new(prefix).help(l.name()))
                         })
-                        .chain(RuleCodePrefix::iter().map(|p| {
+                        .chain(
-                            let prefix = p.linter().common_prefix();
+                            RuleCodePrefix::iter()
-                            let code = p.short_code();
+                                // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
+                                // off-by-default
+                                .filter(|p| {
+                                    format!("{}{}", p.linter().common_prefix(), p.short_code())
+                                        != "RUF014"
+                                })
+                                .map(|p| {
+                                    let prefix = p.linter().common_prefix();
+                                    let code = p.short_code();
 
-                            let mut rules_iter = p.rules();
+                                    let mut rules_iter = p.rules();
-                            let rule1 = rules_iter.next();
+                                    let rule1 = rules_iter.next();
-                            let rule2 = rules_iter.next();
+                                    let rule2 = rules_iter.next();
 
-                            let value = PossibleValue::new(format!("{prefix}{code}"));
+                                    let value = PossibleValue::new(format!("{prefix}{code}"));
 
-                            if rule2.is_none() {
+                                    if rule2.is_none() {
-                                let rule1 = rule1.unwrap();
+                                        let rule1 = rule1.unwrap();
-                                let name: &'static str = rule1.into();
+                                        let name: &'static str = rule1.into();
-                                value.help(name)
+                                        value.help(name)
-                            } else {
+                                    } else {
-                                value
+                                        value
-                            }
+                                    }
-                        })),
+                                }),
+                        ),
                 ),
             ))
         }

crates/ruff_dev/src/generate_json_schema.rs

@@ -61,7 +61,7 @@ mod tests {
 
     use super::{main, Args};
 
-    #[cfg_attr(not(feature = "unreachable-code"), test)]
+    #[test]
     fn test_generate_json_schema() -> Result<()> {
         let mode = if env::var("RUFF_UPDATE_SCHEMA").as_deref() == Ok("1") {
             Mode::Write

ruff.schema.json

@@ -2409,7 +2409,6 @@
         "RUF011",
         "RUF012",
         "RUF013",
-        "RUF014",
         "RUF015",
         "RUF016",
         "RUF1",