Inlay hint

Default.sublime-commands

@@ -126,5 +126,9 @@
     {
         "caption": "LSP: Find References",
         "command": "lsp_symbol_references"
+    },
+    {
+        "caption": "LSP: Toggle Inlay Hints",
+        "command": "lsp_toggle_inlay_hints"
     }
 ]

Default.sublime-keymap

@@ -389,6 +389,20 @@
     //         }
     //     ]
     // },
+    // Toggle inlay hints.
+    // {
+    //     "command": "lsp_toggle_inlay_hints",
+    //     "keys": [
+    //         "UNBOUND"
+    //     ],
+    //     "context": [
+    //         {
+    //             "key": "lsp.session_with_capability",
+    //             "operator": "equal",
+    //             "operand": "inlayHintProvider"
+    //         }
+    //     ]
+    // },
     // Internal key-binding
     {
         "keys": [

LSP.sublime-settings

@@ -134,6 +134,9 @@
   // "phantom" - show a phantom on the top when code actions are available
   "show_code_lens": "annotation",
 
+   // Show inlay hints
+  "show_inlay_hints": true,
+
   // Show code actions in hover popup if available
   "show_code_actions_in_hover": true,
 

boot.py

@@ -48,6 +48,8 @@
 from .plugin.goto import LspSymbolTypeDefinitionCommand
 from .plugin.goto_diagnostic import LspGotoDiagnosticCommand
 from .plugin.hover import LspHoverCommand
+from .plugin.inlay_hint import LspInlayHintClickCommand
+from .plugin.inlay_hint import LspToggleInlayHintsCommand
 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],
+    'location': Location,
+    'command':  Command
+}, total=False)
+
+
+class InlayHintKind:
+    Type = 1
+    Parameter = 1
+
+
+InlayHint = TypedDict('InlayHint', {
+    'position': Position,
+    'label': Union[str, List[InlayHintLabelPart]],
+    'kind': Optional[int],
+    'textEdits': Optional[List[TextEdit]],
+    'tooltip': Optional[Union[str, MarkupContent]],
+    'paddingLeft': Optional[bool],
+    'paddingRight': Optional[bool],
+    'data': Optional[Any]
+}, total=True)
+
+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,13 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
         "codeLens": {
             "dynamicRegistration": True
         },
