Use asyncio

dependencies.json

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

plugin/core/executors.py

@@ -0,0 +1,46 @@
+import concurrent.futures
+import threading
+from typing import Any, Callable, TypeVar
+
+import sublime
+
+
+class _SetTimeoutAsyncExecutor(concurrent.futures.Executor):
+    """
+    An Executor that wraps sublime.set_timeout_async.
+    """
+
+    def __init__(self) -> None:
+        self._running = 0
+        self._shuttingdown = False
+        self._lock = threading.Lock()
+        self._cv = threading.Condition(self._lock)
+
+    def submit(self, fn: Callable[..., Any], *args: Any, **kwargs: Any) -> concurrent.futures.Future:
+        if self._shuttingdown:
+            raise RuntimeError("Executor is shutting down")
+        future: concurrent.futures.Future = concurrent.futures.Future()
+        with self._cv:
+            self._running += 1
+
+        def run() -> None:
+            try:
+                future.set_result(fn(*args, **kwargs))
+            except BaseException as ex:
+                future.set_exception(ex)
+            with self._cv:
+                self._running -= 1
+                if self._running == 0:
+                    self._cv.notify()
+
+        sublime.set_timeout_async(run)
+        return future
+
+    def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None:
+        self._shuttingdown = True
+        if wait:
+            with self._cv:
+                self._cv.wait_for(lambda: self._running == 0)
+
+
+executor = _SetTimeoutAsyncExecutor()

plugin/core/promise.py

@@ -6,6 +6,7 @@
 from typing import Tuple
 from typing import TypeVar
 from typing import Union
+import asyncio
 import functools
 import threading
 
@@ -207,6 +208,22 @@ def async_wrapper(resolve_fn: ResolveFunc[TResult]) -> None:
             return Promise(sync_wrapper)
         return Promise(async_wrapper)
 
+    def __await__(self):
+        """You can `await` a Promise."""
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        with self.mutex:
+            if self.resolved:
+                future.set_result(self.value)
+            else:
+
+                def resolve_callback(value: T) -> None:
+                    # We don't know from which thread we are resolving, so use call_soon_threadsafe.
+                    loop.call_soon_threadsafe(functools.partial(future.set_result, value))
+
+                self.callbacks.append(resolve_callback)
+        return future.__await__()
+
     def _do_resolve(self, new_value: T) -> None:
         # No need to block as we can't change from resolved to unresolved.
         if self.resolved:

plugin/core/protocol.py

@@ -439,6 +439,13 @@ class ResponseError(TypedDict):
     data: NotRequired[LSPAny]
 
 
+class ResponseException(Exception):
+    error: ResponseError
+
+    def __init__(error: ResponseError) -> None:
+        self.error = error
+
+
 class ResolvedCodeLens(TypedDict):
     range: Range
     command: Command