1 files changed, 153 insertions, 177 deletions

diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 9549137aef..30b64d0a7b 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -209,8 +209,9 @@ Vector2 VisualScript::get_scroll() const {
 }
 
 void VisualScript::get_function_list(List<StringName> *r_functions) const {
-	functions.get_key_list(r_functions);
-	// r_functions->sort_custom<StringName::AlphCompare>(); // Don't force sorting.
+	for (const KeyValue<StringName, Function> &E : functions) {
+		r_functions->push_back(E.key);
+	}
 }
 
 int VisualScript::get_function_node_id(const StringName &p_name) const {
@@ -229,12 +230,12 @@ void VisualScript::_node_ports_changed(int p_id) {
 	{
 		List<SequenceConnection> to_remove;
 
-		for (Set<SequenceConnection>::Element *E = sequence_connections.front(); E; E = E->next()) {
-			if (E->get().from_node == p_id && E->get().from_output >= vsn->get_output_sequence_port_count()) {
-				to_remove.push_back(E->get());
+		for (const SequenceConnection &E : sequence_connections) {
+			if (E.from_node == p_id && E.from_output >= vsn->get_output_sequence_port_count()) {
+				to_remove.push_back(E);
 			}
-			if (E->get().to_node == p_id && !vsn->has_input_sequence_port()) {
-				to_remove.push_back(E->get());
+			if (E.to_node == p_id && !vsn->has_input_sequence_port()) {
+				to_remove.push_back(E);
 			}
 		}
 
@@ -247,12 +248,12 @@ void VisualScript::_node_ports_changed(int p_id) {
 	{
 		List<DataConnection> to_remove;
 
-		for (Set<DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
-			if (E->get().from_node == p_id && E->get().from_port >= vsn->get_output_value_port_count()) {
-				to_remove.push_back(E->get());
+		for (const DataConnection &E : data_connections) {
+			if (E.from_node == p_id && E.from_port >= vsn->get_output_value_port_count()) {
+				to_remove.push_back(E);
 			}
-			if (E->get().to_node == p_id && E->get().to_port >= vsn->get_input_value_port_count()) {
-				to_remove.push_back(E->get());
+			if (E.to_node == p_id && E.to_port >= vsn->get_input_value_port_count()) {
+				to_remove.push_back(E);
 			}
 		}
 
@@ -291,9 +292,9 @@ void VisualScript::remove_node(int p_id) {
 	{
 		List<SequenceConnection> to_remove;
 
-		for (Set<SequenceConnection>::Element *E = sequence_connections.front(); E; E = E->next()) {
-			if (E->get().from_node == p_id || E->get().to_node == p_id) {
-				to_remove.push_back(E->get());
+		for (const SequenceConnection &E : sequence_connections) {
+			if (E.from_node == p_id || E.to_node == p_id) {
+				to_remove.push_back(E);
 			}
 		}
 
@@ -306,9 +307,9 @@ void VisualScript::remove_node(int p_id) {
 	{
 		List<DataConnection> to_remove;
 
-		for (Set<DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
-			if (E->get().from_node == p_id || E->get().to_node == p_id) {
-				to_remove.push_back(E->get());
+		for (const DataConnection &E : data_connections) {
+			if (E.from_node == p_id || E.to_node == p_id) {
+				to_remove.push_back(E);
 			}
 		}
 
@@ -346,7 +347,9 @@ Point2 VisualScript::get_node_position(int p_id) const {
 }
 
 void VisualScript::get_node_list(List<int> *r_nodes) const {
-	nodes.get_key_list(r_nodes);
+	for (const KeyValue<int, NodeData> &E : nodes) {
+		r_nodes->push_back(E.key);
+	}
 }
 
 void VisualScript::sequence_connect(int p_from_node, int p_from_output, int p_to_node) {
@@ -381,8 +384,8 @@ bool VisualScript::has_sequence_connection(int p_from_node, int p_from_output, i
 }
 
 void VisualScript::get_sequence_connection_list(List<SequenceConnection> *r_connection) const {
-	for (const Set<SequenceConnection>::Element *E = sequence_connections.front(); E; E = E->next()) {
-		r_connection->push_back(E->get());
+	for (const SequenceConnection &E : sequence_connections) {
+		r_connection->push_back(E);
 	}
 }
 
@@ -423,8 +426,8 @@ bool VisualScript::has_data_connection(int p_from_node, int p_from_port, int p_t
 }
 
 bool VisualScript::is_input_value_port_connected(int p_node, int p_port) const {
-	for (const Set<DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
-		if (E->get().to_node == p_node && E->get().to_port == p_port) {
+	for (const DataConnection &E : data_connections) {
+		if (E.to_node == p_node && E.to_port == p_port) {
 			return true;
 		}
 	}
@@ -432,10 +435,10 @@ bool VisualScript::is_input_value_port_connected(int p_node, int p_port) const {
 }
 
 bool VisualScript::get_input_value_port_connection_source(int p_node, int p_port, int *r_node, int *r_port) const {
-	for (const Set<DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
-		if (E->get().to_node == p_node && E->get().to_port == p_port) {
-			*r_node = E->get().from_node;
-			*r_port = E->get().from_port;
+	for (const DataConnection &E : data_connections) {
+		if (E.to_node == p_node && E.to_port == p_port) {
+			*r_node = E.from_node;
+			*r_port = E.from_port;
 			return true;
 		}
 	}
@@ -443,8 +446,8 @@ bool VisualScript::get_input_value_port_connection_source(int p_node, int p_port
 }
 
 void VisualScript::get_data_connection_list(List<DataConnection> *r_connection) const {
-	for (const Set<DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
-		r_connection->push_back(E->get());
+	for (const DataConnection &E : data_connections) {
+		r_connection->push_back(E);
 	}
 }
 
@@ -563,8 +566,9 @@ Dictionary VisualScript::_get_variable_info(const StringName &p_name) const {
 }
 
 void VisualScript::get_variable_list(List<StringName> *r_variables) const {
-	variables.get_key_list(r_variables);
-	// r_variables->sort_custom<StringName::AlphCompare>(); // Don't force it.
+	for (const KeyValue<StringName, Variable> &E : variables) {
+		r_variables->push_back(E.key);
+	}
 }
 
 void VisualScript::set_instance_base_type(const StringName &p_type) {
@@ -713,12 +717,11 @@ int VisualScript::get_available_id() const {
 	// This is infinitely increasing,
 	// so one might want to implement a better solution,
 	// if the there is a case for huge number of nodes to be added to visual script.
-	List<int> nds;
-	nodes.get_key_list(&nds);
+
 	int max = -1;
-	for (const int &E : nds) {
-		if (E > max) {
-			max = E;
+	for (const KeyValue<int, NodeData> &E : nodes) {
+		if (E.key > max) {
+			max = E.key;
 		}
 	}
 	return (max + 1);
@@ -748,24 +751,21 @@ void VisualScript::_update_placeholders() {
 		return; // No bother if no placeholders.
 	}
 	List<PropertyInfo> pinfo;
-	Map<StringName, Variant> values;
+	HashMap<StringName, Variant> values;
 
-	List<StringName> keys;
-	variables.get_key_list(&keys);
-
-	for (const StringName &E : keys) {
-		if (!variables[E]._export) {
+	for (const KeyValue<StringName, Variable> &E : variables) {
+		if (!variables[E.key]._export) {
 			continue;
 		}
 
-		PropertyInfo p = variables[E].info;
-		p.name = String(E);
+		PropertyInfo p = variables[E.key].info;
+		p.name = String(E.key);
 		pinfo.push_back(p);
-		values[p.name] = variables[E].default_value;
+		values[p.name] = variables[E.key].default_value;
 	}
 
-	for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
-		E->get()->update(pinfo, values);
+	for (PlaceHolderScriptInstance *E : placeholders) {
+		E->update(pinfo, values);
 	}
 }
 
@@ -779,20 +779,17 @@ ScriptInstance *VisualScript::instance_create(Object *p_this) {
 		placeholders.insert(sins);
 
 		List<PropertyInfo> pinfo;
-		Map<StringName, Variant> values;
+		HashMap<StringName, Variant> values;
 
-		List<StringName> keys;
-		variables.get_key_list(&keys);
-
-		for (const StringName &E : keys) {
-			if (!variables[E]._export) {
+		for (const KeyValue<StringName, Variable> &E : variables) {
+			if (!variables[E.key]._export) {
 				continue;
 			}
 
-			PropertyInfo p = variables[E].info;
-			p.name = String(E);
+			PropertyInfo p = variables[E.key].info;
+			p.name = String(E.key);
 			pinfo.push_back(p);
-			values[p.name] = variables[E].default_value;
+			values[p.name] = variables[E.key].default_value;
 		}
 		sins->update(pinfo, values);
 
@@ -872,14 +869,11 @@ bool VisualScript::get_property_default_value(const StringName &p_property, Vari
 }
 
 void VisualScript::get_script_method_list(List<MethodInfo> *p_list) const {
-	List<StringName> funcs;
-	functions.get_key_list(&funcs);
-
-	for (const StringName &E : funcs) {
+	for (const KeyValue<StringName, Function> &E : functions) {
 		MethodInfo mi;
-		mi.name = E;
-		if (functions[E].func_id >= 0) {
-			Ref<VisualScriptFunction> func = nodes[functions[E].func_id].node;
+		mi.name = E.key;
+		if (functions[E.key].func_id >= 0) {
+			Ref<VisualScriptFunction> func = nodes[functions[E.key].func_id].node;
 			if (func.is_valid()) {
 				for (int i = 0; i < func->get_argument_count(); i++) {
 					PropertyInfo arg;
@@ -930,6 +924,9 @@ void VisualScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	get_variable_list(&vars);
 
 	for (const StringName &E : vars) {
+		if (!variables[E]._export) {
+			continue;
+		}
 		PropertyInfo pi = variables[E].info;
 		pi.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 		p_list->push_back(pi);
@@ -942,10 +939,8 @@ int VisualScript::get_member_line(const StringName &p_member) const {
 
 #ifdef TOOLS_ENABLED
 bool VisualScript::are_subnodes_edited() const {
-	List<int> keys;
-	nodes.get_key_list(&keys);
-	for (const int &F : keys) {
-		if (nodes[F].node->is_edited()) {
+	for (const KeyValue<int, NodeData> &F : nodes) {
+		if (F.value.node->is_edited()) {
 			return true;
 		}
 	}
@@ -1014,15 +1009,13 @@ void VisualScript::_set_data(const Dictionary &p_data) {
 
 	// Takes all the rpc methods.
 	rpc_functions.clear();
-	List<StringName> fns;
-	functions.get_key_list(&fns);
-	for (const StringName &E : fns) {
-		if (functions[E].func_id >= 0 && nodes.has(functions[E].func_id)) {
-			Ref<VisualScriptFunction> vsf = nodes[functions[E].func_id].node;
+	for (const KeyValue<StringName, Function> &E : functions) {
+		if (E.value.func_id >= 0 && nodes.has(E.value.func_id)) {
+			Ref<VisualScriptFunction> vsf = nodes[E.value.func_id].node;
 			if (vsf.is_valid()) {
 				if (vsf->get_rpc_mode() != Multiplayer::RPC_MODE_DISABLED) {
 					Multiplayer::RPCConfig nd;
-					nd.name = E;
+					nd.name = E.key;
 					nd.rpc_mode = vsf->get_rpc_mode();
 					nd.transfer_mode = Multiplayer::TRANSFER_MODE_RELIABLE; // TODO
 					if (rpc_functions.find(nd) == -1) {
@@ -1042,13 +1035,11 @@ Dictionary VisualScript::_get_data() const {
 	d["base_type"] = base_type;
 
 	Array vars;
-	List<StringName> var_names;
-	variables.get_key_list(&var_names);
-	for (const StringName &E : var_names) {
-		Dictionary var = _get_variable_info(E);
-		var["name"] = E; // Make sure it's the right one.
-		var["default_value"] = variables[E].default_value;
-		var["export"] = variables[E]._export;
+	for (const KeyValue<StringName, Variable> &E : variables) {
+		Dictionary var = _get_variable_info(E.key);
+		var["name"] = E.key; // Make sure it's the right one.
+		var["default_value"] = E.value.default_value;
+		var["export"] = E.value._export;
 		vars.push_back(var);
 	}
 	d["variables"] = vars;
@@ -1070,40 +1061,36 @@ Dictionary VisualScript::_get_data() const {
 	d["signals"] = sigs;
 
 	Array funcs;
-	List<StringName> func_names;
-	functions.get_key_list(&func_names);
-	for (const StringName &E : func_names) {
+	for (const KeyValue<StringName, Function> &E : functions) {
 		Dictionary func;
-		func["name"] = E;
-		func["function_id"] = functions[E].func_id;
+		func["name"] = E.key;
+		func["function_id"] = E.value.func_id;
 		funcs.push_back(func);
 	}
 	d["functions"] = funcs;
 
 	Array nds;
-	List<int> node_ids;
-	nodes.get_key_list(&node_ids);
-	for (const int &F : node_ids) {
-		nds.push_back(F);
-		nds.push_back(nodes[F].pos);
-		nds.push_back(nodes[F].node);
+	for (const KeyValue<int, NodeData> &F : nodes) {
+		nds.push_back(F.key);
+		nds.push_back(F.value.pos);
+		nds.push_back(F.value.node);
 	}
 	d["nodes"] = nds;
 
 	Array seqconns;
-	for (const Set<SequenceConnection>::Element *F = sequence_connections.front(); F; F = F->next()) {
-		seqconns.push_back(F->get().from_node);
-		seqconns.push_back(F->get().from_output);
-		seqconns.push_back(F->get().to_node);
+	for (const SequenceConnection &F : sequence_connections) {
+		seqconns.push_back(F.from_node);
+		seqconns.push_back(F.from_output);
+		seqconns.push_back(F.to_node);
 	}
 	d["sequence_connections"] = seqconns;
 
 	Array dataconns;
-	for (const Set<DataConnection>::Element *F = data_connections.front(); F; F = F->next()) {
-		dataconns.push_back(F->get().from_node);
-		dataconns.push_back(F->get().from_port);
-		dataconns.push_back(F->get().to_node);
-		dataconns.push_back(F->get().to_port);
+	for (const DataConnection &F : data_connections) {
+		dataconns.push_back(F.from_node);
+		dataconns.push_back(F.from_port);
+		dataconns.push_back(F.to_node);
+		dataconns.push_back(F.to_port);
 	}
 	d["data_connections"] = dataconns;
 
@@ -1118,7 +1105,7 @@ void VisualScript::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("has_function", "name"), &VisualScript::has_function);
 	ClassDB::bind_method(D_METHOD("remove_function", "name"), &VisualScript::remove_function);
 	ClassDB::bind_method(D_METHOD("rename_function", "name", "new_name"), &VisualScript::rename_function);
-	ClassDB::bind_method(D_METHOD("set_scroll", "ofs"), &VisualScript::set_scroll);
+	ClassDB::bind_method(D_METHOD("set_scroll", "offset"), &VisualScript::set_scroll);
 	ClassDB::bind_method(D_METHOD("get_scroll"), &VisualScript::get_scroll);
 
 	ClassDB::bind_method(D_METHOD("add_node", "id", "node", "position"), &VisualScript::add_node, DEFVAL(Point2()));
@@ -1181,10 +1168,10 @@ bool VisualScript::inherits_script(const Ref<Script> &p_script) const {
 	return this == p_script.ptr(); // There is no inheritance in visual scripts, so this is enough.
 }
 
-Set<int> VisualScript::get_output_sequence_ports_connected(int from_node) {
+RBSet<int> VisualScript::get_output_sequence_ports_connected(int from_node) {
 	List<VisualScript::SequenceConnection> *sc = memnew(List<VisualScript::SequenceConnection>);
 	get_sequence_connection_list(sc);
-	Set<int> connected;
+	RBSet<int> connected;
 	for (List<VisualScript::SequenceConnection>::Element *E = sc->front(); E; E = E->next()) {
 		if (E->get().from_node == from_node) {
 			connected.insert(E->get().from_output);
@@ -1196,45 +1183,41 @@ Set<int> VisualScript::get_output_sequence_ports_connected(int from_node) {
 
 VisualScript::~VisualScript() {
 	// Remove all nodes and stuff that hold data refs.
-	List<int> nds;
-	nodes.get_key_list(&nds);
-	for (const int &E : nds) {
-		remove_node(E);
+	for (const KeyValue<int, NodeData> &E : nodes) {
+		remove_node(E.key);
 	}
 }
 
 ////////////////////////////////////////////
 
 bool VisualScriptInstance::set(const StringName &p_name, const Variant &p_value) {
-	Map<StringName, Variant>::Element *E = variables.find(p_name);
+	HashMap<StringName, Variant>::Iterator E = variables.find(p_name);
 	if (!E) {
 		return false;
 	}
 
-	E->get() = p_value;
+	E->value = p_value;
 
 	return true;
 }
 
 bool VisualScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
-	const Map<StringName, Variant>::Element *E = variables.find(p_name);
+	HashMap<StringName, Variant>::ConstIterator E = variables.find(p_name);
 	if (!E) {
 		return false;
 	}
 
-	r_ret = E->get();
+	r_ret = E->value;
 	return true;
 }
 
 void VisualScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
-	List<StringName> vars;
-	script->variables.get_key_list(&vars);
-	for (const StringName &E : vars) {
-		if (!script->variables[E]._export) {
+	for (const KeyValue<StringName, VisualScript::Variable> &E : script->variables) {
+		if (!E.value._export) {
 			continue;
 		}
-		PropertyInfo p = script->variables[E].info;
-		p.name = String(E);
+		PropertyInfo p = E.value.info;
+		p.name = String(E.key);
 		p.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 		p_properties->push_back(p);
 	}
@@ -1256,13 +1239,11 @@ Variant::Type VisualScriptInstance::get_property_type(const StringName &p_name,
 }
 
 void VisualScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
-	List<StringName> fns;
-	script->functions.get_key_list(&fns);
-	for (const StringName &E : fns) {
+	for (const KeyValue<StringName, VisualScript::Function> &E : script->functions) {
 		MethodInfo mi;
-		mi.name = E;
-		if (script->functions[E].func_id >= 0 && script->nodes.has(script->functions[E].func_id)) {
-			Ref<VisualScriptFunction> vsf = script->nodes[script->functions[E].func_id].node;
+		mi.name = E.key;
+		if (E.value.func_id >= 0 && script->nodes.has(E.value.func_id)) {
+			Ref<VisualScriptFunction> vsf = script->nodes[E.value.func_id].node;
 			if (vsf.is_valid()) {
 				for (int i = 0; i < vsf->get_argument_count(); i++) {
 					PropertyInfo arg;
@@ -1334,9 +1315,9 @@ void VisualScriptInstance::_dependency_step(VisualScriptNodeInstance *node, int
 }
 
 Variant VisualScriptInstance::_call_internal(const StringName &p_method, void *p_stack, int p_stack_size, VisualScriptNodeInstance *p_node, int p_flow_stack_pos, int p_pass, bool p_resuming_yield, Callable::CallError &r_error) {
-	Map<StringName, Function>::Element *F = functions.find(p_method);
+	HashMap<StringName, Function>::Iterator F = functions.find(p_method);
 	ERR_FAIL_COND_V(!F, Variant());
-	Function *f = &F->get();
+	Function *f = &F->value;
 
 	// This call goes separate, so it can be yielded and suspended.
 	Variant *variant_stack = (Variant *)p_stack;
@@ -1547,7 +1528,7 @@ Variant VisualScriptInstance::_call_internal(const StringName &p_method, void *p
 			// If no exit bit was set, and has sequence outputs, guess next node.
 			if (output >= node->sequence_output_count) {
 				r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
-				error_str = RTR("Node returned an invalid sequence output: ") + itos(output);
+				error_str = RTR("Node returned an invalid sequence output:") + " " + itos(output);
 				error = true;
 				break;
 			}
@@ -1613,7 +1594,7 @@ Variant VisualScriptInstance::_call_internal(const StringName &p_method, void *p
 					// Check for stack overflow.
 					if (flow_stack_pos + 1 >= flow_max) {
 						r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
-						error_str = RTR("Stack overflow with stack depth: ") + itos(output);
+						error_str = RTR("Stack overflow with stack depth:") + " " + itos(output);
 						error = true;
 						break;
 					}
@@ -1705,10 +1686,10 @@ Variant VisualScriptInstance::_call_internal(const StringName &p_method, void *p
 	return return_value;
 }
 
-Variant VisualScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+Variant VisualScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	r_error.error = Callable::CallError::CALL_OK; //ok by default
 
-	Map<StringName, Function>::Element *F = functions.find(p_method);
+	HashMap<StringName, Function>::Iterator F = functions.find(p_method);
 	if (!F) {
 		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
 		return Variant();
@@ -1716,7 +1697,7 @@ Variant VisualScriptInstance::call(const StringName &p_method, const Variant **p
 
 	VSDEBUG("CALLING: " + String(p_method));
 
-	Function *f = &F->get();
+	Function *f = &F->value;
 
 	int total_stack_size = 0;
 
@@ -1750,14 +1731,14 @@ Variant VisualScriptInstance::call(const StringName &p_method, const Variant **p
 
 	memset(pass_stack, 0, f->pass_stack_size * sizeof(int));
 
-	Map<int, VisualScriptNodeInstance *>::Element *E = instances.find(f->node);
+	HashMap<int, VisualScriptNodeInstance *>::Iterator E = instances.find(f->node);
 	if (!E) {
 		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
 
 		ERR_FAIL_V_MSG(Variant(), "No VisualScriptFunction node in function.");
 	}
 
-	VisualScriptNodeInstance *node = E->get();
+	VisualScriptNodeInstance *node = E->value;
 
 	if (flow_stack) {
 		flow_stack[0] = node->get_id();
@@ -1798,13 +1779,13 @@ void VisualScriptInstance::notification(int p_notification) {
 	Variant what = p_notification;
 	const Variant *whatp = &what;
 	Callable::CallError ce;
-	call(VisualScriptLanguage::singleton->notification, &whatp, 1, ce); // Do as call.
+	callp(VisualScriptLanguage::singleton->notification, &whatp, 1, ce); // Do as call.
 }
 
 String VisualScriptInstance::to_string(bool *r_valid) {
 	if (has_method(CoreStringNames::get_singleton()->_to_string)) {
 		Callable::CallError ce;
-		Variant ret = call(CoreStringNames::get_singleton()->_to_string, nullptr, 0, ce);
+		Variant ret = callp(CoreStringNames::get_singleton()->_to_string, nullptr, 0, ce);
 		if (ce.error == Callable::CallError::CALL_OK) {
 			if (ret.get_type() != Variant::STRING) {
 				if (r_valid) {
@@ -1842,19 +1823,15 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 
 	// Setup variables.
 	{
-		List<StringName> keys;
-		script->variables.get_key_list(&keys);
-		for (const StringName &E : keys) {
-			variables[E] = script->variables[E].default_value;
+		for (const KeyValue<StringName, VisualScript::Variable> &E : script->variables) {
+			variables[E.key] = E.value.default_value;
 		}
 	}
 
 	// Setup functions from sequence trees.
 	{
-		List<StringName> keys;
-		script->functions.get_key_list(&keys);
-		for (const StringName &E : keys) {
-			const VisualScript::Function vsfn = p_script->functions[E];
+		for (const KeyValue<StringName, VisualScript::Function> &E : script->functions) {
+			const VisualScript::Function &vsfn = E.value;
 			Function function;
 			function.node = vsfn.func_id;
 			function.max_stack = 0;
@@ -1862,10 +1839,10 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 			function.pass_stack_size = 0;
 			function.node_count = 0;
 
-			Map<StringName, int> local_var_indices;
+			HashMap<StringName, int> local_var_indices;
 
 			if (function.node < 0) {
-				VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No start node in function: " + String(E));
+				VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No start node in function: " + String(E.key));
 				ERR_CONTINUE(function.node < 0);
 			}
 
@@ -1873,7 +1850,7 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 				Ref<VisualScriptFunction> func_node = script->get_node(vsfn.func_id);
 
 				if (func_node.is_null()) {
-					VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No VisualScriptFunction typed start node in function: " + String(E));
+					VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(), 0, "No VisualScriptFunction typed start node in function: " + String(E.key));
 				}
 
 				ERR_CONTINUE(!func_node.is_valid());
@@ -1884,42 +1861,41 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 				max_input_args = MAX(max_input_args, function.argument_count);
 			}
 			// Function nodes graphs.
-			Set<VisualScript::SequenceConnection> seqconns;
-			Set<VisualScript::DataConnection> dataconns;
-			Set<int> node_ids;
+			RBSet<VisualScript::SequenceConnection> seqconns;
+			RBSet<VisualScript::DataConnection> dataconns;
+			RBSet<int> node_ids;
 			node_ids.insert(function.node);
 			{
 				List<int> nd_queue;
 				nd_queue.push_back(function.node);
 				while (!nd_queue.is_empty()) {
-					for (const Set<VisualScript::SequenceConnection>::Element *F = script->sequence_connections.front(); F; F = F->next()) {
-						if (nd_queue.front()->get() == F->get().from_node && !node_ids.has(F->get().to_node)) {
-							nd_queue.push_back(F->get().to_node);
-							node_ids.insert(F->get().to_node);
+					for (const VisualScript::SequenceConnection &F : script->sequence_connections) {
+						if (nd_queue.front()->get() == F.from_node && !node_ids.has(F.to_node)) {
+							nd_queue.push_back(F.to_node);
+							node_ids.insert(F.to_node);
 						}
-						if (nd_queue.front()->get() == F->get().from_node && !seqconns.has(F->get())) {
-							seqconns.insert(F->get());
+						if (nd_queue.front()->get() == F.from_node && !seqconns.has(F)) {
+							seqconns.insert(F);
 						}
 					}
 					nd_queue.pop_front();
 				}
 				HashMap<int, HashMap<int, Pair<int, int>>> dc_lut; // :: to -> to_port -> (from, from_port)
-				for (const Set<VisualScript::DataConnection>::Element *F = script->data_connections.front(); F; F = F->next()) {
-					dc_lut[F->get().to_node][F->get().to_port] = Pair<int, int>(F->get().from_node, F->get().from_port);
+				for (const VisualScript::DataConnection &F : script->data_connections) {
+					dc_lut[F.to_node][F.to_port] = Pair<int, int>(F.from_node, F.from_port);
 				}
-				for (const Set<int>::Element *F = node_ids.front(); F; F = F->next()) {
-					nd_queue.push_back(F->get());
+				for (const int &F : node_ids) {
+					nd_queue.push_back(F);
 				}
 				List<int> dc_keys;
 				while (!nd_queue.is_empty()) {
 					int ky = nd_queue.front()->get();
-					dc_lut[ky].get_key_list(&dc_keys);
-					for (const int &F : dc_keys) {
+					for (const KeyValue<int, Pair<int, int>> &F : dc_lut[ky]) {
 						VisualScript::DataConnection dc;
-						dc.from_node = dc_lut[ky][F].first;
-						dc.from_port = dc_lut[ky][F].second;
+						dc.from_node = F.value.first;
+						dc.from_port = F.value.second;
 						dc.to_node = ky;
-						dc.to_port = F;
+						dc.to_port = F.key;
 						dataconns.insert(dc);
 						nd_queue.push_back(dc.from_node);
 						node_ids.insert(dc.from_node);
@@ -1931,15 +1907,15 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 
 			//Multiple passes are required to set up this complex thing..
 			//First create the nodes.
-			for (const Set<int>::Element *F = node_ids.front(); F; F = F->next()) {
-				Ref<VisualScriptNode> node = script->nodes[F->get()].node;
+			for (const int &F : node_ids) {
+				Ref<VisualScriptNode> node = script->nodes[F].node;
 
 				VisualScriptNodeInstance *instance = node->instantiate(this); // Create instance.
 				ERR_FAIL_COND(!instance);
 
 				instance->base = node.ptr();
 
-				instance->id = F->get();
+				instance->id = F;
 				instance->input_port_count = node->get_input_value_port_count();
 				instance->input_ports = nullptr;
 				instance->output_port_count = node->get_output_value_port_count();
@@ -1999,14 +1975,14 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 				max_input_args = MAX(max_input_args, instance->input_port_count);
 				max_output_args = MAX(max_output_args, instance->output_port_count);
 
-				instances[F->get()] = instance;
+				instances[F] = instance;
 			}
 
 			function.trash_pos = function.max_stack++; // create pos for trash
 
 			// Second pass, do data connections.
-			for (const Set<VisualScript::DataConnection>::Element *F = dataconns.front(); F; F = F->next()) {
-				VisualScript::DataConnection dc = F->get();
+			for (const VisualScript::DataConnection &F : dataconns) {
+				VisualScript::DataConnection dc = F;
 				ERR_CONTINUE(!instances.has(dc.from_node));
 				VisualScriptNodeInstance *from = instances[dc.from_node];
 				ERR_CONTINUE(!instances.has(dc.to_node));
@@ -2032,8 +2008,8 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 			}
 
 			// Third pass, do sequence connections.
-			for (const Set<VisualScript::SequenceConnection>::Element *F = seqconns.front(); F; F = F->next()) {
-				VisualScript::SequenceConnection sc = F->get();
+			for (const VisualScript::SequenceConnection &F : seqconns) {
+				VisualScript::SequenceConnection sc = F;
 				ERR_CONTINUE(!instances.has(sc.from_node));
 				VisualScriptNodeInstance *from = instances[sc.from_node];
 				ERR_CONTINUE(!instances.has(sc.to_node));
@@ -2046,11 +2022,11 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 			//fourth pass:
 			// 1) unassigned input ports to default values
 			// 2) connect unassigned output ports to trash
-			for (const Set<int>::Element *F = node_ids.front(); F; F = F->next()) {
-				ERR_CONTINUE(!instances.has(F->get()));
+			for (const int &F : node_ids) {
+				ERR_CONTINUE(!instances.has(F));
 
-				Ref<VisualScriptNode> node = script->nodes[F->get()].node;
-				VisualScriptNodeInstance *instance = instances[F->get()];
+				Ref<VisualScriptNode> node = script->nodes[F].node;
+				VisualScriptNodeInstance *instance = instances[F];
 
 				// Connect to default values.
 				for (int i = 0; i < instance->input_port_count; i++) {
@@ -2069,7 +2045,7 @@ void VisualScriptInstance::create(const Ref<VisualScript> &p_script, Object *p_o
 				}
 			}
 
-			functions[E] = function;
+			functions[E.key] = function;
 		}
 	}
 }
@@ -2247,7 +2223,7 @@ Ref<Script> VisualScriptLanguage::make_template(const String &p_template, const
 	return script;
 }
 
-bool VisualScriptLanguage::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 VisualScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptLanguage::ScriptError> *r_errors, List<ScriptLanguage::Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
 	return false;
 }