Merge branch 'python-refactor' into 'master'

WIP: Python implementation using pybind11 and gobject introspection

See merge request cppit/jucipp!181

src/directories.cpp

@@ -702,8 +702,11 @@ void Directories::add_or_update_path(const boost::filesystem::path &dir_path, co
         grandchild->set_value(column_record.markup, Glib::Markup::escape_text("(empty)"));
         grandchild->set_value(column_record.type, PathType::unknown);
       }
-      else
-        child->set_value(column_record.type, Source::guess_language(filename.second) ? PathType::known : PathType::unknown);
+      else {
+        auto language = Source::guess_language(filename.first);
+        if(!language)
+          child->set_value(column_record.type, PathType::unknown);
+      }
     }
   }
   if(children.empty()) {

src/source_base.cpp

@@ -78,31 +78,9 @@ Glib::RefPtr<Gsv::Language> Source::guess_language(const boost::filesystem::path
       language = language_manager->get_language("cpphdr");
     else {
       std::ifstream input(file_path.string(), std::ios::binary);
-      std::string first_chars(2, '\0');
-      if(input && input.read(&first_chars[0], static_cast<std::streamsize>(first_chars.size()))) {
-        if(first_chars == "<?") {
-          std::string next_chars(3, '\0');
-          if(input.read(&next_chars[0], static_cast<std::streamsize>(next_chars.size())) && next_chars == "xml")
-            language = language_manager->get_language("xml");
-        }
-        else if(first_chars == "#!") {
-          boost::filesystem::path interpreter;
-          input >> interpreter;
-          auto interpreter_filename = interpreter.filename().string();
-          if(interpreter_filename == "env")
-            input >> interpreter_filename;
-          if(interpreter_filename == "perl")
-            return language_manager->get_language("perl");
-          else if(interpreter_filename == "python3")
-            return language_manager->get_language("python3");
-          else if(interpreter_filename == "python")
-            return language_manager->get_language("python");
-          else if(interpreter_filename == "sh" || interpreter_filename == "bash")
-            return language_manager->get_language("sh");
-          else if(interpreter_filename == "node")
-            return language_manager->get_language("js");
-        }
-      }
+      std::string tag(5, '\0');
+      if(input && input.read(&tag[0], static_cast<std::streamsize>(tag.size())) && tag == "<?xml")
+        language = language_manager->get_language("xml");
     }
   }
   else if(language->get_id() == "cuda") {

src/source_language_protocol.cpp

@@ -277,8 +277,7 @@ LanguageProtocol::Capabilities LanguageProtocol::Client::initialize() {
     "formatting": { "dynamicRegistration": false },
     "rangeFormatting": { "dynamicRegistration": false },
     "rename": { "dynamicRegistration": false },
-    "publishDiagnostics": { "relatedInformation": true },
-    "diagnostic": { "dynamicRegistration": false, "relatedDocumentSupport": true }
+    "publishDiagnostics": { "relatedInformation":true }
   }
 },
 "initializationOptions": {
@@ -341,8 +340,6 @@ LanguageProtocol::Capabilities LanguageProtocol::Client::initialize() {
                   capabilities.workspace_folders = change_notifications->boolean_or(true); // Can be string as well
               }
             }
-            // Workaround since rust-analyzer erroneously uses both publish and pull diagnostic
-            capabilities.pull_diagnostic = language_id == "rust" ? false : boolean_or_object("diagnosticProvider");
           }
 
           // See https://clangd.llvm.org/extensions.html#utf-8-offsets for documentation on offsetEncoding
@@ -746,10 +743,7 @@ void Source::LanguageProtocolView::initialize() {
         update_status_state(this);
     }
 
-    if(capabilities.type_coverage)
-      update_type_coverage();
-    if(capabilities.pull_diagnostic)
-      pull_diagnostic();
+    update_type_coverage();
 
     initialized = true;
   };
@@ -771,7 +765,6 @@ Source::LanguageProtocolView::~LanguageProtocolView() {
   autocomplete_delayed_show_arguments_connection.disconnect();
   resolve_completion_item_connection.disconnect();
   update_type_coverage_connection.disconnect();
-  pull_diagnostic_connection.disconnect();
 
   if(initialize_thread.joinable())
     initialize_thread.join();
@@ -885,8 +878,7 @@ bool Source::LanguageProtocolView::save() {
 
   write_notification("textDocument/didSave");
 
-  if(capabilities.type_coverage)
-    update_type_coverage();
+  update_type_coverage();
 
   return true;
 }
@@ -1553,12 +1545,6 @@ void Source::LanguageProtocolView::setup_signals() {
       write_did_change_notification({{"contentChanges", "[{" + to_string({"text", '"' + JSON::escape_string(get_buffer()->get_text().raw()) + '"'}) + "}]"}});
     });
   }
