"Goto Diagnostic" quick panels.

Default.sublime-commands

@@ -81,6 +81,15 @@
         "caption": "LSP: Goto Declaration",
         "command": "lsp_symbol_declaration",
     },
+    {
+        "caption": "LSP: Goto Diagnostic",
+        "command": "lsp_goto_diagnostic",
+        "args": {"uri": "$view_uri"}
+    },
+    {
+        "caption": "LSP: Goto Diagnostic in Project",
+        "command": "lsp_goto_diagnostic"
+    },
     {
         "caption": "LSP: Toggle Log Panel",
         "command": "lsp_toggle_server_panel",

Default.sublime-keymap

@@ -252,6 +252,33 @@
     //         }
     //     ]
     // },
+    // Goto Diagnostic
+    // {
+    //     "command": "lsp_goto_diagnostic",
+    //     "args": {
+    //         "uri": "$view_uri"
+    //     },
+    //     "keys": [
+    //         "f8"
+    //     ],
+    //     "context": [
+    //         {
+    //             "key": "setting.lsp_active"
+    //         }
+    //     ]
+    // },
+    // Goto Diagnostic in Project
+    // {
+    //     "command": "lsp_goto_diagnostic",
+    //     "keys": [
+    //         "shift+f8"
+    //     ],
+    //     "context": [
+    //         {
+    //             "key": "setting.lsp_active"
+    //         }
+    //     ]
+    // },
     // Rename
     // {
     //     "command": "lsp_symbol_rename",

Main.sublime-menu

@@ -60,6 +60,15 @@
         "caption": "LSP: Goto Implementation…",
         "command": "lsp_symbol_implementation"
       },
