Start implementing support for "showDocumentation" code action

Author: d-biehl

robotcode/debugger/protocol.py

@@ -151,7 +151,7 @@ def done(f: asyncio.Future[Any]) -> None:
                 self._logger.exception(ex, exc_info=ex)
 
         for m in iterator:
-            task = asyncio.create_task(self.handle_message(m))
+            task = asyncio.create_task(self.handle_message(m), name="handle_message")
             task.add_done_callback(done)
 
     @_logger.call
@@ -234,11 +234,13 @@ def handle_request(self, message: Request) -> None:
 
         with self._received_request_lock:
             if e is None or not callable(e.method):
-                result = asyncio.create_task(self.handle_unknown_command(message))
+                result = asyncio.create_task(self.handle_unknown_command(message), name="handle_unknown_command")
             else:
                 params = self._convert_params(e.method, e.param_type, message.arguments)
 
-                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=e.method.__name__
+                )
 
             self._received_request[message.seq] = result
 

robotcode/jsonrpc2/protocol.py

@@ -695,6 +695,7 @@ async def handle_request(self, message: JsonRPCRequest) -> None:
                 ensure_coroutine(e.method)(*params[0], **params[1]),
                 name=message.method,
             )
+
         with self._received_request_lock:
             self._received_request[message.id] = ReceivedRequestEntry(task, message, e.cancelable)
 

robotcode/language_server/common/decorators.py

@@ -26,6 +26,11 @@ def decorator(func: _F) -> _F:
     return decorator
 
 
+@runtime_checkable
+class HasTriggerCharacters(Protocol):
+    __trigger_characters__: List[str]
+
+
 @runtime_checkable
 class HasRetriggerCharacters(Protocol):
     __retrigger_characters__: str
@@ -39,11 +44,6 @@ def decorator(func: _F) -> _F:
     return decorator
 
 
-@runtime_checkable
-class HasTriggerCharacters(Protocol):
-    __trigger_characters__: List[str]
-
-
 def all_commit_characters(characters: List[str]) -> Callable[[_F], _F]:
     def decorator(func: _F) -> _F:
         setattr(func, "__all_commit_characters__", characters)
@@ -57,6 +57,19 @@ class HasAllCommitCharacters(Protocol):
     __all_commit_characters__: List[str]
 
 
