refactor(langserver): remove async code from formatting and some import corrections

Author: d-biehl

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

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from asyncio import CancelledError
 from typing import TYPE_CHECKING, Any, Final, List, Optional, Union
 
@@ -26,7 +24,7 @@
 class DeclarationProtocolPart(LanguageServerProtocolPart):
     _logger: Final = LoggingDescriptor()
 
-    def __init__(self, parent: LanguageServerProtocol) -> None:
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
         super().__init__(parent)
         self.link_support = False
 

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

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from concurrent.futures import CancelledError
 from typing import TYPE_CHECKING, Any, Final, List, Optional, Union
 
@@ -26,7 +24,7 @@
 class DefinitionProtocolPart(LanguageServerProtocolPart):
     _logger: Final = LoggingDescriptor()
 
-    def __init__(self, parent: LanguageServerProtocol) -> None:
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
         super().__init__(parent)
         self.link_support = False
 

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

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import os
 import re
 import threading
@@ -148,7 +147,7 @@ def get_or_open_document(
                 text=self.read_document_text(uri, language_id),
                 version=version,
             )
-        except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
+        except (SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
             raise CantReadDocumentError(f"Error reading document '{path}': {e!s}") from e

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

@@ -1,10 +1,8 @@
-from __future__ import annotations
-
-from asyncio import CancelledError
+from concurrent.futures 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 (
     DocumentFormattingOptions,
     DocumentFormattingParams,
@@ -32,20 +30,20 @@
 class FormattingProtocolPart(LanguageServerProtocolPart):
     _logger: Final = LoggingDescriptor()
 
-    def __init__(self, parent: LanguageServerProtocol) -> None:
+    def __init__(self, parent: "LanguageServerProtocol") -> None:
         super().__init__(parent)
 
-    @async_tasking_event
-    async def format(
+    @event
+    def format(
         sender,
         document: TextDocument,
         options: FormattingOptions,
         **further_options: Any,  # NOSONAR
     ) -> Optional[List[TextEdit]]:
         ...
 
-    @async_tasking_event
-    async def format_range(
+    @event
+    def format_range(
         sender,
         document: TextDocument,
         range: Range,
@@ -62,7 +60,7 @@ def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
 
     @rpc_method(name="textDocument/formatting", param_type=DocumentFormattingParams)
     @threaded
-    async def _text_document_formatting(
+    def _text_document_formatting(
         self,
         params: DocumentFormattingParams,
         text_document: TextDocumentIdentifier,
@@ -77,13 +75,15 @@ async def _text_document_formatting(
         if document is None:
             return None
 
-        for result in await self.format(
+        for result in self.format(
             self,
             document,
             options,
             callback_filter=language_id_filter(document),
             **kwargs,
         ):
+            check_current_thread_canceled()
+
             if isinstance(result, BaseException):
                 if not isinstance(result, CancelledError):
                     self._logger.exception(result, exc_info=result)
@@ -98,7 +98,7 @@ async def _text_document_formatting(
 
     @rpc_method(name="textDocument/rangeFormatting", param_type=DocumentRangeFormattingParams)
     @threaded
-    async def _text_document_range_formatting(
+    def _text_document_range_formatting(
         self,
         params: DocumentFormattingParams,
         text_document: TextDocumentIdentifier,
@@ -113,14 +113,16 @@ async def _text_document_range_formatting(
         if document is None:
             return None
 
-        for result in await self.format_range(
+        for result in self.format_range(
             self,
             document,
             range,
             options,
             callback_filter=language_id_filter(document),
             **kwargs,
         ):
+            check_current_thread_canceled()
+
             if isinstance(result, BaseException):
                 if not isinstance(result, CancelledError):
                     self._logger.exception(result, exc_info=result)

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

@@ -1,9 +1,7 @@
-from __future__ import annotations
-
-import asyncio
 import io
 import os
 import re
+from concurrent.futures import CancelledError
 from typing import TYPE_CHECKING, Any, List, Optional, cast
 
 from robotcode.core.lsp.types import (
@@ -24,9 +22,7 @@
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
-    from robotcode.language_server.robotframework.protocol import (
-        RobotLanguageServerProtocol,
-    )
+    from robotcode.language_server.robotframework.protocol import RobotLanguageServerProtocol
 
 
 def robotidy_installed() -> bool:
@@ -40,7 +36,7 @@ def robotidy_installed() -> bool:
 class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelperMixin):
     _logger = LoggingDescriptor()
 
-    def __init__(self, parent: RobotLanguageServerProtocol) -> None:
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
         super().__init__(parent)
 
         parent.formatting.format.add(self.format)
@@ -54,29 +50,29 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self.short_test_name_length = 18
         self.setting_and_variable_name_length = 14
 
-    async def get_config(self, document: TextDocument) -> RoboTidyConfig:
+    def get_config(self, document: TextDocument) -> RoboTidyConfig:
         folder = self.parent.workspace.get_workspace_folder(document.uri)
         if folder is None:
             return RoboTidyConfig()
 
-        return await self.parent.workspace.get_configuration_async(RoboTidyConfig, folder.uri)
+        return self.parent.workspace.get_configuration(RoboTidyConfig, folder.uri)
 
     @language_id("robotframework")
     @_logger.call
-    async def format(
+    def format(
         self,
         sender: Any,
         document: TextDocument,
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = await self.get_config(document)
+        config = self.get_config(document)
 
         if (config.enabled or get_robot_version() >= (5, 0)) and robotidy_installed():
-            return await self.format_robot_tidy(document, options, config=config, **further_options)
+            return self.format_robot_tidy(document, options, config=config, **further_options)
 
         if get_robot_version() < (5, 0):
-            return await self.format_internal(document, options, **further_options)
+            return self.format_internal(document, options, **further_options)
 
         self.parent.window.show_message(
             "RobotFramework formatter is not available, please install 'robotframework-tidy'.",
@@ -87,7 +83,7 @@ async def format(
 
     RE_LINEBREAKS = re.compile(r"\r\n|\r|\n")
 
-    async def format_robot_tidy(
+    def format_robot_tidy(
         self,
         document: TextDocument,
         options: FormattingOptions,
@@ -99,7 +95,7 @@ async def format_robot_tidy(
 
         try:
             if config is None:
-                config = await self.get_config(document)
+                config = self.get_config(document)
 
             robotidy_version = create_version_from_str(__version__)
 
@@ -181,14 +177,14 @@ async def format_robot_tidy(
                 )
             ]
 
-        except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
+        except (SystemExit, KeyboardInterrupt, CancelledError):
             raise
         except BaseException as e:
             self._logger.exception(e)
             self.parent.window.show_message(f"Executing `robotidy` failed: {e}", MessageType.ERROR)
         return None
 
-    async def format_internal(
+    def format_internal(
         self, document: TextDocument, options: FormattingOptions, **further_options: Any
     ) -> Optional[List[TextEdit]]:
         from robot.parsing.model.blocks import File
@@ -227,16 +223,16 @@ async def format_internal(
             ]
 
     @language_id("robotframework")
-    async def format_range(
+    def format_range(
         self,
         sender: Any,
         document: TextDocument,
         range: Range,
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = await self.get_config(document)
+        config = self.get_config(document)
         if config.enabled and robotidy_installed():
-            return await self.format_robot_tidy(document, options, range=range, config=config, **further_options)
+            return self.format_robot_tidy(document, options, range=range, config=config, **further_options)
 
         return None