Rename `runtime-evaluated-baseclasses` to `runtime-evaluated-base-classes` (#3379)

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

@@ -2090,7 +2090,7 @@ where
                         let baseclasses = &self
                             .settings
                             .flake8_type_checking
-                            .runtime_evaluated_baseclasses;
+                            .runtime_evaluated_base_classes;
                         let decorators = &self
                             .settings
                             .flake8_type_checking

crates/ruff/src/rules/flake8_type_checking/helpers.rs

@@ -63,7 +63,7 @@ pub fn runtime_evaluated(
     decorators: &[String],
 ) -> bool {
     if !base_classes.is_empty() {
-        if runtime_evaluated_baseclass(context, base_classes) {
+        if runtime_evaluated_base_class(context, base_classes) {
             return true;
         }
     }
@@ -75,7 +75,7 @@ pub fn runtime_evaluated(
     false
 }
 
-fn runtime_evaluated_baseclass(context: &Context, base_classes: &[String]) -> bool {
+fn runtime_evaluated_base_class(context: &Context, base_classes: &[String]) -> bool {
     if let ScopeKind::Class(class_def) = &context.current_scope().kind {
         for base in class_def.bases.iter() {
             if let Some(call_path) = context.resolve_call_path(base) {

crates/ruff/src/rules/flake8_type_checking/mod.rs

@@ -77,16 +77,16 @@ mod tests {
         Ok(())
     }
 
-    #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("runtime_evaluated_baseclasses_1.py"); "runtime_evaluated_baseclasses_1")]
-    #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("runtime_evaluated_baseclasses_2.py"); "runtime_evaluated_baseclasses_2")]
-    #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("runtime_evaluated_baseclasses_3.py"); "runtime_evaluated_baseclasses_3")]
-    fn runtime_evaluated_baseclasses(rule_code: Rule, path: &Path) -> Result<()> {
+    #[test_case(Rule::RuntimeImportInTypeCheckingBlock, Path::new("runtime_evaluated_base_classes_1.py"); "runtime_evaluated_base_classes_1")]
+    #[test_case(Rule::TypingOnlyThirdPartyImport, Path::new("runtime_evaluated_base_classes_2.py"); "runtime_evaluated_base_classes_2")]
+    #[test_case(Rule::TypingOnlyStandardLibraryImport, Path::new("runtime_evaluated_base_classes_3.py"); "runtime_evaluated_base_classes_3")]
+    fn runtime_evaluated_base_classes(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.as_ref(), path.to_string_lossy());
         let diagnostics = test_path(
             Path::new("flake8_type_checking").join(path).as_path(),
             &settings::Settings {
                 flake8_type_checking: super::settings::Settings {
-                    runtime_evaluated_baseclasses: vec!["pydantic.BaseModel".to_string()],
+                    runtime_evaluated_base_classes: vec!["pydantic.BaseModel".to_string()],
                     ..Default::default()
                 },
                 ..settings::Settings::for_rule(rule_code)

crates/ruff/src/rules/flake8_type_checking/settings.rs

@@ -38,12 +38,12 @@ pub struct Options {
         default = "[]",
         value_type = "list[str]",
         example = r#"
-            runtime-evaluated-baseclasses = ["pydantic.BaseModel"]
+            runtime-evaluated-base-classes = ["pydantic.BaseModel"]
         "#
     )]
     /// Exempt classes that list any of the enumerated classes as a base class
     /// from needing to be moved into type-checking blocks.
-    pub runtime_evaluated_baseclasses: Option<Vec<String>>,
+    pub runtime_evaluated_base_classes: Option<Vec<String>>,
     #[option(
         default = "[]",
         value_type = "list[str]",
@@ -60,7 +60,7 @@ pub struct Options {
 pub struct Settings {
     pub strict: bool,
     pub exempt_modules: Vec<String>,
-    pub runtime_evaluated_baseclasses: Vec<String>,
+    pub runtime_evaluated_base_classes: Vec<String>,
     pub runtime_evaluated_decorators: Vec<String>,
 }
 
@@ -69,7 +69,7 @@ impl Default for Settings {
         Self {
             strict: false,
             exempt_modules: vec!["typing".to_string()],
-            runtime_evaluated_baseclasses: vec![],
+            runtime_evaluated_base_classes: vec![],
             runtime_evaluated_decorators: vec![],
         }
     }
@@ -82,8 +82,8 @@ impl From<Options> for Settings {
             exempt_modules: options
                 .exempt_modules
                 .unwrap_or_else(|| vec!["typing".to_string()]),
-            runtime_evaluated_baseclasses: options
-                .runtime_evaluated_baseclasses
+            runtime_evaluated_base_classes: options
+                .runtime_evaluated_base_classes
                 .unwrap_or_default(),
             runtime_evaluated_decorators: options.runtime_evaluated_decorators.unwrap_or_default(),
         }
@@ -95,7 +95,7 @@ impl From<Settings> for Options {
         Self {
             strict: Some(settings.strict),
             exempt_modules: Some(settings.exempt_modules),
-            runtime_evaluated_baseclasses: Some(settings.runtime_evaluated_baseclasses),
+            runtime_evaluated_base_classes: Some(settings.runtime_evaluated_base_classes),
             runtime_evaluated_decorators: Some(settings.runtime_evaluated_decorators),
         }
     }

ruff.schema.json

@@ -908,7 +908,7 @@
             "type": "string"
           }
         },
-        "runtime-evaluated-baseclasses": {
+        "runtime-evaluated-base-classes": {
           "description": "Exempt classes that list any of the enumerated classes as a base class from needing to be moved into type-checking blocks.",
           "type": [
             "array",