+def code_action_kinds(characters: List[str]) -> Callable[[_F], _F]:
+    def decorator(func: _F) -> _F:
+        setattr(func, "__code_action_kinds__", characters)
+        return func
+
+    return decorator
+
+
+@runtime_checkable
+class HasCodeActionKinds(Protocol):
+    __code_action_kinds__: List[str]
+
+
 def language_id_filter(language_id_or_document: Union[str, TextDocument]) -> Callable[[Any], bool]:
     def filter(c: Any) -> bool:
         return not isinstance(c, HasLanguageId) or c.__language_id__ == (

robotcode/language_server/common/lsp_types.py

@@ -397,21 +397,19 @@ class DocumentSymbolClientCapabilities(Model):
     label_support: Optional[bool] = None
 
 
-CodeActionKind = str
-
-
-class CodeActionKinds(Enum):
+class CodeActionKinds:
     EMPTY = ""
     QUICKFIX = "quickfix"
     REFACTOR = "refactor"
-    REFACTOREXTRACT = "refactor.extract"
-    REFACTORINLINE = "refactor.inline"
-    REFACTORREWRITE = "refactor.rewrite"
+    REFACTOR_EXTRACT = "refactor.extract"
+    REFACTOR_INLINE = "refactor.inline"
+    REFACTOR_REWRITE = "refactor.rewrite"
     SOURCE = "source"
-    SOURCEORGANIZEIMPORTS = "source.organizeImports"
+    SOURCE_ORGANIZE_IMPORTS = "source.organizeImports"
+    SOURCE_FIX_ALL = "source.fixAll"
 
-    def __repr__(self) -> str:  # pragma: no cover
-        return super().__str__()
+
+CodeActionKind = str
 
 
 @dataclass(repr=False)
@@ -1099,6 +1097,17 @@ class DiagnosticRegistrationOptions(TextDocumentRegistrationOptions, StaticRegis
     pass
 
 
+@dataclass(repr=False)
+class _CodeActionOptions(Model):
+    code_action_kinds: Optional[List[CodeActionKind]] = None
+    resolve_provider: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class CodeActionOptions(WorkDoneProgressOptions, _CodeActionOptions):
+    pass
+
+
 @dataclass(repr=False)
 class ServerCapabilities(Model):
     position_encoding: Optional[PositionEncodingKind] = None
@@ -1112,7 +1121,7 @@ class ServerCapabilities(Model):
     references_provider: Union[bool, ReferenceOptions, None] = None
     document_highlight_provider: Union[bool, DocumentHighlightOptions, None] = None
     document_symbol_provider: Union[bool, DocumentSymbolOptions, None] = None
-    # TODO code_action_provider: Union[bool, CodeActionOptions] = None
+    code_action_provider: Union[bool, CodeActionOptions, None] = None
     code_lens_provider: Optional[CodeLensOptions] = None
     # TODO document_link_provider: Optional[DocumentLinkOptions] = None
     # TODO color_provider: Union[bool, DocumentColorOptions, DocumentColorRegistrationOptions, None] = None
@@ -2318,3 +2327,44 @@ class WorkspaceDiagnosticReportPartialResult(Model):
 @dataclass(repr=False)
 class WorkspaceDiagnosticReport(Model):
     items: List[WorkspaceDocumentDiagnosticReport]
+
+
+@dataclass(repr=False)
+class _CodeActionParams(Model):
+    text_document: TextDocumentIdentifier
+    range: Range
+    context: CodeActionContext
+
+
+@dataclass(repr=False)
+class CodeActionParams(WorkDoneProgressParams, PartialResultParams, _CodeActionParams):
+    pass
+
+
+class CodeActionTriggerKind(IntEnum):
+    INVOKED = 1
+    AUTOMATIC = 2
+
+
+@dataclass(repr=False)
+class CodeActionContext(Model):
+    diagnostics: List[Diagnostic]
+    only: Optional[List[CodeActionKind]] = None
+    trigger_kind: Optional[CodeActionTriggerKind] = None
+
+
+@dataclass(repr=False)
+class CodeActionDisabled:
+    reason: str
+
+
+@dataclass(repr=False)
+class CodeAction:
+    title: str
+    kind: Optional[CodeActionKind] = None
+    diagnostics: Optional[List[Diagnostic]] = None
+    is_preferred: Optional[bool] = None
+    disabled: Optional[CodeActionDisabled] = None
+    edit: Optional[WorkspaceEdit] = None
+    command: Optional[Command] = None
+    data: Any = None

robotcode/language_server/common/parts/code_action.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from asyncio import CancelledError
+from itertools import chain
+from typing import TYPE_CHECKING, Any, List, Optional, Union, cast
+
+from ....jsonrpc2.protocol import rpc_method
+from ....utils.async_tools import async_tasking_event, threaded
+from ....utils.logging import LoggingDescriptor
+from ..decorators import HasCodeActionKinds, language_id_filter
+from ..has_extend_capabilities import HasExtendCapabilities
+from ..lsp_types import (
+    CodeAction,
+    CodeActionContext,
+    CodeActionOptions,
+    CodeActionParams,
+    Command,
+    Range,
+    ServerCapabilities,
+    TextDocumentIdentifier,
+)
+from ..text_document import TextDocument
+
+if TYPE_CHECKING:
+    from ..protocol import LanguageServerProtocol
+
+from .protocol_part import LanguageServerProtocolPart
+
+
+class CodeActionProtocolPart(LanguageServerProtocolPart, HasExtendCapabilities):
+
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: LanguageServerProtocol) -> None:
+        super().__init__(parent)
+
+    @async_tasking_event
+    async def collect(
+        sender, document: TextDocument, range: Range, context: CodeActionContext  # NOSONAR
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+        ...
+
+    @async_tasking_event
+    async def resolve(sender, code_action: CodeAction) -> CodeAction:  # NOSONAR
+        ...
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if len(self.collect):
+            code_action_kinds = [
+                k
+                for k in chain(
+                    *[
+                        cast(HasCodeActionKinds, e).__code_action_kinds__
+                        for e in self.collect
+                        if isinstance(e, HasCodeActionKinds)
+                    ]
+                )
+            ]
+
+            capabilities.code_action_provider = CodeActionOptions(
+                code_action_kinds=code_action_kinds if code_action_kinds else None,
+                resolve_provider=len(self.resolve) > 0,
+            )
+
+    @rpc_method(name="textDocument/codeAction", param_type=CodeActionParams)
+    @threaded()
+    async def _text_document_code_action(
+        self,
+        text_document: TextDocumentIdentifier,
+        range: Range,
+        context: CodeActionContext,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[List[Union[Command, CodeAction]]]:
+
+        results: List[Union[Command, CodeAction]] = []
+
+        document = await self.parent.documents.get(text_document.uri)
+        if document is None:
+            return None
+
+        for result in await self.collect(
+            self,
+            document,
+            range,
+            context,
+            callback_filter=language_id_filter(document),
+        ):
+            if isinstance(result, BaseException):
+                if not isinstance(result, CancelledError):
+                    self._logger.exception(result, exc_info=result)
+            else:
+                if result is not None:
+                    results.extend(result)
+
+        if len(results) > 0:
+            return results
+
+        return None
+
+    @rpc_method(name="textDocument/codeAction/resolve", param_type=CodeAction)
+    @threaded()
+    async def _text_document_code_action_resolve(
+        self,
+        params: CodeAction,
+        *args: Any,
+        **kwargs: Any,
+    ) -> CodeAction:
+
+        results: List[CodeAction] = []
+
+        for result in await self.resolve(self, params):
+            if isinstance(result, BaseException):
+                if not isinstance(result, CancelledError):
+                    self._logger.exception(result, exc_info=result)
+            else:
+                if result is not None:
+                    results.append(result)
+
+        if len(results) > 0:
+            if len(results) > 1:
+                self._logger.warning("More then one resolve result. Use the last one.")
+
+            return results[-1]
+
+        return params