RPC methods can now be called threaded

Author: d-biehl

robotcode/language_server/common/parts/code_lens.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -43,6 +43,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             capabilities.code_lens_provider = CodeLensOptions(resolve_provider=True if len(self.resolve) > 0 else None)
 
     @rpc_method(name="textDocument/codeLens", param_type=CodeLensParams)
+    @threaded()
     async def _text_document_code_lens(
         self, text_document: TextDocumentIdentifier, *args: Any, **kwargs: Any
     ) -> Optional[List[CodeLens]]:
@@ -66,6 +67,7 @@ async def _text_document_code_lens(
         return None
 
     @rpc_method(name="codeLens/resolve", param_type=CodeLens)
+    @threaded()
     async def _code_lens_resolve(self, params: CodeLens, *args: Any, **kwargs: Any) -> CodeLens:
 
         results: List[CodeLens] = []

robotcode/language_server/common/parts/completion.py

@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import (
     HasAllCommitCharacters,
@@ -79,6 +79,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             )
 
     @rpc_method(name="textDocument/completion", param_type=CompletionParams)
+    @threaded()
     async def _text_document_completion(
         self,
         text_document: TextDocumentIdentifier,

robotcode/language_server/common/parts/declaration.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -50,6 +50,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             capabilities.declaration_provider = True
 
     @rpc_method(name="textDocument/declaration", param_type=DeclarationParams)
+    @threaded()
     async def _text_document_declaration(
         self, text_document: TextDocumentIdentifier, position: Position, *args: Any, **kwargs: Any
     ) -> Optional[Union[Location, List[Location], List[LocationLink]]]:

robotcode/language_server/common/parts/definition.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -50,6 +50,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             capabilities.definition_provider = True
 
     @rpc_method(name="textDocument/definition", param_type=DefinitionParams)
+    @threaded()
     async def _text_document_definition(
         self, text_document: TextDocumentIdentifier, position: Position, *args: Any, **kwargs: Any
     ) -> Optional[Union[Location, List[Location], List[LocationLink]]]:

robotcode/language_server/common/parts/diagnostics.py

@@ -90,7 +90,7 @@ def __init__(self, protocol: LanguageServerProtocol) -> None:
         ] = {}
 
         self._current_workspace_task: Optional[asyncio.Task[WorkspaceDiagnosticReport]] = None
-        self.in_get_document_diagnostics = Event(True)
+
         self.in_get_workspace_diagnostics = Event(True)
         self._collect_full_diagnostics = False
 
@@ -159,9 +159,9 @@ async def ensure_workspace_loaded(self) -> None:
                         await self.on_workspace_loaded(self)
 
     async def get_document_diagnostics(self, document: TextDocument) -> RelatedFullDocumentDiagnosticReport:
-        if self.collect_full_diagnostics:
-            return await document.get_cache(self.__get_full_document_diagnostics)
-        return await document.get_cache(self.__get_document_diagnostics)
+        # if self.collect_full_diagnostics:
+        return await document.get_cache(self.__get_full_document_diagnostics)
+        # return await document.get_cache(self.__get_document_diagnostics)
 
     async def __get_document_diagnostics(self, document: TextDocument) -> RelatedFullDocumentDiagnosticReport:
         await self.ensure_workspace_loaded()
@@ -215,39 +215,34 @@ async def _text_document_diagnostic(
     ) -> DocumentDiagnosticReport:
         self._logger.debug(lambda: f"textDocument/diagnostic for {text_document}")
 
-        self.in_get_document_diagnostics.clear()
-
         try:
-            await self.ensure_workspace_loaded()
+            # await self.ensure_workspace_loaded()
 
             document = await self.parent.documents.get(text_document.uri)
             if document is None:
                 raise JsonRPCErrorException(ErrorCodes.INVALID_PARAMS, f"Document {text_document!r} not found")
 
-            async def _get_diagnostics() -> Optional[RelatedFullDocumentDiagnosticReport]:
+            async def _get_diagnostics(doc: TextDocument) -> Optional[RelatedFullDocumentDiagnosticReport]:
                 if document is not None:
-                    return await self.get_document_diagnostics(document)
+                    return await self.get_document_diagnostics(doc)
 
                 return None
 
             if document in self._current_document_tasks and not self._current_document_tasks[document].done():
                 self._logger.debug(lambda: f"textDocument/diagnostic cancel old task {text_document}")
                 self._current_document_tasks[document].cancel()
 
-            task = create_sub_task(_get_diagnostics())
+            task = create_sub_task(_get_diagnostics(document))
             self._current_document_tasks[document] = task
 
             try:
                 result = await task
                 if result is None:
                     raise RuntimeError("Unexpected result.")
 
-            except asyncio.CancelledError as e:
+            except asyncio.CancelledError:
                 self._logger.debug(lambda: f"textDocument/diagnostic canceled {text_document}")
-
-                raise JsonRPCErrorException(
-                    ErrorCodes.SERVER_CANCELLED, "Cancelled", data=DiagnosticServerCancellationData(True)
-                ) from e
+                raise
             finally:
                 if document in self._current_document_tasks and self._current_document_tasks[document] == task:
                     del self._current_document_tasks[document]
@@ -257,7 +252,7 @@ async def _get_diagnostics() -> Optional[RelatedFullDocumentDiagnosticReport]:
 
             return result
         finally:
-            self.in_get_document_diagnostics.set()
+
             await self.on_document_diagnostics_ended(self)
 
             self._logger.debug(lambda: f"textDocument/diagnostic ready  {text_document}")
@@ -279,6 +274,13 @@ async def _get_diagnostics() -> WorkspaceDiagnosticReport:
             result: List[WorkspaceDocumentDiagnosticReport] = []
 
             for doc in self.parent.documents.documents:
+                if self._current_workspace_task is None:
+                    raise JsonRPCErrorException(
+                        ErrorCodes.SERVER_CANCELLED,
+                        "ServerCancelled",
+                        data=DiagnosticServerCancellationData(True),
+                    )
+
                 doc_result = await self.get_document_diagnostics(doc)
 
                 if doc_result.result_id is not None and any(
@@ -305,7 +307,6 @@ async def _get_partial_diagnostics() -> WorkspaceDiagnosticReport:
             ) as progress:
 
                 async def _task(doc: TextDocument) -> None:
-
                     if await self.get_analysis_progress_mode(doc.uri) == AnalysisProgressMode.DETAILED:
                         path = doc.uri.to_path()
                         folder = self.parent.workspace.get_workspace_folder(doc.uri)
@@ -346,7 +347,14 @@ async def _task(doc: TextDocument) -> None:
                         )
 
                 for doc in self.parent.documents.documents:
