Implement call hierarchy request

.github/workflows/main.yml

@@ -38,7 +38,7 @@ jobs:
           python-version: '3.8'
       - run: sudo apt update
       - run: sudo apt install --no-install-recommends -y x11-xserver-utils
-      - run: pip3 install mypy==0.971 flake8==5.0.4 pyright==1.1.271 yapf==0.31.0 --user
+      - run: pip3 install mypy==0.971 flake8==5.0.4 pyright==1.1.285 yapf==0.31.0 --user
       - run: echo "$HOME/.local/bin" >> $GITHUB_PATH
       # - run: mypy -p plugin
       - run: flake8 plugin tests

Context.sublime-menu

@@ -23,6 +23,10 @@
                 "command": "lsp_symbol_implementation",
                 "caption": "Goto Implementation…"
             },
+            {
+                "command": "lsp_call_hierarchy",
+                "caption": "Show Call Hierarchy"
+            },
             {
                 "command": "lsp_symbol_rename",
                 "caption": "Rename…"

Default.sublime-commands

@@ -150,4 +150,8 @@
         "caption": "LSP: Run Code Lens",
         "command": "lsp_code_lens"
     },
+    {
+        "caption": "LSP: Show Call Hierarchy",
+        "command": "lsp_call_hierarchy"
+    },
 ]

Default.sublime-keymap

@@ -188,6 +188,12 @@
     //     "command": "lsp_open_link",
     //     "context": [{"key": "lsp.link_available"}]
     // },
+    // Show Call Hierarchy
+    // {
+    //     "keys": ["UNBOUND"],
+    //     "command": "lsp_call_hierarchy",
+    //     "context": [{"key": "lsp.session_with_capability", "operand": "callHierarchyProvider"}]
+    // },
     // Expand Selection (a replacement for ST's "Expand Selection")
     // {
     //     "keys": ["primary+shift+a"],

boot.py

@@ -3,6 +3,8 @@
 import sublime_plugin
 
 # Please keep this list sorted (Edit -> Sort Lines)
+from .plugin.call_hierarchy import LspCallHierarchyCommand
+from .plugin.call_hierarchy import LspCallHierarchyToggleCommand
 from .plugin.code_actions import LspCodeActionsCommand
 from .plugin.code_actions import LspRefactorCommand
 from .plugin.code_actions import LspSourceActionCommand
@@ -22,10 +24,13 @@
 from .plugin.core.protocol import Error
 from .plugin.core.protocol import Location
 from .plugin.core.protocol import LocationLink
+from .plugin.core.registry import LspCollapseTreeItemCommand
+from .plugin.core.registry import LspExpandTreeItemCommand
 from .plugin.core.registry import LspNextDiagnosticCommand
 from .plugin.core.registry import LspPrevDiagnosticCommand
 from .plugin.core.registry import LspRecheckSessionsCommand
 from .plugin.core.registry import LspRestartServerCommand
+from .plugin.core.registry import LspWindowCommand
 from .plugin.core.registry import windows
 from .plugin.core.sessions import AbstractPlugin
 from .plugin.core.sessions import register_plugin
