Use asyncio

boot.py

@@ -17,9 +17,11 @@
 from .plugin.configuration import LspDisableLanguageServerInProjectCommand
 from .plugin.configuration import LspEnableLanguageServerGloballyCommand
 from .plugin.configuration import LspEnableLanguageServerInProjectCommand
+from .plugin.core.aio import run_coroutine_threadsafe
 from .plugin.core.constants import ST_VERSION
 from .plugin.core.css import load as load_css
 from .plugin.core.open import g_opening_files
+from .plugin.core.open import g_opening_files_lock
 from .plugin.core.panels import PanelName
 from .plugin.core.registry import LspCheckApplicableCommand
 from .plugin.core.registry import LspNextDiagnosticCommand
@@ -88,9 +90,17 @@
 from .plugin.tooling import LspParseVscodePackageJson
 from .plugin.tooling import LspTroubleshootServerCommand
 from typing import Any
+from typing import TYPE_CHECKING
 import os
 import sublime
+import sublime_aio
 import sublime_plugin
+import warnings
+
+if TYPE_CHECKING:
+    import asyncio
+
+warnings.simplefilter('always', DeprecationWarning)  # turn off filter
 
 __all__ = (
     "DocumentSyncListener",
@@ -219,14 +229,14 @@ def show_warning() -> None:
 
 def plugin_unloaded() -> None:
     _unregister_all_plugins()
-    windows.disable()
+    run_coroutine_threadsafe(windows.disable())
     unload_settings()
 
 
-class Listener(sublime_plugin.EventListener):
+class Listener(sublime_aio.EventListener):
 
-    def on_exit(self) -> None:
-        kill_all_subprocesses()
+    async def on_exit(self) -> None:
+        await kill_all_subprocesses()
 
     def on_load_project_async(self, window: sublime.Window) -> None:
         if manager := windows.lookup(window):
@@ -255,27 +265,27 @@ def on_pre_move(self, view: sublime.View) -> None:
                     sublime.set_timeout_async(listener.on_post_move_window_async, 1)
                     return
 
-    def on_load(self, view: sublime.View) -> None:
+    async def on_load(self, view: sublime.View) -> None:
         file_name = view.file_name()
         if not file_name:
             return
-        for fn in g_opening_files:
-            if fn == file_name or os.path.samefile(fn, file_name):
-                # Remove it from the pending opening files, and resolve the promise.
-                g_opening_files.pop(fn)[1](view)
-                break
+        if future := await self._find_opening_file_future(file_name):
+            future.set_result(view)
 
-    def on_pre_close(self, view: sublime.View) -> None:
+    async def on_pre_close(self, view: sublime.View) -> None:
         file_name = view.file_name()
         if not file_name:
             return
-        for fn in g_opening_files:
-            if fn == file_name or os.path.samefile(fn, file_name):
-                tup = g_opening_files.pop(fn, None)  # noqa: B909
-                if tup:
-                    # The view got closed before it finished loading. This can happen.
-                    tup[1](None)
-                    break
+        if future := await self._find_opening_file_future(file_name):
+            # The view got closed before it finished loading. This can happen.
+            future.set_result(None)
+
+    async def _find_opening_file_future(self, file_name: str) -> asyncio.Future[sublime.View | None] | None:
+        async with g_opening_files_lock:
+            for fn in g_opening_files:
+                if fn == file_name or os.path.samefile(fn, file_name):
+                    return g_opening_files.pop(fn, None)
+        return None
 
     def on_post_window_command(self, window: sublime.Window, command_name: str, args: dict[str, Any] | None) -> None:
         if command_name == "show_panel":

dependencies.json

@@ -4,6 +4,7 @@
             "bracex",
             "mdpopups",
             "orjson",
+            "sublime_aio",
             "typing_extensions",
             "wcmatch"
         ]

plugin/api.py

@@ -1,15 +1,22 @@
 from __future__ import annotations
 
+from ..protocol import ConfigurationItem
+from ..protocol import DocumentUri
+from ..protocol import ExecuteCommandParams
 from ..protocol import LSPAny
 from .core.constants import ST_STORAGE_PATH
 from .core.logging import exception_log
+from .core.logging import debug
+from .core.protocol import Notification
+from .core.protocol import Request
 from .core.protocol import Response
 from .core.settings import client_configs
 from .core.types import method2attr
 from .core.url import parse_uri
 from .core.views import uri_from_view
 from abc import ABC
 from abc import abstractmethod
+from collections.abc import Awaitable
 from dataclasses import dataclass
 from functools import wraps
 from pathlib import Path
