Remove VSCode extension changes, keep only binary command-line flags

Copilot · kv9898 · kv9898 · commit 723f8152c0b1 · 2025-10-29T15:56:05.000Z
Co-authored-by: kv9898 &lt;105025148+kv9898@users.noreply.github.com&gt;
diff --git a/docs/selective-language-services.md b/docs/selective-language-services.md
@@ -1,6 +1,6 @@
 # Selective Language Service Disabling
 
-Pyrefly's LSP server now supports selective disabling of individual language services. This allows users to choose exactly which IDE features they want enabled, providing flexibility for different workflows and preferences.
+Pyrefly's LSP server supports selective disabling of individual language services via command-line arguments. This allows users to choose exactly which IDE features they want enabled, providing flexibility for different workflows and preferences.
 
 ## Available Language Services
 
@@ -22,24 +22,9 @@ The following language services can be selectively disabled:
 
 ## Usage
 
-### VSCode Extension
-
-Add the following to your VSCode settings (`.vscode/settings.json` or user settings):
-
-```json
-{
-  "python.pyrefly.disabledLanguageServices": {
-    "hover": true,
-    "documentSymbol": true
-  }
-}
-```
-
-This example disables hover tooltips and document symbols (outline), while keeping all other services enabled.
-
 ### Command-Line Arguments
 
-When starting the LSP server manually, you can use command-line flags:
+When starting the LSP server, you can use command-line flags to disable specific services:
 
 ```bash
 pyrefly lsp --disable-hover --disable-document-symbol
@@ -60,9 +45,9 @@ Available flags:
 - `--disable-workspace-symbol`
 - `--disable-semantic-tokens`
 
-### Passing Arguments via VSCode Extension
+### Configuring via Editor Settings
 
-You can also pass these command-line arguments through the VSCode extension settings:
+For editors that support passing arguments to the LSP server (like VSCode), you can configure the arguments through editor settings. For VSCode, use the `pyrefly.lspArguments` setting:
 
 ```json
 {
@@ -74,26 +59,26 @@ You can also pass these command-line arguments through the VSCode extension sett
 }
 ```
 
+This allows you to configure which services are disabled without manually starting the LSP server.
+
 ## Implementation Details
 
 ### Architecture Decision
 
-The selective disabling is implemented at the **binary level** (LSP server) rather than the VSCode extension level. This design decision provides several benefits:
+The selective disabling is implemented at the **binary level** (LSP server) via command-line arguments. This design provides several benefits:
 
 1. **Cross-editor compatibility** - Works with any editor that uses Pyrefly's LSP server
-2. **Cleaner architecture** - The server respects capabilities rather than the client filtering
-3. **Performance** - Server doesn't process requests for disabled services
+2. **Cleaner architecture** - The server respects capabilities through standard LSP initialization
+3. **Performance** - Disabled services are not advertised as capabilities
 4. **Maintainability** - Logic is centralized in one place
 
 ### How It Works
 
-1. **Initialization**: Disabled services are communicated to the server via:
-   - Command-line arguments (stored in `LspArgs`)
-   - IDE configuration (sent via `workspace/configuration` request)
+1. **Initialization**: Disabled services are passed via command-line arguments (stored in `LspArgs`)
 
 2. **Capability Negotiation**: The server's `capabilities` function checks disabled services and omits them from the advertised capabilities during LSP initialization.
 
-3. **Runtime Checks**: For services that are disabled via IDE configuration after initialization, the server performs runtime checks before processing requests.
+3. **Service Availability**: Once capabilities are negotiated, clients will not request disabled services since they are not advertised.
 
 ## Use Cases
 
@@ -103,10 +88,11 @@ If you're working on a very large codebase and find that certain language servic
 
 ```json
 {
-  "python.pyrefly.disabledLanguageServices": {
-    "references": true,
-    "workspaceSymbol": true
-  }
+  "pyrefly.lspArguments": [
+    "lsp",
+    "--disable-references",
+    "--disable-workspace-symbol"
+  ]
 }
 ```
 
@@ -116,10 +102,11 @@ If you're using multiple language servers and want to use Pyrefly for type check
 
 ```json
 {
-  "python.pyrefly.disabledLanguageServices": {
-    "completion": true,
-    "hover": true
-  }
+  "pyrefly.lspArguments": [
+    "lsp",
+    "--disable-completion",
+    "--disable-hover"
+  ]
 }
 ```
 
@@ -129,34 +116,28 @@ For a minimal setup with only type checking and go-to-definition:
 
 ```json
 {
-  "python.pyrefly.disabledLanguageServices": {
-    "hover": true,
-    "completion": true,
-    "signatureHelp": true,
-    "documentHighlight": true,
-    "documentSymbol": true,
-    "workspaceSymbol": true,
-    "semanticTokens": true,
-    "inlayHint": true
-  }
+  "pyrefly.lspArguments": [
+    "lsp",
+    "--disable-hover",
+    "--disable-completion",
+    "--disable-signature-help",
+    "--disable-document-highlight",
+    "--disable-document-symbol",
+    "--disable-workspace-symbol",
+    "--disable-semantic-tokens",
+    "--disable-inlay-hint"
+  ]
 }
 ```
 
-## Backward Compatibility
-
-The existing `python.pyrefly.disableLanguageServices` (plural, present tense) boolean setting still works and will disable **all** language services when set to `true`. 
-
-The new `python.pyrefly.disabledLanguageServices` (past tense) object allows for selective disabling of individual services. Both settings are fully backward compatible and can be used independently or together.
-
 ## Testing
 
-The implementation includes comprehensive tests to ensure:
-- Individual services can be disabled independently
-- Other services continue to work when one is disabled
-- Configuration changes are applied correctly
-- Command-line arguments work as expected
+The implementation includes tests to ensure:
+- Command-line arguments are correctly parsed
+- Disabled services are omitted from capabilities
+- The LSP server functions correctly with services disabled
 
 Run tests with:
 ```bash
