Add option to show diagnostics as annotations

LSP.sublime-settings

@@ -115,6 +115,11 @@
   // See also: "diagnostics_highlight_style".
   "show_multiline_diagnostics_highlights": true,
 
+  // Show diagnostics as annotations anchored at the right side of the corresponding line.
+  // When enabled, it's recommended not to use the "annotation" value for the
+  // `show_code_actions` option as it's impossible to enforce which one gets shown first.
+  "show_diagnostics_annotations": false,
+
   // --- Hover popup --------------------------------------------------------------------
 
   // The maximum number of characters (approximately) before wrapping in the popup.

annotations.css

@@ -0,0 +1,16 @@
+.lsp_annotation {
+    margin: 0;
+    border-width: 0;
+}
+.lsp_annotation .errors {
+    color: color(var(--redish) alpha(0.85));
+}
+.lsp_annotation .warnings {
+    color: color(var(--yellowish) alpha(0.85));
+}
+.lsp_annotation .info {
+    color: color(var(--bluish) alpha(0.85));
+}
+.lsp_annotation .hints {
+    color: color(var(--bluish) alpha(0.85));
+}

plugin/core/css.py

@@ -11,6 +11,8 @@ def __init__(self) -> None:
         self.sheets = sublime.load_resource("Packages/LSP/sheets.css")
         self.sheets_classname = "lsp_sheet"
         self.inlay_hints = sublime.load_resource("Packages/LSP/inlay_hints.css")
+        self.annotations = sublime.load_resource("Packages/LSP/annotations.css")
+        self.annotations_classname = "lsp_annotation"
 
 
 _css = None  # type: Optional[CSS]

plugin/core/sessions.py

@@ -819,7 +819,7 @@ def additional_variables(cls) -> Optional[Dict[str, str]]:
     def storage_path(cls) -> str:
         """
         The storage path. Use this as your base directory to install server files. Its path is '$DATA/Package Storage'.
-        You should have an additional subdirectory preferrably the same name as your plugin. For instance:
+        You should have an additional subdirectory preferably the same name as your plugin. For instance:
 
         ```python
         from LSP.plugin import AbstractPlugin

plugin/core/types.py

@@ -110,7 +110,7 @@ def debounced(f: Callable[[], Any], timeout_ms: int = 0, condition: Callable[[],
 
     :param      f:             The function to possibly run. Its return type is discarded.
     :param      timeout_ms:    The time in milliseconds after which to possibly to run the function
-    :param      condition:     The condition that must evaluate to True in order to run the funtion
+    :param      condition:     The condition that must evaluate to True in order to run the function
     :param      async_thread:  If true, run the function on the async worker thread, otherwise run the function on the
                                main thread
     """
@@ -142,7 +142,7 @@ class DebouncerNonThreadSafe:
     the callback function will only be called once, after `timeout_ms` since the last call.
 
     This implementation is not thread safe. You must ensure that `debounce()` is called from the same thread as
-    was choosen during initialization through the `async_thread` argument.
+    was chosen during initialization through the `async_thread` argument.
     """
 
     def __init__(self, async_thread: bool) -> None:
@@ -158,7 +158,7 @@ def debounce(
 
         :param      f:             The function to possibly run
         :param      timeout_ms:    The time in milliseconds after which to possibly to run the function
-        :param      condition:     The condition that must evaluate to True in order to run the funtion
+        :param      condition:     The condition that must evaluate to True in order to run the function
         """
 
         def run(debounce_id: int) -> None:
@@ -212,6 +212,7 @@ class Settings:
     semantic_highlighting = cast(bool, None)
     show_code_actions = cast(str, None)
     show_code_lens = cast(str, None)
+    show_diagnostics_annotations = cast(bool, None)
     show_inlay_hints = cast(bool, None)
     show_code_actions_in_hover = cast(bool, None)
     show_diagnostics_count_in_view_status = cast(bool, None)
@@ -252,6 +253,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_diagnostics_annotations", False)
         r("show_inlay_hints", False)
         r("show_code_actions_in_hover", True)
         r("show_diagnostics_count_in_view_status", False)

plugin/core/views.py

@@ -859,14 +859,31 @@ def diagnostic_severity(diagnostic: Diagnostic) -> DiagnosticSeverity:
     return diagnostic.get("severity", DiagnosticSeverity.Error)
 
 
