implement inlay hints for parameters and namespaces

Author: d-biehl

CHANGELOG.md

@@ -75,7 +75,8 @@
     "configurationDefaults": {
       "[robotframework]": {
         "editor.wordBasedSuggestions": false,
-        "editor.semanticHighlighting.enabled": true
+        "editor.semanticHighlighting.enabled": true,
+        "editor.inlayHints.enabled": "offUnlessPressed"
       }
     },
     "semanticTokenModifiers": [
@@ -559,6 +560,18 @@
             "default": null,
             "markdownDescription": "Defines the header style format. If not defined ```*** {name} ***``` is used.",
             "scope": "resource"
+          },
+          "robotcode.inlayHints.parameterNames": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Enable/disable inlay hints for parameter names.",
+            "scope": "resource"
+          },
+          "robotcode.inlayHints.namespaces": {
+            "type": "boolean",
+            "default": true,
+            "markdownDescription": "Enable/disable inlay hints for namespaces.",
+            "scope": "resource"
           }
         }
       }

package.json

@@ -39,6 +39,7 @@ classifiers = [
   "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: Implementation",
   "Topic :: Software Development :: Testing",
   "Topic :: Software Development :: Testing :: Acceptance",

pyproject.toml

@@ -204,14 +204,14 @@ def __repr__(self) -> str:  # pragma: no cover
 
 
 class CompletionItemTag(IntEnum):
-    Deprecated = 1
+    DEPRECATED = 1
 
     def __repr__(self) -> str:  # pragma: no cover
         return super().__str__()
 
 
 class SymbolTag(IntEnum):
-    Deprecated = 1
+    DEPRECATED = 1
 
     def __repr__(self) -> str:  # pragma: no cover
         return super().__str__()
@@ -1127,6 +1127,21 @@ class CodeActionOptions(WorkDoneProgressOptions, _CodeActionOptions):
     pass
 
 
+@dataclass(repr=False)
+class _InlayHintOptions(Model):
+    resolve_provider: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class InlayHintOptions(WorkDoneProgressOptions, _InlayHintOptions):
+    pass
+
+
+@dataclass(repr=False)
+class InlayHintRegistrationOptions(InlayHintOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions):
+    pass
+
+
 @dataclass(repr=False)
 class ServerCapabilities(Model):
     position_encoding: Optional[PositionEncodingKind] = None
@@ -1160,7 +1175,7 @@ class ServerCapabilities(Model):
 
     # TODO typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions;
     inline_value_provider: Union[bool, InlineValueOptions, InlineValueRegistrationOptions, None] = None
-    # TODO inlayHintProvider?: boolean | InlayHintOptions | InlayHintRegistrationOptions;
+    inlay_hint_provider: Union[bool, InlayHintOptions, InlayHintRegistrationOptions, None] = None
     diagnostic_provider: Union[DiagnosticOptions, DiagnosticRegistrationOptions, None] = None
 
     workspace_symbol_provider: Union[bool, WorkspaceSymbolOptions, None] = None
@@ -2400,3 +2415,42 @@ class ApplyWorkspaceEditResult(Model):
     applied: bool
     failure_reason: Optional[str] = None
     failed_change: Optional[int] = None
+
+
+@dataclass(repr=False)
+class _InlayHintParams(Model):
+    text_document: TextDocumentIdentifier
+    range: Range
+
+
+@dataclass(repr=False)
+class InlayHintParams(WorkDoneProgressParams, _InlayHintParams):
+    pass
+
+
+@dataclass(repr=False)
+class InlayHintLabelPart(Model):
+    value: str
+    tooltip: Union[str, MarkupContent]
+    location: Optional[Location] = None
+    command: Optional[Command] = None
+
+
+class InlayHintKind(IntEnum):
+    TYPE = 1
+    PARAMETER = 2
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return super().__str__()
+
+
+@dataclass(repr=False)
+class InlayHint(Model):
+    position: Position
+    label: Union[str, List[InlayHintLabelPart]]
+    kind: Optional[InlayHintKind] = None
+    text_edits: Optional[List[TextEdit]] = None
+    tooltip: Union[str, MarkupContent, None] = None
+    padding_left: Optional[bool] = None
+    padding_right: Optional[bool] = None
+    data: LSPAny = None

robotcode/language_server/common/lsp_types.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from asyncio import CancelledError
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from ....jsonrpc2.protocol import rpc_method
+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
+from ..lsp_types import (
+    InlayHint,
+    InlayHintOptions,
+    InlayHintParams,
+    Range,
+    ServerCapabilities,
+    TextDocumentIdentifier,
+)
+from ..text_document import TextDocument
+
+if TYPE_CHECKING:
+    from ..protocol import LanguageServerProtocol
+
+from .protocol_part import LanguageServerProtocolPart
+
+
+class InlayHintProtocolPart(LanguageServerProtocolPart, HasExtendCapabilities):
+
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: LanguageServerProtocol) -> None:
+        super().__init__(parent)
+
+    @async_tasking_event
+    async def collect(sender, document: TextDocument, range: Range) -> Optional[List[InlayHint]]:  # NOSONAR
+        ...
+
+    @async_tasking_event
+    async def resolve(sender, hint: InlayHint) -> Optional[InlayHint]:  # NOSONAR
+        ...
+
+    def extend_capabilities(self, capabilities: ServerCapabilities) -> None:
+        if len(self.collect):
+            if len(self.resolve):
+                capabilities.inlay_hint_provider = InlayHintOptions(resolve_provider=bool(len(self.resolve)))
+            else:
+                capabilities.inlay_hint_provider = InlayHintOptions()
+
+    @rpc_method(name="textDocument/inlayHint", param_type=InlayHintParams)
+    @threaded()
+    async def _text_document_inlay_hint(
+        self,
+        text_document: TextDocumentIdentifier,
+        range: Range,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[List[InlayHint]]:
+
+        results: List[InlayHint] = []
+
+        document = await self.parent.documents.get(text_document.uri)
+        if document is None:
+            return None
+
+        for result in await self.collect(
+            self,
+            document,
+            range,
+            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="inlayHint/resolve", param_type=InlayHint)
+    @threaded()
+    async def _inlay_hint_resolve(
+        self,
+        params: InlayHint,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[InlayHint]:
+
+        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 isinstance(result, InlayHint):
+                    return result
+
+        return params
+
+    async def refresh(self) -> None:
+        if (
+            self.parent.client_capabilities is not None
+            and self.parent.client_capabilities.workspace is not None
+            and self.parent.client_capabilities.workspace.inlay_hint is not None
+            and self.parent.client_capabilities.workspace.inlay_hint.refresh_support
+        ):
+            await self.parent.send_request_async("workspace/inlayHint/refresh")

robotcode/language_server/common/parts/inlay_hint.py

@@ -52,6 +52,7 @@
 from .parts.formatting import FormattingProtocolPart
 from .parts.hover import HoverProtocolPart
 from .parts.implementation import ImplementationProtocolPart
+from .parts.inlay_hint import InlayHintProtocolPart
 from .parts.inline_value import InlineValueProtocolPart
 from .parts.linked_editing_ranges import LinkedEditingRangeProtocolPart
 from .parts.references import ReferencesProtocolPart
@@ -94,6 +95,7 @@ class LanguageServerProtocol(JsonRPCProtocol):
     selection_range = ProtocolPartDescriptor(SelectionRangeProtocolPart)
     rename = ProtocolPartDescriptor(RenameProtocolPart)
     inline_value = ProtocolPartDescriptor(InlineValueProtocolPart)
+    inlay_hint = ProtocolPartDescriptor(InlayHintProtocolPart)
     code_action = ProtocolPartDescriptor(CodeActionProtocolPart)
 
     name: Optional[str] = None

robotcode/language_server/common/protocol.py

@@ -90,6 +90,13 @@ class DocumentationServerConfig(ConfigBase):
     end_port: int = 3199
 
 
+@config_section("robotcode.inlayHints")
+@dataclass
+class InlayHintsConfig(ConfigBase):
+    parameter_names: bool = True
+    namespaces: bool = True
+
+
 @config_section("robotcode")
 @dataclass
 class RobotCodeConfig(ConfigBase):
@@ -99,3 +106,4 @@ class RobotCodeConfig(ConfigBase):
     workspace: WorkspaceConfig = field(default_factory=WorkspaceConfig)
     analysis: AnalysisConfig = field(default_factory=AnalysisConfig)
     documentation_server: DocumentationServerConfig = field(default_factory=DocumentationServerConfig)
+    inlay_hints: InlayHintsConfig = field(default_factory=InlayHintsConfig)

robotcode/language_server/robotframework/configuration.py

@@ -645,6 +645,7 @@ def get_keyword_snipped_text(self, kw: KeywordDoc, in_template: bool) -> str:
             return kw.name
 
         result = ""
+        after: Optional[str] = None
         for index, (before, variable, after) in enumerate(
             VariableIterator(kw.name, identifiers="$", ignore_errors=True)
         ):
@@ -661,7 +662,8 @@ def get_keyword_snipped_text(self, kw: KeywordDoc, in_template: bool) -> str:
 
             result += "}"
 
-        result += after
+        if after:
+            result += after
 
         return result