Create default project lazily, centralize apply_changes

Author: MichaReiser

crates/ty/src/lib.rs

@@ -115,17 +115,17 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
         None => ProjectMetadata::discover(&project_path, &system)?,
     };
 
-    let options = args.into_options();
-    project_metadata.apply_options(options.clone());
     project_metadata.apply_configuration_files(&system)?;
 
+    let project_options_overrides = ProjectOptionsOverrides::new(config_file, args.into_options());
+    project_metadata.apply_overrides(&project_options_overrides);
+
     let mut db = ProjectDatabase::new(project_metadata, system)?;
 
     if !check_paths.is_empty() {
         db.project().set_included_paths(&mut db, check_paths);
     }
 
-    let project_options_overrides = ProjectOptionsOverrides::new(config_file, options);
     let (main_loop, main_loop_cancellation_token) = MainLoop::new(project_options_overrides);
 
     // Listen to Ctrl+C and abort the watch mode.

crates/ty_project/src/db.rs

@@ -3,6 +3,7 @@ use std::panic::{AssertUnwindSafe, RefUnwindSafe};
 use std::sync::Arc;
 use std::{cmp, fmt};
 
+pub use self::changes::ChangeResult;
 use crate::metadata::settings::file_settings;
 use crate::{DEFAULT_LINT_REGISTRY, DummyReporter};
 use crate::{Project, ProjectMetadata, Reporter};

crates/ty_project/src/db/changes.rs

