Add use of a thread for resource loading

If use thread is enabled in the language server, threaded load from
ResourceLoader will be utilized.

Only one load task will be running at a time.

Remove unused header

Author: dekaravanhoc

modules/gdscript/language_server/gdscript_language_protocol.cpp

@@ -31,6 +31,8 @@
 #include "gdscript_language_protocol.h"
 
 #include "core/config/project_settings.h"
+#include "core/error/error_list.h"
+#include "core/io/resource_loader.h"
 #include "editor/doc_tools.h"
 #include "editor/editor_help.h"
 #include "editor/editor_log.h"
@@ -238,6 +240,8 @@ void GDScriptLanguageProtocol::poll(int p_limit_usec) {
 		on_client_connected();
 	}
 
+	scene_cache._check_thread_for_cache_update();
+
 	HashMap<int, Ref<LSPeer>>::Iterator E = clients.begin();
 	while (E != clients.end()) {
 		Ref<LSPeer> peer = E->value;
@@ -350,17 +354,17 @@ GDScriptLanguageProtocol::GDScriptLanguageProtocol() {
 	scene_cache.workspace = workspace;
 }
 
-void SceneCache::_get_owners(EditorFileSystemDirectory *efsd, String p_path, List<String> &owners) {
-	if (!efsd) {
+void SceneCache::_get_owners(EditorFileSystemDirectory *p_efsd, String p_path, List<String> &r_owners) {
+	if (!p_efsd) {
 		return;
 	}
 
-	for (int i = 0; i < efsd->get_subdir_count(); i++) {
-		_get_owners(efsd->get_subdir(i), p_path, owners);
+	for (int i = 0; i < p_efsd->get_subdir_count(); i++) {
+		_get_owners(p_efsd->get_subdir(i), p_path, r_owners);
 	}
 
-	for (int i = 0; i < efsd->get_file_count(); i++) {
-		Vector<String> deps = efsd->get_file_deps(i);
+	for (int i = 0; i < p_efsd->get_file_count(); i++) {
+		Vector<String> deps = p_efsd->get_file_deps(i);
 		bool found = false;
 		for (int j = 0; j < deps.size(); j++) {
 			if (deps[j] == p_path) {
@@ -372,19 +376,20 @@ void SceneCache::_get_owners(EditorFileSystemDirectory *efsd, String p_path, Lis
 			continue;
 		}
 
-		owners.push_back(efsd->get_file_path(i));
+		r_owners.push_back(p_efsd->get_file_path(i));
 	}
 }
 
 void SceneCache::_set_owner_scene_node(String p_path) {
-	Node *owner_scene_node = nullptr;
-	List<String> owners;
-
 	if (cache.has(p_path)) {
 		return;
 	}
 
+	Node *owner_scene_node = nullptr;
+	List<String> owners;
+
 	_get_owners(EditorFileSystem::get_singleton()->get_filesystem(), p_path, owners);
+	owners_path_cache[p_path] = owners;
 
 	for (const String &owner : owners) {
 		NodePath owner_path = owner;
@@ -399,46 +404,155 @@ void SceneCache::_set_owner_scene_node(String p_path) {
 	cache[p_path] = owner_scene_node;
 }
 
-bool SceneCache::has(const String &p_uri) {
-	return cache.has(p_uri);
+/**
+ * Does only one threaded request to the ResourceLoader at a time.
+ * Because loading the same subresources in parallel can bring up errors in the editor.
+ * */
+void SceneCache::_add_owner_scene_request(String p_path = "") {
+	if (p_path.is_empty()) {
+		if (resource_request_queue.size() > 0) {
+			p_path = resource_request_queue.front();
+		} else {
+			return;
+		}
+	}
+	if (cache.has(p_path) && resource_request_queue.size() == 0) {
+		return;
+	}
+	if (!cache.has(p_path) && !resource_request_queue.has(p_path)) {
+		resource_request_queue.push_back(p_path);
+	}
+	if (is_loading) {
+		return;
+	}
+
+	String path = resource_request_queue.front();
+	if (!owners_path_cache.has(p_path)) {
+		_get_owners(EditorFileSystem::get_singleton()->get_filesystem(), path, owners_path_cache[p_path]);
+	}
+	Error r_error = Error::FAILED;
+	while (r_error != Error::OK && owners_path_cache[p_path].size() > 0) {
+		NodePath owner_path = owners_path_cache[p_path].front()->get();
+		r_error = ResourceLoader::load_threaded_request(owner_path);
+		if (r_error != Error::OK) {
+			owners_path_cache[path].pop_front();
+		}
+	}
+	if (owners_path_cache[path].size() > 0) {
+		is_loading = true;
+	} else {
+		cache[path] = nullptr;
+		resource_request_queue.pop_front();
+		_add_owner_scene_request();
+	}
+}
+
+void SceneCache::_check_thread_for_cache_update() {
+	if (!is_loading) {
+		return;
+	}
+
+	String check_path = resource_request_queue.front();
+
+	NodePath owner_path = owners_path_cache[check_path].front()->get();
+
+	if (ResourceLoader::load_threaded_get_status(owner_path) != ResourceLoader::ThreadLoadStatus::THREAD_LOAD_LOADED) {
+		return;
+	}
+
+	is_loading = false;
+
+	Ref<PackedScene> owner_res = ResourceLoader::load_threaded_get(owner_path);
+	if (owner_res.is_valid()) {
+		cache[check_path] = owner_res->instantiate();
+		owners_path_cache.erase(check_path);
+		resource_request_queue.pop_front();
+		_add_owner_scene_request();
+		return;
+	}
+	owners_path_cache[check_path].pop_front();
+	if (owners_path_cache[check_path].size() == 0) {
+		cache[check_path] = nullptr;
+		owners_path_cache.erase(check_path);
+		resource_request_queue.pop_front();
+	}
+	_add_owner_scene_request();
+}
+
+bool SceneCache::has(const String &p_path) {
+	return cache.has(p_path);
 }
 
-Node *SceneCache::get(const String &p_uri) {
-	return cache[p_uri];
+Node *SceneCache::get(const String &p_path) {
+	bool remote_use_thread = (bool)_EDITOR_GET("network/language_server/use_thread");
+	if (remote_use_thread) {
+		_check_thread_for_cache_update();
+		_add_owner_scene_request(p_path);
+	}
+	return cache.has(p_path) ? cache[p_path] : nullptr;
 }
 
 Node *SceneCache::get_for_uri(const String &p_uri) {
 	String path = workspace->get_file_path(p_uri);
-	return cache[path];
+	return get(path);
 }
 
 void SceneCache::set(const String &p_path) {
-	_set_owner_scene_node(p_path);
+	bool remote_use_thread = (bool)_EDITOR_GET("network/language_server/use_thread");
+	if (remote_use_thread) {
+		_check_thread_for_cache_update();
+		_add_owner_scene_request(p_path);
+	} else {
+		_set_owner_scene_node(p_path);
+	}
 }
 
 void SceneCache::set_for_uri(const String &p_uri) {
 	String path = workspace->get_file_path(p_uri);
-	_set_owner_scene_node(path);
+	set(path);
 }
 
 void SceneCache::erase(const String &p_path) {
+	bool remote_use_thread = (bool)_EDITOR_GET("network/language_server/use_thread");
+	if (remote_use_thread && resource_request_queue.has(p_path)) {
+		if (is_loading && resource_request_queue.front() == p_path) {
+			while (is_loading) {
+				_check_thread_for_cache_update();
+				OS::get_singleton()->delay_usec(50000);
+			}
+		} else {
+			resource_request_queue.erase(p_path);
+		}
+	}
+	if (!cache.has(p_path)) {
+		return;
+	}
 	if (cache[p_path]) {
 		memdelete(cache[p_path]);
 	}
 	cache.erase(p_path);
+	owners_path_cache.erase(p_path);
 }
 
 void SceneCache::erase_for_uri(const String &p_uri) {
 	String path = workspace->get_file_path(p_uri);
-	memdelete(cache[path]);
-	cache.erase(path);
+	erase(path);
 }
 
 void SceneCache::clear() {
+	if (is_loading) {
+		while (is_loading) {
+			_check_thread_for_cache_update();
+			OS::get_singleton()->delay_usec(100);
+		}
+	}
+	resource_request_queue.clear();
 	for (const KeyValue<String, Node *> &E : cache) {
 		if (E.value) {
 			memdelete(E.value);
 		}
 	}
 	cache.clear();
+	owners_path_cache.clear();
+	is_loading = false;
 }

modules/gdscript/language_server/gdscript_language_protocol.h

@@ -31,6 +31,7 @@
 #ifndef GDSCRIPT_LANGUAGE_PROTOCOL_H
 #define GDSCRIPT_LANGUAGE_PROTOCOL_H
 
+#include "core/templates/hash_map.h"
 #include "core/variant/array.h"
 #include "gdscript_text_document.h"
 #include "gdscript_workspace.h"
@@ -49,17 +50,23 @@
 #define LSP_MAX_BUFFER_SIZE 4194304
 #define LSP_MAX_CLIENTS 8
 
+/**
+ * Used to load and cache scenes for autocompletion.
+ * */
 class SceneCache {
 private:
 	friend class GDScriptLanguageProtocol;
 
 	HashMap<String, Node *> cache;
 	Ref<GDScriptWorkspace> workspace;
-	String current_resource_request_path;
-	TypedArray<String> resource_request_queue;
+	bool is_loading = false;
+	HashMap<String, List<String>> owners_path_cache;
+	Array resource_request_queue;
 
-	void _get_owners(EditorFileSystemDirectory *efsd, String p_path, List<String> &owners);
+	void _get_owners(EditorFileSystemDirectory *p_efsd, String p_path, List<String> &r_owners);
 	void _set_owner_scene_node(String p_path);
+	void _add_owner_scene_request(String p_path);
+	void _check_thread_for_cache_update();
 
 public:
 	bool has(const String &p_path);

modules/gdscript/language_server/gdscript_text_document.cpp

@@ -83,6 +83,7 @@ void GDScriptTextDocument::didChange(const Variant &p_param) {
 		doc.text = evt.text;
 	}
 	sync_script_content(doc.uri, doc.text);
+	GDScriptLanguageProtocol::get_singleton()->get_scene_cache()->get_for_uri(doc.uri);
 }
 
 void GDScriptTextDocument::willSaveWaitUntil(const Variant &p_param) {

modules/gdscript/language_server/gdscript_workspace.h

@@ -31,7 +31,6 @@
 #ifndef GDSCRIPT_WORKSPACE_H
 #define GDSCRIPT_WORKSPACE_H
 
-#include "../gdscript_parser.h"
 #include "gdscript_extend_parser.h"
 #include "godot_lsp.h"
 

modules/gdscript/language_server/godot_lsp.h

@@ -34,7 +34,6 @@
 #include "core/doc_data.h"
 #include "core/object/class_db.h"
 #include "core/templates/list.h"
-#include "scene/main/node.h"
 
 namespace lsp {