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

# Summary

This PR introduces the following modifications in configuration
resolution:

1. In the event where we are reading in a configuration file `myconfig`
with no `target-version` specified, we will search for a
`pyproject.toml` in the _same directory_ as `myconfig` and see if it has
a `requires-python` field. If so, we will use that as the
`target-version`.

2. In the event where...
  - we have not used the flag `--isolated`, and
  - we have not found any configuration file, and
  - we have not passed `--config` specifying a target version

then we will search for a `pyproject.toml` file with `required-python`
in an ancestor directory and use that if we find it.

We've also added some debug logs to indicate which of these paths is
taken.

## Implementation
Two small things:

1. I have chosen a method that will sometimes re-parse a
`pyproject.toml` file that has already been parsed at some earlier stage
in the resolution process. It seemed like avoiding that would require
more drastic changes - but maybe there is a clever way that I'm not
seeing!
2. When searching for these fallbacks, I suppress any errors that may
occur when parsing `pyproject.toml`s rather than propagate them. The
reasoning here is that we have already found or decided upon a perfectly
good configuration, and this is just a "bonus" to find a better guess
for the target version.

Closes #14813, #16662

## Testing

The linked issue contains a repo for reproducing the behavior, which we
used for a manual test:

```console
ruff-F821-repro on  main
❯ uvx ruff check --no-cache
hello.py:9:11: F821 Undefined name `anext`. Consider specifying `requires-python = ">= 3.10"` or `tool.ruff.target-version = "py310"` in your `pyproject.toml` file.
  |
8 | async def main():
9 |     print(anext(g()))
  |           ^^^^^ F821
  |

Found 1 error.

ruff-F821-repro on  main
❯ ../ruff/target/debug/ruff check --no-cache
All checks passed!
```

In addition, we've added snapshot tests with the CLI output in some
examples. Please let me know if there are some additional scenarios
you'd like me to add tests for!

---------

Co-authored-by: Micha Reiser <[email protected]>

Author: dylwil3

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,