Replace most uses of Map by HashMap

* Map is unnecessary and inefficient in almost every case.
* Replaced by the new HashMap.
* Renamed Map to RBMap and Set to RBSet for cases that still make sense
  (order matters) but use is discouraged.

There were very few cases where replacing by HashMap was undesired because
keeping the key order was intended.
I tried to keep those (as RBMap) as much as possible, but might have missed
some. Review appreciated!

25 files changed, 224 insertions, 224 deletions

diff --git a/modules/gdscript/editor/gdscript_highlighter.h b/modules/gdscript/editor/gdscript_highlighter.h
index 1ae0d72896..92764e3891 100644
--- a/modules/gdscript/editor/gdscript_highlighter.h
+++ b/modules/gdscript/editor/gdscript_highlighter.h
@@ -45,7 +45,7 @@ private:
 		bool line_only = false;
 	};
 	Vector<ColorRegion> color_regions;
-	Map<int, int> color_region_cache;
+	HashMap<int, int> color_region_cache;
 
 	HashMap<StringName, Color> keywords;
 	HashMap<StringName, Color> member_keywords;
diff --git a/modules/gdscript/editor/gdscript_translation_parser_plugin.h b/modules/gdscript/editor/gdscript_translation_parser_plugin.h
index e7b40aa367..4633a431d8 100644
--- a/modules/gdscript/editor/gdscript_translation_parser_plugin.h
+++ b/modules/gdscript/editor/gdscript_translation_parser_plugin.h
@@ -31,7 +31,7 @@
 #ifndef GDSCRIPT_TRANSLATION_PARSER_PLUGIN_H
 #define GDSCRIPT_TRANSLATION_PARSER_PLUGIN_H
 
-#include "core/templates/set.h"
+#include "core/templates/rb_set.h"
 #include "editor/editor_translation_parser.h"
 #include "modules/gdscript/gdscript_parser.h"
 
@@ -44,9 +44,9 @@ class GDScriptEditorTranslationParserPlugin : public EditorTranslationParserPlug
 	// List of patterns used for extracting translation strings.
 	StringName tr_func = "tr";
 	StringName trn_func = "tr_n";