@@ -222,31 +229,33 @@ def decorator(func: Callable[[Any, P], None]) -> Callable[[Any, P], None]:
 
 def request_handler(
     method: str
-) -> Callable[[Callable[[Any, P], Promise[R]]], Callable[[Any, P, int], Promise[Response[R]]]]:
+) -> Callable[[Callable[[Any, P], Awaitable[R]]], Callable[[Any, P, int], Awaitable[Response[R]]]]:
     """
-    Decorator to mark a method as a handler for a specific LSP request.
+    Decorator to mark a coroutine method as a handler for a specific LSP request.
 
     Usage:
         ```py
         @request_handler('eslint/openDoc')
-        def on_open_doc(self, params: TextDocumentIdentifier) -> Promise[bool]:
+        async def on_open_doc(self, params: TextDocumentIdentifier) -> bool:
             ...
         ```
 
-    The decorated method will be called with the request parameters whenever the specified
-    request is received from the language server. The method must return a Promise that resolves
-    to the response value. The framework will automatically send it back to the server.
+    The decorated coroutine method will be called with the request parameters whenever the specified
+    request is received from the language server. The coroutine method must return a response value.
+    The framework will automatically send it back to the server.
+
+    An older, but backwards-compatible way to define a request handler is by defining a function that returns a Promise.
+    While that works, the advice is to define a coroutine function.
 
     :param      method:             The LSP request method name (e.g., 'eslint/openDoc').
-    :returns:   A decorator that registers the function as a request handler.
+    :returns:   A decorator that registers the coroutine function as a request handler.
     """
 
-    def decorator(func: Callable[[Any, P], Promise[R]]) -> Callable[[Any, P, int], Promise[Response[R]]]:
+    def decorator(func: Callable[[Any, P], Awaitable[R]]) -> Callable[[Any, P, int], Awaitable[Response[R]]]:
 
         @wraps(func)
-        def wrapper(self: Any, params: P, request_id: int) -> Promise[Response[Any]]:
-            promise = func(self, params)
-            return promise.then(lambda result: Response(request_id, result))
+        async def wrapper(self: Any, params: P, request_id: int) -> Response[Any]:
+            return Response(request_id, await func(self, params))
 
         setattr(wrapper, HANDLER_MARKER, method)
         return wrapper
@@ -423,6 +432,11 @@ def plugin_unloaded() -> None:
         """
         unregister_plugin_impl(cls)
 
+    @classmethod
+    def use_asyncio(cls) -> bool:
+        """Override and return `true` to make LSP use `async def` variants."""
+        return False
+
     @classmethod
     def is_applicable_async(cls, context: IsApplicableContext) -> bool:
         """
@@ -452,8 +466,8 @@ def on_pre_start_async(cls, context: OnPreStartContext) -> None:
         Override to perform any preparation needed before startup - for example installing or updating server binaries,
         resolving the working directory, or injecting extra template variables into `context.variables`.
 
-        This method runs on a worker thread so perform any blocking I/O (e.g. downloading a binary, running
-        `npm install`) directly here without spawning additional threads.
+        Attempt to use non-blocking functionality for downloading binaries and running subprocesses in order to not
+        block the asyncio thread.
 
         Mutations to `context.working_directory` and `context.variables` are picked up and used when launching the
         server process.
@@ -465,6 +479,16 @@ def on_pre_start_async(cls, context: OnPreStartContext) -> None:
         """
         pass
 
+    @classmethod
+    async def on_pre_start(cls, context: OnPreStartContext) -> None:
+        """
+        Async version of on_pre_start_async.
+
+        :param      context:    The startup context. `context.configuration`, `context.variables` and
+                                `context.working_directory` can be mutated to influence how the server is launched.
+        """
+        pass
+
     def __init__(self, weaksession: ref[Session]) -> None:
         """
         Constructs a new instance.
@@ -483,7 +507,7 @@ def __init_subclass__(cls, **kwargs: Any) -> None:
         cls.name = cls.__module__.split('.')[0]  # pyright: ignore[reportAttributeAccessIssue]
         cls.plugin_storage_path = Path(ST_STORAGE_PATH, cls.name)  # pyright: ignore[reportAttributeAccessIssue]
 
-    def on_transport_ready_async(self, transport: TransportWrapper) -> None:
+    async def on_transport_ready(self, transport: TransportWrapper) -> None:
         """
         Called after the transport is established but before the LSP `initialize` request is sent.
 
@@ -501,10 +525,12 @@ def on_transport_ready_async(self, transport: TransportWrapper) -> None:
         """
         pass
 
-    def on_initialize_async(self) -> None:
+    async def on_initialize(self) -> None:
         """
         Called after the `initialize` response has been received from the language server.
 
+        TODO: invoked before or after the `initialized` notification?
+
         Override to perform any post-initialization work, such as sending custom notifications or requests
         that depend on the server's capabilities reported in the `initialize` response.
         """

plugin/code_actions.py

@@ -5,6 +5,8 @@
 from ..protocol import CodeActionParams
 from ..protocol import Command
 from ..protocol import Diagnostic
+from .core.aio import call_soon_threadsafe
+from .core.aio import run_coroutine_threadsafe
 from .core.promise import Promise
 from .core.protocol import Error
 from .core.protocol import Request
@@ -65,9 +67,9 @@ def is_quickfix(action: Command | CodeAction) -> bool:
 
 
 def filter_quickfix_actions(
-    only_with_diagnostics: bool, response: list[Command | CodeAction] | Error | None
+    only_with_diagnostics: bool, response: list[Command | CodeAction] | BaseException | None
 ) -> list[Command | CodeAction]:
