Remove deprecated properties of ClientConfig (#2767)

Author: rchl

docs/src/client_configuration.md

@@ -41,7 +41,7 @@ Below is an example of the `LSP.sublime-settings` file with configurations for t
 | settings | per-project settings (equivalent to VS Code's Workspace Settings) |
 | initializationOptions | options to send to the server at startup (rarely used) |
 | selector | This is _the_ connection between your files and language servers. It's a selector that is matched against the current view's base scope. If the selector matches with the base scope of the the file, the associated language server is started. For more information, see https://www.sublimetext.com/docs/3/selectors.html |
-| priority_selector | Used to prioritize a certain language server when choosing which one to query on views with multiple servers active. Certain LSP actions have to pick which server to query and this setting can be used to decide which one to pick based on the current scopes at the cursor location. For example when having both HTML and PHP servers running on a PHP file, this can be used to give priority to the HTML one in HTML blocks and to PHP one otherwise. That would be done by setting "priority_selector" to `text.html` for HTML server and `source.php` to PHP server. Note: when the "priority_selector" is missing, it will be the same as the "document_selector".
+| priority_selector | Used to prioritize a certain language server when choosing which one to query on views with multiple servers active. Certain LSP actions have to pick which server to query and this setting can be used to decide which one to pick based on the current scopes at the cursor location. For example when having both HTML and PHP servers running on a PHP file, this can be used to give priority to the HTML one in HTML blocks and to PHP one otherwise. That would be done by setting "priority_selector" to `text.html` for HTML server and `source.php` to PHP server.
 | diagnostics_mode | Set to `"workspace"` (default is `"open_files"`) to ignore diagnostics for files that are not within the project (window) folders. If project has no folders then this option has no effect and diagnostics are shown for all files. If the server supports _pull diagnostics_ (`diagnosticProvider`), this setting also controls whether diagnostics are requested only for open files (`"open_files"`), or for all files in the project folders (`"workspace"`). |
 | tcp_port | see instructions below |
 | experimental_capabilities | Turn on experimental capabilities of a language server. This is a dictionary and differs per language server |

plugin/core/sessions.py

@@ -908,8 +908,8 @@ def name(cls) -> str:
     @classmethod
     def configuration(cls) -> tuple[sublime.Settings, str]:
         """
-        Return the Settings object that defines the "command", "languages", and optionally the "initializationOptions",
-        "default_settings", "env" and "tcp_port" as the first element in the tuple, and the path to the base settings
+        Return the Settings object that defines the "command", "selector", and optionally the "initializationOptions",
+        "env" and "tcp_port" as the first element in the tuple, and the path to the base settings
         filename as the second element in the tuple.
 
         The second element in the tuple is used to handle "settings" overrides from users properly. For example, if your

plugin/core/types.py

@@ -725,46 +725,43 @@ def __init__(
 
 
 class ClientConfig:
-    def __init__(self,
-                 name: str,
-                 selector: str,
-                 priority_selector: str | None = None,
-                 schemes: list[str] | None = None,
-                 command: list[str] | None = None,
-                 binary_args: list[str] | None = None,  # DEPRECATED
-                 tcp_port: int | None = None,
-                 auto_complete_selector: str | None = None,
-                 enabled: bool = True,
-                 init_options: DottedDict = DottedDict(),
-                 settings: DottedDict = DottedDict(),
-                 env: dict[str, str | list[str]] = {},
-                 experimental_capabilities: dict[str, Any] | None = None,
-                 disabled_capabilities: DottedDict = DottedDict(),
-                 file_watcher: FileWatcherConfig = {},
-                 semantic_tokens: dict[str, str] | None = None,
-                 diagnostics_mode: str = "open_files",
-                 path_maps: list[PathMap] | None = None) -> None:
+    def __init__(
+        self,
+        name: str,
+        selector: str,
+        priority_selector: str | None = None,
+        schemes: list[str] | None = None,
+        command: list[str] | None = None,
+        tcp_port: int | None = None,
+        auto_complete_selector: str | None = None,
+        enabled: bool = True,
+        init_options: DottedDict | None = None,
+        settings: DottedDict | None = None,
+        env: dict[str, str | list[str]] | None = None,
+        experimental_capabilities: dict[str, Any] | None = None,
+        disabled_capabilities: DottedDict | None = None,
+        file_watcher: FileWatcherConfig | None = None,
+        semantic_tokens: dict[str, str] | None = None,
+        diagnostics_mode: str = "open_files",
+        path_maps: list[PathMap] | None = None
+    ) -> None:
         self.name = name
         self.selector = selector
         self.priority_selector = priority_selector if priority_selector else self.selector
         if isinstance(schemes, list):
             self.schemes: list[str] = schemes
         else:
             self.schemes = ["file"]
-        if isinstance(command, list):
-            self.command = command
-        else:
-            assert isinstance(binary_args, list)
-            self.command = binary_args
+        self.command = command
         self.tcp_port = tcp_port
         self.auto_complete_selector = auto_complete_selector
         self.enabled = enabled
-        self.init_options = init_options
-        self.settings = settings
-        self.env = env
+        self.init_options = init_options or DottedDict()
+        self.settings = settings or DottedDict()
+        self.env = env or {}
         self.experimental_capabilities = experimental_capabilities
-        self.disabled_capabilities = disabled_capabilities
-        self.file_watcher = file_watcher
+        self.disabled_capabilities = disabled_capabilities or DottedDict()
+        self.file_watcher = file_watcher or {}
         self.path_maps = path_maps
         self.status_key = f"lsp_{self.name}"
         self.semantic_tokens = semantic_tokens
@@ -970,88 +967,16 @@ def __eq__(self, other: Any) -> bool:
 
 
 def _read_selector(config: sublime.Settings | dict[str, Any]) -> str:
-    # Best base scenario,
     selector = config.get("selector")
     if isinstance(selector, str):
         return selector
-    # Otherwise, look for "languages": [...]
-    languages = config.get("languages")
-    if isinstance(languages, list):
-        selectors = []
-        for language in languages:
-            # First priority is document_selector,
-            document_selector = language.get("document_selector")
-            if isinstance(document_selector, str):
-                selectors.append(document_selector)
-                continue
-            # After that syntaxes has priority,
-            syntaxes = language.get("syntaxes")
-            if isinstance(syntaxes, list):
-                for path in syntaxes:
-                    syntax = sublime.syntax_from_path(path)
-                    if syntax:
-                        selectors.append(syntax.scope)
-                continue
-            # No syntaxes and no document_selector... then there must exist a languageId.
-            language_id = language.get("languageId")
-            if isinstance(language_id, str):
-                selectors.append(f"source.{language_id}")
-        return "|".join(map("({})".format, selectors))
-    # Otherwise, look for "document_selector"
-    document_selector = config.get("document_selector")
-    if isinstance(document_selector, str):
-        return document_selector
-    # Otherwise, look for "syntaxes": [...]
-    syntaxes = config.get("syntaxes")
-    if isinstance(syntaxes, list):
-        selectors = []
-        for path in syntaxes:
-            syntax = sublime.syntax_from_path(path)
-            if syntax:
-                selectors.append(syntax.scope)
-        return "|".join(selectors)
-    # No syntaxes and no document_selector... then there must exist a languageId.
-    if language_id := config.get("languageId"):
-        return f"source.{language_id}"
     return ""
 
 
 def _read_priority_selector(config: sublime.Settings | dict[str, Any]) -> str:
-    # Best case scenario
     selector = config.get("priority_selector")
     if isinstance(selector, str):
         return selector
-    # Otherwise, look for "languages": [...]
-    languages = config.get("languages")
-    if isinstance(languages, list):
-        selectors = []
-        for language in languages:
-            # First priority is feature_selector.
-            feature_selector = language.get("feature_selector")
-            if isinstance(feature_selector, str):
-                selectors.append(feature_selector)
-                continue
-            # After that scopes has priority.
-            scopes = language.get("scopes")
-            if isinstance(scopes, list):
-                selectors.extend(scopes)
-                continue
-            # No scopes and no feature_selector. So there must be a languageId
-            language_id = language.get("languageId")
-            if isinstance(language_id, str):
-                selectors.append(f"source.{language_id}")
-        return "|".join(map("({})".format, selectors))
-    # Otherwise, look for "feature_selector"
-    feature_selector = config.get("feature_selector")
-    if isinstance(feature_selector, str):
-        return feature_selector
-    # Otherwise, look for "scopes": [...]
-    scopes = config.get("scopes")
-    if isinstance(scopes, list):
-        return "|".join(map("({})".format, scopes))
-    # No scopes and no feature_selector... then there must exist a languageId
-    if language_id := config.get("languageId"):
-        return f"source.{language_id}"
     return ""
 
 

sublime-package.json

@@ -36,11 +36,6 @@
               },
               "markdownDescription": "A dictionary of code action identifiers that should be triggered on save.\n\nCode action identifiers are not officially standardized so refer to specific server's documentation on what is supported but `source.fixAll` is commonly used to apply fix-on-save code actions.\n\nThis option is also supported in syntax-specific settings and/or in the `\"settings\"` section of project files. Settings from all those places will be merged and more specific (syntax and project) settings will override less specific (from LSP or Sublime settings).\n\nOnly \"source.*\" actions are supported."
             },
-            // Deprecated syntaxes and scopes
-            "useSelectorInstead": {
-              "type": "string",
-              "deprecationMessage": "Use the \"selector\" key instead."
-            },
             "FileWatcher": {
               "type": "object",
               "examples": [
@@ -380,30 +375,9 @@
                 "env": {
                   "$ref": "#/definitions/ClientEnv"
                 },
-                "languageId": {
-                  "$ref": "#/definitions/useSelectorInstead"
-                },
-                "document_selector": {
-                  "$ref": "#/definitions/useSelectorInstead"
-                },
-                "feature_selector": {
-                  "$ref": "#/definitions/useSelectorInstead"
-                },
                 "diagnostics_mode": {
                   "$ref": "#/definitions/ClientDiagnosticsMode"
                 },
-                "syntaxes": {
-                  "type": "array",
-                  "$ref": "#/definitions/useSelectorInstead"
-                },
-                "scopes": {
-                  "type": "array",
-                  "$ref": "#/definitions/useSelectorInstead"
-                },
-                "languages": {
-                  "type": "array",
-                  "$ref": "#/definitions/useSelectorInstead"
-                }
               }
             },
             "SemanticTokens": {

tests/test_configs.py

@@ -17,27 +17,6 @@
 
 class ConfigParsingTests(DeferrableTestCase):
 
-    def test_can_parse_old_client_settings(self):
-        settings = {
-            "command": ["pyls"],
-            "scopes": ["text.html.vue"],
-            "syntaxes": ["Packages/Python/Python.sublime-syntax"],  # it should use this one
-            "languageId": "java"
-        }
-        config = read_client_config("pyls", settings)
-        self.assertEqual(config.selector, "source.python")
-        self.assertEqual(config.priority_selector, "(text.html.vue)")
-
-    def test_can_parse_client_settings_with_languages(self):
-        settings = {
-            "command": ["pyls"],
-            # Check that "selector" will be "source.python"
-            "languages": [{"languageId": "python"}]
-        }
-        config = read_client_config("pyls", settings)
-        self.assertEqual(config.selector, "(source.python)")
-        self.assertEqual(config.priority_selector, "(source.python)")
-
     def test_can_parse_settings_with_selector(self):
         settings = {
             "command": ["pyls"],
@@ -50,8 +29,6 @@ def test_can_parse_settings_with_selector(self):
     def test_can_update_config(self):
         settings = {
             "command": ["pyls"],
-            "document_selector": "source.python",
-            "languageId": "python"
         }
         config = read_client_config("pyls", settings)
         config = update_client_config(config, {"enabled": True})
@@ -65,8 +42,6 @@ def test_can_read_experimental_capabilities(self):
         }
         settings = {
             "command": ["pyls"],
-            "document_selector": "source.python",
-            "languageId": "python",
             "experimental_capabilities": experimental_capabilities
         }
         config = read_client_config("pyls", settings)