@@ -190,27 +195,37 @@ def on_post_window_command(self, window: sublime.Window, command_name: str, args
                 sublime.set_timeout(panel_manager.update_log_panel)
 
 
-class LspOpenLocationCommand(sublime_plugin.TextCommand):
+class LspOpenLocationCommand(LspWindowCommand):
     """
     A command to be used by third-party ST packages that need to open an URI with some abstract scheme.
     """
 
     def run(
         self,
-        _: sublime.Edit,
         location: Union[Location, LocationLink],
         session_name: Optional[str] = None,
         flags: int = 0,
-        group: int = -1
+        group: int = -1,
+        event: Optional[dict] = None
     ) -> None:
+        if event:
+            modifier_keys = event.get('modifier_keys')
+            if modifier_keys:
+                if 'primary' in modifier_keys:
+                    flags |= sublime.ADD_TO_SELECTION | sublime.SEMI_TRANSIENT | sublime.CLEAR_TO_RIGHT
+                elif 'shift' in modifier_keys:
+                    flags |= sublime.ADD_TO_SELECTION | sublime.SEMI_TRANSIENT
         sublime.set_timeout_async(lambda: self._run_async(location, session_name, flags, group))
 
+    def want_event(self) -> bool:
+        return True
+
     def _run_async(
-        self, location: Union[Location, LocationLink], session_name: Optional[str], flags: int = 0, group: int = -1
+        self, location: Union[Location, LocationLink], session_name: Optional[str], flags: int, group: int
     ) -> None:
-        manager = windows.lookup(self.view.window())
-        if manager:
-            manager.open_location_async(location, session_name, self.view, flags, group) \
+        session = self.session_by_name(session_name) if session_name else self.session()
+        if session:
+            session.open_location_async(location, flags, group) \
                 .then(lambda view: self._handle_continuation(location, view is not None))
 
     def _handle_continuation(self, location: Union[Location, LocationLink], success: bool) -> None:

docs/src/keyboard_shortcuts.md

@@ -31,6 +31,7 @@ Refer to the [Customization section](customization.md#keyboard-shortcuts-key-bin
 | Run Code Lens | unbound | `lsp_code_lens`
 | Run Refactor Action | unbound | `lsp_code_actions` (with args: `{"only_kinds": ["refactor"]}`)
 | Run Source Action | unbound | `lsp_code_actions` (with args: `{"only_kinds": ["source"]}`)
+| Show Call Hierarchy | unbound | `lsp_call_hierarchy`
 | Signature Help | <kbd>ctrl</kbd> <kbd>alt</kbd> <kbd>space</kbd> | `lsp_signature_help_show`
 | Toggle Diagnostics Panel | <kbd>ctrl</kbd> <kbd>alt</kbd> <kbd>m</kbd> | `lsp_show_diagnostics_panel`
 | Toggle Log Panel | unbound | `lsp_toggle_server_panel`

plugin/call_hierarchy.py

@@ -0,0 +1,157 @@
+from .core.promise import Promise
+from .core.protocol import CallHierarchyIncomingCall
+from .core.protocol import CallHierarchyIncomingCallsParams
+from .core.protocol import CallHierarchyItem
+from .core.protocol import CallHierarchyOutgoingCall
+from .core.protocol import CallHierarchyOutgoingCallsParams
+from .core.protocol import CallHierarchyPrepareParams
+from .core.protocol import Request
+from .core.registry import new_tree_view_sheet
+from .core.registry import get_position
+from .core.registry import LspTextCommand
+from .core.registry import LspWindowCommand
+from .core.sessions import Session
+from .core.tree_view import TreeDataProvider
+from .core.tree_view import TreeItem
+from .core.typing import cast
+from .core.typing import IntEnum, List, Optional
+from .core.views import make_command_link
+from .core.views import parse_uri
+from .core.views import SYMBOL_KINDS
+from .core.views import text_document_position_params
+from functools import partial
+import sublime
+import weakref
+
+
+class CallHierarchyDirection(IntEnum):
+    IncomingCalls = 1
+    OutgoingCalls = 2
+
+
+class CallHierarchyDataProvider(TreeDataProvider):
+
+    def __init__(
+        self,
+        weaksession: 'weakref.ref[Session]',
+        direction: CallHierarchyDirection,
+        root_elements: List[CallHierarchyItem]
+    ) -> None:
+        self.weaksession = weaksession
+        self.direction = direction
+        self.root_elements = root_elements
+        session = self.weaksession()
+        self.session_name = session.config.name if session else None
+
+    def get_children(self, element: Optional[CallHierarchyItem]) -> Promise[List[CallHierarchyItem]]:
+        if element is None:
+            return Promise.resolve(self.root_elements)
+        session = self.weaksession()
+        if not session:
+            return Promise.resolve([])
+        if self.direction == CallHierarchyDirection.IncomingCalls:
+            params = cast(CallHierarchyIncomingCallsParams, {'item': element})
+            return session.send_request_task(Request.incomingCalls(params)).then(self._handle_incoming_calls_async)
+        elif self.direction == CallHierarchyDirection.OutgoingCalls:
+            params = cast(CallHierarchyOutgoingCallsParams, {'item': element})
+            return session.send_request_task(Request.outgoingCalls(params)).then(self._handle_outgoing_calls_async)
+        return Promise.resolve([])
+
+    def get_tree_item(self, element: CallHierarchyItem) -> TreeItem:
+        command_url = sublime.command_url('lsp_open_location', {
+            'location': {
+                'targetUri': element['uri'],
+                'targetRange': element['range'],
+                'targetSelectionRange': element['selectionRange']
+            },
+            'session_name': self.session_name
+        })
+        return TreeItem(
+            element['name'],
+            kind=SYMBOL_KINDS.get(element['kind'], sublime.KIND_AMBIGUOUS),
+            description=element.get('detail', ""),
+            tooltip="{}:{}".format(parse_uri(element['uri'])[1], element['selectionRange']['start']['line'] + 1),
+            command_url=command_url
+        )
+
+    def _handle_incoming_calls_async(
+        self, response: Optional[List[CallHierarchyIncomingCall]]
+    ) -> List[CallHierarchyItem]:
+        return [incoming_call['from'] for incoming_call in response] if response else []
+
+    def _handle_outgoing_calls_async(
+        self, response: Optional[List[CallHierarchyOutgoingCall]]
+    ) -> List[CallHierarchyItem]:
+        return [outgoing_call['to'] for outgoing_call in response] if response else []
+
+
+class LspCallHierarchyCommand(LspTextCommand):
+
+    capability = 'callHierarchyProvider'
+
+    def is_visible(self, event: Optional[dict] = None, point: Optional[int] = None) -> bool:
+        if self.applies_to_context_menu(event):
+            return self.is_enabled(event, point)
+        return True
+
+    def run(self, edit: sublime.Edit, event: Optional[dict] = None, point: Optional[int] = None) -> None:
+        self._window = self.view.window()
+        session = self.best_session(self.capability)
+        if not session:
+            return
+        position = get_position(self.view, event, point)
+        if position is None:
+            return
+        params = cast(CallHierarchyPrepareParams, text_document_position_params(self.view, position))
+        request = Request.prepareCallHierarchy(params, self.view)
+        session.send_request_async(request, partial(self._handle_response_async, weakref.ref(session)))
+
+    def _handle_response_async(
+        self, weaksession: 'weakref.ref[Session]', response: Optional[List[CallHierarchyItem]]
+    ) -> None:
+        if not self._window or not self._window.is_valid():
+            return
+        if not response:
+            self._window.status_message("Call hierarchy not available")
+            return
+        session = weaksession()
+        if not session:
+            return
+        data_provider = CallHierarchyDataProvider(weaksession, CallHierarchyDirection.IncomingCalls, response)
+        header = 'Call Hierarchy: Callers of… {}'.format(
+            make_command_link('lsp_call_hierarchy_toggle', "⇄", {
+                'session_name': session.config.name,
+                'direction': CallHierarchyDirection.OutgoingCalls,
+                'root_elements': response
+            }, tooltip="Show outgoing calls"))
+        new_tree_view_sheet(self._window, "Call Hierarchy", data_provider, header, flags=sublime.ADD_TO_SELECTION)
+
+
+class LspCallHierarchyToggleCommand(LspWindowCommand):
+
+    capability = 'callHierarchyProvider'
+
+    def run(
+        self, session_name: str, direction: CallHierarchyDirection, root_elements: List[CallHierarchyItem]
+    ) -> None:
+        session = self.session_by_name(session_name)
+        if not session:
+            return
+        if direction == CallHierarchyDirection.IncomingCalls:
+            current_label = 'Callers of…'
+            new_direction = CallHierarchyDirection.OutgoingCalls
+            tooltip = 'Show Outgoing Calls'
+        elif direction == CallHierarchyDirection.OutgoingCalls:
+            current_label = 'Calls from…'
+            new_direction = CallHierarchyDirection.IncomingCalls
+            tooltip = 'Show Incoming Calls'
+        else:
+            return
+        header = 'Call Hierarchy: {} {}'.format(
+            current_label, make_command_link('lsp_call_hierarchy_toggle', "⇄", {
+                'session_name': session_name,
+                'direction': new_direction,
+                'root_elements': root_elements
+            }, tooltip=tooltip))
+        data_provider = CallHierarchyDataProvider(weakref.ref(session), direction, root_elements)
+        new_tree_view_sheet(self.window, "Call Hierarchy", data_provider, header, flags=sublime.ADD_TO_SELECTION)

plugin/core/protocol.py

@@ -5912,6 +5912,18 @@ def semanticTokensFullDelta(cls, params: Mapping[str, Any], view: sublime.View)
     def semanticTokensRange(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
         return Request("textDocument/semanticTokens/range", params, view)
 
+    @classmethod
+    def prepareCallHierarchy(cls, params: CallHierarchyPrepareParams, view: sublime.View) -> 'Request':
+        return Request("textDocument/prepareCallHierarchy", params, view)
+
+    @classmethod
+    def incomingCalls(cls, params: CallHierarchyIncomingCallsParams) -> 'Request':
+        return Request("callHierarchy/incomingCalls", params, None)
+
+    @classmethod
+    def outgoingCalls(cls, params: CallHierarchyOutgoingCallsParams) -> 'Request':
+        return Request("callHierarchy/outgoingCalls", params, None)
+
     @classmethod
     def resolveCompletionItem(cls, params: CompletionItem, view: sublime.View) -> 'Request':
         return Request("completionItem/resolve", params, view)