Fallback to requires-python in certain cases when target-version is not found (#16721)

## Summary

Restores #16319 after it got
dropped from the 0.10 release branch :(

---------

Co-authored-by: dylwil3 <[email protected]>

Author: MichaReiser

Cargo.lock

@@ -154,6 +154,7 @@ toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-flame = { version = "0.2.0" }
 tracing-indicatif = { version = "0.3.6" }
+tracing-log = { version = "0.2.0" }
 tracing-subscriber = { version = "0.3.18", default-features = false, features = [
     "env-filter",
     "fmt",

Cargo.toml

@@ -153,7 +153,11 @@ pub fn run(
         }));
     }
 
-    set_up_logging(global_options.log_level())?;
+    // Don't set up logging for the server command, as it has its own logging setup
+    // and setting the global logger can only be done once.
+    if !matches!(command, Command::Server { .. }) {
+        set_up_logging(global_options.log_level())?;
+    }
 
     match command {
         Command::Version { output_format } => {

crates/ruff/src/lib.rs

@@ -5,12 +5,14 @@ use log::debug;
 use path_absolutize::path_dedot;
 
 use ruff_workspace::configuration::Configuration;
-use ruff_workspace::pyproject;
+use ruff_workspace::pyproject::{self, find_fallback_target_version};
 use ruff_workspace::resolver::{
-    resolve_root_settings, ConfigurationTransformer, PyprojectConfig, PyprojectDiscoveryStrategy,
-    Relativity,
+    resolve_root_settings, ConfigurationOrigin, ConfigurationTransformer, PyprojectConfig,
+    PyprojectDiscoveryStrategy,
 };
 
+use ruff_python_ast as ast;
+
 use crate::args::ConfigArguments;
 
 /// Resolve the relevant settings strategy and defaults for the current
@@ -35,7 +37,11 @@ pub fn resolve(
     // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
     // current working directory. (This matches ESLint's behavior.)
     if let Some(pyproject) = config_arguments.config_file() {
-        let settings = resolve_root_settings(pyproject, Relativity::Cwd, config_arguments)?;
+        let settings = resolve_root_settings(
+            pyproject,
+            config_arguments,
+            ConfigurationOrigin::UserSpecified,
+        )?;
         debug!(
             "Using user-specified configuration file at: {}",
             pyproject.display()
@@ -61,7 +67,8 @@ pub fn resolve(
             "Using configuration file (via parent) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Parent, config_arguments)?;
+        let settings =
+            resolve_root_settings(&pyproject, config_arguments, ConfigurationOrigin::Ancestor)?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -74,11 +81,35 @@ pub fn resolve(
     // end up the "closest" `pyproject.toml` file for every Python file later on, so
     // these act as the "default" settings.)
     if let Some(pyproject) = pyproject::find_user_settings_toml() {
+        struct FallbackTransformer<'a> {
+            arguments: &'a ConfigArguments,
+        }
+
+        impl ConfigurationTransformer for FallbackTransformer<'_> {
+            fn transform(&self, mut configuration: Configuration) -> Configuration {
+                // The `requires-python` constraint from the `pyproject.toml` takes precedence
+                // over the `target-version` from the user configuration.
+                let fallback = find_fallback_target_version(&*path_dedot::CWD);
+                if let Some(fallback) = fallback {
+                    debug!("Derived `target-version` from found `requires-python`: {fallback:?}");
+                    configuration.target_version = Some(fallback.into());
+                }
+
+                self.arguments.transform(configuration)
+            }
+        }
+
         debug!(
             "Using configuration file (via cwd) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, config_arguments)?;
+        let settings = resolve_root_settings(
+            &pyproject,
+            &FallbackTransformer {
+                arguments: config_arguments,
+            },
+            ConfigurationOrigin::UserSettings,
+        )?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -91,7 +122,24 @@ pub fn resolve(
     // "closest" `pyproject.toml` file for every Python file later on, so these act
     // as the "default" settings.)
     debug!("Using Ruff default settings");
-    let config = config_arguments.transform(Configuration::default());
+    let mut config = config_arguments.transform(Configuration::default());
+    if config.target_version.is_none() {
+        // If we have arrived here we know that there was no `pyproject.toml`
+        // containing a `[tool.ruff]` section found in an ancestral directory.
+        // (This is an implicit requirement in the function
+        // `pyproject::find_settings_toml`.)
+        // However, there may be a `pyproject.toml` with a `requires-python`
+        // specified, and that is what we look for in this step.
+        let fallback = find_fallback_target_version(
+            stdin_filename
+                .as_ref()
+                .unwrap_or(&path_dedot::CWD.as_path()),
+        );
+        if let Some(version) = fallback {
+            debug!("Derived `target-version` from found `requires-python`: {version:?}");
+        }
+        config.target_version = fallback.map(ast::PythonVersion::from);
+    }
     let settings = config.into_settings(&path_dedot::CWD)?;
     Ok(PyprojectConfig::new(
         PyprojectDiscoveryStrategy::Hierarchical,