Filter out non-quickfix actions in view (#2081)

Context.sublime-menu

@@ -31,6 +31,11 @@
                 "command": "lsp_code_actions",
                 "caption": "Code Action…"
             },
+            {
+                "command": "lsp_code_actions",
+                "args": {"only_kinds": ["refactor"]},
+                "caption": "Refactor…"
+            },
             {
                 "command": "lsp_code_actions",
                 "args": {"only_kinds": ["source"]},

Default.sublime-commands

@@ -84,7 +84,9 @@
     {
         "caption": "LSP: Goto Diagnostic",
         "command": "lsp_goto_diagnostic",
-        "args": {"uri": "$view_uri"}
+        "args": {
+            "uri": "$view_uri"
+        }
     },
     {
         "caption": "LSP: Goto Diagnostic in Project",
@@ -107,11 +109,20 @@
         "command": "lsp_symbol_rename"
     },
     {
-        "caption": "LSP: Run Code Action",
+        "caption": "LSP: Code Action…",
         "command": "lsp_code_actions"
     },
     {
-        "caption": "LSP: Run Source Action",
+        "caption": "LSP: Refactor…",
+        "command": "lsp_code_actions",
+        "args": {
+            "only_kinds": [
+                "refactor"
+            ]
+        },
+    },
+    {
+        "caption": "LSP: Source Action…",
         "command": "lsp_code_actions",
         "args": {
             "only_kinds": [

docs/src/features.md

@@ -136,7 +136,7 @@ Code Actions are an umbrella term for "Quick Fixes" and "Refactorings". They are
 
 Formatting is different from Code Actions, because Formatting is supposed to _not_ mutate the abstract syntax tree of the file, only move around white space. Any Code Action will mutate the abstract syntax tree.
 
-This package presents Code Actions as a bluish clickable annotation positioned to the right of the viewport. Alternatively, they can be presented as a light bulb in the Gutter Area.
+This package presents "Quick Fix" Code Actions as a bluish clickable annotation positioned to the right of the viewport. Alternatively, they can be presented as a light bulb in the Gutter Area.
 
 Sublime Text has no concept of Code Actions.
 

docs/src/keyboard_shortcuts.md

@@ -26,6 +26,7 @@ Refer to the [Customization section](customization.md#keyboard-shortcuts-key-bin
 | Restart Server | unbound | `lsp_restart_server`
 | Run Code Action | unbound | `lsp_code_actions`
 | 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"]}`)
 | 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`

plugin/core/protocol.py

@@ -1,4 +1,4 @@
-from .typing import Enum, IntEnum, IntFlag
+from .typing import Enum, IntEnum, IntFlag, StrEnum
 from .typing import Any, Dict, Iterable, List, Literal, Mapping, NotRequired, Optional, TypedDict, Union
 import sublime
 
@@ -327,7 +327,7 @@ class DocumentHighlightKind(IntEnum):
     """ Write-access of a symbol, like writing to a variable. """
 
 
-class CodeActionKind(Enum):
+class CodeActionKind(StrEnum):
     """ A set of predefined code action kinds """
     Empty = ''
     """ Empty kind. """

plugin/core/sessions.py

@@ -336,6 +336,7 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
                         CodeActionKind.RefactorExtract,
                         CodeActionKind.RefactorInline,
                         CodeActionKind.RefactorRewrite,
+                        CodeActionKind.SourceFixAll,
                         CodeActionKind.SourceOrganizeImports,
                     ]
                 }

plugin/core/typing.py

@@ -2,7 +2,7 @@
 
 if sys.version_info >= (3, 11, 0):
 
-    from enum import Enum, IntEnum, IntFlag
+    from enum import Enum, IntEnum, IntFlag, StrEnum
     from typing import Any
     from typing import Callable
     from typing import cast
@@ -25,6 +25,7 @@
     from typing import Tuple
     from typing import Type
     from typing import TypedDict
+    from typing import TypeGuard
     from typing import TypeVar
     from typing import Union
 
@@ -57,6 +58,9 @@ class TypedDict(Type, dict):  # type: ignore
         def __init__(*args, **kwargs) -> None:  # type: ignore
             pass
 
+    class TypeGuard(Type):  # type: ignore
+        pass
+
     class Enum(Type):  # type: ignore
         pass
 
@@ -66,6 +70,9 @@ class IntEnum(Type):  # type: ignore
     class IntFlag(Type):  # type: ignore
         pass
 
+    class StrEnum(Type):  # type: ignore
+        pass
+
     class Any(Type):  # type: ignore
         pass
 

plugin/core/views.py

@@ -1049,15 +1049,15 @@ def format_completion(
 
 
 def format_code_actions_for_quick_panel(
-    code_actions: List[Union[CodeAction, Command]]
+    session_actions: Iterable[Tuple[str, Union[CodeAction, Command]]]
 ) -> Tuple[List[sublime.QuickPanelItem], int]:
     items = []  # type: List[sublime.QuickPanelItem]
     selected_index = -1
-    for idx, code_action in enumerate(code_actions):
+    for idx, (config_name, code_action) in enumerate(session_actions):
         lsp_kind = code_action.get("kind", "")
         first_kind_component = cast(CodeActionKind, str(lsp_kind).split(".")[0])
         kind = CODE_ACTION_KINDS.get(first_kind_component, sublime.KIND_AMBIGUOUS)
-        items.append(sublime.QuickPanelItem(code_action["title"], kind=kind))
+        items.append(sublime.QuickPanelItem(code_action["title"], annotation=config_name, kind=kind))
         if code_action.get('isPreferred', False):
             selected_index = idx
     return items, selected_index

plugin/documents.py

@@ -176,7 +176,7 @@ def _setup(self) -> None:
         self._stored_region = sublime.Region(-1, -1)
         self._sighelp = None  # type: Optional[SigHelp]
         self._lightbulb_line = None  # type: Optional[int]
-        self._actions_by_config = {}  # type: Dict[str, List[CodeActionOrCommand]]
+        self._actions_by_config = []  # type: List[CodeActionsByConfigName]
         self._registered = False
 
     def _cleanup(self) -> None:
@@ -284,7 +284,7 @@ def diagnostics_touching_point_async(
     def on_diagnostics_updated_async(self) -> None:
         self._clear_code_actions_annotation()
         if userprefs().show_code_actions:
-            self._do_code_actions()
+            self._do_code_actions_async()
         self._update_diagnostic_in_status_bar_async()
         window = self.view.window()
         is_active_view = window and window.active_view() == self.view
@@ -369,7 +369,7 @@ def on_selection_modified_async(self) -> None:
                                                           after_ms=self.highlights_debounce_time)
             self._clear_code_actions_annotation()
             if userprefs().show_code_actions:
-                self._when_selection_remains_stable_async(self._do_code_actions, current_region,
+                self._when_selection_remains_stable_async(self._do_code_actions_async, current_region,
                                                           after_ms=self.code_actions_debounce_time)
             self._update_diagnostic_in_status_bar_async()
             self._resolve_visible_code_lenses_async()
@@ -590,13 +590,17 @@ def _on_sighelp_navigate(self, href: str) -> None:
 
     # --- textDocument/codeAction --------------------------------------------------------------------------------------
 
-    def _do_code_actions(self) -> None:
+    def _do_code_actions_async(self) -> None:
         diagnostics_by_config, covering = self.diagnostics_intersecting_async(self._stored_region)
-        actions_manager.request_for_region_async(
-            self.view, covering, diagnostics_by_config, self._on_code_actions, manual=False)
-
-    def _on_code_actions(self, responses: CodeActionsByConfigName) -> None:
-        action_count = sum(map(len, responses.values()))
+        actions_manager \
+            .request_for_region_async(self.view, covering, diagnostics_by_config, manual=False) \
+            .then(self._on_code_actions)
+
+    def _on_code_actions(self, responses: List[CodeActionsByConfigName]) -> None:
+        # flatten list
+        action_lists = [actions for _, actions in responses if len(actions)]
+        all_actions = [action for actions in action_lists for action in actions]
+        action_count = len(all_actions)
         if action_count == 0:
             return
         regions = [sublime.Region(self._stored_region.b, self._stored_region.a)]
@@ -614,9 +618,9 @@ def _on_code_actions(self, responses: CodeActionsByConfigName) -> None:
             if action_count > 1:
                 title = '{} code actions'.format(action_count)
             else:
-                title = next(itertools.chain.from_iterable(responses.values()))['title']
+                title = all_actions[0]['title']
                 title = "<br>".join(textwrap.wrap(title, width=30))
-            code_actions_link = make_command_link('lsp_code_actions', title, {"commands_by_config": responses})
+            code_actions_link = make_command_link('lsp_code_actions', title, {"code_actions_by_config": responses})
             annotations = ["<div class=\"actions\" style=\"font-family:system\">{}</div>".format(code_actions_link)]
             annotation_color = self.view.style_for_scope("region.bluish markup.accent.codeaction.lsp")["foreground"]
         self.view.add_regions(SessionView.CODE_ACTIONS_KEY, regions, scope, icon, flags, annotations, annotation_color)
@@ -628,26 +632,30 @@ def _clear_code_actions_annotation(self) -> None:
     def _on_navigate(self, href: str, point: int) -> None:
         if href.startswith('code-actions:'):
             _, config_name = href.split(":")
-            actions = self._actions_by_config[config_name]
+            actions = next(actions for name, actions in self._actions_by_config if name == config_name)
             if len(actions) > 1:
                 window = self.view.window()
                 if window:
-                    items, selected_index = format_code_actions_for_quick_panel(actions)
+                    items, selected_index = format_code_actions_for_quick_panel(
+                        map(lambda action: (config_name, action), actions))
                     window.show_quick_panel(
                         items,
-                        lambda i: self.handle_code_action_select(config_name, i),
+                        lambda i: self.handle_code_action_select(config_name, actions, i),
                         selected_index=selected_index,
                         placeholder="Code actions")
             else:
-                self.handle_code_action_select(config_name, 0)
-
-    def handle_code_action_select(self, config_name: str, index: int) -> None:
-        if index > -1:
-            def run_async() -> None:
-                session = self.session_by_name(config_name)
-                if session:
-                    session.run_code_action_async(self._actions_by_config[config_name][index], progress=True)
-            sublime.set_timeout_async(run_async)
+                self.handle_code_action_select(config_name, actions, 0)
+
+    def handle_code_action_select(self, config_name: str, actions: List[CodeActionOrCommand], index: int) -> None:
+        if index == -1:
+            return
+
+        def run_async() -> None:
+            session = self.session_by_name(config_name)
+            if session:
+                session.run_code_action_async(actions[index], progress=True)
+
+        sublime.set_timeout_async(run_async)
 
     # --- textDocument/codeLens ----------------------------------------------------------------------------------------
 

plugin/hover.py

@@ -1,5 +1,6 @@
 from .code_actions import actions_manager
 from .code_actions import CodeActionOrCommand
+from .code_actions import CodeActionsByConfigName
 from .core.open import open_file_uri
 from .core.open import open_in_browser
 from .core.promise import Promise
@@ -79,18 +80,20 @@ def link(self, point: int, view: sublime.View) -> str:
 ]
 
 
-def code_actions_content(actions_by_config: Dict[str, List[CodeActionOrCommand]]) -> str:
+def code_actions_content(actions_by_config: List[CodeActionsByConfigName]) -> str:
     formatted = []
-    for config_name, actions in actions_by_config.items():
+    for config_name, actions in actions_by_config:
         action_count = len(actions)
-        if action_count > 0:
-            href = "{}:{}".format('code-actions', config_name)
-            if action_count > 1:
-                text = "choose code action ({} available)".format(action_count)
-            else:
-                text = actions[0].get('title', 'code action')
-            formatted.append('<div class="actions">[{}] Code action: {}</div>'.format(
-                config_name, make_link(href, text)))
+        if action_count == 0:
+            continue
+        if action_count > 1:
+            text = "choose ({} available)".format(action_count)
+        else:
+            text = actions[0].get('title', 'code action')
+        href = "{}:{}".format('code-actions', config_name)
+        link = make_link(href, text)
+        formatted.append(
+            '<div class="actions">Quick Fix: {} <span class="color-muted">{}</span></div>'.format(link, config_name))
     return "".join(formatted)
 
 
@@ -122,7 +125,7 @@ def run(
         self._base_dir = wm.get_project_path(self.view.file_name() or "")
         self._hover_responses = []  # type: List[Tuple[Hover, Optional[MarkdownLangMap]]]
         self._document_link = ('', False, None)  # type: Tuple[str, bool, Optional[sublime.Region]]
-        self._actions_by_config = {}  # type: Dict[str, List[CodeActionOrCommand]]
+        self._actions_by_config = []  # type: List[CodeActionsByConfigName]
         self._diagnostics_by_config = []  # type: Sequence[Tuple[SessionBufferProtocol, Sequence[Diagnostic]]]
         # TODO: For code actions it makes more sense to use the whole selection under mouse (if available)
         # rather than just the hover point.
@@ -140,9 +143,9 @@ def run_async() -> None:
             if self._diagnostics_by_config:
                 self.show_hover(listener, hover_point, only_diagnostics)
             if not only_diagnostics and userprefs().show_code_actions_in_hover:
-                actions_manager.request_for_region_async(
-                    self.view, covering, self._diagnostics_by_config,
-                    functools.partial(self.handle_code_actions, listener, hover_point), manual=False)
+                actions_manager \
+                    .request_for_region_async(self.view, covering, self._diagnostics_by_config, manual=False) \
+                    .then(lambda results: self._handle_code_actions(listener, hover_point, results))
 
         sublime.set_timeout_async(run_async)
 
@@ -230,11 +233,11 @@ def _on_all_document_links_resolved(
         self._document_link = ('<br>'.join(contents) if contents else '', link_has_standard_tooltip, link_range)
         self.show_hover(listener, point, only_diagnostics=False)
 
-    def handle_code_actions(
+    def _handle_code_actions(
         self,
         listener: AbstractViewListener,
         point: int,
-        responses: Dict[str, List[CodeActionOrCommand]]
+        responses: List[CodeActionsByConfigName]
     ) -> None:
         self._actions_by_config = responses
         self.show_hover(listener, point, only_diagnostics=False)
@@ -329,20 +332,21 @@ def _on_navigate(self, href: str, point: int) -> None:
             if window:
                 open_file_uri(window, href)
         elif href.startswith('code-actions:'):
-            _, config_name = href.split(":")
-            actions = self._actions_by_config[config_name]
             self.view.run_command("lsp_selection_set", {"regions": [(point, point)]})
+            _, config_name = href.split(":")
+            actions = next(actions for name, actions in self._actions_by_config if name == config_name)
             if len(actions) > 1:
                 window = self.view.window()
                 if window:
-                    items, selected_index = format_code_actions_for_quick_panel(actions)
+                    items, selected_index = format_code_actions_for_quick_panel(
+                        map(lambda action: (config_name, action), actions))
                     window.show_quick_panel(
                         items,
-                        lambda i: self.handle_code_action_select(config_name, i),
+                        lambda i: self.handle_code_action_select(config_name, actions, i),
                         selected_index=selected_index,
                         placeholder="Code actions")
             else:
-                self.handle_code_action_select(config_name, 0)
+                self.handle_code_action_select(config_name, actions, 0)
         elif is_location_href(href):
             session_name, uri, row, col_utf16 = unpack_href_location(href)
             session = self.session_by_name(session_name)
@@ -353,12 +357,13 @@ def _on_navigate(self, href: str, point: int) -> None:
         else:
             open_in_browser(href)
 
-    def handle_code_action_select(self, config_name: str, index: int) -> None:
-        if index > -1:
+    def handle_code_action_select(self, config_name: str, actions: List[CodeActionOrCommand], index: int) -> None:
+        if index == -1:
+            return
 
-            def run_async() -> None:
-                session = self.session_by_name(config_name)
-                if session:
-                    session.run_code_action_async(self._actions_by_config[config_name][index], progress=True)
+        def run_async() -> None:
+            session = self.session_by_name(config_name)
+            if session:
+                session.run_code_action_async(actions[index], progress=True)
 
-            sublime.set_timeout_async(run_async)
+        sublime.set_timeout_async(run_async)

popups.css

@@ -22,6 +22,9 @@
     border-width: 0;
     border-radius: 0;
 }
+.color-muted {
+    color: color(var(--foreground) alpha(0.50));
+}
 .diagnostics {
     margin-bottom: 0.5rem;
     font-family: var(--mdpopups-font-mono);