-cargo test --package pyrefly --lib test::lsp::lsp_interaction::configuration
+cargo test --package pyrefly --lib
 ```
diff --git a/lsp/README.md b/lsp/README.md
@@ -24,25 +24,13 @@ to ensure your project is set up properly, see
 The following configuration options are IDE-specific and exposed as VSCode
 settings:
 
-- `python.pyrefly.displayTypeErrors` [enum: default, force-on, force-off]: by
+- `python.pyrefly.disableTypeErrors` [enum: default, force-on, force-off]: by
   default, Pyrefly will only provide type errors in your project if a
   `pyrefly.toml` is present. Modify this setting to override the IDE
   diagnostics.
 - `python.pyrefly.disableLanguageServices` [boolean: false]: by default, Pyrefly
   will provide both type errors and other language features like go-to
   definition, intellisense, hover, etc. Enable this option to keep type errors
   from Pyrefly unchanged but use VSCode's Python extension for everything else.
-- `python.pyrefly.disabledLanguageServices` [object]: selectively disable
-  individual language services. This is an object with boolean properties for
-  each service: `definition`, `typeDefinition`, `codeAction`, `completion`,
-  `documentHighlight`, `references`, `rename`, `signatureHelp`, `hover`,
-  `inlayHint`, `documentSymbol`, `workspaceSymbol`, and `semanticTokens`.
-  For example, to disable hover and document symbols:
-  ```json
-  "python.pyrefly.disabledLanguageServices": {
-    "hover": true,
-    "documentSymbol": true
-  }
-  ```
 - `pyrefly.lspPath` [string: '']: if your platform is not supported, you can
   build pyrefly from source and specify the binary here.
diff --git a/lsp/package.json b/lsp/package.json
@@ -77,78 +77,6 @@
                     "default": false,
                     "description": "If true, pyrefly will not provide other IDE services like completions, hover, definition, etc. To control type errors, see `python.pyrefly.displayTypeErrors`"
                 },
-                "python.pyrefly.disabledLanguageServices": {
-                    "type": "object",
-                    "default": {},
-                    "description": "Selectively disable individual language services",
-                    "properties": {
-                        "definition": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable go-to-definition"
-                        },
-                        "typeDefinition": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable go-to-type-definition"
-                        },
-                        "codeAction": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable code actions (quick fixes)"
-                        },
-                        "completion": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable completion (autocomplete)"
-                        },
-                        "documentHighlight": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable document highlight"
-                        },
-                        "references": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable find references"
-                        },
-                        "rename": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable rename"
-                        },
-                        "signatureHelp": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable signature help (parameter hints)"
-                        },
-                        "hover": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable hover (tooltips)"
-                        },
-                        "inlayHint": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable inlay hints"
-                        },
-                        "documentSymbol": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable document symbols (outline)"
-                        },
-                        "workspaceSymbol": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable workspace symbols"
-                        },
-                        "semanticTokens": {
-                            "type": "boolean",
-                            "default": false,
-                            "description": "Disable semantic tokens"
-                        }
-                    }
-                },
                 "python.pyrefly.displayTypeErrors": {
                     "type": "string",
                     "description": "If 'default', Pyrefly will only provide type check squiggles in the IDE if your file is covered by a Pyrefly configuration. If 'force-off', Pyrefly will never provide type check squiggles in the IDE. If 'force-on', Pyrefly will always provide type check squiggles in the IDE.",
diff --git a/pyrefly/lib/lsp/non_wasm/server.rs b/pyrefly/lib/lsp/non_wasm/server.rs
@@ -187,7 +187,6 @@ 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;
@@ -854,28 +853,17 @@ impl Server {
                     if let Some(params) = self
                         .extract_request_params_or_send_err_response::<HoverRequest>(params, &x.id)
                     {
-                        // 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);
-                        }
+                        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
@@ -937,24 +925,16 @@ impl Server {
                             params, &x.id,
                         )
                     {
-                        // 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);
-                        }
+                        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
@@ -1708,22 +1688,6 @@ 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<'_>,
diff --git a/pyrefly/lib/lsp/non_wasm/workspace.rs b/pyrefly/lib/lsp/non_wasm/workspace.rs
diff --git a/pyrefly/lib/test/lsp/lsp_interaction/configuration.rs b/pyrefly/lib/test/lsp/lsp_interaction/configuration.rs