+      {
+        "caption": "LSP: Goto Diagnostic…",
+        "command": "lsp_goto_diagnostic",
+        "args": {"uri": "$view_uri"}
+      },
+      {
+        "caption": "LSP: Goto Diagnostic in Project…",
+        "command": "lsp_goto_diagnostic"
+      },
       {
         "caption": "LSP: Find References",
         "command": "lsp_symbol_references"

boot.py

@@ -52,6 +52,7 @@
 from .plugin.goto import LspSymbolDefinitionCommand
 from .plugin.goto import LspSymbolImplementationCommand
 from .plugin.goto import LspSymbolTypeDefinitionCommand
+from .plugin.goto_diagnostic import LspGotoDiagnosticCommand
 from .plugin.hover import LspHoverCommand
 from .plugin.panels import LspShowDiagnosticsPanelCommand
 from .plugin.panels import LspToggleServerPanelCommand

dependencies.json

@@ -1,9 +1,10 @@
 {
     "*": {
-        ">=3124": [
+        ">=4096": [
             "backrefs",
             "bracex",
             "mdpopups",
+            "pathlib",
             "pyyaml",
             "wcmatch"
         ]

plugin/core/diagnostics_manager.py

@@ -1,9 +1,12 @@
-from .protocol import Diagnostic, DiagnosticSeverity
-from .settings import userprefs
-from .typing import Callable, Iterator, List, Optional, Tuple
+from .protocol import Diagnostic, DiagnosticSeverity, DocumentUri
+from .typing import Callable, Iterator, List, Tuple, TypeVar
 from .url import parse_uri
-from .views import diagnostic_severity, format_diagnostic_for_panel
+from .views import diagnostic_severity
 from collections import OrderedDict
+import functools
+
+ParsedUri = Tuple[str, str]
+T = TypeVar('T')
 
 
 class DiagnosticsManager(OrderedDict):
@@ -17,44 +20,83 @@ class DiagnosticsManager(OrderedDict):
     #
     # https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics
 
-    def add_diagnostics_async(self, uri: str, diagnostics: List[Diagnostic]) -> None:
-        _, path = parse_uri(uri)
+    def add_diagnostics_async(self, document_uri: DocumentUri, diagnostics: List[Diagnostic]) -> None:
+        """
+        Add `diagnostics` for `document_uri` to the store, replacing previously received `diagnoscis`
+        for this `document_uri`. If `diagnostics` is the empty list, `document_uri` is removed from
+        the store. The item received is moved to the end of the store.
+        """
+        uri = parse_uri(document_uri)
         if not diagnostics:
-            # received "clear diagnostics" message for this path
-            self.pop(path, None)
+            # received "clear diagnostics" message for this uri
+            self.pop(uri, None)
             return
-        max_severity = userprefs().diagnostics_panel_include_severity_level
-        self[path] = (
-            list(
-                filter(
-                    None,
-                    (
-                        format_diagnostic_for_panel(diagnostic)
-                        for diagnostic in diagnostics
-                        if diagnostic_severity(diagnostic) <= max_severity
-                    ),
-                )
-            ),
-            len(list(filter(has_severity(DiagnosticSeverity.Error), diagnostics))),
-            len(list(filter(has_severity(DiagnosticSeverity.Warning), diagnostics))),
-        )
-        self.move_to_end(path)  # maintain incoming order
+        self[uri] = diagnostics
+        self.move_to_end(uri)  # maintain incoming order
+
+    def filter_map_diagnostics_async(self, pred: Callable[[Diagnostic], bool],
+                                     f: Callable[[ParsedUri, Diagnostic], T]) -> Iterator[Tuple[ParsedUri, List[T]]]:
+        """
+        Yields `(uri, results)` items with `results` being a list of `f(diagnostic)` for each
+        diagnostic for this `uri` with `pred(diagnostic) == True`, filtered by `bool(f(diagnostic))`.
+        Only `uri`s with non-empty `results` are returned. Each `uri` is guaranteed to be yielded
+        not more than once. Items and results are ordered as they came in from the server.
+        """
+        for uri, diagnostics in self.items():
+            results = list(filter(None, map(functools.partial(f, uri), filter(pred, diagnostics))))  # type: List[T]
+            if results:
+                yield uri, results
 
-    def diagnostics_panel_contributions_async(
-        self,
-    ) -> Iterator[Tuple[str, List[Tuple[str, Optional[int], Optional[str], Optional[str]]]]]:
-        for path, (contribution, _, _) in self.items():
-            if contribution:
-                yield path, contribution
+    def filter_map_diagnostics_flat_async(self, pred: Callable[[Diagnostic], bool],
+                                          f: Callable[[ParsedUri, Diagnostic], T]) -> Iterator[Tuple[ParsedUri, T]]:
+        """
+        Flattened variant of `filter_map_diagnostics_async()`. Yields `(uri, result)` items for each
+        of the `result`s per `uri` instead. Each `uri` can be yielded more than once. Items are
+        grouped by `uri` and each `uri` group is guaranteed to appear not more than once. Items are
+        ordered as they came in from the server.
+        """
+        for uri, results in self.filter_map_diagnostics_async(pred, f):
+            for result in results:
+                yield uri, result
 
     def sum_total_errors_and_warnings_async(self) -> Tuple[int, int]:
+        """
+        Returns `(total_errors, total_warnings)` count of all diagnostics currently in store.
+        """
         return (
-            sum(errors for _, errors, _ in self.values()),
-            sum(warnings for _, _, warnings in self.values()),
+            sum(map(severity_count(DiagnosticSeverity.Error), self.values())),
+            sum(map(severity_count(DiagnosticSeverity.Warning), self.values())),
         )
 
+    def diagnostics_by_document_uri(self, document_uri: DocumentUri) -> List[Diagnostic]:
+        """
+        Returns possibly empty list of diagnostic for `document_uri`.
+        """
+        return self.get(parse_uri(document_uri), [])
+
+    def diagnostics_by_parsed_uri(self, uri: ParsedUri) -> List[Diagnostic]:
+        """
+        Returns possibly empty list of diagnostic for `uri`.
+        """
+        return self.get(uri, [])
+
+
+def severity_count(severity: int) -> Callable[[List[Diagnostic]], int]:
+    def severity_count(diagnostics: List[Diagnostic]) -> int:
+        return len(list(filter(has_severity(severity), diagnostics)))
+
+    return severity_count
+
 
 def has_severity(severity: int) -> Callable[[Diagnostic], bool]:
     def has_severity(diagnostic: Diagnostic) -> bool:
         return diagnostic_severity(diagnostic) == severity
+
     return has_severity
+
+
+def is_severity_included(max_severity: int) -> Callable[[Diagnostic], bool]:
+    def severity_included(diagnostic: Diagnostic) -> bool:
+        return diagnostic_severity(diagnostic) <= max_severity
+
+    return severity_included

plugin/core/url.py

@@ -61,6 +61,14 @@ def parse_uri(uri: str) -> Tuple[str, str]:
     return parsed.scheme, uri
 
 
+def unparse_uri(parsed_uri: Tuple[str, str]) -> str:
+    """
+    Reverse of `parse_uri()`.
+    """
+    scheme, path = parsed_uri
+    return filename_to_uri(path) if scheme == "file" else path
+
+
 def _to_resource_uri(path: str, prefix: str) -> str:
     """
     Terrible hacks from ST core leak into packages as well.

plugin/core/views.py

@@ -647,34 +647,44 @@ def format_diagnostic_for_panel(diagnostic: Diagnostic) -> Tuple[str, Optional[i
                 When the last three elemenst are not optional, show an inline phantom
                 using the information given.
     """
-    formatted = [diagnostic_source(diagnostic)]
-    offset = None
-    href = None
-    code = diagnostic.get("code")
-    if code is not None:
-        code = str(code)
-        formatted.append(":")
-        code_description = diagnostic.get("codeDescription")
-        if code_description:
-            href = code_description["href"]
-        else:
-            formatted.append(code)
+    formatted, code, href = diagnostic_source_and_code(diagnostic)
     lines = diagnostic["message"].splitlines() or [""]
     # \u200B is the zero-width space
     result = " {:>4}:{:<4}{:<8}{} \u200B{}".format(
         diagnostic["range"]["start"]["line"] + 1,
         diagnostic["range"]["start"]["character"] + 1,
         format_severity(diagnostic_severity(diagnostic)),
         lines[0],
-        "".join(formatted)
+        formatted
     )
-    if href:
-        offset = len(result)
+    offset = len(result) if href else None
     for line in itertools.islice(lines, 1, None):
         result += "\n" + 18 * " " + line
     return result, offset, code, href
 
 
+def format_diagnostic_source_and_code(diagnostic: Diagnostic) -> str:
+    formatted, code, href = diagnostic_source_and_code(diagnostic)
+    if href is None or code is None:
+        return formatted
+    return formatted + code
+
+
+def diagnostic_source_and_code(diagnostic: Diagnostic) -> Tuple[str, Optional[str], Optional[str]]:
+    formatted = [diagnostic_source(diagnostic)]
+    href = None
+    code = diagnostic.get("code")
+    if code is not None:
+        code = str(code)
+        formatted.append(":")
+        code_description = diagnostic.get("codeDescription")
+        if code_description:
+            href = code_description["href"]
+        else:
+            formatted.append(code)
+    return "".join(formatted), code, href
+
+
 def location_to_human_readable(
     config: ClientConfig,
     base_dir: Optional[str],

plugin/core/windows.py

@@ -2,6 +2,7 @@
 from .configurations import ConfigManager
 from .configurations import WindowConfigManager
 from .diagnostics import ensure_diagnostics_panel
+from .diagnostics_manager import is_severity_included
 from .logging import debug
 from .logging import exception_log
 from .message_request_handler import MessageRequestHandler
@@ -25,6 +26,7 @@
 from .typing import Optional, Any, Dict, Deque, List, Generator, Tuple, Iterable, Sequence, Union
 from .url import parse_uri
 from .views import extract_variables
+from .views import format_diagnostic_for_panel
 from .views import make_link
 from .workspace import ProjectFolders
 from .workspace import sorted_workspace_folders
@@ -500,13 +502,15 @@ def update_diagnostics_panel_async(self) -> None:
         listeners = list(self._listeners)
         prephantoms = []  # type: List[Tuple[int, int, str, str]]
         row = 0
+        max_severity = userprefs().diagnostics_panel_include_severity_level
         contributions = OrderedDict(
         )  # type: OrderedDict[str, List[Tuple[str, Optional[int], Optional[str], Optional[str]]]]
         for session in self._sessions:
             local_errors, local_warnings = session.diagnostics_manager.sum_total_errors_and_warnings_async()
             self.total_error_count += local_errors
             self.total_warning_count += local_warnings
-            for path, contribution in session.diagnostics_manager.diagnostics_panel_contributions_async():
+            for (_, path), contribution in session.diagnostics_manager.filter_map_diagnostics_async(
+                    is_severity_included(max_severity), lambda _, diagnostic: format_diagnostic_for_panel(diagnostic)):
                 seen = path in contributions
                 contributions.setdefault(path, []).extend(contribution)
                 if not seen: