Fix loading scene for every request on script file for workspace completion

For workspace completion the Scene for the script is loaded for every
completion request and freed afterwards. Resulting in performance issues
for scenes including large resources.

Loaded Scenes are now cached for each script and loaded when opening the
script. Not loading them again and only freeing them when the connection
is terminated, the language server stopped or the script is closed.

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,11 +31,14 @@
 #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"
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
+#include "scene/resources/packed_scene.h"
 
 GDScriptLanguageProtocol *GDScriptLanguageProtocol::singleton = nullptr;
 
@@ -136,6 +139,7 @@ Error GDScriptLanguageProtocol::on_client_connected() {
 
 void GDScriptLanguageProtocol::on_client_disconnected(const int &p_client_id) {
 	clients.erase(p_client_id);
+	scene_cache.clear();
 	EditorNode::get_log()->add_message("[LSP] Disconnected", EditorLog::MSG_TYPE_EDITOR);
 }
 
@@ -236,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;
@@ -281,7 +287,7 @@ void GDScriptLanguageProtocol::stop() {
 		Ref<LSPeer> peer = clients.get(E.key);
 		peer->connection->disconnect_from_host();
 	}
-
+	scene_cache.clear();
 	server->stop();
 }
 
@@ -345,4 +351,209 @@ GDScriptLanguageProtocol::GDScriptLanguageProtocol() {
 	set_scope("completionItem", text_document.ptr());
 	set_scope("workspace", workspace.ptr());
 	workspace->root = ProjectSettings::get_singleton()->get_resource_path();
+	scene_cache.workspace = workspace;
+}
+
+void SceneCache::_get_owners(EditorFileSystemDirectory *p_efsd, const String &p_path, List<String> &r_owners) {
+	if (!p_efsd) {
+		return;
+	}
+
+	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 < 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) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			continue;
+		}
+
+		r_owners.push_back(p_efsd->get_file_path(i));
+	}
+}
+
+void SceneCache::_set_owner_scene_node(const String &p_path) {
+	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;
+		Ref<Resource> owner_res = ResourceLoader::load(owner_path);
+		if (Object::cast_to<PackedScene>(owner_res.ptr())) {
+			Ref<PackedScene> owner_packed_scene = Ref<PackedScene>(Object::cast_to<PackedScene>(*owner_res));
+			owner_scene_node = owner_packed_scene->instantiate();
+			break;
+		}
+	}
+
+	cache[p_path] = owner_scene_node;
+}
+
+/**
+ * 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;
+		owners_path_cache.erase(path);
+		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_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 get(path);
+}
+
+void SceneCache::set(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);
+	} 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(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);
+	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,11 +31,14 @@
 #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"
 
 #include "core/io/stream_peer_tcp.h"
 #include "core/io/tcp_server.h"
+#include "editor/editor_file_system.h"
 
 #include "modules/modules_enabled.gen.h" // For jsonrpc.
 #ifdef MODULE_JSONRPC_ENABLED
@@ -47,6 +50,35 @@
 #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;
+	bool is_loading = false;
+	HashMap<String, List<String>> owners_path_cache; // needed to keep track of requested scenes in the ResourceLoader
+	Array resource_request_queue;
+
+	void _get_owners(EditorFileSystemDirectory *p_efsd, const String &p_path, List<String> &r_owners);
+	void _set_owner_scene_node(const String &p_path);
+	void _add_owner_scene_request(String p_path);
+	void _check_thread_for_cache_update();
+
+public:
+	bool has(const String &p_path);
+	Node *get(const String &p_path);
+	Node *get_for_uri(const String &p_uri);
+	void set(const String &p_path);
+	void set_for_uri(const String &p_uri);
+	void erase(const String &p_path);
+	void erase_for_uri(const String &p_uri);
+	void clear();
+};
+
 class GDScriptLanguageProtocol : public JSONRPC {
 	GDCLASS(GDScriptLanguageProtocol, JSONRPC)
 
@@ -74,6 +106,7 @@ class GDScriptLanguageProtocol : public JSONRPC {
 	static GDScriptLanguageProtocol *singleton;
 
 	HashMap<int, Ref<LSPeer>> clients;
+	SceneCache scene_cache;
 	Ref<TCPServer> server;
 	int latest_client_id = 0;
 	int next_client_id = 0;
@@ -101,6 +134,8 @@ class GDScriptLanguageProtocol : public JSONRPC {
 	_FORCE_INLINE_ static GDScriptLanguageProtocol *get_singleton() { return singleton; }
 	_FORCE_INLINE_ Ref<GDScriptWorkspace> get_workspace() { return workspace; }
 	_FORCE_INLINE_ Ref<GDScriptTextDocument> get_text_document() { return text_document; }
+	_FORCE_INLINE_ SceneCache *get_scene_cache() { return &scene_cache; }
+
 	_FORCE_INLINE_ bool is_initialized() const { return _initialized; }
 
 	void poll(int p_limit_usec);

modules/gdscript/language_server/gdscript_text_document.cpp

@@ -65,11 +65,12 @@ void GDScriptTextDocument::_bind_methods() {
 void GDScriptTextDocument::didOpen(const Variant &p_param) {
 	lsp::TextDocumentItem doc = load_document_item(p_param);
 	sync_script_content(doc.uri, doc.text);
+	GDScriptLanguageProtocol::get_singleton()->get_scene_cache()->set_for_uri(doc.uri);
 }
 
 void GDScriptTextDocument::didClose(const Variant &p_param) {
-	// Left empty on purpose. Godot does nothing special on closing a document,
-	// but it satisfies LSP clients that require didClose be implemented.
+	lsp::TextDocumentItem doc = load_document_item(p_param);
+	GDScriptLanguageProtocol::get_singleton()->get_scene_cache()->erase_for_uri(doc.uri);
 }
 
 void GDScriptTextDocument::didChange(const Variant &p_param) {
@@ -82,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) {