1 files changed, 96 insertions, 162 deletions

diff --git a/core/script_language.cpp b/core/script_language.cpp
index 7392e7a0af..b63aeb952c 100644
--- a/core/script_language.cpp
+++ b/core/script_language.cpp
@@ -31,22 +31,25 @@
 #include "script_language.h"
 
 #include "core/core_string_names.h"
+#include "core/debugger/engine_debugger.h"
+#include "core/debugger/script_debugger.h"
 #include "core/project_settings.h"
 
+#include <stdint.h>
+
 ScriptLanguage *ScriptServer::_languages[MAX_LANGUAGES];
 int ScriptServer::_language_count = 0;
 
 bool ScriptServer::scripting_enabled = true;
 bool ScriptServer::reload_scripts_on_save = false;
 bool ScriptServer::languages_finished = false;
-ScriptEditRequestFunction ScriptServer::edit_request_func = NULL;
+ScriptEditRequestFunction ScriptServer::edit_request_func = nullptr;
 
 void Script::_notification(int p_what) {
-
 	if (p_what == NOTIFICATION_POSTINITIALIZE) {
-
-		if (ScriptDebugger::get_singleton())
-			ScriptDebugger::get_singleton()->set_break_language(get_language());
+		if (EngineDebugger::is_active()) {
+			EngineDebugger::get_script_debugger()->set_break_language(get_language());
+		}
 	}
 }
 