+        "inlayHint": {
+            "dynamicRegistration": True,
+            "resolveSupport": {
+                # not sure if I can just put "command" because the command is nested in the label
+                "properties": ["textEdits", "command"]
+            }
+        },
         "semanticTokens": {
             "dynamicRegistration": True,
             "requests": {
@@ -391,6 +398,9 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
         "codeLens": {
             "refreshSupport": True
         },
+        "inlayHint": {
+            "refreshSupport": True
+        },
         "semanticTokens": {
             "refreshSupport": True
         }
@@ -487,6 +497,12 @@ def get_resolved_code_lenses_for_region(self, region: sublime.Region) -> Generat
     def start_code_lenses_async(self) -> None:
         ...
 
+    def present_inlay_hints_async(self, phantoms: List[sublime.Phantom]) -> None:
+        ...
+
+    def remove_inlay_hint_phantom(self, phantom_uuid: str) -> None:
+        ...
+
 
 class SessionBufferProtocol(Protocol):
 
@@ -542,6 +558,9 @@ 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:
+        ...
+
 
 class AbstractViewListener(metaclass=ABCMeta):
 
@@ -1622,6 +1641,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
@@ -243,6 +244,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,128 @@
+from .core.protocol import InlayHintLabelPart, MarkupContent, Point, InlayHint, Request
+from .core.registry import LspTextCommand
+from .core.typing import List, Optional, Union
+from .core.views import FORMAT_MARKUP_CONTENT, point_to_offset, minihtml
+from .formatting import apply_text_edits_to_view
+import html
+import sublime
+import uuid
+
+
+class LspToggleInlayHintsCommand(LspTextCommand):
+    capability = 'inlayHintProvider'
+
+    def run(self, _edit: sublime.Edit, _event: Optional[dict] = None) -> None:
+        settings = sublime.load_settings("LSP.sublime-settings")
+        show_inlay_hints = settings.get("show_inlay_hints", False)
+        settings.set("show_inlay_hints", not show_inlay_hints)
+        sublime.save_settings("LSP.sublime-settings")
+
+
+class LspInlayHintClickCommand(LspTextCommand):
+    capability = 'inlayHintProvider'
+
+    def run(self, _edit: sublime.Edit, session_name: str, inlay_hint: InlayHint, phantom_uuid: str,
+            event: Optional[dict] = None) -> None:
+        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))
+            return
+        self.handle(session_name, inlay_hint, phantom_uuid)
+
+    def handle(self, session_name: str, inlay_hint: InlayHint, phantom_uuid: str) -> None:
+        self.handle_inlay_hint_text_edits(session_name, inlay_hint, phantom_uuid)
+        self.handle_inlay_hint_command(session_name, inlay_hint)
+
+    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 sv in session.session_views_async():
+            sv.remove_inlay_hint_phantom(phantom_uuid)
+        apply_text_edits_to_view(text_edits, self.view)
+
+    def handle_inlay_hint_command(self, session_name: str, inlay_hint: InlayHint) -> None:
+        label_parts = inlay_hint.get('label')
+        if not isinstance(label_parts, list):
+            return
+        for label_part in label_parts:
+            command = label_part.get('command')
+            if not command:
+                continue
+            args = {
+                "session_name": session_name,
+                "command_name": command["command"],
+                "command_args": command["arguments"]
+            }
+            self.view.run_command("lsp_execute", args)
+
+
+INLAY_HINT_HTML = """
+<body id="lsp-inlay-hint">
+    <style>
+        .inlay-hint {{
+            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: monospace;
+        }}
+
+        .inlay-hint a {{
+            color: color(var(--foreground) alpha(0.6));
+            text-decoration: none;
+        }}
+    </style>
+    <div class="inlay-hint" title="{tooltip}">
+            <a href="{command}">{label}</a>
+    </div>
+</body>
+"""
+
+
+def format_inlay_hint_tooltip(view: sublime.View, tooltip: Optional[Union[str, MarkupContent]]) -> str:
+    if isinstance(tooltip, str):
+        return html.escape(tooltip)
+    elif isinstance(tooltip, dict):  # MarkupContent
+        return minihtml(view, tooltip, allowed_formats=FORMAT_MARKUP_CONTENT)
+    else:
+        return ""
+
+
+def format_inlay_hint_label(view: sublime.View, label: Union[str, List[InlayHintLabelPart]]) -> str:
+    if isinstance(label, str):
+        return html.escape(label)
+    else:
+        return "".join("<div title=\"{tooltip}\">{value}</div>".format(
+            tooltip=format_inlay_hint_tooltip(view, label_part.get("tooltip")),
+            value=label_part.get("value")
+        ) for label_part in label)
+
+
+def inlay_hint_to_phantom(view: sublime.View, inlay_hint: InlayHint, session_name: str) -> sublime.Phantom:
+    region = sublime.Region(point_to_offset(Point.from_lsp(inlay_hint["position"]), view))
+    tooltip = format_inlay_hint_tooltip(view, inlay_hint.get("tooltip"))
+    label = format_inlay_hint_label(view, inlay_hint["label"])
+    margin_left = "0.6rem" if inlay_hint.get("paddingLeft", False) else "0"
+    margin_right = "0.6rem" if inlay_hint.get("paddingRight", False) else "0"
+    phantom_uuid = str(uuid.uuid4())
+    command = sublime.command_url('lsp_inlay_hint_click', {
+        'session_name': session_name,
+        'inlay_hint': inlay_hint,
+        'phantom_uuid': phantom_uuid
+    })
+    content = INLAY_HINT_HTML.format(
+        margin_left=margin_left,
+        margin_right=margin_right,
+        tooltip=tooltip,
+        label=label,
+        command=command)
+    p = sublime.Phantom(region, content, sublime.LAYOUT_INLINE)
+    setattr(p, 'lsp_uuid', phantom_uuid)
+    return p