+def format_diagnostics_for_annotation(
+    diagnostics: List[Diagnostic], severity: DiagnosticSeverity, view: sublime.View
+) -> Tuple[List[str], str]:
+    css_class = DIAGNOSTIC_SEVERITY[severity - 1][1]
+    scope = DIAGNOSTIC_SEVERITY[severity - 1][2]
+    color = view.style_for_scope(scope).get('foreground') or 'red'
+    annotations = []
+    for diagnostic in diagnostics:
+        message = text2html(diagnostic.get('message') or '')
+        source = diagnostic.get('source')
+        line = "[{}] {}".format(text2html(source), message) if source else message
+        content = '<body id="annotation" class="{1}"><style>{0}</style><div class="{2}">{3}</div></body>'.format(
+            lsp_css().annotations, lsp_css().annotations_classname, css_class, line)
+        annotations.append(content)
+    return (annotations, color)
+
+
 def format_diagnostic_for_panel(diagnostic: Diagnostic) -> Tuple[str, Optional[int], Optional[str], Optional[str]]:
     """
     Turn an LSP diagnostic into a string suitable for an output panel.
 
     :param      diagnostic:  The diagnostic
     :returns:   Tuple of (content, optional offset, optional code, optional href)
                 When the last three elements are optional, don't show an inline phantom
-                When the last three elemenst are not optional, show an inline phantom
+                When the last three elements are not optional, show an inline phantom
                 using the information given.
     """
     formatted, code, href = diagnostic_source_and_code(diagnostic)

plugin/diagnostics.py

@@ -0,0 +1,49 @@
+from .core.protocol import Diagnostic
+from .core.protocol import DiagnosticSeverity
+from .core.typing import Dict, List, Tuple
+from .core.views import DIAGNOSTIC_KINDS
+from .core.views import diagnostic_severity
+from .core.views import format_diagnostics_for_annotation
+import sublime
+
+
+class DiagnosticsAnnotationsView():
+    ANNOTATIONS_REGION_KEY = "lsp_d-annotations"
+
+    @classmethod
+    def initialize_region_keys(cls, view: sublime.View) -> None:
+        r = [sublime.Region(0, 0)]
+        for severity in DIAGNOSTIC_KINDS.keys():
+            view.add_regions(cls._annotation_key(severity), r)
+
+    @classmethod
+    def _annotation_key(cls, severity: DiagnosticSeverity) -> str:
+        return '{}-{}'.format(cls.ANNOTATIONS_REGION_KEY, severity)
+
+    def __init__(self, view: sublime.View) -> None:
+        self._view = view
+
+    def clear_annotations(self) -> None:
+        for severity in DIAGNOSTIC_KINDS.keys():
+            self._view.erase_regions(self._annotation_key(severity))
+
+    def update_diagnostic_annotations_async(self, diagnostics: List[Tuple[Diagnostic, sublime.Region]]) -> None:
+        # To achieve the correct order of annotations (most severe shown first) and have the color of annotation
+        # match the diagnostic severity, we have to separately add regions for each severity, from most to least severe.
+        diagnostics_per_severity = {}  # type: Dict[DiagnosticSeverity, List[Tuple[Diagnostic, sublime.Region]]]
+        for severity in DIAGNOSTIC_KINDS.keys():
+            diagnostics_per_severity[severity] = []
+        for diagnostic, region in diagnostics:
+            diagnostics_per_severity[diagnostic_severity(diagnostic)].append((diagnostic, region))
+        flags = sublime.DRAW_NO_FILL | sublime.DRAW_NO_OUTLINE
+        for severity, diagnostics in diagnostics_per_severity.items():
+            if not diagnostics:
+                continue
+            all_diagnostics = []
+            regions = []
+            for diagnostic, region in diagnostics:
+                all_diagnostics.append(diagnostic)
+                regions.append(region)
+            annotations, color = format_diagnostics_for_annotation(all_diagnostics, severity, self._view)
+            self._view.add_regions(
+                self._annotation_key(severity), regions, flags=flags, annotations=annotations, annotation_color=color)

plugin/documents.py

@@ -44,6 +44,7 @@
 from .core.views import text_document_position_params
 from .core.views import update_lsp_popup
 from .core.windows import WindowManager
+from .diagnostics import DiagnosticsAnnotationsView
 from .hover import code_actions_content
 from .session_buffer import SessionBuffer
 from .session_view import SessionView
@@ -154,6 +155,7 @@ def on_change() -> None:
         self._registration = SettingsRegistration(view.settings(), on_change=on_change)
         self._completions_task = None  # type: Optional[QueryCompletionsTask]
         self._stored_selection = []  # type: List[sublime.Region]
+        self._diagnostics_view = DiagnosticsAnnotationsView(self.view)
         self._setup()
 
     def __del__(self) -> None:
