refactor(langserver): remove async code from inline value

Author: d-biehl

packages/core/src/robotcode/core/concurrent.py

@@ -91,19 +91,22 @@ def is_current_thread_cancelled() -> bool:
     return local_future is not None and local_future.cancelation_requested
 
 
-def check_current_thread_canceled(at_least_seconds: Optional[float] = None) -> None:
+def check_current_thread_canceled(at_least_seconds: Optional[float] = None, raise_exception: bool = True) -> bool:
     local_future = _local_storage._local_future
     if local_future is None:
-        return
+        return False
 
     if at_least_seconds is None or at_least_seconds <= 0:
         if not local_future.cancelation_requested:
-            return
+            return False
     elif not local_future.cancelation_requested_event.wait(at_least_seconds):
-        return
+        return False
+
+    if raise_exception:
+        name = current_thread().name
+        raise CancelledError(f"Thread {name+' ' if name else ' '}cancelled")
 
-    name = current_thread().name
-    raise CancelledError(f"Thread {name+' ' if name else ' '}cancelled")
+    return True
 
 
 _running_callables_lock = RLock()

packages/language_server/src/robotcode/language_server/common/parts/inlay_hint.py

@@ -105,4 +105,4 @@ def refresh(self) -> None:
             and self.parent.client_capabilities.workspace.inlay_hint is not None
             and self.parent.client_capabilities.workspace.inlay_hint.refresh_support
         ):
-            self.parent.send_request("workspace/inlayHint/refresh").result()
+            self.parent.send_request("workspace/inlayHint/refresh").result(30)

packages/language_server/src/robotcode/language_server/common/parts/inline_value.py

@@ -1,10 +1,8 @@
-from __future__ import annotations
-
 from asyncio import CancelledError
 from typing import TYPE_CHECKING, Any, Final, List, Optional
 
-from robotcode.core.async_tools import async_tasking_event
-from robotcode.core.concurrent import threaded
+from robotcode.core.concurrent import check_current_thread_canceled, threaded
+from robotcode.core.event import event
 from robotcode.core.lsp.types import (
     DocumentSelector,
     InlineValue,
@@ -18,10 +16,7 @@
 )
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
-from robotcode.language_server.common.decorators import (
-    LANGUAGE_ID_ATTR,
-    language_id_filter,
-)
+from robotcode.language_server.common.decorators import LANGUAGE_ID_ATTR, language_id_filter
 from robotcode.language_server.common.parts.protocol_part import (
     LanguageServerProtocolPart,
 )
@@ -34,11 +29,11 @@
 class InlineValueProtocolPart(LanguageServerProtocolPart):
     _logger: Final = LoggingDescriptor()
 
-    def __init__(self, parent: LanguageServerProtocol) -> None:
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
         super().__init__(parent)
 
-    @async_tasking_event
-    async def collect(
+    @event
+    def collect(
         sender,
         document: TextDocument,
         range: Range,
@@ -60,7 +55,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
 
     @rpc_method(name="textDocument/inlineValue", param_type=InlineValueParams)
     @threaded
-    async def _text_document_inline_value(
+    def _text_document_inline_value(
         self,
         text_document: TextDocumentIdentifier,
         range: Range,
@@ -73,9 +68,11 @@ async def _text_document_inline_value(
         if document is None:
             return None
 
-        for result in await self.collect(
+        for result in self.collect(
             self, document, document.range_from_utf16(range), context, callback_filter=language_id_filter(document)
         ):
+            check_current_thread_canceled()
+
             if isinstance(result, BaseException):
                 if not isinstance(result, CancelledError):
                     self._logger.exception(result, exc_info=result)
@@ -86,16 +83,16 @@ async def _text_document_inline_value(
         if not results:
             return None
 
-        for result in results:
-            result.range = document.range_to_utf16(result.range)
+        for r in results:
+            r.range = document.range_to_utf16(r.range)
 
         return results
 
-    async def refresh(self) -> None:
+    def refresh(self) -> None:
         if (
             self.parent.client_capabilities
             and self.parent.client_capabilities.workspace
             and self.parent.client_capabilities.workspace.inline_value
             and self.parent.client_capabilities.workspace.inline_value.refresh_support
         ):
-            await self.parent.send_request_async("workspace/inlineValue/refresh")
+            self.parent.send_request("workspace/inlineValue/refresh").result(30)

packages/language_server/src/robotcode/language_server/robotframework/parts/inline_value.py

@@ -1,11 +1,9 @@
-from __future__ import annotations
-
 import ast
+from itertools import dropwhile, takewhile
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
 
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.statements import Statement
-from robotcode.core.async_itertools import async_dropwhile, async_takewhile
 from robotcode.core.lsp.types import InlineValue, InlineValueContext, InlineValueEvaluatableExpression, Range
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.robot.utils.ast import get_nodes_at_position, iter_nodes, range_from_node, range_from_token
@@ -16,22 +14,20 @@
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
-    from robotcode.language_server.robotframework.protocol import (
-        RobotLanguageServerProtocol,
-    )
+    from robotcode.language_server.robotframework.protocol import RobotLanguageServerProtocol
 
 
 class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
     _logger = LoggingDescriptor()
 
-    def __init__(self, parent: RobotLanguageServerProtocol) -> None:
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
         super().__init__(parent)
 
         parent.inline_value.collect.add(self.collect)
 
     @language_id("robotframework")
     @_logger.call
-    async def collect(
+    def collect(
         self,
         sender: Any,
         document: TextDocument,
@@ -60,9 +56,9 @@ def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
                     break
 
         result: List[InlineValue] = []
-        async for token, node in async_takewhile(
+        for token, node in takewhile(
             lambda t: range_from_token(t[0]).end.line <= real_range.end.line,
-            async_dropwhile(
+            dropwhile(
                 lambda t: range_from_token(t[0]).start < real_range.start,
                 get_tokens(),
             ),