add some LSP 3.17 declarations, move InlineValueProvider completely to the language server

Author: d-biehl

robotcode/jsonrpc2/protocol.py

@@ -456,7 +456,11 @@ def inner(d: Dict[Any, Any]) -> JsonRPCMessage:
 
     def _handle_body(self, body: bytes, charset: str) -> None:
         try:
-            self._handle_messages(self._generate_json_rpc_messages_from_dict(json.loads(body.decode(charset))))
+            b = body.decode(charset)
+
+            self._data_logger.trace(lambda: f"JSON Received: {b}")
+
+            self._handle_messages(self._generate_json_rpc_messages_from_dict(json.loads(b)))
         except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
             raise
         except BaseException as e:
@@ -519,7 +523,7 @@ def send_message(self, message: JsonRPCMessage) -> None:
         if self.write_transport is not None:
             msg = header + body
 
-            self._data_logger.trace(lambda: f"JSON Message: {msg.decode()}")
+            self._data_logger.trace(lambda: f"JSON send: {msg.decode()}")
 
             if self._loop:
                 self._loop.call_soon_threadsafe(self.write_transport.write, msg)

robotcode/language_server/common/lsp_types.py

@@ -13,6 +13,30 @@
 ProgressToken = Union[str, int]
 
 
+class ErrorCodes:
+    PARSE_ERROR = -32700
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INVALID_PARAMS = -32602
+    INTERNAL_ERROR = -32603
+    SERVER_ERROR_START = -32000
+    SERVER_ERROR_END = -32099
+
+    JSON_RPC_RESERVED_ERROR_RANGE_START = -32099
+
+    SERVER_NOT_INITIALIZED = -32002
+    UNKNOWN_ERROR = -32001
+
+    JSON_RPC_RESERVED_ERROR_RANGE_END = -32000
+
+    LSP_RESERVED_ERROR_RANGE_START = -32899
+    REQUEST_FAILED = -32803
+    SERVER_CANCELLED = -32802
+    CONTENT_MODIFIED = -32801
+    REQUEST_CANCELLED = -32800
+    LSP_RESERVED_ERROR_RANGE_END = -32800
+
+
 @dataclass(repr=False)
 class Model:
     @classmethod
@@ -485,11 +509,32 @@ class PublishDiagnosticsClientCapabilities(Model):
     data_support: Optional[bool] = None
 
 
+class FoldingRangeKind(Enum):
+    COMMENT = "comment"
+    IMPORTS = "imports"
+    REGION = "region"
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return super().__str__()
+
+
+@dataclass(repr=False)
+class FoldingRangeClientCapabilitiesFoldingRangeKind(Model):
+    value_set: Optional[List[FoldingRangeKind]]
+
+
+@dataclass(repr=False)
+class FoldingRangeClientCapabilitiesFoldingRange(Model):
+    collapsed_text: Optional[bool] = None
+
+
 @dataclass(repr=False)
 class FoldingRangeClientCapabilities(Model):
     dynamic_registration: Optional[bool] = None
     range_limit: Optional[int] = None
     line_folding_only: Optional[bool] = None
+    folding_range_kind: Optional[FoldingRangeClientCapabilitiesFoldingRangeKind] = None
+    folding_range: Optional[FoldingRangeClientCapabilitiesFoldingRange] = None
 
 
 @dataclass(repr=False)
@@ -533,6 +578,8 @@ class SemanticTokensClientCapabilities(Model):
     formats: List[TokenFormat]
     overlapping_token_support: Optional[bool] = None
     multiline_token_support: Optional[bool] = None
+    server_cancel_support: Optional[bool] = None
+    augments_syntax_tokens: Optional[bool] = None
     dynamic_registration: Optional[bool] = None
 
 
@@ -541,6 +588,22 @@ class MonikerClientCapabilities(Model):
     dynamic_registration: Optional[bool] = None
 
 
+@dataclass(repr=False)
+class InlayHintClientCapabilitiesResolveSupport(Model):
+    properties: List[str]
+
+
+@dataclass(repr=False)
+class InlayHintClientCapabilities(Model):
+    dynamic_registration: Optional[bool] = None
+    resolve_support: Optional[InlayHintClientCapabilitiesResolveSupport] = None
+
+
+@dataclass(repr=False)
+class InlineValueClientCapabilities(Model):
+    dynamic_registration: Optional[bool] = None
+
+
 @dataclass(repr=False)
 class TextDocumentClientCapabilities(Model):
     synchronization: Optional[TextDocumentSyncClientCapabilities] = None