-
-  if(capabilities.pull_diagnostic) {
-    get_buffer()->signal_changed().connect([this]() {
-      pull_diagnostic();
-    });
-  }
 }
 
 void Source::LanguageProtocolView::setup_autocomplete() {
@@ -2540,64 +2526,44 @@ boost::optional<char> Source::LanguageProtocolView::get_named_parameter_symbol()
 }
 
 void Source::LanguageProtocolView::update_type_coverage() {
-  write_request("textDocument/typeCoverage", {}, [this](JSON &&result, bool error) {
-    if(error) {
-      if(update_type_coverage_retries > 0) { // Retry typeCoverage request, since these requests can fail while waiting for language server to start
-        dispatcher.post([this] {
-          update_type_coverage_connection.disconnect();
-          update_type_coverage_connection = Glib::signal_timeout().connect(
-              [this]() {
-                --update_type_coverage_retries;
-                update_type_coverage();
-                return false;
-              },
-              1000);
-        });
+  if(capabilities.type_coverage) {
+    write_request("textDocument/typeCoverage", {}, [this](JSON &&result, bool error) {
+      if(error) {
+        if(update_type_coverage_retries > 0) { // Retry typeCoverage request, since these requests can fail while waiting for language server to start
+          dispatcher.post([this] {
+            update_type_coverage_connection.disconnect();
+            update_type_coverage_connection = Glib::signal_timeout().connect(
+                [this]() {
+                  --update_type_coverage_retries;
+                  update_type_coverage();
+                  return false;
+                },
+                1000);
+          });
+        }
+        return;
       }
-      return;
-    }
-    update_type_coverage_retries = 0;
+      update_type_coverage_retries = 0;
 
-    std::vector<LanguageProtocol::Range> ranges;
-    for(auto &uncovered_range : result.array_or_empty("uncoveredRanges")) {
-      try {
-        ranges.emplace_back(uncovered_range.object("range"));
-      }
-      catch(...) {
+      std::vector<LanguageProtocol::Range> ranges;
+      for(auto &uncovered_range : result.array_or_empty("uncoveredRanges")) {
+        try {
+          ranges.emplace_back(uncovered_range.object("range"));
+        }
+        catch(...) {
+        }
       }
-    }
 
-    dispatcher.post([this, ranges = std::move(ranges)] {
-      type_coverage_marks.clear();
-      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);
-        type_coverage_marks.emplace_back(start, end);
-      }
+      dispatcher.post([this, ranges = std::move(ranges)] {
+        type_coverage_marks.clear();
+        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);
+          type_coverage_marks.emplace_back(start, end);
+        }
 
-      update_diagnostics(last_diagnostics);
+        update_diagnostics(last_diagnostics);
+      });
     });
-  });
-}
-
-void Source::LanguageProtocolView::pull_diagnostic() {
-  pull_diagnostic_connection.disconnect();
-  pull_diagnostic_connection = Glib::signal_timeout().connect(
-      [this]() {
-        write_request("textDocument/diagnostic", {}, [this](JSON &&result, bool error) {
-          if(!error) {
-            std::vector<std::shared_ptr<LanguageProtocol::Diagnostic>> diagnostics;
-            for(auto &child : result.array_or_empty("items")) {
-              try {
-                diagnostics.emplace_back(std::make_shared<LanguageProtocol::Diagnostic>(std::move(child)));
-              }
-              catch(...) {
-              }
-            }
-            update_diagnostics_async(std::move(diagnostics));
-          }
-        });
-        return false;
-      },
-      1000);
+  }
 }

src/source_language_protocol.hpp

@@ -140,7 +140,6 @@ namespace LanguageProtocol {
     bool code_action_resolve = false;
     bool execute_command = false;
     bool type_coverage = false;
-    bool pull_diagnostic = false;
     bool use_line_index = false;
   };
 
@@ -308,8 +307,5 @@ namespace Source {
     size_t num_warnings = 0, num_errors = 0, num_fix_its = 0;
     void update_type_coverage();
     std::atomic<int> update_type_coverage_retries = {60};
-
-    sigc::connection pull_diagnostic_connection;
-    void pull_diagnostic();
   };
 } // namespace Source