@@ -41,8 +41,6 @@ impl ProjectDatabase {
         let project_root = project.root(self).to_path_buf();
         let config_file_override =
             project_options_overrides.and_then(|options| options.config_file_override.clone());
-        let options =
-            project_options_overrides.map(|project_options| project_options.options.clone());
         let program = Program::get(self);
         let custom_stdlib_versions_path = program
             .custom_stdlib_search_path(self)
@@ -218,16 +216,16 @@ impl ProjectDatabase {
             };
             match new_project_metadata {
                 Ok(mut metadata) => {
-                    if let Some(cli_options) = options {
-                        metadata.apply_options(cli_options);
-                    }
-
                     if let Err(error) = metadata.apply_configuration_files(self.system()) {
                         tracing::error!(
                             "Failed to apply configuration files, continuing without applying them: {error}"
                         );
                     }
 
+                    if let Some(overrides) = project_options_overrides {
+                        metadata.apply_overrides(overrides);
+                    }
+
                     match metadata.to_program_settings(self.system(), self.vendored()) {
                         Ok(program_settings) => {
                             let program = Program::get(self);

crates/ty_project/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::glob::{GlobFilterCheckMode, IncludeResult};
 use crate::metadata::options::{OptionDiagnostic, ToSettingsError};
 use crate::walk::{ProjectFilesFilter, ProjectFilesWalker};
-pub use db::{CheckMode, Db, ProjectDatabase, SalsaMemoryDump};
+pub use db::{ChangeResult, CheckMode, Db, ProjectDatabase, SalsaMemoryDump};
 use files::{Index, Indexed, IndexedFiles};
 use metadata::settings::Settings;
 pub use metadata::{ProjectMetadata, ProjectMetadataError};

crates/ty_project/src/metadata.rs

@@ -7,6 +7,7 @@ use thiserror::Error;
 use ty_python_semantic::ProgramSettings;
 
 use crate::combine::Combine;
+use crate::metadata::options::ProjectOptionsOverrides;
 use crate::metadata::pyproject::{Project, PyProject, PyProjectError, ResolveRequiresPythonError};
 use crate::metadata::value::ValueSource;
 pub use options::Options;
@@ -276,6 +277,10 @@ impl ProjectMetadata {
             .to_program_settings(self.root(), self.name(), system, vendored)
     }
 
+    pub fn apply_overrides(&mut self, overrides: &ProjectOptionsOverrides) {
+        self.options = overrides.apply_to(std::mem::take(&mut self.options));
+    }
+
     /// Combine the project options with the CLI options where the CLI options take precedence.
     pub fn apply_options(&mut self, options: Options) {
         self.options = options.combine(std::mem::take(&mut self.options));

crates/ty_project/src/metadata/options.rs

@@ -1476,8 +1476,11 @@ impl OptionDiagnostic {
 /// This is a wrapper for options that actually get loaded from configuration files
 /// and the CLI, which also includes a `config_file_override` option that overrides
 /// default configuration discovery with an explicitly-provided path to a configuration file
+#[derive(Debug, Default)]
 pub struct ProjectOptionsOverrides {
     pub config_file_override: Option<SystemPathBuf>,
+    pub fallback_python_version: Option<RangedValue<PythonVersion>>,
+    pub fallback_python: Option<RelativePathBuf>,
     pub options: Options,
 }
 
@@ -1486,8 +1489,51 @@ impl ProjectOptionsOverrides {
         Self {
             config_file_override,
             options,
+            ..Self::default()
         }
     }
+
+    pub fn apply_to(&self, options: Options) -> Options {
+        let mut combined = self.options.clone().combine(options);
+
+        if let Some(python_version) = &self.fallback_python_version {
+            let configured_python_version = combined
+                .environment
+                .as_ref()
+                .and_then(|environment| environment.python_version.as_ref());
+
+            if configured_python_version.is_none() {
+                tracing::debug!(
+                    "Using the Python version of the selected Python interpreter in the VS Code Python extension: {python_version}"
+                );
+
+                combined.environment = Some(EnvironmentOptions {
+                    python_version: Some(python_version.clone()),
+                    ..combined.environment.unwrap_or_default()
+                });
+            }
+        }
+
+        if let Some(python) = &self.fallback_python {
+            let configured_python = combined
+                .environment
+                .as_ref()
+                .and_then(|environment| environment.python.as_ref());
+
+            if configured_python.is_none() {
+                tracing::debug!(
+                    "Using the environment selected in the VS Code Python extension as python path: {python}"
+                );
+
+                combined.environment = Some(EnvironmentOptions {
+                    python: Some(python.clone()),
+                    ..combined.environment.unwrap_or_default()
+                });
+            }
+        }
+
+        combined
+    }
 }
 
 trait OrDefault {

crates/ty_server/src/server/api/notifications/did_change.rs

@@ -37,22 +37,16 @@ impl SyncNotificationHandler for DidChangeTextDocumentHandler {
             .update_text_document(&key, content_changes, version)
             .with_failure_code(ErrorCode::InternalError)?;
 
-        match key.path() {
+        let changes = match key.path() {
             AnySystemPath::System(path) => {
-                let db = match session.project_db_for_path_mut(path) {
-                    Some(db) => db,
-                    None => session.default_project_db_mut(),
-                };
-                db.apply_changes(vec![ChangeEvent::file_content_changed(path.clone())], None);
+                vec![ChangeEvent::file_content_changed(path.clone())]
             }
             AnySystemPath::SystemVirtual(virtual_path) => {
-                let db = session.default_project_db_mut();
-                db.apply_changes(
-                    vec![ChangeEvent::ChangedVirtual(virtual_path.clone())],
-                    None,
-                );
+                vec![ChangeEvent::ChangedVirtual(virtual_path.clone())]
             }
-        }
+        };
+
+        session.apply_changes(key.path(), changes);
 
         publish_diagnostics(session, &key, client)
     }

crates/ty_server/src/server/api/notifications/did_change_watched_files.rs

@@ -88,12 +88,7 @@ impl SyncNotificationHandler for DidChangeWatchedFiles {
         for (root, changes) in events_by_db {
             tracing::debug!("Applying changes to `{root}`");
 
-            // SAFETY: Only paths that are part of the workspace are registered for file watching.
-            // So, virtual paths and paths that are outside of a workspace does not trigger this
-            // notification.
-            let db = session.project_db_for_path_mut(&*root).unwrap();
-
-            let result = db.apply_changes(changes, None);
+            let result = session.apply_changes(&AnySystemPath::System(root), changes);
 
             project_changed |= result.project_changed();
         }

crates/ty_server/src/server/api/notifications/did_close.rs

@@ -34,10 +34,9 @@ impl SyncNotificationHandler for DidCloseTextDocumentHandler {
             .with_failure_code(ErrorCode::InternalError)?;
 
         if let AnySystemPath::SystemVirtual(virtual_path) = key.path() {
-            let db = session.default_project_db_mut();
-            db.apply_changes(
+            session.apply_changes(
+                key.path(),
                 vec![ChangeEvent::DeletedVirtual(virtual_path.clone())],
-                None,
             );
         }
 

crates/ty_server/src/server/api/notifications/did_close_notebook.rs

@@ -33,10 +33,9 @@ impl SyncNotificationHandler for DidCloseNotebookHandler {
             .with_failure_code(lsp_server::ErrorCode::InternalError)?;
 
         if let AnySystemPath::SystemVirtual(virtual_path) = key.path() {
-            let db = session.default_project_db_mut();
-            db.apply_changes(
+            session.apply_changes(
+                key.path(),
                 vec![ChangeEvent::DeletedVirtual(virtual_path.clone())],
-                None,
             );
         }