@@ -97,7 +100,6 @@ Dictionary Script::_get_script_constant_map() {
 }
 
 void Script::_bind_methods() {
-
 	ClassDB::bind_method(D_METHOD("can_instance"), &Script::can_instance);
 	//ClassDB::bind_method(D_METHOD("instance_create","base_object"),&Script::instance_create);
 	ClassDB::bind_method(D_METHOD("instance_has", "base_object"), &Script::instance_has);
@@ -122,30 +124,25 @@ void Script::_bind_methods() {
 }
 
 void ScriptServer::set_scripting_enabled(bool p_enabled) {
-
 	scripting_enabled = p_enabled;
 }
 
 bool ScriptServer::is_scripting_enabled() {
-
 	return scripting_enabled;
 }
 
 ScriptLanguage *ScriptServer::get_language(int p_idx) {
-
-	ERR_FAIL_INDEX_V(p_idx, _language_count, NULL);
+	ERR_FAIL_INDEX_V(p_idx, _language_count, nullptr);
 
 	return _languages[p_idx];
 }
 
 void ScriptServer::register_language(ScriptLanguage *p_language) {
-
 	ERR_FAIL_COND(_language_count >= MAX_LANGUAGES);
 	_languages[_language_count++] = p_language;
 }
 
 void ScriptServer::unregister_language(ScriptLanguage *p_language) {
-
 	for (int i = 0; i < _language_count; i++) {
 		if (_languages[i] == p_language) {
 			_language_count--;
@@ -158,7 +155,6 @@ void ScriptServer::unregister_language(ScriptLanguage *p_language) {
 }
 
 void ScriptServer::init_languages() {
-
 	{ //load global classes
 		global_classes_clear();
 		if (ProjectSettings::get_singleton()->has_setting("_global_script_classes")) {
@@ -166,8 +162,9 @@ void ScriptServer::init_languages() {
 
 			for (int i = 0; i < script_classes.size(); i++) {
 				Dictionary c = script_classes[i];
-				if (!c.has("class") || !c.has("language") || !c.has("path") || !c.has("base"))
+				if (!c.has("class") || !c.has("language") || !c.has("path") || !c.has("base")) {
 					continue;
+				}
 				add_global_class(c["class"], c["base"], c["language"], c["path"]);
 			}
 		}
@@ -179,7 +176,6 @@ void ScriptServer::init_languages() {
 }
 
 void ScriptServer::finish_languages() {
-
 	for (int i = 0; i < _language_count; i++) {
 		_languages[i]->finish();
 	}
@@ -188,24 +184,20 @@ void ScriptServer::finish_languages() {
 }
 
 void ScriptServer::set_reload_scripts_on_save(bool p_enable) {
-
 	reload_scripts_on_save = p_enable;
 }
 
 bool ScriptServer::is_reload_scripts_on_save_enabled() {
-
 	return reload_scripts_on_save;
 }
 
 void ScriptServer::thread_enter() {
-
 	for (int i = 0; i < _language_count; i++) {
 		_languages[i]->thread_enter();
 	}
 }
 
 void ScriptServer::thread_exit() {
-
 	for (int i = 0; i < _language_count; i++) {
 		_languages[i]->thread_exit();
 	}
@@ -225,16 +217,20 @@ void ScriptServer::add_global_class(const StringName &p_class, const StringName
 	g.base = p_base;
 	global_classes[p_class] = g;
 }
+
 void ScriptServer::remove_global_class(const StringName &p_class) {
 	global_classes.erase(p_class);
 }
+
 bool ScriptServer::is_global_class(const StringName &p_class) {
 	return global_classes.has(p_class);
 }
+
 StringName ScriptServer::get_global_class_language(const StringName &p_class) {
 	ERR_FAIL_COND_V(!global_classes.has(p_class), StringName());
 	return global_classes[p_class].language;
 }
+
 String ScriptServer::get_global_class_path(const String &p_class) {
 	ERR_FAIL_COND_V(!global_classes.has(p_class), String());
 	return global_classes[p_class].path;
@@ -244,6 +240,7 @@ StringName ScriptServer::get_global_class_base(const String &p_class) {
 	ERR_FAIL_COND_V(!global_classes.has(p_class), String());
 	return global_classes[p_class].base;
 }
+
 StringName ScriptServer::get_global_class_native_base(const String &p_class) {
 	ERR_FAIL_COND_V(!global_classes.has(p_class), String());
 	String base = global_classes[p_class].base;
@@ -252,8 +249,9 @@ StringName ScriptServer::get_global_class_native_base(const String &p_class) {
 	}
 	return base;
 }
+
 void ScriptServer::get_global_class_list(List<StringName> *r_global_classes) {
-	const StringName *K = NULL;
+	const StringName *K = nullptr;
 	List<StringName> classes;
 	while ((K = global_classes.next(K))) {
 		classes.push_back(*K);
@@ -263,6 +261,7 @@ void ScriptServer::get_global_class_list(List<StringName> *r_global_classes) {
 		r_global_classes->push_back(E->get());
 	}
 }
+
 void ScriptServer::save_global_classes() {
 	List<StringName> gc;
 	get_global_class_list(&gc);
@@ -281,167 +280,95 @@ void ScriptServer::save_global_classes() {
 }
 
 ////////////////////
-void ScriptInstance::get_property_state(List<Pair<StringName, Variant> > &state) {
-
+void ScriptInstance::get_property_state(List<Pair<StringName, Variant>> &state) {
 	List<PropertyInfo> pinfo;
 	get_property_list(&pinfo);
 	for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
-
 		if (E->get().usage & PROPERTY_USAGE_STORAGE) {
 			Pair<StringName, Variant> p;
 			p.first = E->get().name;
-			if (get(p.first, p.second))
+			if (get(p.first, p.second)) {
 				state.push_back(p);
+			}
 		}
 	}
 }
 
 Variant ScriptInstance::call(const StringName &p_method, VARIANT_ARG_DECLARE) {
-
 	VARIANT_ARGPTRS;
 	int argc = 0;
 	for (int i = 0; i < VARIANT_ARG_MAX; i++) {
-		if (argptr[i]->get_type() == Variant::NIL)
+		if (argptr[i]->get_type() == Variant::NIL) {
 			break;
+		}
 		argc++;
 	}
 
-	Variant::CallError error;
+	Callable::CallError error;
 	return call(p_method, argptr, argc, error);
 }
 
-void ScriptInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
-	Variant::CallError ce;
-	call(p_method, p_args, p_argcount, ce); // script may not support multilevel calls
-}
-
-void ScriptInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
-	Variant::CallError ce;
-	call(p_method, p_args, p_argcount, ce); // script may not support multilevel calls
-}
-
 void ScriptInstance::property_set_fallback(const StringName &, const Variant &, bool *r_valid) {
-	if (r_valid)
+	if (r_valid) {
 		*r_valid = false;
+	}
 }
 
 Variant ScriptInstance::property_get_fallback(const StringName &, bool *r_valid) {
-	if (r_valid)
+	if (r_valid) {
 		*r_valid = false;
-	return Variant();
-}
-
-void ScriptInstance::call_multilevel(const StringName &p_method, VARIANT_ARG_DECLARE) {
-
-	VARIANT_ARGPTRS;
-	int argc = 0;
-	for (int i = 0; i < VARIANT_ARG_MAX; i++) {
-		if (argptr[i]->get_type() == Variant::NIL)
-			break;
-		argc++;
 	}
-
-	call_multilevel(p_method, argptr, argc);
+	return Variant();
 }
 
 ScriptInstance::~ScriptInstance() {
 }
 
-ScriptCodeCompletionCache *ScriptCodeCompletionCache::singleton = NULL;
+ScriptCodeCompletionCache *ScriptCodeCompletionCache::singleton = nullptr;
 ScriptCodeCompletionCache::ScriptCodeCompletionCache() {
 	singleton = this;
 }
 
-void ScriptLanguage::frame() {
-}
-
-ScriptDebugger *ScriptDebugger::singleton = NULL;
-
-void ScriptDebugger::set_lines_left(int p_left) {
-
-	lines_left = p_left;
-}
-
-int ScriptDebugger::get_lines_left() const {
-
-	return lines_left;
-}
-
-void ScriptDebugger::set_depth(int p_depth) {
-
-	depth = p_depth;
-}
-
-int ScriptDebugger::get_depth() const {
-
-	return depth;
-}
-
-void ScriptDebugger::insert_breakpoint(int p_line, const StringName &p_source) {
-
-	if (!breakpoints.has(p_line))
-		breakpoints[p_line] = Set<StringName>();
-	breakpoints[p_line].insert(p_source);
-}
-
-void ScriptDebugger::remove_breakpoint(int p_line, const StringName &p_source) {
-
-	if (!breakpoints.has(p_line))
-		return;
-
-	breakpoints[p_line].erase(p_source);
-	if (breakpoints[p_line].size() == 0)
-		breakpoints.erase(p_line);
-}
-bool ScriptDebugger::is_breakpoint(int p_line, const StringName &p_source) const {
-
-	if (!breakpoints.has(p_line))
-		return false;
-	return breakpoints[p_line].has(p_source);
-}
-bool ScriptDebugger::is_breakpoint_line(int p_line) const {
-
-	return breakpoints.has(p_line);
-}
-
-String ScriptDebugger::breakpoint_find_source(const String &p_source) const {
-
-	return p_source;
-}
-
-void ScriptDebugger::clear_breakpoints() {
-
-	breakpoints.clear();
-}
-
-void ScriptDebugger::idle_poll() {
+void ScriptLanguage::get_core_type_words(List<String> *p_core_type_words) const {
+	p_core_type_words->push_back("String");
+	p_core_type_words->push_back("Vector2");
+	p_core_type_words->push_back("Vector2i");
+	p_core_type_words->push_back("Rect2");
+	p_core_type_words->push_back("Rect2i");
+	p_core_type_words->push_back("Vector3");
+	p_core_type_words->push_back("Vector3i");
+	p_core_type_words->push_back("Transform2D");
+	p_core_type_words->push_back("Plane");
+	p_core_type_words->push_back("Quat");
+	p_core_type_words->push_back("AABB");
+	p_core_type_words->push_back("Basis");
+	p_core_type_words->push_back("Transform");
+	p_core_type_words->push_back("Color");
+	p_core_type_words->push_back("StringName");
+	p_core_type_words->push_back("NodePath");
+	p_core_type_words->push_back("RID");
+	p_core_type_words->push_back("Callable");
+	p_core_type_words->push_back("Signal");
+	p_core_type_words->push_back("Dictionary");
+	p_core_type_words->push_back("Array");
+	p_core_type_words->push_back("PackedByteArray");
+	p_core_type_words->push_back("PackedInt32Array");
+	p_core_type_words->push_back("PackedInt64Array");
+	p_core_type_words->push_back("PackedFloat32Array");
+	p_core_type_words->push_back("PackedFloat64Array");
+	p_core_type_words->push_back("PackedStringArray");
+	p_core_type_words->push_back("PackedVector2Array");
+	p_core_type_words->push_back("PackedVector3Array");
+	p_core_type_words->push_back("PackedColorArray");
 }
 
-void ScriptDebugger::line_poll() {
-}
-
-void ScriptDebugger::set_break_language(ScriptLanguage *p_lang) {
-
-	break_lang = p_lang;
-}
-
-ScriptLanguage *ScriptDebugger::get_break_language() const {
-
-	return break_lang;
-}
-
-ScriptDebugger::ScriptDebugger() {
-
-	singleton = this;
-	lines_left = -1;
-	depth = -1;
-	break_lang = NULL;
+void ScriptLanguage::frame() {
 }
 
 bool PlaceHolderScriptInstance::set(const StringName &p_name, const Variant &p_value) {
-
-	if (script->is_placeholder_fallback_enabled())
+	if (script->is_placeholder_fallback_enabled()) {
 		return false;
+	}
 
 	if (values.has(p_name)) {
 		Variant defval;
@@ -464,8 +391,8 @@ bool PlaceHolderScriptInstance::set(const StringName &p_name, const Variant &p_v
 	}
 	return false;
 }
-bool PlaceHolderScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 
+bool PlaceHolderScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 	if (values.has(p_name)) {
 		r_ret = values[p_name];
 		return true;
@@ -488,7 +415,6 @@ bool PlaceHolderScriptInstance::get(const StringName &p_name, Variant &r_ret) co
 }
 
 void PlaceHolderScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
-
 	if (script->is_placeholder_fallback_enabled()) {
 		for (const List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
 			p_properties->push_back(E->get());
@@ -505,38 +431,41 @@ void PlaceHolderScriptInstance::get_property_list(List<PropertyInfo> *p_properti
 }
 
 Variant::Type PlaceHolderScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
-
 	if (values.has(p_name)) {
-		if (r_is_valid)
+		if (r_is_valid) {
 			*r_is_valid = true;
+		}
 		return values[p_name].get_type();
 	}
 
 	if (constants.has(p_name)) {
-		if (r_is_valid)
+		if (r_is_valid) {
 			*r_is_valid = true;
+		}
 		return constants[p_name].get_type();
 	}
 
-	if (r_is_valid)
+	if (r_is_valid) {
 		*r_is_valid = false;
+	}
 
 	return Variant::NIL;
 }
 
 void PlaceHolderScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
-
-	if (script->is_placeholder_fallback_enabled())
+	if (script->is_placeholder_fallback_enabled()) {
 		return;
+	}
 
 	if (script.is_valid()) {
 		script->get_script_method_list(p_list);
 	}
 }
-bool PlaceHolderScriptInstance::has_method(const StringName &p_method) const {
 
-	if (script->is_placeholder_fallback_enabled())
+bool PlaceHolderScriptInstance::has_method(const StringName &p_method) const {
+	if (script->is_placeholder_fallback_enabled()) {
 		return false;
+	}
 
 	if (script.is_valid()) {
 		return script->has_method(p_method);
@@ -545,17 +474,15 @@ bool PlaceHolderScriptInstance::has_method(const StringName &p_method) const {
 }
 
 void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, const Map<StringName, Variant> &p_values) {
-
 	Set<StringName> new_values;
 	for (const List<PropertyInfo>::Element *E = p_properties.front(); E; E = E->next()) {
-
 		StringName n = E->get().name;
 		new_values.insert(n);
 
 		if (!values.has(n) || values[n].get_type() != E->get().type) {
-
-			if (p_values.has(n))
+			if (p_values.has(n)) {
 				values[n] = p_values[n];
+			}
 		}
 	}
 
@@ -563,9 +490,9 @@ void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, c
 	List<StringName> to_remove;
 
 	for (Map<StringName, Variant>::Element *E = values.front(); E; E = E->next()) {
-
-		if (!new_values.has(E->key()))
+		if (!new_values.has(E->key())) {
 			to_remove.push_back(E->key());
+		}
 
 		Variant defval;
 		if (script->get_property_default_value(E->key(), defval)) {
@@ -577,13 +504,11 @@ void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, c
 	}
 
 	while (to_remove.size()) {
-
 		values.erase(to_remove.front()->get());
 		to_remove.pop_front();
 	}
 
 	if (owner && owner->get_script_instance() == this) {
-
 		owner->_change_notify();
 	}
 	//change notify
@@ -593,7 +518,6 @@ void PlaceHolderScriptInstance::update(const List<PropertyInfo> &p_properties, c
 }
 
 void PlaceHolderScriptInstance::property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) {
-
 	if (script->is_placeholder_fallback_enabled()) {
 		Map<StringName, Variant>::Element *E = values.find(p_name);
 
@@ -615,35 +539,46 @@ void PlaceHolderScriptInstance::property_set_fallback(const StringName &p_name,
 		}
 	}
 
-	if (r_valid)
+	if (r_valid) {
 		*r_valid = false; // Cannot change the value in either case
+	}
 }
 
 Variant PlaceHolderScriptInstance::property_get_fallback(const StringName &p_name, bool *r_valid) {
-
 	if (script->is_placeholder_fallback_enabled()) {
 		const Map<StringName, Variant>::Element *E = values.find(p_name);
 
 		if (E) {
-			if (r_valid)
+			if (r_valid) {
 				*r_valid = true;
+			}
 			return E->value();
 		}
 
 		E = constants.find(p_name);
 		if (E) {
-			if (r_valid)
+			if (r_valid) {
 				*r_valid = true;
+			}
 			return E->value();
 		}
 	}
 
-	if (r_valid)
+	if (r_valid) {
 		*r_valid = false;
+	}
 
 	return Variant();
 }
 
+uint16_t PlaceHolderScriptInstance::get_rpc_method_id(const StringName &p_method) const {
+	return UINT16_MAX;
+}
+
+uint16_t PlaceHolderScriptInstance::get_rset_property_id(const StringName &p_method) const {
+	return UINT16_MAX;
+}
+
 PlaceHolderScriptInstance::PlaceHolderScriptInstance(ScriptLanguage *p_language, Ref<Script> p_script, Object *p_owner) :
 		owner(p_owner),
 		language(p_language),
@@ -651,7 +586,6 @@ PlaceHolderScriptInstance::PlaceHolderScriptInstance(ScriptLanguage *p_language,
 }
 
 PlaceHolderScriptInstance::~PlaceHolderScriptInstance() {
-
 	if (script.is_valid()) {
 		script->_placeholder_erased(this);
 	}