Add workspace configuration for selective language service disabling

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

Author: Copilot

pyrefly/lib/lsp/non_wasm/server.rs

@@ -187,6 +187,7 @@ use crate::lsp::non_wasm::queue::HeavyTaskQueue;
 use crate::lsp::non_wasm::queue::LspEvent;
 use crate::lsp::non_wasm::queue::LspQueue;
 use crate::lsp::non_wasm::transaction_manager::TransactionManager;
+use crate::lsp::non_wasm::workspace::DisabledLanguageServicesConfig;
 use crate::lsp::non_wasm::workspace::LspAnalysisConfig;
 use crate::lsp::non_wasm::workspace::Workspace;
 use crate::lsp::non_wasm::workspace::Workspaces;
@@ -853,17 +854,28 @@ impl Server {
                     if let Some(params) = self
                         .extract_request_params_or_send_err_response::<HoverRequest>(params, &x.id)
                     {
-                        let default_response = Hover {
-                            contents: HoverContents::Array(Vec::new()),
-                            range: None,
-                        };
-                        let transaction =
-                            ide_transaction_manager.non_committable_transaction(&self.state);
-                        self.send_response(new_response(
-                            x.id,
-                            Ok(self.hover(&transaction, params).unwrap_or(default_response)),
-                        ));
-                        ide_transaction_manager.save(transaction);
+                        // Check if hover is disabled
+                        if self.is_service_disabled(&params.text_document_position_params.text_document.uri, |d| d.hover.unwrap_or(false)) {
+                            self.send_response(new_response(
+                                x.id,
+                                Ok(Hover {
+                                    contents: HoverContents::Array(Vec::new()),
+                                    range: None,
+                                }),
+                            ));
+                        } else {
+                            let default_response = Hover {
+                                contents: HoverContents::Array(Vec::new()),
+                                range: None,
+                            };
+                            let transaction =
+                                ide_transaction_manager.non_committable_transaction(&self.state);
+                            self.send_response(new_response(
+                                x.id,
+                                Ok(self.hover(&transaction, params).unwrap_or(default_response)),
+                            ));
+                            ide_transaction_manager.save(transaction);
+                        }
                     }
                 } else if let Some(params) = as_request::<InlayHintRequest>(&x) {
                     if let Some(params) = self
@@ -925,16 +937,24 @@ impl Server {
                             params, &x.id,
                         )
                     {
-                        let transaction =
-                            ide_transaction_manager.non_committable_transaction(&self.state);
-                        self.send_response(new_response(
-                            x.id,
-                            Ok(DocumentSymbolResponse::Nested(
-                                self.hierarchical_document_symbols(&transaction, params)
-                                    .unwrap_or_default(),
-                            )),
-                        ));
-                        ide_transaction_manager.save(transaction);
+                        // Check if document symbols are disabled
+                        if self.is_service_disabled(&params.text_document.uri, |d| d.document_symbol.unwrap_or(false)) {
+                            self.send_response(new_response(
+                                x.id,
+                                Ok(DocumentSymbolResponse::Nested(Vec::new())),
+                            ));
+                        } else {
+                            let transaction =
+                                ide_transaction_manager.non_committable_transaction(&self.state);
+                            self.send_response(new_response(
+                                x.id,
+                                Ok(DocumentSymbolResponse::Nested(
+                                    self.hierarchical_document_symbols(&transaction, params)
+                                        .unwrap_or_default(),
+                                )),
+                            ));
+                            ide_transaction_manager.save(transaction);
+                        }
                     }
                 } else if let Some(params) = as_request::<WorkspaceSymbolRequest>(&x) {
                     if let Some(params) = self
@@ -1688,6 +1708,22 @@ impl Server {
             .map(|(handle, _)| handle)
     }
 
+    /// Check if a specific language service is disabled for the given URI
+    fn is_service_disabled(&self, uri: &Url, service_check: impl Fn(&DisabledLanguageServicesConfig) -> bool) -> bool {
+        let path = uri.to_file_path().unwrap();
+        self.workspaces.get_with(path, |(_, workspace)| {
+            // First check the global disable_language_services flag
+            if workspace.disable_language_services {
+                return true;
+            }
+            // Then check if this specific service is disabled
+            if let Some(disabled_services) = &workspace.disabled_language_services {
+                return service_check(disabled_services);
+            }
+            false
+        })
+    }
+
     fn goto_definition(
         &self,
         transaction: &Transaction<'_>,

pyrefly/lib/lsp/non_wasm/workspace.rs

@@ -60,6 +60,7 @@ pub struct Workspace {
     python_info: Option<PythonInfo>,
     search_path: Option<Vec<PathBuf>>,
     pub disable_language_services: bool,
+    pub disabled_language_services: Option<DisabledLanguageServicesConfig>,
     pub display_type_errors: Option<DisplayTypeErrors>,
     pub lsp_analysis_config: Option<LspAnalysisConfig>,
 }
@@ -152,11 +153,30 @@ impl WeakConfigCache {
     }
 }
 
+#[derive(Debug, Default, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DisabledLanguageServicesConfig {
+    pub definition: Option<bool>,
+    pub type_definition: Option<bool>,
+    pub code_action: Option<bool>,
+    pub completion: Option<bool>,
+    pub document_highlight: Option<bool>,
+    pub references: Option<bool>,
+    pub rename: Option<bool>,
+    pub signature_help: Option<bool>,
+    pub hover: Option<bool>,
+    pub inlay_hint: Option<bool>,
+    pub document_symbol: Option<bool>,
+    pub workspace_symbol: Option<bool>,
+    pub semantic_tokens: Option<bool>,
+}
+
 #[derive(Debug, Default, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct PyreflyClientConfig {
     display_type_errors: Option<DisplayTypeErrors>,
     disable_language_services: Option<bool>,
+    disabled_language_services: Option<DisabledLanguageServicesConfig>,
     extra_paths: Option<Vec<PathBuf>>,
 }
 
@@ -289,6 +309,9 @@ impl Workspaces {
             if let Some(disable_language_services) = pyrefly.disable_language_services {
                 self.update_disable_language_services(scope_uri, disable_language_services);
             }
+            if let Some(disabled_services) = pyrefly.disabled_language_services {
+                self.update_disabled_language_services(scope_uri, disabled_services);
+            }
             self.update_display_type_errors(modified, scope_uri, pyrefly.display_type_errors);
         }
         if let Some(analysis) = config.analysis {
@@ -313,6 +336,23 @@ impl Workspaces {
         }
     }
 
+    /// Update disabled language services configuration for scope_uri, None if default workspace
+    fn update_disabled_language_services(
+        &self,
+        scope_uri: &Option<Url>,
+        disabled_services: DisabledLanguageServicesConfig,
+    ) {
+        let mut workspaces = self.workspaces.write();
+        match scope_uri {
+            Some(scope_uri) => {
+                if let Some(workspace) = workspaces.get_mut(&scope_uri.to_file_path().unwrap()) {
+                    workspace.disabled_language_services = Some(disabled_services);
+                }
+            }
+            None => self.default.write().disabled_language_services = Some(disabled_services),
+        }
+    }
+
     /// Update typeCheckingMode setting for scope_uri, None if default workspace
     fn update_display_type_errors(
         &self,