@@ -249,7 +251,7 @@ def diagnostics_intersecting_region_async(
             for diagnostic, candidate in diagnostics:
                 # Checking against points is inclusive unlike checking whether region intersects another region
                 # which is exclusive (at region end) and we want an inclusive behavior in this case.
-                if region.contains(candidate.a) or region.contains(candidate.b):
+                if region.intersects(candidate) or region.contains(candidate.a) or region.contains(candidate.b):
                     covering = covering.cover(candidate)
                     intersections.append(diagnostic)
             if intersections:
@@ -285,6 +287,12 @@ def on_diagnostics_updated_async(self, is_view_visible: bool) -> None:
         is_active_view = window and window.active_view() == self.view
         if is_active_view and self.view.change_count() == self._change_count_on_last_save:
             self._toggle_diagnostics_panel_if_needed_async()
+        self._diagnostics_view.clear_annotations()
+        if userprefs().show_diagnostics_annotations:
+            all_diagnostics = []  # type: List[Tuple[Diagnostic, sublime.Region]]
+            for _, diagnostics in self._diagnostics_async(allow_stale=True):
+                all_diagnostics.extend(diagnostics)
+            self._diagnostics_view.update_diagnostic_annotations_async(all_diagnostics)
 
     def _update_diagnostic_in_status_bar_async(self) -> None:
         if userprefs().show_diagnostics_in_view_status:
@@ -354,7 +362,7 @@ def on_activated_async(self) -> None:
                 sb.do_inlay_hints_async(self.view)
 
     def on_selection_modified_async(self) -> None:
-        first_region, any_different = self._update_stored_selection_async()
+        first_region, _ = self._update_stored_selection_async()
         if first_region is None:
             return
         if not self._is_in_higlighted_region(first_region.b):
@@ -862,7 +870,7 @@ def _register_async(self) -> None:
     def _on_view_updated_async(self) -> None:
         self._code_lenses_debouncer_async.debounce(
             self._do_code_lenses_async, timeout_ms=self.code_lenses_debounce_time)
-        first_region, any_different = self._update_stored_selection_async()
+        first_region, _ = self._update_stored_selection_async()
         if first_region is None:
             return
         self._clear_highlight_regions()

plugin/goto_diagnostic.py

@@ -234,7 +234,7 @@ def name(self) -> str:
         return "diagnostic"
 
     def list_items(self) -> List[sublime.ListInputItem]:
-        list_items = []
+        list_items = []  # type: List[sublime.ListInputItem]
         max_severity = userprefs().diagnostics_panel_include_severity_level
         for i, session in enumerate(self.sessions):
             for diagnostic in filter(is_severity_included(max_severity),

plugin/session_view.py

@@ -13,6 +13,7 @@
 from .core.typing import Any, Iterable, List, Tuple, Optional, Dict, Generator
 from .core.views import DIAGNOSTIC_SEVERITY
 from .core.views import text_document_identifier
+from .diagnostics import DiagnosticsAnnotationsView
 from .session_buffer import SessionBuffer
 from weakref import ref
 from weakref import WeakValueDictionary
@@ -95,6 +96,9 @@ def on_before_remove(self) -> None:
             self.view.erase_regions("{}_underline".format(self.diagnostics_key(severity, True)))
         self.view.erase_regions("lsp_document_link")
         self.session_buffer.remove_session_view(self)
+        listener = self.listener()
+        if listener:
+            listener.on_diagnostics_updated_async(False)
 
     @property
     def session(self) -> Session:
@@ -155,6 +159,7 @@ def _initialize_region_keys(self) -> None:
                     self.view.add_regions("lsp_highlight_{}{}".format(kind, mode), r)
         if hover_highlight_style in ("underline", "stippled"):
             self.view.add_regions(HOVER_HIGHLIGHT_KEY, r)
+        DiagnosticsAnnotationsView.initialize_region_keys(self.view)
 
     def _clear_auto_complete_triggers(self, settings: sublime.Settings) -> None:
         '''Remove all of our modifications to the view's "auto_complete_triggers"'''

sublime-package.json

@@ -455,6 +455,11 @@
               "default": true,
               "markdownDescription": "Show the diagnostics description of the code under the cursor in status bar if available."
             },
+            "show_diagnostics_annotations": {
+              "default": false,
+              "type": "boolean",
+              "markdownDescription": "Show diagnostics as annotations anchored at the right side of the corresponding line. When enabled, it's recommended not to use the `\"annotation\"` value for the `show_code_actions` option as it's impossible to enforce which one gets shown first."
+            },
             "show_diagnostics_severity_level": {
               "type": "integer",
               "default": 4,