-    if isinstance(response, Error) or not response:
+    if isinstance(response, BaseException) or not response:
         return []
     if only_with_diagnostics:
         # If there are multiple diagnostics for the region, in the hover popup we can only use those code actions which
@@ -302,7 +304,7 @@ def _handle_response_async(
         if self._cancelled:
             return
         view = self._task_runner.view
-        tasks: list[Promise[None]] = []
+        tasks: list[Promise[BaseException | None]] = []
         config_name, code_actions = response
         session = self._task_runner.session_by_name(config_name, 'codeActionProvider')
         if session and code_actions:
@@ -386,9 +388,9 @@ def run(
         if code_actions_by_config:
             self._handle_code_actions(code_actions_by_config, run_first=True)
             return
-        self._run_async(only_kinds)
+        run_coroutine_threadsafe(self._run(only_kinds))
 
-    def _run_async(self, only_kinds: list[str | CodeActionKind] | None = None) -> None:
+    async def _run(self, only_kinds: list[str | CodeActionKind] | None = None) -> None:
         view = self.view
         region = first_selection_region(view)
         if region is None:
@@ -427,13 +429,13 @@ def _handle_select(self, index: int, actions: list[tuple[ConfigName, CodeActionO
         if index == -1:
             return
 
-        def run_async() -> None:
+        async def run() -> None:
             config_name, action = actions[index]
             if session := self.session_by_name(config_name):
-                session.run_code_action_async(action, progress=True, view=self.view) \
-                    .then(lambda response: self._handle_response_async(config_name, response))
+                response = await session.run_code_action(action, progress=True, view=self.view)
+                self._handle_response_async(config_name, response)
 
-        sublime.set_timeout_async(run_async)
+        run_coroutine_threadsafe(run())
 
     def _handle_response_async(self, session_name: str, response: Any) -> None:
         if isinstance(response, Error):
@@ -463,7 +465,7 @@ def is_enabled(self, index: int, event: dict | None = None) -> bool:
     def is_visible(self, index: int, event: dict | None = None) -> bool:
         if index == -1:
             if self._has_session(event):
-                sublime.set_timeout_async(partial(self._request_menu_actions_async, event))
+                call_soon_threadsafe(partial(self._request_menu_actions_async, event))
             return False
         return index < len(self.actions_cache) and self._is_cache_valid(event)
 
@@ -488,14 +490,14 @@ def want_event(self) -> bool:
         return True
 
     def run(self, index: int, event: dict | None = None) -> None:
-        sublime.set_timeout_async(partial(self.run_async, index, event))
+        run_coroutine_threadsafe(self._run(index, event))
 
-    def run_async(self, index: int, event: dict | None) -> None:
+    async def _run(self, index: int, event: dict | None) -> None:
         if self._is_cache_valid(event):
             config_name, action = self.actions_cache[index]
             if session := self.session_by_name(config_name):
-                session.run_code_action_async(action, progress=True, view=self.view) \
-                    .then(lambda response: self._handle_response_async(config_name, response))
+                response = await session.run_code_action(action, progress=True, view=self.view)
+                self._handle_response_async(config_name, response)
 
     def _handle_response_async(self, session_name: str, response: Any) -> None:
         if isinstance(response, Error):

plugin/code_lens.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
+from .core.aio import call_soon_threadsafe
 from .core.constants import CODE_LENS_ENABLED_KEY
 from .core.protocol import Error
 from .core.protocol import ResolvedCodeLens
 from .core.registry import LspTextCommand
 from .core.registry import LspWindowCommand
 from .core.registry import windows
 from .core.views import range_to_region
-from functools import partial
 from typing import cast
 from typing import TYPE_CHECKING
 from typing_extensions import TypeGuard
@@ -128,7 +128,7 @@ def is_checked(self) -> bool:
     def run(self) -> None:
         enable = not self.is_checked()
         self.window.settings().set(CODE_LENS_ENABLED_KEY, enable)
-        sublime.set_timeout_async(partial(self._update_views_async, enable))
+        call_soon_threadsafe(self._update_views_async, enable)
 
     def _update_views_async(self, enable: bool) -> None:
         window_manager = windows.lookup(self.window)

plugin/color.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from .core.aio import run_coroutine_threadsafe
 from .core.edit import apply_text_edits
 from .core.protocol import Request
 from .core.registry import LspTextCommand
@@ -27,7 +28,7 @@ def run(self, edit: sublime.Edit, color_information: ColorInformation) -> None:
                 'color': color_information['color'],
                 'range': self._range
             }
-            session.send_request_async(Request.colorPresentation(params, self.view), self._handle_response_async)
+            session.send_request(Request.colorPresentation(params, self.view), self._handle_response_async)
 
     def want_event(self) -> bool:
         return False
@@ -60,4 +61,4 @@ def _on_select(self, index: int) -> None:
         if index > -1:
             color_pres = self._filtered_response[index]
             text_edit = color_pres.get('textEdit') or {'range': self._range, 'newText': color_pres['label']}
-            apply_text_edits(self.view, [text_edit], label="Change Color Format", required_view_version=self._version)
+            run_coroutine_threadsafe(apply_text_edits(self.view, [text_edit], label="Change Color Format", required_view_version=self._version))