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 get_opening_files_lock
 from .plugin.core.panels import PanelName
 from .plugin.core.registry import LspCheckApplicableCommand
 from .plugin.core.registry import LspNextDiagnosticCommand
@@ -88,10 +90,18 @@
 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
 
+if TYPE_CHECKING:
+    import asyncio
+
+# Uncomment to see all invocations that are marked @deprecated in the Console.
+# warnings.simplefilter('always', DeprecationWarning)
+
 __all__ = (
     "DocumentSyncListener",
     "Listener",
@@ -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 get_opening_files_lock():
+            for fn in g_opening_files:
+                if fn == file_name or os.path.samefile(fn, file_name):  # noqa: ASYNC240
+                    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,8 +1,13 @@
 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.protocol import Notification
+from .core.protocol import Request
 from .core.protocol import Response
 from .core.settings import client_configs
 from .core.types import method2attr
@@ -14,6 +19,7 @@
 from functools import wraps
 from pathlib import Path
 from typing import Any
+from typing import Awaitable
 from typing import Callable
 from typing import Final
 from typing import final
@@ -221,31 +227,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
@@ -390,6 +398,9 @@ def plugin_unloaded() -> None:
     Use this as your directory to install server files. Its path is `$DATA/Package Storage/<Package Name>`.
     """
 
+    use_asyncio: bool = False
+    """Set to `true` to make LSP use `async def` variants."""
+
     @classmethod
     @final
     def register(cls) -> None:
@@ -464,6 +475,19 @@ 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.
+
+        Attempt to use non-blocking functionality for downloading binaries and running subprocesses in order to not
+        block the asyncio thread.
+
+        :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.
@@ -491,6 +515,10 @@ def on_initialized_async(self) -> None:
         """
         pass
 
+    async def on_initialized(self) -> None:
+        """Async version of `on_initialize_async`."""
+        pass
+
     def on_pre_send_request_async(self, request: ClientRequest, view: sublime.View | None) -> None:
         """
         Notifies about a request that is about to be sent to the language server.

plugin/code_actions.py

@@ -5,6 +5,10 @@
 from ..protocol import CodeActionParams
 from ..protocol import Command
 from ..protocol import Diagnostic
+from ..protocol import LSPAny
+from .core.aio import call_soon_threadsafe
+from .core.aio import run_coroutine_threadsafe
+from .core.logging import trace
 from .core.promise import Promise
 from .core.protocol import Error
 from .core.protocol import Request
@@ -23,20 +27,21 @@
 from functools import partial
 from typing import Any
 from typing import cast
+from typing import Coroutine
 from typing import final
 from typing import List
 from typing import Tuple
 from typing import TYPE_CHECKING
 from typing import Union
 from typing_extensions import override
+import asyncio
 import sublime
 
 if TYPE_CHECKING:
     from .core.sessions import AbstractViewListener
     from .core.sessions import SessionBufferProtocol
     from collections.abc import Callable
     from collections.abc import Generator
-    from collections.abc import Iterator
     from typing_extensions import TypeGuard
 
 
@@ -65,9 +70,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
@@ -202,17 +207,20 @@ def on_response(
             sb: SessionBufferProtocol, response: Error | list[CodeActionOrCommand] | None
         ) -> CodeActionsByConfigName:
             actions = []
+            trace(sb=sb, response=response)
             if response and not isinstance(response, Error):
                 # Filter actions returned from the session so that only matching kinds are collected.
                 # Since older servers don't support the "context.only" property, those will return all
                 # actions that need to be then manually filtered.
                 session_kinds = get_session_kinds(sb)
                 matching_kinds = get_matching_kinds(code_actions, session_kinds)
                 actions = [a for a in response if a.get('kind') in matching_kinds and not a.get('disabled')]
+                trace(session_kinds=session_kinds, matching_kinds=matching_kinds, actions=actions)
             return (sb.session.config.name, actions)
 
         for sb in listener.session_buffers_async('codeActionProvider'):
             matching_kinds = get_matching_kinds(code_actions, get_session_kinds(sb))
+            trace(code_actions=code_actions, matching_kinds=matching_kinds)
             for kind in matching_kinds:
                 listener.purge_changes_async()
                 # Pull for diagnostics to ensure that server computes them before receiving code action request.
@@ -281,35 +289,21 @@ def get_code_action_kinds(cls, view: sublime.View) -> dict[str, bool]:
         }
 
     @override
-    def run_async(self) -> None:
-        super().run_async()
-        view = self._task_runner.view
+    async def run(self) -> None:
+        await super().run()
+        trace()
+        view = self._text_command.view
         code_action_kinds = self.get_code_action_kinds(view)
-        request_iterator = actions_manager.request_on_save_or_format_async(view, code_action_kinds)
-        self._process_next_request(request_iterator)
-
-    def _process_next_request(self, request_iterator: Iterator[Promise[CodeActionsByConfigName]]) -> None:
-        if self._cancelled:
-            return
-        if request := next(request_iterator, None):
-            request.then(lambda response: self._handle_response_async(response, request_iterator))
-        else:
-            self._on_complete()
-
-    def _handle_response_async(
-        self, response: CodeActionsByConfigName, request_iterator: Iterator[Promise[CodeActionsByConfigName]]
-    ) -> None:
-        if self._cancelled:
-            return
-        view = self._task_runner.view
-        tasks: list[Promise[None]] = []
-        config_name, code_actions = response
-        session = self._task_runner.session_by_name(config_name, 'codeActionProvider')
-        if session and code_actions:
-            tasks.extend([
-                session.run_code_action_async(action, progress=False, view=view) for action in code_actions
-            ])
-        Promise.all(tasks).then(lambda _: self._process_next_request(request_iterator))
+        tasks: list[Coroutine[None, None, LSPAny]] = []
+        for request in actions_manager.request_on_save_or_format_async(view, code_action_kinds):
+            config_name, code_actions = await request
+            trace(code_actions=code_actions)
+            if code_actions and (session := self._text_command.session_by_name(config_name, 'codeActionProvider')):
+                tasks.extend(
+                    session.run_code_action(action, progress=False, view=self._text_command.view)
+                    for action in code_actions
+                )
+        await asyncio.gather(*tasks)
 
 
 @final
@@ -386,9 +380,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 +421,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 +457,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 +482,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):