[ty] Defer uv workspace discovery until after project configuration (#28525)

## Summary

Today, we call uv metadata before we discover the ty project. This is
fine for `uv check` where we always want to call uv metadata, but it's
problematic for `ty check` because it prevents us from adding a
configuration option to skip the metadata discovery (an opt out).


This PR refactors the discovery to:

1. Find the ty project
2. Use the project to decide whether to call uv (for now, this is
skipped because this PR doesn't add the setting)
3. Call uv metadata and if the uv discovered project is different from
ty's, make that project the root instead

## Test Plan

Testing: Project, CLI uv workspace, and language server tests pass;
Clippy and hooks pass.

Author: MichaReiser

crates/ruff_benchmark/benches/ty_script.rs

@@ -5,18 +5,19 @@ use divan::{Bencher, bench};
 use rayon::ThreadPoolBuilder;
 use ruff_db::system::{OsSystem, System, SystemPath, TestSystem};
 use ty_project::{
-    Db, ProjectDatabase, ProjectMetadata, ScriptEnvironmentAvailability, uv_test_env_vars,
+    Db, ProjectDatabase, ProjectMetadata, ScriptEnvironmentAvailability, UseUv, uv_test_env_vars,
 };
 use ty_static::EnvVars;
 
 fn setup_iteration(root: &SystemPath, uv: &SystemPath) -> ProjectDatabase {
     let system = TestSystem::new(OsSystem::new(root));
     system.clear_env_vars();
     system.set_env_vars(uv_test_env_vars());
-    system.set_env_var(EnvVars::TY_UV, "scripts");
     system.set_env_var(EnvVars::UV, uv.as_str());
 
-    let metadata = ProjectMetadata::discover(root, &system).unwrap();
+    let metadata = ProjectMetadata::discover(root, &system)
+        .unwrap()
+        .with_use_uv(UseUv::Scripts);
     ProjectDatabase::fallible(metadata, system).unwrap()
 }
 

crates/ty/src/lib.rs

@@ -31,7 +31,7 @@ use ty_project::metadata::settings::TerminalSettings;
 use ty_project::watch::ProjectWatcher;
 use ty_project::{
     ChangeResult, CollectReporter, Db, Project, ScriptEnvironmentAvailability, UseUv,
-    UvSyncProgress, watch,
+    UvSyncProgress, UvWorkspace, watch,
 };
 use ty_project::{ProjectDatabase, ProjectMetadata, ProjectReloadResult};
 use ty_python_semantic::{fix_all_diagnostics, suppress_all_diagnostics};
@@ -148,8 +148,17 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
         .map(|path| SystemPath::absolute(path, &cwd));
     let force_exclude = args.force_exclude();
 
-    let use_uv = UseUv::from_system(&system);
-    let use_uv = if use_uv == UseUv::On
+    let mut project_metadata = match &config_file {
+        Some(config_file) => {
+            ProjectMetadata::from_config_file(config_file.clone(), &project_path, &system)?
+        }
+        None => ProjectMetadata::discover(&project_path, &system)?,
+    };
+
+    project_metadata.apply_configuration_files(&system)?;
+
+    project_metadata.set_override_options(args.into_options());
+    if project_metadata.use_uv() == UseUv::On
         && let [path] = check_paths.as_slice()
         && system.is_file(path)
         && system
@@ -158,21 +167,13 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
     {
         // A single PEP 723 script uses its own uv environment, even with an explicit ty
         // configuration file. The other explicit paths still discover workspace metadata.
-        UseUv::Scripts
-    } else {
-        use_uv
-    };
-
-    let mut project_metadata = match &config_file {
-        Some(config_file) => {
-            ProjectMetadata::from_config_file(config_file.clone(), &project_path, &system, use_uv)?
-        }
-        None => ProjectMetadata::discover_with_uv(&project_path, &system, use_uv)?,
-    };
-
-    project_metadata.apply_configuration_files(&system)?;
+        project_metadata = project_metadata.with_use_uv(UseUv::Scripts);
+    }
 
-    project_metadata.set_override_options(args.into_options());
+    if project_metadata.use_uv().workspace_discovery_enabled() {
+        let workspace = UvWorkspace::discover(&project_path, &system);
+        project_metadata.apply_uv_workspace(&system, workspace)?;
+    }
 
     let mut db = ProjectDatabase::fallible(project_metadata, system)?;
     let project = db.project();

crates/ty/tests/file_watching.rs

@@ -27,7 +27,7 @@ use ty_project::metadata::value::{RelativeGlobPattern, RelativePathBuf};
 #[cfg(unix)]
 use ty_project::watch::watch_paths;
 use ty_project::watch::{ChangeEvent, ProjectWatcher, directory_watcher};
-use ty_project::{ChangeResult, Db, ProjectDatabase, ProjectMetadata, UseUv};
+use ty_project::{ChangeResult, Db, ProjectDatabase, ProjectMetadata, UvWorkspace};
 use ty_python_core::platform::PythonPlatform;
 use ty_static::EnvVars;
 
@@ -552,12 +552,7 @@ where
     }
 
     let mut project = if let Some(config_file_override) = config_file_override {
-        ProjectMetadata::from_config_file(
-            config_file_override,
-            &project_path,
-            &system,
-            UseUv::from_system(&system),
-        )?
+        ProjectMetadata::from_config_file(config_file_override, &project_path, &system)?
     } else {
         ProjectMetadata::discover(&project_path, &system)?
     };