-                    await _task(doc)
+                    if await self.get_diagnostics_mode(doc.uri) == DiagnosticsMode.WORKSPACE:
+                        await _task(doc)
+                        if self._current_workspace_task is None:
+                            raise JsonRPCErrorException(
+                                ErrorCodes.SERVER_CANCELLED,
+                                "ServerCancelled",
+                                data=DiagnosticServerCancellationData(True),
+                            )
 
                 return WorkspaceDiagnosticReport(items=[])
 
@@ -363,11 +371,9 @@ async def _task(doc: TextDocument) -> None:
                 result = await task
                 await self.set_collect_full_diagnostics(True)
                 return result
-            except asyncio.CancelledError as e:
+            except asyncio.CancelledError:
                 self._logger.debug("workspace/diagnostic canceled")
-                raise JsonRPCErrorException(
-                    ErrorCodes.SERVER_CANCELLED, "ServerCancelled", data=DiagnosticServerCancellationData(True)
-                ) from e
+                raise
             finally:
                 if self._current_workspace_task == task:
                     self._current_workspace_task = None
@@ -376,15 +382,17 @@ async def _task(doc: TextDocument) -> None:
             self.in_get_workspace_diagnostics.set()
             await self.on_workspace_diagnostics_ended(self)
 
-    def cancel_workspace_diagnostics(self) -> None:
+    async def cancel_workspace_diagnostics(self) -> None:
         if self._current_workspace_task is not None and not self._current_workspace_task.done():
-            self._current_workspace_task.cancel()
+            task = self._current_workspace_task
+            self._current_workspace_task = None
+            task.get_loop().call_soon_threadsafe(task.cancel)
 
-    def cancel_document_diagnostics(self, document: TextDocument) -> None:
+    async def cancel_document_diagnostics(self, document: TextDocument) -> None:
         task = self._current_document_tasks.get(document, None)
         if task is not None:
             self._logger.critical(lambda: f"textDocument/diagnostic canceled {document}")
-            task.cancel()
+            task.get_loop().call_soon_threadsafe(task.cancel)
 
     async def get_analysis_progress_mode(self, uri: Uri) -> AnalysisProgressMode:
         for e in await self.on_get_analysis_progress_mode(self, uri):

robotcode/language_server/common/parts/document_highlight.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -42,6 +42,7 @@ async def collect(
         ...
 
     @rpc_method(name="textDocument/documentHighlight", param_type=DocumentHighlightParams)
+    @threaded()
     async def _text_document_document_highlight(
         self,
         text_document: TextDocumentIdentifier,

robotcode/language_server/common/parts/document_symbols.py

@@ -15,7 +15,7 @@
 )
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -98,6 +98,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
                     capabilities.document_symbol_provider = True
 
     @rpc_method(name="textDocument/documentSymbol", param_type=DocumentSymbolParams)
+    @threaded()
     async def _text_document_symbol(
         self, text_document: TextDocumentIdentifier, *args: Any, **kwargs: Any
     ) -> Optional[Union[List[DocumentSymbol], List[SymbolInformation], None]]:

robotcode/language_server/common/parts/documents.py

@@ -354,7 +354,7 @@ async def _text_document_did_change(
         *args: Any,
         **kwargs: Any,
     ) -> None:
-        document = await self.get(str(Uri(text_document.uri).normalized()))
+        document = self.get_sync(str(Uri(text_document.uri).normalized()))
         if document is None:
             raise LanguageServerDocumentException(f"Document {text_document.uri} is not opened.")
 

robotcode/language_server/common/parts/folding_range.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -38,6 +38,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
             capabilities.folding_range_provider = True
 
     @rpc_method(name="textDocument/foldingRange", param_type=FoldingRangeParams)
+    @threaded()
     async def _text_document_folding_range(
         self, text_document: TextDocumentIdentifier, *args: Any, **kwargs: Any
     ) -> Optional[List[FoldingRange]]:

robotcode/language_server/common/parts/formatting.py

@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from ....jsonrpc2.protocol import rpc_method
-from ....utils.async_tools import async_tasking_event
+from ....utils.async_tools import async_tasking_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ..decorators import language_id_filter
 from ..has_extend_capabilities import HasExtendCapabilities
@@ -90,6 +90,7 @@ async def _text_document_formatting(
         return None
 
     @rpc_method(name="textDocument/rangeFormatting", param_type=DocumentRangeFormattingParams)
+    @threaded()
     async def _text_document_range_formatting(
         self,
         params: DocumentFormattingParams,