Inlay hint

LSP.sublime-settings

@@ -134,6 +134,9 @@
   // "phantom" - show a phantom on the top when code actions are available
   "show_code_lens": "annotation",
 
+   // Inlay hints are short annotations within the code, which show variable types or parameter names.
+  "show_inlay_hints": true,
+
   // Show code actions in hover popup if available
   "show_code_actions_in_hover": true,
 

boot.py

@@ -48,6 +48,7 @@
 from .plugin.goto import LspSymbolTypeDefinitionCommand
 from .plugin.goto_diagnostic import LspGotoDiagnosticCommand
 from .plugin.hover import LspHoverCommand
+from .plugin.inlay_hint import LspInlayHintClickCommand
 from .plugin.panels import LspShowDiagnosticsPanelCommand
 from .plugin.panels import LspToggleServerPanelCommand
 from .plugin.references import LspSymbolReferencesCommand

plugin/core/protocol.py

@@ -364,6 +364,37 @@ class SemanticTokenModifiers:
     'watchers': List[FileSystemWatcher],
 }, total=True)
 
+InlayHintParams = TypedDict('InlayHintParams', {
+    'textDocument': TextDocumentIdentifier,
+    'range': RangeLsp,
+}, total=True)
+
+InlayHintLabelPart = TypedDict('InlayHintLabelPart', {
+    'value': str,
+    'tooltip': Union[str, MarkupContent],  # NotRequired
+    'location': Location,  # NotRequired
+    'command':  Command  # NotRequired
+}, total=False)
+
+
+class InlayHintKind:
+    Type = 1
+    Parameter = 2
+
+
+InlayHint = TypedDict('InlayHint', {
+    'position': Position,
+    'label': Union[str, List[InlayHintLabelPart]],
+    'kind': int,  # NotRequired
+    'textEdits': List[TextEdit],  # NotRequired
+    'tooltip': Union[str, MarkupContent],  # NotRequired
+    'paddingLeft': bool,  # NotRequired
+    'paddingRight': bool,  # NotRequired
+    'data': Any  # NotRequired
+}, total=False)
+
+InlayHintResponse = Union[List[InlayHint], None]
+
 WatchKind = int
 WatchKindCreate = 1
 WatchKindChange = 2
@@ -452,6 +483,14 @@ def resolveCompletionItem(cls, params: CompletionItem, view: sublime.View) -> 'R
     def resolveDocumentLink(cls, params: DocumentLink, view: sublime.View) -> 'Request':
         return Request("documentLink/resolve", params, view)
 
+    @classmethod
+    def inlayHint(cls, params: InlayHintParams, view: sublime.View) -> 'Request':
+        return Request('textDocument/inlayHint', params, view)
+
+    @classmethod
+    def resolveInlayHint(cls, params: InlayHint, view: sublime.View) -> 'Request':
+        return Request('inlayHint/resolve', params, view)
+
     @classmethod
     def shutdown(cls) -> 'Request':
         return Request("shutdown")

plugin/core/sessions.py

@@ -349,6 +349,12 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
         "codeLens": {
             "dynamicRegistration": True
         },