@@ -569,6 +632,10 @@ class TextDocumentClientCapabilities(Model):
     call_hierarchy: Optional[CallHierarchyClientCapabilities] = None
     semantic_tokens: Optional[SemanticTokensClientCapabilities] = None
     moniker: Optional[MonikerClientCapabilities] = None
+    # TODO typeHierarchy?: TypeHierarchyClientCapabilities;
+    inline_value: Optional[InlineValueClientCapabilities] = None
+    inlay_hint: Optional[InlayHintClientCapabilities] = None
+    # TODO diagnostic?: DiagnosticClientCapabilities;
 
 
 @dataclass(repr=False)
@@ -596,6 +663,7 @@ class RegularExpressionsClientCapabilities(Model):
 class MarkdownClientCapabilities(Model):
     parser: str
     version: Optional[str] = None
+    allowed_tags: Optional[List[str]] = None
 
 
 @dataclass(repr=False)
@@ -609,6 +677,11 @@ class ClientCapabilitiesWorkspaceFileOperationsWorkspaceClientCapabilities(Model
     will_delete: Optional[bool] = None
 
 
+@dataclass(repr=False)
+class InlineValueWorkspaceClientCapabilities(Model):
+    refresh_support: Optional[bool] = None
+
+
 @dataclass(repr=False)
 class ClientCapabilitiesWorkspace(Model):
     apply_edit: Optional[bool] = None
@@ -622,6 +695,7 @@ class ClientCapabilitiesWorkspace(Model):
     semantic_tokens: Optional[SemanticTokensWorkspaceClientCapabilities] = None
     code_lens: Optional[CodeLensWorkspaceClientCapabilities] = None
     file_operations: Optional[ClientCapabilitiesWorkspaceFileOperationsWorkspaceClientCapabilities] = None
+    inline_value: Optional[InlineValueWorkspaceClientCapabilities] = None
 
 
 @dataclass(repr=False)
@@ -972,6 +1046,16 @@ class RenameRegistrationOptions(TextDocumentRegistrationOptions, RenameOptions,
     pass
 
 
+@dataclass(repr=False)
+class InlineValueOptions(WorkDoneProgressOptions):
+    pass
+
+
+@dataclass(repr=False)
+class InlineValueRegistrationOptions(InlineValueOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions):
+    pass
+
+
 @dataclass(repr=False)
 class ServerCapabilities(Model):
     text_document_sync: Union[TextDocumentSyncOptions, TextDocumentSyncKind, None] = None
@@ -1001,6 +1085,9 @@ class ServerCapabilities(Model):
     # TODO call_hierarchy_provider: Union[boolean, CallHierarchyOptions, CallHierarchyRegistrationOptions, None] = None
     semantic_tokens_provider: Union[SemanticTokensOptions, SemanticTokensRegistrationOptions, None] = None
     # TODO moniker_provider: Union[bool, MonikerOptions, MonikerRegistrationOptions, None] = None
+
+    # TODO typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions;
+    inline_value_provider: Union[bool, InlineValueOptions, InlineValueRegistrationOptions, None] = None
     workspace_symbol_provider: Union[bool, WorkspaceSymbolOptions, None] = None
     workspace: Optional[ServerCapabilitiesWorkspace] = None
     experimental: Optional[Any] = None
@@ -1333,22 +1420,14 @@ class FoldingRangeParams(WorkDoneProgressParams, _FoldingRangeParams):
     pass
 
 
-class FoldingRangeKind(Enum):
-    Comment = "comment"
-    Imports = "imports"
-    Region = "region"
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return super().__str__()
-
-
 @dataclass(repr=False)
 class FoldingRange(Model):
     start_line: int
     end_line: int
     start_character: Optional[int] = None
     end_character: Optional[int] = None
     kind: Union[FoldingRangeKind, str, None] = None
+    collapsed_text: Optional[str] = None
 
 
 @dataclass(repr=False)
@@ -2014,3 +2093,44 @@ class PrepareRenameResultWithDefaultBehavior(Model):
 
 
 PrepareRenameResult = Union[Range, PrepareRenameResultWithPlaceHolder, PrepareRenameResultWithDefaultBehavior]
+
+
+@dataclass(repr=False)
+class InlineValueContext(Model):
+    # TODO: this differs from definition in the LSP 3.17 spec
+    stopped_location: Union[Range, List[Position]]
+    frame_id: Optional[int] = None
+
+
+@dataclass(repr=False)
+class _InlineValueParams(Model):
+    text_document: TextDocumentIdentifier
+    range: Range
+    context: InlineValueContext
+
+
+@dataclass(repr=False)
+class InlineValueParams(WorkDoneProgressParams, _InlineValueParams):
+    pass
+
+
+@dataclass(repr=False)
+class InlineValueText(Model):
+    range: Range
+    text: str
+
+
+@dataclass(repr=False)
+class InlineValueVariableLookup(Model):
+    range: Range
+    variable_name: Optional[str]
+    case_sensitive_lookup: bool
+
+
+@dataclass(repr=False)
+class InlineValueEvaluatableExpression(Model):
+    range: Range
+    expression: Optional[str]
+
+
+InlineValue = Union[InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression]

robotcode/language_server/common/parts/inline_value.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from asyncio import CancelledError
+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.logging import LoggingDescriptor
+from ..decorators import HasLanguageId, language_id_filter
+from ..has_extend_capabilities import HasExtendCapabilities
+from ..lsp_types import (
+    DocumentFilter,
+    DocumentSelector,
+    InlineValue,
+    InlineValueContext,
+    InlineValueParams,
+    InlineValueRegistrationOptions,
+    Position,
+    Range,
+    ServerCapabilities,
+    TextDocumentIdentifier,
+)
+from ..text_document import TextDocument
+
+if TYPE_CHECKING:
+    from ..protocol import LanguageServerProtocol  # pragma: no cover
+
+from .protocol_part import LanguageServerProtocolPart
+
+
+class InlineValueProtocolPart(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: InlineValueContext  # pragma: no cover, NOSONAR
+    ) -> Optional[List[InlineValue]]:
+        ...
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if len(self.collect):
+            document_filters: DocumentSelector = []
+            for e in self.collect:
+                if isinstance(e, HasLanguageId):
+                    document_filters.append(DocumentFilter(language=e.__language_id__))
+            capabilities.inline_value_provider = InlineValueRegistrationOptions(
+                work_done_progress=True, document_selector=document_filters if document_filters else None
+            )
+
+    @rpc_method(name="textDocument/inlineValue", param_type=InlineValueParams)
+    async def _text_document_inline_value(
+        self,
+        text_document: TextDocumentIdentifier,
+        range: Union[Range, List[Position]],
+        context: InlineValueContext,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[List[InlineValue]]:
+
+        results: List[InlineValue] = []
+        document = await self.parent.documents.get(text_document.uri)
+        if document is None:
+            return None
+
+        if isinstance(context.stopped_location, list):  # TODO this is a hack, fix it
+            context.stopped_location = Range(*context.stopped_location)
+
+        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 += result
+
+        if len(results) == 0:
+            return None
+
+        return results
+
+    async 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")

robotcode/language_server/common/protocol.py

@@ -49,6 +49,7 @@
 from .parts.formatting import FormattingProtocolPart
 from .parts.hover import HoverProtocolPart
 from .parts.implementation import ImplementationProtocolPart
+from .parts.inline_value import InlineValueProtocolPart
 from .parts.linked_editing_ranges import LinkedEditingRangeProtocolPart
 from .parts.references import ReferencesProtocolPart
 from .parts.rename import RenameProtocolPart
@@ -88,6 +89,7 @@ class LanguageServerProtocol(JsonRPCProtocol):
     linked_editing_range = ProtocolPartDescriptor(LinkedEditingRangeProtocolPart)
     selection_range = ProtocolPartDescriptor(SelectionRangeProtocolPart)
     rename = ProtocolPartDescriptor(RenameProtocolPart)
+    inline_value = ProtocolPartDescriptor(InlineValueProtocolPart)
 
     name: Optional[str] = None
     short_name: Optional[str] = None