Language protocol: fixed type coverage warnings

src/source_language_protocol.cc

@@ -935,68 +935,74 @@ void Source::LanguageProtocolView::escape_text(std::string &text) {
 
 void Source::LanguageProtocolView::update_diagnostics(std::vector<LanguageProtocol::Diagnostic> &&diagnostics) {
   dispatcher.post([this, diagnostics = std::move(diagnostics)]() {
-    diagnostic_offsets.clear();
+    update_diagnostics(diagnostics);
-    diagnostic_tooltips.clear();
+    last_diagnostics = std::move(diagnostics);
-    if(!capabilities.type_coverage)
+  });
-      get_buffer()->remove_tag_by_name("def:warning_underline", get_buffer()->begin(), get_buffer()->end());
+}
-    get_buffer()->remove_tag_by_name("def:error_underline", get_buffer()->begin(), get_buffer()->end());
-    if(!capabilities.type_coverage)
-      num_warnings = 0;
-    num_errors = 0;
-    num_fix_its = 0;
-    for(auto &diagnostic : diagnostics) {
-      auto start = get_iter_at_line_pos(diagnostic.range.start.line, diagnostic.range.start.character);
-      auto end = get_iter_at_line_pos(diagnostic.range.end.line, diagnostic.range.end.character);
-
-      if(start == end) {
-        if(!end.ends_line())
-          end.forward_char();
-        else
-          while(start.ends_line() && start.backward_char()) { // Move start so that diagnostic underline is visible
-          }
-      }
 
-      bool error = false;
+void Source::LanguageProtocolView::update_diagnostics(const std::vector<LanguageProtocol::Diagnostic> &diagnostics) {
-      std::string severity_tag_name;
+  diagnostic_offsets.clear();
-      if(diagnostic.severity >= 2) {
+  diagnostic_tooltips.clear();
-        severity_tag_name = "def:warning";
+  get_buffer()->remove_tag_by_name("def:warning_underline", get_buffer()->begin(), get_buffer()->end());
-        num_warnings++;
+  get_buffer()->remove_tag_by_name("def:error_underline", get_buffer()->begin(), get_buffer()->end());
-      }
+  num_warnings = 0;
-      else {
+  num_errors = 0;
-        severity_tag_name = "def:error";
+  num_fix_its = 0;
-        num_errors++;
-        error = true;
-      }
 
-      add_diagnostic_tooltip(start, end, error, [this, diagnostic = std::move(diagnostic)](const Glib::RefPtr<Gtk::TextBuffer> &buffer) {
+  for(auto &diagnostic : diagnostics) {
-        buffer->insert_at_cursor(diagnostic.message);
+    auto start = get_iter_at_line_pos(diagnostic.range.start.line, diagnostic.range.start.character);
-
+    auto end = get_iter_at_line_pos(diagnostic.range.end.line, diagnostic.range.end.character);
-        for(size_t i = 0; i < diagnostic.related_informations.size(); ++i) {
+
-          auto link = filesystem::get_relative_path(diagnostic.related_informations[i].location.file, file_path.parent_path()).string();
+    if(start == end) {
-          link += ':' + std::to_string(diagnostic.related_informations[i].location.range.start.line + 1);
+      if(!end.ends_line())
-          link += ':' + std::to_string(diagnostic.related_informations[i].location.range.start.character + 1);
+        end.forward_char();
-
+      else
-          if(i == 0)
+        while(start.ends_line() && start.backward_char()) { // Move start so that diagnostic underline is visible
-            buffer->insert_at_cursor("\n\n");
-          buffer->insert_at_cursor(diagnostic.related_informations[i].message);
-          buffer->insert_at_cursor(": ");
-          auto pos = buffer->get_insert()->get_iter();
-          buffer->insert_with_tag(pos, link, link_tag);
-          if(i != diagnostic.related_informations.size() - 1)
-            buffer->insert_at_cursor("\n");
         }
-      });
     }
 
-    for(auto &mark : type_coverage_marks)
+    bool error = false;
-      add_diagnostic_tooltip(mark.first->get_iter(), mark.second->get_iter(), false, [](const Glib::RefPtr<Gtk::TextBuffer> &buffer) {
+    std::string severity_tag_name;
-        buffer->insert_at_cursor(type_coverage_message);
+    if(diagnostic.severity >= 2) {
-      });
+      severity_tag_name = "def:warning";
+      num_warnings++;
+    }
+    else {
+      severity_tag_name = "def:error";
+      num_errors++;
+      error = true;
+    }
 
-    status_diagnostics = std::make_tuple(num_warnings, num_errors, num_fix_its);
+    add_diagnostic_tooltip(start, end, error, [this, diagnostic = std::move(diagnostic)](const Glib::RefPtr<Gtk::TextBuffer> &buffer) {
-    if(update_status_diagnostics)
+      buffer->insert_at_cursor(diagnostic.message);
-      update_status_diagnostics(this);
+
-  });
+      for(size_t i = 0; i < diagnostic.related_informations.size(); ++i) {
+        auto link = filesystem::get_relative_path(diagnostic.related_informations[i].location.file, file_path.parent_path()).string();
+        link += ':' + std::to_string(diagnostic.related_informations[i].location.range.start.line + 1);
+        link += ':' + std::to_string(diagnostic.related_informations[i].location.range.start.character + 1);
+
+        if(i == 0)
+          buffer->insert_at_cursor("\n\n");
+        buffer->insert_at_cursor(diagnostic.related_informations[i].message);
+        buffer->insert_at_cursor(": ");
+        auto pos = buffer->get_insert()->get_iter();
+        buffer->insert_with_tag(pos, link, link_tag);
+        if(i != diagnostic.related_informations.size() - 1)
+          buffer->insert_at_cursor("\n");
+      }
+    });
+  }
+
+  for(auto &mark : type_coverage_marks) {
+    add_diagnostic_tooltip(mark.first->get_iter(), mark.second->get_iter(), false, [](const Glib::RefPtr<Gtk::TextBuffer> &buffer) {
+      buffer->insert_at_cursor(type_coverage_message);
+    });
+    num_warnings++;
+  }
+
+  status_diagnostics = std::make_tuple(num_warnings, num_errors, num_fix_its);
+  if(update_status_diagnostics)
+    update_status_diagnostics(this);
 }
 
 Gtk::TextIter Source::LanguageProtocolView::get_iter_at_line_pos(int line, int pos) {
@@ -1535,27 +1541,18 @@ void Source::LanguageProtocolView::update_type_coverage() {
       }
 
       dispatcher.post([this, ranges = std::move(ranges)] {
-        num_warnings = 0;
         for(auto &mark : type_coverage_marks) {
           get_buffer()->delete_mark(mark.first);
           get_buffer()->delete_mark(mark.second);
         }
         type_coverage_marks.clear();
-        get_buffer()->remove_tag_by_name("def:warning_underline", get_buffer()->begin(), get_buffer()->end());
         for(auto &range : ranges) {
           auto start = get_iter_at_line_pos(range.start.line, range.start.character);
           auto end = get_iter_at_line_pos(range.end.line, range.end.character);
-          add_diagnostic_tooltip(start, end, false, [](const Glib::RefPtr<Gtk::TextBuffer> &buffer) {
-            buffer->insert_at_cursor(type_coverage_message);
-          });
           type_coverage_marks.emplace_back(get_buffer()->create_mark(start), get_buffer()->create_mark(end));
-
-          ++num_warnings;
         }
 
-        status_diagnostics = std::make_tuple(num_warnings, num_errors, num_fix_its);
+        update_diagnostics(last_diagnostics);
-        if(update_status_diagnostics)
-          update_status_diagnostics(this);
       });
     });
   }

src/source_language_protocol.h

@@ -154,6 +154,10 @@ namespace Source {
 
     void update_diagnostics(std::vector<LanguageProtocol::Diagnostic> &&diagnostics);
 
+  private:
+    void update_diagnostics(const std::vector<LanguageProtocol::Diagnostic> &diagnostics);
+
+  public:
     Gtk::TextIter get_iter_at_line_pos(int line, int pos) override;
 
     std::string uri;
@@ -194,6 +198,8 @@ namespace Source {
 
     bool has_named_parameters();
 
+    std::vector<LanguageProtocol::Diagnostic> last_diagnostics;
+
     sigc::connection update_type_coverage_connection;
     std::vector<std::pair<Glib::RefPtr<Gtk::TextMark>, Glib::RefPtr<Gtk::TextMark>>> type_coverage_marks;
     size_t num_warnings = 0, num_errors = 0, num_fix_its = 0;