+        "inlayHint": {
+            "dynamicRegistration": True,
+            "resolveSupport": {
+                "properties": ["textEdits", "label.command"]
+            }
+        },
         "semanticTokens": {
             "dynamicRegistration": True,
             "requests": {
@@ -391,6 +397,9 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
         "codeLens": {
             "refreshSupport": True
         },
+        "inlayHint": {
+            "refreshSupport": True
+        },
         "semanticTokens": {
             "refreshSupport": True
         }
@@ -542,6 +551,15 @@ def set_semantic_tokens_pending_refresh(self, needs_refresh: bool = True) -> Non
     def get_semantic_tokens(self) -> List[Any]:
         ...
 
+    def do_inlay_hints_async(self, view: sublime.View) -> None:
+        ...
+
+    def remove_inlay_hint_phantom(self, phantom_uuid: str) -> None:
+        ...
+
+    def remove_all_inlay_hints(self) -> None:
+        ...
+
 
 class AbstractViewListener(metaclass=ABCMeta):
 
@@ -1622,6 +1640,12 @@ def m_workspace_semanticTokens_refresh(self, params: Any, request_id: Any) -> No
             else:
                 sv.session_buffer.set_semantic_tokens_pending_refresh()
 
+    def m_workspace_inlayHint_refresh(self, params: None, request_id: Any) -> None:
+        """handles the workspace/inlayHint/refresh request"""
+        for sv in self.session_views_async():
+            sv.session_buffer.do_inlay_hints_async(sv.view)
+        self.send_response(Response(request_id, None))
+
     def m_textDocument_publishDiagnostics(self, params: Any) -> None:
         """handles the textDocument/publishDiagnostics notification"""
         uri = params["uri"]

plugin/core/types.py

@@ -206,6 +206,7 @@ class Settings:
     semantic_highlighting = None  # type: bool
     show_code_actions = None  # type: str
     show_code_lens = None  # type: str
+    show_inlay_hints = None  # type: bool
     show_code_actions_in_hover = None  # type: bool
     show_diagnostics_count_in_view_status = None  # type: bool
     show_multiline_diagnostics_highlights = None  # type: bool
@@ -220,7 +221,6 @@ def __init__(self, s: sublime.Settings) -> None:
         self.update(s)
 
     def update(self, s: sublime.Settings) -> None:
-
         def r(name: str, default: Union[bool, int, str, list, dict]) -> None:
             val = s.get(name)
             setattr(self, name, val if isinstance(val, default.__class__) else default)
@@ -243,6 +243,7 @@ def r(name: str, default: Union[bool, int, str, list, dict]) -> None:
         r("semantic_highlighting", False)
         r("show_code_actions", "annotation")
         r("show_code_lens", "annotation")
+        r("show_inlay_hints", True)
         r("show_code_actions_in_hover", True)
         r("show_diagnostics_count_in_view_status", False)
         r("show_diagnostics_in_view_status", True)

plugin/documents.py

@@ -342,6 +342,7 @@ def on_activated_async(self) -> None:
                 if sb.semantic_tokens.needs_refresh:
                     sb.semantic_tokens.needs_refresh = False
                     sb.do_semantic_tokens_async(self.view)
+                sb.do_inlay_hints_async(self.view)
 
     def on_selection_modified_async(self) -> None:
         different, current_region = self._update_stored_region_async()

plugin/formatting.py

@@ -31,7 +31,7 @@ def format_document(text_command: LspTextCommand) -> Promise[FormatResponse]:
     return Promise.resolve(None)
 
 
-def apply_response_to_view(response: Optional[List[TextEdit]], view: sublime.View) -> None:
+def apply_text_edits_to_view(response: Optional[List[TextEdit]], view: sublime.View) -> None:
     edits = list(parse_text_edit(change) for change in response) if response else []
     view.run_command('lsp_apply_document_edit', {'changes': edits})
 
@@ -66,7 +66,7 @@ def _will_save_wait_until_async(self, session: Session) -> None:
 
     def _on_response(self, response: Any) -> None:
         if response and not self._cancelled:
-            apply_response_to_view(response, self._task_runner.view)
+            apply_text_edits_to_view(response, self._task_runner.view)
         sublime.set_timeout_async(self._handle_next_session_async)
 
 
@@ -85,7 +85,7 @@ def run_async(self) -> None:
 
     def _on_response(self, response: FormatResponse) -> None:
         if response and not isinstance(response, Error) and not self._cancelled:
-            apply_response_to_view(response, self._task_runner.view)
+            apply_text_edits_to_view(response, self._task_runner.view)
         sublime.set_timeout_async(self._on_complete)
 
 
@@ -105,7 +105,7 @@ def run(self, edit: sublime.Edit, event: Optional[dict] = None) -> None:
 
     def on_result(self, result: FormatResponse) -> None:
         if result and not isinstance(result, Error):
-            apply_response_to_view(result, self.view)
+            apply_text_edits_to_view(result, self.view)
 
 
 class LspFormatDocumentRangeCommand(LspTextCommand):
@@ -125,4 +125,4 @@ def run(self, edit: sublime.Edit, event: Optional[dict] = None) -> None:
         selection = first_selection_region(self.view)
         if session and selection is not None:
             req = text_document_range_formatting(self.view, selection)
-            session.send_request(req, lambda response: apply_response_to_view(response, self.view))
+            session.send_request(req, lambda response: apply_text_edits_to_view(response, self.view))

plugin/inlay_hint.py

@@ -0,0 +1,153 @@
+from .core.protocol import InlayHintLabelPart, MarkupContent, Point, InlayHint, Request
+from .core.registry import LspTextCommand
+from .core.sessions import Session
+from .core.typing import Optional, Union
+from .core.views import point_to_offset
+from .formatting import apply_text_edits_to_view
+import html
+import sublime
+import uuid
+
+
+class LspInlayHintClickCommand(LspTextCommand):
+    capability = 'inlayHintProvider'
+
+    def run(self, _edit: sublime.Edit, session_name: str, inlay_hint: InlayHint, phantom_uuid: str,
+            event: Optional[dict] = None, label_part: Optional[InlayHintLabelPart] = None) -> None:
+        # Insert textEdits for the given inlay hint.
+        # If a InlayHintLabelPart was clicked, label_part will be passed as an argument to the LspInlayHintClickCommand
+        # and InlayHintLabelPart.command will be executed.
+        session = self.session_by_name(session_name, 'inlayHintProvider')
+        if session and session.has_capability('inlayHintProvider.resolveProvider'):
+            request = Request.resolveInlayHint(inlay_hint, self.view)
+            session.send_request_async(
+                request,
+                lambda response: self.handle(session_name, response, phantom_uuid, label_part))
+            return
+        self.handle(session_name, inlay_hint, phantom_uuid, label_part)
+
+    def handle(self, session_name: str, inlay_hint: InlayHint, phantom_uuid: str,
+               label_part: Optional[InlayHintLabelPart] = None) -> None:
+        self.handle_inlay_hint_text_edits(session_name, inlay_hint, phantom_uuid)
+        self.handle_label_part_command(session_name, label_part)
+
+    def handle_inlay_hint_text_edits(self, session_name: str, inlay_hint: InlayHint, phantom_uuid: str) -> None:
+        session = self.session_by_name(session_name, 'inlayHintProvider')
+        if not session:
+            return
+        text_edits = inlay_hint.get('textEdits')
+        if not text_edits:
+            return
+        for sb in session.session_buffers_async():
+            sb.remove_inlay_hint_phantom(phantom_uuid)
+        apply_text_edits_to_view(text_edits, self.view)
+
+    def handle_label_part_command(self, session_name: str, label_part: Optional[InlayHintLabelPart] = None) -> None:
+        if not label_part:
+            return
+        command = label_part.get('command')
+        if not command:
+            return
+        args = {
+            "session_name": session_name,
+            "command_name": command["command"],
+            "command_args": command["arguments"]
+        }
+        self.view.run_command("lsp_execute", args)
+
+
+def inlay_hint_to_phantom(view: sublime.View, inlay_hint: InlayHint, session: Session) -> sublime.Phantom:
+    position = inlay_hint["position"]  # type: ignore
+    region = sublime.Region(point_to_offset(Point.from_lsp(position), view))
+    phantom_uuid = str(uuid.uuid4())
+    content = get_inlay_hint_html(view, inlay_hint, session, phantom_uuid)
+    p = sublime.Phantom(region, content, sublime.LAYOUT_INLINE)
+    setattr(p, 'lsp_uuid', phantom_uuid)
+    return p
+
+
+def get_inlay_hint_html(view: sublime.View, inlay_hint: InlayHint, session: Session, phantom_uuid: str) -> str:
+    tooltip = format_inlay_hint_tooltip(inlay_hint.get("tooltip"))
+    label = format_inlay_hint_label(inlay_hint, session, phantom_uuid)
+    margin_left = "0.6rem" if inlay_hint.get("paddingLeft", False) else "0"
+    margin_right = "0.6rem" if inlay_hint.get("paddingRight", False) else "0"
+    font = view.settings().get('font_face') or "monospace"
+    html = """
+    <body id="lsp-inlay-hint">
+        <style>
+            .inlay-hint {{
+                color: color(var(--foreground) alpha(0.6));
+                background-color: color(var(--foreground) alpha(0.08));
+                border-radius: 4px;
+                margin-left: {margin_left};
+                margin-right: {margin_right};
+                padding: 0.05em 4px;
+                font-size: 0.9em;
+                font-family: {font};
+            }}
+
+            .inlay-hint a {{
+                color: color(var(--foreground) alpha(0.6));
+                text-decoration: none;
+            }}
+        </style>
+        <div class="inlay-hint" title="{tooltip}">
+            {label}
+        </div>
+    </body>
+    """.format(
+        margin_left=margin_left,
+        margin_right=margin_right,
+        tooltip=tooltip,
+        font=font,
+        label=label
+    )
+    return html
+
+
+def format_inlay_hint_tooltip(tooltip: Optional[Union[str, MarkupContent]]) -> str:
+    if isinstance(tooltip, str):
+        return tooltip
+    if isinstance(tooltip, dict):  # MarkupContent
+        return tooltip.get('value') or ""
+    return ""
+
+
+def format_inlay_hint_label(inlay_hint: InlayHint, session: Session, phantom_uuid: str) -> str:
+    result = ""
+    can_resolve_inlay_hint = session.has_capability('inlayHintProvider.resolveProvider')
+    label = inlay_hint['label']  # type: ignore
+    is_clickable = bool(inlay_hint.get('textEdits')) or can_resolve_inlay_hint
+    if isinstance(label, str):
+        if is_clickable:
+            inlay_hint_click_command = sublime.command_url('lsp_inlay_hint_click', {
+                'session_name': session.config.name,
+                'inlay_hint': inlay_hint,
+                'phantom_uuid': phantom_uuid
+            })
+            result += '<a href="{command}">'.format(command=inlay_hint_click_command)
+        result += html.escape(label)
+        if is_clickable:
+            result += "</a>"
+        return result
+
+    for label_part in label:
+        value = ""
+        is_clickable = is_clickable or bool(label_part.get('command'))
+        if is_clickable:
+            inlay_hint_click_command = sublime.command_url('lsp_inlay_hint_click', {
+                'session_name': session.config.name,
+                'inlay_hint': inlay_hint,
+                'phantom_uuid': phantom_uuid,
+                'label_part': label_part
+            })
+            value += '<a href="{command}">'.format(command=inlay_hint_click_command)
+        value += html.escape(label_part.get('value') or "")
+        if is_clickable:
+            value += "</a>"
+        # InlayHintLabelPart.location is not supported
+        result += "<div title=\"{tooltip}\">{value}</div>".format(
+            tooltip=format_inlay_hint_tooltip(label_part.get("tooltip")),
+            value=value
+        )
+    return result