completion is now calculated in a separate thread

Author: d-biehl

robotcode/jsonrpc2/protocol.py

@@ -503,7 +503,7 @@ def send_message(self, message: JsonRPCMessage) -> None:
         ).encode(self.CHARSET)
 
         header = (
-            f"Content-Length: {len(body)}\r\n" f"Content-Type: {self.CONTENT_TYPE}; charset={self.CHARSET}\r\n\r\n"
+            f"Content-Length: {len(body)}\r\nContent-Type: {self.CONTENT_TYPE}; charset={self.CHARSET}\r\n\r\n"
         ).encode("ascii")
 
         self._message_logger.debug(
@@ -640,30 +640,31 @@ async def handle_request(self, message: JsonRPCRequest) -> None:
             )
             return
 
-        try:
-            params = self._convert_params(e.method, e.param_type, message.params)
+        params = self._convert_params(e.method, e.param_type, message.params)
 
-            result = asyncio.create_task(ensure_coroutine(e.method)(*params[0], **params[1]))
+        result = asyncio.create_task(ensure_coroutine(e.method)(*params[0], **params[1]), name=message.method)
 
-            with self._received_request_lock:
-                self._received_request[message.id] = ReceivedRequestEntry(result, message)
+        with self._received_request_lock:
+            self._received_request[message.id] = ReceivedRequestEntry(result, message)
 
+        def done(t: asyncio.Task[Any]) -> None:
             try:
-                self.send_response(message.id, await result)
+                self.send_response(message.id, t.result())
+            except asyncio.CancelledError:
+                self._logger.info(f"request message {repr(message)} canceled")
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except JsonRPCErrorException as ex:
+                self._logger.exception(ex)
+                self.send_error(ex.code, ex.message, id=message.id, data=ex.data)
+            except BaseException as e:
+                self._logger.exception(e)
+                self.send_error(JsonRPCErrors.INTERNAL_ERROR, f"{type(e).__name__}: {e}", id=message.id)
             finally:
                 with self._received_request_lock:
                     self._received_request.pop(message.id, None)
 
-        except asyncio.CancelledError:
-            self._logger.info(f"request message {repr(message)} canceled")
-        except (SystemExit, KeyboardInterrupt):
-            raise
-        except JsonRPCErrorException as ex:
-            self._logger.exception(ex)
-            self.send_error(ex.code, ex.message, id=message.id, data=ex.data)
-        except BaseException as e:
-            self._logger.exception(e)
-            self.send_error(JsonRPCErrors.INTERNAL_ERROR, f"{type(e).__name__}: {e}", id=message.id)
+        result.add_done_callback(done)
 
     async def cancel_request(self, id: Union[int, str, None]) -> None:
         with self._received_request_lock:
@@ -687,7 +688,8 @@ async def handle_notification(self, message: JsonRPCNotification) -> None:
             params = self._convert_params(e.method, e.param_type, message.params)
             result = e.method(*params[0], **params[1])
             if inspect.isawaitable(result):
-                await result
+                asyncio.create_task(result)
+
         except asyncio.CancelledError:
             pass
         except (SystemExit, KeyboardInterrupt):

robotcode/language_server/common/parts/diagnostics.py

@@ -19,7 +19,7 @@
 
 __all__ = ["DiagnosticsProtocolPart", "DiagnosticsResult"]
 
-DIAGNOSTICS_DEBOUNCE = 0.75
+DIAGNOSTICS_DEBOUNCE = 1.5
 
 
 class PublishDiagnosticsEntry:
@@ -57,7 +57,9 @@ def _done(t: asyncio.Task[Any]) -> None:
 
                 self._task.add_done_callback(_done)
 
-        self._timer_handle: asyncio.TimerHandle = asyncio.get_event_loop().call_later(DIAGNOSTICS_DEBOUNCE, create_task)
+        self._timer_handle: asyncio.TimerHandle = asyncio.get_running_loop().call_later(
+            DIAGNOSTICS_DEBOUNCE, create_task
+        )
 
     def __del__(self) -> None:
         if self.task is not None:
@@ -155,9 +157,7 @@ async def _cancel_entry(self, entry: Optional[PublishDiagnosticsEntry]) -> None:
         if entry is None:
             return
         if not entry.done:
-            cancel_task = entry.cancel()
-            if cancel_task is not None:
-                await cancel_task
+            entry.cancel()
 
     @language_id("robotframework")
     @_logger.call