Merge branch 'python-refactor' into 'master'

WIP: Python implementation using pybind11 and gobject introspection

See merge request cppit/jucipp!181

src/directories.cpp

@@ -702,11 +702,8 @@ 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 {
+      else
-        auto language = Source::guess_language(filename.first);
+        child->set_value(column_record.type, Source::guess_language(filename.second) ? PathType::known : PathType::unknown);
-        if(!language)
-          child->set_value(column_record.type, PathType::unknown);
-      }
     }
   }
   if(children.empty()) {

src/source_base.cpp

@@ -78,9 +78,31 @@ 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 tag(5, '\0');
+      std::string first_chars(2, '\0');
-      if(input && input.read(&tag[0], static_cast<std::streamsize>(tag.size())) && tag == "<?xml")
+      if(input && input.read(&first_chars[0], static_cast<std::streamsize>(first_chars.size()))) {
-        language = language_manager->get_language("xml");
+        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");
+        }
+      }
     }
   }
   else if(language->get_id() == "cuda") {

src/source_language_protocol.cpp

@@ -277,7 +277,8 @@ LanguageProtocol::Capabilities LanguageProtocol::Client::initialize() {
     "formatting": { "dynamicRegistration": false },
     "rangeFormatting": { "dynamicRegistration": false },
     "rename": { "dynamicRegistration": false },
-    "publishDiagnostics": { "relatedInformation":true }
+    "publishDiagnostics": { "relatedInformation": true },
+    "diagnostic": { "dynamicRegistration": false, "relatedDocumentSupport": true }
   }
 },
 "initializationOptions": {
@@ -340,6 +341,8 @@ 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
@@ -743,7 +746,10 @@ void Source::LanguageProtocolView::initialize() {
         update_status_state(this);
     }
 
-    update_type_coverage();
+    if(capabilities.type_coverage)
+      update_type_coverage();
+    if(capabilities.pull_diagnostic)
+      pull_diagnostic();
 
     initialized = true;
   };
@@ -765,6 +771,7 @@ 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();
@@ -878,7 +885,8 @@ bool Source::LanguageProtocolView::save() {
 
   write_notification("textDocument/didSave");
 
-  update_type_coverage();
+  if(capabilities.type_coverage)
+    update_type_coverage();
 
   return true;
 }
@@ -1545,6 +1553,12 @@ 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() {
@@ -2526,44 +2540,64 @@ boost::optional<char> Source::LanguageProtocolView::get_named_parameter_symbol()
 }
 
 void Source::LanguageProtocolView::update_type_coverage() {
-  if(capabilities.type_coverage) {
+  write_request("textDocument/typeCoverage", {}, [this](JSON &&result, bool error) {
-    write_request("textDocument/typeCoverage", {}, [this](JSON &&result, bool error) {
+    if(error) {
-      if(error) {
+      if(update_type_coverage_retries > 0) { // Retry typeCoverage request, since these requests can fail while waiting for language server to start
-        if(update_type_coverage_retries > 0) { // Retry typeCoverage request, since these requests can fail while waiting for language server to start
+        dispatcher.post([this] {
-          dispatcher.post([this] {
+          update_type_coverage_connection.disconnect();
-            update_type_coverage_connection.disconnect();
+          update_type_coverage_connection = Glib::signal_timeout().connect(
-            update_type_coverage_connection = Glib::signal_timeout().connect(
+              [this]() {
-                [this]() {
+                --update_type_coverage_retries;
-                  --update_type_coverage_retries;
+                update_type_coverage();
-                  update_type_coverage();
+                return false;
-                  return false;
+              },
-                },
+              1000);
-                1000);
+        });
-          });
-        }
-        return;
       }
-      update_type_coverage_retries = 0;
+      return;
+    }
+    update_type_coverage_retries = 0;
 
-      std::vector<LanguageProtocol::Range> ranges;
+    std::vector<LanguageProtocol::Range> ranges;
-      for(auto &uncovered_range : result.array_or_empty("uncoveredRanges")) {
+    for(auto &uncovered_range : result.array_or_empty("uncoveredRanges")) {
-        try {
+      try {
-          ranges.emplace_back(uncovered_range.object("range"));
+        ranges.emplace_back(uncovered_range.object("range"));
-        }
-        catch(...) {
-        }
       }
+      catch(...) {
+      }
+    }
 
-      dispatcher.post([this, ranges = std::move(ranges)] {
+    dispatcher.post([this, ranges = std::move(ranges)] {
-        type_coverage_marks.clear();
+      type_coverage_marks.clear();
-        for(auto &range : ranges) {
+      for(auto &range : ranges) {
-          auto start = get_iter_at_line_pos(range.start.line, range.start.character);
+        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);
+        auto end = get_iter_at_line_pos(range.end.line, range.end.character);
-          type_coverage_marks.emplace_back(start, end);
+        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,6 +140,7 @@ namespace LanguageProtocol {
     bool code_action_resolve = false;
     bool execute_command = false;
     bool type_coverage = false;
+    bool pull_diagnostic = false;
     bool use_line_index = false;
   };
 
@@ -307,5 +308,8 @@ 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