-	Set<StringName> assignment_patterns;
-	Set<StringName> first_arg_patterns;
-	Set<StringName> second_arg_patterns;
+	RBSet<StringName> assignment_patterns;
+	RBSet<StringName> first_arg_patterns;
+	RBSet<StringName> second_arg_patterns;
 	// FileDialog patterns.
 	StringName fd_add_filter = "add_filter";
 	StringName fd_set_filter = "set_filters";
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 1b4711804c..e3c9101733 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -340,14 +340,14 @@ bool GDScript::has_method(const StringName &p_method) const {
 }
 
 MethodInfo GDScript::get_method_info(const StringName &p_method) const {
-	const Map<StringName, GDScriptFunction *>::Element *E = member_functions.find(p_method);
+	HashMap<StringName, GDScriptFunction *>::ConstIterator E = member_functions.find(p_method);
 	if (!E) {
 		return MethodInfo();
 	}
 
-	GDScriptFunction *func = E->get();
+	GDScriptFunction *func = E->value;
 	MethodInfo mi;
-	mi.name = E->key();
+	mi.name = E->key;
 	for (int i = 0; i < func->get_argument_count(); i++) {
 		mi.arguments.push_back(func->get_argument_type(i));
 	}
@@ -359,9 +359,9 @@ MethodInfo GDScript::get_method_info(const StringName &p_method) const {
 bool GDScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
 #ifdef TOOLS_ENABLED
 
-	const Map<StringName, Variant>::Element *E = member_default_values_cache.find(p_property);
+	HashMap<StringName, Variant>::ConstIterator E = member_default_values_cache.find(p_property);
 	if (E) {
-		r_value = E->get();
+		r_value = E->value;
 		return true;
 	}
 
@@ -427,7 +427,7 @@ void GDScript::set_source_code(const String &p_code) {
 }
 
 #ifdef TOOLS_ENABLED
-void GDScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {
+void GDScript::_update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames) {
 	if (base_cache.is_valid()) {
 		base_cache->_update_exports_values(values, propnames);
 	}
@@ -759,12 +759,12 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 	if ((changed || p_instance_to_update) && placeholders.size()) { //hm :(
 
 		// update placeholders if any
-		Map<StringName, Variant> values;
+		HashMap<StringName, Variant> values;
 		List<PropertyInfo> propnames;
 		_update_exports_values(values, propnames);
 
 		if (changed) {
-			for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
+			for (RBSet<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
 				E->get()->update(propnames, values);
 			}
 		} else {
@@ -788,9 +788,9 @@ void GDScript::update_exports() {
 		return;
 	}
 
-	Set<ObjectID> copy = inheriters_cache; //might get modified
+	RBSet<ObjectID> copy = inheriters_cache; //might get modified
 
-	for (Set<ObjectID>::Element *E = copy.front(); E; E = E->next()) {
+	for (RBSet<ObjectID>::Element *E = copy.front(); E; E = E->next()) {
 		Object *id = ObjectDB::get_instance(E->get());
 		GDScript *s = Object::cast_to<GDScript>(id);
 		if (!s) {
@@ -929,7 +929,7 @@ ScriptLanguage *GDScript::get_language() const {
 	return GDScriptLanguage::get_singleton();
 }
 
-void GDScript::get_constants(Map<StringName, Variant> *p_constants) {
+void GDScript::get_constants(HashMap<StringName, Variant> *p_constants) {
 	if (p_constants) {
 		for (const KeyValue<StringName, Variant> &E : constants) {
 			(*p_constants)[E.key] = E.value;
@@ -937,9 +937,9 @@ void GDScript::get_constants(Map<StringName, Variant> *p_constants) {
 	}
 }
 
-void GDScript::get_members(Set<StringName> *p_members) {
+void GDScript::get_members(RBSet<StringName> *p_members) {
 	if (p_members) {
-		for (Set<StringName>::Element *E = members.front(); E; E = E->next()) {
+		for (RBSet<StringName>::Element *E = members.front(); E; E = E->next()) {
 			p_members->insert(E->get());
 		}
 	}
@@ -952,11 +952,11 @@ const Vector<Multiplayer::RPCConfig> GDScript::get_rpc_methods() const {
 Variant GDScript::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	GDScript *top = this;
 	while (top) {
-		Map<StringName, GDScriptFunction *>::Element *E = top->member_functions.find(p_method);
+		HashMap<StringName, GDScriptFunction *>::Iterator E = top->member_functions.find(p_method);
 		if (E) {
-			ERR_FAIL_COND_V_MSG(!E->get()->is_static(), Variant(), "Can't call non-static function '" + String(p_method) + "' in script.");
+			ERR_FAIL_COND_V_MSG(!E->value->is_static(), Variant(), "Can't call non-static function '" + String(p_method) + "' in script.");
 
-			return E->get()->call(nullptr, p_args, p_argcount, r_error);
+			return E->value->call(nullptr, p_args, p_argcount, r_error);
 		}
 		top = top->_base;
 	}
@@ -971,17 +971,17 @@ bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
 		const GDScript *top = this;
 		while (top) {
 			{
-				const Map<StringName, Variant>::Element *E = top->constants.find(p_name);
+				HashMap<StringName, Variant>::ConstIterator E = top->constants.find(p_name);
 				if (E) {
-					r_ret = E->get();
+					r_ret = E->value;
 					return true;
 				}
 			}
 
 			{
-				const Map<StringName, Ref<GDScript>>::Element *E = subclasses.find(p_name);
+				HashMap<StringName, Ref<GDScript>>::ConstIterator E = subclasses.find(p_name);
 				if (E) {
-					r_ret = E->get();
+					r_ret = E->value;
 					return true;
 				}
 			}
@@ -1061,7 +1061,7 @@ Error GDScript::load_source_code(const String &p_path) {
 	return OK;
 }
 
-const Map<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions() const {
+const HashMap<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions() const {
 	return member_functions;
 }
 
@@ -1209,7 +1209,7 @@ void GDScript::_init_rpc_methods_properties() {
 	}
 
 	GDScript *cscript = this;
-	Map<StringName, Ref<GDScript>>::Element *sub_E = subclasses.front();
+	HashMap<StringName, Ref<GDScript>>::Iterator sub_E = subclasses.begin();
 	while (cscript) {
 		// RPC Methods
 		for (KeyValue<StringName, GDScriptFunction *> &E : cscript->member_functions) {
@@ -1223,11 +1223,11 @@ void GDScript::_init_rpc_methods_properties() {
 		}
 
 		if (cscript != this) {
-			sub_E = sub_E->next();
+			++sub_E;
 		}
 
 		if (sub_E) {
-			cscript = sub_E->get().ptr();
+			cscript = sub_E->value.ptr();
 		} else {
 			cscript = nullptr;
 		}
@@ -1282,9 +1282,9 @@ GDScript::~GDScript() {
 bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 	//member
 	{
-		const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+		HashMap<StringName, GDScript::MemberInfo>::Iterator E = script->member_indices.find(p_name);
 		if (E) {
-			const GDScript::MemberInfo *member = &E->get();
+			const GDScript::MemberInfo *member = &E->value;
 			if (member->setter) {
 				const Variant *val = &p_value;
 				Callable::CallError err;
@@ -1325,13 +1325,13 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 
 	GDScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
+		HashMap<StringName, GDScriptFunction *>::Iterator E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
 		if (E) {
 			Variant name = p_name;
 			const Variant *args[2] = { &name, &p_value };
 
 			Callable::CallError err;
-			Variant ret = E->get()->call(this, (const Variant **)args, 2, err);
+			Variant ret = E->value->call(this, (const Variant **)args, 2, err);
 			if (err.error == Callable::CallError::CALL_OK && ret.get_type() == Variant::BOOL && ret.operator bool()) {
 				return true;
 			}
@@ -1346,16 +1346,16 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 	const GDScript *sptr = script.ptr();
 	while (sptr) {
 		{
-			const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+			HashMap<StringName, GDScript::MemberInfo>::ConstIterator E = script->member_indices.find(p_name);
 			if (E) {
-				if (E->get().getter) {
+				if (E->value.getter) {
 					Callable::CallError err;
-					r_ret = const_cast<GDScriptInstance *>(this)->callp(E->get().getter, nullptr, 0, err);
+					r_ret = const_cast<GDScriptInstance *>(this)->callp(E->value.getter, nullptr, 0, err);
 					if (err.error == Callable::CallError::CALL_OK) {
 						return true;
 					}
 				}
-				r_ret = members[E->get().index];
+				r_ret = members[E->value.index];
 				return true; //index found
 			}
 		}
@@ -1363,9 +1363,9 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 		{
 			const GDScript *sl = sptr;
 			while (sl) {
-				const Map<StringName, Variant>::Element *E = sl->constants.find(p_name);
+				HashMap<StringName, Variant>::ConstIterator E = sl->constants.find(p_name);
 				if (E) {
-					r_ret = E->get();
+					r_ret = E->value;
 					return true; //index found
 				}
 				sl = sl->_base;
@@ -1376,9 +1376,9 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 			// Signals.
 			const GDScript *sl = sptr;
 			while (sl) {
-				const Map<StringName, Vector<StringName>>::Element *E = sl->_signals.find(p_name);
+				HashMap<StringName, Vector<StringName>>::ConstIterator E = sl->_signals.find(p_name);
 				if (E) {
-					r_ret = Signal(this->owner, E->key());
+					r_ret = Signal(this->owner, E->key);
 					return true; //index found
 				}
 				sl = sl->_base;
@@ -1389,14 +1389,14 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 			// Methods.
 			const GDScript *sl = sptr;
 			while (sl) {
-				const Map<StringName, GDScriptFunction *>::Element *E = sl->member_functions.find(p_name);
+				HashMap<StringName, GDScriptFunction *>::ConstIterator E = sl->member_functions.find(p_name);
 				if (E) {
 					Multiplayer::RPCConfig config;
 					config.name = p_name;
 					if (sptr->rpc_functions.find(config) != -1) {
-						r_ret = Callable(memnew(GDScriptRPCCallable(this->owner, E->key())));
+						r_ret = Callable(memnew(GDScriptRPCCallable(this->owner, E->key)));
 					} else {
-						r_ret = Callable(this->owner, E->key());
+						r_ret = Callable(this->owner, E->key);
 					}
 					return true; //index found
 				}
@@ -1405,13 +1405,13 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 		}
 
 		{
-			const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
+			HashMap<StringName, GDScriptFunction *>::ConstIterator E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
 			if (E) {
 				Variant name = p_name;
 				const Variant *args[1] = { &name };
 
 				Callable::CallError err;
-				Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), (const Variant **)args, 1, err);
+				Variant ret = const_cast<GDScriptFunction *>(E->value)->call(const_cast<GDScriptInstance *>(this), (const Variant **)args, 1, err);
 				if (err.error == Callable::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
 					r_ret = ret;
 					return true;
@@ -1449,10 +1449,10 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 	List<PropertyInfo> props;
 
 	while (sptr) {
-		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
+		HashMap<StringName, GDScriptFunction *>::ConstIterator E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
 		if (E) {
 			Callable::CallError err;
-			Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), nullptr, 0, err);
+			Variant ret = const_cast<GDScriptFunction *>(E->value)->call(const_cast<GDScriptInstance *>(this), nullptr, 0, err);
 			if (err.error == Callable::CallError::CALL_OK) {
 				ERR_FAIL_COND_MSG(ret.get_type() != Variant::ARRAY, "Wrong type for _get_property_list, must be an array of dictionaries.");
 
@@ -1525,7 +1525,7 @@ void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
 bool GDScriptInstance::has_method(const StringName &p_method) const {
 	const GDScript *sptr = script.ptr();
 	while (sptr) {
-		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		HashMap<StringName, GDScriptFunction *>::ConstIterator E = sptr->member_functions.find(p_method);
 		if (E) {
 			return true;
 		}
@@ -1538,9 +1538,9 @@ bool GDScriptInstance::has_method(const StringName &p_method) const {
 Variant GDScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	GDScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		HashMap<StringName, GDScriptFunction *>::Iterator E = sptr->member_functions.find(p_method);
 		if (E) {
-			return E->get()->call(this, p_args, p_argcount, r_error);
+			return E->value->call(this, p_args, p_argcount, r_error);
 		}
 		sptr = sptr->_base;
 	}
@@ -1555,10 +1555,10 @@ void GDScriptInstance::notification(int p_notification) {
 
 	GDScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
+		HashMap<StringName, GDScriptFunction *>::Iterator E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
 		if (E) {
 			Callable::CallError err;
-			E->get()->call(this, args, 1, err);
+			E->value->call(this, args, 1, err);
 			if (err.error != Callable::CallError::CALL_OK) {
 				//print error about notification call
 			}
@@ -1882,7 +1882,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 
 	//when someone asks you why dynamically typed languages are easier to write....
 
-	Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
+	HashMap<Ref<GDScript>, HashMap<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
 
 	//as scripts are going to be reloaded, must proceed without locking here
 
@@ -1895,11 +1895,11 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 			continue;
 		}
 
-		to_reload.insert(script, Map<ObjectID, List<Pair<StringName, Variant>>>());
+		to_reload.insert(script, HashMap<ObjectID, List<Pair<StringName, Variant>>>());
 
 		if (!p_soft_reload) {
 			//save state and remove script from instances
-			Map<ObjectID, List<Pair<StringName, Variant>>> &map = to_reload[script];
+			HashMap<ObjectID, List<Pair<StringName, Variant>>> &map = to_reload[script];
 
 			while (script->instances.front()) {
 				Object *obj = script->instances.front()->get();
@@ -1938,7 +1938,7 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 		}
 	}
 
-	for (KeyValue<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>> &E : to_reload) {
+	for (KeyValue<Ref<GDScript>, HashMap<ObjectID, List<Pair<StringName, Variant>>>> &E : to_reload) {
 		Ref<GDScript> scr = E.key;
 		scr->reload(p_soft_reload);
 
@@ -2277,13 +2277,13 @@ void GDScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const
 }
 
 Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_name) {
-	Map<String, ObjectID>::Element *orphan_subclass_element = orphan_subclasses.find(p_qualified_name);
+	HashMap<String, ObjectID>::Iterator orphan_subclass_element = orphan_subclasses.find(p_qualified_name);
 	if (!orphan_subclass_element) {
 		return Ref<GDScript>();
 	}
-	ObjectID orphan_subclass = orphan_subclass_element->get();
+	ObjectID orphan_subclass = orphan_subclass_element->value;
 	Object *obj = ObjectDB::get_instance(orphan_subclass);
-	orphan_subclasses.erase(orphan_subclass_element);
+	orphan_subclasses.remove(orphan_subclass_element);
 	if (!obj) {
 		return Ref<GDScript>();
 	}
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index a20f3b2fca..5199d3215d 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -80,48 +80,48 @@ class GDScript : public Script {
 	GDScript *_base = nullptr; //fast pointer access
 	GDScript *_owner = nullptr; //for subclasses
 
-	Set<StringName> members; //members are just indices to the instantiated script.
-	Map<StringName, Variant> constants;
-	Map<StringName, GDScriptFunction *> member_functions;
-	Map<StringName, MemberInfo> member_indices; //members are just indices to the instantiated script.
-	Map<StringName, Ref<GDScript>> subclasses;
-	Map<StringName, Vector<StringName>> _signals;
+	RBSet<StringName> members; //members are just indices to the instantiated script.
+	HashMap<StringName, Variant> constants;
+	HashMap<StringName, GDScriptFunction *> member_functions;
+	HashMap<StringName, MemberInfo> member_indices; //members are just indices to the instantiated script.
+	HashMap<StringName, Ref<GDScript>> subclasses;
+	HashMap<StringName, Vector<StringName>> _signals;
 	Vector<Multiplayer::RPCConfig> rpc_functions;
 
 #ifdef TOOLS_ENABLED
 
-	Map<StringName, int> member_lines;
-	Map<StringName, Variant> member_default_values;
+	HashMap<StringName, int> member_lines;
+	HashMap<StringName, Variant> member_default_values;
 	List<PropertyInfo> members_cache;
-	Map<StringName, Variant> member_default_values_cache;
+	HashMap<StringName, Variant> member_default_values_cache;
 	Ref<GDScript> base_cache;
-	Set<ObjectID> inheriters_cache;
+	RBSet<ObjectID> inheriters_cache;
 	bool source_changed_cache = false;
 	bool placeholder_fallback_enabled = false;
-	void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames);
+	void _update_exports_values(HashMap<StringName, Variant> &values, List<PropertyInfo> &propnames);
 
 	DocData::ClassDoc doc;
 	Vector<DocData::ClassDoc> docs;
 	String doc_brief_description;
 	String doc_description;
 	Vector<DocData::TutorialDoc> doc_tutorials;
-	Map<String, String> doc_functions;
-	Map<String, String> doc_variables;
-	Map<String, String> doc_constants;
-	Map<String, String> doc_signals;
-	Map<String, DocData::EnumDoc> doc_enums;
+	HashMap<String, String> doc_functions;
+	HashMap<String, String> doc_variables;
+	HashMap<String, String> doc_constants;
+	HashMap<String, String> doc_signals;
+	HashMap<String, DocData::EnumDoc> doc_enums;
 	void _clear_doc();
 	void _update_doc();
 	void _add_doc(const DocData::ClassDoc &p_inner_class);
 
 #endif
-	Map<StringName, PropertyInfo> member_info;
+	HashMap<StringName, PropertyInfo> member_info;
 
 	GDScriptFunction *implicit_initializer = nullptr;
 	GDScriptFunction *initializer = nullptr; //direct pointer to new , faster to locate
 
 	int subclass_count = 0;
-	Set<Object *> instances;
+	RBSet<Object *> instances;
 	//exported members
 	String source;
 	String path;
@@ -139,14 +139,14 @@ class GDScript : public Script {
 	String _get_debug_path() const;
 
 #ifdef TOOLS_ENABLED
-	Set<PlaceHolderScriptInstance *> placeholders;
+	RBSet<PlaceHolderScriptInstance *> placeholders;
 	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override;
 #endif
 
 #ifdef DEBUG_ENABLED
 
-	Map<ObjectID, List<Pair<StringName, Variant>>> pending_reload_state;
+	HashMap<ObjectID, List<Pair<StringName, Variant>>> pending_reload_state;
 
 #endif
 
@@ -176,14 +176,14 @@ public:
 
 	bool inherits_script(const Ref<Script> &p_script) const override;
 
-	const Map<StringName, Ref<GDScript>> &get_subclasses() const { return subclasses; }
-	const Map<StringName, Variant> &get_constants() const { return constants; }
-	const Set<StringName> &get_members() const { return members; }
+	const HashMap<StringName, Ref<GDScript>> &get_subclasses() const { return subclasses; }
+	const HashMap<StringName, Variant> &get_constants() const { return constants; }
+	const RBSet<StringName> &get_members() const { return members; }
 	const GDScriptDataType &get_member_type(const StringName &p_member) const {
 		CRASH_COND(!member_indices.has(p_member));
 		return member_indices[p_member].data_type;
 	}
-	const Map<StringName, GDScriptFunction *> &get_member_functions() const { return member_functions; }
+	const HashMap<StringName, GDScriptFunction *> &get_member_functions() const { return member_functions; }
 	const Ref<GDScriptNativeClass> &get_native() const { return native; }
 	const String &get_script_class_name() const { return name; }
 
@@ -193,8 +193,8 @@ public:
 	bool is_tool() const override { return tool; }
 	Ref<GDScript> get_base() const;
 
-	const Map<StringName, MemberInfo> &debug_get_member_indices() const { return member_indices; }
-	const Map<StringName, GDScriptFunction *> &debug_get_member_functions() const; //this is debug only
+	const HashMap<StringName, MemberInfo> &debug_get_member_indices() const { return member_indices; }
+	const HashMap<StringName, GDScriptFunction *> &debug_get_member_functions() const; //this is debug only
 	StringName debug_get_member_by_index(int p_idx) const;
 
 	Variant _new(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
@@ -245,8 +245,8 @@ public:
 		return -1;
 	}
 
-	virtual void get_constants(Map<StringName, Variant> *p_constants) override;
-	virtual void get_members(Set<StringName> *p_members) override;
+	virtual void get_constants(HashMap<StringName, Variant> *p_constants) override;
+	virtual void get_members(RBSet<StringName> *p_members) override;
 
 	virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const override;
 
@@ -270,7 +270,7 @@ class GDScriptInstance : public ScriptInstance {
 	Object *owner = nullptr;
 	Ref<GDScript> script;
 #ifdef DEBUG_ENABLED
-	Map<StringName, int> member_indices_cache; //used only for hot script reloading
+	HashMap<StringName, int> member_indices_cache; //used only for hot script reloading
 #endif
 	Vector<Variant> members;
 	bool base_ref_counted;
@@ -315,8 +315,8 @@ class GDScriptLanguage : public ScriptLanguage {
 
 	Variant *_global_array = nullptr;
 	Vector<Variant> global_array;
-	Map<StringName, int> globals;
-	Map<StringName, Variant> named_globals;
+	HashMap<StringName, int> globals;
+	HashMap<StringName, Variant> named_globals;
 
 	struct CallLevel {
 		Variant *stack = nullptr;
@@ -348,7 +348,7 @@ class GDScriptLanguage : public ScriptLanguage {
 	bool profiling;
 	uint64_t script_frame_time;
 
-	Map<String, ObjectID> orphan_subclasses;
+	HashMap<String, ObjectID> orphan_subclasses;
 
 public:
 	int calls;
@@ -427,8 +427,8 @@ public:
 
 	_FORCE_INLINE_ int get_global_array_size() const { return global_array.size(); }
 	_FORCE_INLINE_ Variant *get_global_array() { return _global_array; }
-	_FORCE_INLINE_ const Map<StringName, int> &get_global_map() const { return globals; }
-	_FORCE_INLINE_ const Map<StringName, Variant> &get_named_globals_map() const { return named_globals; }
+	_FORCE_INLINE_ const HashMap<StringName, int> &get_global_map() const { return globals; }
+	_FORCE_INLINE_ const HashMap<StringName, Variant> &get_named_globals_map() const { return named_globals; }
 
 	_FORCE_INLINE_ static GDScriptLanguage *get_singleton() { return singleton; }
 
@@ -449,7 +449,7 @@ public:
 	virtual bool is_using_templates() override;
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
 	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, Set<int> *r_safe_lines = nullptr) const override;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::ScriptError> *r_errors = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, RBSet<int> *r_safe_lines = nullptr) const override;
 	virtual Script *create_script() const override;
 	virtual bool has_named_classes() const override;
 	virtual bool supports_builtin_mode() const override;
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index 85ad08ea4f..32fa3b8c87 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -898,7 +898,7 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class) {
 			}
 
 #ifdef DEBUG_ENABLED
-			Set<uint32_t> previously_ignored = parser->ignored_warning_codes;
+			RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 			for (uint32_t ignored_warning : member.function->ignored_warnings) {
 				parser->ignored_warning_codes.insert(ignored_warning);
 			}
@@ -947,7 +947,7 @@ void GDScriptAnalyzer::resolve_class_body(GDScriptParser::ClassNode *p_class) {
 		GDScriptParser::ClassNode::Member member = p_class->members[i];
 		if (member.type == GDScriptParser::ClassNode::Member::VARIABLE) {
 #ifdef DEBUG_ENABLED
-			Set<uint32_t> previously_ignored = parser->ignored_warning_codes;
+			RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 			for (uint32_t ignored_warning : member.function->ignored_warnings) {
 				parser->ignored_warning_codes.insert(ignored_warning);
 			}
@@ -1279,7 +1279,7 @@ void GDScriptAnalyzer::resolve_suite(GDScriptParser::SuiteNode *p_suite) {
 		}
 
 #ifdef DEBUG_ENABLED
-		Set<uint32_t> previously_ignored = parser->ignored_warning_codes;
+		RBSet<uint32_t> previously_ignored = parser->ignored_warning_codes;
 		for (uint32_t ignored_warning : stmt->ignored_warnings) {
 			parser->ignored_warning_codes.insert(ignored_warning);
 		}
@@ -2174,7 +2174,7 @@ void GDScriptAnalyzer::reduce_binary_op(GDScriptParser::BinaryOpNode *p_binary_o
 
 void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool p_is_await, bool p_is_root) {
 	bool all_is_constant = true;
-	Map<int, GDScriptParser::ArrayNode *> arrays; // For array literal to potentially type when passing.
+	HashMap<int, GDScriptParser::ArrayNode *> arrays; // For array literal to potentially type when passing.
 	for (int i = 0; i < p_call->arguments.size(); i++) {
 		reduce_expression(p_call->arguments[i]);
 		if (p_call->arguments[i]->type == GDScriptParser::Node::ARRAY) {
diff --git a/modules/gdscript/gdscript_analyzer.h b/modules/gdscript/gdscript_analyzer.h
index 519e1975c4..5b03f6dbb4 100644
--- a/modules/gdscript/gdscript_analyzer.h
+++ b/modules/gdscript/gdscript_analyzer.h
@@ -33,7 +33,7 @@
 
 #include "core/object/object.h"
 #include "core/object/ref_counted.h"
-#include "core/templates/set.h"
+#include "core/templates/rb_set.h"
 #include "gdscript_cache.h"
 #include "gdscript_parser.h"
 
diff --git a/modules/gdscript/gdscript_byte_codegen.h b/modules/gdscript/gdscript_byte_codegen.h
index 0503f66161..6ee8fda533 100644
--- a/modules/gdscript/gdscript_byte_codegen.h
+++ b/modules/gdscript/gdscript_byte_codegen.h
@@ -53,19 +53,19 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 	bool debug_stack = false;
 
 	Vector<int> opcodes;
-	List<Map<StringName, int>> stack_id_stack;
-	Map<StringName, int> stack_identifiers;
+	List<RBMap<StringName, int>> stack_id_stack;
+	RBMap<StringName, int> stack_identifiers;
 	List<int> stack_identifiers_counts;
-	Map<StringName, int> local_constants;
+	RBMap<StringName, int> local_constants;
 
 	Vector<StackSlot> locals;
 	Vector<StackSlot> temporaries;
 	List<int> used_temporaries;
-	Map<Variant::Type, List<int>> temporaries_pool;
+	RBMap<Variant::Type, List<int>> temporaries_pool;
 
 	List<GDScriptFunction::StackDebug> stack_debug;
-	List<Map<StringName, int>> block_identifier_stack;
-	Map<StringName, int> block_identifiers;
+	List<RBMap<StringName, int>> block_identifier_stack;
+	RBMap<StringName, int> block_identifiers;
 
 	int max_locals = 0;
 	int current_line = 0;
@@ -77,23 +77,23 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 #endif
 
 	HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
-	Map<StringName, int> name_map;
+	RBMap<StringName, int> name_map;
 #ifdef TOOLS_ENABLED
 	Vector<StringName> named_globals;
 #endif
-	Map<Variant::ValidatedOperatorEvaluator, int> operator_func_map;
-	Map<Variant::ValidatedSetter, int> setters_map;
-	Map<Variant::ValidatedGetter, int> getters_map;
-	Map<Variant::ValidatedKeyedSetter, int> keyed_setters_map;
-	Map<Variant::ValidatedKeyedGetter, int> keyed_getters_map;
-	Map<Variant::ValidatedIndexedSetter, int> indexed_setters_map;
-	Map<Variant::ValidatedIndexedGetter, int> indexed_getters_map;
-	Map<Variant::ValidatedBuiltInMethod, int> builtin_method_map;
-	Map<Variant::ValidatedConstructor, int> constructors_map;
-	Map<Variant::ValidatedUtilityFunction, int> utilities_map;
-	Map<GDScriptUtilityFunctions::FunctionPtr, int> gds_utilities_map;
-	Map<MethodBind *, int> method_bind_map;
-	Map<GDScriptFunction *, int> lambdas_map;
+	RBMap<Variant::ValidatedOperatorEvaluator, int> operator_func_map;
+	RBMap<Variant::ValidatedSetter, int> setters_map;
+	RBMap<Variant::ValidatedGetter, int> getters_map;
+	RBMap<Variant::ValidatedKeyedSetter, int> keyed_setters_map;
+	RBMap<Variant::ValidatedKeyedGetter, int> keyed_getters_map;
+	RBMap<Variant::ValidatedIndexedSetter, int> indexed_setters_map;
+	RBMap<Variant::ValidatedIndexedGetter, int> indexed_getters_map;
+	RBMap<Variant::ValidatedBuiltInMethod, int> builtin_method_map;
+	RBMap<Variant::ValidatedConstructor, int> constructors_map;
+	RBMap<Variant::ValidatedUtilityFunction, int> utilities_map;
+	RBMap<GDScriptUtilityFunctions::FunctionPtr, int> gds_utilities_map;
+	RBMap<MethodBind *, int> method_bind_map;
+	RBMap<GDScriptFunction *, int> lambdas_map;
 
 	// Lists since these can be nested.
 	List<int> if_jmp_addrs;
@@ -135,7 +135,7 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
 		stack_identifiers_counts.push_back(locals.size());
 		stack_id_stack.push_back(stack_identifiers);
 		if (debug_stack) {
-			Map<StringName, int> block_ids(block_identifiers);
+			RBMap<StringName, int> block_ids(block_identifiers);
 			block_identifier_stack.push_back(block_ids);
 			block_identifiers.clear();
 		}
diff --git a/modules/gdscript/gdscript_cache.cpp b/modules/gdscript/gdscript_cache.cpp
index 8c198345c2..bd98d66fcc 100644
--- a/modules/gdscript/gdscript_cache.cpp
+++ b/modules/gdscript/gdscript_cache.cpp
@@ -223,10 +223,10 @@ Error GDScriptCache::finish_compiling(const String &p_owner) {
 	singleton->full_gdscript_cache[p_owner] = script.ptr();
 	singleton->shallow_gdscript_cache.erase(p_owner);
 
-	Set<String> depends = singleton->dependencies[p_owner];
+	RBSet<String> depends = singleton->dependencies[p_owner];
 
 	Error err = OK;
-	for (const Set<String>::Element *E = depends.front(); E != nullptr; E = E->next()) {
+	for (const RBSet<String>::Element *E = depends.front(); E != nullptr; E = E->next()) {
 		Error this_err = OK;
 		// No need to save the script. We assume it's already referenced in the owner.
 		get_full_script(E->get(), this_err);
diff --git a/modules/gdscript/gdscript_cache.h b/modules/gdscript/gdscript_cache.h
index 3ce976ee14..8abae7d4ad 100644
--- a/modules/gdscript/gdscript_cache.h
+++ b/modules/gdscript/gdscript_cache.h
@@ -34,7 +34,7 @@
 #include "core/object/ref_counted.h"
 #include "core/os/mutex.h"
 #include "core/templates/hash_map.h"
-#include "core/templates/set.h"
+#include "core/templates/rb_set.h"
 #include "gdscript.h"
 
 class GDScriptAnalyzer;
@@ -74,7 +74,7 @@ class GDScriptCache {
 	HashMap<String, GDScriptParserRef *> parser_map;
 	HashMap<String, GDScript *> shallow_gdscript_cache;
 	HashMap<String, GDScript *> full_gdscript_cache;
-	HashMap<String, Set<String>> dependencies;
+	HashMap<String, RBSet<String>> dependencies;
 
 	friend class GDScript;
 	friend class GDScriptParserRef;
diff --git a/modules/gdscript/gdscript_compiler.cpp b/modules/gdscript/gdscript_compiler.cpp
index c194fbf9b8..cb389fd86a 100644
--- a/modules/gdscript/gdscript_compiler.cpp
+++ b/modules/gdscript/gdscript_compiler.cpp
@@ -703,10 +703,10 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 			} else if (subscript->is_attribute) {
 				if (subscript->base->type == GDScriptParser::Node::SELF && codegen.script) {
 					GDScriptParser::IdentifierNode *identifier = subscript->attribute;
-					const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
+					HashMap<StringName, GDScript::MemberInfo>::Iterator MI = codegen.script->member_indices.find(identifier->name);
 
 #ifdef DEBUG_ENABLED
-					if (MI && MI->get().getter == codegen.function_name) {
+					if (MI && MI->value.getter == codegen.function_name) {
 						String n = identifier->name;
 						_set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", identifier);
 						r_error = ERR_COMPILATION_FAILED;
@@ -714,11 +714,11 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 					}
 #endif
 
-					if (MI && MI->get().getter == "") {
+					if (MI && MI->value.getter == "") {
 						// Remove result temp as we don't need it.
 						gen->pop_temporary();
 						// Faster than indexing self (as if no self. had been used).
-						return GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::MEMBER, MI->get().index, _gdtype_from_datatype(subscript->get_datatype()));
+						return GDScriptCodeGenerator::Address(GDScriptCodeGenerator::Address::MEMBER, MI->value.index, _gdtype_from_datatype(subscript->get_datatype()));
 					}
 				}
 
@@ -894,8 +894,8 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
 				const GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(assignment->assignee);
 #ifdef DEBUG_ENABLED
 				if (subscript->is_attribute && subscript->base->type == GDScriptParser::Node::SELF && codegen.script) {
-					const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(subscript->attribute->name);
-					if (MI && MI->get().setter == codegen.function_name) {
+					HashMap<StringName, GDScript::MemberInfo>::Iterator MI = codegen.script->member_indices.find(subscript->attribute->name);
+					if (MI && MI->value.setter == codegen.function_name) {
 						String n = subscript->attribute->name;
 						_set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", subscript);
 						r_error = ERR_COMPILATION_FAILED;
@@ -2500,8 +2500,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 	//validate instances if keeping state
 
 	if (p_keep_state) {
-		for (Set<Object *>::Element *E = p_script->instances.front(); E;) {
-			Set<Object *>::Element *N = E->next();
+		for (RBSet<Object *>::Element *E = p_script->instances.front(); E;) {
+			RBSet<Object *>::Element *N = E->next();
 
 			ScriptInstance *si = E->get()->get_script_instance();
 			if (si->is_placeholder()) {
@@ -2563,7 +2563,7 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 }
 
 void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
-	Map<StringName, Ref<GDScript>> old_subclasses;
+	HashMap<StringName, Ref<GDScript>> old_subclasses;
 
 	if (p_keep_state) {
 		old_subclasses = p_script->subclasses;
diff --git a/modules/gdscript/gdscript_compiler.h b/modules/gdscript/gdscript_compiler.h
index 8d71437344..c9ffb04fb8 100644
--- a/modules/gdscript/gdscript_compiler.h
+++ b/modules/gdscript/gdscript_compiler.h
@@ -31,7 +31,7 @@
 #ifndef GDSCRIPT_COMPILER_H
 #define GDSCRIPT_COMPILER_H
 
-#include "core/templates/set.h"
+#include "core/templates/rb_set.h"
 #include "gdscript.h"
 #include "gdscript_codegen.h"
 #include "gdscript_function.h"
@@ -39,8 +39,8 @@
 
 class GDScriptCompiler {
 	const GDScriptParser *parser = nullptr;
-	Set<GDScript *> parsed_classes;
-	Set<GDScript *> parsing_classes;
+	RBSet<GDScript *> parsed_classes;
+	RBSet<GDScript *> parsing_classes;
 	GDScript *main_script = nullptr;
 
 	struct CodeGen {
@@ -49,9 +49,9 @@ class GDScriptCompiler {
 		const GDScriptParser::FunctionNode *function_node = nullptr;
 		StringName function_name;
 		GDScriptCodeGenerator *generator = nullptr;
-		Map<StringName, GDScriptCodeGenerator::Address> parameters;
-		Map<StringName, GDScriptCodeGenerator::Address> locals;
-		List<Map<StringName, GDScriptCodeGenerator::Address>> locals_stack;
+		HashMap<StringName, GDScriptCodeGenerator::Address> parameters;
+		HashMap<StringName, GDScriptCodeGenerator::Address> locals;
+		List<HashMap<StringName, GDScriptCodeGenerator::Address>> locals_stack;
 
 		GDScriptCodeGenerator::Address add_local(const StringName &p_name, const GDScriptDataType &p_type) {
 			uint32_t addr = generator->add_local(p_name, p_type);
@@ -101,7 +101,7 @@ class GDScriptCompiler {
 		}
 
 		void start_block() {
-			Map<StringName, GDScriptCodeGenerator::Address> old_locals = locals;
+			HashMap<StringName, GDScriptCodeGenerator::Address> old_locals = locals;
 			locals_stack.push_back(old_locals);
 			generator->start_block();
 		}
diff --git a/modules/gdscript/gdscript_editor.cpp b/modules/gdscript/gdscript_editor.cpp
index 226b4c24b1..72f54626e3 100644
--- a/modules/gdscript/gdscript_editor.cpp
+++ b/modules/gdscript/gdscript_editor.cpp
@@ -98,7 +98,7 @@ Vector<ScriptLanguage::ScriptTemplate> GDScriptLanguage::get_built_in_templates(
 	return templates;
 }
 
-static void get_function_names_recursively(const GDScriptParser::ClassNode *p_class, const String &p_prefix, Map<int, String> &r_funcs) {
+static void get_function_names_recursively(const GDScriptParser::ClassNode *p_class, const String &p_prefix, HashMap<int, String> &r_funcs) {
 	for (int i = 0; i < p_class->members.size(); i++) {
 		if (p_class->members[i].type == GDScriptParser::ClassNode::Member::FUNCTION) {
 			const GDScriptParser::FunctionNode *function = p_class->members[i].function;
@@ -110,7 +110,7 @@ static void get_function_names_recursively(const GDScriptParser::ClassNode *p_cl
 	}
 }
 
-bool GDScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, Set<int> *r_safe_lines) const {
+bool GDScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, RBSet<int> *r_safe_lines) const {
 	GDScriptParser parser;
 	GDScriptAnalyzer analyzer(&parser);
 
@@ -148,7 +148,7 @@ bool GDScriptLanguage::validate(const String &p_script, const String &p_path, Li
 		return false;
 	} else {
 		const GDScriptParser::ClassNode *cl = parser.get_tree();
-		Map<int, String> funcs;
+		HashMap<int, String> funcs;
 
 		get_function_names_recursively(cl, "", funcs);
 
@@ -159,7 +159,7 @@ bool GDScriptLanguage::validate(const String &p_script, const String &p_path, Li
 
 #ifdef DEBUG_ENABLED
 	if (r_safe_lines) {
-		const Set<int> &unsafe_lines = parser.get_unsafe_lines();
+		const RBSet<int> &unsafe_lines = parser.get_unsafe_lines();
 		for (int i = 1; i <= parser.get_last_line_number(); i++) {
 			if (!unsafe_lines.has(i)) {
 				r_safe_lines->insert(i);
@@ -321,7 +321,7 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *
 	Ref<GDScript> script = instance->get_script();
 	ERR_FAIL_COND(script.is_null());
 
-	const Map<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
+	const HashMap<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
 
 	for (const KeyValue<StringName, GDScript::MemberInfo> &E : mi) {
 		p_members->push_back(E.key);
@@ -343,7 +343,7 @@ ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
 }
 
 void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
-	const Map<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
+	const HashMap<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
 	const Variant *globals = GDScriptLanguage::get_singleton()->get_global_array();
 
 	List<Pair<String, Variant>> cinfo;
@@ -722,7 +722,7 @@ static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_functio
 	return arghint;
 }
 
-static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptLanguage::CodeCompletionOption> &r_list) {
+static void _get_directory_contents(EditorFileSystemDirectory *p_dir, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_list) {
 	const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
 
 	for (int i = 0; i < p_dir->get_file_count(); i++) {
@@ -736,7 +736,7 @@ static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String
 	}
 }
 
-static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
+static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	if (p_annotation->name == SNAME("@export_range")) {
 		if (p_argument == 3 || p_argument == 4) {
 			// Slider hint.
@@ -777,7 +777,7 @@ static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_a
 	}
 }
 
-static void _find_built_in_variants(Map<String, ScriptLanguage::CodeCompletionOption> &r_result, bool exclude_nil = false) {
+static void _find_built_in_variants(HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, bool exclude_nil = false) {
 	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
 		if (!exclude_nil && Variant::Type(i) == Variant::Type::NIL) {
 			ScriptLanguage::CodeCompletionOption option("null", ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
@@ -789,7 +789,7 @@ static void _find_built_in_variants(Map<String, ScriptLanguage::CodeCompletionOp
 	}
 }
 
-static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
+static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	// Built-in Variant Types
 	_find_built_in_variants(r_result, true);
 
@@ -863,7 +863,7 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 	}
 }
 
-static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
+static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	for (int i = 0; i < p_suite->locals.size(); i++) {
 		ScriptLanguage::CodeCompletionOption option;
 		if (p_suite->locals[i].type == GDScriptParser::SuiteNode::Local::CONSTANT) {
@@ -879,9 +879,9 @@ static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite,
 	}
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth);
+static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth);
 
-static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
 
 	if (!p_parent_only) {
@@ -966,7 +966,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 	_find_identifiers_in_base(base_type, p_only_functions, r_result, p_recursion_depth + 1);
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
 
 	GDScriptParser::DataType base_type = p_base.type;
@@ -998,7 +998,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 								r_result.insert(option.display, option);
 							}
 						}
-						Map<StringName, Variant> constants;
+						HashMap<StringName, Variant> constants;
 						scr->get_constants(&constants);
 						for (const KeyValue<StringName, Variant> &E : constants) {
 							int location = p_recursion_depth + _get_constant_location(scr->get_class_name(), E.key);
@@ -1149,7 +1149,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 	}
 }
 
-static void _find_identifiers(const GDScriptParser::CompletionContext &p_context, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers(const GDScriptParser::CompletionContext &p_context, bool p_only_functions, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	if (!p_only_functions && p_context.current_suite) {
 		// This includes function parameters, since they are also locals.
 		_find_identifiers_in_suite(p_context.current_suite, r_result);
@@ -2089,7 +2089,7 @@ static bool _guess_identifier_type_from_base(GDScriptParser::CompletionContext &
 			case GDScriptParser::DataType::SCRIPT: {
 				Ref<Script> scr = base_type.script_type;
 				if (scr.is_valid()) {
-					Map<StringName, Variant> constants;
+					HashMap<StringName, Variant> constants;
 					scr->get_constants(&constants);
 					if (constants.has(p_identifier)) {
 						r_type = _type_from_variant(constants[p_identifier]);
@@ -2318,7 +2318,7 @@ static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContex
 	return false;
 }
 
-static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
+static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	if (!p_enum_hint.contains(".")) {
 		// Global constant or in the current class.
 		StringName current_enum = p_enum_hint;
@@ -2355,7 +2355,7 @@ static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_co
 	}
 }
 
-static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) {
+static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) {
 	Variant base = p_base.value;
 	GDScriptParser::DataType base_type = p_base.type;
 
@@ -2474,7 +2474,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 	}
 }
 
-static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
+static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, HashMap<String, ScriptLanguage::CodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
 	if (p_call->type == GDScriptParser::Node::PRELOAD) {
 		if (p_argidx == 0 && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) {
 			_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result);
@@ -2589,7 +2589,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 	analyzer.analyze();
 
 	r_forced = false;
-	Map<String, ScriptLanguage::CodeCompletionOption> options;
+	HashMap<String, ScriptLanguage::CodeCompletionOption> options;
 
 	GDScriptParser::CompletionContext completion_context = parser.get_completion_context();
 	completion_context.base = p_owner;
@@ -3279,7 +3279,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				}
 
 				// Global.
-				Map<StringName, int> classes = GDScriptLanguage::get_singleton()->get_global_map();
+				HashMap<StringName, int> classes = GDScriptLanguage::get_singleton()->get_global_map();
 				if (classes.has(p_symbol)) {
 					Variant value = GDScriptLanguage::get_singleton()->get_global_array()[classes[p_symbol]];
 					if (value.get_type() == Variant::OBJECT) {
diff --git a/modules/gdscript/gdscript_function.cpp b/modules/gdscript/gdscript_function.cpp
index 3d708955ed..7c372afac7 100644
--- a/modules/gdscript/gdscript_function.cpp
+++ b/modules/gdscript/gdscript_function.cpp
@@ -93,7 +93,7 @@ struct _GDFKCS {
 
 void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const {
 	int oc = 0;
-	Map<StringName, _GDFKC> sdmap;
+	HashMap<StringName, _GDFKC> sdmap;
 	for (const StackDebug &sd : stack_debug) {
 		if (sd.line >= p_line) {
 			break;
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index ba0d51c5cc..d2ca795977 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -495,7 +495,7 @@ private:
 	Vector<GDScriptDataType> argument_types;
 	GDScriptDataType return_type;
 
-	Map<int, Variant::Type> temporary_slots;
+	HashMap<int, Variant::Type> temporary_slots;
 
 #ifdef TOOLS_ENABLED
 	Vector<StringName> arg_names;
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index aa1bfb312c..8563f2b432 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -3053,7 +3053,7 @@ bool GDScriptParser::has_comment(int p_line) {
 }
 
 String GDScriptParser::get_doc_comment(int p_line, bool p_single_line) {
-	const Map<int, GDScriptTokenizer::CommentData> &comments = tokenizer.get_comments();
+	const HashMap<int, GDScriptTokenizer::CommentData> &comments = tokenizer.get_comments();
 	ERR_FAIL_COND_V(!comments.has(p_line), String());
 
 	if (p_single_line) {
@@ -3105,7 +3105,7 @@ String GDScriptParser::get_doc_comment(int p_line, bool p_single_line) {
 }
 
 void GDScriptParser::get_class_doc_comment(int p_line, String &p_brief, String &p_desc, Vector<Pair<String, String>> &p_tutorials, bool p_inner_class) {
-	const Map<int, GDScriptTokenizer::CommentData> &comments = tokenizer.get_comments();
+	const HashMap<int, GDScriptTokenizer::CommentData> &comments = tokenizer.get_comments();
 	if (!comments.has(p_line)) {
 		return;
 	}
diff --git a/modules/gdscript/gdscript_parser.h b/modules/gdscript/gdscript_parser.h
index 857e06440c..17f87edeeb 100644
--- a/modules/gdscript/gdscript_parser.h
+++ b/modules/gdscript/gdscript_parser.h
@@ -39,7 +39,7 @@
 #include "core/string/ustring.h"
 #include "core/templates/hash_map.h"
 #include "core/templates/list.h"
-#include "core/templates/map.h"
+#include "core/templates/rb_map.h"
 #include "core/templates/vector.h"
 #include "core/variant/variant.h"
 #include "gdscript_cache.h"
@@ -802,7 +802,7 @@ public:
 		FunctionNode *function = nullptr;
 		FunctionNode *parent_function = nullptr;
 		Vector<IdentifierNode *> captures;
-		Map<StringName, int> captures_indices;
+		HashMap<StringName, int> captures_indices;
 		bool use_self = false;
 
 		bool has_name() const {
@@ -1205,9 +1205,9 @@ private:
 	List<ParserError> errors;
 #ifdef DEBUG_ENABLED
 	List<GDScriptWarning> warnings;
-	Set<String> ignored_warnings;
-	Set<uint32_t> ignored_warning_codes;
-	Set<int> unsafe_lines;
+	RBSet<String> ignored_warnings;
+	RBSet<uint32_t> ignored_warning_codes;
+	RBSet<int> unsafe_lines;
 #endif
 
 	GDScriptTokenizer tokenizer;
@@ -1419,7 +1419,7 @@ public:
 	}
 #ifdef DEBUG_ENABLED
 	const List<GDScriptWarning> &get_warnings() const { return warnings; }
-	const Set<int> &get_unsafe_lines() const { return unsafe_lines; }
+	const RBSet<int> &get_unsafe_lines() const { return unsafe_lines; }
 	int get_last_line_number() const { return current.end_line; }
 #endif
 
diff --git a/modules/gdscript/gdscript_tokenizer.h b/modules/gdscript/gdscript_tokenizer.h
index 75f9a7626e..ad818cf812 100644
--- a/modules/gdscript/gdscript_tokenizer.h
+++ b/modules/gdscript/gdscript_tokenizer.h
@@ -31,9 +31,9 @@
 #ifndef GDSCRIPT_TOKENIZER_H
 #define GDSCRIPT_TOKENIZER_H
 
+#include "core/templates/hash_map.h"
 #include "core/templates/list.h"
-#include "core/templates/map.h"
-#include "core/templates/set.h"
+#include "core/templates/rb_set.h"
 #include "core/templates/vector.h"
 #include "core/variant/variant.h"
 
@@ -193,7 +193,7 @@ public:
 			new_line = p_new_line;
 		}
 	};
-	const Map<int, CommentData> &get_comments() const {
+	const HashMap<int, CommentData> &get_comments() const {
 		return comments;
 	}
 #endif // TOOLS_ENABLED
@@ -226,7 +226,7 @@ private:
 	int length = 0;
 
 #ifdef TOOLS_ENABLED
-	Map<int, CommentData> comments;
+	HashMap<int, CommentData> comments;
 #endif // TOOLS_ENABLED
 
 	_FORCE_INLINE_ bool _is_at_end() { return position >= length; }
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index e28dd26c28..e7872176dd 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -2104,7 +2104,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 				const GDScript *gds = _script;
 
-				const Map<StringName, GDScriptFunction *>::Element *E = nullptr;
+				HashMap<StringName, GDScriptFunction *>::ConstIterator E;
 				while (gds->base.ptr()) {
 					gds = gds->base.ptr();
 					E = gds->member_functions.find(*methodname);
@@ -2116,7 +2116,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				Callable::CallError err;
 
 				if (E) {
-					*dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err);
+					*dst = E->value->call(p_instance, (const Variant **)argptrs, argc, err);
 				} else if (gds->native.ptr()) {
 					if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
 						MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname);
diff --git a/modules/gdscript/language_server/gdscript_extend_parser.cpp b/modules/gdscript/language_server/gdscript_extend_parser.cpp
index bc1f001d86..d3c5fed95a 100644
--- a/modules/gdscript/language_server/gdscript_extend_parser.cpp
+++ b/modules/gdscript/language_server/gdscript_extend_parser.cpp
@@ -216,8 +216,8 @@ void ExtendGDScriptParser::parse_class_symbol(const GDScriptParser::ClassNode *p
 					if (res.is_valid() && !res->get_path().is_empty()) {
 						value_text = "preload(\"" + res->get_path() + "\")";
 						if (symbol.documentation.is_empty()) {
-							if (Map<String, ExtendGDScriptParser *>::Element *S = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(res->get_path())) {
-								symbol.documentation = S->get()->class_symbol.documentation;
+							if (HashMap<String, ExtendGDScriptParser *>::Iterator S = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(res->get_path())) {
+								symbol.documentation = S->value->class_symbol.documentation;
 							}
 						}
 					} else {
diff --git a/modules/gdscript/language_server/gdscript_text_document.cpp b/modules/gdscript/language_server/gdscript_text_document.cpp
index 1f02943480..d763701911 100644
--- a/modules/gdscript/language_server/gdscript_text_document.cpp
+++ b/modules/gdscript/language_server/gdscript_text_document.cpp
@@ -141,9 +141,9 @@ Array GDScriptTextDocument::documentSymbol(const Dictionary &p_params) {
 	String uri = params["uri"];
 	String path = GDScriptLanguageProtocol::get_singleton()->get_workspace()->get_file_path(uri);
 	Array arr;
-	if (const Map<String, ExtendGDScriptParser *>::Element *parser = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(path)) {
+	if (HashMap<String, ExtendGDScriptParser *>::ConstIterator parser = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(path)) {
 		Vector<lsp::DocumentedSymbolInformation> list;
-		parser->get()->get_symbols().symbol_tree_as_list(uri, list);
+		parser->value->get_symbols().symbol_tree_as_list(uri, list);
 		for (int i = 0; i < list.size(); i++) {
 			arr.push_back(list[i].to_json());
 		}
@@ -267,8 +267,8 @@ Dictionary GDScriptTextDocument::resolve(const Dictionary &p_params) {
 			}
 
 			if (!symbol) {
-				if (const Map<String, ExtendGDScriptParser *>::Element *E = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(class_name)) {
-					symbol = E->get()->get_member_symbol(member_name, inner_class_name);
+				if (HashMap<String, ExtendGDScriptParser *>::ConstIterator E = GDScriptLanguageProtocol::get_singleton()->get_workspace()->scripts.find(class_name)) {
+					symbol = E->value->get_member_symbol(member_name, inner_class_name);
 				}
 			}
 		}
diff --git a/modules/gdscript/language_server/gdscript_workspace.cpp b/modules/gdscript/language_server/gdscript_workspace.cpp
index 378dc6d04b..d9de112bb0 100644
--- a/modules/gdscript/language_server/gdscript_workspace.cpp
+++ b/modules/gdscript/language_server/gdscript_workspace.cpp
@@ -116,22 +116,22 @@ void GDScriptWorkspace::did_delete_files(const Dictionary &p_params) {
 }
 
 void GDScriptWorkspace::remove_cache_parser(const String &p_path) {
-	Map<String, ExtendGDScriptParser *>::Element *parser = parse_results.find(p_path);
-	Map<String, ExtendGDScriptParser *>::Element *script = scripts.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator parser = parse_results.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator script = scripts.find(p_path);
 	if (parser && script) {
-		if (script->get() && script->get() == parser->get()) {
-			memdelete(script->get());
+		if (script->value && script->value == parser->value) {
+			memdelete(script->value);
 		} else {
-			memdelete(script->get());
-			memdelete(parser->get());
+			memdelete(script->value);
+			memdelete(parser->value);
 		}
 		parse_results.erase(p_path);
 		scripts.erase(p_path);
 	} else if (parser) {
-		memdelete(parser->get());
+		memdelete(parser->value);
 		parse_results.erase(p_path);
 	} else if (script) {
-		memdelete(script->get());
+		memdelete(script->value);
 		scripts.erase(p_path);
 	}
 }
@@ -141,8 +141,8 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_
 	StringName empty;
 
 	while (class_name != empty) {
-		if (const Map<StringName, lsp::DocumentSymbol>::Element *E = native_symbols.find(class_name)) {
-			const lsp::DocumentSymbol &class_symbol = E->value();
+		if (HashMap<StringName, lsp::DocumentSymbol>::ConstIterator E = native_symbols.find(class_name)) {
+			const lsp::DocumentSymbol &class_symbol = E->value;
 
 			if (p_member.is_empty()) {
 				return &class_symbol;
@@ -162,9 +162,9 @@ const lsp::DocumentSymbol *GDScriptWorkspace::get_native_symbol(const String &p_
 }
 
 const lsp::DocumentSymbol *GDScriptWorkspace::get_script_symbol(const String &p_path) const {
-	const Map<String, ExtendGDScriptParser *>::Element *S = scripts.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::ConstIterator S = scripts.find(p_path);
 	if (S) {
-		return &(S->get()->get_symbols());
+		return &(S->value->get_symbols());
 	}
 	return nullptr;
 }
@@ -209,10 +209,10 @@ void GDScriptWorkspace::reload_all_workspace_scripts() {
 		err = parse_script(path, content);
 
 		if (err != OK) {
-			Map<String, ExtendGDScriptParser *>::Element *S = parse_results.find(path);
+			HashMap<String, ExtendGDScriptParser *>::Iterator S = parse_results.find(path);
 			String err_msg = "Failed parse script " + path;
 			if (S) {
-				err_msg += "\n" + S->get()->get_errors()[0].message;
+				err_msg += "\n" + S->value->get_errors()[0].message;
 			}
 			ERR_CONTINUE_MSG(err != OK, err_msg);
 		}
@@ -238,25 +238,25 @@ void GDScriptWorkspace::list_script_files(const String &p_root_dir, List<String>
 }
 
 ExtendGDScriptParser *GDScriptWorkspace::get_parse_successed_script(const String &p_path) {
-	const Map<String, ExtendGDScriptParser *>::Element *S = scripts.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator S = scripts.find(p_path);
 	if (!S) {
 		parse_local_script(p_path);
 		S = scripts.find(p_path);
 	}
 	if (S) {
-		return S->get();
+		return S->value;
 	}
 	return nullptr;
 }
 
 ExtendGDScriptParser *GDScriptWorkspace::get_parse_result(const String &p_path) {
-	const Map<String, ExtendGDScriptParser *>::Element *S = parse_results.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator S = parse_results.find(p_path);
 	if (!S) {
 		parse_local_script(p_path);
 		S = parse_results.find(p_path);
 	}
 	if (S) {
-		return S->get();
+		return S->value;
 	}
 	return nullptr;
 }
@@ -424,8 +424,8 @@ Error GDScriptWorkspace::initialize() {
 Error GDScriptWorkspace::parse_script(const String &p_path, const String &p_content) {
 	ExtendGDScriptParser *parser = memnew(ExtendGDScriptParser);
 	Error err = parser->parse(p_content, p_path);
-	Map<String, ExtendGDScriptParser *>::Element *last_parser = parse_results.find(p_path);
-	Map<String, ExtendGDScriptParser *>::Element *last_script = scripts.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator last_parser = parse_results.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::Iterator last_script = scripts.find(p_path);
 
 	if (err == OK) {
 		remove_cache_parser(p_path);
@@ -433,8 +433,8 @@ Error GDScriptWorkspace::parse_script(const String &p_path, const String &p_cont
 		scripts[p_path] = parser;
 
 	} else {
-		if (last_parser && last_script && last_parser->get() != last_script->get()) {
-			memdelete(last_parser->get());
+		if (last_parser && last_script && last_parser->value != last_script->value) {
+			memdelete(last_parser->value);
 		}
 		parse_results[p_path] = parser;
 	}
@@ -513,9 +513,9 @@ String GDScriptWorkspace::get_file_uri(const String &p_path) const {
 void GDScriptWorkspace::publish_diagnostics(const String &p_path) {
 	Dictionary params;
 	Array errors;
-	const Map<String, ExtendGDScriptParser *>::Element *ele = parse_results.find(p_path);
+	HashMap<String, ExtendGDScriptParser *>::ConstIterator ele = parse_results.find(p_path);
 	if (ele) {
-		const Vector<lsp::Diagnostic> &list = ele->get()->get_diagnostics();
+		const Vector<lsp::Diagnostic> &list = ele->value->get_diagnostics();
 		errors.resize(list.size());
 		for (int i = 0; i < list.size(); ++i) {
 			errors[i] = list[i].to_json();
@@ -707,8 +707,8 @@ void GDScriptWorkspace::resolve_related_symbols(const lsp::TextDocumentPositionP
 }
 
 const lsp::DocumentSymbol *GDScriptWorkspace::resolve_native_symbol(const lsp::NativeSymbolInspectParams &p_params) {
-	if (Map<StringName, lsp::DocumentSymbol>::Element *E = native_symbols.find(p_params.native_class)) {
-		const lsp::DocumentSymbol &symbol = E->get();
+	if (HashMap<StringName, lsp::DocumentSymbol>::Iterator E = native_symbols.find(p_params.native_class)) {
+		const lsp::DocumentSymbol &symbol = E->value;
 		if (p_params.symbol_name.is_empty() || p_params.symbol_name == symbol.name) {
 			return &symbol;
 		}
@@ -784,7 +784,7 @@ GDScriptWorkspace::GDScriptWorkspace() {
 }
 
 GDScriptWorkspace::~GDScriptWorkspace() {
-	Set<String> cached_parsers;
+	RBSet<String> cached_parsers;
 
 	for (const KeyValue<String, ExtendGDScriptParser *> &E : parse_results) {
 		cached_parsers.insert(E.key);
@@ -794,7 +794,7 @@ GDScriptWorkspace::~GDScriptWorkspace() {
 		cached_parsers.insert(E.key);
 	}
 
-	for (Set<String>::Element *E = cached_parsers.front(); E; E = E->next()) {
+	for (RBSet<String>::Element *E = cached_parsers.front(); E; E = E->next()) {
 		remove_cache_parser(E->get());
 	}
 }
diff --git a/modules/gdscript/language_server/gdscript_workspace.h b/modules/gdscript/language_server/gdscript_workspace.h
index 92e78f8992..7bff5db81f 100644
--- a/modules/gdscript/language_server/gdscript_workspace.h
+++ b/modules/gdscript/language_server/gdscript_workspace.h
@@ -48,7 +48,7 @@ protected:
 	static void _bind_methods();
 	void remove_cache_parser(const String &p_path);
 	bool initialized = false;
-	Map<StringName, lsp::DocumentSymbol> native_symbols;
+	HashMap<StringName, lsp::DocumentSymbol> native_symbols;
 
 	const lsp::DocumentSymbol *get_native_symbol(const String &p_class, const String &p_member = "") const;
 	const lsp::DocumentSymbol *get_script_symbol(const String &p_path) const;
@@ -68,8 +68,8 @@ public:
 	String root;
 	String root_uri;
 
-	Map<String, ExtendGDScriptParser *> scripts;
-	Map<String, ExtendGDScriptParser *> parse_results;
+	HashMap<String, ExtendGDScriptParser *> scripts;
+	HashMap<String, ExtendGDScriptParser *> parse_results;
 	HashMap<StringName, ClassMembers> native_members;
 
 public:
diff --git a/modules/gdscript/language_server/lsp.hpp b/modules/gdscript/language_server/lsp.hpp
index a63f9df918..d4aa207972 100644
--- a/modules/gdscript/language_server/lsp.hpp
+++ b/modules/gdscript/language_server/lsp.hpp
@@ -261,7 +261,7 @@ struct WorkspaceEdit {
 	/**
 	 * Holds changes to existing resources.
 	 */
-	Map<String, Vector<TextEdit>> changes;
+	HashMap<String, Vector<TextEdit>> changes;
 
 	_FORCE_INLINE_ void add_edit(const String &uri, const TextEdit &edit) {
 		if (changes.has(uri)) {
@@ -293,8 +293,8 @@ struct WorkspaceEdit {
 	}
 
 	_FORCE_INLINE_ void add_change(const String &uri, const int &line, const int &start_character, const int &end_character, const String &new_text) {
-		if (Map<String, Vector<TextEdit>>::Element *E = changes.find(uri)) {
-			Vector<TextEdit> edit_list = E->value();
+		if (HashMap<String, Vector<TextEdit>>::Iterator E = changes.find(uri)) {
+			Vector<TextEdit> edit_list = E->value;
 			for (int i = 0; i < edit_list.size(); ++i) {
 				TextEdit edit = edit_list[i];
 				if (edit.range.start.character == start_character) {
@@ -310,8 +310,8 @@ struct WorkspaceEdit {
 		new_edit.range.end.line = line;
 		new_edit.range.end.character = end_character;
 
-		if (Map<String, Vector<TextEdit>>::Element *E = changes.find(uri)) {
-			E->value().push_back(new_edit);
+		if (HashMap<String, Vector<TextEdit>>::Iterator E = changes.find(uri)) {
+			E->value.push_back(new_edit);
 		} else {
 			Vector<TextEdit> edit_list;
 			edit_list.push_back(new_edit);
diff --git a/modules/gdscript/register_types.cpp b/modules/gdscript/register_types.cpp
index 59acb1c064..7cedbda804 100644
--- a/modules/gdscript/register_types.cpp
+++ b/modules/gdscript/register_types.cpp
@@ -70,7 +70,7 @@ class EditorExportGDScript : public EditorExportPlugin {
 	GDCLASS(EditorExportGDScript, EditorExportPlugin);
 
 public:
-	virtual void _export_file(const String &p_path, const String &p_type, const Set<String> &p_features) override {
+	virtual void _export_file(const String &p_path, const String &p_type, const RBSet<String> &p_features) override {
 		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		String script_key;
 
diff --git a/modules/gdscript/tests/gdscript_test_runner.cpp b/modules/gdscript/tests/gdscript_test_runner.cpp
index 71dc5de7e4..de5cd10e7c 100644
--- a/modules/gdscript/tests/gdscript_test_runner.cpp
+++ b/modules/gdscript/tests/gdscript_test_runner.cpp
@@ -543,8 +543,8 @@ GDScriptTest::TestResult GDScriptTest::execute_test_code(bool p_is_generating) {
 		return result;
 	}
 	// Test running.
-	const Map<StringName, GDScriptFunction *>::Element *test_function_element = script->get_member_functions().find(GDScriptTestRunner::test_function_name);
-	if (test_function_element == nullptr) {
+	const HashMap<StringName, GDScriptFunction *>::ConstIterator test_function_element = script->get_member_functions().find(GDScriptTestRunner::test_function_name);
+	if (!test_function_element) {
 		enable_stdout();
 		result.status = GDTEST_LOAD_ERROR;
 		result.output = "";