@@ -568,6 +563,10 @@ where
     if let Some(override_options) = override_options {
         project.set_override_options(override_options);
     }
+    if project.use_uv().workspace_discovery_enabled() {
+        let workspace = UvWorkspace::discover(&project_path, &system);
+        project.apply_uv_workspace(&system, workspace)?;
+    }
 
     // We need a chance to create the directories here.
     let merged_options = project.to_merged_options();

crates/ty_project/src/db/changes.rs

@@ -363,9 +363,9 @@ impl ProjectDatabase {
             if metadata.use_uv().workspace_discovery_enabled() {
                 result.project_sync_path = Some(path.to_path_buf());
             } else {
-                // We're not refreshing uv metadata, so use the existing environment.
-                let environment = metadata.environment().clone();
-                match project.rediscover(self, path, environment) {
+                // We're not refreshing uv metadata, so use the existing workspace.
+                let workspace = metadata.uv_workspace().clone();
+                match project.rediscover(self, path, workspace) {
                     Ok(ProjectReloadResult::Unchanged) => {}
                     Ok(ProjectReloadResult::Changed { files_changed }) => {
                         result.project_changed = true;
@@ -642,7 +642,7 @@ fn affects_uv_metadata(db: &dyn Db, change: &ChangeEvent) -> bool {
             let project = db.project();
             let workspace_root = project
                 .metadata(db)
-                .uv_workspace()
+                .uv_workspace_metadata()
                 .map_or(project.root(db), |workspace| workspace.workspace_root());
             let is_included_workspace_directory = path.starts_with(workspace_root)
                 && project

crates/ty_project/src/lib.rs

@@ -36,7 +36,8 @@ use ty_python_semantic::dependency::{DependencyMetadata, DependencyProjectKind};
 use ty_python_semantic::lint::RuleSelection;
 use uv::DependencyMetadataError;
 pub use uv::{
-    ScriptEnvironmentAvailability, UseUv, UvEnvironments, UvSyncChanges, uv_test_env_vars,
+    ScriptEnvironmentAvailability, UseUv, UvEnvironments, UvSyncChanges, UvWorkspace,
+    uv_test_env_vars,
 };
 
 mod db;
@@ -285,7 +286,7 @@ impl Project {
         db: &dyn Db,
     ) -> Result<Option<Box<DependencyMetadata>>, DependencyMetadataError> {
         let metadata = self.metadata(db);
-        let Some(workspace) = metadata.uv_workspace() else {
+        let Some(workspace) = metadata.uv_workspace_metadata() else {
             tracing::debug!(
                 "Skipping dependency checks for '{}': no uv workspace metadata is available",
                 metadata.root(),
@@ -375,11 +376,9 @@ impl Project {
         self,
         db: &mut dyn Db,
         path: &SystemPath,
-        environment: uv::ProjectEnvironment,
+        workspace: uv::UvWorkspace,
     ) -> Result<ProjectReloadResult, ProjectMetadataError> {
-        let mut metadata = self
-            .metadata(db)
-            .rediscover(db.system(), path, environment)?;
+        let mut metadata = self.metadata(db).rediscover(db.system(), path, workspace)?;
         if let Err(error) = metadata.apply_configuration_files(db.system()) {
             let error = anyhow::Error::new(error);
             tracing::error!(
@@ -802,7 +801,7 @@ impl Project {
     pub fn check_settings(&self, db: &dyn Db) -> Vec<Diagnostic> {
         let metadata = self.metadata(db);
         let uv_diagnostic = metadata.uv_diagnostic(db).or_else(|| {
-            let workspace = metadata.uv_workspace()?;
+            let workspace = metadata.uv_workspace_metadata()?;
             let error = self.dependency_metadata(db).as_ref().err()?;
             let mut diagnostic = error.to_diagnostic(DependencyProjectKind::Project);
             if let Ok(file) =