[ty] Add python.ty.disableLanguageServices config

Author: dhruvmanila

crates/ty_server/src/server/api/requests/completion.rs

@@ -28,6 +28,10 @@ impl BackgroundDocumentRequestHandler for CompletionRequestHandler {
         _notifier: Notifier,
         params: CompletionParams,
     ) -> crate::server::Result<Option<CompletionResponse>> {
+        if snapshot.client_settings().is_language_services_disabled() {
+            return Ok(None);
+        }
+
         let Some(file) = snapshot.file(db) else {
             tracing::debug!("Failed to resolve file for {:?}", params);
             return Ok(None);

crates/ty_server/src/server/api/requests/goto_type_definition.rs

@@ -28,6 +28,10 @@ impl BackgroundDocumentRequestHandler for GotoTypeDefinitionRequestHandler {
         _notifier: Notifier,
         params: GotoTypeDefinitionParams,
     ) -> crate::server::Result<Option<GotoDefinitionResponse>> {
+        if snapshot.client_settings().is_language_services_disabled() {
+            return Ok(None);
+        }
+
         let Some(file) = snapshot.file(db) else {
             tracing::debug!("Failed to resolve file for {:?}", params);
             return Ok(None);

crates/ty_server/src/server/api/requests/hover.rs

@@ -28,6 +28,10 @@ impl BackgroundDocumentRequestHandler for HoverRequestHandler {
         _notifier: Notifier,
         params: HoverParams,
     ) -> crate::server::Result<Option<lsp_types::Hover>> {
+        if snapshot.client_settings().is_language_services_disabled() {
+            return Ok(None);
+        }
+
         let Some(file) = snapshot.file(db) else {
             tracing::debug!("Failed to resolve file for {:?}", params);
             return Ok(None);

crates/ty_server/src/server/api/requests/inlay_hints.rs

@@ -27,6 +27,10 @@ impl BackgroundDocumentRequestHandler for InlayHintRequestHandler {
         _notifier: Notifier,
         params: InlayHintParams,
     ) -> crate::server::Result<Option<Vec<lsp_types::InlayHint>>> {
+        if snapshot.client_settings().is_language_services_disabled() {
+            return Ok(None);
+        }
+
         let Some(file) = snapshot.file(db) else {
             tracing::debug!("Failed to resolve file for {:?}", params);
             return Ok(None);

crates/ty_server/src/session.rs

@@ -11,6 +11,7 @@ use lsp_types::{ClientCapabilities, TextDocumentContentChangeEvent, Url};
 use ruff_db::Db;
 use ruff_db::files::{File, system_path_to_file};
 use ruff_db::system::SystemPath;
+use settings::ResolvedClientSettings;
 use ty_project::{ProjectDatabase, ProjectMetadata};
 
 use crate::document::{DocumentKey, DocumentVersion, NotebookDocument};
@@ -136,6 +137,7 @@ impl Session {
         let key = self.key_from_url(url);
         Some(DocumentSnapshot {
             resolved_client_capabilities: self.resolved_client_capabilities.clone(),
+            client_settings: self.index().client_settings(),
             document_ref: self.index().make_document_ref(key)?,
             position_encoding: self.position_encoding,
         })
@@ -260,6 +262,7 @@ impl Drop for MutIndexGuard<'_> {
 #[derive(Debug)]
 pub struct DocumentSnapshot {
     resolved_client_capabilities: Arc<ResolvedClientCapabilities>,
+    client_settings: ResolvedClientSettings,
     document_ref: index::DocumentQuery,
     position_encoding: PositionEncoding,
 }
@@ -269,14 +272,18 @@ impl DocumentSnapshot {
         &self.resolved_client_capabilities
     }
 
-    pub fn query(&self) -> &index::DocumentQuery {
+    pub(crate) fn query(&self) -> &index::DocumentQuery {
         &self.document_ref
     }
 
     pub(crate) fn encoding(&self) -> PositionEncoding {
         self.position_encoding
     }
 
+    pub(crate) fn client_settings(&self) -> &ResolvedClientSettings {
+        &self.client_settings
+    }
+
     pub(crate) fn file(&self, db: &dyn Db) -> Option<File> {
         match url_to_any_system_path(self.document_ref.file_url()).ok()? {
             AnySystemPath::System(path) => system_path_to_file(db, path).ok(),

crates/ty_server/src/session/index.rs

@@ -10,6 +10,7 @@ use crate::{
 };
 
 use super::ClientSettings;
+use super::settings::ResolvedClientSettings;
 
 /// Stores and tracks all open documents in a session, along with their associated settings.
 #[derive(Default, Debug)]
@@ -21,7 +22,6 @@ pub(crate) struct Index {
     notebook_cells: FxHashMap<Url, Url>,
 
     /// Global settings provided by the client.
-    #[expect(dead_code)]
     global_settings: ClientSettings,
 }
 
@@ -165,6 +165,10 @@ impl Index {
         Ok(())
     }
 
+    pub(crate) fn client_settings(&self) -> ResolvedClientSettings {
+        ResolvedClientSettings::global(&self.global_settings)
+    }
+
     fn document_controller_for_key(
         &mut self,
         key: &DocumentKey,

crates/ty_server/src/session/settings.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::{ops::Deref, path::PathBuf};
 
 use lsp_types::Url;
 use rustc_hash::FxHashMap;
@@ -7,6 +7,24 @@ use serde::Deserialize;
 /// Maps a workspace URI to its associated client settings. Used during server initialization.
 pub(crate) type WorkspaceSettingsMap = FxHashMap<Url, ClientSettings>;
 
+// TODO(dhruvmanila): We need to mirror the "python.*" namespace on the server side but ideally it
+// would be useful to instead use `workspace/didChangeConfiguration` notification instead. This
+// would be then used to get all settings and not just the ones in "python.*".
+
+#[derive(Debug, Deserialize, Default)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+#[serde(rename_all = "camelCase")]
+struct Python {
+    ty: Option<Ty>,
+}
+
+#[derive(Debug, Deserialize, Default)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+#[serde(rename_all = "camelCase")]
+struct Ty {
+    disable_language_services: Option<bool>,
+}
+
 #[derive(Debug, Deserialize, Default)]
 #[cfg_attr(test, derive(PartialEq, Eq))]
 #[serde(rename_all = "camelCase")]
@@ -36,6 +54,11 @@ impl Experimental {
 #[serde(rename_all = "camelCase")]
 pub struct ClientSettings {
     pub(crate) experimental: Option<Experimental>,
+
+    /// Settings under the `python.*` namespace in VS Code that are useful for the ty language
+    /// server.
+    python: Option<Python>,
+
     // These settings are only needed for tracing, and are only read from the global configuration.
     // These will not be in the resolved settings.
     #[serde(flatten)]
@@ -133,3 +156,66 @@ impl Default for InitializationOptions {
         }
     }
 }
+
+/// Resolved client settings for a specific document. These settings are meant to be
+/// used directly by the server, and are *not* a 1:1 representation with how the client
+/// sends them.
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+pub(crate) struct ResolvedClientSettings {
+    disable_language_services: bool,
+}
+
+impl ResolvedClientSettings {
+    pub(crate) fn is_language_services_disabled(&self) -> bool {
+        self.disable_language_services
+    }
+
+    /// Resolves global settings only.
+    pub(super) fn global(global_settings: &ClientSettings) -> Self {
+        Self::new_impl(&[global_settings])
+    }
+
+    fn new_impl(all_settings: &[&ClientSettings]) -> Self {
+        Self {
+            disable_language_services: Self::resolve_or(
+                all_settings,
+                |settings| {
+                    settings
+                        .python
+                        .as_ref()?
+                        .ty
+                        .as_ref()?
+                        .disable_language_services
+                },
+                false,
+            ),
+        }
+    }
+
+    /// Attempts to resolve a setting using a list of available client settings as sources.
+    /// Client settings that come earlier in the list take priority. `default` will be returned
+    /// if none of the settings specify the requested setting.
+    ///
+    /// Use [`ResolvedClientSettings::resolve_optional`] if the setting should be optional instead
+    /// of having a default value.
+    fn resolve_or<T>(
+        all_settings: &[&ClientSettings],
+        get: impl Fn(&ClientSettings) -> Option<T>,
+        default: T,
+    ) -> T {
+        Self::resolve_optional(all_settings, get).unwrap_or(default)
+    }
+
+    /// Attempts to resolve a setting using a list of available client settings as sources.
+    /// Client settings that come earlier in the list take priority. This function is for fields
+    /// that do not have a default value and should be left unset.
+    ///
+    /// Use [`ResolvedClientSettings::resolve_or`] for settings that should have default values.
+    fn resolve_optional<T>(
+        all_settings: &[&ClientSettings],
+        get: impl FnMut(&ClientSettings) -> Option<T>,
+    ) -> Option<T> {
+        all_settings.iter().map(Deref::deref).find_map(get)
+    }
+}