From e687fc6a4a658a6f74868b284352722c98f19ab6 Mon Sep 17 00:00:00 2001
From: Relintai <relintai@protonmail.com>
Date: Tue, 12 Jul 2022 12:20:34 +0200
Subject: [PATCH] Added a new cscript module. It's a copy of gdscript, and it's
 build is disabled for now. I plan to experiment with it to have a scripting
 language that's syntax is as close to c (c++) as possible.

---
 modules/cscript/SCsub                         |   12 +
 modules/cscript/config.py                     |   21 +
 modules/cscript/cscript.cpp                   | 2293 +++++
 modules/cscript/cscript.h                     |  567 ++
 modules/cscript/cscript_compiler.cpp          | 2236 +++++
 modules/cscript/cscript_compiler.h            |  169 +
 modules/cscript/cscript_editor.cpp            | 3552 +++++++
 modules/cscript/cscript_function.cpp          | 1879 ++++
 modules/cscript/cscript_function.h            |  389 +
 modules/cscript/cscript_functions.cpp         | 1984 ++++
 modules/cscript/cscript_functions.h           |  138 +
 modules/cscript/cscript_parser.cpp            | 8926 +++++++++++++++++
 modules/cscript/cscript_parser.h              |  699 ++
 modules/cscript/cscript_tokenizer.cpp         | 1498 +++
 modules/cscript/cscript_tokenizer.h           |  306 +
 modules/cscript/doc_classes/@CScript.xml      | 1237 +++
 modules/cscript/doc_classes/CScript.xml       |   35 +
 .../cscript/editor/cscript_highlighter.cpp    |  395 +
 modules/cscript/editor/cscript_highlighter.h  |   71 +
 modules/cscript/icons/icon_c_script.svg       |   65 +
 modules/cscript/register_types.cpp            |  170 +
 modules/cscript/register_types.h              |   36 +
 22 files changed, 26678 insertions(+)
 create mode 100644 modules/cscript/SCsub
 create mode 100644 modules/cscript/config.py
 create mode 100644 modules/cscript/cscript.cpp
 create mode 100644 modules/cscript/cscript.h
 create mode 100644 modules/cscript/cscript_compiler.cpp
 create mode 100644 modules/cscript/cscript_compiler.h
 create mode 100644 modules/cscript/cscript_editor.cpp
 create mode 100644 modules/cscript/cscript_function.cpp
 create mode 100644 modules/cscript/cscript_function.h
 create mode 100644 modules/cscript/cscript_functions.cpp
 create mode 100644 modules/cscript/cscript_functions.h
 create mode 100644 modules/cscript/cscript_parser.cpp
 create mode 100644 modules/cscript/cscript_parser.h
 create mode 100644 modules/cscript/cscript_tokenizer.cpp
 create mode 100644 modules/cscript/cscript_tokenizer.h
 create mode 100644 modules/cscript/doc_classes/@CScript.xml
 create mode 100644 modules/cscript/doc_classes/CScript.xml
 create mode 100644 modules/cscript/editor/cscript_highlighter.cpp
 create mode 100644 modules/cscript/editor/cscript_highlighter.h
 create mode 100644 modules/cscript/icons/icon_c_script.svg
 create mode 100644 modules/cscript/register_types.cpp
 create mode 100644 modules/cscript/register_types.h

diff --git a/modules/cscript/SCsub b/modules/cscript/SCsub
new file mode 100644
index 000000000..a4af0cf66
--- /dev/null
+++ b/modules/cscript/SCsub
@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+
+Import("env")
+Import("env_modules")
+
+env_gdscript = env_modules.Clone()
+
+env_gdscript.add_source_files(env.modules_sources, "*.cpp")
+
+if env["tools"]:
+    env_gdscript.add_source_files(env.modules_sources, "./editor/*.cpp")
+    
\ No newline at end of file
diff --git a/modules/cscript/config.py b/modules/cscript/config.py
new file mode 100644
index 000000000..f22ac6711
--- /dev/null
+++ b/modules/cscript/config.py
@@ -0,0 +1,21 @@
+
+def can_build(env, platform):
+    #return True
+    #not yet
+    return False
+
+
+def configure(env):
+    pass
+
+
+def get_doc_classes():
+    return [
+        "@CScript",
+        "CScript",
+        "CScriptFunctionState",
+    ]
+
+
+def get_doc_path():
+    return "doc_classes"
diff --git a/modules/cscript/cscript.cpp b/modules/cscript/cscript.cpp
new file mode 100644
index 000000000..db110202a
--- /dev/null
+++ b/modules/cscript/cscript.cpp
@@ -0,0 +1,2293 @@
+/*************************************************************************/
+/*  gdscript.cpp                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript.h"
+
+#include "core/core_string_names.h"
+#include "core/engine.h"
+#include "core/global_constants.h"
+#include "core/io/file_access_encrypted.h"
+#include "core/os/file_access.h"
+#include "core/os/os.h"
+#include "core/project_settings.h"
+#include "cscript_compiler.h"
+
+///////////////////////////
+
+GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) {
+	name = p_name;
+}
+
+bool GDScriptNativeClass::_get(const StringName &p_name, Variant &r_ret) const {
+	bool ok;
+	int v = ClassDB::get_integer_constant(name, p_name, &ok);
+
+	if (ok) {
+		r_ret = v;
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void GDScriptNativeClass::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("new"), &GDScriptNativeClass::_new);
+}
+
+Variant GDScriptNativeClass::_new() {
+	Object *o = instance();
+	ERR_FAIL_COND_V_MSG(!o, Variant(), "Class type: '" + String(name) + "' is not instantiable.");
+
+	Reference *ref = Object::cast_to<Reference>(o);
+	if (ref) {
+		return REF(ref);
+	} else {
+		return o;
+	}
+}
+
+Object *GDScriptNativeClass::instance() {
+	return ClassDB::instance(name);
+}
+
+void GDScript::_clear_pending_func_states() {
+	GDScriptLanguage::get_singleton()->lock.lock();
+	while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
+		// Order matters since clearing the stack may already cause
+		// the GDSCriptFunctionState to be destroyed and thus removed from the list.
+		pending_func_states.remove(E);
+		E->self()->_clear_stack();
+	}
+	GDScriptLanguage::get_singleton()->lock.unlock();
+}
+
+GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error) {
+	/* STEP 1, CREATE */
+
+	GDScriptInstance *instance = memnew(GDScriptInstance);
+	instance->base_ref = p_isref;
+	instance->members.resize(member_indices.size());
+	instance->script = Ref<GDScript>(this);
+	instance->owner = p_owner;
+#ifdef DEBUG_ENABLED
+	//needed for hot reloading
+	for (Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
+		instance->member_indices_cache[E->key()] = E->get().index;
+	}
+#endif
+	instance->owner->set_script_instance(instance);
+
+	/* STEP 2, INITIALIZE AND CONSTRUCT */
+
+	GDScriptLanguage::singleton->lock.lock();
+	instances.insert(instance->owner);
+	GDScriptLanguage::singleton->lock.unlock();
+
+	initializer->call(instance, p_args, p_argcount, r_error);
+
+	if (r_error.error != Variant::CallError::CALL_OK) {
+		instance->script = Ref<GDScript>();
+		instance->owner->set_script_instance(nullptr);
+#ifndef NO_THREADS
+		GDScriptLanguage::singleton->lock.lock();
+#endif
+		instances.erase(p_owner);
+#ifndef NO_THREADS
+		GDScriptLanguage::singleton->lock.unlock();
+#endif
+
+		ERR_FAIL_COND_V(r_error.error != Variant::CallError::CALL_OK, nullptr); //error constructing
+	}
+
+	//@TODO make thread safe
+	return instance;
+}
+
+Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	/* STEP 1, CREATE */
+
+	if (!valid) {
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		return Variant();
+	}
+
+	r_error.error = Variant::CallError::CALL_OK;
+	REF ref;
+	Object *owner = nullptr;
+
+	GDScript *_baseptr = this;
+	while (_baseptr->_base) {
+		_baseptr = _baseptr->_base;
+	}
+
+	ERR_FAIL_COND_V(_baseptr->native.is_null(), Variant());
+	if (_baseptr->native.ptr()) {
+		owner = _baseptr->native->instance();
+	} else {
+		owner = memnew(Reference); //by default, no base means use reference
+	}
+	ERR_FAIL_COND_V_MSG(!owner, Variant(), "Can't inherit from a virtual class.");
+
+	Reference *r = Object::cast_to<Reference>(owner);
+	if (r) {
+		ref = REF(r);
+	}
+
+	GDScriptInstance *instance = _create_instance(p_args, p_argcount, owner, r != nullptr, r_error);
+	if (!instance) {
+		if (ref.is_null()) {
+			memdelete(owner); //no owner, sorry
+		}
+		return Variant();
+	}
+
+	if (ref.is_valid()) {
+		return ref;
+	} else {
+		return owner;
+	}
+}
+
+bool GDScript::can_instance() const {
+#ifdef TOOLS_ENABLED
+	return valid && (tool || ScriptServer::is_scripting_enabled());
+#else
+	return valid;
+#endif
+}
+
+Ref<Script> GDScript::get_base_script() const {
+	if (_base) {
+		return Ref<GDScript>(_base);
+	} else {
+		return Ref<Script>();
+	}
+}
+
+StringName GDScript::get_instance_base_type() const {
+	if (native.is_valid()) {
+		return native->get_name();
+	}
+	if (base.is_valid() && base->is_valid()) {
+		return base->get_instance_base_type();
+	}
+	return StringName();
+}
+
+struct _GDScriptMemberSort {
+	int index;
+	StringName name;
+	_FORCE_INLINE_ bool operator<(const _GDScriptMemberSort &p_member) const { return index < p_member.index; }
+};
+
+#ifdef TOOLS_ENABLED
+
+void GDScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
+	placeholders.erase(p_placeholder);
+}
+#endif
+
+void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
+	const GDScript *current = this;
+	while (current) {
+		for (const Map<StringName, GDScriptFunction *>::Element *E = current->member_functions.front(); E; E = E->next()) {
+			GDScriptFunction *func = E->get();
+			MethodInfo mi;
+			mi.name = E->key();
+			for (int i = 0; i < func->get_argument_count(); i++) {
+				mi.arguments.push_back(func->get_argument_type(i));
+			}
+
+			mi.return_val = func->get_return_type();
+			p_list->push_back(mi);
+		}
+
+		current = current->_base;
+	}
+}
+
+void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+	const GDScript *sptr = this;
+	List<PropertyInfo> props;
+
+	while (sptr) {
+		Vector<_GDScriptMemberSort> msort;
+		for (Map<StringName, PropertyInfo>::Element *E = sptr->member_info.front(); E; E = E->next()) {
+			_GDScriptMemberSort ms;
+			ERR_CONTINUE(!sptr->member_indices.has(E->key()));
+			ms.index = sptr->member_indices[E->key()].index;
+			ms.name = E->key();
+			msort.push_back(ms);
+		}
+
+		msort.sort();
+		msort.invert();
+		for (int i = 0; i < msort.size(); i++) {
+			props.push_front(sptr->member_info[msort[i].name]);
+		}
+
+		sptr = sptr->_base;
+	}
+
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+		p_list->push_back(E->get());
+	}
+}
+
+bool GDScript::has_method(const StringName &p_method) const {
+	return member_functions.has(p_method);
+}
+
+MethodInfo GDScript::get_method_info(const StringName &p_method) const {
+	const Map<StringName, GDScriptFunction *>::Element *E = member_functions.find(p_method);
+	if (!E) {
+		return MethodInfo();
+	}
+
+	GDScriptFunction *func = E->get();
+	MethodInfo mi;
+	mi.name = E->key();
+	for (int i = 0; i < func->get_argument_count(); i++) {
+		mi.arguments.push_back(func->get_argument_type(i));
+	}
+
+	mi.return_val = func->get_return_type();
+	return mi;
+}
+
+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);
+	if (E) {
+		r_value = E->get();
+		return true;
+	}
+
+	if (base_cache.is_valid()) {
+		return base_cache->get_property_default_value(p_property, r_value);
+	}
+#endif
+	return false;
+}
+
+ScriptInstance *GDScript::instance_create(Object *p_this) {
+	GDScript *top = this;
+	while (top->_base) {
+		top = top->_base;
+	}
+
+	if (top->native.is_valid()) {
+		if (!ClassDB::is_parent_class(p_this->get_class_name(), top->native->get_name())) {
+			if (ScriptDebugger::get_singleton()) {
+				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), 1, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'");
+			}
+			ERR_FAIL_V_MSG(nullptr, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type '" + p_this->get_class() + "'" + ".");
+		}
+	}
+
+	Variant::CallError unchecked_error;
+	return _create_instance(nullptr, 0, p_this, Object::cast_to<Reference>(p_this) != nullptr, unchecked_error);
+}
+
+PlaceHolderScriptInstance *GDScript::placeholder_instance_create(Object *p_this) {
+#ifdef TOOLS_ENABLED
+	PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(GDScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
+	placeholders.insert(si);
+	_update_exports(nullptr, false, si);
+	return si;
+#else
+	return NULL;
+#endif
+}
+
+bool GDScript::instance_has(const Object *p_this) const {
+	GDScriptLanguage::singleton->lock.lock();
+	bool hasit = instances.has((Object *)p_this);
+	GDScriptLanguage::singleton->lock.unlock();
+
+	return hasit;
+}
+
+bool GDScript::has_source_code() const {
+	return source != "";
+}
+String GDScript::get_source_code() const {
+	return source;
+}
+void GDScript::set_source_code(const String &p_code) {
+	if (source == p_code) {
+		return;
+	}
+	source = p_code;
+#ifdef TOOLS_ENABLED
+	source_changed_cache = true;
+#endif
+}
+
+#ifdef TOOLS_ENABLED
+void GDScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {
+	if (base_cache.is_valid()) {
+		base_cache->_update_exports_values(values, propnames);
+	}
+
+	for (Map<StringName, Variant>::Element *E = member_default_values_cache.front(); E; E = E->next()) {
+		values[E->key()] = E->get();
+	}
+
+	for (List<PropertyInfo>::Element *E = members_cache.front(); E; E = E->next()) {
+		propnames.push_back(E->get());
+	}
+}
+#endif
+
+bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderScriptInstance *p_instance_to_update) {
+#ifdef TOOLS_ENABLED
+
+	static Vector<GDScript *> base_caches;
+	if (!p_recursive_call) {
+		base_caches.clear();
+	}
+	base_caches.push_back(this);
+
+	bool changed = false;
+
+	if (source_changed_cache) {
+		source_changed_cache = false;
+		changed = true;
+
+		String basedir = path;
+
+		if (basedir == "") {
+			basedir = get_path();
+		}
+
+		if (basedir != "") {
+			basedir = basedir.get_base_dir();
+		}
+
+		GDScriptParser parser;
+		Error err = parser.parse(source, basedir, true, path);
+
+		if (err == OK) {
+			const GDScriptParser::Node *root = parser.get_parse_tree();
+			ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, false);
+
+			const GDScriptParser::ClassNode *c = static_cast<const GDScriptParser::ClassNode *>(root);
+
+			if (base_cache.is_valid()) {
+				base_cache->inheriters_cache.erase(get_instance_id());
+				base_cache = Ref<GDScript>();
+			}
+
+			if (c->extends_used) {
+				String path = "";
+				if (String(c->extends_file) != "" && String(c->extends_file) != get_path()) {
+					path = c->extends_file;
+					if (path.is_rel_path()) {
+						String base = get_path();
+						if (base == "" || base.is_rel_path()) {
+							ERR_PRINT(("Could not resolve relative path for parent class: " + path).utf8().get_data());
+						} else {
+							path = base.get_base_dir().plus_file(path);
+						}
+					}
+				} else if (c->extends_class.size() != 0) {
+					String base = c->extends_class[0];
+
+					if (ScriptServer::is_global_class(base)) {
+						path = ScriptServer::get_global_class_path(base);
+					}
+				}
+
+				if (path != "") {
+					if (path != get_path()) {
+						Ref<GDScript> bf = ResourceLoader::load(path);
+
+						if (bf.is_valid()) {
+							base_cache = bf;
+							bf->inheriters_cache.insert(get_instance_id());
+						}
+					} else {
+						ERR_PRINT(("Path extending itself in  " + path).utf8().get_data());
+					}
+				}
+			}
+
+			members_cache.clear();
+			member_default_values_cache.clear();
+
+			for (int i = 0; i < c->variables.size(); i++) {
+				if (c->variables[i]._export.type == Variant::NIL) {
+					continue;
+				}
+
+				members_cache.push_back(c->variables[i]._export);
+
+				Variant::Type default_value_type = c->variables[i].default_value.get_type();
+				Variant::Type export_type = c->variables[i]._export.type;
+
+				// Convert the default value to the export type to avoid issues with the property editor and scene serialization.
+				// This is done only in the export side, the script itself will use the default value with no type change.
+				if (default_value_type != Variant::NIL && default_value_type != export_type) {
+					Variant::CallError ce;
+					const Variant *args = &c->variables[i].default_value;
+					member_default_values_cache[c->variables[i].identifier] = Variant::construct(export_type, &args, 1, ce);
+				} else {
+					member_default_values_cache[c->variables[i].identifier] = c->variables[i].default_value;
+				}
+			}
+
+			_signals.clear();
+
+			for (int i = 0; i < c->_signals.size(); i++) {
+				_signals[c->_signals[i].name] = c->_signals[i].arguments;
+			}
+		} else {
+			placeholder_fallback_enabled = true;
+			return false;
+		}
+	} else if (placeholder_fallback_enabled) {
+		return false;
+	}
+
+	placeholder_fallback_enabled = false;
+
+	if (base_cache.is_valid() && base_cache->is_valid()) {
+		for (int i = 0; i < base_caches.size(); i++) {
+			if (base_caches[i] == base_cache.ptr()) {
+				if (r_err) {
+					*r_err = true;
+				}
+				valid = false; // to show error in the editor
+				base_cache->valid = false;
+				base_cache->inheriters_cache.clear(); // to prevent future stackoverflows
+				base_cache.unref();
+				base.unref();
+				_base = nullptr;
+				ERR_FAIL_V_MSG(false, "Cyclic inheritance in script class.");
+			}
+		}
+		if (base_cache->_update_exports(r_err, true)) {
+			if (r_err && *r_err) {
+				return false;
+			}
+			changed = true;
+		}
+	}
+
+	if ((changed || p_instance_to_update) && placeholders.size()) { //hm :(
+
+		// update placeholders if any
+		Map<StringName, Variant> values;
+		List<PropertyInfo> propnames;
+		_update_exports_values(values, propnames);
+
+		if (changed) {
+			for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
+				E->get()->update(propnames, values);
+			}
+		} else {
+			p_instance_to_update->update(propnames, values);
+		}
+	}
+
+	return changed;
+
+#else
+	return false;
+#endif
+}
+
+void GDScript::update_exports() {
+#ifdef TOOLS_ENABLED
+
+	bool cyclic_error = false;
+	_update_exports(&cyclic_error);
+	if (cyclic_error) {
+		return;
+	}
+
+	Set<ObjectID> copy = inheriters_cache; //might get modified
+
+	for (Set<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) {
+			continue;
+		}
+		s->update_exports();
+	}
+
+#endif
+}
+
+void GDScript::_set_subclass_path(Ref<GDScript> &p_sc, const String &p_path) {
+	p_sc->path = p_path;
+	for (Map<StringName, Ref<GDScript>>::Element *E = p_sc->subclasses.front(); E; E = E->next()) {
+		_set_subclass_path(E->get(), p_path);
+	}
+}
+
+String GDScript::_get_debug_path() const {
+	if ((get_path().empty() || get_path().find("::") != -1) && !get_name().empty()) {
+		return get_name() + " (" + get_path().get_slice("::", 0) + ")";
+	} else {
+		return get_path();
+	}
+}
+
+Error GDScript::reload(bool p_keep_state) {
+	GDScriptLanguage::singleton->lock.lock();
+	bool has_instances = instances.size();
+	GDScriptLanguage::singleton->lock.unlock();
+
+	ERR_FAIL_COND_V(!p_keep_state && has_instances, ERR_ALREADY_IN_USE);
+
+	String basedir = path;
+
+	if (basedir == "") {
+		basedir = get_path();
+	}
+
+	if (basedir != "") {
+		basedir = basedir.get_base_dir();
+	}
+
+	if (source.find("%BASE%") != -1) {
+		//loading a template, don't parse
+		return OK;
+	}
+
+	valid = false;
+	GDScriptParser parser;
+	Error err = parser.parse(source, basedir, false, path);
+	if (err) {
+		if (ScriptDebugger::get_singleton()) {
+			GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), parser.get_error_line(), "Parser Error: " + parser.get_error());
+		}
+		_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		ERR_FAIL_V(ERR_PARSE_ERROR);
+	}
+
+	bool can_run = ScriptServer::is_scripting_enabled() || parser.is_tool_script();
+
+	GDScriptCompiler compiler;
+	err = compiler.compile(&parser, this, p_keep_state);
+
+	if (err) {
+		if (can_run) {
+			if (ScriptDebugger::get_singleton()) {
+				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
+			}
+			_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+			ERR_FAIL_V(ERR_COMPILATION_FAILED);
+		} else {
+			return err;
+		}
+	}
+#ifdef DEBUG_ENABLED
+	for (const List<GDScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
+		const GDScriptWarning &warning = E->get();
+		if (ScriptDebugger::get_singleton()) {
+			Vector<ScriptLanguage::StackInfo> si;
+			ScriptDebugger::get_singleton()->send_error("", get_path(), warning.line, warning.get_name(), warning.get_message(), ERR_HANDLER_WARNING, si);
+		}
+	}
+#endif
+
+	valid = true;
+
+	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+		_set_subclass_path(E->get(), path);
+	}
+	_clear_pending_func_states();
+
+	return OK;
+}
+
+ScriptLanguage *GDScript::get_language() const {
+	return GDScriptLanguage::get_singleton();
+}
+
+void GDScript::get_constants(Map<StringName, Variant> *p_constants) {
+	if (p_constants) {
+		for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {
+			(*p_constants)[E->key()] = E->value();
+		}
+	}
+}
+
+void GDScript::get_members(Set<StringName> *p_members) {
+	if (p_members) {
+		for (Set<StringName>::Element *E = members.front(); E; E = E->next()) {
+			p_members->insert(E->get());
+		}
+	}
+}
+
+Variant GDScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	GDScript *top = this;
+	while (top) {
+		Map<StringName, GDScriptFunction *>::Element *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.");
+
+			return E->get()->call(nullptr, p_args, p_argcount, r_error);
+		}
+		top = top->_base;
+	}
+
+	//none found, regular
+
+	return Script::call(p_method, p_args, p_argcount, r_error);
+}
+
+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);
+				if (E) {
+					r_ret = E->get();
+					return true;
+				}
+			}
+
+			{
+				const Map<StringName, Ref<GDScript>>::Element *E = subclasses.find(p_name);
+				if (E) {
+					r_ret = E->get();
+					return true;
+				}
+			}
+			top = top->_base;
+		}
+
+		if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
+			r_ret = get_source_code();
+			return true;
+		}
+	}
+
+	return false;
+}
+bool GDScript::_set(const StringName &p_name, const Variant &p_value) {
+	if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
+		set_source_code(p_value);
+		reload();
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+void GDScript::_get_property_list(List<PropertyInfo> *p_properties) const {
+	p_properties->push_back(PropertyInfo(Variant::STRING, "script/source", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
+}
+
+void GDScript::_bind_methods() {
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &GDScript::_new, MethodInfo("new"));
+
+	ClassDB::bind_method(D_METHOD("get_as_byte_code"), &GDScript::get_as_byte_code);
+}
+
+Vector<uint8_t> GDScript::get_as_byte_code() const {
+	GDScriptTokenizerBuffer tokenizer;
+	return tokenizer.parse_code_string(source);
+};
+
+Error GDScript::load_byte_code(const String &p_path) {
+	Vector<uint8_t> bytecode;
+
+	if (p_path.ends_with("gde")) {
+		FileAccess *fa = FileAccess::open(p_path, FileAccess::READ);
+		ERR_FAIL_COND_V(!fa, ERR_CANT_OPEN);
+
+		FileAccessEncrypted *fae = memnew(FileAccessEncrypted);
+		ERR_FAIL_COND_V(!fae, ERR_CANT_OPEN);
+
+		Vector<uint8_t> key;
+		key.resize(32);
+		for (int i = 0; i < key.size(); i++) {
+			key.write[i] = script_encryption_key[i];
+		}
+
+		Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_READ);
+
+		if (err) {
+			fa->close();
+			memdelete(fa);
+			memdelete(fae);
+
+			ERR_FAIL_COND_V(err, err);
+		}
+
+		bytecode.resize(fae->get_len());
+		fae->get_buffer(bytecode.ptrw(), bytecode.size());
+		fae->close();
+		memdelete(fae);
+
+	} else {
+		bytecode = FileAccess::get_file_as_array(p_path);
+	}
+
+	ERR_FAIL_COND_V(bytecode.size() == 0, ERR_PARSE_ERROR);
+	path = p_path;
+
+	String basedir = path;
+
+	if (basedir == "") {
+		basedir = get_path();
+	}
+
+	if (basedir != "") {
+		basedir = basedir.get_base_dir();
+	}
+
+	valid = false;
+	GDScriptParser parser;
+	Error err = parser.parse_bytecode(bytecode, basedir, get_path());
+	if (err) {
+		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		ERR_FAIL_V(ERR_PARSE_ERROR);
+	}
+
+	GDScriptCompiler compiler;
+	err = compiler.compile(&parser, this);
+
+	if (err) {
+		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		ERR_FAIL_V(ERR_COMPILATION_FAILED);
+	}
+
+	valid = true;
+
+	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+		_set_subclass_path(E->get(), path);
+	}
+
+	return OK;
+}
+
+Error GDScript::load_source_code(const String &p_path) {
+	PoolVector<uint8_t> sourcef;
+	Error err;
+	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
+	if (err) {
+		ERR_FAIL_COND_V(err, err);
+	}
+
+	uint64_t len = f->get_len();
+	sourcef.resize(len + 1);
+	PoolVector<uint8_t>::Write w = sourcef.write();
+	uint64_t r = f->get_buffer(w.ptr(), len);
+	f->close();
+	memdelete(f);
+	ERR_FAIL_COND_V(r != len, ERR_CANT_OPEN);
+	w[len] = 0;
+
+	String s;
+	if (s.parse_utf8((const char *)w.ptr())) {
+		ERR_FAIL_V_MSG(ERR_INVALID_DATA, "Script '" + p_path + "' contains invalid unicode (UTF-8), so it was not loaded. Please ensure that scripts are saved in valid UTF-8 unicode.");
+	}
+
+	source = s;
+#ifdef TOOLS_ENABLED
+	source_changed_cache = true;
+#endif
+	path = p_path;
+	return OK;
+}
+
+const Map<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions() const {
+	return member_functions;
+}
+
+StringName GDScript::debug_get_member_by_index(int p_idx) const {
+	for (const Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
+		if (E->get().index == p_idx) {
+			return E->key();
+		}
+	}
+
+	return "<error>";
+}
+
+Ref<GDScript> GDScript::get_base() const {
+	return base;
+}
+
+bool GDScript::inherits_script(const Ref<Script> &p_script) const {
+	Ref<GDScript> gd = p_script;
+	if (gd.is_null()) {
+		return false;
+	}
+
+	const GDScript *s = this;
+
+	while (s) {
+		if (s == p_script.ptr()) {
+			return true;
+		}
+		s = s->_base;
+	}
+
+	return false;
+}
+
+bool GDScript::has_script_signal(const StringName &p_signal) const {
+	if (_signals.has(p_signal)) {
+		return true;
+	}
+	if (base.is_valid()) {
+		return base->has_script_signal(p_signal);
+	}
+#ifdef TOOLS_ENABLED
+	else if (base_cache.is_valid()) {
+		return base_cache->has_script_signal(p_signal);
+	}
+#endif
+	return false;
+}
+void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
+	for (const Map<StringName, Vector<StringName>>::Element *E = _signals.front(); E; E = E->next()) {
+		MethodInfo mi;
+		mi.name = E->key();
+		for (int i = 0; i < E->get().size(); i++) {
+			PropertyInfo arg;
+			arg.name = E->get()[i];
+			mi.arguments.push_back(arg);
+		}
+		r_signals->push_back(mi);
+	}
+
+	if (base.is_valid()) {
+		base->get_script_signal_list(r_signals);
+	}
+#ifdef TOOLS_ENABLED
+	else if (base_cache.is_valid()) {
+		base_cache->get_script_signal_list(r_signals);
+	}
+
+#endif
+}
+
+GDScript::GDScript() :
+		script_list(this) {
+	valid = false;
+	subclass_count = 0;
+	initializer = nullptr;
+	_base = nullptr;
+	_owner = nullptr;
+	tool = false;
+#ifdef TOOLS_ENABLED
+	source_changed_cache = false;
+	placeholder_fallback_enabled = false;
+#endif
+
+#ifdef DEBUG_ENABLED
+	GDScriptLanguage::get_singleton()->lock.lock();
+	GDScriptLanguage::get_singleton()->script_list.add(&script_list);
+	GDScriptLanguage::get_singleton()->lock.unlock();
+#endif
+}
+
+void GDScript::_save_orphaned_subclasses() {
+	struct ClassRefWithName {
+		ObjectID id;
+		String fully_qualified_name;
+	};
+	Vector<ClassRefWithName> weak_subclasses;
+	// collect subclasses ObjectID and name
+	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+		E->get()->_owner = nullptr; //bye, you are no longer owned cause I died
+		ClassRefWithName subclass;
+		subclass.id = E->get()->get_instance_id();
+		subclass.fully_qualified_name = E->get()->fully_qualified_name;
+		weak_subclasses.push_back(subclass);
+	}
+
+	// clear subclasses to allow unused subclasses to be deleted
+	subclasses.clear();
+	// subclasses are also held by constants, clear those as well
+	constants.clear();
+
+	// keep orphan subclass only for subclasses that are still in use
+	for (int i = 0; i < weak_subclasses.size(); i++) {
+		ClassRefWithName subclass = weak_subclasses[i];
+		Object *obj = ObjectDB::get_instance(subclass.id);
+		if (!obj) {
+			continue;
+		}
+		// subclass is not released
+		GDScriptLanguage::get_singleton()->add_orphan_subclass(subclass.fully_qualified_name, subclass.id);
+	}
+}
+
+GDScript::~GDScript() {
+	_clear_pending_func_states();
+
+	for (Map<StringName, GDScriptFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+
+	_save_orphaned_subclasses();
+
+#ifdef DEBUG_ENABLED
+	GDScriptLanguage::get_singleton()->lock.lock();
+	GDScriptLanguage::get_singleton()->script_list.remove(&script_list);
+	GDScriptLanguage::get_singleton()->lock.unlock();
+#endif
+}
+
+//////////////////////////////
+//         INSTANCE         //
+//////////////////////////////
+
+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);
+		if (E) {
+			const GDScript::MemberInfo *member = &E->get();
+			if (member->setter) {
+				const Variant *val = &p_value;
+				Variant::CallError err;
+				call(member->setter, &val, 1, err);
+				if (err.error == Variant::CallError::CALL_OK) {
+					return true; //function exists, call was successful
+				} else {
+					return false;
+				}
+			} else {
+				if (!member->data_type.is_type(p_value)) {
+					// Try conversion
+					Variant::CallError ce;
+					const Variant *value = &p_value;
+					Variant converted = Variant::construct(member->data_type.builtin_type, &value, 1, ce);
+					if (ce.error == Variant::CallError::CALL_OK) {
+						members.write[member->index] = converted;
+						return true;
+					} else {
+						return false;
+					}
+				} else {
+					members.write[member->index] = p_value;
+				}
+			}
+			return true;
+		}
+	}
+
+	GDScript *sptr = script.ptr();
+	while (sptr) {
+		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
+		if (E) {
+			Variant name = p_name;
+			const Variant *args[2] = { &name, &p_value };
+
+			Variant::CallError err;
+			Variant ret = E->get()->call(this, (const Variant **)args, 2, err);
+			if (err.error == Variant::CallError::CALL_OK && ret.get_type() == Variant::BOOL && ret.operator bool()) {
+				return true;
+			}
+		}
+		sptr = sptr->_base;
+	}
+
+	return false;
+}
+
+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);
+			if (E) {
+				if (E->get().getter) {
+					Variant::CallError err;
+					r_ret = const_cast<GDScriptInstance *>(this)->call(E->get().getter, nullptr, 0, err);
+					if (err.error == Variant::CallError::CALL_OK) {
+						return true;
+					}
+				}
+				r_ret = members[E->get().index];
+				return true; //index found
+			}
+		}
+
+		{
+			const GDScript *sl = sptr;
+			while (sl) {
+				const Map<StringName, Variant>::Element *E = sl->constants.find(p_name);
+				if (E) {
+					r_ret = E->get();
+					return true; //index found
+				}
+				sl = sl->_base;
+			}
+		}
+
+		{
+			const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
+			if (E) {
+				Variant name = p_name;
+				const Variant *args[1] = { &name };
+
+				Variant::CallError err;
+				Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), (const Variant **)args, 1, err);
+				if (err.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
+					r_ret = ret;
+					return true;
+				}
+			}
+		}
+		sptr = sptr->_base;
+	}
+
+	return false;
+}
+
+Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
+		if (sptr->member_info.has(p_name)) {
+			if (r_is_valid) {
+				*r_is_valid = true;
+			}
+			return sptr->member_info[p_name].type;
+		}
+		sptr = sptr->_base;
+	}
+
+	if (r_is_valid) {
+		*r_is_valid = false;
+	}
+	return Variant::NIL;
+}
+
+void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
+	// exported members, not done yet!
+
+	const GDScript *sptr = script.ptr();
+	List<PropertyInfo> props;
+
+	while (sptr) {
+		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
+		if (E) {
+			Variant::CallError err;
+			Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), nullptr, 0, err);
+			if (err.error == Variant::CallError::CALL_OK) {
+				ERR_FAIL_COND_MSG(ret.get_type() != Variant::ARRAY, "Wrong type for _get_property_list, must be an array of dictionaries.");
+
+				Array arr = ret;
+				for (int i = 0; i < arr.size(); i++) {
+					Dictionary d = arr[i];
+					ERR_CONTINUE(!d.has("name"));
+					ERR_CONTINUE(!d.has("type"));
+					PropertyInfo pinfo;
+					pinfo.type = Variant::Type(d["type"].operator int());
+					ERR_CONTINUE(pinfo.type < 0 || pinfo.type >= Variant::VARIANT_MAX);
+					pinfo.name = d["name"];
+					ERR_CONTINUE(pinfo.name == "");
+					if (d.has("hint")) {
+						pinfo.hint = PropertyHint(d["hint"].operator int());
+					}
+					if (d.has("hint_string")) {
+						pinfo.hint_string = d["hint_string"];
+					}
+					if (d.has("usage")) {
+						pinfo.usage = d["usage"];
+					}
+
+					props.push_back(pinfo);
+				}
+			}
+		}
+
+		//instance a fake script for editing the values
+
+		Vector<_GDScriptMemberSort> msort;
+		for (Map<StringName, PropertyInfo>::Element *F = sptr->member_info.front(); F; F = F->next()) {
+			_GDScriptMemberSort ms;
+			ERR_CONTINUE(!sptr->member_indices.has(F->key()));
+			ms.index = sptr->member_indices[F->key()].index;
+			ms.name = F->key();
+			msort.push_back(ms);
+		}
+
+		msort.sort();
+		msort.invert();
+		for (int i = 0; i < msort.size(); i++) {
+			props.push_front(sptr->member_info[msort[i].name]);
+		}
+
+		sptr = sptr->_base;
+	}
+
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+		p_properties->push_back(E->get());
+	}
+}
+
+void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
+	const GDScript *sptr = script.ptr();
+	while (sptr) {
+		for (Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.front(); E; E = E->next()) {
+			MethodInfo mi;
+			mi.name = E->key();
+			mi.flags |= METHOD_FLAG_FROM_SCRIPT;
+			for (int i = 0; i < E->get()->get_argument_count(); i++) {
+				mi.arguments.push_back(PropertyInfo(Variant::NIL, "arg" + itos(i)));
+			}
+			p_list->push_back(mi);
+		}
+		sptr = sptr->_base;
+	}
+}
+
+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);
+		if (E) {
+			return true;
+		}
+		sptr = sptr->_base;
+	}
+
+	return false;
+}
+Variant GDScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	GDScript *sptr = script.ptr();
+	while (sptr) {
+		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		if (E) {
+			return E->get()->call(this, p_args, p_argcount, r_error);
+		}
+		sptr = sptr->_base;
+	}
+	r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+	return Variant();
+}
+
+void GDScriptInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
+	GDScript *sptr = script.ptr();
+	Variant::CallError ce;
+
+	while (sptr) {
+		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		if (E) {
+			E->get()->call(this, p_args, p_argcount, ce);
+		}
+		sptr = sptr->_base;
+	}
+}
+
+void GDScriptInstance::_ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
+	if (sptr->_base) {
+		_ml_call_reversed(sptr->_base, p_method, p_args, p_argcount);
+	}
+
+	Variant::CallError ce;
+
+	Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+	if (E) {
+		E->get()->call(this, p_args, p_argcount, ce);
+	}
+}
+
+void GDScriptInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
+	if (script.ptr()) {
+		_ml_call_reversed(script.ptr(), p_method, p_args, p_argcount);
+	}
+}
+
+void GDScriptInstance::notification(int p_notification) {
+	//notification is not virtual, it gets called at ALL levels just like in C.
+	Variant value = p_notification;
+	const Variant *args[1] = { &value };
+
+	GDScript *sptr = script.ptr();
+	while (sptr) {
+		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
+		if (E) {
+			Variant::CallError err;
+			E->get()->call(this, args, 1, err);
+			if (err.error != Variant::CallError::CALL_OK) {
+				//print error about notification call
+			}
+		}
+		sptr = sptr->_base;
+	}
+}
+
+String GDScriptInstance::to_string(bool *r_valid) {
+	if (has_method(CoreStringNames::get_singleton()->_to_string)) {
+		Variant::CallError ce;
+		Variant ret = call(CoreStringNames::get_singleton()->_to_string, nullptr, 0, ce);
+		if (ce.error == Variant::CallError::CALL_OK) {
+			if (ret.get_type() != Variant::STRING) {
+				if (r_valid) {
+					*r_valid = false;
+				}
+				ERR_FAIL_V_MSG(String(), "Wrong type for " + CoreStringNames::get_singleton()->_to_string + ", must be a String.");
+			}
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return ret.operator String();
+		}
+	}
+	if (r_valid) {
+		*r_valid = false;
+	}
+	return String();
+}
+
+Ref<Script> GDScriptInstance::get_script() const {
+	return script;
+}
+
+ScriptLanguage *GDScriptInstance::get_language() {
+	return GDScriptLanguage::get_singleton();
+}
+
+MultiplayerAPI::RPCMode GDScriptInstance::get_rpc_mode(const StringName &p_method) const {
+	const GDScript *cscript = script.ptr();
+
+	while (cscript) {
+		const Map<StringName, GDScriptFunction *>::Element *E = cscript->member_functions.find(p_method);
+		if (E) {
+			if (E->get()->get_rpc_mode() != MultiplayerAPI::RPC_MODE_DISABLED) {
+				return E->get()->get_rpc_mode();
+			}
+		}
+		cscript = cscript->_base;
+	}
+
+	return MultiplayerAPI::RPC_MODE_DISABLED;
+}
+
+MultiplayerAPI::RPCMode GDScriptInstance::get_rset_mode(const StringName &p_variable) const {
+	const GDScript *cscript = script.ptr();
+
+	while (cscript) {
+		const Map<StringName, GDScript::MemberInfo>::Element *E = cscript->member_indices.find(p_variable);
+		if (E) {
+			if (E->get().rpc_mode) {
+				return E->get().rpc_mode;
+			}
+		}
+		cscript = cscript->_base;
+	}
+
+	return MultiplayerAPI::RPC_MODE_DISABLED;
+}
+
+void GDScriptInstance::reload_members() {
+#ifdef DEBUG_ENABLED
+
+	members.resize(script->member_indices.size()); //resize
+
+	Vector<Variant> new_members;
+	new_members.resize(script->member_indices.size());
+
+	//pass the values to the new indices
+	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+		if (member_indices_cache.has(E->key())) {
+			Variant value = members[member_indices_cache[E->key()]];
+			new_members.write[E->get().index] = value;
+		}
+	}
+
+	//apply
+	members = new_members;
+
+	//pass the values to the new indices
+	member_indices_cache.clear();
+	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+		member_indices_cache[E->key()] = E->get().index;
+	}
+
+#endif
+}
+
+GDScriptInstance::GDScriptInstance() {
+	owner = nullptr;
+	base_ref = false;
+}
+
+GDScriptInstance::~GDScriptInstance() {
+	GDScriptLanguage::singleton->lock.lock();
+
+	while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
+		// Order matters since clearing the stack may already cause
+		// the GDSCriptFunctionState to be destroyed and thus removed from the list.
+		pending_func_states.remove(E);
+		E->self()->_clear_stack();
+	}
+
+	if (script.is_valid() && owner) {
+		script->instances.erase(owner);
+	}
+
+	GDScriptLanguage::singleton->lock.unlock();
+}
+
+/************* SCRIPT LANGUAGE **************/
+
+GDScriptLanguage *GDScriptLanguage::singleton = nullptr;
+
+String GDScriptLanguage::get_name() const {
+	return "GDScript";
+}
+
+/* LANGUAGE FUNCTIONS */
+
+void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) {
+	if (globals.has(p_name)) {
+		//overwrite existing
+		global_array.write[globals[p_name]] = p_value;
+		return;
+	}
+	globals[p_name] = global_array.size();
+	global_array.push_back(p_value);
+	_global_array = global_array.ptrw();
+}
+
+void GDScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
+	_add_global(p_variable, p_value);
+}
+
+void GDScriptLanguage::add_named_global_constant(const StringName &p_name, const Variant &p_value) {
+	named_globals[p_name] = p_value;
+}
+
+void GDScriptLanguage::remove_named_global_constant(const StringName &p_name) {
+	ERR_FAIL_COND(!named_globals.has(p_name));
+	named_globals.erase(p_name);
+}
+
+void GDScriptLanguage::init() {
+	//populate global constants
+	int gcc = GlobalConstants::get_global_constant_count();
+	for (int i = 0; i < gcc; i++) {
+		_add_global(StaticCString::create(GlobalConstants::get_global_constant_name(i)), GlobalConstants::get_global_constant_value(i));
+	}
+
+	_add_global(StaticCString::create("PI"), Math_PI);
+	_add_global(StaticCString::create("TAU"), Math_TAU);
+	_add_global(StaticCString::create("INF"), Math_INF);
+	_add_global(StaticCString::create("NAN"), Math_NAN);
+
+	//populate native classes
+
+	List<StringName> class_list;
+	ClassDB::get_class_list(&class_list);
+	for (List<StringName>::Element *E = class_list.front(); E; E = E->next()) {
+		StringName n = E->get();
+		String s = String(n);
+		if (s.begins_with("_")) {
+			n = s.substr(1, s.length());
+		}
+
+		if (globals.has(n)) {
+			continue;
+		}
+		Ref<GDScriptNativeClass> nc = memnew(GDScriptNativeClass(E->get()));
+		_add_global(n, nc);
+	}
+
+	//populate singletons
+
+	List<Engine::Singleton> singletons;
+	Engine::get_singleton()->get_singletons(&singletons);
+	for (List<Engine::Singleton>::Element *E = singletons.front(); E; E = E->next()) {
+		_add_global(E->get().name, E->get().ptr);
+	}
+}
+
+String GDScriptLanguage::get_type() const {
+	return "GDScript";
+}
+String GDScriptLanguage::get_extension() const {
+	return "gd";
+}
+Error GDScriptLanguage::execute_file(const String &p_path) {
+	// ??
+	return OK;
+}
+void GDScriptLanguage::finish() {
+}
+
+void GDScriptLanguage::profiling_start() {
+#ifdef DEBUG_ENABLED
+	lock.lock();
+
+	SelfList<GDScriptFunction> *elem = function_list.first();
+	while (elem) {
+		elem->self()->profile.call_count = 0;
+		elem->self()->profile.self_time = 0;
+		elem->self()->profile.total_time = 0;
+		elem->self()->profile.frame_call_count = 0;
+		elem->self()->profile.frame_self_time = 0;
+		elem->self()->profile.frame_total_time = 0;
+		elem->self()->profile.last_frame_call_count = 0;
+		elem->self()->profile.last_frame_self_time = 0;
+		elem->self()->profile.last_frame_total_time = 0;
+		elem = elem->next();
+	}
+
+	profiling = true;
+	lock.unlock();
+#endif
+}
+
+void GDScriptLanguage::profiling_stop() {
+#ifdef DEBUG_ENABLED
+	lock.lock();
+	profiling = false;
+	lock.unlock();
+#endif
+}
+
+int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
+	int current = 0;
+#ifdef DEBUG_ENABLED
+	lock.lock();
+
+	SelfList<GDScriptFunction> *elem = function_list.first();
+	while (elem) {
+		if (current >= p_info_max) {
+			break;
+		}
+		p_info_arr[current].call_count = elem->self()->profile.call_count;
+		p_info_arr[current].self_time = elem->self()->profile.self_time;
+		p_info_arr[current].total_time = elem->self()->profile.total_time;
+		p_info_arr[current].signature = elem->self()->profile.signature;
+		elem = elem->next();
+		current++;
+	}
+
+	lock.unlock();
+#endif
+
+	return current;
+}
+
+int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
+	int current = 0;
+
+#ifdef DEBUG_ENABLED
+	lock.lock();
+
+	SelfList<GDScriptFunction> *elem = function_list.first();
+	while (elem) {
+		if (current >= p_info_max) {
+			break;
+		}
+		if (elem->self()->profile.last_frame_call_count > 0) {
+			p_info_arr[current].call_count = elem->self()->profile.last_frame_call_count;
+			p_info_arr[current].self_time = elem->self()->profile.last_frame_self_time;
+			p_info_arr[current].total_time = elem->self()->profile.last_frame_total_time;
+			p_info_arr[current].signature = elem->self()->profile.signature;
+			current++;
+		}
+		elem = elem->next();
+	}
+
+	lock.unlock();
+#endif
+
+	return current;
+}
+
+struct GDScriptDepSort {
+	//must support sorting so inheritance works properly (parent must be reloaded first)
+	bool operator()(const Ref<GDScript> &A, const Ref<GDScript> &B) const {
+		if (A == B) {
+			return false; //shouldn't happen but..
+		}
+		const GDScript *I = B->get_base().ptr();
+		while (I) {
+			if (I == A.ptr()) {
+				// A is a base of B
+				return true;
+			}
+
+			I = I->get_base().ptr();
+		}
+
+		return false; //not a base
+	}
+};
+
+void GDScriptLanguage::reload_all_scripts() {
+#ifdef DEBUG_ENABLED
+	print_verbose("GDScript: Reloading all scripts");
+	lock.lock();
+
+	List<Ref<GDScript>> scripts;
+
+	SelfList<GDScript> *elem = script_list.first();
+	while (elem) {
+		if (elem->self()->get_path().is_resource_file()) {
+			print_verbose("GDScript: Found: " + elem->self()->get_path());
+			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+		}
+		elem = elem->next();
+	}
+
+	lock.unlock();
+
+	//as scripts are going to be reloaded, must proceed without locking here
+
+	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+
+	for (List<Ref<GDScript>>::Element *E = scripts.front(); E; E = E->next()) {
+		print_verbose("GDScript: Reloading: " + E->get()->get_path());
+		E->get()->load_source_code(E->get()->get_path());
+		E->get()->reload(true);
+	}
+#endif
+}
+
+void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
+#ifdef DEBUG_ENABLED
+
+	lock.lock();
+
+	List<Ref<GDScript>> scripts;
+
+	SelfList<GDScript> *elem = script_list.first();
+	while (elem) {
+		if (elem->self()->get_path().is_resource_file()) {
+			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+		}
+		elem = elem->next();
+	}
+
+	lock.unlock();
+
+	//when someone asks you why dynamically typed languages are easier to write....
+
+	Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
+
+	//as scripts are going to be reloaded, must proceed without locking here
+
+	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+
+	for (List<Ref<GDScript>>::Element *E = scripts.front(); E; E = E->next()) {
+		bool reload = E->get() == p_script || to_reload.has(E->get()->get_base());
+
+		if (!reload) {
+			continue;
+		}
+
+		to_reload.insert(E->get(), Map<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[E->get()];
+
+			while (E->get()->instances.front()) {
+				Object *obj = E->get()->instances.front()->get();
+				//save instance info
+				List<Pair<StringName, Variant>> state;
+				if (obj->get_script_instance()) {
+					obj->get_script_instance()->get_property_state(state);
+					map[obj->get_instance_id()] = state;
+					obj->set_script(RefPtr());
+				}
+			}
+
+//same thing for placeholders
+#ifdef TOOLS_ENABLED
+
+			while (E->get()->placeholders.size()) {
+				Object *obj = E->get()->placeholders.front()->get()->get_owner();
+
+				//save instance info
+				if (obj->get_script_instance()) {
+					map.insert(obj->get_instance_id(), List<Pair<StringName, Variant>>());
+					List<Pair<StringName, Variant>> &state = map[obj->get_instance_id()];
+					obj->get_script_instance()->get_property_state(state);
+					obj->set_script(RefPtr());
+				} else {
+					// no instance found. Let's remove it so we don't loop forever
+					E->get()->placeholders.erase(E->get()->placeholders.front()->get());
+				}
+			}
+
+#endif
+
+			for (Map<ObjectID, List<Pair<StringName, Variant>>>::Element *F = E->get()->pending_reload_state.front(); F; F = F->next()) {
+				map[F->key()] = F->get(); //pending to reload, use this one instead
+			}
+		}
+	}
+
+	for (Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>>::Element *E = to_reload.front(); E; E = E->next()) {
+		Ref<GDScript> scr = E->key();
+		scr->reload(p_soft_reload);
+
+		//restore state if saved
+		for (Map<ObjectID, List<Pair<StringName, Variant>>>::Element *F = E->get().front(); F; F = F->next()) {
+			List<Pair<StringName, Variant>> &saved_state = F->get();
+
+			Object *obj = ObjectDB::get_instance(F->key());
+			if (!obj) {
+				continue;
+			}
+
+			if (!p_soft_reload) {
+				//clear it just in case (may be a pending reload state)
+				obj->set_script(RefPtr());
+			}
+			obj->set_script(scr.get_ref_ptr());
+
+			ScriptInstance *script_instance = obj->get_script_instance();
+
+			if (!script_instance) {
+				//failed, save reload state for next time if not saved
+				if (!scr->pending_reload_state.has(obj->get_instance_id())) {
+					scr->pending_reload_state[obj->get_instance_id()] = saved_state;
+				}
+				continue;
+			}
+
+			if (script_instance->is_placeholder() && scr->is_placeholder_fallback_enabled()) {
+				PlaceHolderScriptInstance *placeholder = static_cast<PlaceHolderScriptInstance *>(script_instance);
+				for (List<Pair<StringName, Variant>>::Element *G = saved_state.front(); G; G = G->next()) {
+					placeholder->property_set_fallback(G->get().first, G->get().second);
+				}
+			} else {
+				for (List<Pair<StringName, Variant>>::Element *G = saved_state.front(); G; G = G->next()) {
+					script_instance->set(G->get().first, G->get().second);
+				}
+			}
+
+			scr->pending_reload_state.erase(obj->get_instance_id()); //as it reloaded, remove pending state
+		}
+
+		//if instance states were saved, set them!
+	}
+
+#endif
+}
+
+void GDScriptLanguage::frame() {
+	calls = 0;
+
+#ifdef DEBUG_ENABLED
+	if (profiling) {
+		lock.lock();
+
+		SelfList<GDScriptFunction> *elem = function_list.first();
+		while (elem) {
+			elem->self()->profile.last_frame_call_count = elem->self()->profile.frame_call_count;
+			elem->self()->profile.last_frame_self_time = elem->self()->profile.frame_self_time;
+			elem->self()->profile.last_frame_total_time = elem->self()->profile.frame_total_time;
+			elem->self()->profile.frame_call_count = 0;
+			elem->self()->profile.frame_self_time = 0;
+			elem->self()->profile.frame_total_time = 0;
+			elem = elem->next();
+		}
+
+		lock.unlock();
+	}
+
+#endif
+}
+
+/* EDITOR FUNCTIONS */
+void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
+	static const char *_reserved_words[] = {
+		// operators
+		"and",
+		"in",
+		"not",
+		"or",
+		// types and values
+		"false",
+		"float",
+		"int",
+		"bool",
+		"null",
+		"PI",
+		"TAU",
+		"INF",
+		"NAN",
+		"self",
+		"true",
+		"void",
+		// functions
+		"as",
+		"assert",
+		"breakpoint",
+		"class",
+		"class_name",
+		"extends",
+		"is",
+		"func",
+		"preload",
+		"setget",
+		"signal",
+		"tool",
+		"yield",
+		// var
+		"const",
+		"enum",
+		"export",
+		"onready",
+		"static",
+		"var",
+		// control flow
+		"break",
+		"continue",
+		"if",
+		"elif",
+		"else",
+		"for",
+		"pass",
+		"return",
+		"match",
+		"while",
+		"remote",
+		"sync",
+		"master",
+		"puppet",
+		"slave",
+		"remotesync",
+		"mastersync",
+		"puppetsync",
+		nullptr
+	};
+
+	const char **w = _reserved_words;
+
+	while (*w) {
+		p_words->push_back(*w);
+		w++;
+	}
+
+	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+		p_words->push_back(GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i)));
+	}
+}
+
+bool GDScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+	return p_keyword == "break" ||
+			p_keyword == "continue" ||
+			p_keyword == "elif" ||
+			p_keyword == "else" ||
+			p_keyword == "if" ||
+			p_keyword == "for" ||
+			p_keyword == "match" ||
+			p_keyword == "pass" ||
+			p_keyword == "return" ||
+			p_keyword == "while";
+}
+
+bool GDScriptLanguage::handles_global_class_type(const String &p_type) const {
+	return p_type == "GDScript";
+}
+
+String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_base_type, String *r_icon_path) const {
+	PoolVector<uint8_t> sourcef;
+	Error err;
+	FileAccessRef f = FileAccess::open(p_path, FileAccess::READ, &err);
+	if (err) {
+		return String();
+	}
+
+	String source = f->get_as_utf8_string();
+
+	GDScriptParser parser;
+	parser.parse(source, p_path.get_base_dir(), true, p_path, false, nullptr, true);
+
+	if (parser.get_parse_tree() && parser.get_parse_tree()->type == GDScriptParser::Node::TYPE_CLASS) {
+		const GDScriptParser::ClassNode *c = static_cast<const GDScriptParser::ClassNode *>(parser.get_parse_tree());
+		if (r_icon_path) {
+			if (c->icon_path.empty() || c->icon_path.is_abs_path()) {
+				*r_icon_path = c->icon_path;
+			} else if (c->icon_path.is_rel_path()) {
+				*r_icon_path = p_path.get_base_dir().plus_file(c->icon_path).simplify_path();
+			}
+		}
+		if (r_base_type) {
+			const GDScriptParser::ClassNode *subclass = c;
+			String path = p_path;
+			GDScriptParser subparser;
+			while (subclass) {
+				if (subclass->extends_used) {
+					if (subclass->extends_file) {
+						if (subclass->extends_class.size() == 0) {
+							get_global_class_name(subclass->extends_file, r_base_type);
+							subclass = nullptr;
+							break;
+						} else {
+							Vector<StringName> extend_classes = subclass->extends_class;
+
+							FileAccessRef subfile = FileAccess::open(subclass->extends_file, FileAccess::READ);
+							if (!subfile) {
+								break;
+							}
+							String subsource = subfile->get_as_utf8_string();
+
+							if (subsource.empty()) {
+								break;
+							}
+							String subpath = subclass->extends_file;
+							if (subpath.is_rel_path()) {
+								subpath = path.get_base_dir().plus_file(subpath).simplify_path();
+							}
+
+							if (OK != subparser.parse(subsource, subpath.get_base_dir(), true, subpath, false, nullptr, true)) {
+								break;
+							}
+							path = subpath;
+							if (!subparser.get_parse_tree() || subparser.get_parse_tree()->type != GDScriptParser::Node::TYPE_CLASS) {
+								break;
+							}
+							subclass = static_cast<const GDScriptParser::ClassNode *>(subparser.get_parse_tree());
+
+							while (extend_classes.size() > 0) {
+								bool found = false;
+								for (int i = 0; i < subclass->subclasses.size(); i++) {
+									const GDScriptParser::ClassNode *inner_class = subclass->subclasses[i];
+									if (inner_class->name == extend_classes[0]) {
+										extend_classes.remove(0);
+										found = true;
+										subclass = inner_class;
+										break;
+									}
+								}
+								if (!found) {
+									subclass = nullptr;
+									break;
+								}
+							}
+						}
+					} else if (subclass->extends_class.size() == 1) {
+						*r_base_type = subclass->extends_class[0];
+						subclass = nullptr;
+					} else {
+						break;
+					}
+				} else {
+					*r_base_type = "Reference";
+					subclass = nullptr;
+				}
+			}
+		}
+		return c->name;
+	}
+
+	return String();
+}
+
+#ifdef DEBUG_ENABLED
+String GDScriptWarning::get_message() const {
+#define CHECK_SYMBOLS(m_amount) ERR_FAIL_COND_V(symbols.size() < m_amount, String());
+
+	switch (code) {
+		case UNASSIGNED_VARIABLE_OP_ASSIGN: {
+			CHECK_SYMBOLS(1);
+			return "Using assignment with operation but the variable '" + symbols[0] + "' was not previously assigned a value.";
+		} break;
+		case UNASSIGNED_VARIABLE: {
+			CHECK_SYMBOLS(1);
+			return "The variable '" + symbols[0] + "' was used but never assigned a value.";
+		} break;
+		case UNUSED_VARIABLE: {
+			CHECK_SYMBOLS(1);
+			return "The local variable '" + symbols[0] + "' is declared but never used in the block. If this is intended, prefix it with an underscore: '_" + symbols[0] + "'";
+		} break;
+		case SHADOWED_VARIABLE: {
+			CHECK_SYMBOLS(2);
+			return "The local variable '" + symbols[0] + "' is shadowing an already-defined variable at line " + symbols[1] + ".";
+		} break;
+		case UNUSED_CLASS_VARIABLE: {
+			CHECK_SYMBOLS(1);
+			return "The class variable '" + symbols[0] + "' is declared but never used in the script.";
+		} break;
+		case UNUSED_ARGUMENT: {
+			CHECK_SYMBOLS(2);
+			return "The argument '" + symbols[1] + "' is never used in the function '" + symbols[0] + "'. If this is intended, prefix it with an underscore: '_" + symbols[1] + "'";
+		} break;
+		case UNREACHABLE_CODE: {
+			CHECK_SYMBOLS(1);
+			return "Unreachable code (statement after return) in function '" + symbols[0] + "()'.";
+		} break;
+		case STANDALONE_EXPRESSION: {
+			return "Standalone expression (the line has no effect).";
+		} break;
+		case VOID_ASSIGNMENT: {
+			CHECK_SYMBOLS(1);
+			return "Assignment operation, but the function '" + symbols[0] + "()' returns void.";
+		} break;
+		case NARROWING_CONVERSION: {
+			return "Narrowing conversion (float is converted to int and loses precision).";
+		} break;
+		case FUNCTION_MAY_YIELD: {
+			CHECK_SYMBOLS(1);
+			return "Assigned variable is typed but the function '" + symbols[0] + "()' may yield and return a GDScriptFunctionState instead.";
+		} break;
+		case VARIABLE_CONFLICTS_FUNCTION: {
+			CHECK_SYMBOLS(1);
+			return "Variable declaration of '" + symbols[0] + "' conflicts with a function of the same name.";
+		} break;
+		case FUNCTION_CONFLICTS_VARIABLE: {
+			CHECK_SYMBOLS(1);
+			return "Function declaration of '" + symbols[0] + "()' conflicts with a variable of the same name.";
+		} break;
+		case FUNCTION_CONFLICTS_CONSTANT: {
+			CHECK_SYMBOLS(1);
+			return "Function declaration of '" + symbols[0] + "()' conflicts with a constant of the same name.";
+		} break;
+		case INCOMPATIBLE_TERNARY: {
+			return "Values of the ternary conditional are not mutually compatible.";
+		} break;
+		case UNUSED_SIGNAL: {
+			CHECK_SYMBOLS(1);
+			return "The signal '" + symbols[0] + "' is declared but never emitted.";
+		} break;
+		case RETURN_VALUE_DISCARDED: {
+			CHECK_SYMBOLS(1);
+			return "The function '" + symbols[0] + "()' returns a value, but this value is never used.";
+		} break;
+		case PROPERTY_USED_AS_FUNCTION: {
+			CHECK_SYMBOLS(2);
+			return "The method '" + symbols[0] + "()' was not found in base '" + symbols[1] + "' but there's a property with the same name. Did you mean to access it?";
+		} break;
+		case CONSTANT_USED_AS_FUNCTION: {
+			CHECK_SYMBOLS(2);
+			return "The method '" + symbols[0] + "()' was not found in base '" + symbols[1] + "' but there's a constant with the same name. Did you mean to access it?";
+		} break;
+		case FUNCTION_USED_AS_PROPERTY: {
+			CHECK_SYMBOLS(2);
+			return "The property '" + symbols[0] + "' was not found in base '" + symbols[1] + "' but there's a method with the same name. Did you mean to call it?";
+		} break;
+		case INTEGER_DIVISION: {
+			return "Integer division, decimal part will be discarded.";
+		} break;
+		case UNSAFE_PROPERTY_ACCESS: {
+			CHECK_SYMBOLS(2);
+			return "The property '" + symbols[0] + "' is not present on the inferred type '" + symbols[1] + "' (but may be present on a subtype).";
+		} break;
+		case UNSAFE_METHOD_ACCESS: {
+			CHECK_SYMBOLS(2);
+			return "The method '" + symbols[0] + "' is not present on the inferred type '" + symbols[1] + "' (but may be present on a subtype).";
+		} break;
+		case UNSAFE_CAST: {
+			CHECK_SYMBOLS(1);
+			return "The value is cast to '" + symbols[0] + "' but has an unknown type.";
+		} break;
+		case UNSAFE_CALL_ARGUMENT: {
+			CHECK_SYMBOLS(4);
+			return "The argument '" + symbols[0] + "' of the function '" + symbols[1] + "' requires a the subtype '" + symbols[2] + "' but the supertype '" + symbols[3] + "' was provided";
+		} break;
+		case DEPRECATED_KEYWORD: {
+			CHECK_SYMBOLS(2);
+			return "The '" + symbols[0] + "' keyword is deprecated and will be removed in a future release, please replace its uses by '" + symbols[1] + "'.";
+		} break;
+		case STANDALONE_TERNARY: {
+			return "Standalone ternary conditional operator: the return value is being discarded.";
+		}
+		case EXPORT_HINT_TYPE_MISTMATCH: {
+			CHECK_SYMBOLS(2);
+			return vformat("The type of the default value (%s) doesn't match the type of the export hint (%s). The type won't be coerced.", symbols[0], symbols[1]);
+		}
+		case WARNING_MAX:
+			break; // Can't happen, but silences warning
+	}
+	ERR_FAIL_V_MSG(String(), "Invalid GDScript warning code: " + get_name_from_code(code) + ".");
+
+#undef CHECK_SYMBOLS
+}
+
+String GDScriptWarning::get_name() const {
+	return get_name_from_code(code);
+}
+
+String GDScriptWarning::get_name_from_code(Code p_code) {
+	ERR_FAIL_COND_V(p_code < 0 || p_code >= WARNING_MAX, String());
+
+	static const char *names[] = {
+		"UNASSIGNED_VARIABLE",
+		"UNASSIGNED_VARIABLE_OP_ASSIGN",
+		"UNUSED_VARIABLE",
+		"SHADOWED_VARIABLE",
+		"UNUSED_CLASS_VARIABLE",
+		"UNUSED_ARGUMENT",
+		"UNREACHABLE_CODE",
+		"STANDALONE_EXPRESSION",
+		"VOID_ASSIGNMENT",
+		"NARROWING_CONVERSION",
+		"FUNCTION_MAY_YIELD",
+		"VARIABLE_CONFLICTS_FUNCTION",
+		"FUNCTION_CONFLICTS_VARIABLE",
+		"FUNCTION_CONFLICTS_CONSTANT",
+		"INCOMPATIBLE_TERNARY",
+		"UNUSED_SIGNAL",
+		"RETURN_VALUE_DISCARDED",
+		"PROPERTY_USED_AS_FUNCTION",
+		"CONSTANT_USED_AS_FUNCTION",
+		"FUNCTION_USED_AS_PROPERTY",
+		"INTEGER_DIVISION",
+		"UNSAFE_PROPERTY_ACCESS",
+		"UNSAFE_METHOD_ACCESS",
+		"UNSAFE_CAST",
+		"UNSAFE_CALL_ARGUMENT",
+		"DEPRECATED_KEYWORD",
+		"STANDALONE_TERNARY",
+		"EXPORT_HINT_TYPE_MISTMATCH",
+		nullptr
+	};
+
+	return names[(int)p_code];
+}
+
+GDScriptWarning::Code GDScriptWarning::get_code_from_name(const String &p_name) {
+	for (int i = 0; i < WARNING_MAX; i++) {
+		if (get_name_from_code((Code)i) == p_name) {
+			return (Code)i;
+		}
+	}
+
+	ERR_FAIL_V_MSG(WARNING_MAX, "Invalid GDScript warning name: " + p_name);
+}
+
+#endif // DEBUG_ENABLED
+
+GDScriptLanguage::GDScriptLanguage() {
+	calls = 0;
+	ERR_FAIL_COND(singleton);
+	singleton = this;
+	strings._init = StaticCString::create("_init");
+	strings._notification = StaticCString::create("_notification");
+	strings._set = StaticCString::create("_set");
+	strings._get = StaticCString::create("_get");
+	strings._get_property_list = StaticCString::create("_get_property_list");
+	strings._script_source = StaticCString::create("script/source");
+	_debug_parse_err_line = -1;
+	_debug_parse_err_file = "";
+
+	profiling = false;
+	script_frame_time = 0;
+
+	_debug_call_stack_pos = 0;
+	int dmcs = GLOBAL_DEF("debug/settings/gdscript/max_call_stack", 1024);
+	ProjectSettings::get_singleton()->set_custom_property_info("debug/settings/gdscript/max_call_stack", PropertyInfo(Variant::INT, "debug/settings/gdscript/max_call_stack", PROPERTY_HINT_RANGE, "1024,4096,1,or_greater")); //minimum is 1024
+
+	if (ScriptDebugger::get_singleton()) {
+		//debugging enabled!
+
+		_debug_max_call_stack = dmcs;
+		_call_stack = memnew_arr(CallLevel, _debug_max_call_stack + 1);
+
+	} else {
+		_debug_max_call_stack = 0;
+		_call_stack = nullptr;
+	}
+
+#ifdef DEBUG_ENABLED
+	GLOBAL_DEF("debug/gdscript/warnings/enable", true);
+	GLOBAL_DEF("debug/gdscript/warnings/treat_warnings_as_errors", false);
+	GLOBAL_DEF("debug/gdscript/warnings/exclude_addons", true);
+	GLOBAL_DEF("debug/gdscript/completion/autocomplete_setters_and_getters", false);
+	for (int i = 0; i < (int)GDScriptWarning::WARNING_MAX; i++) {
+		String warning = GDScriptWarning::get_name_from_code((GDScriptWarning::Code)i).to_lower();
+		bool default_enabled = !warning.begins_with("unsafe_") && i != GDScriptWarning::UNUSED_CLASS_VARIABLE;
+		GLOBAL_DEF("debug/gdscript/warnings/" + warning, default_enabled);
+	}
+#endif // DEBUG_ENABLED
+}
+
+GDScriptLanguage::~GDScriptLanguage() {
+	if (_call_stack) {
+		memdelete_arr(_call_stack);
+	}
+
+	// Clear dependencies between scripts, to ensure cyclic references are broken (to avoid leaks at exit).
+	SelfList<GDScript> *s = script_list.first();
+	while (s) {
+		GDScript *script = s->self();
+		// This ensures the current script is not released before we can check what's the next one
+		// in the list (we can't get the next upfront because we don't know if the reference breaking
+		// will cause it -or any other after it, for that matter- to be released so the next one
+		// is not the same as before).
+		script->reference();
+
+		for (Map<StringName, GDScriptFunction *>::Element *E = script->member_functions.front(); E; E = E->next()) {
+			GDScriptFunction *func = E->get();
+			for (int i = 0; i < func->argument_types.size(); i++) {
+				func->argument_types.write[i].script_type_ref = Ref<Script>();
+			}
+			func->return_type.script_type_ref = Ref<Script>();
+		}
+		for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+			E->get().data_type.script_type_ref = Ref<Script>();
+		}
+
+		s = s->next();
+		script->unreference();
+	}
+
+	singleton = nullptr;
+}
+
+void GDScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass) {
+	orphan_subclasses[p_qualified_name] = p_subclass;
+}
+
+Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_name) {
+	Map<String, ObjectID>::Element *orphan_subclass_element = orphan_subclasses.find(p_qualified_name);
+	if (!orphan_subclass_element) {
+		return Ref<GDScript>();
+	}
+	ObjectID orphan_subclass = orphan_subclass_element->get();
+	Object *obj = ObjectDB::get_instance(orphan_subclass);
+	orphan_subclasses.erase(orphan_subclass_element);
+	if (!obj) {
+		return Ref<GDScript>();
+	}
+	return Ref<GDScript>(Object::cast_to<GDScript>(obj));
+}
+
+/*************** RESOURCE ***************/
+
+RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+	if (r_error) {
+		*r_error = ERR_FILE_CANT_OPEN;
+	}
+
+	GDScript *script = memnew(GDScript);
+
+	Ref<GDScript> scriptres(script);
+
+	if (p_path.ends_with(".gde") || p_path.ends_with(".gdc")) {
+		script->set_script_path(p_original_path); // script needs this.
+		script->set_path(p_original_path, true);
+		Error err = script->load_byte_code(p_path);
+		ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot load byte code from file '" + p_path + "'.");
+
+	} else {
+		Error err = script->load_source_code(p_path);
+		ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot load source code from file '" + p_path + "'.");
+
+		script->set_script_path(p_original_path); // script needs this.
+		script->set_path(p_original_path, true);
+
+		script->reload();
+	}
+	if (r_error) {
+		*r_error = OK;
+	}
+
+	return scriptres;
+}
+
+void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back("gd");
+	p_extensions->push_back("gdc");
+	p_extensions->push_back("gde");
+}
+
+bool ResourceFormatLoaderGDScript::handles_type(const String &p_type) const {
+	return (p_type == "Script" || p_type == "GDScript");
+}
+
+String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const {
+	String el = p_path.get_extension().to_lower();
+	if (el == "gd" || el == "gdc" || el == "gde") {
+		return "GDScript";
+	}
+	return "";
+}
+
+void ResourceFormatLoaderGDScript::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
+	FileAccessRef file = FileAccess::open(p_path, FileAccess::READ);
+	ERR_FAIL_COND_MSG(!file, "Cannot open file '" + p_path + "'.");
+
+	String source = file->get_as_utf8_string();
+	if (source.empty()) {
+		return;
+	}
+
+	GDScriptParser parser;
+	if (OK != parser.parse(source, p_path.get_base_dir(), true, p_path, false, nullptr, true)) {
+		return;
+	}
+
+	for (const List<String>::Element *E = parser.get_dependencies().front(); E; E = E->next()) {
+		p_dependencies->push_back(E->get());
+	}
+}
+
+Error ResourceFormatSaverGDScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
+	Ref<GDScript> sqscr = p_resource;
+	ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
+
+	String source = sqscr->get_source_code();
+
+	Error err;
+	FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err);
+
+	ERR_FAIL_COND_V_MSG(err, err, "Cannot save GDScript file '" + p_path + "'.");
+
+	file->store_string(source);
+	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
+		memdelete(file);
+		return ERR_CANT_CREATE;
+	}
+	file->close();
+	memdelete(file);
+
+	if (ScriptServer::is_reload_scripts_on_save_enabled()) {
+		GDScriptLanguage::get_singleton()->reload_tool_script(p_resource, false);
+	}
+
+	return OK;
+}
+
+void ResourceFormatSaverGDScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
+	if (Object::cast_to<GDScript>(*p_resource)) {
+		p_extensions->push_back("gd");
+	}
+}
+bool ResourceFormatSaverGDScript::recognize(const RES &p_resource) const {
+	return Object::cast_to<GDScript>(*p_resource) != nullptr;
+}
diff --git a/modules/cscript/cscript.h b/modules/cscript/cscript.h
new file mode 100644
index 000000000..d8ad383c3
--- /dev/null
+++ b/modules/cscript/cscript.h
@@ -0,0 +1,567 @@
+#ifndef CSCRIPT_H
+#define CSCRIPT_H
+/*************************************************************************/
+/*  gdscript.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/io/resource_loader.h"
+#include "core/io/resource_saver.h"
+#include "core/script_language.h"
+#include "cscript_function.h"
+
+class GDScriptNativeClass : public Reference {
+	GDCLASS(GDScriptNativeClass, Reference);
+
+	StringName name;
+
+protected:
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	static void _bind_methods();
+
+public:
+	_FORCE_INLINE_ const StringName &get_name() const { return name; }
+	Variant _new();
+	Object *instance();
+	GDScriptNativeClass(const StringName &p_name);
+};
+
+class GDScript : public Script {
+	GDCLASS(GDScript, Script);
+	bool tool;
+	bool valid;
+
+	struct MemberInfo {
+		int index;
+		StringName setter;
+		StringName getter;
+		MultiplayerAPI::RPCMode rpc_mode;
+		GDScriptDataType data_type;
+	};
+
+	friend class GDScriptInstance;
+	friend class GDScriptFunction;
+	friend class GDScriptCompiler;
+	friend class GDScriptFunctions;
+	friend class GDScriptLanguage;
+
+	Ref<GDScriptNativeClass> native;
+	Ref<GDScript> base;
+	GDScript *_base; //fast pointer access
+	GDScript *_owner; //for subclasses
+
+	Set<StringName> members; //members are just indices to the instanced script.
+	Map<StringName, Variant> constants;
+	Map<StringName, GDScriptFunction *> member_functions;
+	Map<StringName, MemberInfo> member_indices; //members are just indices to the instanced script.
+	Map<StringName, Ref<GDScript>> subclasses;
+	Map<StringName, Vector<StringName>> _signals;
+
+#ifdef TOOLS_ENABLED
+
+	Map<StringName, int> member_lines;
+
+	Map<StringName, Variant> member_default_values;
+
+	List<PropertyInfo> members_cache;
+	Map<StringName, Variant> member_default_values_cache;
+	Ref<GDScript> base_cache;
+	Set<ObjectID> inheriters_cache;
+	bool source_changed_cache;
+	bool placeholder_fallback_enabled;
+	void _update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames);
+
+#endif
+	Map<StringName, PropertyInfo> member_info;
+
+	GDScriptFunction *initializer; //direct pointer to _init , faster to locate
+
+	int subclass_count;
+	Set<Object *> instances;
+	//exported members
+	String source;
+	String path;
+	String name;
+	String fully_qualified_name;
+	SelfList<GDScript> script_list;
+
+	SelfList<GDScriptFunctionState>::List pending_func_states;
+	void _clear_pending_func_states();
+
+	GDScriptInstance *_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error);
+
+	void _set_subclass_path(Ref<GDScript> &p_sc, const String &p_path);
+	String _get_debug_path() const;
+
+#ifdef TOOLS_ENABLED
+	Set<PlaceHolderScriptInstance *> placeholders;
+	//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
+	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
+#endif
+
+#ifdef DEBUG_ENABLED
+
+	Map<ObjectID, List<Pair<StringName, Variant>>> pending_reload_state;
+
+#endif
+
+	bool _update_exports(bool *r_err = nullptr, bool p_recursive_call = false, PlaceHolderScriptInstance *p_instance_to_update = nullptr);
+
+	void _save_orphaned_subclasses();
+
+protected:
+	bool _get(const StringName &p_name, Variant &r_ret) const;
+	bool _set(const StringName &p_name, const Variant &p_value);
+	void _get_property_list(List<PropertyInfo> *p_properties) const;
+
+	Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	//void call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount);
+
+	static void _bind_methods();
+
+public:
+	virtual bool is_valid() const {
+		return valid;
+	}
+
+	bool inherits_script(const Ref<Script> &p_script) const;
+
+	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 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 Ref<GDScriptNativeClass> &get_native() const {
+		return native;
+	}
+	const String &get_script_class_name() const {
+		return name;
+	}
+
+	virtual bool has_script_signal(const StringName &p_signal) const;
+	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
+
+	bool is_tool() const {
+		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
+	StringName debug_get_member_by_index(int p_idx) const;
+
+	Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	virtual bool can_instance() const;
+
+	virtual Ref<Script> get_base_script() const;
+
+	virtual StringName get_instance_base_type() const; // this may not work in all scripts, will return empty if so
+	virtual ScriptInstance *instance_create(Object *p_this);
+	virtual PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this);
+	virtual bool instance_has(const Object *p_this) const;
+
+	virtual bool has_source_code() const;
+	virtual String get_source_code() const;
+	virtual void set_source_code(const String &p_code);
+	virtual void update_exports();
+
+	virtual Error reload(bool p_keep_state = false);
+
+	void set_script_path(const String &p_path) {
+		path = p_path;
+	} //because subclasses need a path too...
+	Error load_source_code(const String &p_path);
+	Error load_byte_code(const String &p_path);
+
+	Vector<uint8_t> get_as_byte_code() const;
+
+	bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
+
+	virtual void get_script_method_list(List<MethodInfo> *p_list) const;
+	virtual bool has_method(const StringName &p_method) const;
+	virtual MethodInfo get_method_info(const StringName &p_method) const;
+
+	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
+
+	virtual ScriptLanguage *get_language() const;
+
+	virtual int get_member_line(const StringName &p_member) const {
+#ifdef TOOLS_ENABLED
+		if (member_lines.has(p_member)) {
+			return member_lines[p_member];
+		}
+#endif
+		return -1;
+	}
+
+	virtual void get_constants(Map<StringName, Variant> *p_constants);
+	virtual void get_members(Set<StringName> *p_members);
+
+#ifdef TOOLS_ENABLED
+	virtual bool is_placeholder_fallback_enabled() const {
+		return placeholder_fallback_enabled;
+	}
+#endif
+
+	GDScript();
+	~GDScript();
+};
+
+class GDScriptInstance : public ScriptInstance {
+	friend class GDScript;
+	friend class GDScriptFunction;
+	friend class GDScriptFunctions;
+	friend class GDScriptCompiler;
+
+	Object *owner;
+	Ref<GDScript> script;
+#ifdef DEBUG_ENABLED
+	Map<StringName, int> member_indices_cache; //used only for hot script reloading
+#endif
+	Vector<Variant> members;
+	bool base_ref;
+
+	SelfList<GDScriptFunctionState>::List pending_func_states;
+
+	void _ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount);
+
+public:
+	virtual Object *get_owner() {
+		return owner;
+	}
+
+	virtual bool set(const StringName &p_name, const Variant &p_value);
+	virtual bool get(const StringName &p_name, Variant &r_ret) const;
+	virtual void get_property_list(List<PropertyInfo> *p_properties) const;
+	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const;
+
+	virtual void get_method_list(List<MethodInfo> *p_list) const;
+	virtual bool has_method(const StringName &p_method) const;
+	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	virtual void call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount);
+	virtual void call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount);
+
+	Variant debug_get_member_by_index(int p_idx) const {
+		return members[p_idx];
+	}
+
+	virtual void notification(int p_notification);
+	String to_string(bool *r_valid);
+
+	virtual Ref<Script> get_script() const;
+
+	virtual ScriptLanguage *get_language();
+
+	void reload_members();
+
+	virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const;
+	virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const;
+
+	GDScriptInstance();
+	~GDScriptInstance();
+};
+
+#ifdef DEBUG_ENABLED
+struct GDScriptWarning {
+	enum Code {
+		UNASSIGNED_VARIABLE, // Variable used but never assigned
+		UNASSIGNED_VARIABLE_OP_ASSIGN, // Variable never assigned but used in an assignment operation (+=, *=, etc)
+		UNUSED_VARIABLE, // Local variable is declared but never used
+		SHADOWED_VARIABLE, // Variable name shadowed by other variable
+		UNUSED_CLASS_VARIABLE, // Class variable is declared but never used in the file
+		UNUSED_ARGUMENT, // Function argument is never used
+		UNREACHABLE_CODE, // Code after a return statement
+		STANDALONE_EXPRESSION, // Expression not assigned to a variable
+		VOID_ASSIGNMENT, // Function returns void but it's assigned to a variable
+		NARROWING_CONVERSION, // Float value into an integer slot, precision is lost
+		FUNCTION_MAY_YIELD, // Typed assign of function call that yields (it may return a function state)
+		VARIABLE_CONFLICTS_FUNCTION, // Variable has the same name of a function
+		FUNCTION_CONFLICTS_VARIABLE, // Function has the same name of a variable
+		FUNCTION_CONFLICTS_CONSTANT, // Function has the same name of a constant
+		INCOMPATIBLE_TERNARY, // Possible values of a ternary if are not mutually compatible
+		UNUSED_SIGNAL, // Signal is defined but never emitted
+		RETURN_VALUE_DISCARDED, // Function call returns something but the value isn't used
+		PROPERTY_USED_AS_FUNCTION, // Function not found, but there's a property with the same name
+		CONSTANT_USED_AS_FUNCTION, // Function not found, but there's a constant with the same name
+		FUNCTION_USED_AS_PROPERTY, // Property not found, but there's a function with the same name
+		INTEGER_DIVISION, // Integer divide by integer, decimal part is discarded
+		UNSAFE_PROPERTY_ACCESS, // Property not found in the detected type (but can be in subtypes)
+		UNSAFE_METHOD_ACCESS, // Function not found in the detected type (but can be in subtypes)
+		UNSAFE_CAST, // Cast used in an unknown type
+		UNSAFE_CALL_ARGUMENT, // Function call argument is of a supertype of the require argument
+		DEPRECATED_KEYWORD, // The keyword is deprecated and should be replaced
+		STANDALONE_TERNARY, // Return value of ternary expression is discarded
+		EXPORT_HINT_TYPE_MISTMATCH, // The type of the variable's default value doesn't match its export hint
+		WARNING_MAX,
+	} code;
+	Vector<String> symbols;
+	int line;
+
+	String get_name() const;
+	String get_message() const;
+	static String get_name_from_code(Code p_code);
+	static Code get_code_from_name(const String &p_name);
+
+	GDScriptWarning() :
+			code(WARNING_MAX),
+			line(-1) {}
+};
+#endif // DEBUG_ENABLED
+
+class GDScriptLanguage : public ScriptLanguage {
+	friend class GDScriptFunctionState;
+
+	static GDScriptLanguage *singleton;
+
+	Variant *_global_array;
+	Vector<Variant> global_array;
+	Map<StringName, int> globals;
+	Map<StringName, Variant> named_globals;
+
+	struct CallLevel {
+		Variant *stack;
+		GDScriptFunction *function;
+		GDScriptInstance *instance;
+		int *ip;
+		int *line;
+	};
+
+	int _debug_parse_err_line;
+	String _debug_parse_err_file;
+	String _debug_error;
+	int _debug_call_stack_pos;
+	int _debug_max_call_stack;
+	CallLevel *_call_stack;
+
+	void _add_global(const StringName &p_name, const Variant &p_value);
+
+	friend class GDScriptInstance;
+
+	Mutex lock;
+
+	friend class GDScript;
+
+	SelfList<GDScript>::List script_list;
+	friend class GDScriptFunction;
+
+	SelfList<GDScriptFunction>::List function_list;
+	bool profiling;
+	uint64_t script_frame_time;
+
+	Map<String, ObjectID> orphan_subclasses;
+
+public:
+	int calls;
+
+	bool debug_break(const String &p_error, bool p_allow_continue = true);
+	bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
+
+	_FORCE_INLINE_ void enter_function(GDScriptInstance *p_instance, GDScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
+			return; //no support for other threads than main for now
+		}
+
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0) {
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() + 1);
+		}
+
+		if (_debug_call_stack_pos >= _debug_max_call_stack) {
+			//stack overflow
+			_debug_error = "Stack Overflow (Stack Size: " + itos(_debug_max_call_stack) + ")";
+			ScriptDebugger::get_singleton()->debug(this);
+			return;
+		}
+
+		_call_stack[_debug_call_stack_pos].stack = p_stack;
+		_call_stack[_debug_call_stack_pos].instance = p_instance;
+		_call_stack[_debug_call_stack_pos].function = p_function;
+		_call_stack[_debug_call_stack_pos].ip = p_ip;
+		_call_stack[_debug_call_stack_pos].line = p_line;
+		_debug_call_stack_pos++;
+	}
+
+	_FORCE_INLINE_ void exit_function() {
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
+			return; //no support for other threads than main for now
+		}
+
+		if (ScriptDebugger::get_singleton()->get_lines_left() > 0 && ScriptDebugger::get_singleton()->get_depth() >= 0) {
+			ScriptDebugger::get_singleton()->set_depth(ScriptDebugger::get_singleton()->get_depth() - 1);
+		}
+
+		if (_debug_call_stack_pos == 0) {
+			_debug_error = "Stack Underflow (Engine Bug)";
+			ScriptDebugger::get_singleton()->debug(this);
+			return;
+		}
+
+		_debug_call_stack_pos--;
+	}
+
+	virtual Vector<StackInfo> debug_get_current_stack_info() {
+		if (Thread::get_main_id() != Thread::get_caller_id()) {
+			return Vector<StackInfo>();
+		}
+
+		Vector<StackInfo> csi;
+		csi.resize(_debug_call_stack_pos);
+		for (int i = 0; i < _debug_call_stack_pos; i++) {
+			csi.write[_debug_call_stack_pos - i - 1].line = _call_stack[i].line ? *_call_stack[i].line : 0;
+			if (_call_stack[i].function) {
+				csi.write[_debug_call_stack_pos - i - 1].func = _call_stack[i].function->get_name();
+				csi.write[_debug_call_stack_pos - i - 1].file = _call_stack[i].function->get_script()->get_path();
+			}
+		}
+		return csi;
+	}
+
+	struct {
+		StringName _init;
+		StringName _notification;
+		StringName _set;
+		StringName _get;
+		StringName _get_property_list;
+		StringName _script_source;
+
+	} strings;
+
+	_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_ static GDScriptLanguage *get_singleton() { return singleton; }
+
+	virtual String get_name() const;
+
+	/* LANGUAGE FUNCTIONS */
+	virtual void init();
+	virtual String get_type() const;
+	virtual String get_extension() const;
+	virtual Error execute_file(const String &p_path);
+	virtual void finish();
+
+	/* EDITOR FUNCTIONS */
+	virtual void get_reserved_words(List<String> *p_words) const;
+	virtual bool is_control_flow_keyword(String p_keywords) const;
+	virtual void get_comment_delimiters(List<String> *p_delimiters) const;
+	virtual void get_string_delimiters(List<String> *p_delimiters) const;
+	virtual String _get_processed_template(const String &p_template, const String &p_base_class_name) const;
+	virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
+	virtual bool is_using_templates();
+	virtual void make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script);
+	virtual bool validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptLanguage::Warning> *r_warnings = nullptr, Set<int> *r_safe_lines = nullptr) const;
+	virtual Script *create_script() const;
+	virtual bool has_named_classes() const;
+	virtual bool supports_builtin_mode() const;
+	virtual bool can_inherit_from_file() { return true; }
+	virtual int find_function(const String &p_function, const String &p_code) const;
+	virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const;
+	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint);
+#ifdef TOOLS_ENABLED
+	virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result);
+#endif
+	virtual String _get_indentation() const;
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const;
+	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value);
+	virtual void add_named_global_constant(const StringName &p_name, const Variant &p_value);
+	virtual void remove_named_global_constant(const StringName &p_name);
+
+	/* DEBUGGER FUNCTIONS */
+
+	virtual String debug_get_error() const;
+	virtual int debug_get_stack_level_count() const;
+	virtual int debug_get_stack_level_line(int p_level) const;
+	virtual String debug_get_stack_level_function(int p_level) const;
+	virtual String debug_get_stack_level_source(int p_level) const;
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual ScriptInstance *debug_get_stack_level_instance(int p_level);
+	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1);
+
+	virtual void reload_all_scripts();
+	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload);
+
+	virtual void frame();
+
+	virtual void get_public_functions(List<MethodInfo> *p_functions) const;
+	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const;
+
+	virtual void profiling_start();
+	virtual void profiling_stop();
+
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max);
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max);
+
+	/* LOADER FUNCTIONS */
+
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
+
+	/* GLOBAL CLASSES */
+
+	virtual bool handles_global_class_type(const String &p_type) const;
+	virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const;
+
+	void add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass);
+	Ref<GDScript> get_orphan_subclass(const String &p_qualified_name);
+
+	GDScriptLanguage();
+	~GDScriptLanguage();
+};
+
+class ResourceFormatLoaderGDScript : public ResourceFormatLoader {
+public:
+	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
+	virtual bool handles_type(const String &p_type) const;
+	virtual String get_resource_type(const String &p_path) const;
+	virtual void get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types = false);
+};
+
+class ResourceFormatSaverGDScript : public ResourceFormatSaver {
+public:
+	virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
+	virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
+	virtual bool recognize(const RES &p_resource) const;
+};
+
+#endif // GDSCRIPT_H
diff --git a/modules/cscript/cscript_compiler.cpp b/modules/cscript/cscript_compiler.cpp
new file mode 100644
index 000000000..7312e566e
--- /dev/null
+++ b/modules/cscript/cscript_compiler.cpp
@@ -0,0 +1,2236 @@
+/*************************************************************************/
+/*  gdscript_compiler.cpp                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript_compiler.h"
+
+#include "cscript.h"
+
+bool GDScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
+	if (codegen.function_node && codegen.function_node->_static) {
+		return false;
+	}
+
+	if (codegen.stack_identifiers.has(p_name)) {
+		return false; //shadowed
+	}
+
+	return _is_class_member_property(codegen.script, p_name);
+}
+
+bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) {
+	GDScript *scr = owner;
+	GDScriptNativeClass *nc = nullptr;
+	while (scr) {
+		if (scr->native.is_valid()) {
+			nc = scr->native.ptr();
+		}
+		scr = scr->_base;
+	}
+
+	ERR_FAIL_COND_V(!nc, false);
+
+	return ClassDB::has_property(nc->get_name(), p_name);
+}
+
+void GDScriptCompiler::_set_error(const String &p_error, const GDScriptParser::Node *p_node) {
+	if (error != "") {
+		return;
+	}
+
+	error = p_error;
+	if (p_node) {
+		err_line = p_node->line;
+		err_column = p_node->column;
+	} else {
+		err_line = 0;
+		err_column = 0;
+	}
+}
+
+bool GDScriptCompiler::_create_unary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level) {
+	ERR_FAIL_COND_V(on->arguments.size() != 1, false);
+
+	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level);
+	if (src_address_a < 0) {
+		return false;
+	}
+
+	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(op); //which operator
+	codegen.opcodes.push_back(src_address_a); // argument 1
+	codegen.opcodes.push_back(src_address_a); // argument 2 (repeated)
+	//codegen.opcodes.push_back(GDScriptFunction::ADDR_TYPE_NIL); // argument 2 (unary only takes one parameter)
+	return true;
+}
+
+bool GDScriptCompiler::_create_binary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer, int p_index_addr) {
+	ERR_FAIL_COND_V(on->arguments.size() != 2, false);
+
+	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer, p_index_addr);
+	if (src_address_a < 0) {
+		return false;
+	}
+	if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+		p_stack_level++; //uses stack for return, increase stack
+	}
+
+	int src_address_b = _parse_expression(codegen, on->arguments[1], p_stack_level, false, p_initializer);
+	if (src_address_b < 0) {
+		return false;
+	}
+
+	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(op); //which operator
+	codegen.opcodes.push_back(src_address_a); // argument 1
+	codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+	return true;
+}
+
+GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::DataType &p_datatype, GDScript *p_owner) const {
+	if (!p_datatype.has_type) {
+		return GDScriptDataType();
+	}
+
+	GDScriptDataType result;
+	result.has_type = true;
+
+	switch (p_datatype.kind) {
+		case GDScriptParser::DataType::BUILTIN: {
+			result.kind = GDScriptDataType::BUILTIN;
+			result.builtin_type = p_datatype.builtin_type;
+		} break;
+		case GDScriptParser::DataType::NATIVE: {
+			result.kind = GDScriptDataType::NATIVE;
+			result.native_type = p_datatype.native_type;
+		} break;
+		case GDScriptParser::DataType::SCRIPT: {
+			result.kind = GDScriptDataType::SCRIPT;
+			result.script_type_ref = Ref<Script>(p_datatype.script_type);
+			result.script_type = result.script_type_ref.ptr();
+			result.native_type = result.script_type->get_instance_base_type();
+		} break;
+		case GDScriptParser::DataType::GDSCRIPT: {
+			result.kind = GDScriptDataType::GDSCRIPT;
+			result.script_type_ref = Ref<Script>(p_datatype.script_type);
+			result.script_type = result.script_type_ref.ptr();
+			result.native_type = result.script_type->get_instance_base_type();
+		} break;
+		case GDScriptParser::DataType::CLASS: {
+			// Locate class by constructing the path to it and following that path
+			GDScriptParser::ClassNode *class_type = p_datatype.class_type;
+			List<StringName> names;
+			while (class_type->owner) {
+				names.push_back(class_type->name);
+				class_type = class_type->owner;
+			}
+
+			Ref<GDScript> script = Ref<GDScript>(main_script);
+			while (names.back()) {
+				if (!script->subclasses.has(names.back()->get())) {
+					ERR_PRINT("Parser bug: Cannot locate datatype class.");
+					result.has_type = false;
+					return GDScriptDataType();
+				}
+				script = script->subclasses[names.back()->get()];
+				names.pop_back();
+			}
+
+			result.kind = GDScriptDataType::GDSCRIPT;
+			result.script_type_ref = Ref<Script>(script);
+			result.script_type = result.script_type_ref.ptr();
+			result.native_type = script->get_instance_base_type();
+		} break;
+		default: {
+			ERR_PRINT("Parser bug: converting unresolved type.");
+			return GDScriptDataType();
+		}
+	}
+
+	// Only hold strong reference to the script if it's not the owner of the
+	// element qualified with this type, to avoid cyclic references (leaks).
+	if (result.script_type && result.script_type == p_owner) {
+		result.script_type_ref = Ref<Script>();
+	}
+
+	return result;
+}
+
+int GDScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr) {
+	Variant::Operator var_op = Variant::OP_MAX;
+
+	switch (p_expression->op) {
+		case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
+			var_op = Variant::OP_ADD;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_SUB:
+			var_op = Variant::OP_SUBTRACT;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_MUL:
+			var_op = Variant::OP_MULTIPLY;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_DIV:
+			var_op = Variant::OP_DIVIDE;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_MOD:
+			var_op = Variant::OP_MODULE;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+			var_op = Variant::OP_SHIFT_LEFT;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+			var_op = Variant::OP_SHIFT_RIGHT;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
+			var_op = Variant::OP_BIT_AND;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
+			var_op = Variant::OP_BIT_OR;
+			break;
+		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
+			var_op = Variant::OP_BIT_XOR;
+			break;
+		case GDScriptParser::OperatorNode::OP_INIT_ASSIGN:
+		case GDScriptParser::OperatorNode::OP_ASSIGN: {
+			//none
+		} break;
+		default: {
+			ERR_FAIL_V(-1);
+		}
+	}
+
+	bool initializer = p_expression->op == GDScriptParser::OperatorNode::OP_INIT_ASSIGN;
+
+	if (var_op == Variant::OP_MAX) {
+		return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer);
+	}
+
+	if (!_create_binary_operator(codegen, p_expression, var_op, p_stack_level, initializer, p_index_addr)) {
+		return -1;
+	}
+
+	int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+	codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+	codegen.alloc_stack(p_stack_level);
+	return dst_addr;
+}
+
+int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::Node *p_expression, int p_stack_level, bool p_root, bool p_initializer, int p_index_addr) {
+	switch (p_expression->type) {
+		//should parse variable declaration and adjust stack accordingly...
+		case GDScriptParser::Node::TYPE_IDENTIFIER: {
+			//return identifier
+			//wait, identifier could be a local variable or something else... careful here, must reference properly
+			//as stack may be more interesting to work with
+
+			//This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases performance a lot.
+
+			const GDScriptParser::IdentifierNode *in = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
+
+			StringName identifier = in->name;
+
+			// TRY STACK!
+			if (!p_initializer && codegen.stack_identifiers.has(identifier)) {
+				int pos = codegen.stack_identifiers[identifier];
+				return pos | (GDScriptFunction::ADDR_TYPE_STACK_VARIABLE << GDScriptFunction::ADDR_BITS);
+			}
+
+			// TRY CLASS MEMBER
+			if (_is_class_member_property(codegen, identifier)) {
+				//get property
+				codegen.opcodes.push_back(GDScriptFunction::OPCODE_GET_MEMBER); // perform operator
+				codegen.opcodes.push_back(codegen.get_name_map_pos(identifier)); // argument 2 (unary only takes one parameter)
+				int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+				codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+				codegen.alloc_stack(p_stack_level);
+				return dst_addr;
+			}
+
+			//TRY MEMBERS!
+			if (!codegen.function_node || !codegen.function_node->_static) {
+				// TRY MEMBER VARIABLES!
+				//static function
+				if (codegen.script->member_indices.has(identifier)) {
+					int idx = codegen.script->member_indices[identifier].index;
+					return idx | (GDScriptFunction::ADDR_TYPE_MEMBER << GDScriptFunction::ADDR_BITS); //argument (stack root)
+				}
+			}
+
+			//TRY CLASS CONSTANTS
+
+			GDScript *owner = codegen.script;
+			while (owner) {
+				GDScript *scr = owner;
+				GDScriptNativeClass *nc = nullptr;
+				while (scr) {
+					if (scr->constants.has(identifier)) {
+						//int idx=scr->constants[identifier];
+						int idx = codegen.get_name_map_pos(identifier);
+						return idx | (GDScriptFunction::ADDR_TYPE_CLASS_CONSTANT << GDScriptFunction::ADDR_BITS); //argument (stack root)
+					}
+					if (scr->native.is_valid()) {
+						nc = scr->native.ptr();
+					}
+					scr = scr->_base;
+				}
+
+				// CLASS C++ Integer Constant
+
+				if (nc) {
+					bool success = false;
+					int constant = ClassDB::get_integer_constant(nc->get_name(), identifier, &success);
+					if (success) {
+						Variant key = constant;
+						int idx;
+
+						if (!codegen.constant_map.has(key)) {
+							idx = codegen.constant_map.size();
+							codegen.constant_map[key] = idx;
+
+						} else {
+							idx = codegen.constant_map[key];
+						}
+
+						return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //make it a local constant (faster access)
+					}
+				}
+
+				owner = owner->_owner;
+			}
+
+			if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
+				int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier];
+				return idx | (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+			}
+
+			/* TRY GLOBAL CLASSES */
+
+			if (ScriptServer::is_global_class(identifier)) {
+				const GDScriptParser::ClassNode *class_node = codegen.class_node;
+				while (class_node->owner) {
+					class_node = class_node->owner;
+				}
+
+				if (class_node->name == identifier) {
+					_set_error("Using own name in class file is not allowed (creates a cyclic reference)", p_expression);
+					return -1;
+				}
+
+				RES res = ResourceLoader::load(ScriptServer::get_global_class_path(identifier));
+				if (res.is_null()) {
+					_set_error("Can't load global class " + String(identifier) + ", cyclic reference?", p_expression);
+					return -1;
+				}
+
+				Variant key = res;
+				int idx;
+
+				if (!codegen.constant_map.has(key)) {
+					idx = codegen.constant_map.size();
+					codegen.constant_map[key] = idx;
+
+				} else {
+					idx = codegen.constant_map[key];
+				}
+
+				return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //make it a local constant (faster access)
+			}
+
+#ifdef TOOLS_ENABLED
+			if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
+				int idx = codegen.named_globals.find(identifier);
+				if (idx == -1) {
+					idx = codegen.named_globals.size();
+					codegen.named_globals.push_back(identifier);
+				}
+				return idx | (GDScriptFunction::ADDR_TYPE_NAMED_GLOBAL << GDScriptFunction::ADDR_BITS);
+			}
+#endif
+
+			//not found, error
+
+			_set_error("Identifier not found: " + String(identifier), p_expression);
+
+			return -1;
+
+		} break;
+		case GDScriptParser::Node::TYPE_CONSTANT: {
+			//return constant
+			const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(p_expression);
+
+			int idx;
+
+			if (!codegen.constant_map.has(cn->value)) {
+				idx = codegen.constant_map.size();
+				codegen.constant_map[cn->value] = idx;
+
+			} else {
+				idx = codegen.constant_map[cn->value];
+			}
+
+			return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //argument (stack root)
+
+		} break;
+		case GDScriptParser::Node::TYPE_SELF: {
+			//return constant
+			if (codegen.function_node && codegen.function_node->_static) {
+				_set_error("'self' not present in static function!", p_expression);
+				return -1;
+			}
+			return (GDScriptFunction::ADDR_TYPE_SELF << GDScriptFunction::ADDR_BITS);
+		} break;
+		case GDScriptParser::Node::TYPE_ARRAY: {
+			const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
+			Vector<int> values;
+
+			int slevel = p_stack_level;
+
+			for (int i = 0; i < an->elements.size(); i++) {
+				int ret = _parse_expression(codegen, an->elements[i], slevel);
+				if (ret < 0) {
+					return ret;
+				}
+				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+			}
+
+			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY);
+			codegen.opcodes.push_back(values.size());
+			for (int i = 0; i < values.size(); i++) {
+				codegen.opcodes.push_back(values[i]);
+			}
+
+			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+
+		} break;
+		case GDScriptParser::Node::TYPE_DICTIONARY: {
+			const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
+			Vector<int> values;
+
+			int slevel = p_stack_level;
+
+			for (int i = 0; i < dn->elements.size(); i++) {
+				int ret = _parse_expression(codegen, dn->elements[i].key, slevel);
+				if (ret < 0) {
+					return ret;
+				}
+				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+
+				ret = _parse_expression(codegen, dn->elements[i].value, slevel);
+				if (ret < 0) {
+					return ret;
+				}
+				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+			}
+
+			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY);
+			codegen.opcodes.push_back(dn->elements.size());
+			for (int i = 0; i < values.size(); i++) {
+				codegen.opcodes.push_back(values[i]);
+			}
+
+			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+
+		} break;
+		case GDScriptParser::Node::TYPE_CAST: {
+			const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
+
+			int slevel = p_stack_level;
+			int src_addr = _parse_expression(codegen, cn->source_node, slevel);
+			if (src_addr < 0) {
+				return src_addr;
+			}
+			if (src_addr & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+				slevel++;
+				codegen.alloc_stack(slevel);
+			}
+
+			GDScriptDataType cast_type = _gdtype_from_datatype(cn->cast_type);
+
+			switch (cast_type.kind) {
+				case GDScriptDataType::BUILTIN: {
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_BUILTIN);
+					codegen.opcodes.push_back(cast_type.builtin_type);
+				} break;
+				case GDScriptDataType::NATIVE: {
+					int class_idx;
+					if (GDScriptLanguage::get_singleton()->get_global_map().has(cast_type.native_type)) {
+						class_idx = GDScriptLanguage::get_singleton()->get_global_map()[cast_type.native_type];
+						class_idx |= (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+					} else {
+						_set_error("Invalid native class type '" + String(cast_type.native_type) + "'.", cn);
+						return -1;
+					}
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_NATIVE); // perform operator
+					codegen.opcodes.push_back(class_idx); // variable type
+				} break;
+				case GDScriptDataType::SCRIPT:
+				case GDScriptDataType::GDSCRIPT: {
+					Variant script = cast_type.script_type;
+					int idx = codegen.get_constant_pos(script);
+					idx |= GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS; //make it a local constant (faster access)
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_SCRIPT); // perform operator
+					codegen.opcodes.push_back(idx); // variable type
+				} break;
+				default: {
+					_set_error("Parser bug: unresolved data type.", cn);
+					return -1;
+				}
+			}
+
+			codegen.opcodes.push_back(src_addr); // source address
+			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+
+		} break;
+		case GDScriptParser::Node::TYPE_OPERATOR: {
+			//hell breaks loose
+
+			const GDScriptParser::OperatorNode *on = static_cast<const GDScriptParser::OperatorNode *>(p_expression);
+			switch (on->op) {
+				//call/constructor operator
+				case GDScriptParser::OperatorNode::OP_PARENT_CALL: {
+					ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
+
+					const GDScriptParser::IdentifierNode *in = (const GDScriptParser::IdentifierNode *)on->arguments[0];
+
+					Vector<int> arguments;
+					int slevel = p_stack_level;
+					for (int i = 1; i < on->arguments.size(); i++) {
+						int ret = _parse_expression(codegen, on->arguments[i], slevel);
+						if (ret < 0) {
+							return ret;
+						}
+						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+						arguments.push_back(ret);
+					}
+
+					//push call bytecode
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_SELF_BASE); // basic type constructor
+
+					codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance
+					codegen.opcodes.push_back(arguments.size()); //argument count
+					codegen.alloc_call(arguments.size());
+					for (int i = 0; i < arguments.size(); i++) {
+						codegen.opcodes.push_back(arguments[i]); //arguments
+					}
+
+				} break;
+				case GDScriptParser::OperatorNode::OP_CALL: {
+					if (on->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
+						//construct a basic type
+						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
+
+						const GDScriptParser::TypeNode *tn = (const GDScriptParser::TypeNode *)on->arguments[0];
+						int vtype = tn->vtype;
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+						for (int i = 1; i < on->arguments.size(); i++) {
+							int ret = _parse_expression(codegen, on->arguments[i], slevel);
+							if (ret < 0) {
+								return ret;
+							}
+							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+							arguments.push_back(ret);
+						}
+
+						//push call bytecode
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT); // basic type constructor
+						codegen.opcodes.push_back(vtype); //instance
+						codegen.opcodes.push_back(arguments.size()); //argument count
+						codegen.alloc_call(arguments.size());
+						for (int i = 0; i < arguments.size(); i++) {
+							codegen.opcodes.push_back(arguments[i]); //arguments
+						}
+
+					} else if (on->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+						//built in function
+
+						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+						for (int i = 1; i < on->arguments.size(); i++) {
+							int ret = _parse_expression(codegen, on->arguments[i], slevel);
+							if (ret < 0) {
+								return ret;
+							}
+
+							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+
+							arguments.push_back(ret);
+						}
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_BUILT_IN);
+						codegen.opcodes.push_back(static_cast<const GDScriptParser::BuiltInFunctionNode *>(on->arguments[0])->function);
+						codegen.opcodes.push_back(on->arguments.size() - 1);
+						codegen.alloc_call(on->arguments.size() - 1);
+						for (int i = 0; i < arguments.size(); i++) {
+							codegen.opcodes.push_back(arguments[i]);
+						}
+
+					} else {
+						//regular function
+						ERR_FAIL_COND_V(on->arguments.size() < 2, -1);
+
+						const GDScriptParser::Node *instance = on->arguments[0];
+
+						if (instance->type == GDScriptParser::Node::TYPE_SELF) {
+							//room for optimization
+						}
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+
+						for (int i = 0; i < on->arguments.size(); i++) {
+							int ret;
+
+							if (i == 0 && on->arguments[i]->type == GDScriptParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) {
+								//static call to self
+								ret = (GDScriptFunction::ADDR_TYPE_CLASS << GDScriptFunction::ADDR_BITS);
+							} else if (i == 1) {
+								if (on->arguments[i]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+									_set_error("Attempt to call a non-identifier.", on);
+									return -1;
+								}
+								GDScriptParser::IdentifierNode *id = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[i]);
+								ret = codegen.get_name_map_pos(id->name);
+
+							} else {
+								ret = _parse_expression(codegen, on->arguments[i], slevel);
+								if (ret < 0) {
+									return ret;
+								}
+								if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+									slevel++;
+									codegen.alloc_stack(slevel);
+								}
+							}
+							arguments.push_back(ret);
+						}
+
+						codegen.opcodes.push_back(p_root ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN); // perform operator
+						codegen.opcodes.push_back(on->arguments.size() - 2);
+						codegen.alloc_call(on->arguments.size() - 2);
+						for (int i = 0; i < arguments.size(); i++) {
+							codegen.opcodes.push_back(arguments[i]);
+						}
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_YIELD: {
+					ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size() != 2, -1);
+
+					Vector<int> arguments;
+					int slevel = p_stack_level;
+					for (int i = 0; i < on->arguments.size(); i++) {
+						int ret = _parse_expression(codegen, on->arguments[i], slevel);
+						if (ret < 0) {
+							return ret;
+						}
+						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+						arguments.push_back(ret);
+					}
+
+					//push call bytecode
+					codegen.opcodes.push_back(arguments.size() == 0 ? GDScriptFunction::OPCODE_YIELD : GDScriptFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
+					for (int i = 0; i < arguments.size(); i++) {
+						codegen.opcodes.push_back(arguments[i]); //arguments
+					}
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_YIELD_RESUME);
+					//next will be where to place the result :)
+
+				} break;
+
+				//indexing operator
+				case GDScriptParser::OperatorNode::OP_INDEX:
+				case GDScriptParser::OperatorNode::OP_INDEX_NAMED: {
+					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
+
+					int slevel = p_stack_level;
+					bool named = (on->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED);
+
+					int from = _parse_expression(codegen, on->arguments[0], slevel);
+					if (from < 0) {
+						return from;
+					}
+
+					int index;
+					if (p_index_addr != 0) {
+						index = p_index_addr;
+					} else if (named) {
+						if (on->arguments[0]->type == GDScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+							GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1]);
+							const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
+
+#ifdef DEBUG_ENABLED
+							if (MI && MI->get().getter == codegen.function_node->name) {
+								String n = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1])->name;
+								_set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", on);
+								return -1;
+							}
+#endif
+
+							if (MI && MI->get().getter == "") {
+								// Faster than indexing self (as if no self. had been used)
+								return (MI->get().index) | (GDScriptFunction::ADDR_TYPE_MEMBER << GDScriptFunction::ADDR_BITS);
+							}
+						}
+
+						index = codegen.get_name_map_pos(static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1])->name);
+
+					} else {
+						if (on->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT && static_cast<const GDScriptParser::ConstantNode *>(on->arguments[1])->value.get_type() == Variant::STRING) {
+							//also, somehow, named (speed up anyway)
+							StringName name = static_cast<const GDScriptParser::ConstantNode *>(on->arguments[1])->value;
+							index = codegen.get_name_map_pos(name);
+							named = true;
+
+						} else {
+							//regular indexing
+							if (from & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+
+							index = _parse_expression(codegen, on->arguments[1], slevel);
+							if (index < 0) {
+								return index;
+							}
+						}
+					}
+
+					codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_GET_NAMED : GDScriptFunction::OPCODE_GET); // perform operator
+					codegen.opcodes.push_back(from); // argument 1
+					codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter)
+
+				} break;
+				case GDScriptParser::OperatorNode::OP_AND: {
+					// AND operator with early out on failure
+
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(res);
+					int jump_fail_pos = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(res);
+					int jump_fail_pos2 = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					codegen.alloc_stack(p_stack_level); //it will be used..
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_fail_pos2] = codegen.opcodes.size();
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+
+				} break;
+				case GDScriptParser::OperatorNode::OP_OR: {
+					// OR operator with early out on success
+
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(res);
+					int jump_success_pos = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(res);
+					int jump_success_pos2 = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					codegen.alloc_stack(p_stack_level); //it will be used..
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+					codegen.opcodes.write[jump_success_pos] = codegen.opcodes.size();
+					codegen.opcodes.write[jump_success_pos2] = codegen.opcodes.size();
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+
+				} break;
+				// ternary operators
+				case GDScriptParser::OperatorNode::OP_TERNARY_IF: {
+					// x IF a ELSE y operator with early out on failure
+
+					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(res);
+					int jump_fail_pos = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					res = _parse_expression(codegen, on->arguments[1], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+
+					codegen.alloc_stack(p_stack_level); //it will be used..
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(res);
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					int jump_past_pos = codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
+					res = _parse_expression(codegen, on->arguments[2], p_stack_level);
+					if (res < 0) {
+						return res;
+					}
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
+					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(res);
+
+					codegen.opcodes.write[jump_past_pos] = codegen.opcodes.size();
+
+					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+
+				} break;
+				//unary operators
+				case GDScriptParser::OperatorNode::OP_NEG: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_POS: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_NOT: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_BIT_INVERT: {
+					if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				//binary operators (in precedence order)
+				case GDScriptParser::OperatorNode::OP_IN: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_NOT_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_LESS: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_LESS_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_GREATER: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_GREATER_EQUAL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_ADD: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_SUB: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_MUL: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_DIV: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_MOD: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				//case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
+				//case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
+				case GDScriptParser::OperatorNode::OP_BIT_AND: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_BIT_OR: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_BIT_XOR: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				//shift
+				case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: {
+					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) {
+						return -1;
+					}
+				} break;
+				//assignment operators
+				case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_SUB:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_MUL:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_DIV:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_MOD:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
+				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
+				case GDScriptParser::OperatorNode::OP_INIT_ASSIGN:
+				case GDScriptParser::OperatorNode::OP_ASSIGN: {
+					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
+
+					if (on->arguments[0]->type == GDScriptParser::Node::TYPE_OPERATOR && (static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX || static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED)) {
+						// SET (chained) MODE!
+#ifdef DEBUG_ENABLED
+						if (static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
+							const GDScriptParser::OperatorNode *inon = static_cast<GDScriptParser::OperatorNode *>(on->arguments[0]);
+
+							if (inon->arguments[0]->type == GDScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+								const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDScriptParser::IdentifierNode *>(inon->arguments[1])->name);
+								if (MI && MI->get().setter == codegen.function_node->name) {
+									String n = static_cast<GDScriptParser::IdentifierNode *>(inon->arguments[1])->name;
+									_set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", inon);
+									return -1;
+								}
+							}
+						}
+#endif
+
+						int slevel = p_stack_level;
+
+						GDScriptParser::OperatorNode *op = static_cast<GDScriptParser::OperatorNode *>(on->arguments[0]);
+
+						/* Find chain of sets */
+
+						StringName assign_property;
+
+						List<GDScriptParser::OperatorNode *> chain;
+
+						{
+							//create get/set chain
+							GDScriptParser::OperatorNode *n = op;
+							while (true) {
+								chain.push_back(n);
+								if (n->arguments[0]->type != GDScriptParser::Node::TYPE_OPERATOR) {
+									//check for a built-in property
+									if (n->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
+										GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(n->arguments[0]);
+										if (_is_class_member_property(codegen, identifier->name)) {
+											assign_property = identifier->name;
+										}
+									}
+									break;
+								}
+								n = static_cast<GDScriptParser::OperatorNode *>(n->arguments[0]);
+								if (n->op != GDScriptParser::OperatorNode::OP_INDEX && n->op != GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
+									break;
+								}
+							}
+						}
+
+						/* Chain of gets */
+
+						//get at (potential) root stack pos, so it can be returned
+						int prev_pos = _parse_expression(codegen, chain.back()->get()->arguments[0], slevel);
+						if (prev_pos < 0) {
+							return prev_pos;
+						}
+						int retval = prev_pos;
+
+						if (retval & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+						Vector<int> setchain;
+
+						if (assign_property != StringName()) {
+							// recover and assign at the end, this allows stuff like
+							// position.x+=2.0
+							// in Node2D
+							setchain.push_back(prev_pos);
+							setchain.push_back(codegen.get_name_map_pos(assign_property));
+							setchain.push_back(GDScriptFunction::OPCODE_SET_MEMBER);
+						}
+
+						for (List<GDScriptParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) {
+							if (E == chain.front()) { //ignore first
+								break;
+							}
+
+							bool named = E->get()->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED;
+							int key_idx;
+
+							if (named) {
+								key_idx = codegen.get_name_map_pos(static_cast<const GDScriptParser::IdentifierNode *>(E->get()->arguments[1])->name);
+								//printf("named key %x\n",key_idx);
+
+							} else {
+								if (prev_pos & (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS)) {
+									slevel++;
+									codegen.alloc_stack(slevel);
+								}
+
+								GDScriptParser::Node *key = E->get()->arguments[1];
+								key_idx = _parse_expression(codegen, key, slevel);
+								//printf("expr key %x\n",key_idx);
+
+								//stack was raised here if retval was stack but..
+							}
+
+							if (key_idx < 0) { //error
+								return key_idx;
+							}
+
+							codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_GET_NAMED : GDScriptFunction::OPCODE_GET);
+							codegen.opcodes.push_back(prev_pos);
+							codegen.opcodes.push_back(key_idx);
+							slevel++;
+							codegen.alloc_stack(slevel);
+							int dst_pos = (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) | slevel;
+
+							codegen.opcodes.push_back(dst_pos);
+
+							//add in reverse order, since it will be reverted
+
+							setchain.push_back(dst_pos);
+							setchain.push_back(key_idx);
+							setchain.push_back(prev_pos);
+							setchain.push_back(named ? GDScriptFunction::OPCODE_SET_NAMED : GDScriptFunction::OPCODE_SET);
+
+							prev_pos = dst_pos;
+						}
+
+						setchain.invert();
+
+						int set_index;
+						bool named = false;
+
+						if (op->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
+							set_index = codegen.get_name_map_pos(static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1])->name);
+							named = true;
+						} else {
+							set_index = _parse_expression(codegen, op->arguments[1], slevel + 1);
+							named = false;
+						}
+
+						if (set_index < 0) { //error
+							return set_index;
+						}
+
+						if (set_index & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+						int set_value = _parse_assign_right_expression(codegen, on, slevel + 1, named ? 0 : set_index);
+						if (set_value < 0) { //error
+							return set_value;
+						}
+
+						codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_SET_NAMED : GDScriptFunction::OPCODE_SET);
+						codegen.opcodes.push_back(prev_pos);
+						codegen.opcodes.push_back(set_index);
+						codegen.opcodes.push_back(set_value);
+
+						for (int i = 0; i < setchain.size(); i++) {
+							codegen.opcodes.push_back(setchain[i]);
+						}
+
+						return retval;
+
+					} else if (on->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast<GDScriptParser::IdentifierNode *>(on->arguments[0])->name)) {
+						//assignment to member property
+
+						int slevel = p_stack_level;
+
+						int src_address = _parse_assign_right_expression(codegen, on, slevel);
+						if (src_address < 0) {
+							return -1;
+						}
+
+						StringName name = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[0])->name;
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_SET_MEMBER);
+						codegen.opcodes.push_back(codegen.get_name_map_pos(name));
+						codegen.opcodes.push_back(src_address);
+
+						return GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
+					} else {
+						//REGULAR ASSIGNMENT MODE!!
+
+						int slevel = p_stack_level;
+
+						int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDScriptParser::OperatorNode::OP_INIT_ASSIGN);
+						if (dst_address_a < 0) {
+							return -1;
+						}
+
+						if (dst_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+						int src_address_b = _parse_assign_right_expression(codegen, on, slevel);
+						if (src_address_b < 0) {
+							return -1;
+						}
+
+						GDScriptDataType assign_type = _gdtype_from_datatype(on->arguments[0]->get_datatype());
+
+						if (assign_type.has_type && !on->datatype.has_type) {
+							// Typed assignment
+							switch (assign_type.kind) {
+								case GDScriptDataType::BUILTIN: {
+									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN); // perform operator
+									codegen.opcodes.push_back(assign_type.builtin_type); // variable type
+									codegen.opcodes.push_back(dst_address_a); // argument 1
+									codegen.opcodes.push_back(src_address_b); // argument 2
+								} break;
+								case GDScriptDataType::NATIVE: {
+									int class_idx;
+									if (GDScriptLanguage::get_singleton()->get_global_map().has(assign_type.native_type)) {
+										class_idx = GDScriptLanguage::get_singleton()->get_global_map()[assign_type.native_type];
+										class_idx |= (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+									} else {
+										_set_error("Invalid native class type '" + String(assign_type.native_type) + "'.", on->arguments[0]);
+										return -1;
+									}
+									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE); // perform operator
+									codegen.opcodes.push_back(class_idx); // variable type
+									codegen.opcodes.push_back(dst_address_a); // argument 1
+									codegen.opcodes.push_back(src_address_b); // argument 2
+								} break;
+								case GDScriptDataType::SCRIPT:
+								case GDScriptDataType::GDSCRIPT: {
+									Variant script = assign_type.script_type;
+									int idx = codegen.get_constant_pos(script);
+									idx |= GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS; //make it a local constant (faster access)
+
+									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT); // perform operator
+									codegen.opcodes.push_back(idx); // variable type
+									codegen.opcodes.push_back(dst_address_a); // argument 1
+									codegen.opcodes.push_back(src_address_b); // argument 2
+								} break;
+								default: {
+									ERR_PRINT("Compiler bug: unresolved assign.");
+
+									// Shouldn't get here, but fail-safe to a regular assignment
+									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN); // perform operator
+									codegen.opcodes.push_back(dst_address_a); // argument 1
+									codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+								}
+							}
+						} else {
+							// Either untyped assignment or already type-checked by the parser
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN); // perform operator
+							codegen.opcodes.push_back(dst_address_a); // argument 1
+							codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+						}
+						return dst_address_a; //if anything, returns whatever was assigned or correct stack position
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_IS: {
+					ERR_FAIL_COND_V(on->arguments.size() != 2, false);
+
+					int slevel = p_stack_level;
+
+					int src_address_a = _parse_expression(codegen, on->arguments[0], slevel);
+					if (src_address_a < 0) {
+						return -1;
+					}
+
+					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+						slevel++; //uses stack for return, increase stack
+					}
+
+					int src_address_b = _parse_expression(codegen, on->arguments[1], slevel);
+					if (src_address_b < 0) {
+						return -1;
+					}
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_EXTENDS_TEST); // perform operator
+					codegen.opcodes.push_back(src_address_a); // argument 1
+					codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+
+				} break;
+				case GDScriptParser::OperatorNode::OP_IS_BUILTIN: {
+					ERR_FAIL_COND_V(on->arguments.size() != 2, false);
+					ERR_FAIL_COND_V(on->arguments[1]->type != GDScriptParser::Node::TYPE_TYPE, false);
+
+					int slevel = p_stack_level;
+
+					int src_address_a = _parse_expression(codegen, on->arguments[0], slevel);
+					if (src_address_a < 0) {
+						return -1;
+					}
+
+					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+						slevel++; //uses stack for return, increase stack
+					}
+
+					const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(on->arguments[1]);
+
+					codegen.opcodes.push_back(GDScriptFunction::OPCODE_IS_BUILTIN); // perform operator
+					codegen.opcodes.push_back(src_address_a); // argument 1
+					codegen.opcodes.push_back((int)tn->vtype); // argument 2 (unary only takes one parameter)
+				} break;
+				default: {
+					ERR_FAIL_V_MSG(0, "Bug in bytecode compiler, unexpected operator #" + itos(on->op) + " in parse tree while parsing expression."); //unreachable code
+
+				} break;
+			}
+
+			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+		} break;
+		//TYPE_TYPE,
+		default: {
+			ERR_FAIL_V_MSG(-1, "Bug in bytecode compiler, unexpected node in parse tree while parsing expression."); //unreachable code
+		} break;
+	}
+}
+
+Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::BlockNode *p_block, int p_stack_level, int p_break_addr, int p_continue_addr) {
+	codegen.push_stack_identifiers();
+	int new_identifiers = 0;
+	codegen.current_line = p_block->line;
+
+	for (int i = 0; i < p_block->statements.size(); i++) {
+		const GDScriptParser::Node *s = p_block->statements[i];
+
+		switch (s->type) {
+			case GDScriptParser::Node::TYPE_NEWLINE: {
+#ifdef DEBUG_ENABLED
+				const GDScriptParser::NewLineNode *nl = static_cast<const GDScriptParser::NewLineNode *>(s);
+				codegen.opcodes.push_back(GDScriptFunction::OPCODE_LINE);
+				codegen.opcodes.push_back(nl->line);
+				codegen.current_line = nl->line;
+#endif
+			} break;
+			case GDScriptParser::Node::TYPE_CONTROL_FLOW: {
+				// try subblocks
+
+				const GDScriptParser::ControlFlowNode *cf = static_cast<const GDScriptParser::ControlFlowNode *>(s);
+
+				switch (cf->cf_type) {
+					case GDScriptParser::ControlFlowNode::CF_MATCH: {
+						GDScriptParser::MatchNode *match = cf->match;
+
+						GDScriptParser::IdentifierNode *id = memnew(GDScriptParser::IdentifierNode);
+						id->name = "#match_value";
+
+						// var #match_value
+						// copied because there is no _parse_statement :(
+						codegen.add_stack_identifier(id->name, p_stack_level++);
+						codegen.alloc_stack(p_stack_level);
+						new_identifiers++;
+
+						GDScriptParser::OperatorNode *op = memnew(GDScriptParser::OperatorNode);
+						op->op = GDScriptParser::OperatorNode::OP_ASSIGN;
+						op->arguments.push_back(id);
+						op->arguments.push_back(match->val_to_match);
+
+						int ret = _parse_expression(codegen, op, p_stack_level);
+						if (ret < 0) {
+							memdelete(id);
+							memdelete(op);
+							return ERR_PARSE_ERROR;
+						}
+
+						// break address
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+						int break_addr = codegen.opcodes.size();
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(0); // break addr
+
+						for (int j = 0; j < match->compiled_pattern_branches.size(); j++) {
+							GDScriptParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j];
+
+							// jump over continue
+							// jump unconditionally
+							// continue address
+							// compile the condition
+							int ret2 = _parse_expression(codegen, branch.compiled_pattern, p_stack_level);
+							if (ret2 < 0) {
+								memdelete(id);
+								memdelete(op);
+								return ERR_PARSE_ERROR;
+							}
+
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+							codegen.opcodes.push_back(ret2);
+							codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+							int continue_addr = codegen.opcodes.size();
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							codegen.opcodes.push_back(0);
+
+							Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr);
+							if (err) {
+								memdelete(id);
+								memdelete(op);
+								return ERR_PARSE_ERROR;
+							}
+
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							codegen.opcodes.push_back(break_addr);
+
+							codegen.opcodes.write[continue_addr + 1] = codegen.opcodes.size();
+						}
+
+						codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();
+
+						memdelete(id);
+						memdelete(op);
+
+					} break;
+
+					case GDScriptParser::ControlFlowNode::CF_IF: {
+						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret2 < 0) {
+							return ERR_PARSE_ERROR;
+						}
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(ret2);
+						int else_addr = codegen.opcodes.size();
+						codegen.opcodes.push_back(0); //temporary
+
+						Error err = _parse_block(codegen, cf->body, p_stack_level, p_break_addr, p_continue_addr);
+						if (err) {
+							return err;
+						}
+
+						if (cf->body_else) {
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							int end_addr = codegen.opcodes.size();
+							codegen.opcodes.push_back(0);
+							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
+
+							codegen.opcodes.push_back(GDScriptFunction::OPCODE_LINE);
+							codegen.opcodes.push_back(cf->body_else->line);
+							codegen.current_line = cf->body_else->line;
+
+							Error err2 = _parse_block(codegen, cf->body_else, p_stack_level, p_break_addr, p_continue_addr);
+							if (err2) {
+								return err2;
+							}
+
+							codegen.opcodes.write[end_addr] = codegen.opcodes.size();
+						} else {
+							//end without else
+							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
+						}
+
+					} break;
+					case GDScriptParser::ControlFlowNode::CF_FOR: {
+						int slevel = p_stack_level;
+						int iter_stack_pos = slevel;
+						int iterator_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+						int counter_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+						int container_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+						codegen.alloc_stack(slevel);
+
+						codegen.push_stack_identifiers();
+						codegen.add_stack_identifier(static_cast<const GDScriptParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
+
+						int ret2 = _parse_expression(codegen, cf->arguments[1], slevel, false);
+						if (ret2 < 0) {
+							return ERR_COMPILATION_FAILED;
+						}
+
+						//assign container
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(ret2);
+
+						//begin loop
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ITERATE_BEGIN);
+						codegen.opcodes.push_back(counter_pos);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(codegen.opcodes.size() + 4);
+						codegen.opcodes.push_back(iterator_pos);
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(codegen.opcodes.size() + 8);
+						//break loop
+						int break_pos = codegen.opcodes.size();
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(0); //skip code for next
+						//next loop
+						int continue_pos = codegen.opcodes.size();
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ITERATE);
+						codegen.opcodes.push_back(counter_pos);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(break_pos);
+						codegen.opcodes.push_back(iterator_pos);
+
+						Error err = _parse_block(codegen, cf->body, slevel, break_pos, continue_pos);
+						if (err) {
+							return err;
+						}
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(continue_pos);
+						codegen.opcodes.write[break_pos + 1] = codegen.opcodes.size();
+
+						codegen.pop_stack_identifiers();
+
+					} break;
+					case GDScriptParser::ControlFlowNode::CF_WHILE: {
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
+						int break_addr = codegen.opcodes.size();
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(0);
+						int continue_addr = codegen.opcodes.size();
+
+						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+						if (ret2 < 0) {
+							return ERR_PARSE_ERROR;
+						}
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(ret2);
+						codegen.opcodes.push_back(break_addr);
+						Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr);
+						if (err) {
+							return err;
+						}
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(continue_addr);
+
+						codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();
+
+					} break;
+					case GDScriptParser::ControlFlowNode::CF_BREAK: {
+						if (p_break_addr < 0) {
+							_set_error("'break'' not within loop", cf);
+							return ERR_COMPILATION_FAILED;
+						}
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(p_break_addr);
+
+					} break;
+					case GDScriptParser::ControlFlowNode::CF_CONTINUE: {
+						if (p_continue_addr < 0) {
+							_set_error("'continue' not within loop", cf);
+							return ERR_COMPILATION_FAILED;
+						}
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(p_continue_addr);
+
+					} break;
+					case GDScriptParser::ControlFlowNode::CF_RETURN: {
+						int ret2;
+
+						if (cf->arguments.size()) {
+							ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
+							if (ret2 < 0) {
+								return ERR_PARSE_ERROR;
+							}
+
+						} else {
+							ret2 = GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
+						}
+
+						codegen.opcodes.push_back(GDScriptFunction::OPCODE_RETURN);
+						codegen.opcodes.push_back(ret2);
+
+					} break;
+				}
+			} break;
+			case GDScriptParser::Node::TYPE_ASSERT: {
+#ifdef DEBUG_ENABLED
+				// try subblocks
+
+				const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
+
+				int ret2 = _parse_expression(codegen, as->condition, p_stack_level, false);
+				if (ret2 < 0) {
+					return ERR_PARSE_ERROR;
+				}
+
+				int message_ret = 0;
+				if (as->message) {
+					message_ret = _parse_expression(codegen, as->message, p_stack_level + 1, false);
+					if (message_ret < 0) {
+						return ERR_PARSE_ERROR;
+					}
+				}
+
+				codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSERT);
+				codegen.opcodes.push_back(ret2);
+				codegen.opcodes.push_back(message_ret);
+#endif
+			} break;
+			case GDScriptParser::Node::TYPE_BREAKPOINT: {
+#ifdef DEBUG_ENABLED
+				// try subblocks
+				codegen.opcodes.push_back(GDScriptFunction::OPCODE_BREAKPOINT);
+#endif
+			} break;
+			case GDScriptParser::Node::TYPE_LOCAL_VAR: {
+				const GDScriptParser::LocalVarNode *lv = static_cast<const GDScriptParser::LocalVarNode *>(s);
+
+				// since we are using properties now for most class access, allow shadowing of class members to make user's life easier.
+				//
+				//if (_is_class_member_property(codegen, lv->name)) {
+				//	_set_error("Name for local variable '" + String(lv->name) + "' can't shadow class property of the same name.", lv);
+				//	return ERR_ALREADY_EXISTS;
+				//}
+
+				codegen.add_stack_identifier(lv->name, p_stack_level++);
+				codegen.alloc_stack(p_stack_level);
+				new_identifiers++;
+
+			} break;
+			default: {
+				//expression
+				int ret2 = _parse_expression(codegen, s, p_stack_level, true);
+				if (ret2 < 0) {
+					return ERR_PARSE_ERROR;
+				}
+			} break;
+		}
+	}
+	codegen.pop_stack_identifiers();
+	return OK;
+}
+
+Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready) {
+	Vector<int> bytecode;
+	CodeGen codegen;
+
+	codegen.class_node = p_class;
+	codegen.script = p_script;
+	codegen.function_node = p_func;
+	codegen.stack_max = 0;
+	codegen.current_line = 0;
+	codegen.call_max = 0;
+	codegen.debug_stack = ScriptDebugger::get_singleton() != nullptr;
+	Vector<StringName> argnames;
+
+	int stack_level = 0;
+
+	if (p_func) {
+		for (int i = 0; i < p_func->arguments.size(); i++) {
+			// since we are using properties now for most class access, allow shadowing of class members to make user's life easier.
+			//
+			//if (_is_class_member_property(p_script, p_func->arguments[i])) {
+			//	_set_error("Name for argument '" + String(p_func->arguments[i]) + "' can't shadow class property of the same name.", p_func);
+			//	return ERR_ALREADY_EXISTS;
+			//}
+
+			codegen.add_stack_identifier(p_func->arguments[i], i);
+#ifdef TOOLS_ENABLED
+			argnames.push_back(p_func->arguments[i]);
+#endif
+		}
+		stack_level = p_func->arguments.size();
+	}
+
+	codegen.alloc_stack(stack_level);
+
+	/* Parse initializer -if applies- */
+
+	bool is_initializer = !p_for_ready && !p_func;
+
+	if (is_initializer || (p_func && String(p_func->name) == "_init")) {
+		//parse initializer for class members
+		if (!p_func && p_class->extends_used && p_script->native.is_null()) {
+			//call implicit parent constructor
+			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_SELF_BASE);
+			codegen.opcodes.push_back(codegen.get_name_map_pos("_init"));
+			codegen.opcodes.push_back(0);
+			codegen.opcodes.push_back((GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) | 0);
+		}
+		Error err = _parse_block(codegen, p_class->initializer, stack_level);
+		if (err) {
+			return err;
+		}
+		is_initializer = true;
+	}
+
+	if (p_for_ready || (p_func && String(p_func->name) == "_ready")) {
+		//parse initializer for class members
+		if (p_class->ready->statements.size()) {
+			Error err = _parse_block(codegen, p_class->ready, stack_level);
+			if (err) {
+				return err;
+			}
+		}
+	}
+
+	/* Parse default argument code -if applies- */
+
+	Vector<int> defarg_addr;
+	StringName func_name;
+
+	if (p_func) {
+		if (p_func->default_values.size()) {
+			codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
+			defarg_addr.push_back(codegen.opcodes.size());
+			for (int i = 0; i < p_func->default_values.size(); i++) {
+				_parse_expression(codegen, p_func->default_values[i], stack_level, true);
+				defarg_addr.push_back(codegen.opcodes.size());
+			}
+
+			defarg_addr.invert();
+		}
+
+		Error err = _parse_block(codegen, p_func->body, stack_level);
+		if (err) {
+			return err;
+		}
+
+		func_name = p_func->name;
+	} else {
+		if (p_for_ready) {
+			func_name = "_ready";
+		} else {
+			func_name = "_init";
+		}
+	}
+
+	codegen.opcodes.push_back(GDScriptFunction::OPCODE_END);
+
+	/*
+	if (String(p_func->name)=="") { //initializer func
+		gdfunc = &p_script->initializer;
+	*/
+	//} else { //regular func
+	p_script->member_functions[func_name] = memnew(GDScriptFunction);
+	GDScriptFunction *gdfunc = p_script->member_functions[func_name];
+	//}
+
+	if (p_func) {
+		gdfunc->_static = p_func->_static;
+		gdfunc->rpc_mode = p_func->rpc_mode;
+		gdfunc->argument_types.resize(p_func->argument_types.size());
+		for (int i = 0; i < p_func->argument_types.size(); i++) {
+			gdfunc->argument_types.write[i] = _gdtype_from_datatype(p_func->argument_types[i], p_script);
+		}
+		gdfunc->return_type = _gdtype_from_datatype(p_func->return_type, p_script);
+	} else {
+		gdfunc->_static = false;
+		gdfunc->rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+		gdfunc->return_type = GDScriptDataType();
+		gdfunc->return_type.has_type = true;
+		gdfunc->return_type.kind = GDScriptDataType::BUILTIN;
+		gdfunc->return_type.builtin_type = Variant::NIL;
+	}
+
+#ifdef TOOLS_ENABLED
+	gdfunc->arg_names = argnames;
+#endif
+	//constants
+	if (codegen.constant_map.size()) {
+		gdfunc->_constant_count = codegen.constant_map.size();
+		gdfunc->constants.resize(codegen.constant_map.size());
+		gdfunc->_constants_ptr = gdfunc->constants.ptrw();
+		const Variant *K = nullptr;
+		while ((K = codegen.constant_map.next(K))) {
+			int idx = codegen.constant_map[*K];
+			gdfunc->constants.write[idx] = *K;
+		}
+	} else {
+		gdfunc->_constants_ptr = nullptr;
+		gdfunc->_constant_count = 0;
+	}
+	//global names
+	if (codegen.name_map.size()) {
+		gdfunc->global_names.resize(codegen.name_map.size());
+		gdfunc->_global_names_ptr = &gdfunc->global_names[0];
+		for (Map<StringName, int>::Element *E = codegen.name_map.front(); E; E = E->next()) {
+			gdfunc->global_names.write[E->get()] = E->key();
+		}
+		gdfunc->_global_names_count = gdfunc->global_names.size();
+
+	} else {
+		gdfunc->_global_names_ptr = nullptr;
+		gdfunc->_global_names_count = 0;
+	}
+
+#ifdef TOOLS_ENABLED
+	// Named globals
+	if (codegen.named_globals.size()) {
+		gdfunc->named_globals.resize(codegen.named_globals.size());
+		gdfunc->_named_globals_ptr = gdfunc->named_globals.ptr();
+		for (int i = 0; i < codegen.named_globals.size(); i++) {
+			gdfunc->named_globals.write[i] = codegen.named_globals[i];
+		}
+		gdfunc->_named_globals_count = gdfunc->named_globals.size();
+	}
+#endif
+
+	if (codegen.opcodes.size()) {
+		gdfunc->code = codegen.opcodes;
+		gdfunc->_code_ptr = &gdfunc->code[0];
+		gdfunc->_code_size = codegen.opcodes.size();
+
+	} else {
+		gdfunc->_code_ptr = nullptr;
+		gdfunc->_code_size = 0;
+	}
+
+	if (defarg_addr.size()) {
+		gdfunc->default_arguments = defarg_addr;
+		gdfunc->_default_arg_count = defarg_addr.size() - 1;
+		gdfunc->_default_arg_ptr = &gdfunc->default_arguments[0];
+	} else {
+		gdfunc->_default_arg_count = 0;
+		gdfunc->_default_arg_ptr = nullptr;
+	}
+
+	gdfunc->_argument_count = p_func ? p_func->arguments.size() : 0;
+	gdfunc->_stack_size = codegen.stack_max;
+	gdfunc->_call_size = codegen.call_max;
+	gdfunc->name = func_name;
+#ifdef DEBUG_ENABLED
+	if (ScriptDebugger::get_singleton()) {
+		String signature;
+		//path
+		if (p_script->get_path() != String()) {
+			signature += p_script->get_path();
+		}
+		//loc
+		if (p_func) {
+			signature += "::" + itos(p_func->body->line);
+		} else {
+			signature += "::0";
+		}
+
+		//function and class
+
+		if (p_class->name) {
+			signature += "::" + String(p_class->name) + "." + String(func_name);
+		} else {
+			signature += "::" + String(func_name);
+		}
+
+		gdfunc->profile.signature = signature;
+	}
+#endif
+	gdfunc->_script = p_script;
+	gdfunc->source = source;
+
+#ifdef DEBUG_ENABLED
+
+	{
+		gdfunc->func_cname = (String(source) + " - " + String(func_name)).utf8();
+		gdfunc->_func_cname = gdfunc->func_cname.get_data();
+	}
+
+#endif
+	if (p_func) {
+		gdfunc->_initial_line = p_func->line;
+#ifdef TOOLS_ENABLED
+
+		p_script->member_lines[func_name] = p_func->line;
+#endif
+	} else {
+		gdfunc->_initial_line = 0;
+	}
+
+	if (codegen.debug_stack) {
+		gdfunc->stack_debug = codegen.stack_debug;
+	}
+
+	if (is_initializer) {
+		p_script->initializer = gdfunc;
+	}
+
+	return OK;
+}
+
+Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+	parsing_classes.insert(p_script);
+
+	if (p_class->owner && p_class->owner->owner) {
+		// Owner is not root
+		if (!parsed_classes.has(p_script->_owner)) {
+			if (parsing_classes.has(p_script->_owner)) {
+				_set_error("Cyclic class reference for '" + String(p_class->name) + "'.", p_class);
+				return ERR_PARSE_ERROR;
+			}
+			Error err = _parse_class_level(p_script->_owner, p_class->owner, p_keep_state);
+			if (err) {
+				return err;
+			}
+		}
+	}
+
+	p_script->native = Ref<GDScriptNativeClass>();
+	p_script->base = Ref<GDScript>();
+	p_script->_base = nullptr;
+	p_script->members.clear();
+	p_script->constants.clear();
+	for (Map<StringName, GDScriptFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) {
+		memdelete(E->get());
+	}
+	p_script->member_functions.clear();
+	p_script->member_indices.clear();
+	p_script->member_info.clear();
+	p_script->_signals.clear();
+	p_script->initializer = nullptr;
+
+	p_script->tool = p_class->tool;
+	p_script->name = p_class->name;
+
+	Ref<GDScriptNativeClass> native;
+
+	GDScriptDataType base_type = _gdtype_from_datatype(p_class->base_type);
+	// Inheritance
+	switch (base_type.kind) {
+		case GDScriptDataType::NATIVE: {
+			int native_idx = GDScriptLanguage::get_singleton()->get_global_map()[base_type.native_type];
+			native = GDScriptLanguage::get_singleton()->get_global_array()[native_idx];
+			ERR_FAIL_COND_V(native.is_null(), ERR_BUG);
+			p_script->native = native;
+		} break;
+		case GDScriptDataType::GDSCRIPT: {
+			Ref<GDScript> base = Ref<Script>(base_type.script_type);
+			p_script->base = base;
+			p_script->_base = base.ptr();
+			p_script->member_indices = base->member_indices;
+
+			if (p_class->base_type.kind == GDScriptParser::DataType::CLASS) {
+				if (!parsed_classes.has(p_script->_base)) {
+					if (parsing_classes.has(p_script->_base)) {
+						_set_error("Cyclic class reference for '" + String(p_class->name) + "'.", p_class);
+						return ERR_PARSE_ERROR;
+					}
+					Error err = _parse_class_level(p_script->_base, p_class->base_type.class_type, p_keep_state);
+					if (err) {
+						return err;
+					}
+				}
+			}
+		} break;
+		default: {
+			_set_error("Parser bug: invalid inheritance.", p_class);
+			return ERR_BUG;
+		} break;
+	}
+
+	for (int i = 0; i < p_class->variables.size(); i++) {
+		StringName name = p_class->variables[i].identifier;
+
+		GDScript::MemberInfo minfo;
+		minfo.index = p_script->member_indices.size();
+		minfo.setter = p_class->variables[i].setter;
+		minfo.getter = p_class->variables[i].getter;
+		minfo.rpc_mode = p_class->variables[i].rpc_mode;
+		minfo.data_type = _gdtype_from_datatype(p_class->variables[i].data_type, p_script);
+
+		PropertyInfo prop_info = minfo.data_type;
+		prop_info.name = name;
+		PropertyInfo export_info = p_class->variables[i]._export;
+
+		if (export_info.type != Variant::NIL) {
+			if (!minfo.data_type.has_type) {
+				prop_info.type = export_info.type;
+				prop_info.class_name = export_info.class_name;
+			}
+			prop_info.hint = export_info.hint;
+			prop_info.hint_string = export_info.hint_string;
+			prop_info.usage = export_info.usage;
+#ifdef TOOLS_ENABLED
+			if (p_class->variables[i].default_value.get_type() != Variant::NIL) {
+				p_script->member_default_values[name] = p_class->variables[i].default_value;
+			}
+#endif
+		} else {
+			prop_info.usage = PROPERTY_USAGE_SCRIPT_VARIABLE;
+		}
+
+		p_script->member_info[name] = prop_info;
+		p_script->member_indices[name] = minfo;
+		p_script->members.insert(name);
+
+#ifdef TOOLS_ENABLED
+		p_script->member_lines[name] = p_class->variables[i].line;
+#endif
+	}
+
+	for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
+		StringName name = E->key();
+
+		ERR_CONTINUE(E->get().expression->type != GDScriptParser::Node::TYPE_CONSTANT);
+
+		GDScriptParser::ConstantNode *constant = static_cast<GDScriptParser::ConstantNode *>(E->get().expression);
+
+		p_script->constants.insert(name, constant->value);
+#ifdef TOOLS_ENABLED
+
+		p_script->member_lines[name] = E->get().expression->line;
+#endif
+	}
+
+	for (int i = 0; i < p_class->_signals.size(); i++) {
+		StringName name = p_class->_signals[i].name;
+
+		GDScript *c = p_script;
+
+		while (c) {
+			if (c->_signals.has(name)) {
+				_set_error("Signal '" + name + "' redefined (in current or parent class)", p_class);
+				return ERR_ALREADY_EXISTS;
+			}
+
+			if (c->base.is_valid()) {
+				c = c->base.ptr();
+			} else {
+				c = nullptr;
+			}
+		}
+
+		if (native.is_valid()) {
+			if (ClassDB::has_signal(native->get_name(), name)) {
+				_set_error("Signal '" + name + "' redefined (original in native class '" + String(native->get_name()) + "')", p_class);
+				return ERR_ALREADY_EXISTS;
+			}
+		}
+
+		p_script->_signals[name] = p_class->_signals[i].arguments;
+	}
+
+	parsed_classes.insert(p_script);
+	parsing_classes.erase(p_script);
+
+	//parse sub-classes
+
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
+		StringName name = p_class->subclasses[i]->name;
+		Ref<GDScript> &subclass = p_script->subclasses[name];
+		GDScript *subclass_ptr = subclass.ptr();
+
+		// Subclass might still be parsing, just skip it
+		if (!parsed_classes.has(subclass_ptr) && !parsing_classes.has(subclass_ptr)) {
+			Error err = _parse_class_level(subclass_ptr, p_class->subclasses[i], p_keep_state);
+			if (err) {
+				return err;
+			}
+		}
+
+#ifdef TOOLS_ENABLED
+
+		p_script->member_lines[name] = p_class->subclasses[i]->line;
+#endif
+
+		p_script->constants.insert(name, subclass); //once parsed, goes to the list of constants
+	}
+
+	return OK;
+}
+
+Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+	//parse methods
+
+	bool has_initializer = false;
+	bool has_ready = false;
+
+	for (int i = 0; i < p_class->functions.size(); i++) {
+		if (!has_initializer && p_class->functions[i]->name == "_init") {
+			has_initializer = true;
+		}
+		if (!has_ready && p_class->functions[i]->name == "_ready") {
+			has_ready = true;
+		}
+		Error err = _parse_function(p_script, p_class, p_class->functions[i]);
+		if (err) {
+			return err;
+		}
+	}
+
+	//parse static methods
+
+	for (int i = 0; i < p_class->static_functions.size(); i++) {
+		Error err = _parse_function(p_script, p_class, p_class->static_functions[i]);
+		if (err) {
+			return err;
+		}
+	}
+
+	if (!has_initializer) {
+		//create a constructor
+		Error err = _parse_function(p_script, p_class, nullptr);
+		if (err) {
+			return err;
+		}
+	}
+
+	if (!has_ready && p_class->ready->statements.size()) {
+		//create a constructor
+		Error err = _parse_function(p_script, p_class, nullptr, true);
+		if (err) {
+			return err;
+		}
+	}
+
+#ifdef DEBUG_ENABLED
+
+	//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();
+
+			ScriptInstance *si = E->get()->get_script_instance();
+			if (si->is_placeholder()) {
+#ifdef TOOLS_ENABLED
+				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si);
+
+				if (p_script->is_tool()) {
+					//re-create as an instance
+					p_script->placeholders.erase(psi); //remove placeholder
+
+					GDScriptInstance *instance = memnew(GDScriptInstance);
+					instance->base_ref = Object::cast_to<Reference>(E->get());
+					instance->members.resize(p_script->member_indices.size());
+					instance->script = Ref<GDScript>(p_script);
+					instance->owner = E->get();
+
+					//needed for hot reloading
+					for (Map<StringName, GDScript::MemberInfo>::Element *F = p_script->member_indices.front(); F; F = F->next()) {
+						instance->member_indices_cache[F->key()] = F->get().index;
+					}
+					instance->owner->set_script_instance(instance);
+
+					/* STEP 2, INITIALIZE AND CONSTRUCT */
+
+					Variant::CallError ce;
+					p_script->initializer->call(instance, nullptr, 0, ce);
+
+					if (ce.error != Variant::CallError::CALL_OK) {
+						//well, tough luck, not goinna do anything here
+					}
+				}
+#endif
+			} else {
+				GDScriptInstance *gi = static_cast<GDScriptInstance *>(si);
+				gi->reload_members();
+			}
+
+			E = N;
+		}
+	}
+#endif
+
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
+		StringName name = p_class->subclasses[i]->name;
+		GDScript *subclass = p_script->subclasses[name].ptr();
+
+		Error err = _parse_class_blocks(subclass, p_class->subclasses[i], p_keep_state);
+		if (err) {
+			return err;
+		}
+	}
+
+	p_script->valid = true;
+	return OK;
+}
+
+void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+	Map<StringName, Ref<GDScript>> old_subclasses;
+
+	if (p_keep_state) {
+		old_subclasses = p_script->subclasses;
+	}
+
+	p_script->subclasses.clear();
+
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
+		StringName name = p_class->subclasses[i]->name;
+
+		Ref<GDScript> subclass;
+		String fully_qualified_name = p_script->fully_qualified_name + "::" + name;
+
+		if (old_subclasses.has(name)) {
+			subclass = old_subclasses[name];
+		} else {
+			Ref<GDScript> orphan_subclass = GDScriptLanguage::get_singleton()->get_orphan_subclass(fully_qualified_name);
+			if (orphan_subclass.is_valid()) {
+				subclass = orphan_subclass;
+			} else {
+				subclass.instance();
+			}
+		}
+
+		subclass->_owner = p_script;
+		subclass->fully_qualified_name = fully_qualified_name;
+		p_script->subclasses.insert(name, subclass);
+
+		_make_scripts(subclass.ptr(), p_class->subclasses[i], false);
+	}
+}
+
+Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_script, bool p_keep_state) {
+	err_line = -1;
+	err_column = -1;
+	error = "";
+	parser = p_parser;
+	main_script = p_script;
+	const GDScriptParser::Node *root = parser->get_parse_tree();
+	ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, ERR_INVALID_DATA);
+
+	source = p_script->get_path();
+
+	// The best fully qualified name for a base level script is its file path
+	p_script->fully_qualified_name = p_script->path;
+
+	// Create scripts for subclasses beforehand so they can be referenced
+	_make_scripts(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+
+	p_script->_owner = nullptr;
+	Error err = _parse_class_level(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+
+	if (err) {
+		return err;
+	}
+
+	err = _parse_class_blocks(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+
+	if (err) {
+		return err;
+	}
+
+	return OK;
+}
+
+String GDScriptCompiler::get_error() const {
+	return error;
+}
+int GDScriptCompiler::get_error_line() const {
+	return err_line;
+}
+int GDScriptCompiler::get_error_column() const {
+	return err_column;
+}
+
+GDScriptCompiler::GDScriptCompiler() {
+}
diff --git a/modules/cscript/cscript_compiler.h b/modules/cscript/cscript_compiler.h
new file mode 100644
index 000000000..6fcef29b4
--- /dev/null
+++ b/modules/cscript/cscript_compiler.h
@@ -0,0 +1,169 @@
+#ifndef CSCRIPT_COMPILER_H
+#define CSCRIPT_COMPILER_H
+/*************************************************************************/
+/*  gdscript_compiler.h                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/set.h"
+#include "cscript.h"
+#include "cscript_parser.h"
+
+class GDScriptCompiler {
+	const GDScriptParser *parser;
+	Set<GDScript *> parsed_classes;
+	Set<GDScript *> parsing_classes;
+	GDScript *main_script;
+	struct CodeGen {
+		GDScript *script;
+		const GDScriptParser::ClassNode *class_node;
+		const GDScriptParser::FunctionNode *function_node;
+		bool debug_stack;
+
+		List<Map<StringName, int>> stack_id_stack;
+		Map<StringName, int> stack_identifiers;
+
+		List<GDScriptFunction::StackDebug> stack_debug;
+		List<Map<StringName, int>> block_identifier_stack;
+		Map<StringName, int> block_identifiers;
+
+		void add_stack_identifier(const StringName &p_id, int p_stackpos) {
+			stack_identifiers[p_id] = p_stackpos;
+			if (debug_stack) {
+				block_identifiers[p_id] = p_stackpos;
+				GDScriptFunction::StackDebug sd;
+				sd.added = true;
+				sd.line = current_line;
+				sd.identifier = p_id;
+				sd.pos = p_stackpos;
+				stack_debug.push_back(sd);
+			}
+		}
+
+		void push_stack_identifiers() {
+			stack_id_stack.push_back(stack_identifiers);
+			if (debug_stack) {
+				block_identifier_stack.push_back(block_identifiers);
+				block_identifiers.clear();
+			}
+		}
+
+		void pop_stack_identifiers() {
+			stack_identifiers = stack_id_stack.back()->get();
+			stack_id_stack.pop_back();
+
+			if (debug_stack) {
+				for (Map<StringName, int>::Element *E = block_identifiers.front(); E; E = E->next()) {
+					GDScriptFunction::StackDebug sd;
+					sd.added = false;
+					sd.identifier = E->key();
+					sd.line = current_line;
+					sd.pos = E->get();
+					stack_debug.push_back(sd);
+				}
+				block_identifiers = block_identifier_stack.back()->get();
+				block_identifier_stack.pop_back();
+			}
+		}
+
+		HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
+		Map<StringName, int> name_map;
+#ifdef TOOLS_ENABLED
+		Vector<StringName> named_globals;
+#endif
+
+		int get_name_map_pos(const StringName &p_identifier) {
+			int ret;
+			if (!name_map.has(p_identifier)) {
+				ret = name_map.size();
+				name_map[p_identifier] = ret;
+			} else {
+				ret = name_map[p_identifier];
+			}
+			return ret;
+		}
+
+		int get_constant_pos(const Variant &p_constant) {
+			if (constant_map.has(p_constant)) {
+				return constant_map[p_constant];
+			}
+			int pos = constant_map.size();
+			constant_map[p_constant] = pos;
+			return pos;
+		}
+
+		Vector<int> opcodes;
+		void alloc_stack(int p_level) {
+			if (p_level >= stack_max) {
+				stack_max = p_level + 1;
+			}
+		}
+		void alloc_call(int p_params) {
+			if (p_params >= call_max) {
+				call_max = p_params;
+			}
+		}
+
+		int current_line;
+		int stack_max;
+		int call_max;
+	};
+
+	bool _is_class_member_property(CodeGen &codegen, const StringName &p_name);
+	bool _is_class_member_property(GDScript *owner, const StringName &p_name);
+
+	void _set_error(const String &p_error, const GDScriptParser::Node *p_node);
+
+	bool _create_unary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level);
+	bool _create_binary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer = false, int p_index_addr = 0);
+
+	GDScriptDataType _gdtype_from_datatype(const GDScriptParser::DataType &p_datatype, GDScript *p_owner = nullptr) const;
+
+	int _parse_assign_right_expression(CodeGen &codegen, const GDScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr = 0);
+	int _parse_expression(CodeGen &codegen, const GDScriptParser::Node *p_expression, int p_stack_level, bool p_root = false, bool p_initializer = false, int p_index_addr = 0);
+	Error _parse_block(CodeGen &codegen, const GDScriptParser::BlockNode *p_block, int p_stack_level = 0, int p_break_addr = -1, int p_continue_addr = -1);
+	Error _parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready = false);
+	Error _parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
+	Error _parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
+	void _make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
+	int err_line;
+	int err_column;
+	StringName source;
+	String error;
+
+public:
+	Error compile(const GDScriptParser *p_parser, GDScript *p_script, bool p_keep_state = false);
+
+	String get_error() const;
+	int get_error_line() const;
+	int get_error_column() const;
+
+	GDScriptCompiler();
+};
+
+#endif // GDSCRIPT_COMPILER_H
diff --git a/modules/cscript/cscript_editor.cpp b/modules/cscript/cscript_editor.cpp
new file mode 100644
index 000000000..d57bbb028
--- /dev/null
+++ b/modules/cscript/cscript_editor.cpp
@@ -0,0 +1,3552 @@
+/*************************************************************************/
+/*  gdscript_editor.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript.h"
+
+#include "core/engine.h"
+#include "core/global_constants.h"
+#include "core/os/file_access.h"
+#include "core/project_settings.h"
+#include "cscript_compiler.h"
+
+#ifdef TOOLS_ENABLED
+#include "editor/editor_file_system.h"
+#include "editor/editor_settings.h"
+#endif
+
+void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("#");
+}
+
+void GDScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("\"\"\" \"\"\"");
+	p_delimiters->push_back("\" \"");
+	p_delimiters->push_back("' '");
+}
+
+String GDScriptLanguage::_get_processed_template(const String &p_template, const String &p_base_class_name) const {
+	String processed_template = p_template;
+
+#ifdef TOOLS_ENABLED
+	if (EDITOR_DEF("text_editor/completion/add_type_hints", false)) {
+		processed_template = processed_template.replace("%INT_TYPE%", ": int");
+		processed_template = processed_template.replace("%STRING_TYPE%", ": String");
+		processed_template = processed_template.replace("%FLOAT_TYPE%", ": float");
+		processed_template = processed_template.replace("%VOID_RETURN%", " -> void");
+	} else {
+		processed_template = processed_template.replace("%INT_TYPE%", "");
+		processed_template = processed_template.replace("%STRING_TYPE%", "");
+		processed_template = processed_template.replace("%FLOAT_TYPE%", "");
+		processed_template = processed_template.replace("%VOID_RETURN%", "");
+	}
+#else
+	processed_template = processed_template.replace("%INT_TYPE%", "");
+	processed_template = processed_template.replace("%STRING_TYPE%", "");
+	processed_template = processed_template.replace("%FLOAT_TYPE%", "");
+	processed_template = processed_template.replace("%VOID_RETURN%", "");
+#endif
+
+	processed_template = processed_template.replace("%BASE%", p_base_class_name);
+	processed_template = processed_template.replace("%TS%", _get_indentation());
+
+	return processed_template;
+}
+
+Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
+	String _template = "extends %BASE%\n"
+					   "\n"
+					   "\n"
+					   "# Declare member variables here. Examples:\n"
+					   "# var a%INT_TYPE% = 2\n"
+					   "# var b%STRING_TYPE% = \"text\"\n"
+					   "\n"
+					   "\n"
+					   "# Called when the node enters the scene tree for the first time.\n"
+					   "func _ready()%VOID_RETURN%:\n"
+					   "%TS%pass # Replace with function body.\n"
+					   "\n"
+					   "\n"
+					   "# Called every frame. 'delta' is the elapsed time since the previous frame.\n"
+					   "#func _process(delta%FLOAT_TYPE%)%VOID_RETURN%:\n"
+					   "#%TS%pass\n";
+
+	_template = _get_processed_template(_template, p_base_class_name);
+
+	Ref<GDScript> script;
+	script.instance();
+	script->set_source_code(_template);
+
+	return script;
+}
+
+bool GDScriptLanguage::is_using_templates() {
+	return true;
+}
+
+void GDScriptLanguage::make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script) {
+	String _template = _get_processed_template(p_script->get_source_code(), p_base_class_name);
+	p_script->set_source_code(_template);
+}
+
+bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings, Set<int> *r_safe_lines) const {
+	GDScriptParser parser;
+
+	Error err = parser.parse(p_script, p_path.get_base_dir(), true, p_path, false, r_safe_lines);
+#ifdef DEBUG_ENABLED
+	if (r_warnings) {
+		for (const List<GDScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
+			const GDScriptWarning &warn = E->get();
+			ScriptLanguage::Warning w;
+			w.line = warn.line;
+			w.code = (int)warn.code;
+			w.string_code = GDScriptWarning::get_name_from_code(warn.code);
+			w.message = warn.get_message();
+			r_warnings->push_back(w);
+		}
+	}
+#endif
+	if (err) {
+		r_line_error = parser.get_error_line();
+		r_col_error = parser.get_error_column();
+		r_test_error = parser.get_error();
+		return false;
+	} else {
+		const GDScriptParser::Node *root = parser.get_parse_tree();
+		ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, false);
+
+		const GDScriptParser::ClassNode *cl = static_cast<const GDScriptParser::ClassNode *>(root);
+		Map<int, String> funcs;
+		for (int i = 0; i < cl->functions.size(); i++) {
+			funcs[cl->functions[i]->line] = cl->functions[i]->name;
+		}
+
+		for (int i = 0; i < cl->static_functions.size(); i++) {
+			funcs[cl->static_functions[i]->line] = cl->static_functions[i]->name;
+		}
+
+		for (int i = 0; i < cl->subclasses.size(); i++) {
+			for (int j = 0; j < cl->subclasses[i]->functions.size(); j++) {
+				funcs[cl->subclasses[i]->functions[j]->line] = String(cl->subclasses[i]->name) + "." + cl->subclasses[i]->functions[j]->name;
+			}
+			for (int j = 0; j < cl->subclasses[i]->static_functions.size(); j++) {
+				funcs[cl->subclasses[i]->static_functions[j]->line] = String(cl->subclasses[i]->name) + "." + cl->subclasses[i]->static_functions[j]->name;
+			}
+		}
+
+		for (Map<int, String>::Element *E = funcs.front(); E; E = E->next()) {
+			r_functions->push_back(E->get() + ":" + itos(E->key()));
+		}
+	}
+
+	return true;
+}
+
+bool GDScriptLanguage::has_named_classes() const {
+	return false;
+}
+
+bool GDScriptLanguage::supports_builtin_mode() const {
+	return true;
+}
+
+int GDScriptLanguage::find_function(const String &p_function, const String &p_code) const {
+	GDScriptTokenizerText tokenizer;
+	tokenizer.set_code(p_code);
+	int indent = 0;
+	while (tokenizer.get_token() != GDScriptTokenizer::TK_EOF && tokenizer.get_token() != GDScriptTokenizer::TK_ERROR) {
+		if (tokenizer.get_token() == GDScriptTokenizer::TK_NEWLINE) {
+			indent = tokenizer.get_token_line_indent();
+		}
+		if (indent == 0 && tokenizer.get_token() == GDScriptTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1) == GDScriptTokenizer::TK_IDENTIFIER) {
+			String identifier = tokenizer.get_token_identifier(1);
+			if (identifier == p_function) {
+				return tokenizer.get_token_line();
+			}
+		}
+		tokenizer.advance();
+	}
+	return -1;
+}
+
+Script *GDScriptLanguage::create_script() const {
+	return memnew(GDScript);
+}
+
+/* DEBUGGER FUNCTIONS */
+
+bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
+	//break because of parse error
+
+	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
+		_debug_parse_err_line = p_line;
+		_debug_parse_err_file = p_file;
+		_debug_error = p_error;
+		ScriptDebugger::get_singleton()->debug(this, false, true);
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
+	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
+		_debug_parse_err_line = -1;
+		_debug_parse_err_file = "";
+		_debug_error = p_error;
+		bool is_error_breakpoint = p_error != "Breakpoint";
+		ScriptDebugger::get_singleton()->debug(this, p_allow_continue, is_error_breakpoint);
+		return true;
+	} else {
+		return false;
+	}
+}
+
+String GDScriptLanguage::debug_get_error() const {
+	return _debug_error;
+}
+
+int GDScriptLanguage::debug_get_stack_level_count() const {
+	if (_debug_parse_err_line >= 0) {
+		return 1;
+	}
+
+	return _debug_call_stack_pos;
+}
+int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
+	if (_debug_parse_err_line >= 0) {
+		return _debug_parse_err_line;
+	}
+
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, -1);
+
+	int l = _debug_call_stack_pos - p_level - 1;
+
+	return *(_call_stack[l].line);
+}
+String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
+	if (_debug_parse_err_line >= 0) {
+		return "";
+	}
+
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return _call_stack[l].function->get_name();
+}
+String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
+	if (_debug_parse_err_line >= 0) {
+		return _debug_parse_err_file;
+	}
+
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, "");
+	int l = _debug_call_stack_pos - p_level - 1;
+	return _call_stack[l].function->get_source();
+}
+void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+	if (_debug_parse_err_line >= 0) {
+		return;
+	}
+
+	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
+	int l = _debug_call_stack_pos - p_level - 1;
+
+	GDScriptFunction *f = _call_stack[l].function;
+
+	List<Pair<StringName, int>> locals;
+
+	f->debug_get_stack_member_state(*_call_stack[l].line, &locals);
+	for (List<Pair<StringName, int>>::Element *E = locals.front(); E; E = E->next()) {
+		p_locals->push_back(E->get().first);
+		p_values->push_back(_call_stack[l].stack[E->get().second]);
+	}
+}
+void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+	if (_debug_parse_err_line >= 0) {
+		return;
+	}
+
+	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
+	int l = _debug_call_stack_pos - p_level - 1;
+
+	GDScriptInstance *instance = _call_stack[l].instance;
+
+	if (!instance) {
+		return;
+	}
+
+	Ref<GDScript> script = instance->get_script();
+	ERR_FAIL_COND(script.is_null());
+
+	const Map<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
+
+	for (const Map<StringName, GDScript::MemberInfo>::Element *E = mi.front(); E; E = E->next()) {
+		p_members->push_back(E->key());
+		p_values->push_back(instance->debug_get_member_by_index(E->get().index));
+	}
+}
+
+ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
+	if (_debug_parse_err_line >= 0) {
+		return nullptr;
+	}
+
+	ERR_FAIL_INDEX_V(p_level, _debug_call_stack_pos, nullptr);
+
+	int l = _debug_call_stack_pos - p_level - 1;
+	ScriptInstance *instance = _call_stack[l].instance;
+
+	return instance;
+}
+
+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 Variant *globals = GDScriptLanguage::get_singleton()->get_global_array();
+
+	List<Pair<String, Variant>> cinfo;
+	get_public_constants(&cinfo);
+
+	for (const Map<StringName, int>::Element *E = name_idx.front(); E; E = E->next()) {
+		if (ClassDB::class_exists(E->key()) || Engine::get_singleton()->has_singleton(E->key())) {
+			continue;
+		}
+
+		bool is_script_constant = false;
+		for (List<Pair<String, Variant>>::Element *CE = cinfo.front(); CE; CE = CE->next()) {
+			if (CE->get().first == E->key()) {
+				is_script_constant = true;
+				break;
+			}
+		}
+		if (is_script_constant) {
+			continue;
+		}
+
+		const Variant &var = globals[E->value()];
+		if (Object *obj = var) {
+			if (Object::cast_to<GDScriptNativeClass>(obj)) {
+				continue;
+			}
+		}
+
+		bool skip = false;
+		for (int i = 0; i < GlobalConstants::get_global_constant_count(); i++) {
+			if (E->key() == GlobalConstants::get_global_constant_name(i)) {
+				skip = true;
+				break;
+			}
+		}
+		if (skip) {
+			continue;
+		}
+
+		p_globals->push_back(E->key());
+		p_values->push_back(var);
+	}
+}
+
+String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
+	return "";
+}
+
+void GDScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back("gd");
+}
+
+void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
+	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+		p_functions->push_back(GDScriptFunctions::get_info(GDScriptFunctions::Function(i)));
+	}
+
+	//not really "functions", but..
+	{
+		MethodInfo mi;
+		mi.name = "preload";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "path"));
+		mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "Resource");
+		p_functions->push_back(mi);
+	}
+	{
+		MethodInfo mi;
+		mi.name = "yield";
+		mi.arguments.push_back(PropertyInfo(Variant::OBJECT, "object"));
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "signal"));
+		mi.default_arguments.push_back(Variant());
+		mi.default_arguments.push_back(String());
+		mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "GDScriptFunctionState");
+		p_functions->push_back(mi);
+	}
+	{
+		MethodInfo mi;
+		mi.name = "assert";
+		mi.return_val.type = Variant::NIL;
+		mi.arguments.push_back(PropertyInfo(Variant::BOOL, "condition"));
+		mi.arguments.push_back(PropertyInfo(Variant::STRING, "message"));
+		mi.default_arguments.push_back(String());
+		p_functions->push_back(mi);
+	}
+}
+
+void GDScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_constants) const {
+	Pair<String, Variant> pi;
+	pi.first = "PI";
+	pi.second = Math_PI;
+	p_constants->push_back(pi);
+
+	Pair<String, Variant> tau;
+	tau.first = "TAU";
+	tau.second = Math_TAU;
+	p_constants->push_back(tau);
+
+	Pair<String, Variant> infinity;
+	infinity.first = "INF";
+	infinity.second = Math_INF;
+	p_constants->push_back(infinity);
+
+	Pair<String, Variant> nan;
+	nan.first = "NAN";
+	nan.second = Math_NAN;
+	p_constants->push_back(nan);
+}
+
+String GDScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
+#ifdef TOOLS_ENABLED
+	bool th = EditorSettings::get_singleton()->get_setting("text_editor/completion/add_type_hints");
+#else
+	bool th = false;
+#endif
+
+	String s = "func " + p_name + "(";
+	if (p_args.size()) {
+		for (int i = 0; i < p_args.size(); i++) {
+			if (i > 0) {
+				s += ", ";
+			}
+			s += p_args[i].get_slice(":", 0);
+			if (th) {
+				String type = p_args[i].get_slice(":", 1);
+				if (!type.empty() && type != "var") {
+					s += ": " + type;
+				}
+			}
+		}
+	}
+	s += String(")") + (th ? " -> void" : "") + ":\n" + _get_indentation() + "pass # Replace with function body.\n";
+
+	return s;
+}
+
+//////// COMPLETION //////////
+
+#if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED)
+
+struct GDScriptCompletionContext {
+	const GDScriptParser::ClassNode *_class;
+	const GDScriptParser::FunctionNode *function;
+	const GDScriptParser::BlockNode *block;
+	Object *base;
+	String base_path;
+	int line;
+	uint32_t depth;
+
+	GDScriptCompletionContext() :
+			_class(nullptr),
+			function(nullptr),
+			block(nullptr),
+			base(nullptr),
+			line(0),
+			depth(0) {}
+};
+
+struct GDScriptCompletionIdentifier {
+	GDScriptParser::DataType type;
+	String enumeration;
+	Variant value;
+	const GDScriptParser::Node *assigned_expression;
+
+	GDScriptCompletionIdentifier() :
+			assigned_expression(nullptr) {}
+};
+
+static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptCodeCompletionOption> &r_list, String p_ends_with = "") {
+	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
+
+	for (int i = 0; i < p_dir->get_file_count(); i++) {
+		ScriptCodeCompletionOption option(p_dir->get_file_path(i), ScriptCodeCompletionOption::KIND_FILE_PATH);
+		option.insert_text = quote_style + option.display + quote_style;
+		if (!p_ends_with.empty()) {
+			if (option.display.ends_with(p_ends_with)) {
+				r_list.insert(option.display, option);
+			}
+		} else {
+			r_list.insert(option.display, option);
+		}
+	}
+
+	for (int i = 0; i < p_dir->get_subdir_count(); i++) {
+		_get_directory_contents(p_dir->get_subdir(i), r_list, p_ends_with);
+	}
+}
+
+static String _get_visual_datatype(const PropertyInfo &p_info, bool p_isarg = true) {
+	if (p_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+		String enum_name = p_info.class_name;
+		if (enum_name.find(".") == -1) {
+			return enum_name;
+		}
+		return enum_name.get_slice(".", 1);
+	}
+
+	String n = p_info.name;
+	int idx = n.find(":");
+	if (idx != -1) {
+		return n.substr(idx + 1, n.length());
+	}
+
+	if (p_info.type == Variant::OBJECT) {
+		if (p_info.hint == PROPERTY_HINT_RESOURCE_TYPE) {
+			return p_info.hint_string;
+		} else {
+			return p_info.class_name.operator String();
+		}
+	}
+	if (p_info.type == Variant::NIL) {
+		if (p_isarg || (p_info.usage & PROPERTY_USAGE_NIL_IS_VARIANT)) {
+			return "Variant";
+		} else {
+			return "void";
+		}
+	}
+
+	return Variant::get_type_name(p_info.type);
+}
+
+static GDScriptCompletionIdentifier _type_from_variant(const Variant &p_value) {
+	GDScriptCompletionIdentifier ci;
+	ci.value = p_value;
+	ci.type.is_constant = true;
+	ci.type.has_type = true;
+	ci.type.kind = GDScriptParser::DataType::BUILTIN;
+	ci.type.builtin_type = p_value.get_type();
+
+	if (ci.type.builtin_type == Variant::OBJECT) {
+		Object *obj = p_value.operator Object *();
+		if (!obj) {
+			return ci;
+		}
+		ci.type.native_type = obj->get_class_name();
+		Ref<Script> scr = p_value;
+		if (scr.is_valid()) {
+			ci.type.is_meta_type = true;
+		} else {
+			ci.type.is_meta_type = false;
+			scr = obj->get_script();
+		}
+		if (scr.is_valid()) {
+			ci.type.script_type = scr;
+			Ref<GDScript> gds = scr;
+			if (gds.is_valid()) {
+				ci.type.kind = GDScriptParser::DataType::GDSCRIPT;
+			} else {
+				ci.type.kind = GDScriptParser::DataType::SCRIPT;
+			}
+			ci.type.native_type = scr->get_instance_base_type();
+		} else {
+			ci.type.kind = GDScriptParser::DataType::NATIVE;
+		}
+	}
+
+	return ci;
+}
+
+static GDScriptCompletionIdentifier _type_from_property(const PropertyInfo &p_property) {
+	GDScriptCompletionIdentifier ci;
+
+	if (p_property.type == Variant::NIL) {
+		// Variant
+		return ci;
+	}
+
+	if (p_property.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+		ci.enumeration = p_property.class_name;
+	}
+
+	ci.type.has_type = true;
+	ci.type.builtin_type = p_property.type;
+	if (p_property.type == Variant::OBJECT) {
+		ci.type.kind = GDScriptParser::DataType::NATIVE;
+		ci.type.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
+	} else {
+		ci.type.kind = GDScriptParser::DataType::BUILTIN;
+	}
+	return ci;
+}
+
+static GDScriptCompletionIdentifier _type_from_gdtype(const GDScriptDataType &p_gdtype) {
+	GDScriptCompletionIdentifier ci;
+	if (!p_gdtype.has_type) {
+		return ci;
+	}
+
+	ci.type.has_type = true;
+	ci.type.builtin_type = p_gdtype.builtin_type;
+	ci.type.native_type = p_gdtype.native_type;
+	ci.type.script_type = Ref<Script>(p_gdtype.script_type);
+
+	switch (p_gdtype.kind) {
+		case GDScriptDataType::UNINITIALIZED: {
+			ERR_PRINT("Uninitialized completion. Please report a bug.");
+		} break;
+		case GDScriptDataType::BUILTIN: {
+			ci.type.kind = GDScriptParser::DataType::BUILTIN;
+		} break;
+		case GDScriptDataType::NATIVE: {
+			ci.type.kind = GDScriptParser::DataType::NATIVE;
+		} break;
+		case GDScriptDataType::GDSCRIPT: {
+			ci.type.kind = GDScriptParser::DataType::GDSCRIPT;
+		} break;
+		case GDScriptDataType::SCRIPT: {
+			ci.type.kind = GDScriptParser::DataType::SCRIPT;
+		} break;
+	}
+	return ci;
+}
+
+static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type);
+static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type);
+static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type);
+
+static bool _guess_expression_type(GDScriptCompletionContext &p_context, const GDScriptParser::Node *p_expression, GDScriptCompletionIdentifier &r_type) {
+	bool found = false;
+
+	if (++p_context.depth > 100) {
+		print_error("Maximum _guess_expression_type depth limit reached. Please file a bugreport.");
+		return false;
+	}
+
+	switch (p_expression->type) {
+		case GDScriptParser::Node::TYPE_CONSTANT: {
+			const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(p_expression);
+			r_type = _type_from_variant(cn->value);
+			found = true;
+		} break;
+		case GDScriptParser::Node::TYPE_SELF: {
+			if (p_context._class) {
+				r_type.type.has_type = true;
+				r_type.type.kind = GDScriptParser::DataType::CLASS;
+				r_type.type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+				r_type.type.is_constant = true;
+				r_type.value = p_context.base;
+				found = true;
+			}
+		} break;
+		case GDScriptParser::Node::TYPE_IDENTIFIER: {
+			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
+			found = _guess_identifier_type(p_context, id->name, r_type);
+		} break;
+		case GDScriptParser::Node::TYPE_DICTIONARY: {
+			// Try to recreate the dictionary
+			const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
+			Dictionary d;
+			bool full = true;
+			for (int i = 0; i < dn->elements.size(); i++) {
+				GDScriptCompletionIdentifier key;
+				if (_guess_expression_type(p_context, dn->elements[i].key, key)) {
+					GDScriptCompletionIdentifier value;
+					if (_guess_expression_type(p_context, dn->elements[i].value, value)) {
+						if (!value.type.is_constant) {
+							full = false;
+							break;
+						}
+						d[key.value] = value.value;
+					} else {
+						full = false;
+						break;
+					}
+				} else {
+					full = false;
+					break;
+				}
+			}
+			if (full) {
+				// If not fully constant, setting this value is detrimental to the inference
+				r_type.value = d;
+				r_type.type.is_constant = true;
+			}
+			r_type.type.has_type = true;
+			r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+			r_type.type.builtin_type = Variant::DICTIONARY;
+		} break;
+		case GDScriptParser::Node::TYPE_ARRAY: {
+			// Try to recreate the array
+			const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
+			Array a;
+			bool full = true;
+			a.resize(an->elements.size());
+			for (int i = 0; i < an->elements.size(); i++) {
+				GDScriptCompletionIdentifier value;
+				if (_guess_expression_type(p_context, an->elements[i], value)) {
+					a[i] = value.value;
+				} else {
+					full = false;
+					break;
+				}
+			}
+			if (full) {
+				// If not fully constant, setting this value is detrimental to the inference
+				r_type.value = a;
+			}
+			r_type.type.has_type = true;
+			r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+			r_type.type.builtin_type = Variant::ARRAY;
+		} break;
+		case GDScriptParser::Node::TYPE_CAST: {
+			const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
+			GDScriptCompletionIdentifier value;
+			if (_guess_expression_type(p_context, cn->source_node, r_type)) {
+				r_type.type = cn->get_datatype();
+				found = true;
+			}
+		} break;
+		case GDScriptParser::Node::TYPE_OPERATOR: {
+			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_expression);
+			switch (op->op) {
+				case GDScriptParser::OperatorNode::OP_CALL: {
+					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
+						const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(op->arguments[0]);
+						r_type.type.has_type = true;
+						r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+						r_type.type.builtin_type = tn->vtype;
+						found = true;
+						break;
+					} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+						const GDScriptParser::BuiltInFunctionNode *bin = static_cast<const GDScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
+						MethodInfo mi = GDScriptFunctions::get_info(bin->function);
+						r_type = _type_from_property(mi.return_val);
+						found = true;
+						break;
+					} else if (op->arguments.size() >= 2 && op->arguments[1]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
+						StringName id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1])->name;
+
+						GDScriptCompletionContext c = p_context;
+						c.line = op->line;
+
+						GDScriptCompletionIdentifier base;
+						if (!_guess_expression_type(c, op->arguments[0], base)) {
+							found = false;
+							break;
+						}
+
+						// Try call if constant methods with constant arguments
+						if (base.type.is_constant && base.value.get_type() == Variant::OBJECT) {
+							GDScriptParser::DataType native_type = base.type;
+
+							while (native_type.kind == GDScriptParser::DataType::CLASS) {
+								native_type = native_type.class_type->base_type;
+							}
+
+							while (native_type.kind == GDScriptParser::DataType::GDSCRIPT || native_type.kind == GDScriptParser::DataType::SCRIPT) {
+								if (native_type.script_type.is_valid()) {
+									Ref<Script> parent = native_type.script_type->get_base_script();
+									if (parent.is_valid()) {
+										native_type.script_type = parent;
+									} else {
+										native_type.kind = GDScriptParser::DataType::NATIVE;
+										native_type.native_type = native_type.script_type->get_instance_base_type();
+										if (!ClassDB::class_exists(native_type.native_type)) {
+											native_type.native_type = String("_") + native_type.native_type;
+											if (!ClassDB::class_exists(native_type.native_type)) {
+												native_type.has_type = false;
+											}
+										}
+									}
+								}
+							}
+
+							if (native_type.has_type && native_type.kind == GDScriptParser::DataType::NATIVE) {
+								MethodBind *mb = ClassDB::get_method(native_type.native_type, id);
+								if (mb && mb->is_const()) {
+									bool all_is_const = true;
+									Vector<Variant> args;
+									GDScriptCompletionContext c2 = p_context;
+									c2.line = op->line;
+									for (int i = 2; all_is_const && i < op->arguments.size(); i++) {
+										GDScriptCompletionIdentifier arg;
+
+										if (_guess_expression_type(c2, op->arguments[i], arg)) {
+											if (arg.type.has_type && arg.type.is_constant && arg.value.get_type() != Variant::OBJECT) {
+												args.push_back(arg.value);
+											} else {
+												all_is_const = false;
+											}
+										} else {
+											all_is_const = false;
+										}
+									}
+
+									Object *baseptr = base.value;
+
+									if (all_is_const && String(id) == "get_node" && ClassDB::is_parent_class(native_type.native_type, "Node") && args.size()) {
+										String arg1 = args[0];
+										if (arg1.begins_with("/root/")) {
+											String which = arg1.get_slice("/", 2);
+											if (which != "") {
+												// Try singletons first
+												if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(which)) {
+													r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[which]);
+													found = true;
+												} else {
+													List<PropertyInfo> props;
+													ProjectSettings::get_singleton()->get_property_list(&props);
+
+													for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+														String s = E->get().name;
+														if (!s.begins_with("autoload/")) {
+															continue;
+														}
+														String name = s.get_slice("/", 1);
+														if (name == which) {
+															String script = ProjectSettings::get_singleton()->get(s);
+
+															if (script.begins_with("*")) {
+																script = script.right(1);
+															}
+
+															if (!script.begins_with("res://")) {
+																script = "res://" + script;
+															}
+
+															if (!script.ends_with(".gd")) {
+																//not a script, try find the script anyway,
+																//may have some success
+																script = script.get_basename() + ".gd";
+															}
+
+															if (FileAccess::exists(script)) {
+																Ref<Script> scr;
+																if (ScriptCodeCompletionCache::get_singleton()) {
+																	scr = ScriptCodeCompletionCache::get_singleton()->get_cached_resource(script);
+																} else {
+																	scr = ResourceLoader::load(script);
+																}
+																if (scr.is_valid()) {
+																	r_type.type.has_type = true;
+																	r_type.type.script_type = scr;
+																	r_type.type.is_constant = false;
+																	Ref<GDScript> gds = scr;
+																	if (gds.is_valid()) {
+																		r_type.type.kind = GDScriptParser::DataType::GDSCRIPT;
+																	} else {
+																		r_type.type.kind = GDScriptParser::DataType::SCRIPT;
+																	}
+																	r_type.value = Variant();
+																	found = true;
+																}
+															}
+															break;
+														}
+													}
+												}
+											}
+										}
+									}
+
+									if (!found && all_is_const && baseptr) {
+										Vector<const Variant *> argptr;
+										for (int i = 0; i < args.size(); i++) {
+											argptr.push_back(&args[i]);
+										}
+
+										Variant::CallError ce;
+										Variant ret = mb->call(baseptr, (const Variant **)argptr.ptr(), argptr.size(), ce);
+
+										if (ce.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
+											if (ret.get_type() != Variant::OBJECT || ret.operator Object *() != nullptr) {
+												r_type = _type_from_variant(ret);
+												found = true;
+											}
+										}
+									}
+								}
+							}
+						}
+
+						if (!found) {
+							found = _guess_method_return_type_from_base(c, base, id, r_type);
+						}
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_PARENT_CALL: {
+					if (!p_context._class || !op->arguments.size() || op->arguments[0]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+						break;
+					}
+
+					StringName id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name;
+
+					GDScriptCompletionIdentifier base;
+					base.value = p_context.base;
+					base.type = p_context._class->base_type;
+
+					GDScriptCompletionContext c = p_context;
+					c.line = op->line;
+
+					found = _guess_method_return_type_from_base(c, base, id, r_type);
+				} break;
+				case GDScriptParser::OperatorNode::OP_INDEX_NAMED: {
+					if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+						found = false;
+						break;
+					}
+					const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+
+					GDScriptCompletionContext c = p_context;
+					c.line = op->line;
+
+					GDScriptCompletionIdentifier base;
+					if (!_guess_expression_type(c, op->arguments[0], base)) {
+						found = false;
+						break;
+					}
+
+					if (base.value.get_type() == Variant::DICTIONARY && base.value.operator Dictionary().has(String(id->name))) {
+						Variant value = base.value.operator Dictionary()[String(id->name)];
+						r_type = _type_from_variant(value);
+						found = true;
+						break;
+					}
+
+					const GDScriptParser::DictionaryNode *dn = nullptr;
+					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const GDScriptParser::DictionaryNode *>(op->arguments[0]);
+					} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
+					}
+
+					if (dn) {
+						for (int i = 0; i < dn->elements.size(); i++) {
+							GDScriptCompletionIdentifier key;
+							if (!_guess_expression_type(c, dn->elements[i].key, key)) {
+								continue;
+							}
+							if (key.value == String(id->name)) {
+								r_type.assigned_expression = dn->elements[i].value;
+								found = _guess_expression_type(c, dn->elements[i].value, r_type);
+								break;
+							}
+						}
+					}
+
+					if (!found) {
+						found = _guess_identifier_type_from_base(c, base, id->name, r_type);
+					}
+				} break;
+				case GDScriptParser::OperatorNode::OP_INDEX: {
+					if (op->arguments.size() < 2) {
+						found = false;
+						break;
+					}
+
+					GDScriptCompletionContext c = p_context;
+					c.line = op->line;
+
+					GDScriptCompletionIdentifier base;
+					if (!_guess_expression_type(c, op->arguments[0], base)) {
+						found = false;
+						break;
+					}
+
+					GDScriptCompletionIdentifier index;
+					if (!_guess_expression_type(c, op->arguments[1], index)) {
+						found = false;
+						break;
+					}
+
+					if (base.value.in(index.value)) {
+						Variant value = base.value.get(index.value);
+						r_type = _type_from_variant(value);
+						found = true;
+						break;
+					}
+
+					// Look if it is a dictionary node
+					const GDScriptParser::DictionaryNode *dn = nullptr;
+					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const GDScriptParser::DictionaryNode *>(op->arguments[0]);
+					} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
+					}
+
+					if (dn) {
+						for (int i = 0; i < dn->elements.size(); i++) {
+							GDScriptCompletionIdentifier key;
+							if (!_guess_expression_type(c, dn->elements[i].key, key)) {
+								continue;
+							}
+							if (key.value == index.value) {
+								r_type.assigned_expression = dn->elements[i].value;
+								found = _guess_expression_type(p_context, dn->elements[i].value, r_type);
+								break;
+							}
+						}
+					}
+
+					// Look if it is an array node
+					if (!found && index.value.is_num()) {
+						int idx = index.value;
+						const GDScriptParser::ArrayNode *an = nullptr;
+						if (op->arguments[0]->type == GDScriptParser::Node::TYPE_ARRAY) {
+							an = static_cast<const GDScriptParser::ArrayNode *>(op->arguments[0]);
+						} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_ARRAY) {
+							an = static_cast<const GDScriptParser::ArrayNode *>(base.assigned_expression);
+						}
+
+						if (an && idx >= 0 && an->elements.size() > idx) {
+							r_type.assigned_expression = an->elements[idx];
+							found = _guess_expression_type(c, an->elements[idx], r_type);
+							break;
+						}
+					}
+
+					// Look for valid indexing in other types
+					if (!found && (index.value.get_type() == Variant::STRING || index.value.get_type() == Variant::NODE_PATH)) {
+						StringName id = index.value;
+						found = _guess_identifier_type_from_base(c, base, id, r_type);
+					} else if (!found && index.type.kind == GDScriptParser::DataType::BUILTIN) {
+						Variant::CallError err;
+						Variant base_val = Variant::construct(base.type.builtin_type, nullptr, 0, err);
+						bool valid = false;
+						Variant res = base_val.get(index.value, &valid);
+						if (valid) {
+							r_type = _type_from_variant(res);
+							r_type.value = Variant();
+							r_type.type.is_constant = false;
+							found = true;
+						}
+					}
+				} break;
+				default: {
+					if (op->arguments.size() < 2) {
+						found = false;
+						break;
+					}
+
+					Variant::Operator vop = Variant::OP_MAX;
+					switch (op->op) {
+						case GDScriptParser::OperatorNode::OP_ADD:
+							vop = Variant::OP_ADD;
+							break;
+						case GDScriptParser::OperatorNode::OP_SUB:
+							vop = Variant::OP_SUBTRACT;
+							break;
+						case GDScriptParser::OperatorNode::OP_MUL:
+							vop = Variant::OP_MULTIPLY;
+							break;
+						case GDScriptParser::OperatorNode::OP_DIV:
+							vop = Variant::OP_DIVIDE;
+							break;
+						case GDScriptParser::OperatorNode::OP_MOD:
+							vop = Variant::OP_MODULE;
+							break;
+						case GDScriptParser::OperatorNode::OP_SHIFT_LEFT:
+							vop = Variant::OP_SHIFT_LEFT;
+							break;
+						case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT:
+							vop = Variant::OP_SHIFT_RIGHT;
+							break;
+						case GDScriptParser::OperatorNode::OP_BIT_AND:
+							vop = Variant::OP_BIT_AND;
+							break;
+						case GDScriptParser::OperatorNode::OP_BIT_OR:
+							vop = Variant::OP_BIT_OR;
+							break;
+						case GDScriptParser::OperatorNode::OP_BIT_XOR:
+							vop = Variant::OP_BIT_XOR;
+							break;
+						default: {
+						}
+					}
+
+					if (vop == Variant::OP_MAX) {
+						break;
+					}
+
+					GDScriptCompletionContext context = p_context;
+					context.line = op->line;
+
+					GDScriptCompletionIdentifier p1;
+					GDScriptCompletionIdentifier p2;
+
+					if (!_guess_expression_type(context, op->arguments[0], p1)) {
+						found = false;
+						break;
+					}
+
+					if (!_guess_expression_type(context, op->arguments[1], p2)) {
+						found = false;
+						break;
+					}
+
+					Variant::CallError ce;
+					bool v1_use_value = p1.value.get_type() != Variant::NIL && p1.value.get_type() != Variant::OBJECT;
+					Variant v1 = (v1_use_value) ? p1.value : Variant::construct(p1.type.builtin_type, nullptr, 0, ce);
+					bool v2_use_value = p2.value.get_type() != Variant::NIL && p2.value.get_type() != Variant::OBJECT;
+					Variant v2 = (v2_use_value) ? p2.value : Variant::construct(p2.type.builtin_type, nullptr, 0, ce);
+					// avoid potential invalid ops
+					if ((vop == Variant::OP_DIVIDE || vop == Variant::OP_MODULE) && v2.get_type() == Variant::INT) {
+						v2 = 1;
+						v2_use_value = false;
+					}
+					if (vop == Variant::OP_DIVIDE && v2.get_type() == Variant::REAL) {
+						v2 = 1.0;
+						v2_use_value = false;
+					}
+
+					Variant res;
+					bool valid;
+					Variant::evaluate(vop, v1, v2, res, valid);
+					if (!valid) {
+						found = false;
+						break;
+					}
+					r_type = _type_from_variant(res);
+					if (!v1_use_value || !v2_use_value) {
+						r_type.value = Variant();
+						r_type.type.is_constant = false;
+					}
+
+					found = true;
+				} break;
+			}
+		} break;
+		default: {
+		}
+	}
+
+	// It may have found a null, but that's never useful
+	if (found && r_type.type.has_type && r_type.type.kind == GDScriptParser::DataType::BUILTIN && r_type.type.builtin_type == Variant::NIL) {
+		found = false;
+	}
+
+	// Check type hint last. For collections we want chance to get the actual value first
+	// This way we can detect types from the content of dictionaries and arrays
+	if (!found && p_expression->get_datatype().has_type) {
+		r_type.type = p_expression->get_datatype();
+		if (!r_type.assigned_expression) {
+			r_type.assigned_expression = p_expression;
+		}
+		found = true;
+	}
+
+	return found;
+}
+
+static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type) {
+	// Look in blocks first
+	const GDScriptParser::BlockNode *blk = p_context.block;
+	int last_assign_line = -1;
+	const GDScriptParser::Node *last_assigned_expression = nullptr;
+	GDScriptParser::DataType var_type;
+	while (blk) {
+		if (blk->variables.has(p_identifier)) {
+			if (blk->variables[p_identifier]->line > p_context.line) {
+				return false;
+			}
+
+			var_type = blk->variables[p_identifier]->datatype;
+
+			if (!last_assigned_expression && blk->variables[p_identifier]->assign && blk->variables[p_identifier]->assign->type == GDScriptParser::Node::TYPE_OPERATOR) {
+				const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(blk->variables[p_identifier]->assign);
+				if (op->op == GDScriptParser::OperatorNode::OP_ASSIGN && op->arguments.size() >= 2) {
+					last_assign_line = op->line;
+					last_assigned_expression = op->arguments[1];
+				}
+			}
+		}
+
+		for (int z = 0; z < blk->statements.size(); z++) {
+			const GDScriptParser::Node *expr = blk->statements[z];
+			if (expr->line > p_context.line || expr->type != GDScriptParser::Node::TYPE_OPERATOR) {
+				continue;
+			}
+
+			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(expr);
+			if (op->op != GDScriptParser::OperatorNode::OP_ASSIGN || op->line < last_assign_line) {
+				continue;
+			}
+
+			if (op->arguments.size() >= 2 && op->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
+				const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0]);
+				if (id->name == p_identifier) {
+					last_assign_line = op->line;
+					last_assigned_expression = op->arguments[1];
+				}
+			}
+		}
+
+		if (blk->if_condition && blk->if_condition->type == GDScriptParser::Node::TYPE_OPERATOR && static_cast<const GDScriptParser::OperatorNode *>(blk->if_condition)->op == GDScriptParser::OperatorNode::OP_IS) {
+			//is used, check if identifier is in there! this helps resolve in blocks that are (if (identifier is value)): which are very common..
+			//super dirty hack, but very useful
+			//credit: Zylann
+			//TODO: this could be hacked to detect ANDed conditions too..
+			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(blk->if_condition);
+			if (op->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER && static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name == p_identifier) {
+				//bingo
+				GDScriptCompletionContext c = p_context;
+				c.line = op->line;
+				c.block = blk;
+				if (_guess_expression_type(p_context, op->arguments[1], r_type)) {
+					r_type.type.is_meta_type = false; // Right-hand of `is` will be a meta type, but the left-hand value is not
+					// Not an assignment, it shouldn't carry any value
+					r_type.value = Variant();
+					r_type.assigned_expression = nullptr;
+
+					return true;
+				}
+			}
+		}
+
+		blk = blk->parent_block;
+	}
+
+	if (last_assigned_expression && last_assign_line != p_context.line) {
+		GDScriptCompletionContext c = p_context;
+		c.line = last_assign_line;
+		r_type.assigned_expression = last_assigned_expression;
+		if (_guess_expression_type(c, last_assigned_expression, r_type)) {
+			if (var_type.has_type) {
+				r_type.type = var_type;
+			}
+			return true;
+		}
+	}
+
+	if (var_type.has_type) {
+		r_type.type = var_type;
+		return true;
+	}
+
+	if (p_context.function) {
+		for (int i = 0; i < p_context.function->arguments.size(); i++) {
+			if (p_context.function->arguments[i] == p_identifier) {
+				if (p_context.function->argument_types[i].has_type) {
+					r_type.type = p_context.function->argument_types[i];
+					return true;
+				}
+
+				int def_from = p_context.function->arguments.size() - p_context.function->default_values.size();
+				if (i >= def_from) {
+					int def_idx = i - def_from;
+					if (p_context.function->default_values[def_idx]->type == GDScriptParser::Node::TYPE_OPERATOR) {
+						const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_context.function->default_values[def_idx]);
+						if (op->arguments.size() < 2) {
+							return false;
+						}
+						GDScriptCompletionContext c = p_context;
+						c.function = nullptr;
+						c.block = nullptr;
+						return _guess_expression_type(c, op->arguments[1], r_type);
+					}
+				}
+				break;
+			}
+		}
+
+		GDScriptParser::DataType base_type = p_context._class->base_type;
+		while (base_type.has_type) {
+			switch (base_type.kind) {
+				case GDScriptParser::DataType::GDSCRIPT: {
+					Ref<GDScript> gds = base_type.script_type;
+					if (gds.is_valid() && gds->has_method(p_context.function->name)) {
+						GDScriptFunction *func = gds->get_member_functions()[p_context.function->name];
+						if (func) {
+							for (int i = 0; i < func->get_argument_count(); i++) {
+								if (func->get_argument_name(i) == p_identifier) {
+									r_type = _type_from_gdtype(func->get_argument_type(i));
+									return true;
+								}
+							}
+						}
+						Ref<GDScript> base_gds = gds->get_base_script();
+						if (base_gds.is_valid()) {
+							base_type.kind = GDScriptParser::DataType::GDSCRIPT;
+							base_type.script_type = base_gds;
+						} else {
+							base_type.kind = GDScriptParser::DataType::NATIVE;
+							base_type.native_type = gds->get_instance_base_type();
+						}
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = gds->get_instance_base_type();
+					}
+				} break;
+				case GDScriptParser::DataType::NATIVE: {
+					List<MethodInfo> methods;
+					ClassDB::get_method_list(base_type.native_type, &methods);
+					ClassDB::get_virtual_methods(base_type.native_type, &methods);
+
+					for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+						if (E->get().name == p_context.function->name) {
+							MethodInfo &mi = E->get();
+							for (List<PropertyInfo>::Element *F = mi.arguments.front(); F; F = F->next()) {
+								if (F->get().name == p_identifier) {
+									r_type = _type_from_property(F->get());
+									return true;
+								}
+							}
+						}
+					}
+					base_type.has_type = false;
+				} break;
+				default: {
+					base_type.has_type = false;
+				} break;
+			}
+		}
+	}
+
+	// Check current class (including inheritance)
+	if (p_context._class) {
+		GDScriptCompletionIdentifier context_base;
+		context_base.value = p_context.base;
+		context_base.type.has_type = true;
+		context_base.type.kind = GDScriptParser::DataType::CLASS;
+		context_base.type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+		context_base.type.is_meta_type = p_context.function && p_context.function->_static;
+
+		if (_guess_identifier_type_from_base(p_context, context_base, p_identifier, r_type)) {
+			return true;
+		}
+	}
+
+	// Check named scripts
+	if (ScriptServer::is_global_class(p_identifier)) {
+		Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_identifier));
+		if (scr.is_valid()) {
+			r_type = _type_from_variant(scr);
+			r_type.type.is_meta_type = true;
+			return true;
+		}
+		return false;
+	}
+
+	for (int i = 0; i < 2; i++) {
+		StringName target_id;
+		switch (i) {
+			case 0:
+				// Check ClassDB
+				target_id = p_identifier;
+				break;
+			case 1:
+				// ClassDB again for underscore-prefixed classes
+				target_id = String("_") + p_identifier;
+				break;
+		}
+
+		if (ClassDB::class_exists(target_id)) {
+			r_type.type.has_type = true;
+			r_type.type.kind = GDScriptParser::DataType::NATIVE;
+			r_type.type.native_type = target_id;
+			if (Engine::get_singleton()->has_singleton(target_id)) {
+				r_type.type.is_meta_type = false;
+				r_type.value = Engine::get_singleton()->get_singleton_object(target_id);
+			} else {
+				r_type.type.is_meta_type = true;
+				const Map<StringName, int>::Element *target_elem = GDScriptLanguage::get_singleton()->get_global_map().find(target_id);
+				// Check because classes like EditorNode are in ClassDB by now, but unknown to GDScript
+				if (!target_elem) {
+					return false;
+				}
+				int idx = target_elem->get();
+				r_type.value = GDScriptLanguage::get_singleton()->get_global_array()[idx];
+			}
+			return true;
+		}
+	}
+
+	// Check autoload singletons
+	if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
+		r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier]);
+		return true;
+	}
+
+	return false;
+}
+
+static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type) {
+	GDScriptParser::DataType base_type = p_base.type;
+	bool _static = base_type.is_meta_type;
+	while (base_type.has_type) {
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::CLASS: {
+				if (base_type.class_type->constant_expressions.has(p_identifier)) {
+					GDScriptParser::ClassNode::Constant c = base_type.class_type->constant_expressions[p_identifier];
+					r_type.type = c.type;
+					if (c.expression->type == GDScriptParser::Node::TYPE_CONSTANT) {
+						r_type.value = static_cast<const GDScriptParser::ConstantNode *>(c.expression)->value;
+					}
+					return true;
+				}
+
+				if (!_static) {
+					for (int i = 0; i < base_type.class_type->variables.size(); i++) {
+						GDScriptParser::ClassNode::Member m = base_type.class_type->variables[i];
+						if (m.identifier == p_identifier) {
+							if (m.expression) {
+								if (p_context.line == m.expression->line) {
+									// Variable used in the same expression
+									return false;
+								}
+								if (_guess_expression_type(p_context, m.expression, r_type)) {
+									return true;
+								}
+								if (m.expression->get_datatype().has_type) {
+									r_type.type = m.expression->get_datatype();
+									return true;
+								}
+							}
+							if (m.data_type.has_type) {
+								r_type.type = m.data_type;
+								return true;
+							}
+							return false;
+						}
+					}
+				}
+				base_type = base_type.class_type->base_type;
+			} break;
+			case GDScriptParser::DataType::GDSCRIPT: {
+				Ref<GDScript> gds = base_type.script_type;
+				if (gds.is_valid()) {
+					if (gds->get_constants().has(p_identifier)) {
+						r_type = _type_from_variant(gds->get_constants()[p_identifier]);
+						return true;
+					}
+					if (!_static) {
+						const Set<StringName>::Element *m = gds->get_members().find(p_identifier);
+						if (m) {
+							r_type = _type_from_gdtype(gds->get_member_type(p_identifier));
+							return true;
+						}
+					}
+					Ref<GDScript> parent = gds->get_base_script();
+					if (parent.is_valid()) {
+						base_type.script_type = parent;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = gds->get_instance_base_type();
+					}
+				} else {
+					return false;
+				}
+			} break;
+			case GDScriptParser::DataType::SCRIPT: {
+				Ref<Script> scr = base_type.script_type;
+				if (scr.is_valid()) {
+					Map<StringName, Variant> constants;
+					scr->get_constants(&constants);
+					if (constants.has(p_identifier)) {
+						r_type = _type_from_variant(constants[p_identifier]);
+						return true;
+					}
+
+					if (!_static) {
+						List<PropertyInfo> members;
+						scr->get_script_property_list(&members);
+						for (const List<PropertyInfo>::Element *E = members.front(); E; E = E->next()) {
+							const PropertyInfo &prop = E->get();
+							if (prop.name == p_identifier) {
+								r_type = _type_from_property(prop);
+								return true;
+							}
+						}
+					}
+					Ref<Script> parent = scr->get_base_script();
+					if (parent.is_valid()) {
+						base_type.script_type = parent;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = scr->get_instance_base_type();
+					}
+				} else {
+					return false;
+				}
+			} break;
+			case GDScriptParser::DataType::NATIVE: {
+				StringName class_name = base_type.native_type;
+				if (!ClassDB::class_exists(class_name)) {
+					class_name = String("_") + class_name;
+					if (!ClassDB::class_exists(class_name)) {
+						return false;
+					}
+				}
+
+				// Skip constants since they're all integers. Type does not matter because int has no members
+
+				List<PropertyInfo> props;
+				ClassDB::get_property_list(class_name, &props);
+				for (const List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+					const PropertyInfo &prop = E->get();
+
+					// Ignore groups and categories in code completion.
+					if (prop.usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)) {
+						continue;
+					}
+
+					if (prop.name == p_identifier) {
+						StringName getter = ClassDB::get_property_getter(class_name, p_identifier);
+						if (getter != StringName()) {
+							MethodBind *g = ClassDB::get_method(class_name, getter);
+							if (g) {
+								r_type = _type_from_property(g->get_return_info());
+								return true;
+							}
+						} else {
+							r_type = _type_from_property(prop);
+							return true;
+						}
+						break;
+					}
+				}
+				return false;
+			} break;
+			case GDScriptParser::DataType::BUILTIN: {
+				Variant::CallError err;
+				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+
+				if (err.error != Variant::CallError::CALL_OK) {
+					return false;
+				}
+				bool valid = false;
+				Variant res = tmp.get(p_identifier, &valid);
+				if (valid) {
+					r_type = _type_from_variant(res);
+					r_type.value = Variant();
+					r_type.type.is_constant = false;
+					return true;
+				}
+				return false;
+			} break;
+			default: {
+				return false;
+			} break;
+		}
+	}
+
+	return false;
+}
+
+static bool _find_last_return_in_block(const GDScriptCompletionContext &p_context, int &r_last_return_line, const GDScriptParser::Node **r_last_returned_value) {
+	if (!p_context.block) {
+		return false;
+	}
+
+	for (int i = 0; i < p_context.block->statements.size(); i++) {
+		if (p_context.block->statements[i]->line < r_last_return_line) {
+			continue;
+		}
+		if (p_context.block->statements[i]->type != GDScriptParser::Node::TYPE_CONTROL_FLOW) {
+			continue;
+		}
+
+		const GDScriptParser::ControlFlowNode *cf = static_cast<const GDScriptParser::ControlFlowNode *>(p_context.block->statements[i]);
+		if (cf->cf_type == GDScriptParser::ControlFlowNode::CF_RETURN && cf->arguments.size() > 0) {
+			if (cf->line > r_last_return_line) {
+				r_last_return_line = cf->line;
+				*r_last_returned_value = cf->arguments[0];
+			}
+		}
+	}
+
+	// Recurse into subblocks
+	for (int i = 0; i < p_context.block->sub_blocks.size(); i++) {
+		GDScriptCompletionContext c = p_context;
+		c.block = p_context.block->sub_blocks[i];
+		_find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
+	}
+
+	return false;
+}
+
+static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type) {
+	GDScriptParser::DataType base_type = p_base.type;
+	bool _static = base_type.is_meta_type;
+
+	if (_static && p_method == "new") {
+		r_type.type = base_type;
+		r_type.type.is_meta_type = false;
+		r_type.type.is_constant = false;
+		return true;
+	}
+
+	while (base_type.has_type) {
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::CLASS: {
+				if (!base_type.class_type) {
+					base_type.has_type = false;
+					break;
+				}
+
+				for (int i = 0; i < base_type.class_type->static_functions.size(); i++) {
+					if (base_type.class_type->static_functions[i]->name == p_method) {
+						int last_return_line = -1;
+						const GDScriptParser::Node *last_returned_value = nullptr;
+						GDScriptCompletionContext c = p_context;
+						c._class = base_type.class_type;
+						c.function = base_type.class_type->static_functions[i];
+						c.block = c.function->body;
+
+						_find_last_return_in_block(c, last_return_line, &last_returned_value);
+						if (last_returned_value) {
+							c.line = c.block->end_line;
+							return _guess_expression_type(c, last_returned_value, r_type);
+						}
+					}
+				}
+				if (!_static) {
+					for (int i = 0; i < base_type.class_type->functions.size(); i++) {
+						if (base_type.class_type->functions[i]->name == p_method) {
+							int last_return_line = -1;
+							const GDScriptParser::Node *last_returned_value = nullptr;
+							GDScriptCompletionContext c = p_context;
+							c._class = base_type.class_type;
+							c.function = base_type.class_type->functions[i];
+							c.block = c.function->body;
+
+							_find_last_return_in_block(c, last_return_line, &last_returned_value);
+							if (last_returned_value) {
+								c.line = c.block->end_line;
+								return _guess_expression_type(c, last_returned_value, r_type);
+							}
+						}
+					}
+				}
+
+				base_type = base_type.class_type->base_type;
+			} break;
+			case GDScriptParser::DataType::GDSCRIPT: {
+				Ref<GDScript> gds = base_type.script_type;
+				if (gds.is_valid()) {
+					if (gds->get_member_functions().has(p_method)) {
+						r_type = _type_from_gdtype(gds->get_member_functions()[p_method]->get_return_type());
+						return true;
+					}
+					Ref<GDScript> base_script = gds->get_base_script();
+					if (base_script.is_valid()) {
+						base_type.script_type = base_script;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = gds->get_instance_base_type();
+					}
+				} else {
+					return false;
+				}
+			} break;
+			case GDScriptParser::DataType::SCRIPT: {
+				Ref<Script> scr = base_type.script_type;
+				if (scr.is_valid()) {
+					List<MethodInfo> methods;
+					scr->get_script_method_list(&methods);
+					for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+						MethodInfo &mi = E->get();
+						if (mi.name == p_method) {
+							r_type = _type_from_property(mi.return_val);
+							return true;
+						}
+					}
+					Ref<Script> base_script = scr->get_base_script();
+					if (base_script.is_valid()) {
+						base_type.script_type = base_script;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = scr->get_instance_base_type();
+					}
+				} else {
+					return false;
+				}
+			} break;
+			case GDScriptParser::DataType::NATIVE: {
+				StringName native = base_type.native_type;
+				if (!ClassDB::class_exists(native)) {
+					native = String("_") + native;
+					if (!ClassDB::class_exists(native)) {
+						return false;
+					}
+				}
+				MethodBind *mb = ClassDB::get_method(native, p_method);
+				if (mb) {
+					r_type = _type_from_property(mb->get_return_info());
+					return true;
+				}
+				return false;
+			} break;
+			case GDScriptParser::DataType::BUILTIN: {
+				Variant::CallError err;
+				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+				if (err.error != Variant::CallError::CALL_OK) {
+					return false;
+				}
+
+				List<MethodInfo> methods;
+				tmp.get_method_list(&methods);
+
+				for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+					MethodInfo &mi = E->get();
+					if (mi.name == p_method) {
+						r_type = _type_from_property(mi.return_val);
+						return true;
+					}
+				}
+				return false;
+			} break;
+			default: {
+				return false;
+			}
+		}
+	}
+	return false;
+}
+
+static String _make_arguments_hint(const MethodInfo &p_info, int p_arg_idx) {
+	String arghint = _get_visual_datatype(p_info.return_val, false) + " " + p_info.name + "(";
+
+	int def_args = p_info.arguments.size() - p_info.default_arguments.size();
+	int i = 0;
+	for (const List<PropertyInfo>::Element *E = p_info.arguments.front(); E; E = E->next()) {
+		if (i > 0) {
+			arghint += ", ";
+		}
+
+		if (i == p_arg_idx) {
+			arghint += String::chr(0xFFFF);
+		}
+		arghint += E->get().name + ": " + _get_visual_datatype(E->get(), true);
+
+		if (i - def_args >= 0) {
+			arghint += String(" = ") + p_info.default_arguments[i - def_args].get_construct_string();
+		}
+
+		if (i == p_arg_idx) {
+			arghint += String::chr(0xFFFF);
+		}
+
+		i++;
+	}
+
+	if (p_info.flags & METHOD_FLAG_VARARG) {
+		if (p_info.arguments.size() > 0) {
+			arghint += ", ";
+		}
+		if (p_arg_idx >= p_info.arguments.size()) {
+			arghint += String::chr(0xFFFF);
+		}
+		arghint += "...";
+		if (p_arg_idx >= p_info.arguments.size()) {
+			arghint += String::chr(0xFFFF);
+		}
+	}
+
+	arghint += ")";
+
+	return arghint;
+}
+
+static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_function, int p_arg_idx) {
+	String arghint = p_function->return_type.to_string() + " " + p_function->name.operator String() + "(";
+
+	int def_args = p_function->arguments.size() - p_function->default_values.size();
+	for (int i = 0; i < p_function->arguments.size(); i++) {
+		if (i > 0) {
+			arghint += ", ";
+		}
+
+		if (i == p_arg_idx) {
+			arghint += String::chr(0xFFFF);
+		}
+		arghint += p_function->arguments[i].operator String() + ": " + p_function->argument_types[i].to_string();
+
+		if (i - def_args >= 0) {
+			String def_val = "<unknown>";
+			if (p_function->default_values[i - def_args] && p_function->default_values[i - def_args]->type == GDScriptParser::Node::TYPE_OPERATOR) {
+				const GDScriptParser::OperatorNode *assign = static_cast<const GDScriptParser::OperatorNode *>(p_function->default_values[i - def_args]);
+
+				if (assign->arguments.size() >= 2) {
+					if (assign->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT) {
+						const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(assign->arguments[1]);
+						def_val = cn->value.get_construct_string();
+					} else if (assign->arguments[1]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
+						const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(assign->arguments[1]);
+						def_val = id->name.operator String();
+					}
+				}
+			}
+			arghint += " = " + def_val;
+		}
+		if (i == p_arg_idx) {
+			arghint += String::chr(0xFFFF);
+		}
+	}
+
+	arghint += ")";
+
+	return arghint;
+}
+
+static void _find_enumeration_candidates(const String p_enum_hint, Map<String, ScriptCodeCompletionOption> &r_result) {
+	if (p_enum_hint.find(".") == -1) {
+		// Global constant
+		StringName current_enum = p_enum_hint;
+		for (int i = 0; i < GlobalConstants::get_global_constant_count(); i++) {
+			if (GlobalConstants::get_global_constant_enum(i) == current_enum) {
+				ScriptCodeCompletionOption option(GlobalConstants::get_global_constant_name(i), ScriptCodeCompletionOption::KIND_ENUM);
+				r_result.insert(option.display, option);
+			}
+		}
+	} else {
+		String class_name = p_enum_hint.get_slice(".", 0);
+		String enum_name = p_enum_hint.get_slice(".", 1);
+
+		if (!ClassDB::class_exists(class_name)) {
+			return;
+		}
+
+		List<StringName> enum_constants;
+		ClassDB::get_enum_constants(class_name, enum_name, &enum_constants);
+		for (List<StringName>::Element *E = enum_constants.front(); E; E = E->next()) {
+			String candidate = class_name + "." + E->get();
+			ScriptCodeCompletionOption option(candidate, ScriptCodeCompletionOption::KIND_ENUM);
+			r_result.insert(option.display, option);
+		}
+	}
+}
+
+static void _find_identifiers_in_block(const GDScriptCompletionContext &p_context, Map<String, ScriptCodeCompletionOption> &r_result) {
+	for (Map<StringName, GDScriptParser::LocalVarNode *>::Element *E = p_context.block->variables.front(); E; E = E->next()) {
+		if (E->get()->line < p_context.line) {
+			ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_VARIABLE);
+			r_result.insert(option.display, option);
+		}
+	}
+	if (p_context.block->parent_block) {
+		GDScriptCompletionContext c = p_context;
+		c.block = p_context.block->parent_block;
+		_find_identifiers_in_block(c, r_result);
+	}
+}
+
+static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result);
+
+static void _find_identifiers_in_class(const GDScriptCompletionContext &p_context, bool p_static, bool p_only_functions, bool p_parent_only, Map<String, ScriptCodeCompletionOption> &r_result) {
+	if (!p_parent_only) {
+		if (!p_static && !p_only_functions) {
+			for (int i = 0; i < p_context._class->variables.size(); i++) {
+				ScriptCodeCompletionOption option(p_context._class->variables[i].identifier, ScriptCodeCompletionOption::KIND_MEMBER);
+				r_result.insert(option.display, option);
+			}
+		}
+
+		if (!p_only_functions) {
+			for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_context._class->constant_expressions.front(); E; E = E->next()) {
+				ScriptCodeCompletionOption option(E->key(), ScriptCodeCompletionOption::KIND_CONSTANT);
+				if (E->get().expression && E->get().expression->type == GDScriptParser::Node::TYPE_CONSTANT) {
+					GDScriptParser::ConstantNode *cnode = (GDScriptParser::ConstantNode *)E->get().expression;
+					if (cnode) {
+						option.default_value = cnode->value;
+					}
+				}
+				r_result.insert(option.display, option);
+			}
+			for (int i = 0; i < p_context._class->subclasses.size(); i++) {
+				ScriptCodeCompletionOption option(p_context._class->subclasses[i]->name, ScriptCodeCompletionOption::KIND_CLASS);
+				r_result.insert(option.display, option);
+			}
+		}
+
+		for (int i = 0; i < p_context._class->static_functions.size(); i++) {
+			ScriptCodeCompletionOption option(p_context._class->static_functions[i]->name.operator String(), ScriptCodeCompletionOption::KIND_FUNCTION);
+			if (p_context._class->static_functions[i]->arguments.size()) {
+				option.insert_text += "(";
+			} else {
+				option.insert_text += "()";
+			}
+			r_result.insert(option.display, option);
+		}
+
+		if (!p_static) {
+			for (int i = 0; i < p_context._class->functions.size(); i++) {
+				ScriptCodeCompletionOption option(p_context._class->functions[i]->name.operator String(), ScriptCodeCompletionOption::KIND_FUNCTION);
+				if (p_context._class->functions[i]->arguments.size()) {
+					option.insert_text += "(";
+				} else {
+					option.insert_text += "()";
+				}
+				r_result.insert(option.display, option);
+			}
+		}
+	}
+
+	// Parents
+	GDScriptCompletionIdentifier base_type;
+	base_type.type = p_context._class->base_type;
+	base_type.type.is_meta_type = p_static;
+	base_type.value = p_context.base;
+
+	GDScriptCompletionContext c = p_context;
+	c.block = nullptr;
+	c.function = nullptr;
+
+	_find_identifiers_in_base(c, base_type, p_only_functions, r_result);
+}
+
+static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
+	GDScriptParser::DataType base_type = p_base.type;
+	bool _static = base_type.is_meta_type;
+
+	if (_static && base_type.kind != GDScriptParser::DataType::BUILTIN) {
+		ScriptCodeCompletionOption option("new", ScriptCodeCompletionOption::KIND_FUNCTION);
+		option.insert_text += "(";
+		r_result.insert(option.display, option);
+	}
+
+	while (base_type.has_type) {
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::CLASS: {
+				GDScriptCompletionContext c = p_context;
+				c._class = base_type.class_type;
+				c.block = nullptr;
+				c.function = nullptr;
+				_find_identifiers_in_class(c, _static, p_only_functions, false, r_result);
+				base_type = base_type.class_type->base_type;
+			} break;
+			case GDScriptParser::DataType::GDSCRIPT: {
+				Ref<GDScript> script = base_type.script_type;
+				if (script.is_valid()) {
+					if (!_static && !p_only_functions) {
+						if (p_context.base && p_context.base->get_script_instance()) {
+							List<PropertyInfo> members;
+							p_context.base->get_script_instance()->get_property_list(&members);
+							for (List<PropertyInfo>::Element *E = members.front(); E; E = E->next()) {
+								ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_MEMBER);
+								r_result.insert(option.display, option);
+							}
+						}
+						for (const Set<StringName>::Element *E = script->get_members().front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->get().operator String(), ScriptCodeCompletionOption::KIND_MEMBER);
+							r_result.insert(option.display, option);
+						}
+					}
+					if (!p_only_functions) {
+						for (const Map<StringName, Variant>::Element *E = script->get_constants().front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CONSTANT);
+							r_result.insert(option.display, option);
+						}
+					}
+					for (const Map<StringName, GDScriptFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) {
+						if (!_static || E->get()->is_static()) {
+							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_FUNCTION);
+							if (E->get()->get_argument_count()) {
+								option.insert_text += "(";
+							} else {
+								option.insert_text += "()";
+							}
+							r_result.insert(option.display, option);
+						}
+					}
+					if (!p_only_functions) {
+						for (const Map<StringName, Ref<GDScript>>::Element *E = script->get_subclasses().front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+							r_result.insert(option.display, option);
+						}
+					}
+					base_type = GDScriptParser::DataType();
+					if (script->get_base().is_valid()) {
+						base_type.has_type = true;
+						base_type.kind = GDScriptParser::DataType::GDSCRIPT;
+						base_type.script_type = script->get_base();
+					} else {
+						base_type.has_type = script->get_instance_base_type() != StringName();
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = script->get_instance_base_type();
+					}
+				} else {
+					return;
+				}
+			} break;
+			case GDScriptParser::DataType::SCRIPT: {
+				Ref<Script> scr = base_type.script_type;
+				if (scr.is_valid()) {
+					if (!_static && !p_only_functions) {
+						List<PropertyInfo> members;
+						scr->get_script_property_list(&members);
+						for (List<PropertyInfo>::Element *E = members.front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_MEMBER);
+							r_result.insert(option.display, option);
+						}
+					}
+					if (!p_only_functions) {
+						Map<StringName, Variant> constants;
+						scr->get_constants(&constants);
+						for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CONSTANT);
+							r_result.insert(option.display, option);
+						}
+					}
+
+					List<MethodInfo> methods;
+					scr->get_script_method_list(&methods);
+					for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+						ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_FUNCTION);
+						if (E->get().arguments.size()) {
+							option.insert_text += "(";
+						} else {
+							option.insert_text += "()";
+						}
+						r_result.insert(option.display, option);
+					}
+
+					Ref<Script> base_script = scr->get_base_script();
+					if (base_script.is_valid()) {
+						base_type.script_type = base_script;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = scr->get_instance_base_type();
+					}
+				} else {
+					return;
+				}
+			} break;
+			case GDScriptParser::DataType::NATIVE: {
+				StringName type = base_type.native_type;
+				if (!ClassDB::class_exists(type)) {
+					type = String("_") + type;
+					if (!ClassDB::class_exists(type)) {
+						return;
+					}
+				}
+
+				if (!p_only_functions) {
+					List<String> constants;
+					ClassDB::get_integer_constant_list(type, &constants);
+					for (List<String>::Element *E = constants.front(); E; E = E->next()) {
+						ScriptCodeCompletionOption option(E->get(), ScriptCodeCompletionOption::KIND_CONSTANT);
+						r_result.insert(option.display, option);
+					}
+
+					if (!_static) {
+						List<PropertyInfo> pinfo;
+						ClassDB::get_property_list(type, &pinfo);
+						for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+							if (E->get().usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)) {
+								continue;
+							}
+							if (E->get().name.find("/") != -1) {
+								continue;
+							}
+							ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_MEMBER);
+							r_result.insert(option.display, option);
+						}
+					}
+				}
+
+				if (!_static) {
+					List<MethodInfo> methods;
+					bool is_autocompleting_getters = GLOBAL_GET("debug/gdscript/completion/autocomplete_setters_and_getters").booleanize();
+					ClassDB::get_method_list(type, &methods, false, !is_autocompleting_getters);
+					for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+						if (E->get().name.begins_with("_")) {
+							continue;
+						}
+						ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_FUNCTION);
+						if (E->get().arguments.size()) {
+							option.insert_text += "(";
+						} else {
+							option.insert_text += "()";
+						}
+						r_result.insert(option.display, option);
+					}
+				}
+
+				return;
+			} break;
+			case GDScriptParser::DataType::BUILTIN: {
+				Variant::CallError err;
+				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+				if (err.error != Variant::CallError::CALL_OK) {
+					return;
+				}
+
+				if (!p_only_functions) {
+					List<PropertyInfo> members;
+					if (p_base.value.get_type() != Variant::NIL) {
+						p_base.value.get_property_list(&members);
+					} else {
+						tmp.get_property_list(&members);
+					}
+
+					for (List<PropertyInfo>::Element *E = members.front(); E; E = E->next()) {
+						if (String(E->get().name).find("/") == -1) {
+							ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_MEMBER);
+							r_result.insert(option.display, option);
+						}
+					}
+				}
+
+				List<MethodInfo> methods;
+				tmp.get_method_list(&methods);
+				for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+					ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_FUNCTION);
+					if (E->get().arguments.size()) {
+						option.insert_text += "(";
+					} else {
+						option.insert_text += "()";
+					}
+					r_result.insert(option.display, option);
+				}
+
+				return;
+			} break;
+			default: {
+				return;
+			} break;
+		}
+	}
+}
+
+static void _find_identifiers(const GDScriptCompletionContext &p_context, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
+	const GDScriptParser::BlockNode *block = p_context.block;
+
+	if (p_context.function) {
+		const GDScriptParser::FunctionNode *f = p_context.function;
+
+		for (int i = 0; i < f->arguments.size(); i++) {
+			ScriptCodeCompletionOption option(f->arguments[i].operator String(), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			r_result.insert(option.display, option);
+		}
+	}
+
+	if (!p_only_functions && block) {
+		GDScriptCompletionContext c = p_context;
+		c.block = block;
+		_find_identifiers_in_block(c, r_result);
+	}
+
+	const GDScriptParser::ClassNode *clss = p_context._class;
+	bool _static = p_context.function && p_context.function->_static;
+
+	while (clss) {
+		GDScriptCompletionContext c = p_context;
+		c._class = clss;
+		c.block = nullptr;
+		c.function = nullptr;
+		_find_identifiers_in_class(c, _static, p_only_functions, false, r_result);
+		_static = true;
+		clss = clss->owner;
+	}
+
+	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+		MethodInfo mi = GDScriptFunctions::get_info(GDScriptFunctions::Function(i));
+		ScriptCodeCompletionOption option(String(GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i))), ScriptCodeCompletionOption::KIND_FUNCTION);
+		if (mi.arguments.size() || (mi.flags & METHOD_FLAG_VARARG)) {
+			option.insert_text += "(";
+		} else {
+			option.insert_text += "()";
+		}
+		r_result.insert(option.display, option);
+	}
+
+	static const char *_type_names[Variant::VARIANT_MAX] = {
+		"null", "bool", "int", "float", "String", "Vector2", "Vector2i", "Rect2", "Rect2i", "Vector3", "Vector3i", "Transform2D", "Plane",
+		"Quat", "AABB", "Basis", "Transform", "Color", "NodePath", "RID", "Object", "Dictionary", "Array",
+		"PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray",
+		"PoolVector2Array", "PoolVector2iArray", "PoolVector3Array", "PoolVector3iArray", "PoolColorArray"
+	};
+
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		ScriptCodeCompletionOption option(_type_names[i], ScriptCodeCompletionOption::KIND_CLASS);
+		r_result.insert(option.display, option);
+	}
+
+	static const char *_keywords[] = {
+		"and", "in", "not", "or", "false", "PI", "TAU", "INF", "NAN", "self", "true", "as", "assert",
+		"breakpoint", "class", "extends", "is", "func", "preload", "setget", "signal", "tool", "yield",
+		"const", "enum", "export", "onready", "static", "var", "break", "continue", "if", "elif",
+		"else", "for", "pass", "return", "match", "while", "remote", "sync", "master", "puppet", "slave",
+		"remotesync", "mastersync", "puppetsync",
+		nullptr
+	};
+
+	const char **kw = _keywords;
+	while (*kw) {
+		ScriptCodeCompletionOption option(*kw, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+		r_result.insert(option.display, option);
+		kw++;
+	}
+
+	// Autoload singletons
+	List<PropertyInfo> props;
+	ProjectSettings::get_singleton()->get_property_list(&props);
+	for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+		String s = E->get().name;
+		if (!s.begins_with("autoload/")) {
+			continue;
+		}
+		String path = ProjectSettings::get_singleton()->get(s);
+		if (path.begins_with("*")) {
+			ScriptCodeCompletionOption option(s.get_slice("/", 1), ScriptCodeCompletionOption::KIND_CONSTANT);
+			r_result.insert(option.display, option);
+		}
+	}
+
+	// Named scripts
+	List<StringName> named_scripts;
+	ScriptServer::get_global_class_list(&named_scripts);
+	for (List<StringName>::Element *E = named_scripts.front(); E; E = E->next()) {
+		ScriptCodeCompletionOption option(E->get().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+		r_result.insert(option.display, option);
+	}
+
+	// Native classes
+	for (const Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
+		ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+		r_result.insert(option.display, option);
+	}
+}
+
+static void _find_call_arguments(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptCodeCompletionOption> &r_result, String &r_arghint) {
+	Variant base = p_base.value;
+	GDScriptParser::DataType base_type = p_base.type;
+
+	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
+
+#define IS_METHOD_SIGNAL(m_method) (m_method == "connect" || m_method == "disconnect" || m_method == "is_connected" || m_method == "emit_signal")
+
+	while (base_type.has_type) {
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::CLASS: {
+				for (int i = 0; i < base_type.class_type->static_functions.size(); i++) {
+					if (base_type.class_type->static_functions[i]->name == p_method) {
+						r_arghint = _make_arguments_hint(base_type.class_type->static_functions[i], p_argidx);
+						return;
+					}
+				}
+				for (int i = 0; i < base_type.class_type->functions.size(); i++) {
+					if (base_type.class_type->functions[i]->name == p_method) {
+						r_arghint = _make_arguments_hint(base_type.class_type->functions[i], p_argidx);
+						return;
+					}
+				}
+
+				if (IS_METHOD_SIGNAL(p_method) && p_argidx == 0) {
+					for (int i = 0; i < base_type.class_type->_signals.size(); i++) {
+						ScriptCodeCompletionOption option(base_type.class_type->_signals[i].name.operator String(), ScriptCodeCompletionOption::KIND_SIGNAL);
+						option.insert_text = quote_style + option.display + quote_style;
+						r_result.insert(option.display, option);
+					}
+				}
+
+				base_type = base_type.class_type->base_type;
+			} break;
+			case GDScriptParser::DataType::GDSCRIPT: {
+				Ref<GDScript> gds = base_type.script_type;
+				if (gds.is_valid()) {
+					if (IS_METHOD_SIGNAL(p_method) && p_argidx == 0) {
+						List<MethodInfo> signals;
+						gds->get_script_signal_list(&signals);
+						for (List<MethodInfo>::Element *E = signals.front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_SIGNAL);
+							option.insert_text = quote_style + option.display + quote_style;
+							r_result.insert(option.display, option);
+						}
+					}
+					Ref<GDScript> base_script = gds->get_base_script();
+					if (base_script.is_valid()) {
+						base_type.script_type = base_script;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = gds->get_instance_base_type();
+					}
+				} else {
+					return;
+				}
+			} break;
+			case GDScriptParser::DataType::NATIVE: {
+				StringName class_name = base_type.native_type;
+				if (!ClassDB::class_exists(class_name)) {
+					class_name = String("_") + class_name;
+					if (!ClassDB::class_exists(class_name)) {
+						base_type.has_type = false;
+						break;
+					}
+				}
+
+				List<MethodInfo> methods;
+				ClassDB::get_method_list(class_name, &methods);
+				ClassDB::get_virtual_methods(class_name, &methods);
+				int method_args = 0;
+
+				for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+					if (E->get().name == p_method) {
+						method_args = E->get().arguments.size();
+						if (base.get_type() == Variant::OBJECT) {
+							Object *obj = base.operator Object *();
+							if (obj) {
+								List<String> options;
+								obj->get_argument_options(p_method, p_argidx, &options);
+								for (List<String>::Element *F = options.front(); F; F = F->next()) {
+									ScriptCodeCompletionOption option(F->get(), ScriptCodeCompletionOption::KIND_FUNCTION);
+									r_result.insert(option.display, option);
+								}
+							}
+						}
+
+						if (p_argidx < method_args) {
+							PropertyInfo arg_info = E->get().arguments[p_argidx];
+							if (arg_info.usage & PROPERTY_USAGE_CLASS_IS_ENUM) {
+								_find_enumeration_candidates(arg_info.class_name, r_result);
+							}
+						}
+
+						r_arghint = _make_arguments_hint(E->get(), p_argidx);
+						break;
+					}
+				}
+
+				if (IS_METHOD_SIGNAL(p_method) && p_argidx == 0) {
+					List<MethodInfo> signals;
+					ClassDB::get_signal_list(class_name, &signals);
+					for (List<MethodInfo>::Element *E = signals.front(); E; E = E->next()) {
+						ScriptCodeCompletionOption option(E->get().name, ScriptCodeCompletionOption::KIND_SIGNAL);
+						option.insert_text = quote_style + option.display + quote_style;
+						r_result.insert(option.display, option);
+					}
+				}
+#undef IS_METHOD_SIGNAL
+
+				if (ClassDB::is_parent_class(class_name, "Node") && (p_method == "get_node" || p_method == "has_node") && p_argidx == 0) {
+					// Get autoloads
+					List<PropertyInfo> props;
+					ProjectSettings::get_singleton()->get_property_list(&props);
+
+					for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+						String s = E->get().name;
+						if (!s.begins_with("autoload/")) {
+							continue;
+						}
+						String name = s.get_slice("/", 1);
+						ScriptCodeCompletionOption option("/root/" + name, ScriptCodeCompletionOption::KIND_NODE_PATH);
+						option.insert_text = quote_style + option.display + quote_style;
+						r_result.insert(option.display, option);
+					}
+				}
+
+				if (p_argidx == 0 && method_args > 0 && ClassDB::is_parent_class(class_name, "InputEvent") && p_method.operator String().find("action") != -1) {
+					// Get input actions
+					List<PropertyInfo> props;
+					ProjectSettings::get_singleton()->get_property_list(&props);
+					for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+						String s = E->get().name;
+						if (!s.begins_with("input/")) {
+							continue;
+						}
+						String name = s.get_slice("/", 1);
+						ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_CONSTANT);
+						option.insert_text = quote_style + option.display + quote_style;
+						r_result.insert(option.display, option);
+					}
+				}
+
+				base_type.has_type = false;
+			} break;
+			case GDScriptParser::DataType::BUILTIN: {
+				if (base.get_type() == Variant::NIL) {
+					Variant::CallError err;
+					base = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+					if (err.error != Variant::CallError::CALL_OK) {
+						return;
+					}
+				}
+
+				List<MethodInfo> methods;
+				base.get_method_list(&methods);
+				for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
+					if (E->get().name == p_method) {
+						r_arghint = _make_arguments_hint(E->get(), p_argidx);
+						return;
+					}
+				}
+
+				base_type.has_type = false;
+			} break;
+			default: {
+				base_type.has_type = false;
+			} break;
+		}
+	}
+}
+
+static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDScriptParser::Node *p_node, int p_argidx, Map<String, ScriptCodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
+	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
+
+	if (!p_node || p_node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+		return;
+	}
+
+	Variant base;
+	GDScriptParser::DataType base_type;
+	StringName function;
+	bool _static = false;
+	const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_node);
+
+	GDScriptCompletionIdentifier connect_base;
+
+	if (op->op != GDScriptParser::OperatorNode::OP_CALL && op->op != GDScriptParser::OperatorNode::OP_PARENT_CALL) {
+		return;
+	}
+
+	if (!op->arguments.size()) {
+		return;
+	}
+
+	if (op->op == GDScriptParser::OperatorNode::OP_CALL) {
+		if (op->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+			// Complete built-in function
+			const GDScriptParser::BuiltInFunctionNode *fn = static_cast<const GDScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
+			MethodInfo mi = GDScriptFunctions::get_info(fn->function);
+
+			if ((mi.name == "load" || mi.name == "preload") && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) {
+				_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result);
+			}
+
+			r_arghint = _make_arguments_hint(mi, p_argidx);
+			return;
+
+		} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
+			// Complete constructor
+			const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(op->arguments[0]);
+
+			List<MethodInfo> constructors;
+			Variant::get_constructor_list(tn->vtype, &constructors);
+
+			int i = 0;
+			for (List<MethodInfo>::Element *E = constructors.front(); E; E = E->next()) {
+				if (p_argidx >= E->get().arguments.size()) {
+					continue;
+				}
+				if (i > 0) {
+					r_arghint += "\n";
+				}
+				r_arghint += _make_arguments_hint(E->get(), p_argidx);
+				i++;
+			}
+			return;
+		} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_SELF) {
+			if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+				return;
+			}
+
+			base = p_context.base;
+
+			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+			function = id->name;
+			base_type.has_type = true;
+			base_type.kind = GDScriptParser::DataType::CLASS;
+			base_type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+			_static = p_context.function && p_context.function->_static;
+
+			if (function == "connect" && op->arguments.size() >= 4) {
+				_guess_expression_type(p_context, op->arguments[3], connect_base);
+			}
+
+		} else {
+			if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+				return;
+			}
+			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+			function = id->name;
+
+			GDScriptCompletionIdentifier ci;
+			if (_guess_expression_type(p_context, op->arguments[0], ci)) {
+				base_type = ci.type;
+				base = ci.value;
+			} else {
+				return;
+			}
+			_static = ci.type.is_meta_type;
+
+			if (function == "connect" && op->arguments.size() >= 4) {
+				_guess_expression_type(p_context, op->arguments[3], connect_base);
+			}
+		}
+	} else {
+		if (!p_context._class || op->arguments.size() < 1 || op->arguments[0]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+			return;
+		}
+		base_type.has_type = true;
+		base_type.kind = GDScriptParser::DataType::CLASS;
+		base_type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+		base_type.is_meta_type = p_context.function && p_context.function->_static;
+		base = p_context.base;
+
+		function = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name;
+
+		if (function == "connect" && op->arguments.size() >= 4) {
+			_guess_expression_type(p_context, op->arguments[3], connect_base);
+		}
+	}
+
+	GDScriptCompletionIdentifier ci;
+	ci.type = base_type;
+	ci.value = base;
+	_find_call_arguments(p_context, ci, function, p_argidx, _static, r_result, r_arghint);
+
+	if (function == "connect" && p_argidx == 2) {
+		Map<String, ScriptCodeCompletionOption> methods;
+		_find_identifiers_in_base(p_context, connect_base, true, methods);
+		for (Map<String, ScriptCodeCompletionOption>::Element *E = methods.front(); E; E = E->next()) {
+			ScriptCodeCompletionOption &option = E->value();
+			option.insert_text = quote_style + option.display + quote_style;
+			r_result.insert(option.display, option);
+		}
+	}
+
+	r_forced = r_result.size() > 0;
+}
+
+Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
+	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
+
+	GDScriptParser parser;
+
+	parser.parse(p_code, p_path.get_base_dir(), false, p_path, true);
+	r_forced = false;
+	Map<String, ScriptCodeCompletionOption> options;
+	GDScriptCompletionContext context;
+	context._class = parser.get_completion_class();
+	context.block = parser.get_completion_block();
+	context.function = parser.get_completion_function();
+	context.line = parser.get_completion_line();
+
+	if (!context._class || context._class->owner == nullptr) {
+		context.base = p_owner;
+		context.base_path = p_path.get_base_dir();
+	}
+
+	bool is_function = false;
+
+	switch (parser.get_completion_type()) {
+		case GDScriptParser::COMPLETION_NONE: {
+		} break;
+		case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
+			List<StringName> constants;
+			Variant::get_constants_for_type(parser.get_completion_built_in_constant(), &constants);
+			for (List<StringName>::Element *E = constants.front(); E; E = E->next()) {
+				ScriptCodeCompletionOption option(E->get().operator String(), ScriptCodeCompletionOption::KIND_CONSTANT);
+				bool valid = false;
+				Variant default_value = Variant::get_constant_value(parser.get_completion_built_in_constant(), E->get(), &valid);
+				if (valid) {
+					option.default_value = default_value;
+				}
+				options.insert(option.display, option);
+			}
+		} break;
+		case GDScriptParser::COMPLETION_PARENT_FUNCTION: {
+			_find_identifiers_in_class(context, !context.function || context.function->_static, true, true, options);
+		} break;
+		case GDScriptParser::COMPLETION_FUNCTION: {
+			is_function = true;
+			FALLTHROUGH;
+		}
+		case GDScriptParser::COMPLETION_IDENTIFIER: {
+			_find_identifiers(context, is_function, options);
+		} break;
+		case GDScriptParser::COMPLETION_EXTENDS: {
+			// Native classes.
+			List<StringName> class_list;
+			ClassDB::get_class_list(&class_list);
+			for (int i = 0; i < class_list.size(); i++) {
+				ScriptCodeCompletionOption option(class_list[i], ScriptCodeCompletionOption::KIND_CLASS);
+				options.insert(option.display, option);
+			}
+
+			// GDScript classes.
+			if (EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths")) {
+				for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+					if (ScriptServer::get_language(i)->get_name() == "GDScript") {
+						List<String> extensions;
+						ScriptServer::get_language(i)->get_recognized_extensions(&extensions);
+						for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
+							_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), options, String("." + E->get()));
+						}
+					}
+				}
+				r_forced = true;
+			}
+
+			// Named Scripts.
+			List<StringName> named_scripts;
+			ScriptServer::get_global_class_list(&named_scripts);
+			for (List<StringName>::Element *E = named_scripts.front(); E; E = E->next()) {
+				ScriptCodeCompletionOption option(E->get().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+				options.insert(option.display, option);
+			}
+		} break;
+		case GDScriptParser::COMPLETION_GET_NODE: {
+			if (p_owner) {
+				List<String> opts;
+				p_owner->get_argument_options("get_node", 0, &opts);
+
+				for (List<String>::Element *E = opts.front(); E; E = E->next()) {
+					String opt = E->get().strip_edges();
+					if (opt.is_quoted()) {
+						r_forced = true;
+						String idopt = opt.unquote();
+						if (idopt.replace("/", "_").is_valid_identifier()) {
+							ScriptCodeCompletionOption option(idopt, ScriptCodeCompletionOption::KIND_NODE_PATH);
+							options.insert(option.display, option);
+						} else {
+							ScriptCodeCompletionOption option(opt, ScriptCodeCompletionOption::KIND_NODE_PATH);
+							options.insert(option.display, option);
+						}
+					}
+				}
+
+				// Get autoloads
+				List<PropertyInfo> props;
+				ProjectSettings::get_singleton()->get_property_list(&props);
+
+				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+					String s = E->get().name;
+					if (!s.begins_with("autoload/")) {
+						continue;
+					}
+					String name = s.get_slice("/", 1);
+					ScriptCodeCompletionOption option(quote_style + "/root/" + name + quote_style, ScriptCodeCompletionOption::KIND_NODE_PATH);
+					options.insert(option.display, option);
+				}
+			}
+		} break;
+		case GDScriptParser::COMPLETION_METHOD: {
+			is_function = true;
+			FALLTHROUGH;
+		}
+		case GDScriptParser::COMPLETION_INDEX: {
+			const GDScriptParser::Node *node = parser.get_completion_node();
+			if (node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+				break;
+			}
+			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(node);
+			if (op->arguments.size() < 1) {
+				break;
+			}
+
+			GDScriptCompletionIdentifier base;
+			if (!_guess_expression_type(context, op->arguments[0], base)) {
+				break;
+			}
+
+			GDScriptCompletionContext c = context;
+			c.function = nullptr;
+			c.block = nullptr;
+			c.base = base.value.get_type() == Variant::OBJECT ? base.value.operator Object *() : nullptr;
+			if (base.type.kind == GDScriptParser::DataType::CLASS) {
+				c._class = base.type.class_type;
+			} else {
+				c._class = nullptr;
+			}
+
+			_find_identifiers_in_base(c, base, is_function, options);
+		} break;
+		case GDScriptParser::COMPLETION_CALL_ARGUMENTS: {
+			_find_call_arguments(context, parser.get_completion_node(), parser.get_completion_argument_index(), options, r_forced, r_call_hint);
+		} break;
+		case GDScriptParser::COMPLETION_VIRTUAL_FUNC: {
+			GDScriptParser::DataType native_type = context._class->base_type;
+			while (native_type.has_type && native_type.kind != GDScriptParser::DataType::NATIVE) {
+				switch (native_type.kind) {
+					case GDScriptParser::DataType::CLASS: {
+						native_type = native_type.class_type->base_type;
+					} break;
+					case GDScriptParser::DataType::GDSCRIPT: {
+						Ref<GDScript> gds = native_type.script_type;
+						if (gds.is_valid()) {
+							Ref<GDScript> base = gds->get_base_script();
+							if (base.is_valid()) {
+								native_type.script_type = base;
+							} else {
+								native_type.native_type = gds->get_instance_base_type();
+								native_type.kind = GDScriptParser::DataType::NATIVE;
+							}
+						} else {
+							native_type.has_type = false;
+						}
+					} break;
+					default: {
+						native_type.has_type = false;
+					} break;
+				}
+			}
+
+			if (!native_type.has_type) {
+				break;
+			}
+
+			StringName class_name = native_type.native_type;
+			if (!ClassDB::class_exists(class_name)) {
+				class_name = String("_") + class_name;
+				if (!ClassDB::class_exists(class_name)) {
+					break;
+				}
+			}
+
+			bool use_type_hint = EditorSettings::get_singleton()->get_setting("text_editor/completion/add_type_hints").operator bool();
+
+			List<MethodInfo> virtual_methods;
+			ClassDB::get_virtual_methods(class_name, &virtual_methods);
+			for (List<MethodInfo>::Element *E = virtual_methods.front(); E; E = E->next()) {
+				MethodInfo &mi = E->get();
+				String method_hint = mi.name;
+				if (method_hint.find(":") != -1) {
+					method_hint = method_hint.get_slice(":", 0);
+				}
+				method_hint += "(";
+
+				if (mi.arguments.size()) {
+					for (int i = 0; i < mi.arguments.size(); i++) {
+						if (i > 0) {
+							method_hint += ", ";
+						}
+						String arg = mi.arguments[i].name;
+						if (arg.find(":") != -1) {
+							arg = arg.substr(0, arg.find(":"));
+						}
+						method_hint += arg;
+						if (use_type_hint && mi.arguments[i].type != Variant::NIL) {
+							method_hint += ": ";
+							if (mi.arguments[i].type == Variant::OBJECT && mi.arguments[i].class_name != StringName()) {
+								method_hint += mi.arguments[i].class_name.operator String();
+							} else {
+								method_hint += Variant::get_type_name(mi.arguments[i].type);
+							}
+						}
+					}
+				}
+				method_hint += ")";
+				if (use_type_hint && (mi.return_val.type != Variant::NIL || !(mi.return_val.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
+					method_hint += " -> ";
+					if (mi.return_val.type == Variant::NIL) {
+						method_hint += "void";
+					} else if (mi.return_val.type == Variant::OBJECT && mi.return_val.class_name != StringName()) {
+						method_hint += mi.return_val.class_name.operator String();
+					} else {
+						method_hint += Variant::get_type_name(mi.return_val.type);
+					}
+				}
+				method_hint += ":";
+
+				ScriptCodeCompletionOption option(method_hint, ScriptCodeCompletionOption::KIND_FUNCTION);
+				options.insert(option.display, option);
+			}
+		} break;
+		case GDScriptParser::COMPLETION_YIELD: {
+			const GDScriptParser::Node *node = parser.get_completion_node();
+
+			GDScriptCompletionContext c = context;
+			c.line = node->line;
+			GDScriptCompletionIdentifier type;
+			if (!_guess_expression_type(c, node, type)) {
+				break;
+			}
+
+			GDScriptParser::DataType base_type = type.type;
+			while (base_type.has_type) {
+				switch (base_type.kind) {
+					case GDScriptParser::DataType::CLASS: {
+						for (int i = 0; i < base_type.class_type->_signals.size(); i++) {
+							ScriptCodeCompletionOption option(base_type.class_type->_signals[i].name.operator String(), ScriptCodeCompletionOption::KIND_SIGNAL);
+							option.insert_text = quote_style + option.display + quote_style;
+							options.insert(option.display, option);
+						}
+						base_type = base_type.class_type->base_type;
+					} break;
+					case GDScriptParser::DataType::SCRIPT:
+					case GDScriptParser::DataType::GDSCRIPT: {
+						Ref<Script> scr = base_type.script_type;
+						if (scr.is_valid()) {
+							List<MethodInfo> signals;
+							scr->get_script_signal_list(&signals);
+							for (List<MethodInfo>::Element *E = signals.front(); E; E = E->next()) {
+								ScriptCodeCompletionOption option(quote_style + E->get().name + quote_style, ScriptCodeCompletionOption::KIND_SIGNAL);
+								options.insert(option.display, option);
+							}
+							Ref<Script> base_script = scr->get_base_script();
+							if (base_script.is_valid()) {
+								base_type.script_type = base_script;
+							} else {
+								base_type.kind = GDScriptParser::DataType::NATIVE;
+								base_type.native_type = scr->get_instance_base_type();
+							}
+						} else {
+							base_type.has_type = false;
+						}
+					} break;
+					case GDScriptParser::DataType::NATIVE: {
+						base_type.has_type = false;
+
+						StringName class_name = base_type.native_type;
+						if (!ClassDB::class_exists(class_name)) {
+							class_name = String("_") + class_name;
+							if (!ClassDB::class_exists(class_name)) {
+								break;
+							}
+						}
+
+						List<MethodInfo> signals;
+						ClassDB::get_signal_list(class_name, &signals);
+						for (List<MethodInfo>::Element *E = signals.front(); E; E = E->next()) {
+							ScriptCodeCompletionOption option(quote_style + E->get().name + quote_style, ScriptCodeCompletionOption::KIND_SIGNAL);
+							options.insert(option.display, option);
+						}
+					} break;
+					default: {
+						base_type.has_type = false;
+					}
+				}
+			}
+		} break;
+		case GDScriptParser::COMPLETION_RESOURCE_PATH: {
+			if (EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths")) {
+				_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), options);
+				r_forced = true;
+			}
+		} break;
+		case GDScriptParser::COMPLETION_ASSIGN: {
+			GDScriptCompletionIdentifier type;
+			if (!_guess_expression_type(context, parser.get_completion_node(), type)) {
+				break;
+			}
+
+			if (!type.enumeration.empty()) {
+				_find_enumeration_candidates(type.enumeration, options);
+				r_forced = options.size() > 0;
+			}
+		} break;
+		case GDScriptParser::COMPLETION_TYPE_HINT: {
+			const GDScriptParser::ClassNode *clss = context._class;
+			while (clss) {
+				for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = clss->constant_expressions.front(); E; E = E->next()) {
+					GDScriptCompletionIdentifier constant;
+					GDScriptCompletionContext c = context;
+					c.function = nullptr;
+					c.block = nullptr;
+					c.line = E->value().expression->line;
+					if (_guess_expression_type(c, E->value().expression, constant)) {
+						if (constant.type.has_type && constant.type.is_meta_type) {
+							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+							options.insert(option.display, option);
+						}
+					}
+				}
+				for (int i = 0; i < clss->subclasses.size(); i++) {
+					if (clss->subclasses[i]->name != StringName()) {
+						ScriptCodeCompletionOption option(clss->subclasses[i]->name.operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+						options.insert(option.display, option);
+					}
+				}
+				clss = clss->owner;
+				for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+					ScriptCodeCompletionOption option(Variant::get_type_name((Variant::Type)i), ScriptCodeCompletionOption::KIND_CLASS);
+					options.insert(option.display, option);
+				}
+				List<PropertyInfo> props;
+				ProjectSettings::get_singleton()->get_property_list(&props);
+				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+					String s = E->get().name;
+					if (!s.begins_with("autoload/")) {
+						continue;
+					}
+					ScriptCodeCompletionOption option(s.get_slice("/", 1), ScriptCodeCompletionOption::KIND_CLASS);
+					options.insert(option.display, option);
+				}
+			}
+
+			List<StringName> native_classes;
+			ClassDB::get_class_list(&native_classes);
+			for (List<StringName>::Element *E = native_classes.front(); E; E = E->next()) {
+				String class_name = E->get().operator String();
+				if (class_name.begins_with("_")) {
+					class_name = class_name.right(1);
+				}
+				if (Engine::get_singleton()->has_singleton(class_name)) {
+					continue;
+				}
+				ScriptCodeCompletionOption option(class_name, ScriptCodeCompletionOption::KIND_CLASS);
+				options.insert(option.display, option);
+			}
+
+			// Named scripts
+			List<StringName> named_scripts;
+			ScriptServer::get_global_class_list(&named_scripts);
+			for (List<StringName>::Element *E = named_scripts.front(); E; E = E->next()) {
+				ScriptCodeCompletionOption option(E->get().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+				options.insert(option.display, option);
+			}
+
+			if (parser.get_completion_identifier_is_function()) {
+				ScriptCodeCompletionOption option("void", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				options.insert(option.display, option);
+			}
+			r_forced = true;
+		} break;
+		case GDScriptParser::COMPLETION_TYPE_HINT_INDEX: {
+			GDScriptCompletionIdentifier base;
+			String index = parser.get_completion_cursor().operator String();
+			if (!_guess_identifier_type(context, index.get_slice(".", 0), base)) {
+				break;
+			}
+
+			GDScriptCompletionContext c = context;
+			c._class = nullptr;
+			c.function = nullptr;
+			c.block = nullptr;
+			bool finding = true;
+			index = index.right(index.find(".") + 1);
+			while (index.find(".") != -1) {
+				String id = index.get_slice(".", 0);
+
+				GDScriptCompletionIdentifier sub_base;
+				if (!_guess_identifier_type_from_base(c, base, id, sub_base)) {
+					finding = false;
+					break;
+				}
+				index = index.right(index.find(".") + 1);
+				base = sub_base;
+			}
+
+			if (!finding) {
+				break;
+			}
+
+			GDScriptParser::DataType base_type = base.type;
+			while (base_type.has_type) {
+				switch (base_type.kind) {
+					case GDScriptParser::DataType::CLASS: {
+						if (base_type.class_type) {
+							for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = base_type.class_type->constant_expressions.front(); E; E = E->next()) {
+								GDScriptCompletionIdentifier constant;
+								GDScriptCompletionContext c2 = context;
+								c2._class = base_type.class_type;
+								c2.function = nullptr;
+								c2.block = nullptr;
+								c2.line = E->value().expression->line;
+								if (_guess_expression_type(c2, E->value().expression, constant)) {
+									if (constant.type.has_type && constant.type.is_meta_type) {
+										ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+										options.insert(option.display, option);
+									}
+								}
+							}
+							for (int i = 0; i < base_type.class_type->subclasses.size(); i++) {
+								if (base_type.class_type->subclasses[i]->name != StringName()) {
+									ScriptCodeCompletionOption option(base_type.class_type->subclasses[i]->name.operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+									options.insert(option.display, option);
+								}
+							}
+
+							base_type = base_type.class_type->base_type;
+						} else {
+							base_type.has_type = false;
+						}
+					} break;
+					case GDScriptParser::DataType::SCRIPT:
+					case GDScriptParser::DataType::GDSCRIPT: {
+						Ref<Script> scr = base_type.script_type;
+						if (scr.is_valid()) {
+							Map<StringName, Variant> constants;
+							scr->get_constants(&constants);
+							for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {
+								Ref<Script> const_scr = E->value();
+								if (const_scr.is_valid()) {
+									ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+									options.insert(option.display, option);
+								}
+							}
+							Ref<Script> base_script = scr->get_base_script();
+							if (base_script.is_valid()) {
+								base_type.script_type = base_script;
+							} else {
+								base_type.has_type = false;
+							}
+						} else {
+							base_type.has_type = false;
+						}
+					} break;
+					default: {
+						base_type.has_type = false;
+					} break;
+				}
+			}
+			r_forced = options.size() > 0;
+		} break;
+	}
+
+	for (Map<String, ScriptCodeCompletionOption>::Element *E = options.front(); E; E = E->next()) {
+		r_options->push_back(E->get());
+	}
+
+	return OK;
+}
+
+#else
+
+Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
+	return OK;
+}
+
+#endif
+
+//////// END COMPLETION //////////
+
+String GDScriptLanguage::_get_indentation() const {
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		bool use_space_indentation = EDITOR_DEF("text_editor/indent/type", false);
+
+		if (use_space_indentation) {
+			int indent_size = EDITOR_DEF("text_editor/indent/size", 4);
+
+			String space_indent = "";
+			for (int i = 0; i < indent_size; i++) {
+				space_indent += " ";
+			}
+			return space_indent;
+		}
+	}
+#endif
+	return "\t";
+}
+
+void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
+	String indent = _get_indentation();
+
+	Vector<String> lines = p_code.split("\n");
+	List<int> indent_stack;
+
+	for (int i = 0; i < lines.size(); i++) {
+		String l = lines[i];
+		int tc = 0;
+		for (int j = 0; j < l.length(); j++) {
+			if (l[j] == ' ' || l[j] == '\t') {
+				tc++;
+			} else {
+				break;
+			}
+		}
+
+		String st = l.substr(tc, l.length()).strip_edges();
+		if (st == "" || st.begins_with("#")) {
+			continue; //ignore!
+		}
+
+		int ilevel = 0;
+		if (indent_stack.size()) {
+			ilevel = indent_stack.back()->get();
+		}
+
+		if (tc > ilevel) {
+			indent_stack.push_back(tc);
+		} else if (tc < ilevel) {
+			while (indent_stack.size() && indent_stack.back()->get() > tc) {
+				indent_stack.pop_back();
+			}
+
+			if (indent_stack.size() && indent_stack.back()->get() != tc) {
+				indent_stack.push_back(tc); //this is not right but gets the job done
+			}
+		}
+
+		if (i >= p_from_line) {
+			l = "";
+			for (int j = 0; j < indent_stack.size(); j++) {
+				l += indent;
+			}
+			l += st;
+
+		} else if (i > p_to_line) {
+			break;
+		}
+
+		lines.write[i] = l;
+	}
+
+	p_code = "";
+	for (int i = 0; i < lines.size(); i++) {
+		if (i > 0) {
+			p_code += "\n";
+		}
+		p_code += lines[i];
+	}
+}
+
+#ifdef TOOLS_ENABLED
+
+static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, const String &p_symbol, bool p_is_function, GDScriptLanguage::LookupResult &r_result) {
+	GDScriptParser::DataType base_type = p_base;
+
+	while (base_type.has_type) {
+		switch (base_type.kind) {
+			case GDScriptParser::DataType::CLASS: {
+				if (base_type.class_type) {
+					if (p_is_function) {
+						for (int i = 0; i < base_type.class_type->functions.size(); i++) {
+							if (base_type.class_type->functions[i]->name == p_symbol) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = base_type.class_type->functions[i]->line;
+								return OK;
+							}
+						}
+						for (int i = 0; i < base_type.class_type->static_functions.size(); i++) {
+							if (base_type.class_type->static_functions[i]->name == p_symbol) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = base_type.class_type->static_functions[i]->line;
+								return OK;
+							}
+						}
+					} else {
+						if (base_type.class_type->constant_expressions.has(p_symbol)) {
+							r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+							r_result.location = base_type.class_type->constant_expressions[p_symbol].expression->line;
+							return OK;
+						}
+
+						for (int i = 0; i < base_type.class_type->variables.size(); i++) {
+							if (base_type.class_type->variables[i].identifier == p_symbol) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = base_type.class_type->variables[i].line;
+								return OK;
+							}
+						}
+
+						for (int i = 0; i < base_type.class_type->subclasses.size(); i++) {
+							if (base_type.class_type->subclasses[i]->name == p_symbol) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = base_type.class_type->subclasses[i]->line;
+								return OK;
+							}
+						}
+					}
+					base_type = base_type.class_type->base_type;
+				}
+			} break;
+			case GDScriptParser::DataType::SCRIPT:
+			case GDScriptParser::DataType::GDSCRIPT: {
+				Ref<Script> scr = base_type.script_type;
+				if (scr.is_valid()) {
+					int line = scr->get_member_line(p_symbol);
+					if (line >= 0) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = line;
+						r_result.script = scr;
+						return OK;
+					}
+					Ref<Script> base_script = scr->get_base_script();
+					if (base_script.is_valid()) {
+						base_type.script_type = base_script;
+					} else {
+						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.native_type = scr->get_instance_base_type();
+					}
+				} else {
+					base_type.has_type = false;
+				}
+			} break;
+			case GDScriptParser::DataType::NATIVE: {
+				StringName class_name = base_type.native_type;
+				if (!ClassDB::class_exists(class_name)) {
+					class_name = String("_") + class_name;
+					if (!ClassDB::class_exists(class_name)) {
+						base_type.has_type = false;
+						break;
+					}
+				}
+
+				if (ClassDB::has_method(class_name, p_symbol, true)) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+					r_result.class_name = base_type.native_type;
+					r_result.class_member = p_symbol;
+					return OK;
+				}
+
+				List<MethodInfo> virtual_methods;
+				ClassDB::get_virtual_methods(class_name, &virtual_methods, true);
+				for (List<MethodInfo>::Element *E = virtual_methods.front(); E; E = E->next()) {
+					if (E->get().name == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+						r_result.class_name = base_type.native_type;
+						r_result.class_member = p_symbol;
+						return OK;
+					}
+				}
+
+				StringName enum_name = ClassDB::get_integer_constant_enum(class_name, p_symbol, true);
+				if (enum_name != StringName()) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_ENUM;
+					r_result.class_name = base_type.native_type;
+					r_result.class_member = enum_name;
+					return OK;
+				}
+
+				List<String> constants;
+				ClassDB::get_integer_constant_list(class_name, &constants, true);
+				for (List<String>::Element *E = constants.front(); E; E = E->next()) {
+					if (E->get() == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+						r_result.class_name = base_type.native_type;
+						r_result.class_member = p_symbol;
+						return OK;
+					}
+				}
+
+				List<PropertyInfo> properties;
+				ClassDB::get_property_list(class_name, &properties, true);
+				for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
+					if (E->get().name == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+						r_result.class_name = base_type.native_type;
+						r_result.class_member = p_symbol;
+						return OK;
+					}
+				}
+
+				StringName parent = ClassDB::get_parent_class(class_name);
+				if (parent != StringName()) {
+					if (String(parent).begins_with("_")) {
+						base_type.native_type = String(parent).right(1);
+					} else {
+						base_type.native_type = parent;
+					}
+				} else {
+					base_type.has_type = false;
+				}
+			} break;
+			case GDScriptParser::DataType::BUILTIN: {
+				base_type.has_type = false;
+
+				if (Variant::has_constant(base_type.builtin_type, p_symbol)) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
+					r_result.class_member = p_symbol;
+					return OK;
+				}
+
+				Variant v;
+				REF v_ref;
+				if (base_type.builtin_type == Variant::OBJECT) {
+					v_ref.instance();
+					v = v_ref;
+				} else {
+					Variant::CallError err;
+					v = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+					if (err.error != Variant::CallError::CALL_OK) {
+						break;
+					}
+				}
+
+				if (v.has_method(p_symbol)) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
+					r_result.class_member = p_symbol;
+					return OK;
+				}
+
+				bool valid = false;
+				v.get(p_symbol, &valid);
+				if (valid) {
+					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
+					r_result.class_member = p_symbol;
+					return OK;
+				}
+			} break;
+			default: {
+				base_type.has_type = false;
+			} break;
+		}
+	}
+
+	return ERR_CANT_RESOLVE;
+}
+
+Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) {
+	//before parsing, try the usual stuff
+	if (ClassDB::class_exists(p_symbol)) {
+		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+		r_result.class_name = p_symbol;
+		return OK;
+	} else {
+		String under_prefix = "_" + p_symbol;
+		if (ClassDB::class_exists(under_prefix)) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+			r_result.class_name = p_symbol;
+			return OK;
+		}
+	}
+
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		Variant::Type t = Variant::Type(i);
+		if (Variant::get_type_name(t) == p_symbol) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+			r_result.class_name = Variant::get_type_name(t);
+			return OK;
+		}
+	}
+
+	if ("PI" == p_symbol || "TAU" == p_symbol || "INF" == p_symbol || "NAN" == p_symbol) {
+		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+		r_result.class_name = "@GDScript";
+		r_result.class_member = p_symbol;
+		return OK;
+	}
+
+	GDScriptParser parser;
+	parser.parse(p_code, p_path.get_base_dir(), false, p_path, true);
+
+	if (parser.get_completion_type() == GDScriptParser::COMPLETION_NONE) {
+		return ERR_CANT_RESOLVE;
+	}
+
+	GDScriptCompletionContext context;
+	context._class = parser.get_completion_class();
+	context.function = parser.get_completion_function();
+	context.block = parser.get_completion_block();
+	context.line = parser.get_completion_line();
+	context.base = p_owner;
+	context.base_path = p_path.get_base_dir();
+
+	if (context._class && context._class->extends_class.size() > 0) {
+		bool success = false;
+		ClassDB::get_integer_constant(context._class->extends_class[0], p_symbol, &success);
+		if (success) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+			r_result.class_name = context._class->extends_class[0];
+			r_result.class_member = p_symbol;
+			return OK;
+		}
+	}
+
+	bool is_function = false;
+
+	switch (parser.get_completion_type()) {
+		case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+			r_result.class_name = Variant::get_type_name(parser.get_completion_built_in_constant());
+			r_result.class_member = p_symbol;
+			return OK;
+		} break;
+		case GDScriptParser::COMPLETION_PARENT_FUNCTION:
+		case GDScriptParser::COMPLETION_FUNCTION: {
+			is_function = true;
+			FALLTHROUGH;
+		}
+		case GDScriptParser::COMPLETION_IDENTIFIER: {
+			if (!is_function) {
+				is_function = parser.get_completion_identifier_is_function();
+			}
+
+			GDScriptParser::DataType base_type;
+			if (context._class) {
+				if (parser.get_completion_type() != GDScriptParser::COMPLETION_PARENT_FUNCTION) {
+					base_type.has_type = true;
+					base_type.kind = GDScriptParser::DataType::CLASS;
+					base_type.class_type = const_cast<GDScriptParser::ClassNode *>(context._class);
+				} else {
+					base_type = context._class->base_type;
+				}
+			} else {
+				break;
+			}
+
+			if (!is_function && context.block) {
+				// Lookup local variables
+				const GDScriptParser::BlockNode *block = context.block;
+				while (block) {
+					if (block->variables.has(p_symbol)) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = block->variables[p_symbol]->line;
+						return OK;
+					}
+					block = block->parent_block;
+				}
+			}
+
+			if (context.function && context.function->name != StringName()) {
+				// Lookup function arguments
+				for (int i = 0; i < context.function->arguments.size(); i++) {
+					if (context.function->arguments[i] == p_symbol) {
+						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.location = context.function->line;
+						return OK;
+					}
+				}
+			}
+
+			if (_lookup_symbol_from_base(base_type, p_symbol, is_function, r_result) == OK) {
+				return OK;
+			}
+
+			if (!is_function) {
+				// Guess in autoloads as singletons
+				List<PropertyInfo> props;
+				ProjectSettings::get_singleton()->get_property_list(&props);
+
+				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+					String s = E->get().name;
+					if (!s.begins_with("autoload/")) {
+						continue;
+					}
+					String name = s.get_slice("/", 1);
+					if (name == String(p_symbol)) {
+						String path = ProjectSettings::get_singleton()->get(s);
+						if (path.begins_with("*")) {
+							String script = path.substr(1, path.length());
+
+							if (!script.ends_with(".gd")) {
+								// Not a script, try find the script anyway,
+								// may have some success
+								script = script.get_basename() + ".gd";
+							}
+
+							if (FileAccess::exists(script)) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+								r_result.location = 0;
+								r_result.script = ResourceLoader::load(script);
+								return OK;
+							}
+						}
+					}
+				}
+
+				// Global
+				Map<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) {
+						Object *obj = value;
+						if (obj) {
+							if (Object::cast_to<GDScriptNativeClass>(obj)) {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+								r_result.class_name = Object::cast_to<GDScriptNativeClass>(obj)->get_name();
+							} else {
+								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+								r_result.class_name = obj->get_class();
+							}
+
+							// proxy class remove the underscore.
+							if (r_result.class_name.begins_with("_")) {
+								r_result.class_name = r_result.class_name.right(1);
+							}
+							return OK;
+						}
+					} else {
+						/*
+						// Because get_integer_constant_enum and get_integer_constant don't work on @GlobalScope
+						// We cannot determine the exact nature of the identifier here
+						// Otherwise these codes would work
+						StringName enumName = ClassDB::get_integer_constant_enum("@GlobalScope", p_symbol, true);
+						if (enumName != NULL) {
+							r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_ENUM;
+							r_result.class_name = "@GlobalScope";
+							r_result.class_member = enumName;
+							return OK;
+						}
+						else {
+							r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+							r_result.class_name = "@GlobalScope";
+							r_result.class_member = p_symbol;
+							return OK;
+						}*/
+						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE;
+						r_result.class_name = "@GlobalScope";
+						r_result.class_member = p_symbol;
+						return OK;
+					}
+				}
+			}
+		} break;
+		case GDScriptParser::COMPLETION_METHOD: {
+			is_function = true;
+			FALLTHROUGH;
+		}
+		case GDScriptParser::COMPLETION_INDEX: {
+			const GDScriptParser::Node *node = parser.get_completion_node();
+			if (node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+				break;
+			}
+			GDScriptCompletionIdentifier base;
+			if (!_guess_expression_type(context, static_cast<const GDScriptParser::OperatorNode *>(node)->arguments[0], base)) {
+				break;
+			}
+
+			if (_lookup_symbol_from_base(base.type, p_symbol, is_function, r_result) == OK) {
+				return OK;
+			}
+		} break;
+		case GDScriptParser::COMPLETION_VIRTUAL_FUNC: {
+			GDScriptParser::DataType base_type = context._class->base_type;
+
+			if (_lookup_symbol_from_base(base_type, p_symbol, true, r_result) == OK) {
+				return OK;
+			}
+		} break;
+		case GDScriptParser::COMPLETION_TYPE_HINT: {
+			GDScriptParser::DataType base_type = context._class->base_type;
+			base_type.has_type = true;
+			base_type.kind = GDScriptParser::DataType::CLASS;
+			base_type.class_type = const_cast<GDScriptParser::ClassNode *>(context._class);
+
+			if (_lookup_symbol_from_base(base_type, p_symbol, false, r_result) == OK) {
+				return OK;
+			}
+		} break;
+		default: {
+		}
+	}
+
+	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+		// this has to get run after parsing because otherwise functions like Array.max() will trigger it
+		if (GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i)) == p_symbol) {
+			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+			r_result.class_name = "@GDScript";
+			r_result.class_member = p_symbol;
+			return OK;
+		}
+	}
+
+	return ERR_CANT_RESOLVE;
+}
+
+#endif
diff --git a/modules/cscript/cscript_function.cpp b/modules/cscript/cscript_function.cpp
new file mode 100644
index 000000000..767b73595
--- /dev/null
+++ b/modules/cscript/cscript_function.cpp
@@ -0,0 +1,1879 @@
+/*************************************************************************/
+/*  gdscript_function.cpp                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript_function.h"
+
+#include "core/os/os.h"
+#include "cscript.h"
+#include "cscript_functions.h"
+
+Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_instance, GDScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const {
+	int address = p_address & ADDR_MASK;
+
+	//sequential table (jump table generated by compiler)
+	switch ((p_address & ADDR_TYPE_MASK) >> ADDR_BITS) {
+		case ADDR_TYPE_SELF: {
+#ifdef DEBUG_ENABLED
+			if (unlikely(!p_instance)) {
+				r_error = "Cannot access self without instance.";
+				return nullptr;
+			}
+#endif
+			return &self;
+		} break;
+		case ADDR_TYPE_CLASS: {
+			return &static_ref;
+		} break;
+		case ADDR_TYPE_MEMBER: {
+#ifdef DEBUG_ENABLED
+			if (unlikely(!p_instance)) {
+				r_error = "Cannot access member without instance.";
+				return nullptr;
+			}
+#endif
+			//member indexing is O(1)
+			return &p_instance->members.write[address];
+		} break;
+		case ADDR_TYPE_CLASS_CONSTANT: {
+			//todo change to index!
+			GDScript *s = p_script;
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_INDEX_V(address, _global_names_count, nullptr);
+#endif
+			const StringName *sn = &_global_names_ptr[address];
+
+			while (s) {
+				GDScript *o = s;
+				while (o) {
+					Map<StringName, Variant>::Element *E = o->constants.find(*sn);
+					if (E) {
+						return &E->get();
+					}
+					o = o->_owner;
+				}
+				s = s->_base;
+			}
+
+			ERR_FAIL_V_MSG(nullptr, "GDScriptCompiler bug.");
+		} break;
+		case ADDR_TYPE_LOCAL_CONSTANT: {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_INDEX_V(address, _constant_count, nullptr);
+#endif
+			return &_constants_ptr[address];
+		} break;
+		case ADDR_TYPE_STACK:
+		case ADDR_TYPE_STACK_VARIABLE: {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_INDEX_V(address, _stack_size, nullptr);
+#endif
+			return &p_stack[address];
+		} break;
+		case ADDR_TYPE_GLOBAL: {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_INDEX_V(address, GDScriptLanguage::get_singleton()->get_global_array_size(), nullptr);
+#endif
+			return &GDScriptLanguage::get_singleton()->get_global_array()[address];
+		} break;
+#ifdef TOOLS_ENABLED
+		case ADDR_TYPE_NAMED_GLOBAL: {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_INDEX_V(address, _named_globals_count, nullptr);
+#endif
+			StringName id = _named_globals_ptr[address];
+
+			if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(id)) {
+				return (Variant *)&GDScriptLanguage::get_singleton()->get_named_globals_map()[id];
+			} else {
+				r_error = "Autoload singleton '" + String(id) + "' has been removed.";
+				return nullptr;
+			}
+		} break;
+#endif
+		case ADDR_TYPE_NIL: {
+			return &nil;
+		} break;
+	}
+
+	ERR_FAIL_V_MSG(nullptr, "Bad code! (unknown addressing mode).");
+	return nullptr;
+}
+
+#ifdef DEBUG_ENABLED
+static String _get_var_type(const Variant *p_var) {
+	String basestr;
+
+	if (p_var->get_type() == Variant::OBJECT) {
+		Object *bobj = *p_var;
+		if (!bobj) {
+			if (p_var->is_invalid_object()) {
+				basestr = "previously freed instance";
+			} else {
+				basestr = "null instance";
+			}
+		} else {
+			if (bobj->get_script_instance()) {
+				basestr = bobj->get_class() + " (" + bobj->get_script_instance()->get_script()->get_path().get_file() + ")";
+			} else {
+				basestr = bobj->get_class();
+			}
+		}
+
+	} else {
+		basestr = Variant::get_type_name(p_var->get_type());
+	}
+
+	return basestr;
+}
+#endif // DEBUG_ENABLED
+
+String GDScriptFunction::_get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const {
+	String err_text;
+
+	if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+		int errorarg = p_err.argument;
+		// Handle the Object to Object case separately as we don't have further class details.
+#ifdef DEBUG_ENABLED
+		if (p_err.expected == Variant::OBJECT && argptrs[errorarg]->get_type() == p_err.expected) {
+			err_text = "Invalid type in " + p_where + ". The Object-derived class of argument " + itos(errorarg + 1) + " (" + _get_var_type(argptrs[errorarg]) + ") is not a subclass of the expected argument class.";
+		} else
+#endif // DEBUG_ENABLED
+		{
+			err_text = "Invalid type in " + p_where + ". Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(p_err.expected) + ".";
+		}
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
+		err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
+		err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+		err_text = "Invalid call. Nonexistent " + p_where + ".";
+	} else if (p_err.error == Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
+		err_text = "Attempt to call " + p_where + " on a null instance.";
+	} else {
+		err_text = "Bug, call error: #" + itos(p_err.error);
+	}
+
+	return err_text;
+}
+
+#if defined(__GNUC__)
+#define OPCODES_TABLE                         \
+	static const void *switch_table_ops[] = { \
+		&&OPCODE_OPERATOR,                    \
+		&&OPCODE_EXTENDS_TEST,                \
+		&&OPCODE_IS_BUILTIN,                  \
+		&&OPCODE_SET,                         \
+		&&OPCODE_GET,                         \
+		&&OPCODE_SET_NAMED,                   \
+		&&OPCODE_GET_NAMED,                   \
+		&&OPCODE_SET_MEMBER,                  \
+		&&OPCODE_GET_MEMBER,                  \
+		&&OPCODE_ASSIGN,                      \
+		&&OPCODE_ASSIGN_TRUE,                 \
+		&&OPCODE_ASSIGN_FALSE,                \
+		&&OPCODE_ASSIGN_TYPED_BUILTIN,        \
+		&&OPCODE_ASSIGN_TYPED_NATIVE,         \
+		&&OPCODE_ASSIGN_TYPED_SCRIPT,         \
+		&&OPCODE_CAST_TO_BUILTIN,             \
+		&&OPCODE_CAST_TO_NATIVE,              \
+		&&OPCODE_CAST_TO_SCRIPT,              \
+		&&OPCODE_CONSTRUCT,                   \
+		&&OPCODE_CONSTRUCT_ARRAY,             \
+		&&OPCODE_CONSTRUCT_DICTIONARY,        \
+		&&OPCODE_CALL,                        \
+		&&OPCODE_CALL_RETURN,                 \
+		&&OPCODE_CALL_BUILT_IN,               \
+		&&OPCODE_CALL_SELF,                   \
+		&&OPCODE_CALL_SELF_BASE,              \
+		&&OPCODE_YIELD,                       \
+		&&OPCODE_YIELD_SIGNAL,                \
+		&&OPCODE_YIELD_RESUME,                \
+		&&OPCODE_JUMP,                        \
+		&&OPCODE_JUMP_IF,                     \
+		&&OPCODE_JUMP_IF_NOT,                 \
+		&&OPCODE_JUMP_TO_DEF_ARGUMENT,        \
+		&&OPCODE_RETURN,                      \
+		&&OPCODE_ITERATE_BEGIN,               \
+		&&OPCODE_ITERATE,                     \
+		&&OPCODE_ASSERT,                      \
+		&&OPCODE_BREAKPOINT,                  \
+		&&OPCODE_LINE,                        \
+		&&OPCODE_END                          \
+	};
+
+#define OPCODE(m_op) \
+	m_op:
+#define OPCODE_WHILE(m_test)
+#define OPCODES_END \
+	OPSEXIT:
+#define OPCODES_OUT \
+	OPSOUT:
+#define DISPATCH_OPCODE goto *switch_table_ops[_code_ptr[ip]]
+#define OPCODE_SWITCH(m_test) DISPATCH_OPCODE;
+#define OPCODE_BREAK goto OPSEXIT
+#define OPCODE_OUT goto OPSOUT
+#else
+#define OPCODES_TABLE
+#define OPCODE(m_op) case m_op:
+#define OPCODE_WHILE(m_test) while (m_test)
+#define OPCODES_END
+#define OPCODES_OUT
+#define DISPATCH_OPCODE continue
+#define OPCODE_SWITCH(m_test) switch (m_test)
+#define OPCODE_BREAK break
+#define OPCODE_OUT break
+#endif
+
+Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state) {
+	OPCODES_TABLE;
+
+	if (!_code_ptr) {
+		return Variant();
+	}
+
+	r_err.error = Variant::CallError::CALL_OK;
+
+	Variant self;
+	Variant static_ref;
+	Variant retvalue;
+	Variant *stack = nullptr;
+	Variant **call_args;
+	int defarg = 0;
+
+#ifdef DEBUG_ENABLED
+
+	//GDScriptLanguage::get_singleton()->calls++;
+
+#endif
+
+	uint32_t alloca_size = 0;
+	GDScript *script;
+	int ip = 0;
+	int line = _initial_line;
+
+	if (p_state) {
+		//use existing (supplied) state (yielded)
+		stack = (Variant *)p_state->stack.ptr();
+		call_args = (Variant **)&p_state->stack.ptr()[sizeof(Variant) * p_state->stack_size]; //ptr() to avoid bounds check
+		line = p_state->line;
+		ip = p_state->ip;
+		alloca_size = p_state->stack.size();
+		script = p_state->script;
+		p_instance = p_state->instance;
+		defarg = p_state->defarg;
+		self = p_state->self;
+		//stack[p_state->result_pos]=p_state->result; //assign stack with result
+
+	} else {
+		if (p_argcount != _argument_count) {
+			if (p_argcount > _argument_count) {
+				r_err.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_err.argument = _argument_count;
+
+				return Variant();
+			} else if (p_argcount < _argument_count - _default_arg_count) {
+				r_err.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_err.argument = _argument_count - _default_arg_count;
+				return Variant();
+			} else {
+				defarg = _argument_count - p_argcount;
+			}
+		}
+
+		alloca_size = sizeof(Variant *) * _call_size + sizeof(Variant) * _stack_size;
+
+		if (alloca_size) {
+			uint8_t *aptr = (uint8_t *)alloca(alloca_size);
+
+			if (_stack_size) {
+				stack = (Variant *)aptr;
+				for (int i = 0; i < p_argcount; i++) {
+					if (!argument_types[i].has_type) {
+						memnew_placement(&stack[i], Variant(*p_args[i]));
+						continue;
+					}
+
+					if (!argument_types[i].is_type(*p_args[i], true)) {
+						if (argument_types[i].is_type(Variant(), true)) {
+							memnew_placement(&stack[i], Variant);
+							continue;
+						} else {
+							r_err.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+							r_err.argument = i;
+							r_err.expected = argument_types[i].kind == GDScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT;
+							return Variant();
+						}
+					}
+					if (argument_types[i].kind == GDScriptDataType::BUILTIN) {
+						Variant arg = Variant::construct(argument_types[i].builtin_type, &p_args[i], 1, r_err);
+						memnew_placement(&stack[i], Variant(arg));
+					} else {
+						memnew_placement(&stack[i], Variant(*p_args[i]));
+					}
+				}
+				for (int i = p_argcount; i < _stack_size; i++) {
+					memnew_placement(&stack[i], Variant);
+				}
+			} else {
+				stack = nullptr;
+			}
+
+			if (_call_size) {
+				call_args = (Variant **)&aptr[sizeof(Variant) * _stack_size];
+			} else {
+				call_args = nullptr;
+			}
+
+		} else {
+			stack = nullptr;
+			call_args = nullptr;
+		}
+
+		if (p_instance) {
+			self = p_instance->owner;
+			script = p_instance->script.ptr();
+		} else {
+			script = _script;
+		}
+	}
+
+#ifdef DEBUG_ENABLED
+	Variant instance = p_instance;
+#endif
+	static_ref = script;
+
+	String err_text;
+
+#ifdef DEBUG_ENABLED
+
+	if (ScriptDebugger::get_singleton()) {
+		GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
+	}
+
+#define GD_ERR_BREAK(m_cond)                                                                                           \
+	{                                                                                                                  \
+		if (unlikely(m_cond)) {                                                                                        \
+			_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition ' " _STR(m_cond) " ' is true. Breaking..:"); \
+			OPCODE_BREAK;                                                                                              \
+		}                                                                                                              \
+	}
+
+#define CHECK_SPACE(m_space) \
+	GD_ERR_BREAK((ip + m_space) > _code_size)
+
+#define GET_VARIANT_PTR(m_v, m_code_ofs)                                                                   \
+	Variant *m_v;                                                                                          \
+	m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, script, self, static_ref, stack, err_text); \
+	if (unlikely(!m_v))                                                                                    \
+		OPCODE_BREAK;
+
+#else
+#define GD_ERR_BREAK(m_cond)
+#define CHECK_SPACE(m_space)
+#define GET_VARIANT_PTR(m_v, m_code_ofs) \
+	Variant *m_v;                        \
+	m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, script, self, static_ref, stack, err_text);
+
+#endif
+
+#ifdef DEBUG_ENABLED
+
+	uint64_t function_start_time = 0;
+	uint64_t function_call_time = 0;
+
+	if (GDScriptLanguage::get_singleton()->profiling) {
+		function_start_time = OS::get_singleton()->get_ticks_usec();
+		function_call_time = 0;
+		profile.call_count++;
+		profile.frame_call_count++;
+	}
+	bool exit_ok = false;
+	bool yielded = false;
+#endif
+
+#ifdef DEBUG_ENABLED
+	OPCODE_WHILE(ip < _code_size) {
+		int last_opcode = _code_ptr[ip];
+#else
+	OPCODE_WHILE(true) {
+#endif
+
+		OPCODE_SWITCH(_code_ptr[ip]) {
+			OPCODE(OPCODE_OPERATOR) {
+				CHECK_SPACE(5);
+
+				bool valid;
+				Variant::Operator op = (Variant::Operator)_code_ptr[ip + 1];
+				GD_ERR_BREAK(op >= Variant::OP_MAX);
+
+				GET_VARIANT_PTR(a, 2);
+				GET_VARIANT_PTR(b, 3);
+				GET_VARIANT_PTR(dst, 4);
+
+#ifdef DEBUG_ENABLED
+
+				Variant ret;
+				Variant::evaluate(op, *a, *b, ret, valid);
+#else
+				Variant::evaluate(op, *a, *b, *dst, valid);
+#endif
+#ifdef DEBUG_ENABLED
+				if (!valid) {
+					if (ret.get_type() == Variant::STRING) {
+						//return a string when invalid with the error
+						err_text = ret;
+						err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
+					} else {
+						err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
+					}
+					OPCODE_BREAK;
+				}
+				*dst = ret;
+#endif
+				ip += 5;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_EXTENDS_TEST) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(a, 1);
+				GET_VARIANT_PTR(b, 2);
+				GET_VARIANT_PTR(dst, 3);
+
+#ifdef DEBUG_ENABLED
+				if (a->is_invalid_object()) {
+					err_text = "Left operand of 'is' was already freed.";
+					OPCODE_BREAK;
+				}
+				if (b->get_type() != Variant::OBJECT || b->is_invalid_object()) {
+					err_text = "Right operand of 'is' is not a class.";
+					OPCODE_BREAK;
+				}
+#endif
+
+				bool extends_ok = false;
+				if (a->get_type() == Variant::OBJECT && a->operator Object *() != nullptr) {
+					Object *obj_A = *a;
+					Object *obj_B = *b;
+
+					GDScript *scr_B = Object::cast_to<GDScript>(obj_B);
+
+					if (scr_B) {
+						//if B is a script, the only valid condition is that A has an instance which inherits from the script
+						//in other situation, this shoul return false.
+
+						if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) {
+							GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr());
+							//bool found=false;
+							while (cmp) {
+								if (cmp == scr_B) {
+									//inherits from script, all ok
+									extends_ok = true;
+									break;
+								}
+
+								cmp = cmp->_base;
+							}
+						}
+
+					} else {
+						GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(obj_B);
+
+#ifdef DEBUG_ENABLED
+						if (!nc) {
+							if (obj_B) {
+								err_text = "Right operand of 'is' is not a class (type: '" + obj_B->get_class() + "').";
+							} else {
+								err_text = "Right operand of 'is' is null.";
+							}
+							OPCODE_BREAK;
+						}
+#endif
+						extends_ok = ClassDB::is_parent_class(obj_A->get_class_name(), nc->get_name());
+					}
+				}
+
+				*dst = extends_ok;
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_IS_BUILTIN) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(value, 1);
+				Variant::Type var_type = (Variant::Type)_code_ptr[ip + 2];
+				GET_VARIANT_PTR(dst, 3);
+
+				GD_ERR_BREAK(var_type < 0 || var_type >= Variant::VARIANT_MAX);
+
+				*dst = value->get_type() == var_type;
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_SET) {
+				CHECK_SPACE(3);
+
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(index, 2);
+				GET_VARIANT_PTR(value, 3);
+
+				bool valid;
+				dst->set(*index, *value, &valid);
+
+#ifdef DEBUG_ENABLED
+				if (!valid) {
+					String v = index->operator String();
+					if (v != "") {
+						v = "'" + v + "'";
+					} else {
+						v = "of type '" + _get_var_type(index) + "'";
+					}
+					err_text = "Invalid set index " + v + " (on base: '" + _get_var_type(dst) + "') with value of type '" + _get_var_type(value) + "'";
+					OPCODE_BREAK;
+				}
+#endif
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_GET) {
+				CHECK_SPACE(3);
+
+				GET_VARIANT_PTR(src, 1);
+				GET_VARIANT_PTR(index, 2);
+				GET_VARIANT_PTR(dst, 3);
+
+				bool valid;
+#ifdef DEBUG_ENABLED
+				//allow better error message in cases where src and dst are the same stack position
+				Variant ret = src->get(*index, &valid);
+#else
+				*dst = src->get(*index, &valid);
+
+#endif
+#ifdef DEBUG_ENABLED
+				if (!valid) {
+					String v = index->operator String();
+					if (v != "") {
+						v = "'" + v + "'";
+					} else {
+						v = "of type '" + _get_var_type(index) + "'";
+					}
+					err_text = "Invalid get index " + v + " (on base: '" + _get_var_type(src) + "').";
+
+					OPCODE_BREAK;
+				}
+				*dst = ret;
+#endif
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_SET_NAMED) {
+				CHECK_SPACE(3);
+
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(value, 3);
+
+				int indexname = _code_ptr[ip + 2];
+
+				GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
+				const StringName *index = &_global_names_ptr[indexname];
+
+				bool valid;
+				dst->set_named(*index, *value, &valid);
+
+#ifdef DEBUG_ENABLED
+				if (!valid) {
+					String err_type;
+					err_text = "Invalid set index '" + String(*index) + "' (on base: '" + _get_var_type(dst) + "') with value of type '" + _get_var_type(value) + "'.";
+					OPCODE_BREAK;
+				}
+#endif
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_GET_NAMED) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(src, 1);
+				GET_VARIANT_PTR(dst, 3);
+
+				int indexname = _code_ptr[ip + 2];
+
+				GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
+				const StringName *index = &_global_names_ptr[indexname];
+
+				bool valid;
+#ifdef DEBUG_ENABLED
+				//allow better error message in cases where src and dst are the same stack position
+				Variant ret = src->get_named(*index, &valid);
+
+#else
+				*dst = src->get_named(*index, &valid);
+#endif
+#ifdef DEBUG_ENABLED
+				if (!valid) {
+					if (src->has_method(*index)) {
+						err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "'). Did you mean '." + index->operator String() + "()' or funcref(obj, \"" + index->operator String() + "\") ?";
+					} else {
+						err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "').";
+					}
+					OPCODE_BREAK;
+				}
+				*dst = ret;
+#endif
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_SET_MEMBER) {
+				CHECK_SPACE(3);
+				int indexname = _code_ptr[ip + 1];
+				GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
+				const StringName *index = &_global_names_ptr[indexname];
+				GET_VARIANT_PTR(src, 2);
+
+				bool valid;
+#ifndef DEBUG_ENABLED
+				ClassDB::set_property(p_instance->owner, *index, *src, &valid);
+#else
+				bool ok = ClassDB::set_property(p_instance->owner, *index, *src, &valid);
+				if (!ok) {
+					err_text = "Internal error setting property: " + String(*index);
+					OPCODE_BREAK;
+				} else if (!valid) {
+					err_text = "Error setting property '" + String(*index) + "' with value of type " + Variant::get_type_name(src->get_type()) + ".";
+					OPCODE_BREAK;
+				}
+#endif
+				ip += 3;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_GET_MEMBER) {
+				CHECK_SPACE(3);
+				int indexname = _code_ptr[ip + 1];
+				GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
+				const StringName *index = &_global_names_ptr[indexname];
+				GET_VARIANT_PTR(dst, 2);
+
+#ifndef DEBUG_ENABLED
+				ClassDB::get_property(p_instance->owner, *index, *dst);
+#else
+				bool ok = ClassDB::get_property(p_instance->owner, *index, *dst);
+				if (!ok) {
+					err_text = "Internal error getting property: " + String(*index);
+					OPCODE_BREAK;
+				}
+#endif
+				ip += 3;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN) {
+				CHECK_SPACE(3);
+				GET_VARIANT_PTR(dst, 1);
+				GET_VARIANT_PTR(src, 2);
+
+				*dst = *src;
+
+				ip += 3;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN_TRUE) {
+				CHECK_SPACE(2);
+				GET_VARIANT_PTR(dst, 1);
+
+				*dst = true;
+
+				ip += 2;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN_FALSE) {
+				CHECK_SPACE(2);
+				GET_VARIANT_PTR(dst, 1);
+
+				*dst = false;
+
+				ip += 2;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN_TYPED_BUILTIN) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(dst, 2);
+				GET_VARIANT_PTR(src, 3);
+
+				Variant::Type var_type = (Variant::Type)_code_ptr[ip + 1];
+				GD_ERR_BREAK(var_type < 0 || var_type >= Variant::VARIANT_MAX);
+
+				if (src->get_type() != var_type) {
+#ifdef DEBUG_ENABLED
+					if (Variant::can_convert_strict(src->get_type(), var_type)) {
+#endif // DEBUG_ENABLED
+						Variant::CallError ce;
+						*dst = Variant::construct(var_type, const_cast<const Variant **>(&src), 1, ce);
+					} else {
+#ifdef DEBUG_ENABLED
+						err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
+								"' to a variable of type '" + Variant::get_type_name(var_type) + "'.";
+						OPCODE_BREAK;
+					}
+				} else {
+#endif // DEBUG_ENABLED
+					*dst = *src;
+				}
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN_TYPED_NATIVE) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(dst, 2);
+				GET_VARIANT_PTR(src, 3);
+
+#ifdef DEBUG_ENABLED
+				GET_VARIANT_PTR(type, 1);
+				GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *());
+				GD_ERR_BREAK(!nc);
+				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
+					err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
+							"' to a variable of type '" + nc->get_name() + "'.";
+					OPCODE_BREAK;
+				}
+				Object *src_obj = src->operator Object *();
+
+				if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
+					err_text = "Trying to assign value of type '" + src_obj->get_class_name() +
+							"' to a variable of type '" + nc->get_name() + "'.";
+					OPCODE_BREAK;
+				}
+#endif // DEBUG_ENABLED
+				*dst = *src;
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSIGN_TYPED_SCRIPT) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(dst, 2);
+				GET_VARIANT_PTR(src, 3);
+
+#ifdef DEBUG_ENABLED
+				GET_VARIANT_PTR(type, 1);
+				Script *base_type = Object::cast_to<Script>(type->operator Object *());
+
+				GD_ERR_BREAK(!base_type);
+
+				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
+					err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
+					OPCODE_BREAK;
+				}
+
+				if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
+					ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
+					if (!scr_inst) {
+						err_text = "Trying to assign value of type '" + src->operator Object *()->get_class_name() +
+								"' to a variable of type '" + base_type->get_path().get_file() + "'.";
+						OPCODE_BREAK;
+					}
+
+					Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
+					bool valid = false;
+
+					while (src_type) {
+						if (src_type == base_type) {
+							valid = true;
+							break;
+						}
+						src_type = src_type->get_base_script().ptr();
+					}
+
+					if (!valid) {
+						err_text = "Trying to assign value of type '" + src->operator Object *()->get_script_instance()->get_script()->get_path().get_file() +
+								"' to a variable of type '" + base_type->get_path().get_file() + "'.";
+						OPCODE_BREAK;
+					}
+				}
+#endif // DEBUG_ENABLED
+
+				*dst = *src;
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CAST_TO_BUILTIN) {
+				CHECK_SPACE(4);
+				Variant::Type to_type = (Variant::Type)_code_ptr[ip + 1];
+				GET_VARIANT_PTR(src, 2);
+				GET_VARIANT_PTR(dst, 3);
+
+				GD_ERR_BREAK(to_type < 0 || to_type >= Variant::VARIANT_MAX);
+
+				Variant::CallError err;
+				*dst = Variant::construct(to_type, (const Variant **)&src, 1, err);
+
+#ifdef DEBUG_ENABLED
+				if (src->is_invalid_object()) {
+					err_text = "Trying to cast a deleted object.";
+					OPCODE_BREAK;
+				}
+				if (err.error != Variant::CallError::CALL_OK) {
+					err_text = "Invalid cast: could not convert value to '" + Variant::get_type_name(to_type) + "'.";
+					OPCODE_BREAK;
+				}
+#endif
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CAST_TO_NATIVE) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(to_type, 1);
+				GET_VARIANT_PTR(src, 2);
+				GET_VARIANT_PTR(dst, 3);
+
+				GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(to_type->operator Object *());
+				GD_ERR_BREAK(!nc);
+
+#ifdef DEBUG_ENABLED
+				if (src->is_invalid_object()) {
+					err_text = "Trying to cast a deleted object.";
+					OPCODE_BREAK;
+				}
+				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
+					err_text = "Invalid cast: can't convert a non-object value to an object type.";
+					OPCODE_BREAK;
+				}
+#endif
+				Object *src_obj = src->operator Object *();
+
+				if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
+					*dst = Variant(); // invalid cast, assign NULL
+				} else {
+					*dst = *src;
+				}
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CAST_TO_SCRIPT) {
+				CHECK_SPACE(4);
+				GET_VARIANT_PTR(to_type, 1);
+				GET_VARIANT_PTR(src, 2);
+				GET_VARIANT_PTR(dst, 3);
+
+				Script *base_type = Object::cast_to<Script>(to_type->operator Object *());
+
+				GD_ERR_BREAK(!base_type);
+
+#ifdef DEBUG_ENABLED
+				if (src->is_invalid_object()) {
+					err_text = "Trying to cast a deleted object.";
+					OPCODE_BREAK;
+				}
+				if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
+					err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
+					OPCODE_BREAK;
+				}
+#endif
+
+				bool valid = false;
+
+				if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
+					ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
+
+					if (scr_inst) {
+						Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
+
+						while (src_type) {
+							if (src_type == base_type) {
+								valid = true;
+								break;
+							}
+							src_type = src_type->get_base_script().ptr();
+						}
+					}
+				}
+
+				if (valid) {
+					*dst = *src; // Valid cast, copy the source object
+				} else {
+					*dst = Variant(); // invalid cast, assign NULL
+				}
+
+				ip += 4;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CONSTRUCT) {
+				CHECK_SPACE(2);
+				Variant::Type t = Variant::Type(_code_ptr[ip + 1]);
+				int argc = _code_ptr[ip + 2];
+				CHECK_SPACE(argc + 2);
+				Variant **argptrs = call_args;
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, 3 + i);
+					argptrs[i] = v;
+				}
+
+				GET_VARIANT_PTR(dst, 3 + argc);
+				Variant::CallError err;
+				*dst = Variant::construct(t, (const Variant **)argptrs, argc, err);
+
+#ifdef DEBUG_ENABLED
+				if (err.error != Variant::CallError::CALL_OK) {
+					err_text = _get_call_error(err, "'" + Variant::get_type_name(t) + "' constructor", (const Variant **)argptrs);
+					OPCODE_BREAK;
+				}
+#endif
+
+				ip += 4 + argc;
+				//construct a basic type
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CONSTRUCT_ARRAY) {
+				CHECK_SPACE(1);
+				int argc = _code_ptr[ip + 1];
+				Array array; //arrays are always shared
+				array.resize(argc);
+				CHECK_SPACE(argc + 2);
+
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, 2 + i);
+					array[i] = *v;
+				}
+
+				GET_VARIANT_PTR(dst, 2 + argc);
+
+				*dst = array;
+
+				ip += 3 + argc;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CONSTRUCT_DICTIONARY) {
+				CHECK_SPACE(1);
+				int argc = _code_ptr[ip + 1];
+				Dictionary dict; //arrays are always shared
+
+				CHECK_SPACE(argc * 2 + 2);
+
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(k, 2 + i * 2 + 0);
+					GET_VARIANT_PTR(v, 2 + i * 2 + 1);
+					dict[*k] = *v;
+				}
+
+				GET_VARIANT_PTR(dst, 2 + argc * 2);
+
+				*dst = dict;
+
+				ip += 3 + argc * 2;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CALL_RETURN)
+			OPCODE(OPCODE_CALL) {
+				CHECK_SPACE(4);
+				bool call_ret = _code_ptr[ip] == OPCODE_CALL_RETURN;
+
+				int argc = _code_ptr[ip + 1];
+				GET_VARIANT_PTR(base, 2);
+				int nameg = _code_ptr[ip + 3];
+
+				GD_ERR_BREAK(nameg < 0 || nameg >= _global_names_count);
+				const StringName *methodname = &_global_names_ptr[nameg];
+
+				GD_ERR_BREAK(argc < 0);
+				ip += 4;
+				CHECK_SPACE(argc + 1);
+				Variant **argptrs = call_args;
+
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i);
+					argptrs[i] = v;
+				}
+
+#ifdef DEBUG_ENABLED
+				uint64_t call_time = 0;
+
+				if (GDScriptLanguage::get_singleton()->profiling) {
+					call_time = OS::get_singleton()->get_ticks_usec();
+				}
+
+#endif
+				Variant::CallError err;
+				if (call_ret) {
+					GET_VARIANT_PTR(ret, argc);
+					base->call_ptr(*methodname, (const Variant **)argptrs, argc, ret, err);
+				} else {
+					base->call_ptr(*methodname, (const Variant **)argptrs, argc, nullptr, err);
+				}
+#ifdef DEBUG_ENABLED
+				if (GDScriptLanguage::get_singleton()->profiling) {
+					function_call_time += OS::get_singleton()->get_ticks_usec() - call_time;
+				}
+
+				if (err.error != Variant::CallError::CALL_OK) {
+					String methodstr = *methodname;
+					String basestr = _get_var_type(base);
+
+					if (methodstr == "call") {
+						if (argc >= 1) {
+							methodstr = String(*argptrs[0]) + " (via call)";
+							if (err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+								err.argument += 1;
+							}
+						}
+					} else if (methodstr == "free") {
+						if (err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+							if (base->is_ref()) {
+								err_text = "Attempted to free a reference.";
+								OPCODE_BREAK;
+							} else if (base->get_type() == Variant::OBJECT) {
+								err_text = "Attempted to free a locked object (calling or emitting).";
+								OPCODE_BREAK;
+							}
+						}
+					} else if (methodstr == "call_recursive" && basestr == "TreeItem") {
+						if (argc >= 1) {
+							methodstr = String(*argptrs[0]) + " (via TreeItem.call_recursive)";
+							if (err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+								err.argument += 1;
+							}
+						}
+					}
+					err_text = _get_call_error(err, "function '" + methodstr + "' in base '" + basestr + "'", (const Variant **)argptrs);
+					OPCODE_BREAK;
+				}
+#endif
+
+				//_call_func(NULL,base,*methodname,ip,argc,p_instance,stack);
+				ip += argc + 1;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CALL_BUILT_IN) {
+				CHECK_SPACE(4);
+
+				GDScriptFunctions::Function func = GDScriptFunctions::Function(_code_ptr[ip + 1]);
+				int argc = _code_ptr[ip + 2];
+				GD_ERR_BREAK(argc < 0);
+
+				ip += 3;
+				CHECK_SPACE(argc + 1);
+				Variant **argptrs = call_args;
+
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i);
+					argptrs[i] = v;
+				}
+
+				GET_VARIANT_PTR(dst, argc);
+
+				Variant::CallError err;
+
+				GDScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
+
+#ifdef DEBUG_ENABLED
+				if (err.error != Variant::CallError::CALL_OK) {
+					String methodstr = GDScriptFunctions::get_func_name(func);
+					if (dst->get_type() == Variant::STRING) {
+						//call provided error string
+						err_text = "Error calling built-in function '" + methodstr + "': " + String(*dst);
+					} else {
+						err_text = _get_call_error(err, "built-in function '" + methodstr + "'", (const Variant **)argptrs);
+					}
+					OPCODE_BREAK;
+				}
+#endif
+				ip += argc + 1;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_CALL_SELF) {
+				OPCODE_BREAK;
+			}
+
+			OPCODE(OPCODE_CALL_SELF_BASE) {
+				CHECK_SPACE(2);
+				int self_fun = _code_ptr[ip + 1];
+
+#ifdef DEBUG_ENABLED
+				if (self_fun < 0 || self_fun >= _global_names_count) {
+					err_text = "compiler bug, function name not found";
+					OPCODE_BREAK;
+				}
+#endif
+				const StringName *methodname = &_global_names_ptr[self_fun];
+
+				int argc = _code_ptr[ip + 2];
+
+				CHECK_SPACE(2 + argc + 1);
+
+				Variant **argptrs = call_args;
+
+				for (int i = 0; i < argc; i++) {
+					GET_VARIANT_PTR(v, i + 3);
+					argptrs[i] = v;
+				}
+
+				GET_VARIANT_PTR(dst, argc + 3);
+
+				const GDScript *gds = _script;
+
+				const Map<StringName, GDScriptFunction *>::Element *E = nullptr;
+				while (gds->base.ptr()) {
+					gds = gds->base.ptr();
+					E = gds->member_functions.find(*methodname);
+					if (E) {
+						break;
+					}
+				}
+
+				Variant::CallError err;
+
+				if (E) {
+					*dst = E->get()->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);
+						if (!mb) {
+							err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						} else {
+							*dst = mb->call(p_instance->owner, (const Variant **)argptrs, argc, err);
+						}
+					} else {
+						err.error = Variant::CallError::CALL_OK;
+					}
+				} else {
+					if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
+						err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					} else {
+						err.error = Variant::CallError::CALL_OK;
+					}
+				}
+
+				if (err.error != Variant::CallError::CALL_OK) {
+					String methodstr = *methodname;
+					err_text = _get_call_error(err, "function '" + methodstr + "'", (const Variant **)argptrs);
+
+					OPCODE_BREAK;
+				}
+
+				ip += 4 + argc;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_YIELD)
+			OPCODE(OPCODE_YIELD_SIGNAL) {
+				int ipofs = 1;
+				if (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
+					CHECK_SPACE(4);
+					ipofs += 2;
+				} else {
+					CHECK_SPACE(2);
+				}
+
+				Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState);
+				gdfs->function = this;
+
+				gdfs->state.stack.resize(alloca_size);
+				//copy variant stack
+				for (int i = 0; i < _stack_size; i++) {
+					memnew_placement(&gdfs->state.stack.write[sizeof(Variant) * i], Variant(stack[i]));
+				}
+				gdfs->state.stack_size = _stack_size;
+				gdfs->state.self = self;
+				gdfs->state.alloca_size = alloca_size;
+				gdfs->state.ip = ip + ipofs;
+				gdfs->state.line = line;
+				gdfs->state.script = _script;
+				GDScriptLanguage::singleton->lock.lock();
+
+				_script->pending_func_states.add(&gdfs->scripts_list);
+				if (p_instance) {
+					gdfs->state.instance = p_instance;
+					p_instance->pending_func_states.add(&gdfs->instances_list);
+				} else {
+					gdfs->state.instance = nullptr;
+				}
+				GDScriptLanguage::singleton->lock.unlock();
+#ifdef DEBUG_ENABLED
+				gdfs->state.function_name = name;
+				gdfs->state.script_path = _script->get_path();
+#endif
+				//gdfs->state.result_pos=ip+ipofs-1;
+				gdfs->state.defarg = defarg;
+				gdfs->function = this;
+
+				retvalue = gdfs;
+
+				if (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
+					//do the oneshot connect
+					GET_VARIANT_PTR(argobj, 1);
+					GET_VARIANT_PTR(argname, 2);
+
+#ifdef DEBUG_ENABLED
+					if (argobj->get_type() != Variant::OBJECT) {
+						err_text = "First argument of yield() not of type object.";
+						OPCODE_BREAK;
+					}
+					if (argname->get_type() != Variant::STRING) {
+						err_text = "Second argument of yield() not a string (for signal name).";
+						OPCODE_BREAK;
+					}
+#endif
+
+					Object *obj = argobj->operator Object *();
+					String signal = argname->operator String();
+
+					if (argobj->is_invalid_object()) {
+						err_text = "First argument of yield() is a previously freed instance.";
+						OPCODE_BREAK;
+					}
+#ifdef DEBUG_ENABLED
+					if (!obj) {
+						err_text = "First argument of yield() is null.";
+						OPCODE_BREAK;
+					}
+					if (signal.length() == 0) {
+						err_text = "Second argument of yield() is an empty string (for signal name).";
+						OPCODE_BREAK;
+					}
+
+					Error err = obj->connect(signal, gdfs.ptr(), "_signal_callback", varray(gdfs), Object::CONNECT_ONESHOT);
+					if (err != OK) {
+						err_text = "Error connecting to signal: " + signal + " during yield().";
+						OPCODE_BREAK;
+					}
+#else
+					obj->connect(signal, gdfs.ptr(), "_signal_callback", varray(gdfs), Object::CONNECT_ONESHOT);
+#endif
+				}
+
+#ifdef DEBUG_ENABLED
+				exit_ok = true;
+				yielded = true;
+#endif
+				OPCODE_BREAK;
+			}
+
+			OPCODE(OPCODE_YIELD_RESUME) {
+				CHECK_SPACE(2);
+#ifdef DEBUG_ENABLED
+				if (!p_state) {
+					err_text = ("Invalid Resume (bug?)");
+					OPCODE_BREAK;
+				}
+#endif
+				GET_VARIANT_PTR(result, 1);
+				*result = p_state->result;
+				ip += 2;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_JUMP) {
+				CHECK_SPACE(2);
+				int to = _code_ptr[ip + 1];
+
+				GD_ERR_BREAK(to < 0 || to > _code_size);
+				ip = to;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_JUMP_IF) {
+				CHECK_SPACE(3);
+
+				GET_VARIANT_PTR(test, 1);
+
+				bool result = test->booleanize();
+
+				if (result) {
+					int to = _code_ptr[ip + 2];
+					GD_ERR_BREAK(to < 0 || to > _code_size);
+					ip = to;
+				} else {
+					ip += 3;
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_JUMP_IF_NOT) {
+				CHECK_SPACE(3);
+
+				GET_VARIANT_PTR(test, 1);
+
+				bool result = test->booleanize();
+
+				if (!result) {
+					int to = _code_ptr[ip + 2];
+					GD_ERR_BREAK(to < 0 || to > _code_size);
+					ip = to;
+				} else {
+					ip += 3;
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_JUMP_TO_DEF_ARGUMENT) {
+				CHECK_SPACE(2);
+				ip = _default_arg_ptr[defarg];
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_RETURN) {
+				CHECK_SPACE(2);
+				GET_VARIANT_PTR(r, 1);
+				retvalue = *r;
+#ifdef DEBUG_ENABLED
+				exit_ok = true;
+#endif
+				OPCODE_BREAK;
+			}
+
+			OPCODE(OPCODE_ITERATE_BEGIN) {
+				CHECK_SPACE(8); //space for this a regular iterate
+
+				GET_VARIANT_PTR(counter, 1);
+				GET_VARIANT_PTR(container, 2);
+
+				bool valid;
+				if (!container->iter_init(*counter, valid)) {
+#ifdef DEBUG_ENABLED
+					if (!valid) {
+						err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "'.";
+						OPCODE_BREAK;
+					}
+#endif
+					int jumpto = _code_ptr[ip + 3];
+					GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
+					ip = jumpto;
+				} else {
+					GET_VARIANT_PTR(iterator, 4);
+
+					*iterator = container->iter_get(*counter, valid);
+#ifdef DEBUG_ENABLED
+					if (!valid) {
+						err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "'.";
+						OPCODE_BREAK;
+					}
+#endif
+					ip += 5; //skip regular iterate which is always next
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ITERATE) {
+				CHECK_SPACE(4);
+
+				GET_VARIANT_PTR(counter, 1);
+				GET_VARIANT_PTR(container, 2);
+
+				bool valid;
+				if (!container->iter_next(*counter, valid)) {
+#ifdef DEBUG_ENABLED
+					if (!valid) {
+						err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "' (type changed since first iteration?).";
+						OPCODE_BREAK;
+					}
+#endif
+					int jumpto = _code_ptr[ip + 3];
+					GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
+					ip = jumpto;
+				} else {
+					GET_VARIANT_PTR(iterator, 4);
+
+					*iterator = container->iter_get(*counter, valid);
+#ifdef DEBUG_ENABLED
+					if (!valid) {
+						err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "' (but was obtained on first iteration?).";
+						OPCODE_BREAK;
+					}
+#endif
+					ip += 5; //loop again
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_ASSERT) {
+				CHECK_SPACE(3);
+
+#ifdef DEBUG_ENABLED
+				GET_VARIANT_PTR(test, 1);
+				bool result = test->booleanize();
+
+				if (!result) {
+					String message_str;
+					if (_code_ptr[ip + 2] != 0) {
+						GET_VARIANT_PTR(message, 2);
+						message_str = *message;
+					}
+					if (message_str.empty()) {
+						err_text = "Assertion failed.";
+					} else {
+						err_text = "Assertion failed: " + message_str;
+					}
+					OPCODE_BREAK;
+				}
+
+#endif
+				ip += 3;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_BREAKPOINT) {
+#ifdef DEBUG_ENABLED
+				if (ScriptDebugger::get_singleton()) {
+					GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
+				}
+#endif
+				ip += 1;
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_LINE) {
+				CHECK_SPACE(2);
+
+				line = _code_ptr[ip + 1];
+				ip += 2;
+
+				if (ScriptDebugger::get_singleton()) {
+					// line
+					bool do_break = false;
+
+					if (ScriptDebugger::get_singleton()->get_lines_left() > 0) {
+						if (ScriptDebugger::get_singleton()->get_depth() <= 0) {
+							ScriptDebugger::get_singleton()->set_lines_left(ScriptDebugger::get_singleton()->get_lines_left() - 1);
+						}
+						if (ScriptDebugger::get_singleton()->get_lines_left() <= 0) {
+							do_break = true;
+						}
+					}
+
+					if (ScriptDebugger::get_singleton()->is_breakpoint(line, source)) {
+						do_break = true;
+					}
+
+					if (do_break) {
+						GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
+					}
+
+					ScriptDebugger::get_singleton()->line_poll();
+				}
+			}
+			DISPATCH_OPCODE;
+
+			OPCODE(OPCODE_END) {
+#ifdef DEBUG_ENABLED
+				exit_ok = true;
+#endif
+				OPCODE_BREAK;
+			}
+
+#if 0 // Enable for debugging.
+			default: {
+				err_text = "Illegal opcode " + itos(_code_ptr[ip]) + " at address " + itos(ip);
+				OPCODE_BREAK;
+			}
+#endif
+		}
+
+		OPCODES_END
+#ifdef DEBUG_ENABLED
+		if (exit_ok) {
+			OPCODE_OUT;
+		}
+		//error
+		// function, file, line, error, explanation
+		String err_file;
+		if (p_instance && !instance.is_invalid_object() && p_instance->script->is_valid() && p_instance->script->path != "") {
+			err_file = p_instance->script->path;
+		} else if (script) {
+			err_file = script->path;
+		}
+		if (err_file == "") {
+			err_file = "<built-in>";
+		}
+		String err_func = name;
+		if (p_instance && !instance.is_invalid_object() && p_instance->script->is_valid() && p_instance->script->name != "") {
+			err_func = p_instance->script->name + "." + err_func;
+		}
+		int err_line = line;
+		if (err_text == "") {
+			err_text = "Internal script error! Opcode: " + itos(last_opcode) + " (please report).";
+		}
+
+		if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
+			// debugger break did not happen
+
+			_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), ERR_HANDLER_SCRIPT);
+		}
+
+#endif
+		OPCODE_OUT;
+	}
+
+	OPCODES_OUT
+#ifdef DEBUG_ENABLED
+	if (GDScriptLanguage::get_singleton()->profiling) {
+		uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time;
+		profile.total_time += time_taken;
+		profile.self_time += time_taken - function_call_time;
+		profile.frame_total_time += time_taken;
+		profile.frame_self_time += time_taken - function_call_time;
+		GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
+	}
+
+	// Check if this is the last time the function is resuming from yield
+	// Will be true if never yielded as well
+	// When it's the last resume it will postpone the exit from stack,
+	// so the debugger knows which function triggered the resume of the next function (if any)
+	if (!p_state || yielded) {
+		if (ScriptDebugger::get_singleton()) {
+			GDScriptLanguage::get_singleton()->exit_function();
+		}
+#endif
+
+		if (_stack_size) {
+			//free stack
+			for (int i = 0; i < _stack_size; i++) {
+				stack[i].~Variant();
+			}
+		}
+
+#ifdef DEBUG_ENABLED
+	}
+#endif
+
+	return retvalue;
+}
+
+const int *GDScriptFunction::get_code() const {
+	return _code_ptr;
+}
+int GDScriptFunction::get_code_size() const {
+	return _code_size;
+}
+
+Variant GDScriptFunction::get_constant(int p_idx) const {
+	ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>");
+	return constants[p_idx];
+}
+
+StringName GDScriptFunction::get_global_name(int p_idx) const {
+	ERR_FAIL_INDEX_V(p_idx, global_names.size(), "<errgname>");
+	return global_names[p_idx];
+}
+
+int GDScriptFunction::get_default_argument_count() const {
+	return _default_arg_count;
+}
+int GDScriptFunction::get_default_argument_addr(int p_idx) const {
+	ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), -1);
+	return default_arguments[p_idx];
+}
+
+GDScriptDataType GDScriptFunction::get_return_type() const {
+	return return_type;
+}
+
+GDScriptDataType GDScriptFunction::get_argument_type(int p_idx) const {
+	ERR_FAIL_INDEX_V(p_idx, argument_types.size(), GDScriptDataType());
+	return argument_types[p_idx];
+}
+
+StringName GDScriptFunction::get_name() const {
+	return name;
+}
+
+int GDScriptFunction::get_max_stack_size() const {
+	return _stack_size;
+}
+
+struct _GDFKC {
+	int order;
+	List<int> pos;
+};
+
+struct _GDFKCS {
+	int order;
+	StringName id;
+	int pos;
+
+	bool operator<(const _GDFKCS &p_r) const {
+		return order < p_r.order;
+	}
+};
+
+void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const {
+	int oc = 0;
+	Map<StringName, _GDFKC> sdmap;
+	for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) {
+		const StackDebug &sd = E->get();
+		if (sd.line > p_line) {
+			break;
+		}
+
+		if (sd.added) {
+			if (!sdmap.has(sd.identifier)) {
+				_GDFKC d;
+				d.order = oc++;
+				d.pos.push_back(sd.pos);
+				sdmap[sd.identifier] = d;
+
+			} else {
+				sdmap[sd.identifier].pos.push_back(sd.pos);
+			}
+		} else {
+			ERR_CONTINUE(!sdmap.has(sd.identifier));
+
+			sdmap[sd.identifier].pos.pop_back();
+			if (sdmap[sd.identifier].pos.empty()) {
+				sdmap.erase(sd.identifier);
+			}
+		}
+	}
+
+	List<_GDFKCS> stackpositions;
+	for (Map<StringName, _GDFKC>::Element *E = sdmap.front(); E; E = E->next()) {
+		_GDFKCS spp;
+		spp.id = E->key();
+		spp.order = E->get().order;
+		spp.pos = E->get().pos.back()->get();
+		stackpositions.push_back(spp);
+	}
+
+	stackpositions.sort();
+
+	for (List<_GDFKCS>::Element *E = stackpositions.front(); E; E = E->next()) {
+		Pair<StringName, int> p;
+		p.first = E->get().id;
+		p.second = E->get().pos;
+		r_stackvars->push_back(p);
+	}
+}
+
+GDScriptFunction::GDScriptFunction() :
+		function_list(this) {
+	_stack_size = 0;
+	_call_size = 0;
+	rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+	name = "<anonymous>";
+#ifdef DEBUG_ENABLED
+	_func_cname = nullptr;
+
+	GDScriptLanguage::get_singleton()->lock.lock();
+	GDScriptLanguage::get_singleton()->function_list.add(&function_list);
+	GDScriptLanguage::get_singleton()->lock.unlock();
+
+	profile.call_count = 0;
+	profile.self_time = 0;
+	profile.total_time = 0;
+	profile.frame_call_count = 0;
+	profile.frame_self_time = 0;
+	profile.frame_total_time = 0;
+	profile.last_frame_call_count = 0;
+	profile.last_frame_self_time = 0;
+	profile.last_frame_total_time = 0;
+
+#endif
+}
+
+GDScriptFunction::~GDScriptFunction() {
+#ifdef DEBUG_ENABLED
+	GDScriptLanguage::get_singleton()->lock.lock();
+	GDScriptLanguage::get_singleton()->function_list.remove(&function_list);
+	GDScriptLanguage::get_singleton()->lock.unlock();
+#endif
+}
+
+/////////////////////
+
+Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	Variant arg;
+	r_error.error = Variant::CallError::CALL_OK;
+
+	if (p_argcount == 0) {
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+		r_error.argument = 1;
+		return Variant();
+	} else if (p_argcount == 1) {
+		//noooneee
+	} else if (p_argcount == 2) {
+		arg = *p_args[0];
+	} else {
+		Array extra_args;
+		for (int i = 0; i < p_argcount - 1; i++) {
+			extra_args.push_back(*p_args[i]);
+		}
+		arg = extra_args;
+	}
+
+	Ref<GDScriptFunctionState> self = *p_args[p_argcount - 1];
+
+	if (self.is_null()) {
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+		r_error.argument = p_argcount - 1;
+		r_error.expected = Variant::OBJECT;
+		return Variant();
+	}
+
+	return resume(arg);
+}
+
+bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
+	if (function == nullptr) {
+		return false;
+	}
+
+	if (p_extended_check) {
+#ifndef NO_THREADS
+		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+#endif
+		// Script gone?
+		if (!scripts_list.in_list()) {
+			return false;
+		}
+		// Class instance gone? (if not static function)
+		if (state.instance && !instances_list.in_list()) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+Variant GDScriptFunctionState::resume(const Variant &p_arg) {
+	ERR_FAIL_COND_V(!function, Variant());
+	{
+#ifndef NO_THREADS
+		MutexLock lock(GDScriptLanguage::singleton->lock);
+#endif
+		if (!scripts_list.in_list()) {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after yield, but script is gone. At script: " + state.script_path + ":" + itos(state.line));
+#else
+			return Variant();
+#endif
+		}
+		if (state.instance && !instances_list.in_list()) {
+#ifdef DEBUG_ENABLED
+			ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after yield, but class instance is gone. At script: " + state.script_path + ":" + itos(state.line));
+#else
+			return Variant();
+#endif
+		}
+		// Do these now to avoid locking again after the call
+		scripts_list.remove_from_list();
+		instances_list.remove_from_list();
+	}
+
+	state.result = p_arg;
+	Variant::CallError err;
+	Variant ret = function->call(nullptr, nullptr, 0, err, &state);
+
+	bool completed = true;
+
+	// If the return value is a GDScriptFunctionState reference,
+	// then the function did yield again after resuming.
+	if (ret.is_ref()) {
+		GDScriptFunctionState *gdfs = Object::cast_to<GDScriptFunctionState>(ret);
+		if (gdfs && gdfs->function == function) {
+			completed = false;
+			gdfs->first_state = first_state.is_valid() ? first_state : Ref<GDScriptFunctionState>(this);
+		}
+	}
+
+	function = nullptr; //cleaned up;
+	state.result = Variant();
+
+	if (completed) {
+		if (first_state.is_valid()) {
+			first_state->emit_signal("completed", ret);
+		} else {
+			emit_signal("completed", ret);
+		}
+
+#ifdef DEBUG_ENABLED
+		if (ScriptDebugger::get_singleton()) {
+			GDScriptLanguage::get_singleton()->exit_function();
+		}
+#endif
+	}
+
+	return ret;
+}
+
+void GDScriptFunctionState::_clear_stack() {
+	if (state.stack_size) {
+		Variant *stack = (Variant *)state.stack.ptr();
+		for (int i = 0; i < state.stack_size; i++) {
+			stack[i].~Variant();
+		}
+		state.stack_size = 0;
+	}
+}
+
+void GDScriptFunctionState::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("resume", "arg"), &GDScriptFunctionState::resume, DEFVAL(Variant()));
+	ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDScriptFunctionState::is_valid, DEFVAL(false));
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDScriptFunctionState::_signal_callback, MethodInfo("_signal_callback"));
+
+	ADD_SIGNAL(MethodInfo("completed", PropertyInfo(Variant::NIL, "result", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
+}
+
+GDScriptFunctionState::GDScriptFunctionState() :
+		scripts_list(this),
+		instances_list(this) {
+	function = nullptr;
+}
+
+GDScriptFunctionState::~GDScriptFunctionState() {
+	_clear_stack();
+	GDScriptLanguage::singleton->lock.lock();
+	scripts_list.remove_from_list();
+	instances_list.remove_from_list();
+	GDScriptLanguage::singleton->lock.unlock();
+}
diff --git a/modules/cscript/cscript_function.h b/modules/cscript/cscript_function.h
new file mode 100644
index 000000000..5954560a9
--- /dev/null
+++ b/modules/cscript/cscript_function.h
@@ -0,0 +1,389 @@
+#ifndef CSCRIPT_FUNCTION_H
+#define CSCRIPT_FUNCTION_H
+/*************************************************************************/
+/*  gdscript_function.h                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/os/thread.h"
+#include "core/pair.h"
+#include "core/reference.h"
+#include "core/script_language.h"
+#include "core/self_list.h"
+#include "core/string_name.h"
+#include "core/variant.h"
+
+class GDScriptInstance;
+class GDScript;
+
+struct GDScriptDataType {
+	bool has_type;
+	enum {
+		UNINITIALIZED,
+		BUILTIN,
+		NATIVE,
+		SCRIPT,
+		GDSCRIPT,
+	} kind;
+	Variant::Type builtin_type;
+	StringName native_type;
+	Script *script_type;
+	Ref<Script> script_type_ref;
+
+	bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
+		if (!has_type) {
+			return true; // Can't type check
+		}
+
+		switch (kind) {
+			case UNINITIALIZED:
+				break;
+			case BUILTIN: {
+				Variant::Type var_type = p_variant.get_type();
+				bool valid = builtin_type == var_type;
+				if (!valid && p_allow_implicit_conversion) {
+					valid = Variant::can_convert_strict(var_type, builtin_type);
+				}
+				return valid;
+			} break;
+			case NATIVE: {
+				if (p_variant.get_type() == Variant::NIL) {
+					return true;
+				}
+				if (p_variant.get_type() != Variant::OBJECT) {
+					return false;
+				}
+
+				Object *obj = p_variant.operator Object *();
+				if (!obj) {
+					return false;
+				}
+
+				if (!ClassDB::is_parent_class(obj->get_class_name(), native_type)) {
+					// Try with underscore prefix
+					StringName underscore_native_type = "_" + native_type;
+					if (!ClassDB::is_parent_class(obj->get_class_name(), underscore_native_type)) {
+						return false;
+					}
+				}
+				return true;
+			} break;
+			case SCRIPT:
+			case GDSCRIPT: {
+				if (p_variant.get_type() == Variant::NIL) {
+					return true;
+				}
+				if (p_variant.get_type() != Variant::OBJECT) {
+					return false;
+				}
+
+				Object *obj = p_variant.operator Object *();
+				if (!obj) {
+					return false;
+				}
+
+				Ref<Script> base = obj && obj->get_script_instance() ? obj->get_script_instance()->get_script() : nullptr;
+				bool valid = false;
+				while (base.is_valid()) {
+					if (base == script_type) {
+						valid = true;
+						break;
+					}
+					base = base->get_base_script();
+				}
+				return valid;
+			} break;
+		}
+		return false;
+	}
+
+	operator PropertyInfo() const {
+		PropertyInfo info;
+		if (has_type) {
+			switch (kind) {
+				case UNINITIALIZED:
+					break;
+				case BUILTIN: {
+					info.type = builtin_type;
+				} break;
+				case NATIVE: {
+					info.type = Variant::OBJECT;
+					info.class_name = native_type;
+				} break;
+				case SCRIPT:
+				case GDSCRIPT: {
+					info.type = Variant::OBJECT;
+					info.class_name = script_type->get_instance_base_type();
+				} break;
+			}
+		} else {
+			info.type = Variant::NIL;
+			info.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+		}
+		return info;
+	}
+
+	GDScriptDataType() :
+			has_type(false),
+			kind(UNINITIALIZED),
+			builtin_type(Variant::NIL),
+			script_type(nullptr) {}
+};
+
+class GDScriptFunction {
+public:
+	enum Opcode {
+		OPCODE_OPERATOR,
+		OPCODE_EXTENDS_TEST,
+		OPCODE_IS_BUILTIN,
+		OPCODE_SET,
+		OPCODE_GET,
+		OPCODE_SET_NAMED,
+		OPCODE_GET_NAMED,
+		OPCODE_SET_MEMBER,
+		OPCODE_GET_MEMBER,
+		OPCODE_ASSIGN,
+		OPCODE_ASSIGN_TRUE,
+		OPCODE_ASSIGN_FALSE,
+		OPCODE_ASSIGN_TYPED_BUILTIN,
+		OPCODE_ASSIGN_TYPED_NATIVE,
+		OPCODE_ASSIGN_TYPED_SCRIPT,
+		OPCODE_CAST_TO_BUILTIN,
+		OPCODE_CAST_TO_NATIVE,
+		OPCODE_CAST_TO_SCRIPT,
+		OPCODE_CONSTRUCT, //only for basic types!!
+		OPCODE_CONSTRUCT_ARRAY,
+		OPCODE_CONSTRUCT_DICTIONARY,
+		OPCODE_CALL,
+		OPCODE_CALL_RETURN,
+		OPCODE_CALL_BUILT_IN,
+		OPCODE_CALL_SELF,
+		OPCODE_CALL_SELF_BASE,
+		OPCODE_YIELD,
+		OPCODE_YIELD_SIGNAL,
+		OPCODE_YIELD_RESUME,
+		OPCODE_JUMP,
+		OPCODE_JUMP_IF,
+		OPCODE_JUMP_IF_NOT,
+		OPCODE_JUMP_TO_DEF_ARGUMENT,
+		OPCODE_RETURN,
+		OPCODE_ITERATE_BEGIN,
+		OPCODE_ITERATE,
+		OPCODE_ASSERT,
+		OPCODE_BREAKPOINT,
+		OPCODE_LINE,
+		OPCODE_END
+	};
+
+	enum Address {
+		ADDR_BITS = 24,
+		ADDR_MASK = ((1 << ADDR_BITS) - 1),
+		ADDR_TYPE_MASK = ~ADDR_MASK,
+		ADDR_TYPE_SELF = 0,
+		ADDR_TYPE_CLASS = 1,
+		ADDR_TYPE_MEMBER = 2,
+		ADDR_TYPE_CLASS_CONSTANT = 3,
+		ADDR_TYPE_LOCAL_CONSTANT = 4,
+		ADDR_TYPE_STACK = 5,
+		ADDR_TYPE_STACK_VARIABLE = 6,
+		ADDR_TYPE_GLOBAL = 7,
+		ADDR_TYPE_NAMED_GLOBAL = 8,
+		ADDR_TYPE_NIL = 9
+	};
+
+	struct StackDebug {
+		int line;
+		int pos;
+		bool added;
+		StringName identifier;
+	};
+
+private:
+	friend class GDScriptCompiler;
+
+	StringName source;
+
+	mutable Variant nil;
+	mutable Variant *_constants_ptr;
+	int _constant_count;
+	const StringName *_global_names_ptr;
+	int _global_names_count;
+#ifdef TOOLS_ENABLED
+	const StringName *_named_globals_ptr;
+	int _named_globals_count;
+#endif
+	const int *_default_arg_ptr;
+	int _default_arg_count;
+	const int *_code_ptr;
+	int _code_size;
+	int _argument_count;
+	int _stack_size;
+	int _call_size;
+	int _initial_line;
+	bool _static;
+	MultiplayerAPI::RPCMode rpc_mode;
+
+	GDScript *_script;
+
+	StringName name;
+	Vector<Variant> constants;
+	Vector<StringName> global_names;
+#ifdef TOOLS_ENABLED
+	Vector<StringName> named_globals;
+#endif
+	Vector<int> default_arguments;
+	Vector<int> code;
+	Vector<GDScriptDataType> argument_types;
+	GDScriptDataType return_type;
+
+#ifdef TOOLS_ENABLED
+	Vector<StringName> arg_names;
+#endif
+
+	List<StackDebug> stack_debug;
+
+	_FORCE_INLINE_ Variant *_get_variant(int p_address, GDScriptInstance *p_instance, GDScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const;
+	_FORCE_INLINE_ String _get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const;
+
+	friend class GDScriptLanguage;
+
+	SelfList<GDScriptFunction> function_list;
+#ifdef DEBUG_ENABLED
+	CharString func_cname;
+	const char *_func_cname;
+
+	struct Profile {
+		StringName signature;
+		uint64_t call_count;
+		uint64_t self_time;
+		uint64_t total_time;
+		uint64_t frame_call_count;
+		uint64_t frame_self_time;
+		uint64_t frame_total_time;
+		uint64_t last_frame_call_count;
+		uint64_t last_frame_self_time;
+		uint64_t last_frame_total_time;
+	} profile;
+
+#endif
+
+public:
+	struct CallState {
+		GDScript *script;
+		GDScriptInstance *instance;
+#ifdef DEBUG_ENABLED
+		StringName function_name;
+		String script_path;
+#endif
+		Vector<uint8_t> stack;
+		int stack_size;
+		Variant self;
+		uint32_t alloca_size;
+		int ip;
+		int line;
+		int defarg;
+		Variant result;
+	};
+
+	_FORCE_INLINE_ bool is_static() const {
+		return _static;
+	}
+
+	const int *get_code() const; //used for debug
+	int get_code_size() const;
+	Variant get_constant(int p_idx) const;
+	StringName get_global_name(int p_idx) const;
+	StringName get_name() const;
+	int get_max_stack_size() const;
+	int get_default_argument_count() const;
+	int get_default_argument_addr(int p_idx) const;
+	GDScriptDataType get_return_type() const;
+	GDScriptDataType get_argument_type(int p_idx) const;
+	GDScript *get_script() const {
+		return _script;
+	}
+	StringName get_source() const {
+		return source;
+	}
+
+	void debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const;
+
+	_FORCE_INLINE_ bool is_empty() const {
+		return _code_size == 0;
+	}
+
+	int get_argument_count() const {
+		return _argument_count;
+	}
+	StringName get_argument_name(int p_idx) const {
+#ifdef TOOLS_ENABLED
+		ERR_FAIL_INDEX_V(p_idx, arg_names.size(), StringName());
+		return arg_names[p_idx];
+#else
+		return StringName();
+#endif
+	}
+	Variant get_default_argument(int p_idx) const {
+		ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), Variant());
+		return default_arguments[p_idx];
+	}
+
+	Variant call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state = nullptr);
+
+	_FORCE_INLINE_ MultiplayerAPI::RPCMode get_rpc_mode() const {
+		return rpc_mode;
+	}
+	GDScriptFunction();
+	~GDScriptFunction();
+};
+
+class GDScriptFunctionState : public Reference {
+	GDCLASS(GDScriptFunctionState, Reference);
+	friend class GDScriptFunction;
+	GDScriptFunction *function;
+	GDScriptFunction::CallState state;
+	Variant _signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	Ref<GDScriptFunctionState> first_state;
+
+	SelfList<GDScriptFunctionState> scripts_list;
+	SelfList<GDScriptFunctionState> instances_list;
+
+protected:
+	static void _bind_methods();
+
+public:
+	bool is_valid(bool p_extended_check = false) const;
+	Variant resume(const Variant &p_arg = Variant());
+
+	void _clear_stack();
+
+	GDScriptFunctionState();
+	~GDScriptFunctionState();
+};
+
+#endif // GDSCRIPT_FUNCTION_H
diff --git a/modules/cscript/cscript_functions.cpp b/modules/cscript/cscript_functions.cpp
new file mode 100644
index 000000000..f2eff8e4d
--- /dev/null
+++ b/modules/cscript/cscript_functions.cpp
@@ -0,0 +1,1984 @@
+/*************************************************************************/
+/*  gdscript_functions.cpp                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript_functions.h"
+
+#include "core/class_db.h"
+#include "core/func_ref.h"
+#include "core/io/json.h"
+#include "core/io/marshalls.h"
+#include "core/math/math_funcs.h"
+#include "core/os/os.h"
+#include "core/reference.h"
+#include "core/variant_parser.h"
+#include "cscript.h"
+
+const char *GDScriptFunctions::get_func_name(Function p_func) {
+	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, "");
+
+	static const char *_names[FUNC_MAX] = {
+		"sin",
+		"cos",
+		"tan",
+		"sinh",
+		"cosh",
+		"tanh",
+		"asin",
+		"acos",
+		"atan",
+		"atan2",
+		"sqrt",
+		"fmod",
+		"fposmod",
+		"posmod",
+		"floor",
+		"ceil",
+		"round",
+		"abs",
+		"sign",
+		"pow",
+		"log",
+		"exp",
+		"is_nan",
+		"is_inf",
+		"is_equal_approx",
+		"is_zero_approx",
+		"ease",
+		"decimals",
+		"step_decimals",
+		"stepify",
+		"lerp",
+		"lerp_angle",
+		"inverse_lerp",
+		"range_lerp",
+		"smoothstep",
+		"move_toward",
+		"dectime",
+		"randomize",
+		"randi",
+		"randf",
+		"rand_range",
+		"seed",
+		"rand_seed",
+		"deg2rad",
+		"rad2deg",
+		"linear2db",
+		"db2linear",
+		"polar2cartesian",
+		"cartesian2polar",
+		"wrapi",
+		"wrapf",
+		"max",
+		"min",
+		"clamp",
+		"nearest_po2",
+		"weakref",
+		"funcref",
+		"convert",
+		"typeof",
+		"type_exists",
+		"char",
+		"ord",
+		"str",
+		"print",
+		"printt",
+		"prints",
+		"printerr",
+		"printraw",
+		"print_debug",
+		"push_error",
+		"push_warning",
+		"var2str",
+		"str2var",
+		"var2bytes",
+		"bytes2var",
+		"range",
+		"load",
+		"inst2dict",
+		"dict2inst",
+		"validate_json",
+		"parse_json",
+		"to_json",
+		"hash",
+		"Color8",
+		"ColorN",
+		"print_stack",
+		"get_stack",
+		"instance_from_id",
+		"len",
+		"is_instance_valid",
+		"deep_equal",
+	};
+
+	return _names[p_func];
+}
+
+void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) {
+	r_error.error = Variant::CallError::CALL_OK;
+#ifdef DEBUG_ENABLED
+
+#define VALIDATE_ARG_COUNT(m_count)                                        \
+	if (p_arg_count < m_count) {                                           \
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;  \
+		r_error.argument = m_count;                                        \
+		r_ret = Variant();                                                 \
+		return;                                                            \
+	}                                                                      \
+	if (p_arg_count > m_count) {                                           \
+		r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; \
+		r_error.argument = m_count;                                        \
+		r_ret = Variant();                                                 \
+		return;                                                            \
+	}
+
+#define VALIDATE_ARG_NUM(m_arg)                                          \
+	if (!p_args[m_arg]->is_num()) {                                      \
+		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
+		r_error.argument = m_arg;                                        \
+		r_error.expected = Variant::REAL;                                \
+		r_ret = Variant();                                               \
+		return;                                                          \
+	}
+
+#else
+
+#define VALIDATE_ARG_COUNT(m_count)
+#define VALIDATE_ARG_NUM(m_arg)
+#endif
+
+	//using a switch, so the compiler generates a jumptable
+
+	switch (p_func) {
+		case MATH_SIN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::sin((double)*p_args[0]);
+		} break;
+		case MATH_COS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::cos((double)*p_args[0]);
+		} break;
+		case MATH_TAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::tan((double)*p_args[0]);
+		} break;
+		case MATH_SINH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::sinh((double)*p_args[0]);
+		} break;
+		case MATH_COSH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::cosh((double)*p_args[0]);
+		} break;
+		case MATH_TANH: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::tanh((double)*p_args[0]);
+		} break;
+		case MATH_ASIN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::asin((double)*p_args[0]);
+		} break;
+		case MATH_ACOS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::acos((double)*p_args[0]);
+		} break;
+		case MATH_ATAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::atan((double)*p_args[0]);
+		} break;
+		case MATH_ATAN2: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::atan2((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_SQRT: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::sqrt((double)*p_args[0]);
+		} break;
+		case MATH_FMOD: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::fmod((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_FPOSMOD: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::fposmod((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_POSMOD: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::posmod((int64_t)*p_args[0], (int64_t)*p_args[1]);
+		} break;
+		case MATH_FLOOR: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::floor((double)*p_args[0]);
+		} break;
+		case MATH_CEIL: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::ceil((double)*p_args[0]);
+		} break;
+		case MATH_ROUND: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::round((double)*p_args[0]);
+		} break;
+		case MATH_ABS: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() == Variant::INT) {
+				int64_t i = *p_args[0];
+				r_ret = ABS(i);
+			} else if (p_args[0]->get_type() == Variant::REAL) {
+				double r = *p_args[0];
+				r_ret = Math::abs(r);
+			} else {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+				r_ret = Variant();
+			}
+		} break;
+		case MATH_SIGN: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() == Variant::INT) {
+				int64_t i = *p_args[0];
+				r_ret = i < 0 ? -1 : (i > 0 ? +1 : 0);
+			} else if (p_args[0]->get_type() == Variant::REAL) {
+				double r = *p_args[0];
+				r_ret = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
+			} else {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::REAL;
+				r_ret = Variant();
+			}
+		} break;
+		case MATH_POW: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::pow((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_LOG: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::log((double)*p_args[0]);
+		} break;
+		case MATH_EXP: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::exp((double)*p_args[0]);
+		} break;
+		case MATH_ISNAN: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::is_nan((double)*p_args[0]);
+		} break;
+		case MATH_ISINF: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::is_inf((double)*p_args[0]);
+		} break;
+		case MATH_ISEQUALAPPROX: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::is_equal_approx((real_t)*p_args[0], (real_t)*p_args[1]);
+		} break;
+		case MATH_ISZEROAPPROX: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::is_zero_approx((real_t)*p_args[0]);
+		} break;
+		case MATH_EASE: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::ease((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_DECIMALS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::step_decimals((double)*p_args[0]);
+			WARN_DEPRECATED_MSG("GDScript method 'decimals' is deprecated and has been renamed to 'step_decimals', please update your code accordingly.");
+		} break;
+		case MATH_STEP_DECIMALS: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::step_decimals((double)*p_args[0]);
+		} break;
+		case MATH_STEPIFY: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::stepify((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_LERP: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(2);
+			const double t = (double)*p_args[2];
+			switch (p_args[0]->get_type() == p_args[1]->get_type() ? p_args[0]->get_type() : Variant::REAL) {
+				case Variant::VECTOR2: {
+					r_ret = ((Vector2)*p_args[0]).linear_interpolate((Vector2)*p_args[1], t);
+				} break;
+				case Variant::VECTOR3: {
+					r_ret = ((Vector3)*p_args[0]).linear_interpolate((Vector3)*p_args[1], t);
+				} break;
+				case Variant::COLOR: {
+					r_ret = ((Color)*p_args[0]).linear_interpolate((Color)*p_args[1], t);
+				} break;
+				default: {
+					VALIDATE_ARG_NUM(0);
+					VALIDATE_ARG_NUM(1);
+					r_ret = Math::lerp((double)*p_args[0], (double)*p_args[1], t);
+				} break;
+			}
+		} break;
+		case MATH_LERP_ANGLE: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::lerp_angle((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case MATH_INVERSE_LERP: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::inverse_lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case MATH_RANGE_LERP: {
+			VALIDATE_ARG_COUNT(5);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			VALIDATE_ARG_NUM(3);
+			VALIDATE_ARG_NUM(4);
+			r_ret = Math::range_lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2], (double)*p_args[3], (double)*p_args[4]);
+		} break;
+		case MATH_SMOOTHSTEP: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::smoothstep((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case MATH_MOVE_TOWARD: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::move_toward((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case MATH_DECTIME: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::dectime((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case MATH_RANDOMIZE: {
+			VALIDATE_ARG_COUNT(0);
+			Math::randomize();
+			r_ret = Variant();
+		} break;
+		case MATH_RAND: {
+			VALIDATE_ARG_COUNT(0);
+			r_ret = Math::rand();
+		} break;
+		case MATH_RANDF: {
+			VALIDATE_ARG_COUNT(0);
+			r_ret = Math::randf();
+		} break;
+		case MATH_RANDOM: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			r_ret = Math::random((double)*p_args[0], (double)*p_args[1]);
+		} break;
+		case MATH_SEED: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			uint64_t seed = *p_args[0];
+			Math::seed(seed);
+			r_ret = Variant();
+		} break;
+		case MATH_RANDSEED: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			uint64_t seed = *p_args[0];
+			int ret = Math::rand_from_seed(&seed);
+			Array reta;
+			reta.push_back(ret);
+			reta.push_back(seed);
+			r_ret = reta;
+
+		} break;
+		case MATH_DEG2RAD: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::deg2rad((double)*p_args[0]);
+		} break;
+		case MATH_RAD2DEG: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::rad2deg((double)*p_args[0]);
+		} break;
+		case MATH_LINEAR2DB: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::linear2db((double)*p_args[0]);
+		} break;
+		case MATH_DB2LINEAR: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			r_ret = Math::db2linear((double)*p_args[0]);
+		} break;
+		case MATH_POLAR2CARTESIAN: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			double r = *p_args[0];
+			double th = *p_args[1];
+			r_ret = Vector2(r * Math::cos(th), r * Math::sin(th));
+		} break;
+		case MATH_CARTESIAN2POLAR: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			double x = *p_args[0];
+			double y = *p_args[1];
+			r_ret = Vector2(Math::sqrt(x * x + y * y), Math::atan2(y, x));
+		} break;
+		case MATH_WRAP: {
+			VALIDATE_ARG_COUNT(3);
+			r_ret = Math::wrapi((int64_t)*p_args[0], (int64_t)*p_args[1], (int64_t)*p_args[2]);
+		} break;
+		case MATH_WRAPF: {
+			VALIDATE_ARG_COUNT(3);
+			r_ret = Math::wrapf((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
+		case LOGIC_MAX: {
+			VALIDATE_ARG_COUNT(2);
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				r_ret = MAX(a, b);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+
+				double a = *p_args[0];
+				double b = *p_args[1];
+
+				r_ret = MAX(a, b);
+			}
+
+		} break;
+		case LOGIC_MIN: {
+			VALIDATE_ARG_COUNT(2);
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				r_ret = MIN(a, b);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+
+				double a = *p_args[0];
+				double b = *p_args[1];
+
+				r_ret = MIN(a, b);
+			}
+		} break;
+		case LOGIC_CLAMP: {
+			VALIDATE_ARG_COUNT(3);
+			if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT && p_args[2]->get_type() == Variant::INT) {
+				int64_t a = *p_args[0];
+				int64_t b = *p_args[1];
+				int64_t c = *p_args[2];
+				r_ret = CLAMP(a, b, c);
+			} else {
+				VALIDATE_ARG_NUM(0);
+				VALIDATE_ARG_NUM(1);
+				VALIDATE_ARG_NUM(2);
+
+				double a = *p_args[0];
+				double b = *p_args[1];
+				double c = *p_args[2];
+
+				r_ret = CLAMP(a, b, c);
+			}
+		} break;
+		case LOGIC_NEAREST_PO2: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			int64_t num = *p_args[0];
+			r_ret = next_power_of_2(num);
+		} break;
+		case OBJ_WEAKREF: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() == Variant::OBJECT) {
+				if (p_args[0]->is_ref()) {
+					Ref<WeakRef> wref = memnew(WeakRef);
+					REF r = *p_args[0];
+					if (r.is_valid()) {
+						wref->set_ref(r);
+					}
+					r_ret = wref;
+				} else {
+					Ref<WeakRef> wref = memnew(WeakRef);
+					Object *obj = *p_args[0];
+					if (obj) {
+						wref->set_obj(obj);
+					}
+					r_ret = wref;
+				}
+			} else if (p_args[0]->get_type() == Variant::NIL) {
+				Ref<WeakRef> wref = memnew(WeakRef);
+				r_ret = wref;
+			} else {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
+				return;
+			}
+		} break;
+		case FUNC_FUNCREF: {
+			VALIDATE_ARG_COUNT(2);
+			if (p_args[0]->get_type() != Variant::OBJECT) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
+				return;
+			}
+			if (p_args[1]->get_type() != Variant::STRING && p_args[1]->get_type() != Variant::NODE_PATH) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 1;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				return;
+			}
+
+			Ref<FuncRef> fr = memnew(FuncRef);
+
+			fr->set_instance(*p_args[0]);
+			fr->set_function(*p_args[1]);
+
+			r_ret = fr;
+
+		} break;
+		case TYPE_CONVERT: {
+			VALIDATE_ARG_COUNT(2);
+			VALIDATE_ARG_NUM(1);
+			int type = *p_args[1];
+			if (type < 0 || type >= Variant::VARIANT_MAX) {
+				r_ret = RTR("Invalid type argument to convert(), use TYPE_* constants.");
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
+				return;
+
+			} else {
+				r_ret = Variant::construct(Variant::Type(type), p_args, 1, r_error);
+			}
+		} break;
+		case TYPE_OF: {
+			VALIDATE_ARG_COUNT(1);
+			r_ret = p_args[0]->get_type();
+
+		} break;
+		case TYPE_EXISTS: {
+			VALIDATE_ARG_COUNT(1);
+			r_ret = ClassDB::class_exists(*p_args[0]);
+
+		} break;
+		case TEXT_CHAR: {
+			VALIDATE_ARG_COUNT(1);
+			VALIDATE_ARG_NUM(0);
+			CharType result[2] = { *p_args[0], 0 };
+			r_ret = String(result);
+		} break;
+		case TEXT_ORD: {
+			VALIDATE_ARG_COUNT(1);
+
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				return;
+			}
+
+			String str = p_args[0]->operator String();
+
+			if (str.length() != 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = RTR("Expected a string of length 1 (a character).");
+				return;
+			}
+
+			r_ret = str.get(0);
+
+		} break;
+		case TEXT_STR: {
+			if (p_arg_count < 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 1;
+				r_ret = Variant();
+
+				return;
+			}
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				String os = p_args[i]->operator String();
+
+				if (i == 0) {
+					str = os;
+				} else {
+					str += os;
+				}
+			}
+
+			r_ret = str;
+
+		} break;
+		case TEXT_PRINT: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				str += p_args[i]->operator String();
+			}
+
+			print_line(str);
+			r_ret = Variant();
+
+		} break;
+		case TEXT_PRINT_TABBED: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				if (i) {
+					str += "\t";
+				}
+				str += p_args[i]->operator String();
+			}
+
+			print_line(str);
+			r_ret = Variant();
+
+		} break;
+		case TEXT_PRINT_SPACED: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				if (i) {
+					str += " ";
+				}
+				str += p_args[i]->operator String();
+			}
+
+			print_line(str);
+			r_ret = Variant();
+
+		} break;
+
+		case TEXT_PRINTERR: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				str += p_args[i]->operator String();
+			}
+
+			print_error(str);
+			r_ret = Variant();
+
+		} break;
+		case TEXT_PRINTRAW: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				str += p_args[i]->operator String();
+			}
+
+			OS::get_singleton()->print("%s", str.utf8().get_data());
+			r_ret = Variant();
+
+		} break;
+		case TEXT_PRINT_DEBUG: {
+			String str;
+			for (int i = 0; i < p_arg_count; i++) {
+				str += p_args[i]->operator String();
+			}
+
+			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			if (script->debug_get_stack_level_count() > 0) {
+				str += "\n   At: " + script->debug_get_stack_level_source(0) + ":" + itos(script->debug_get_stack_level_line(0)) + ":" + script->debug_get_stack_level_function(0) + "()";
+			}
+
+			print_line(str);
+			r_ret = Variant();
+		} break;
+		case PUSH_ERROR: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				break;
+			}
+
+			String message = *p_args[0];
+			ERR_PRINT(message);
+			r_ret = Variant();
+		} break;
+		case PUSH_WARNING: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				break;
+			}
+
+			String message = *p_args[0];
+			WARN_PRINT(message);
+			r_ret = Variant();
+		} break;
+		case VAR_TO_STR: {
+			VALIDATE_ARG_COUNT(1);
+			String vars;
+			VariantWriter::write_to_string(*p_args[0], vars);
+			r_ret = vars;
+		} break;
+		case STR_TO_VAR: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				return;
+			}
+			r_ret = *p_args[0];
+
+			VariantParser::StreamString ss;
+			ss.s = *p_args[0];
+
+			String errs;
+			int line;
+			(void)VariantParser::parse(&ss, r_ret, errs, line);
+		} break;
+		case VAR_TO_BYTES: {
+			bool full_objects = false;
+			if (p_arg_count < 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 1;
+				r_ret = Variant();
+				return;
+			} else if (p_arg_count > 2) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 2;
+				r_ret = Variant();
+			} else if (p_arg_count == 2) {
+				if (p_args[1]->get_type() != Variant::BOOL) {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 1;
+					r_error.expected = Variant::BOOL;
+					r_ret = Variant();
+					return;
+				}
+				full_objects = *p_args[1];
+			}
+
+			PoolByteArray barr;
+			int len;
+			Error err = encode_variant(*p_args[0], nullptr, len, full_objects);
+			if (err) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::NIL;
+				r_ret = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
+				return;
+			}
+
+			barr.resize(len);
+			{
+				PoolByteArray::Write w = barr.write();
+				encode_variant(*p_args[0], w.ptr(), len, full_objects);
+			}
+			r_ret = barr;
+		} break;
+		case BYTES_TO_VAR: {
+			bool allow_objects = false;
+			if (p_arg_count < 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 1;
+				r_ret = Variant();
+				return;
+			} else if (p_arg_count > 2) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 2;
+				r_ret = Variant();
+			} else if (p_arg_count == 2) {
+				if (p_args[1]->get_type() != Variant::BOOL) {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 1;
+					r_error.expected = Variant::BOOL;
+					r_ret = Variant();
+					return;
+				}
+				allow_objects = *p_args[1];
+			}
+
+			if (p_args[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 1;
+				r_error.expected = Variant::POOL_BYTE_ARRAY;
+				r_ret = Variant();
+				return;
+			}
+
+			PoolByteArray varr = *p_args[0];
+			Variant ret;
+			{
+				PoolByteArray::Read r = varr.read();
+				Error err = decode_variant(ret, r.ptr(), varr.size(), nullptr, allow_objects);
+				if (err != OK) {
+					r_ret = RTR("Not enough bytes for decoding bytes, or invalid format.");
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::POOL_BYTE_ARRAY;
+					return;
+				}
+			}
+
+			r_ret = ret;
+
+		} break;
+		case GEN_RANGE: {
+			switch (p_arg_count) {
+				case 0: {
+					r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+					r_error.argument = 1;
+					r_ret = Variant();
+
+				} break;
+				case 1: {
+					VALIDATE_ARG_NUM(0);
+					int count = *p_args[0];
+					Array arr;
+					if (count <= 0) {
+						r_ret = arr;
+						return;
+					}
+					Error err = arr.resize(count);
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
+						return;
+					}
+
+					for (int i = 0; i < count; i++) {
+						arr[i] = i;
+					}
+
+					r_ret = arr;
+				} break;
+				case 2: {
+					VALIDATE_ARG_NUM(0);
+					VALIDATE_ARG_NUM(1);
+
+					int from = *p_args[0];
+					int to = *p_args[1];
+
+					Array arr;
+					if (from >= to) {
+						r_ret = arr;
+						return;
+					}
+					Error err = arr.resize(to - from);
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
+						return;
+					}
+					for (int i = from; i < to; i++) {
+						arr[i - from] = i;
+					}
+					r_ret = arr;
+				} break;
+				case 3: {
+					VALIDATE_ARG_NUM(0);
+					VALIDATE_ARG_NUM(1);
+					VALIDATE_ARG_NUM(2);
+
+					int from = *p_args[0];
+					int to = *p_args[1];
+					int incr = *p_args[2];
+					if (incr == 0) {
+						r_ret = RTR("Step argument is zero!");
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						return;
+					}
+
+					Array arr;
+					if (from >= to && incr > 0) {
+						r_ret = arr;
+						return;
+					}
+					if (from <= to && incr < 0) {
+						r_ret = arr;
+						return;
+					}
+
+					//calculate how many
+					int count = 0;
+					if (incr > 0) {
+						count = ((to - from - 1) / incr) + 1;
+					} else {
+						count = ((from - to - 1) / -incr) + 1;
+					}
+
+					Error err = arr.resize(count);
+
+					if (err != OK) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+						r_ret = Variant();
+						return;
+					}
+
+					if (incr > 0) {
+						int idx = 0;
+						for (int i = from; i < to; i += incr) {
+							arr[idx++] = i;
+						}
+					} else {
+						int idx = 0;
+						for (int i = from; i > to; i += incr) {
+							arr[idx++] = i;
+						}
+					}
+
+					r_ret = arr;
+				} break;
+				default: {
+					r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+					r_error.argument = 3;
+					r_ret = Variant();
+
+				} break;
+			}
+
+		} break;
+		case RESOURCE_LOAD: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+			} else {
+				r_ret = ResourceLoader::load(*p_args[0]);
+			}
+
+		} break;
+		case INST2DICT: {
+			VALIDATE_ARG_COUNT(1);
+
+			if (p_args[0]->get_type() == Variant::NIL) {
+				r_ret = Variant();
+			} else if (p_args[0]->get_type() != Variant::OBJECT) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_ret = Variant();
+			} else {
+				Object *obj = *p_args[0];
+				if (!obj) {
+					r_ret = Variant();
+
+				} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != GDScriptLanguage::get_singleton()) {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::DICTIONARY;
+					r_ret = RTR("Not a script with an instance");
+					return;
+				} else {
+					GDScriptInstance *ins = static_cast<GDScriptInstance *>(obj->get_script_instance());
+					Ref<GDScript> base = ins->get_script();
+					if (base.is_null()) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+						r_error.argument = 0;
+						r_error.expected = Variant::DICTIONARY;
+						r_ret = RTR("Not based on a script");
+						return;
+					}
+
+					GDScript *p = base.ptr();
+					Vector<StringName> sname;
+
+					while (p->_owner) {
+						sname.push_back(p->name);
+						p = p->_owner;
+					}
+					sname.invert();
+
+					if (!p->path.is_resource_file()) {
+						r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+						r_error.argument = 0;
+						r_error.expected = Variant::DICTIONARY;
+						r_ret = Variant();
+
+						r_ret = RTR("Not based on a resource file");
+
+						return;
+					}
+
+					NodePath cp(sname, Vector<StringName>(), false);
+
+					Dictionary d;
+					d["@subpath"] = cp;
+					d["@path"] = p->get_path();
+
+					for (Map<StringName, GDScript::MemberInfo>::Element *E = base->member_indices.front(); E; E = E->next()) {
+						if (!d.has(E->key())) {
+							d[E->key()] = ins->members[E->get().index];
+						}
+					}
+					r_ret = d;
+				}
+			}
+
+		} break;
+		case DICT2INST: {
+			VALIDATE_ARG_COUNT(1);
+
+			if (p_args[0]->get_type() != Variant::DICTIONARY) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::DICTIONARY;
+				r_ret = Variant();
+
+				return;
+			}
+
+			Dictionary d = *p_args[0];
+
+			if (!d.has("@path")) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = RTR("Invalid instance dictionary format (missing @path)");
+
+				return;
+			}
+
+			Ref<Script> scr = ResourceLoader::load(d["@path"]);
+			if (!scr.is_valid()) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = RTR("Invalid instance dictionary format (can't load script at @path)");
+				return;
+			}
+
+			Ref<GDScript> gdscr = scr;
+
+			if (!gdscr.is_valid()) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::OBJECT;
+				r_ret = Variant();
+				r_ret = RTR("Invalid instance dictionary format (invalid script at @path)");
+				return;
+			}
+
+			NodePath sub;
+			if (d.has("@subpath")) {
+				sub = d["@subpath"];
+			}
+
+			for (int i = 0; i < sub.get_name_count(); i++) {
+				gdscr = gdscr->subclasses[sub.get_name(i)];
+				if (!gdscr.is_valid()) {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::OBJECT;
+					r_ret = Variant();
+					r_ret = RTR("Invalid instance dictionary (invalid subclasses)");
+					return;
+				}
+			}
+
+			r_ret = gdscr->_new(nullptr, 0, r_error);
+
+			if (r_error.error != Variant::CallError::CALL_OK) {
+				r_ret = Variant();
+				return;
+			}
+
+			GDScriptInstance *ins = static_cast<GDScriptInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
+			Ref<GDScript> gd_ref = ins->get_script();
+
+			for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
+				if (d.has(E->key())) {
+					ins->members.write[E->get().index] = d[E->key()];
+				}
+			}
+
+		} break;
+		case VALIDATE_JSON: {
+			VALIDATE_ARG_COUNT(1);
+
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				return;
+			}
+
+			String errs;
+			int errl;
+
+			Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
+
+			if (err != OK) {
+				r_ret = itos(errl) + ":" + errs;
+			} else {
+				r_ret = "";
+			}
+
+		} break;
+		case PARSE_JSON: {
+			VALIDATE_ARG_COUNT(1);
+
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::STRING;
+				r_ret = Variant();
+				return;
+			}
+
+			String errs;
+			int errl;
+
+			Error err = JSON::parse(*p_args[0], r_ret, errs, errl);
+
+			if (err != OK) {
+				r_ret = Variant();
+				ERR_PRINT(vformat("Error parsing JSON at line %s: %s", errl, errs));
+			}
+
+		} break;
+		case TO_JSON: {
+			VALIDATE_ARG_COUNT(1);
+
+			r_ret = JSON::print(*p_args[0]);
+		} break;
+		case HASH: {
+			VALIDATE_ARG_COUNT(1);
+			r_ret = p_args[0]->hash();
+
+		} break;
+		case COLOR8: {
+			if (p_arg_count < 3) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 3;
+				r_ret = Variant();
+
+				return;
+			}
+			if (p_arg_count > 4) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 4;
+				r_ret = Variant();
+
+				return;
+			}
+
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+
+			Color color((float)*p_args[0] / 255.0f, (float)*p_args[1] / 255.0f, (float)*p_args[2] / 255.0f);
+
+			if (p_arg_count == 4) {
+				VALIDATE_ARG_NUM(3);
+				color.a = (float)*p_args[3] / 255.0f;
+			}
+
+			r_ret = color;
+
+		} break;
+		case COLORN: {
+			if (p_arg_count < 1) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+				r_error.argument = 1;
+				r_ret = Variant();
+				return;
+			}
+
+			if (p_arg_count > 2) {
+				r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+				r_error.argument = 2;
+				r_ret = Variant();
+				return;
+			}
+
+			if (p_args[0]->get_type() != Variant::STRING) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_ret = Variant();
+			} else {
+				Color color = Color::named(*p_args[0]);
+				if (p_arg_count == 2) {
+					VALIDATE_ARG_NUM(1);
+					color.a = *p_args[1];
+				}
+				r_ret = color;
+			}
+
+		} break;
+
+		case PRINT_STACK: {
+			VALIDATE_ARG_COUNT(0);
+
+			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
+				print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
+			};
+		} break;
+
+		case GET_STACK: {
+			VALIDATE_ARG_COUNT(0);
+
+			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			Array ret;
+			for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
+				Dictionary frame;
+				frame["source"] = script->debug_get_stack_level_source(i);
+				frame["function"] = script->debug_get_stack_level_function(i);
+				frame["line"] = script->debug_get_stack_level_line(i);
+				ret.push_back(frame);
+			};
+			r_ret = ret;
+		} break;
+
+		case INSTANCE_FROM_ID: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::INT && p_args[0]->get_type() != Variant::REAL) {
+				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+				r_error.argument = 0;
+				r_error.expected = Variant::INT;
+				r_ret = Variant();
+				break;
+			}
+
+			uint32_t id = *p_args[0];
+			r_ret = ObjectDB::get_instance(id);
+
+		} break;
+		case LEN: {
+			VALIDATE_ARG_COUNT(1);
+			switch (p_args[0]->get_type()) {
+				case Variant::STRING: {
+					String d = *p_args[0];
+					r_ret = d.length();
+				} break;
+				case Variant::DICTIONARY: {
+					Dictionary d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::ARRAY: {
+					Array d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_BYTE_ARRAY: {
+					PoolVector<uint8_t> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_INT_ARRAY: {
+					PoolVector<int> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_REAL_ARRAY: {
+					PoolVector<real_t> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_STRING_ARRAY: {
+					PoolVector<String> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_VECTOR2_ARRAY: {
+					PoolVector<Vector2> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_VECTOR2I_ARRAY: {
+					PoolVector<Vector2i> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_VECTOR3_ARRAY: {
+					PoolVector<Vector3> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_VECTOR3I_ARRAY: {
+					PoolVector<Vector3i> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				case Variant::POOL_COLOR_ARRAY: {
+					PoolVector<Color> d = *p_args[0];
+					r_ret = d.size();
+				} break;
+				default: {
+					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+					r_error.argument = 0;
+					r_error.expected = Variant::OBJECT;
+					r_ret = Variant();
+					r_ret = RTR("Object can't provide a length.");
+				}
+			}
+
+		} break;
+		case IS_INSTANCE_VALID: {
+			VALIDATE_ARG_COUNT(1);
+			if (p_args[0]->get_type() != Variant::OBJECT) {
+				r_ret = false;
+			} else {
+				Object *obj = *p_args[0];
+				r_ret = obj != nullptr;
+			}
+
+		} break;
+		case DEEP_EQUAL: {
+			VALIDATE_ARG_COUNT(2);
+			r_ret = p_args[0]->deep_equal(*p_args[1]);
+		} break;
+		case FUNC_MAX: {
+			ERR_FAIL();
+		} break;
+	}
+}
+
+bool GDScriptFunctions::is_deterministic(Function p_func) {
+	//man i couldn't have chosen a worse function name,
+	//way too controversial..
+
+	switch (p_func) {
+		case MATH_SIN:
+		case MATH_COS:
+		case MATH_TAN:
+		case MATH_SINH:
+		case MATH_COSH:
+		case MATH_TANH:
+		case MATH_ASIN:
+		case MATH_ACOS:
+		case MATH_ATAN:
+		case MATH_ATAN2:
+		case MATH_SQRT:
+		case MATH_FMOD:
+		case MATH_FPOSMOD:
+		case MATH_POSMOD:
+		case MATH_FLOOR:
+		case MATH_CEIL:
+		case MATH_ROUND:
+		case MATH_ABS:
+		case MATH_SIGN:
+		case MATH_POW:
+		case MATH_LOG:
+		case MATH_EXP:
+		case MATH_ISNAN:
+		case MATH_ISINF:
+		case MATH_EASE:
+		case MATH_DECIMALS:
+		case MATH_STEP_DECIMALS:
+		case MATH_STEPIFY:
+		case MATH_LERP:
+		case MATH_INVERSE_LERP:
+		case MATH_RANGE_LERP:
+		case MATH_SMOOTHSTEP:
+		case MATH_MOVE_TOWARD:
+		case MATH_DECTIME:
+		case MATH_DEG2RAD:
+		case MATH_RAD2DEG:
+		case MATH_LINEAR2DB:
+		case MATH_DB2LINEAR:
+		case MATH_POLAR2CARTESIAN:
+		case MATH_CARTESIAN2POLAR:
+		case MATH_WRAP:
+		case MATH_WRAPF:
+		case LOGIC_MAX:
+		case LOGIC_MIN:
+		case LOGIC_CLAMP:
+		case LOGIC_NEAREST_PO2:
+		case TYPE_CONVERT:
+		case TYPE_OF:
+		case TYPE_EXISTS:
+		case TEXT_CHAR:
+		case TEXT_ORD:
+		case TEXT_STR:
+		case COLOR8:
+		case LEN:
+			// enable for debug only, otherwise not desirable - case GEN_RANGE:
+			return true;
+		default:
+			return false;
+	}
+
+	return false;
+}
+
+MethodInfo GDScriptFunctions::get_info(Function p_func) {
+#ifdef DEBUG_ENABLED
+	//using a switch, so the compiler generates a jumptable
+
+	switch (p_func) {
+		case MATH_SIN: {
+			MethodInfo mi("sin", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+
+		} break;
+		case MATH_COS: {
+			MethodInfo mi("cos", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_TAN: {
+			MethodInfo mi("tan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_SINH: {
+			MethodInfo mi("sinh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_COSH: {
+			MethodInfo mi("cosh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_TANH: {
+			MethodInfo mi("tanh", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ASIN: {
+			MethodInfo mi("asin", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ACOS: {
+			MethodInfo mi("acos", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ATAN: {
+			MethodInfo mi("atan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ATAN2: {
+			MethodInfo mi("atan2", PropertyInfo(Variant::REAL, "y"), PropertyInfo(Variant::REAL, "x"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_SQRT: {
+			MethodInfo mi("sqrt", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_FMOD: {
+			MethodInfo mi("fmod", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_FPOSMOD: {
+			MethodInfo mi("fposmod", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_POSMOD: {
+			MethodInfo mi("posmod", PropertyInfo(Variant::INT, "a"), PropertyInfo(Variant::INT, "b"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case MATH_FLOOR: {
+			MethodInfo mi("floor", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_CEIL: {
+			MethodInfo mi("ceil", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ROUND: {
+			MethodInfo mi("round", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ABS: {
+			MethodInfo mi("abs", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_SIGN: {
+			MethodInfo mi("sign", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_POW: {
+			MethodInfo mi("pow", PropertyInfo(Variant::REAL, "base"), PropertyInfo(Variant::REAL, "exp"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_LOG: {
+			MethodInfo mi("log", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_EXP: {
+			MethodInfo mi("exp", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_ISNAN: {
+			MethodInfo mi("is_nan", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		case MATH_ISINF: {
+			MethodInfo mi("is_inf", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		case MATH_ISEQUALAPPROX: {
+			MethodInfo mi("is_equal_approx", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		case MATH_ISZEROAPPROX: {
+			MethodInfo mi("is_zero_approx", PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		case MATH_EASE: {
+			MethodInfo mi("ease", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "curve"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_DECIMALS: {
+			MethodInfo mi("decimals", PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case MATH_STEP_DECIMALS: {
+			MethodInfo mi("step_decimals", PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case MATH_STEPIFY: {
+			MethodInfo mi("stepify", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_LERP: {
+			MethodInfo mi("lerp", PropertyInfo(Variant::NIL, "from"), PropertyInfo(Variant::NIL, "to"), PropertyInfo(Variant::REAL, "weight"));
+			mi.return_val.type = Variant::NIL;
+			mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+			return mi;
+		} break;
+		case MATH_LERP_ANGLE: {
+			MethodInfo mi("lerp_angle", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_INVERSE_LERP: {
+			MethodInfo mi("inverse_lerp", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_RANGE_LERP: {
+			MethodInfo mi("range_lerp", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "istart"), PropertyInfo(Variant::REAL, "istop"), PropertyInfo(Variant::REAL, "ostart"), PropertyInfo(Variant::REAL, "ostop"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_SMOOTHSTEP: {
+			MethodInfo mi("smoothstep", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "s"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_MOVE_TOWARD: {
+			MethodInfo mi("move_toward", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "delta"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_DECTIME: {
+			MethodInfo mi("dectime", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "amount"), PropertyInfo(Variant::REAL, "step"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_RANDOMIZE: {
+			MethodInfo mi("randomize");
+			mi.return_val.type = Variant::NIL;
+			return mi;
+		} break;
+		case MATH_RAND: {
+			MethodInfo mi("randi");
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case MATH_RANDF: {
+			MethodInfo mi("randf");
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_RANDOM: {
+			MethodInfo mi("rand_range", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_SEED: {
+			MethodInfo mi("seed", PropertyInfo(Variant::INT, "seed"));
+			mi.return_val.type = Variant::NIL;
+			return mi;
+		} break;
+		case MATH_RANDSEED: {
+			MethodInfo mi("rand_seed", PropertyInfo(Variant::INT, "seed"));
+			mi.return_val.type = Variant::ARRAY;
+			return mi;
+		} break;
+		case MATH_DEG2RAD: {
+			MethodInfo mi("deg2rad", PropertyInfo(Variant::REAL, "deg"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_RAD2DEG: {
+			MethodInfo mi("rad2deg", PropertyInfo(Variant::REAL, "rad"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_LINEAR2DB: {
+			MethodInfo mi("linear2db", PropertyInfo(Variant::REAL, "nrg"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_DB2LINEAR: {
+			MethodInfo mi("db2linear", PropertyInfo(Variant::REAL, "db"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case MATH_POLAR2CARTESIAN: {
+			MethodInfo mi("polar2cartesian", PropertyInfo(Variant::REAL, "r"), PropertyInfo(Variant::REAL, "th"));
+			mi.return_val.type = Variant::VECTOR2;
+			return mi;
+		} break;
+		case MATH_CARTESIAN2POLAR: {
+			MethodInfo mi("cartesian2polar", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
+			mi.return_val.type = Variant::VECTOR2;
+			return mi;
+		} break;
+		case MATH_WRAP: {
+			MethodInfo mi("wrapi", PropertyInfo(Variant::INT, "value"), PropertyInfo(Variant::INT, "min"), PropertyInfo(Variant::INT, "max"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case MATH_WRAPF: {
+			MethodInfo mi("wrapf", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "min"), PropertyInfo(Variant::REAL, "max"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case LOGIC_MAX: {
+			MethodInfo mi("max", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+
+		} break;
+		case LOGIC_MIN: {
+			MethodInfo mi("min", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case LOGIC_CLAMP: {
+			MethodInfo mi("clamp", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "min"), PropertyInfo(Variant::REAL, "max"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
+		case LOGIC_NEAREST_PO2: {
+			MethodInfo mi("nearest_po2", PropertyInfo(Variant::INT, "value"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case OBJ_WEAKREF: {
+			MethodInfo mi("weakref", PropertyInfo(Variant::OBJECT, "obj"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.class_name = "WeakRef";
+
+			return mi;
+
+		} break;
+		case FUNC_FUNCREF: {
+			MethodInfo mi("funcref", PropertyInfo(Variant::OBJECT, "instance"), PropertyInfo(Variant::STRING, "funcname"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.class_name = "FuncRef";
+			return mi;
+
+		} break;
+		case TYPE_CONVERT: {
+			MethodInfo mi("convert", PropertyInfo(Variant::NIL, "what", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT), PropertyInfo(Variant::INT, "type"));
+			mi.return_val.type = Variant::NIL;
+			mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+			return mi;
+		} break;
+		case TYPE_OF: {
+			MethodInfo mi("typeof", PropertyInfo(Variant::NIL, "what", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT));
+			mi.return_val.type = Variant::INT;
+			return mi;
+
+		} break;
+		case TYPE_EXISTS: {
+			MethodInfo mi("type_exists", PropertyInfo(Variant::STRING, "type"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+
+		} break;
+		case TEXT_CHAR: {
+			MethodInfo mi("char", PropertyInfo(Variant::INT, "code"));
+			mi.return_val.type = Variant::STRING;
+			return mi;
+
+		} break;
+		case TEXT_ORD: {
+			MethodInfo mi("ord", PropertyInfo(Variant::STRING, "char"));
+			mi.return_val.type = Variant::INT;
+			return mi;
+
+		} break;
+		case TEXT_STR: {
+			MethodInfo mi("str");
+			mi.return_val.type = Variant::STRING;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINT: {
+			MethodInfo mi("print");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINT_TABBED: {
+			MethodInfo mi("printt");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINT_SPACED: {
+			MethodInfo mi("prints");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINTERR: {
+			MethodInfo mi("printerr");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINTRAW: {
+			MethodInfo mi("printraw");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case TEXT_PRINT_DEBUG: {
+			MethodInfo mi("print_debug");
+			mi.return_val.type = Variant::NIL;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+
+		} break;
+		case PUSH_ERROR: {
+			MethodInfo mi(Variant::NIL, "push_error", PropertyInfo(Variant::STRING, "message"));
+			mi.return_val.type = Variant::NIL;
+			return mi;
+
+		} break;
+		case PUSH_WARNING: {
+			MethodInfo mi(Variant::NIL, "push_warning", PropertyInfo(Variant::STRING, "message"));
+			mi.return_val.type = Variant::NIL;
+			return mi;
+
+		} break;
+		case VAR_TO_STR: {
+			MethodInfo mi("var2str", PropertyInfo(Variant::NIL, "var", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT));
+			mi.return_val.type = Variant::STRING;
+			return mi;
+		} break;
+		case STR_TO_VAR: {
+			MethodInfo mi(Variant::NIL, "str2var", PropertyInfo(Variant::STRING, "string"));
+			mi.return_val.type = Variant::NIL;
+			mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+			return mi;
+		} break;
+		case VAR_TO_BYTES: {
+			MethodInfo mi("var2bytes", PropertyInfo(Variant::NIL, "var", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT), PropertyInfo(Variant::BOOL, "full_objects"));
+			mi.default_arguments.push_back(false);
+			mi.return_val.type = Variant::POOL_BYTE_ARRAY;
+			return mi;
+		} break;
+		case BYTES_TO_VAR: {
+			MethodInfo mi(Variant::NIL, "bytes2var", PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes"), PropertyInfo(Variant::BOOL, "allow_objects"));
+			mi.default_arguments.push_back(false);
+			mi.return_val.type = Variant::NIL;
+			mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+			return mi;
+		} break;
+		case GEN_RANGE: {
+			MethodInfo mi("range");
+			mi.return_val.type = Variant::ARRAY;
+			mi.flags |= METHOD_FLAG_VARARG;
+			return mi;
+		} break;
+		case RESOURCE_LOAD: {
+			MethodInfo mi("load", PropertyInfo(Variant::STRING, "path"));
+			mi.return_val.type = Variant::OBJECT;
+			mi.return_val.class_name = "Resource";
+			return mi;
+		} break;
+		case INST2DICT: {
+			MethodInfo mi("inst2dict", PropertyInfo(Variant::OBJECT, "inst"));
+			mi.return_val.type = Variant::DICTIONARY;
+			return mi;
+		} break;
+		case DICT2INST: {
+			MethodInfo mi("dict2inst", PropertyInfo(Variant::DICTIONARY, "dict"));
+			mi.return_val.type = Variant::OBJECT;
+			return mi;
+		} break;
+		case VALIDATE_JSON: {
+			MethodInfo mi("validate_json", PropertyInfo(Variant::STRING, "json"));
+			mi.return_val.type = Variant::STRING;
+			return mi;
+		} break;
+		case PARSE_JSON: {
+			MethodInfo mi(Variant::NIL, "parse_json", PropertyInfo(Variant::STRING, "json"));
+			mi.return_val.type = Variant::NIL;
+			mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+			return mi;
+		} break;
+		case TO_JSON: {
+			MethodInfo mi("to_json", PropertyInfo(Variant::NIL, "var", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT));
+			mi.return_val.type = Variant::STRING;
+			return mi;
+		} break;
+		case HASH: {
+			MethodInfo mi("hash", PropertyInfo(Variant::NIL, "var", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case COLOR8: {
+			MethodInfo mi("Color8", PropertyInfo(Variant::INT, "r8"), PropertyInfo(Variant::INT, "g8"), PropertyInfo(Variant::INT, "b8"), PropertyInfo(Variant::INT, "a8"));
+			mi.default_arguments.push_back(255);
+			mi.return_val.type = Variant::COLOR;
+			return mi;
+		} break;
+		case COLORN: {
+			MethodInfo mi("ColorN", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::REAL, "alpha"));
+			mi.default_arguments.push_back(1.0f);
+			mi.return_val.type = Variant::COLOR;
+			return mi;
+		} break;
+
+		case PRINT_STACK: {
+			MethodInfo mi("print_stack");
+			mi.return_val.type = Variant::NIL;
+			return mi;
+		} break;
+		case GET_STACK: {
+			MethodInfo mi("get_stack");
+			mi.return_val.type = Variant::ARRAY;
+			return mi;
+		} break;
+
+		case INSTANCE_FROM_ID: {
+			MethodInfo mi("instance_from_id", PropertyInfo(Variant::INT, "instance_id"));
+			mi.return_val.type = Variant::OBJECT;
+			return mi;
+		} break;
+		case LEN: {
+			MethodInfo mi("len", PropertyInfo(Variant::NIL, "var", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_NIL_IS_VARIANT));
+			mi.return_val.type = Variant::INT;
+			return mi;
+		} break;
+		case IS_INSTANCE_VALID: {
+			MethodInfo mi("is_instance_valid", PropertyInfo(Variant::OBJECT, "instance"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		case DEEP_EQUAL: {
+			MethodInfo mi("deep_equal", PropertyInfo(Variant::NIL, "a"), PropertyInfo(Variant::NIL, "b"));
+			mi.return_val.type = Variant::BOOL;
+			return mi;
+		} break;
+		default: {
+			ERR_FAIL_V(MethodInfo());
+		} break;
+	}
+#endif
+	MethodInfo mi;
+	mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+	return mi;
+}
diff --git a/modules/cscript/cscript_functions.h b/modules/cscript/cscript_functions.h
new file mode 100644
index 000000000..a7dbf11cf
--- /dev/null
+++ b/modules/cscript/cscript_functions.h
@@ -0,0 +1,138 @@
+#ifndef CSCRIPT_FUNCTIONS_H
+#define CSCRIPT_FUNCTIONS_H
+/*************************************************************************/
+/*  gdscript_functions.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/variant.h"
+
+class GDScriptFunctions {
+public:
+	enum Function {
+		MATH_SIN,
+		MATH_COS,
+		MATH_TAN,
+		MATH_SINH,
+		MATH_COSH,
+		MATH_TANH,
+		MATH_ASIN,
+		MATH_ACOS,
+		MATH_ATAN,
+		MATH_ATAN2,
+		MATH_SQRT,
+		MATH_FMOD,
+		MATH_FPOSMOD,
+		MATH_POSMOD,
+		MATH_FLOOR,
+		MATH_CEIL,
+		MATH_ROUND,
+		MATH_ABS,
+		MATH_SIGN,
+		MATH_POW,
+		MATH_LOG,
+		MATH_EXP,
+		MATH_ISNAN,
+		MATH_ISINF,
+		MATH_ISEQUALAPPROX,
+		MATH_ISZEROAPPROX,
+		MATH_EASE,
+		MATH_DECIMALS,
+		MATH_STEP_DECIMALS,
+		MATH_STEPIFY,
+		MATH_LERP,
+		MATH_LERP_ANGLE,
+		MATH_INVERSE_LERP,
+		MATH_RANGE_LERP,
+		MATH_SMOOTHSTEP,
+		MATH_MOVE_TOWARD,
+		MATH_DECTIME,
+		MATH_RANDOMIZE,
+		MATH_RAND,
+		MATH_RANDF,
+		MATH_RANDOM,
+		MATH_SEED,
+		MATH_RANDSEED,
+		MATH_DEG2RAD,
+		MATH_RAD2DEG,
+		MATH_LINEAR2DB,
+		MATH_DB2LINEAR,
+		MATH_POLAR2CARTESIAN,
+		MATH_CARTESIAN2POLAR,
+		MATH_WRAP,
+		MATH_WRAPF,
+		LOGIC_MAX,
+		LOGIC_MIN,
+		LOGIC_CLAMP,
+		LOGIC_NEAREST_PO2,
+		OBJ_WEAKREF,
+		FUNC_FUNCREF,
+		TYPE_CONVERT,
+		TYPE_OF,
+		TYPE_EXISTS,
+		TEXT_CHAR,
+		TEXT_ORD,
+		TEXT_STR,
+		TEXT_PRINT,
+		TEXT_PRINT_TABBED,
+		TEXT_PRINT_SPACED,
+		TEXT_PRINTERR,
+		TEXT_PRINTRAW,
+		TEXT_PRINT_DEBUG,
+		PUSH_ERROR,
+		PUSH_WARNING,
+		VAR_TO_STR,
+		STR_TO_VAR,
+		VAR_TO_BYTES,
+		BYTES_TO_VAR,
+		GEN_RANGE,
+		RESOURCE_LOAD,
+		INST2DICT,
+		DICT2INST,
+		VALIDATE_JSON,
+		PARSE_JSON,
+		TO_JSON,
+		HASH,
+		COLOR8,
+		COLORN,
+		PRINT_STACK,
+		GET_STACK,
+		INSTANCE_FROM_ID,
+		LEN,
+		IS_INSTANCE_VALID,
+		DEEP_EQUAL,
+		FUNC_MAX
+	};
+
+	static const char *get_func_name(Function p_func);
+	static void call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error);
+	static bool is_deterministic(Function p_func);
+	static MethodInfo get_info(Function p_func);
+};
+
+#endif // GDSCRIPT_FUNCTIONS_H
diff --git a/modules/cscript/cscript_parser.cpp b/modules/cscript/cscript_parser.cpp
new file mode 100644
index 000000000..f7651d716
--- /dev/null
+++ b/modules/cscript/cscript_parser.cpp
@@ -0,0 +1,8926 @@
+/*************************************************************************/
+/*  gdscript_parser.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript_parser.h"
+
+#include "core/core_string_names.h"
+#include "core/engine.h"
+#include "core/io/resource_loader.h"
+#include "core/os/file_access.h"
+#include "core/print_string.h"
+#include "core/project_settings.h"
+#include "core/reference.h"
+#include "core/script_language.h"
+#include "cscript.h"
+
+template <class T>
+T *GDScriptParser::alloc_node() {
+	T *t = memnew(T);
+
+	t->next = list;
+	list = t;
+
+	if (!head) {
+		head = t;
+	}
+
+	t->line = tokenizer->get_token_line();
+	t->column = tokenizer->get_token_column();
+	return t;
+}
+
+#ifdef DEBUG_ENABLED
+static String _find_function_name(const GDScriptParser::OperatorNode *p_call);
+#endif // DEBUG_ENABLED
+
+bool GDScriptParser::_end_statement() {
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
+		tokenizer->advance();
+		return true; //handle next
+	} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+		return true; //will be handled properly
+	}
+
+	return false;
+}
+
+void GDScriptParser::_set_end_statement_error(String p_name) {
+	String error_msg;
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER) {
+		error_msg = vformat("Expected end of statement (\"%s\"), got %s (\"%s\") instead.", p_name, tokenizer->get_token_name(tokenizer->get_token()), tokenizer->get_token_identifier());
+	} else {
+		error_msg = vformat("Expected end of statement (\"%s\"), got %s instead.", p_name, tokenizer->get_token_name(tokenizer->get_token()));
+	}
+	_set_error(error_msg);
+}
+
+bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
+	if (tokenizer->get_token() != GDScriptTokenizer::TK_COLON) {
+		// report location at the previous token (on the previous line)
+		int error_line = tokenizer->get_token_line(-1);
+		int error_column = tokenizer->get_token_column(-1);
+		_set_error("':' expected at end of line.", error_line, error_column);
+		return false;
+	}
+	tokenizer->advance();
+
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+		return false;
+	}
+
+	if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
+		// be more python-like
+		IndentLevel current_level = indent_level.back()->get();
+		indent_level.push_back(current_level);
+		return true;
+		//_set_error("newline expected after ':'.");
+		//return false;
+	}
+
+	while (true) {
+		if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
+			return false; //wtf
+		} else if (tokenizer->get_token(1) == GDScriptTokenizer::TK_EOF) {
+			return false;
+		} else if (tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
+			int indent = tokenizer->get_token_line_indent();
+			int tabs = tokenizer->get_token_line_tab_indent();
+			IndentLevel current_level = indent_level.back()->get();
+			IndentLevel new_indent(indent, tabs);
+			if (new_indent.is_mixed(current_level)) {
+				_set_error("Mixed tabs and spaces in indentation.");
+				return false;
+			}
+
+			if (indent <= current_level.indent) {
+				return false;
+			}
+
+			indent_level.push_back(new_indent);
+			tokenizer->advance();
+			return true;
+
+		} else if (p_block) {
+			NewLineNode *nl = alloc_node<NewLineNode>();
+			nl->line = tokenizer->get_token_line();
+			p_block->statements.push_back(nl);
+		}
+
+		tokenizer->advance(); // go to next newline
+	}
+}
+
+bool GDScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete, bool p_parsing_constant) {
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+		tokenizer->advance();
+	} else {
+		parenthesis++;
+		int argidx = 0;
+
+		while (true) {
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+				_make_completable_call(argidx);
+				completion_node = p_parent;
+			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
+				//completing a string argument..
+				completion_cursor = tokenizer->get_token_constant();
+
+				_make_completable_call(argidx);
+				completion_node = p_parent;
+				tokenizer->advance(1);
+				return false;
+			}
+
+			Node *arg = _parse_expression(p_parent, p_static, false, p_parsing_constant);
+			if (!arg) {
+				return false;
+			}
+
+			p_args.push_back(arg);
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				tokenizer->advance();
+				break;
+
+			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token(1) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+					_set_error("Expression expected");
+					return false;
+				}
+
+				tokenizer->advance();
+				argidx++;
+			} else {
+				// something is broken
+				_set_error("Expected ',' or ')'");
+				return false;
+			}
+		}
+		parenthesis--;
+	}
+
+	return true;
+}
+
+void GDScriptParser::_make_completable_call(int p_arg) {
+	completion_cursor = StringName();
+	completion_type = COMPLETION_CALL_ARGUMENTS;
+	completion_class = current_class;
+	completion_function = current_function;
+	completion_line = tokenizer->get_token_line();
+	completion_argument = p_arg;
+	completion_block = current_block;
+	completion_found = true;
+	tokenizer->advance();
+}
+
+bool GDScriptParser::_get_completable_identifier(CompletionType p_type, StringName &identifier) {
+	identifier = StringName();
+	if (tokenizer->is_token_literal()) {
+		identifier = tokenizer->get_token_literal();
+		tokenizer->advance();
+	}
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+		completion_cursor = identifier;
+		completion_type = p_type;
+		completion_class = current_class;
+		completion_function = current_function;
+		completion_line = tokenizer->get_token_line();
+		completion_block = current_block;
+		completion_found = true;
+		completion_ident_is_call = false;
+		tokenizer->advance();
+
+		if (tokenizer->is_token_literal()) {
+			identifier = identifier.operator String() + tokenizer->get_token_literal().operator String();
+			tokenizer->advance();
+		}
+
+		if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+			completion_ident_is_call = true;
+		}
+		return true;
+	}
+
+	return false;
+}
+
+GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign, bool p_parsing_constant) {
+	//Vector<Node*> expressions;
+	//Vector<OperatorNode::Operator> operators;
+
+	Vector<Expression> expression;
+
+	Node *expr = nullptr;
+
+	int op_line = tokenizer->get_token_line(); // when operators are created at the bottom, the line might have been changed (\n found)
+
+	while (true) {
+		/*****************/
+		/* Parse Operand */
+		/*****************/
+
+		if (parenthesis > 0) {
+			//remove empty space (only allowed if inside parenthesis
+			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+				tokenizer->advance();
+			}
+		}
+
+		// Check that the next token is not TK_CURSOR and if it is, the offset should be incremented.
+		int next_valid_offset = 1;
+		if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_CURSOR) {
+			next_valid_offset++;
+			// There is a chunk of the identifier that also needs to be ignored (not always there!)
+			if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_IDENTIFIER) {
+				next_valid_offset++;
+			}
+		}
+
+		if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+			//subexpression ()
+			tokenizer->advance();
+			parenthesis++;
+			Node *subexpr = _parse_expression(p_parent, p_static, p_allow_assign, p_parsing_constant);
+			parenthesis--;
+			if (!subexpr) {
+				return nullptr;
+			}
+
+			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				_set_error("Expected ')' in expression");
+				return nullptr;
+			}
+
+			tokenizer->advance();
+			expr = subexpr;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_DOLLAR) {
+			tokenizer->advance();
+
+			String path;
+
+			bool need_identifier = true;
+			bool done = false;
+			int line = tokenizer->get_token_line();
+
+			while (!done) {
+				switch (tokenizer->get_token()) {
+					case GDScriptTokenizer::TK_CURSOR: {
+						completion_type = COMPLETION_GET_NODE;
+						completion_class = current_class;
+						completion_function = current_function;
+						completion_line = tokenizer->get_token_line();
+						completion_cursor = path;
+						completion_argument = 0;
+						completion_block = current_block;
+						completion_found = true;
+						tokenizer->advance();
+					} break;
+					case GDScriptTokenizer::TK_CONSTANT: {
+						if (!need_identifier) {
+							done = true;
+							break;
+						}
+
+						if (tokenizer->get_token_constant().get_type() != Variant::STRING) {
+							_set_error("Expected string constant or identifier after '$' or '/'.");
+							return nullptr;
+						}
+
+						path += String(tokenizer->get_token_constant());
+						tokenizer->advance();
+						need_identifier = false;
+
+					} break;
+					case GDScriptTokenizer::TK_OP_DIV: {
+						if (need_identifier) {
+							done = true;
+							break;
+						}
+
+						path += "/";
+						tokenizer->advance();
+						need_identifier = true;
+
+					} break;
+					default: {
+						// Instead of checking for TK_IDENTIFIER, we check with is_token_literal, as this allows us to use match/sync/etc. as a name
+						if (need_identifier && tokenizer->is_token_literal()) {
+							path += String(tokenizer->get_token_literal());
+							tokenizer->advance();
+							need_identifier = false;
+						} else {
+							done = true;
+						}
+
+						break;
+					}
+				}
+			}
+
+			if (path == "") {
+				_set_error("Path expected after $.");
+				return nullptr;
+			}
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = OperatorNode::OP_CALL;
+			op->line = line;
+			op->arguments.push_back(alloc_node<SelfNode>());
+			op->arguments[0]->line = line;
+
+			IdentifierNode *funcname = alloc_node<IdentifierNode>();
+			funcname->name = "get_node";
+			funcname->line = line;
+			op->arguments.push_back(funcname);
+
+			ConstantNode *nodepath = alloc_node<ConstantNode>();
+			nodepath->value = NodePath(StringName(path));
+			nodepath->datatype = _type_from_variant(nodepath->value);
+			nodepath->line = line;
+			op->arguments.push_back(nodepath);
+
+			expr = op;
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+			tokenizer->advance();
+			continue; //no point in cursor in the middle of expression
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+			//constant defined by tokenizer
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = tokenizer->get_token_constant();
+			constant->datatype = _type_from_variant(constant->value);
+			tokenizer->advance();
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_PI) {
+			//constant defined by tokenizer
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = Math_PI;
+			constant->datatype = _type_from_variant(constant->value);
+			tokenizer->advance();
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_TAU) {
+			//constant defined by tokenizer
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = Math_TAU;
+			constant->datatype = _type_from_variant(constant->value);
+			tokenizer->advance();
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_INF) {
+			//constant defined by tokenizer
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = Math_INF;
+			constant->datatype = _type_from_variant(constant->value);
+			tokenizer->advance();
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_NAN) {
+			//constant defined by tokenizer
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = Math_NAN;
+			constant->datatype = _type_from_variant(constant->value);
+			tokenizer->advance();
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_PRELOAD) {
+			//constant defined by tokenizer
+			tokenizer->advance();
+			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				_set_error("Expected '(' after 'preload'");
+				return nullptr;
+			}
+			tokenizer->advance();
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+				completion_cursor = StringName();
+				completion_node = p_parent;
+				completion_type = COMPLETION_RESOURCE_PATH;
+				completion_class = current_class;
+				completion_function = current_function;
+				completion_line = tokenizer->get_token_line();
+				completion_block = current_block;
+				completion_argument = 0;
+				completion_found = true;
+				tokenizer->advance();
+			}
+
+			String path;
+			bool found_constant = false;
+			bool valid = false;
+			ConstantNode *cn;
+
+			parenthesis++;
+			Node *subexpr = _parse_and_reduce_expression(p_parent, p_static);
+			parenthesis--;
+			if (subexpr) {
+				if (subexpr->type == Node::TYPE_CONSTANT) {
+					cn = static_cast<ConstantNode *>(subexpr);
+					found_constant = true;
+				}
+				if (subexpr->type == Node::TYPE_IDENTIFIER) {
+					IdentifierNode *in = static_cast<IdentifierNode *>(subexpr);
+
+					// Try to find the constant expression by the identifier
+					if (current_class->constant_expressions.has(in->name)) {
+						Node *cn_exp = current_class->constant_expressions[in->name].expression;
+						if (cn_exp->type == Node::TYPE_CONSTANT) {
+							cn = static_cast<ConstantNode *>(cn_exp);
+							found_constant = true;
+						}
+					}
+				}
+
+				if (found_constant && cn->value.get_type() == Variant::STRING) {
+					valid = true;
+					path = (String)cn->value;
+				}
+			}
+
+			if (!valid) {
+				_set_error("expected string constant as 'preload' argument.");
+				return nullptr;
+			}
+
+			if (!path.is_abs_path() && base_path != "") {
+				path = base_path.plus_file(path);
+			}
+			path = path.replace("///", "//").simplify_path();
+			if (path == self_path) {
+				_set_error("Can't preload itself (use 'get_script()').");
+				return nullptr;
+			}
+
+			Ref<Resource> res;
+			dependencies.push_back(path);
+			if (!dependencies_only) {
+				if (!validating) {
+					//this can be too slow for just validating code
+					if (for_completion && ScriptCodeCompletionCache::get_singleton() && FileAccess::exists(path)) {
+						res = ScriptCodeCompletionCache::get_singleton()->get_cached_resource(path);
+					} else if (!for_completion || FileAccess::exists(path)) {
+						res = ResourceLoader::load(path);
+					}
+				} else {
+					if (!FileAccess::exists(path)) {
+						_set_error("Can't preload resource at path: " + path);
+						return nullptr;
+					} else if (ScriptCodeCompletionCache::get_singleton()) {
+						res = ScriptCodeCompletionCache::get_singleton()->get_cached_resource(path);
+					}
+				}
+				if (!res.is_valid()) {
+					_set_error("Can't preload resource at path: " + path);
+					return nullptr;
+				}
+			}
+
+			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				_set_error("Expected ')' after 'preload' path");
+				return nullptr;
+			}
+
+			Ref<GDScript> gds = res;
+			if (gds.is_valid() && !gds->is_valid()) {
+				_set_error("Couldn't fully preload the script, possible cyclic reference or compilation error. Use \"load()\" instead if a cyclic reference is intended.");
+				return nullptr;
+			}
+
+			tokenizer->advance();
+
+			ConstantNode *constant = alloc_node<ConstantNode>();
+			constant->value = res;
+			constant->datatype = _type_from_variant(constant->value);
+
+			expr = constant;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_YIELD) {
+			if (!current_function) {
+				_set_error("\"yield()\" can only be used inside function blocks.");
+				return nullptr;
+			}
+
+			current_function->has_yield = true;
+
+			tokenizer->advance();
+			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				_set_error("Expected \"(\" after \"yield\".");
+				return nullptr;
+			}
+
+			tokenizer->advance();
+
+			OperatorNode *yield = alloc_node<OperatorNode>();
+			yield->op = OperatorNode::OP_YIELD;
+
+			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+				tokenizer->advance();
+			}
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				expr = yield;
+				tokenizer->advance();
+			} else {
+				parenthesis++;
+
+				Node *object = _parse_and_reduce_expression(p_parent, p_static);
+				if (!object) {
+					return nullptr;
+				}
+				yield->arguments.push_back(object);
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+					_set_error("Expected \",\" after the first argument of \"yield\".");
+					return nullptr;
+				}
+
+				tokenizer->advance();
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+					completion_cursor = StringName();
+					completion_node = object;
+					completion_type = COMPLETION_YIELD;
+					completion_class = current_class;
+					completion_function = current_function;
+					completion_line = tokenizer->get_token_line();
+					completion_argument = 0;
+					completion_block = current_block;
+					completion_found = true;
+					tokenizer->advance();
+				}
+
+				Node *signal = _parse_and_reduce_expression(p_parent, p_static);
+				if (!signal) {
+					return nullptr;
+				}
+				yield->arguments.push_back(signal);
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+					_set_error("Expected \")\" after the second argument of \"yield\".");
+					return nullptr;
+				}
+
+				parenthesis--;
+
+				tokenizer->advance();
+
+				expr = yield;
+			}
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_SELF) {
+			if (p_static) {
+				_set_error("\"self\" isn't allowed in a static function or constant expression.");
+				return nullptr;
+			}
+			//constant defined by tokenizer
+			SelfNode *self = alloc_node<SelfNode>();
+			tokenizer->advance();
+			expr = self;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+			Variant::Type bi_type = tokenizer->get_token_type();
+			tokenizer->advance(2);
+
+			StringName identifier;
+
+			if (_get_completable_identifier(COMPLETION_BUILT_IN_TYPE_CONSTANT, identifier)) {
+				completion_built_in_constant = bi_type;
+			}
+
+			if (identifier == StringName()) {
+				_set_error("Built-in type constant or static function expected after \".\".");
+				return nullptr;
+			}
+			if (!Variant::has_constant(bi_type, identifier)) {
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN &&
+						Variant::is_method_const(bi_type, identifier) &&
+						Variant::get_method_return_type(bi_type, identifier) == bi_type) {
+					tokenizer->advance();
+
+					OperatorNode *construct = alloc_node<OperatorNode>();
+					construct->op = OperatorNode::OP_CALL;
+
+					TypeNode *tn = alloc_node<TypeNode>();
+					tn->vtype = bi_type;
+					construct->arguments.push_back(tn);
+
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_CALL;
+					op->arguments.push_back(construct);
+
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = identifier;
+					op->arguments.push_back(id);
+
+					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
+						return nullptr;
+					}
+
+					expr = op;
+				} else {
+					// Object is a special case
+					bool valid = false;
+					if (bi_type == Variant::OBJECT) {
+						int object_constant = ClassDB::get_integer_constant("Object", identifier, &valid);
+						if (valid) {
+							ConstantNode *cn = alloc_node<ConstantNode>();
+							cn->value = object_constant;
+							cn->datatype = _type_from_variant(cn->value);
+							expr = cn;
+						}
+					}
+					if (!valid) {
+						_set_error("Static constant  '" + identifier.operator String() + "' not present in built-in type " + Variant::get_type_name(bi_type) + ".");
+						return nullptr;
+					}
+				}
+			} else {
+				ConstantNode *cn = alloc_node<ConstantNode>();
+				cn->value = Variant::get_constant_value(bi_type, identifier);
+				cn->datatype = _type_from_variant(cn->value);
+				expr = cn;
+			}
+
+		} else if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_PARENTHESIS_OPEN && tokenizer->is_token_literal()) {
+			// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
+			//function or constructor
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = OperatorNode::OP_CALL;
+
+			//Do a quick Array and Dictionary Check.  Replace if either require no arguments.
+			bool replaced = false;
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+				Variant::Type ct = tokenizer->get_token_type();
+				if (!p_parsing_constant) {
+					if (ct == Variant::ARRAY) {
+						if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							ArrayNode *arr = alloc_node<ArrayNode>();
+							expr = arr;
+							replaced = true;
+							tokenizer->advance(3);
+						}
+					}
+					if (ct == Variant::DICTIONARY) {
+						if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							DictionaryNode *dict = alloc_node<DictionaryNode>();
+							expr = dict;
+							replaced = true;
+							tokenizer->advance(3);
+						}
+					}
+				}
+
+				if (!replaced) {
+					TypeNode *tn = alloc_node<TypeNode>();
+					tn->vtype = tokenizer->get_token_type();
+					op->arguments.push_back(tn);
+					tokenizer->advance(2);
+				}
+			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_FUNC) {
+				BuiltInFunctionNode *bn = alloc_node<BuiltInFunctionNode>();
+				bn->function = tokenizer->get_token_built_in_func();
+				op->arguments.push_back(bn);
+				tokenizer->advance(2);
+			} else {
+				SelfNode *self = alloc_node<SelfNode>();
+				op->arguments.push_back(self);
+
+				StringName identifier;
+				if (_get_completable_identifier(COMPLETION_FUNCTION, identifier)) {
+				}
+
+				IdentifierNode *id = alloc_node<IdentifierNode>();
+				id->name = identifier;
+				op->arguments.push_back(id);
+				tokenizer->advance(1);
+			}
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+				_make_completable_call(0);
+				completion_node = op;
+			}
+			if (!replaced) {
+				if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
+					return nullptr;
+				}
+				expr = op;
+			}
+		} else if (tokenizer->is_token_literal(0, true)) {
+			// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
+			//identifier (reference)
+
+			const ClassNode *cln = current_class;
+			bool bfn = false;
+			StringName identifier;
+			int id_line = tokenizer->get_token_line();
+			if (_get_completable_identifier(COMPLETION_IDENTIFIER, identifier)) {
+			}
+
+			BlockNode *b = current_block;
+			while (!bfn && b) {
+				if (b->variables.has(identifier)) {
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = identifier;
+					id->declared_block = b;
+					id->line = id_line;
+					expr = id;
+					bfn = true;
+
+#ifdef DEBUG_ENABLED
+					LocalVarNode *lv = b->variables[identifier];
+					switch (tokenizer->get_token()) {
+						case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
+						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+						case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
+						case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
+						case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
+						case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+						case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+						case GDScriptTokenizer::TK_OP_ASSIGN_SUB: {
+							if (lv->assignments == 0) {
+								if (!lv->datatype.has_type) {
+									_set_error("Using assignment with operation on a variable that was never assigned.");
+									return nullptr;
+								}
+								_add_warning(GDScriptWarning::UNASSIGNED_VARIABLE_OP_ASSIGN, -1, identifier.operator String());
+							}
+							FALLTHROUGH;
+						}
+						case GDScriptTokenizer::TK_OP_ASSIGN: {
+							lv->assignments += 1;
+							lv->usages--; // Assignment is not really usage
+						} break;
+						default: {
+							lv->usages++;
+						}
+					}
+#endif // DEBUG_ENABLED
+					break;
+				}
+				b = b->parent_block;
+			}
+
+			if (!bfn && p_parsing_constant) {
+				if (cln->constant_expressions.has(identifier)) {
+					expr = cln->constant_expressions[identifier].expression;
+					bfn = true;
+				} else if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
+					//check from constants
+					ConstantNode *constant = alloc_node<ConstantNode>();
+					constant->value = GDScriptLanguage::get_singleton()->get_global_array()[GDScriptLanguage::get_singleton()->get_global_map()[identifier]];
+					constant->datatype = _type_from_variant(constant->value);
+					constant->line = id_line;
+					expr = constant;
+					bfn = true;
+				}
+
+				if (!bfn && GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
+					//check from singletons
+					ConstantNode *constant = alloc_node<ConstantNode>();
+					constant->value = GDScriptLanguage::get_singleton()->get_named_globals_map()[identifier];
+					expr = constant;
+					bfn = true;
+				}
+
+				if (!dependencies_only) {
+					if (!bfn && ScriptServer::is_global_class(identifier)) {
+						Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(identifier));
+						if (scr.is_valid() && scr->is_valid()) {
+							ConstantNode *constant = alloc_node<ConstantNode>();
+							constant->value = scr;
+							expr = constant;
+							bfn = true;
+						}
+					}
+
+					// Check parents for the constant
+					if (!bfn) {
+						// Using current_class instead of cln here, since cln is const*
+						_determine_inheritance(current_class, false);
+						if (cln->base_type.has_type && cln->base_type.kind == DataType::GDSCRIPT && cln->base_type.script_type->is_valid()) {
+							Map<StringName, Variant> parent_constants;
+							current_class->base_type.script_type->get_constants(&parent_constants);
+							if (parent_constants.has(identifier)) {
+								ConstantNode *constant = alloc_node<ConstantNode>();
+								constant->value = parent_constants[identifier];
+								expr = constant;
+								bfn = true;
+							}
+						}
+					}
+				}
+			}
+
+			if (!bfn) {
+#ifdef DEBUG_ENABLED
+				if (current_function) {
+					int arg_idx = current_function->arguments.find(identifier);
+					if (arg_idx != -1) {
+						switch (tokenizer->get_token()) {
+							case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
+							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+							case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
+							case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
+							case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
+							case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+							case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+							case GDScriptTokenizer::TK_OP_ASSIGN_SUB:
+							case GDScriptTokenizer::TK_OP_ASSIGN: {
+								// Assignment is not really usage
+							} break;
+							default: {
+								current_function->arguments_usage.write[arg_idx] = current_function->arguments_usage[arg_idx] + 1;
+							}
+						}
+					}
+				}
+#endif // DEBUG_ENABLED
+				IdentifierNode *id = alloc_node<IdentifierNode>();
+				id->name = identifier;
+				id->line = id_line;
+				expr = id;
+			}
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ADD || tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB || tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT || tokenizer->get_token() == GDScriptTokenizer::TK_OP_BIT_INVERT) {
+			//single prefix operators like !expr +expr -expr ++expr --expr
+			alloc_node<OperatorNode>();
+			Expression e;
+			e.is_op = true;
+
+			switch (tokenizer->get_token()) {
+				case GDScriptTokenizer::TK_OP_ADD:
+					e.op = OperatorNode::OP_POS;
+					break;
+				case GDScriptTokenizer::TK_OP_SUB:
+					e.op = OperatorNode::OP_NEG;
+					break;
+				case GDScriptTokenizer::TK_OP_NOT:
+					e.op = OperatorNode::OP_NOT;
+					break;
+				case GDScriptTokenizer::TK_OP_BIT_INVERT:
+					e.op = OperatorNode::OP_BIT_INVERT;
+					break;
+				default: {
+				}
+			}
+
+			tokenizer->advance();
+
+			if (e.op != OperatorNode::OP_NOT && tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT) {
+				_set_error("Misplaced 'not'.");
+				return nullptr;
+			}
+
+			expression.push_back(e);
+			continue; //only exception, must continue...
+
+			/*
+			Node *subexpr=_parse_expression(op,p_static);
+			if (!subexpr)
+				return NULL;
+			op->arguments.push_back(subexpr);
+			expr=op;*/
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_IS && tokenizer->get_token(1) == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+			// 'is' operator with built-in type
+			if (!expr) {
+				_set_error("Expected identifier before 'is' operator");
+				return nullptr;
+			}
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = OperatorNode::OP_IS_BUILTIN;
+			op->arguments.push_back(expr);
+
+			tokenizer->advance();
+
+			TypeNode *tn = alloc_node<TypeNode>();
+			tn->vtype = tokenizer->get_token_type();
+			op->arguments.push_back(tn);
+			tokenizer->advance();
+
+			expr = op;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
+			// array
+			tokenizer->advance();
+
+			ArrayNode *arr = alloc_node<ArrayNode>();
+			bool expecting_comma = false;
+
+			while (true) {
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+					_set_error("Unterminated array");
+					return nullptr;
+
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					tokenizer->advance();
+					break;
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+					tokenizer->advance(); //ignore newline
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					if (!expecting_comma) {
+						_set_error("expression or ']' expected");
+						return nullptr;
+					}
+
+					expecting_comma = false;
+					tokenizer->advance(); //ignore newline
+				} else {
+					//parse expression
+					if (expecting_comma) {
+						_set_error("',' or ']' expected");
+						return nullptr;
+					}
+					Node *n = _parse_expression(arr, p_static, p_allow_assign, p_parsing_constant);
+					if (!n) {
+						return nullptr;
+					}
+					arr->elements.push_back(n);
+					expecting_comma = true;
+				}
+			}
+
+			expr = arr;
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
+			// array
+			tokenizer->advance();
+
+			DictionaryNode *dict = alloc_node<DictionaryNode>();
+
+			enum DictExpect {
+
+				DICT_EXPECT_KEY,
+				DICT_EXPECT_COLON,
+				DICT_EXPECT_VALUE,
+				DICT_EXPECT_COMMA
+
+			};
+
+			Node *key = nullptr;
+			Set<Variant> keys;
+
+			DictExpect expecting = DICT_EXPECT_KEY;
+
+			while (true) {
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+					_set_error("Unterminated dictionary");
+					return nullptr;
+
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					if (expecting == DICT_EXPECT_COLON) {
+						_set_error("':' expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_VALUE) {
+						_set_error("value expected");
+						return nullptr;
+					}
+					tokenizer->advance();
+					break;
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+					tokenizer->advance(); //ignore newline
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					if (expecting == DICT_EXPECT_KEY) {
+						_set_error("key or '}' expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_VALUE) {
+						_set_error("value expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_COLON) {
+						_set_error("':' expected");
+						return nullptr;
+					}
+
+					expecting = DICT_EXPECT_KEY;
+					tokenizer->advance(); //ignore newline
+
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+					if (expecting == DICT_EXPECT_KEY) {
+						_set_error("key or '}' expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_VALUE) {
+						_set_error("value expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_COMMA) {
+						_set_error("',' or '}' expected");
+						return nullptr;
+					}
+
+					expecting = DICT_EXPECT_VALUE;
+					tokenizer->advance(); //ignore newline
+				} else {
+					if (expecting == DICT_EXPECT_COMMA) {
+						_set_error("',' or '}' expected");
+						return nullptr;
+					}
+					if (expecting == DICT_EXPECT_COLON) {
+						_set_error("':' expected");
+						return nullptr;
+					}
+
+					if (expecting == DICT_EXPECT_KEY) {
+						if (tokenizer->is_token_literal() && tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+							// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
+							//lua style identifier, easier to write
+							ConstantNode *cn = alloc_node<ConstantNode>();
+							cn->value = tokenizer->get_token_literal();
+							cn->datatype = _type_from_variant(cn->value);
+							key = cn;
+							tokenizer->advance(2);
+							expecting = DICT_EXPECT_VALUE;
+						} else {
+							//python/js style more flexible
+							key = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
+							if (!key) {
+								return nullptr;
+							}
+							expecting = DICT_EXPECT_COLON;
+						}
+					}
+
+					if (expecting == DICT_EXPECT_VALUE) {
+						Node *value = _parse_expression(dict, p_static, p_allow_assign, p_parsing_constant);
+						if (!value) {
+							return nullptr;
+						}
+						expecting = DICT_EXPECT_COMMA;
+
+						if (key->type == GDScriptParser::Node::TYPE_CONSTANT) {
+							Variant const &keyName = static_cast<const GDScriptParser::ConstantNode *>(key)->value;
+
+							if (keys.has(keyName)) {
+								_set_error("Duplicate key found in Dictionary literal");
+								return nullptr;
+							}
+							keys.insert(keyName);
+						}
+
+						DictionaryNode::Pair pair;
+						pair.key = key;
+						pair.value = value;
+						dict->elements.push_back(pair);
+						key = nullptr;
+					}
+				}
+			}
+
+			expr = dict;
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && (tokenizer->is_token_literal(1) || tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR)) {
+			// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
+			// parent call
+
+			tokenizer->advance(); //goto identifier
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = OperatorNode::OP_PARENT_CALL;
+
+			/*SelfNode *self = alloc_node<SelfNode>();
+			op->arguments.push_back(self);
+			forbidden for now */
+			StringName identifier;
+			bool is_completion = _get_completable_identifier(COMPLETION_PARENT_FUNCTION, identifier) && for_completion;
+
+			IdentifierNode *id = alloc_node<IdentifierNode>();
+			id->name = identifier;
+			op->arguments.push_back(id);
+
+			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				if (!is_completion) {
+					_set_error("Expected '(' for parent function call.");
+					return nullptr;
+				}
+			} else {
+				tokenizer->advance();
+				if (!_parse_arguments(op, op->arguments, p_static, false, p_parsing_constant)) {
+					return nullptr;
+				}
+			}
+
+			expr = op;
+
+		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && expression.size() > 0 && expression[expression.size() - 1].is_op && expression[expression.size() - 1].op == OperatorNode::OP_IS) {
+			Expression e = expression[expression.size() - 1];
+			e.op = OperatorNode::OP_IS_BUILTIN;
+			expression.write[expression.size() - 1] = e;
+
+			TypeNode *tn = alloc_node<TypeNode>();
+			tn->vtype = tokenizer->get_token_type();
+			expr = tn;
+			tokenizer->advance();
+		} else {
+			//find list [ or find dictionary {
+			_set_error("Error parsing expression, misplaced: " + String(tokenizer->get_token_name(tokenizer->get_token())));
+			return nullptr; //nothing
+		}
+
+		ERR_FAIL_COND_V_MSG(!expr, nullptr, "GDScriptParser bug, couldn't figure out what expression is.");
+
+		/******************/
+		/* Parse Indexing */
+		/******************/
+
+		while (true) {
+			//expressions can be indexed any number of times
+
+			if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+				//indexing using "."
+
+				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_CURSOR && !tokenizer->is_token_literal(1)) {
+					// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
+					_set_error("Expected identifier as member");
+					return nullptr;
+				} else if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+					//call!!
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_CALL;
+
+					tokenizer->advance();
+
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					StringName identifier;
+					if (_get_completable_identifier(COMPLETION_METHOD, identifier)) {
+						completion_node = op;
+						//indexing stuff
+					}
+
+					id->name = identifier;
+
+					op->arguments.push_back(expr); // call what
+					op->arguments.push_back(id); // call func
+					//get arguments
+					tokenizer->advance(1);
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+						_make_completable_call(0);
+						completion_node = op;
+					}
+					if (!_parse_arguments(op, op->arguments, p_static, true, p_parsing_constant)) {
+						return nullptr;
+					}
+					expr = op;
+
+				} else {
+					//simple indexing!
+
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_INDEX_NAMED;
+					tokenizer->advance();
+
+					StringName identifier;
+					if (_get_completable_identifier(COMPLETION_INDEX, identifier)) {
+						if (identifier == StringName()) {
+							identifier = "@temp"; //so it parses alright
+						}
+						completion_node = op;
+
+						//indexing stuff
+					}
+
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = identifier;
+
+					op->arguments.push_back(expr);
+					op->arguments.push_back(id);
+
+					expr = op;
+				}
+
+			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
+				//indexing using "[]"
+				OperatorNode *op = alloc_node<OperatorNode>();
+				op->op = OperatorNode::OP_INDEX;
+
+				tokenizer->advance(1);
+
+				parenthesis++;
+				Node *subexpr = _parse_expression(op, p_static, p_allow_assign, p_parsing_constant);
+				parenthesis--;
+				if (!subexpr) {
+					return nullptr;
+				}
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					_set_error("Expected ']'");
+					return nullptr;
+				}
+
+				op->arguments.push_back(expr);
+				op->arguments.push_back(subexpr);
+				tokenizer->advance(1);
+				expr = op;
+
+			} else {
+				break;
+			}
+		}
+
+		/*****************/
+		/* Parse Casting */
+		/*****************/
+
+		bool has_casting = expr->type == Node::TYPE_CAST;
+		if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_AS) {
+			if (has_casting) {
+				_set_error("Unexpected 'as'.");
+				return nullptr;
+			}
+			CastNode *cn = alloc_node<CastNode>();
+			if (!_parse_type(cn->cast_type)) {
+				_set_error("Expected type after 'as'.");
+				return nullptr;
+			}
+			has_casting = true;
+			cn->source_node = expr;
+			expr = cn;
+		}
+
+		/******************/
+		/* Parse Operator */
+		/******************/
+
+		if (parenthesis > 0) {
+			//remove empty space (only allowed if inside parenthesis
+			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+				tokenizer->advance();
+			}
+		}
+
+		Expression e;
+		e.is_op = false;
+		e.node = expr;
+		expression.push_back(e);
+
+		// determine which operator is next
+
+		OperatorNode::Operator op;
+		bool valid = true;
+
+//assign, if allowed is only allowed on the first operator
+#define _VALIDATE_ASSIGN                  \
+	if (!p_allow_assign || has_casting) { \
+		_set_error("Unexpected assign."); \
+		return NULL;                      \
+	}                                     \
+	p_allow_assign = false;
+
+		switch (tokenizer->get_token()) { //see operator
+
+			case GDScriptTokenizer::TK_OP_IN:
+				op = OperatorNode::OP_IN;
+				break;
+			case GDScriptTokenizer::TK_OP_EQUAL:
+				op = OperatorNode::OP_EQUAL;
+				break;
+			case GDScriptTokenizer::TK_OP_NOT_EQUAL:
+				op = OperatorNode::OP_NOT_EQUAL;
+				break;
+			case GDScriptTokenizer::TK_OP_LESS:
+				op = OperatorNode::OP_LESS;
+				break;
+			case GDScriptTokenizer::TK_OP_LESS_EQUAL:
+				op = OperatorNode::OP_LESS_EQUAL;
+				break;
+			case GDScriptTokenizer::TK_OP_GREATER:
+				op = OperatorNode::OP_GREATER;
+				break;
+			case GDScriptTokenizer::TK_OP_GREATER_EQUAL:
+				op = OperatorNode::OP_GREATER_EQUAL;
+				break;
+			case GDScriptTokenizer::TK_OP_AND:
+				op = OperatorNode::OP_AND;
+				break;
+			case GDScriptTokenizer::TK_OP_OR:
+				op = OperatorNode::OP_OR;
+				break;
+			case GDScriptTokenizer::TK_OP_ADD:
+				op = OperatorNode::OP_ADD;
+				break;
+			case GDScriptTokenizer::TK_OP_SUB:
+				op = OperatorNode::OP_SUB;
+				break;
+			case GDScriptTokenizer::TK_OP_MUL:
+				op = OperatorNode::OP_MUL;
+				break;
+			case GDScriptTokenizer::TK_OP_DIV:
+				op = OperatorNode::OP_DIV;
+				break;
+			case GDScriptTokenizer::TK_OP_MOD:
+				op = OperatorNode::OP_MOD;
+				break;
+			//case GDScriptTokenizer::TK_OP_NEG: op=OperatorNode::OP_NEG ; break;
+			case GDScriptTokenizer::TK_OP_SHIFT_LEFT:
+				op = OperatorNode::OP_SHIFT_LEFT;
+				break;
+			case GDScriptTokenizer::TK_OP_SHIFT_RIGHT:
+				op = OperatorNode::OP_SHIFT_RIGHT;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN: {
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN;
+
+				if (tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
+					//code complete assignment
+					completion_type = COMPLETION_ASSIGN;
+					completion_node = expr;
+					completion_class = current_class;
+					completion_function = current_function;
+					completion_line = tokenizer->get_token_line();
+					completion_block = current_block;
+					completion_found = true;
+					tokenizer->advance();
+				}
+
+			} break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_ADD;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_SUB:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SUB;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MUL;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_DIV;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MOD;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_LEFT;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_RIGHT;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_AND;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_OR;
+				break;
+			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_XOR;
+				break;
+			case GDScriptTokenizer::TK_OP_BIT_AND:
+				op = OperatorNode::OP_BIT_AND;
+				break;
+			case GDScriptTokenizer::TK_OP_BIT_OR:
+				op = OperatorNode::OP_BIT_OR;
+				break;
+			case GDScriptTokenizer::TK_OP_BIT_XOR:
+				op = OperatorNode::OP_BIT_XOR;
+				break;
+			case GDScriptTokenizer::TK_PR_IS:
+				op = OperatorNode::OP_IS;
+				break;
+			case GDScriptTokenizer::TK_CF_IF:
+				op = OperatorNode::OP_TERNARY_IF;
+				break;
+			case GDScriptTokenizer::TK_CF_ELSE:
+				op = OperatorNode::OP_TERNARY_ELSE;
+				break;
+			default:
+				valid = false;
+				break;
+		}
+
+		if (valid) {
+			e.is_op = true;
+			e.op = op;
+			expression.push_back(e);
+			tokenizer->advance();
+		} else {
+			break;
+		}
+	}
+
+	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
+
+	while (expression.size() > 1) {
+		int next_op = -1;
+		int min_priority = 0xFFFFF;
+		bool is_unary = false;
+		bool is_ternary = false;
+
+		for (int i = 0; i < expression.size(); i++) {
+			if (!expression[i].is_op) {
+				continue;
+			}
+
+			int priority;
+
+			bool unary = false;
+			bool ternary = false;
+			bool error = false;
+			bool right_to_left = false;
+
+			switch (expression[i].op) {
+				case OperatorNode::OP_IS:
+				case OperatorNode::OP_IS_BUILTIN:
+					priority = -1;
+					break; //before anything
+
+				case OperatorNode::OP_BIT_INVERT:
+					priority = 0;
+					unary = true;
+					break;
+				case OperatorNode::OP_NEG:
+				case OperatorNode::OP_POS:
+					priority = 1;
+					unary = true;
+					break;
+
+				case OperatorNode::OP_MUL:
+					priority = 2;
+					break;
+				case OperatorNode::OP_DIV:
+					priority = 2;
+					break;
+				case OperatorNode::OP_MOD:
+					priority = 2;
+					break;
+
+				case OperatorNode::OP_ADD:
+					priority = 3;
+					break;
+				case OperatorNode::OP_SUB:
+					priority = 3;
+					break;
+
+				case OperatorNode::OP_SHIFT_LEFT:
+					priority = 4;
+					break;
+				case OperatorNode::OP_SHIFT_RIGHT:
+					priority = 4;
+					break;
+
+				case OperatorNode::OP_BIT_AND:
+					priority = 5;
+					break;
+				case OperatorNode::OP_BIT_XOR:
+					priority = 6;
+					break;
+				case OperatorNode::OP_BIT_OR:
+					priority = 7;
+					break;
+
+				case OperatorNode::OP_LESS:
+					priority = 8;
+					break;
+				case OperatorNode::OP_LESS_EQUAL:
+					priority = 8;
+					break;
+				case OperatorNode::OP_GREATER:
+					priority = 8;
+					break;
+				case OperatorNode::OP_GREATER_EQUAL:
+					priority = 8;
+					break;
+
+				case OperatorNode::OP_EQUAL:
+					priority = 8;
+					break;
+				case OperatorNode::OP_NOT_EQUAL:
+					priority = 8;
+					break;
+
+				case OperatorNode::OP_IN:
+					priority = 10;
+					break;
+
+				case OperatorNode::OP_NOT:
+					priority = 11;
+					unary = true;
+					break;
+				case OperatorNode::OP_AND:
+					priority = 12;
+					break;
+				case OperatorNode::OP_OR:
+					priority = 13;
+					break;
+
+				case OperatorNode::OP_TERNARY_IF:
+					priority = 14;
+					ternary = true;
+					right_to_left = true;
+					break;
+				case OperatorNode::OP_TERNARY_ELSE:
+					priority = 14;
+					error = true;
+					// Rigth-to-left should be false in this case, otherwise it would always error.
+					break;
+
+				case OperatorNode::OP_ASSIGN:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_ADD:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_SUB:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_MUL:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_DIV:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_MOD:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_BIT_AND:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_BIT_OR:
+					priority = 15;
+					break;
+				case OperatorNode::OP_ASSIGN_BIT_XOR:
+					priority = 15;
+					break;
+
+				default: {
+					_set_error("GDScriptParser bug, invalid operator in expression: " + itos(expression[i].op));
+					return nullptr;
+				}
+			}
+
+			if (priority < min_priority || (right_to_left && priority == min_priority)) {
+				// < is used for left to right (default)
+				// <= is used for right to left
+				if (error) {
+					_set_error("Unexpected operator");
+					return nullptr;
+				}
+				next_op = i;
+				min_priority = priority;
+				is_unary = unary;
+				is_ternary = ternary;
+			}
+		}
+
+		if (next_op == -1) {
+			_set_error("Yet another parser bug....");
+			ERR_FAIL_V(nullptr);
+		}
+
+		// OK! create operator..
+		if (is_unary) {
+			int expr_pos = next_op;
+			while (expression[expr_pos].is_op) {
+				expr_pos++;
+				if (expr_pos == expression.size()) {
+					//can happen..
+					_set_error("Unexpected end of expression...");
+					return nullptr;
+				}
+			}
+
+			//consecutively do unary operators
+			for (int i = expr_pos - 1; i >= next_op; i--) {
+				OperatorNode *op = alloc_node<OperatorNode>();
+				op->op = expression[i].op;
+				op->arguments.push_back(expression[i + 1].node);
+				op->line = op_line; //line might have been changed from a \n
+				expression.write[i].is_op = false;
+				expression.write[i].node = op;
+				expression.remove(i + 1);
+			}
+
+		} else if (is_ternary) {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
+				_set_error("Parser bug...");
+				ERR_FAIL_V(nullptr);
+			}
+
+			if (next_op >= (expression.size() - 2) || expression[next_op + 2].op != OperatorNode::OP_TERNARY_ELSE) {
+				_set_error("Expected else after ternary if.");
+				return nullptr;
+			}
+			if (next_op >= (expression.size() - 3)) {
+				_set_error("Expected value after ternary else.");
+				return nullptr;
+			}
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = expression[next_op].op;
+			op->line = op_line; //line might have been changed from a \n
+
+			if (expression[next_op - 1].is_op) {
+				_set_error("Parser bug...");
+				ERR_FAIL_V(nullptr);
+			}
+
+			if (expression[next_op + 1].is_op) {
+				// this is not invalid and can really appear
+				// but it becomes invalid anyway because no binary op
+				// can be followed by a unary op in a valid combination,
+				// due to how precedence works, unaries will always disappear first
+
+				_set_error("Unexpected two consecutive operators after ternary if.");
+				return nullptr;
+			}
+
+			if (expression[next_op + 3].is_op) {
+				// this is not invalid and can really appear
+				// but it becomes invalid anyway because no binary op
+				// can be followed by a unary op in a valid combination,
+				// due to how precedence works, unaries will always disappear first
+
+				_set_error("Unexpected two consecutive operators after ternary else.");
+				return nullptr;
+			}
+
+			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as first
+			op->arguments.push_back(expression[next_op - 1].node); //left expression goes as when-true
+			op->arguments.push_back(expression[next_op + 3].node); //expression after next goes as when-false
+
+			//replace all 3 nodes by this operator and make it an expression
+			expression.write[next_op - 1].node = op;
+			expression.remove(next_op);
+			expression.remove(next_op);
+			expression.remove(next_op);
+			expression.remove(next_op);
+		} else {
+			if (next_op < 1 || next_op >= (expression.size() - 1)) {
+				_set_error("Parser bug...");
+				ERR_FAIL_V(nullptr);
+			}
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = expression[next_op].op;
+			op->line = op_line; //line might have been changed from a \n
+
+			if (expression[next_op - 1].is_op) {
+				_set_error("Parser bug...");
+				ERR_FAIL_V(nullptr);
+			}
+
+			if (expression[next_op + 1].is_op) {
+				// this is not invalid and can really appear
+				// but it becomes invalid anyway because no binary op
+				// can be followed by a unary op in a valid combination,
+				// due to how precedence works, unaries will always disappear first
+
+				_set_error("Unexpected two consecutive operators.");
+				return nullptr;
+			}
+
+			op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
+			op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
+
+			//replace all 3 nodes by this operator and make it an expression
+			expression.write[next_op - 1].node = op;
+			expression.remove(next_op);
+			expression.remove(next_op);
+		}
+	}
+
+	return expression[0].node;
+}
+
+GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to_const) {
+	switch (p_node->type) {
+		case Node::TYPE_BUILT_IN_FUNCTION: {
+			//many may probably be optimizable
+			return p_node;
+		} break;
+		case Node::TYPE_ARRAY: {
+			ArrayNode *an = static_cast<ArrayNode *>(p_node);
+			bool all_constants = true;
+
+			for (int i = 0; i < an->elements.size(); i++) {
+				an->elements.write[i] = _reduce_expression(an->elements[i], p_to_const);
+				if (an->elements[i]->type != Node::TYPE_CONSTANT) {
+					all_constants = false;
+				}
+			}
+
+			if (all_constants && p_to_const) {
+				//reduce constant array expression
+
+				ConstantNode *cn = alloc_node<ConstantNode>();
+				Array arr;
+				arr.resize(an->elements.size());
+				for (int i = 0; i < an->elements.size(); i++) {
+					ConstantNode *acn = static_cast<ConstantNode *>(an->elements[i]);
+					arr[i] = acn->value;
+				}
+				cn->value = arr;
+				cn->datatype = _type_from_variant(cn->value);
+				return cn;
+			}
+
+			return an;
+
+		} break;
+		case Node::TYPE_DICTIONARY: {
+			DictionaryNode *dn = static_cast<DictionaryNode *>(p_node);
+			bool all_constants = true;
+
+			for (int i = 0; i < dn->elements.size(); i++) {
+				dn->elements.write[i].key = _reduce_expression(dn->elements[i].key, p_to_const);
+				if (dn->elements[i].key->type != Node::TYPE_CONSTANT) {
+					all_constants = false;
+				}
+				dn->elements.write[i].value = _reduce_expression(dn->elements[i].value, p_to_const);
+				if (dn->elements[i].value->type != Node::TYPE_CONSTANT) {
+					all_constants = false;
+				}
+			}
+
+			if (all_constants && p_to_const) {
+				//reduce constant array expression
+
+				ConstantNode *cn = alloc_node<ConstantNode>();
+				Dictionary dict;
+				for (int i = 0; i < dn->elements.size(); i++) {
+					ConstantNode *key_c = static_cast<ConstantNode *>(dn->elements[i].key);
+					ConstantNode *value_c = static_cast<ConstantNode *>(dn->elements[i].value);
+
+					dict[key_c->value] = value_c->value;
+				}
+				cn->value = dict;
+				cn->datatype = _type_from_variant(cn->value);
+				return cn;
+			}
+
+			return dn;
+
+		} break;
+		case Node::TYPE_OPERATOR: {
+			OperatorNode *op = static_cast<OperatorNode *>(p_node);
+
+			bool all_constants = true;
+			int last_not_constant = -1;
+
+			for (int i = 0; i < op->arguments.size(); i++) {
+				op->arguments.write[i] = _reduce_expression(op->arguments[i], p_to_const);
+				if (op->arguments[i]->type != Node::TYPE_CONSTANT) {
+					all_constants = false;
+					last_not_constant = i;
+				}
+			}
+
+			if (op->op == OperatorNode::OP_IS) {
+				//nothing much
+				return op;
+			}
+			if (op->op == OperatorNode::OP_PARENT_CALL) {
+				//nothing much
+				return op;
+
+			} else if (op->op == OperatorNode::OP_CALL) {
+				//can reduce base type constructors
+				if ((op->arguments[0]->type == Node::TYPE_TYPE || (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && GDScriptFunctions::is_deterministic(static_cast<BuiltInFunctionNode *>(op->arguments[0])->function))) && last_not_constant == 0) {
+					//native type constructor or intrinsic function
+					const Variant **vptr = nullptr;
+					Vector<Variant *> ptrs;
+					if (op->arguments.size() > 1) {
+						ptrs.resize(op->arguments.size() - 1);
+						for (int i = 0; i < ptrs.size(); i++) {
+							ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i + 1]);
+							ptrs.write[i] = &cn->value;
+						}
+
+						vptr = (const Variant **)&ptrs[0];
+					}
+
+					Variant::CallError ce;
+					Variant v;
+
+					if (op->arguments[0]->type == Node::TYPE_TYPE) {
+						TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
+						v = Variant::construct(tn->vtype, vptr, ptrs.size(), ce);
+
+					} else {
+						GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+						GDScriptFunctions::call(func, vptr, ptrs.size(), v, ce);
+					}
+
+					if (ce.error != Variant::CallError::CALL_OK) {
+						String errwhere;
+						if (op->arguments[0]->type == Node::TYPE_TYPE) {
+							TypeNode *tn = static_cast<TypeNode *>(op->arguments[0]);
+							errwhere = "'" + Variant::get_type_name(tn->vtype) + "' constructor";
+
+						} else {
+							GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+							errwhere = String("'") + GDScriptFunctions::get_func_name(func) + "' intrinsic function";
+						}
+
+						switch (ce.error) {
+							case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT: {
+								_set_error("Invalid argument (#" + itos(ce.argument + 1) + ") for " + errwhere + ".");
+
+							} break;
+							case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS: {
+								_set_error("Too many arguments for " + errwhere + ".");
+							} break;
+							case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS: {
+								_set_error("Too few arguments for " + errwhere + ".");
+							} break;
+							default: {
+								_set_error("Invalid arguments for " + errwhere + ".");
+
+							} break;
+						}
+
+						error_line = op->line;
+
+						return p_node;
+					}
+
+					ConstantNode *cn = alloc_node<ConstantNode>();
+					cn->value = v;
+					cn->datatype = _type_from_variant(v);
+					return cn;
+				}
+
+				return op; //don't reduce yet
+
+			} else if (op->op == OperatorNode::OP_YIELD) {
+				return op;
+
+			} else if (op->op == OperatorNode::OP_INDEX) {
+				//can reduce indices into constant arrays or dictionaries
+
+				if (all_constants) {
+					ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
+					ConstantNode *cb = static_cast<ConstantNode *>(op->arguments[1]);
+
+					bool valid;
+
+					Variant v = ca->value.get(cb->value, &valid);
+					if (!valid) {
+						_set_error("invalid index in constant expression");
+						error_line = op->line;
+						return op;
+					}
+
+					ConstantNode *cn = alloc_node<ConstantNode>();
+					cn->value = v;
+					cn->datatype = _type_from_variant(v);
+					return cn;
+				}
+
+				return op;
+
+			} else if (op->op == OperatorNode::OP_INDEX_NAMED) {
+				if (op->arguments[0]->type == Node::TYPE_CONSTANT && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
+					ConstantNode *ca = static_cast<ConstantNode *>(op->arguments[0]);
+					IdentifierNode *ib = static_cast<IdentifierNode *>(op->arguments[1]);
+
+					bool valid;
+					Variant v = ca->value.get_named(ib->name, &valid);
+					if (!valid) {
+						_set_error("invalid index '" + String(ib->name) + "' in constant expression");
+						error_line = op->line;
+						return op;
+					}
+
+					ConstantNode *cn = alloc_node<ConstantNode>();
+					cn->value = v;
+					cn->datatype = _type_from_variant(v);
+					return cn;
+				}
+
+				return op;
+			}
+
+			//validate assignment (don't assign to constant expression
+			switch (op->op) {
+				case OperatorNode::OP_ASSIGN:
+				case OperatorNode::OP_ASSIGN_ADD:
+				case OperatorNode::OP_ASSIGN_SUB:
+				case OperatorNode::OP_ASSIGN_MUL:
+				case OperatorNode::OP_ASSIGN_DIV:
+				case OperatorNode::OP_ASSIGN_MOD:
+				case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+				case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+				case OperatorNode::OP_ASSIGN_BIT_AND:
+				case OperatorNode::OP_ASSIGN_BIT_OR:
+				case OperatorNode::OP_ASSIGN_BIT_XOR: {
+					if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
+						_set_error("Can't assign to constant", tokenizer->get_token_line() - 1);
+						error_line = op->line;
+						return op;
+					} else if (op->arguments[0]->type == Node::TYPE_SELF) {
+						_set_error("Can't assign to self.", op->line);
+						error_line = op->line;
+						return op;
+					}
+
+					if (op->arguments[0]->type == Node::TYPE_OPERATOR) {
+						OperatorNode *on = static_cast<OperatorNode *>(op->arguments[0]);
+						if (on->op != OperatorNode::OP_INDEX && on->op != OperatorNode::OP_INDEX_NAMED) {
+							_set_error("Can't assign to an expression", tokenizer->get_token_line() - 1);
+							error_line = op->line;
+							return op;
+						}
+					}
+
+				} break;
+				default: {
+					break;
+				}
+			}
+			//now se if all are constants
+			if (!all_constants) {
+				return op; //nothing to reduce from here on
+			}
+#define _REDUCE_UNARY(m_vop)                                                                               \
+	bool valid = false;                                                                                    \
+	Variant res;                                                                                           \
+	Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, Variant(), res, valid); \
+	if (!valid) {                                                                                          \
+		_set_error("Invalid operand for unary operator");                                                  \
+		error_line = op->line;                                                                             \
+		return p_node;                                                                                     \
+	}                                                                                                      \
+	ConstantNode *cn = alloc_node<ConstantNode>();                                                         \
+	cn->value = res;                                                                                       \
+	cn->datatype = _type_from_variant(res);                                                                \
+	return cn;
+
+#define _REDUCE_BINARY(m_vop)                                                                                                                         \
+	bool valid = false;                                                                                                                               \
+	Variant res;                                                                                                                                      \
+	Variant::evaluate(m_vop, static_cast<ConstantNode *>(op->arguments[0])->value, static_cast<ConstantNode *>(op->arguments[1])->value, res, valid); \
+	if (!valid) {                                                                                                                                     \
+		_set_error("Invalid operands for operator");                                                                                                  \
+		error_line = op->line;                                                                                                                        \
+		return p_node;                                                                                                                                \
+	}                                                                                                                                                 \
+	ConstantNode *cn = alloc_node<ConstantNode>();                                                                                                    \
+	cn->value = res;                                                                                                                                  \
+	cn->datatype = _type_from_variant(res);                                                                                                           \
+	return cn;
+
+			switch (op->op) {
+				//unary operators
+				case OperatorNode::OP_NEG: {
+					_REDUCE_UNARY(Variant::OP_NEGATE);
+				} break;
+				case OperatorNode::OP_POS: {
+					_REDUCE_UNARY(Variant::OP_POSITIVE);
+				} break;
+				case OperatorNode::OP_NOT: {
+					_REDUCE_UNARY(Variant::OP_NOT);
+				} break;
+				case OperatorNode::OP_BIT_INVERT: {
+					_REDUCE_UNARY(Variant::OP_BIT_NEGATE);
+				} break;
+				//binary operators (in precedence order)
+				case OperatorNode::OP_IN: {
+					_REDUCE_BINARY(Variant::OP_IN);
+				} break;
+				case OperatorNode::OP_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_EQUAL);
+				} break;
+				case OperatorNode::OP_NOT_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_NOT_EQUAL);
+				} break;
+				case OperatorNode::OP_LESS: {
+					_REDUCE_BINARY(Variant::OP_LESS);
+				} break;
+				case OperatorNode::OP_LESS_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_LESS_EQUAL);
+				} break;
+				case OperatorNode::OP_GREATER: {
+					_REDUCE_BINARY(Variant::OP_GREATER);
+				} break;
+				case OperatorNode::OP_GREATER_EQUAL: {
+					_REDUCE_BINARY(Variant::OP_GREATER_EQUAL);
+				} break;
+				case OperatorNode::OP_AND: {
+					_REDUCE_BINARY(Variant::OP_AND);
+				} break;
+				case OperatorNode::OP_OR: {
+					_REDUCE_BINARY(Variant::OP_OR);
+				} break;
+				case OperatorNode::OP_ADD: {
+					_REDUCE_BINARY(Variant::OP_ADD);
+				} break;
+				case OperatorNode::OP_SUB: {
+					_REDUCE_BINARY(Variant::OP_SUBTRACT);
+				} break;
+				case OperatorNode::OP_MUL: {
+					_REDUCE_BINARY(Variant::OP_MULTIPLY);
+				} break;
+				case OperatorNode::OP_DIV: {
+					_REDUCE_BINARY(Variant::OP_DIVIDE);
+				} break;
+				case OperatorNode::OP_MOD: {
+					_REDUCE_BINARY(Variant::OP_MODULE);
+				} break;
+				case OperatorNode::OP_SHIFT_LEFT: {
+					_REDUCE_BINARY(Variant::OP_SHIFT_LEFT);
+				} break;
+				case OperatorNode::OP_SHIFT_RIGHT: {
+					_REDUCE_BINARY(Variant::OP_SHIFT_RIGHT);
+				} break;
+				case OperatorNode::OP_BIT_AND: {
+					_REDUCE_BINARY(Variant::OP_BIT_AND);
+				} break;
+				case OperatorNode::OP_BIT_OR: {
+					_REDUCE_BINARY(Variant::OP_BIT_OR);
+				} break;
+				case OperatorNode::OP_BIT_XOR: {
+					_REDUCE_BINARY(Variant::OP_BIT_XOR);
+				} break;
+				case OperatorNode::OP_TERNARY_IF: {
+					if (static_cast<ConstantNode *>(op->arguments[0])->value.booleanize()) {
+						return op->arguments[1];
+					} else {
+						return op->arguments[2];
+					}
+				} break;
+				default: {
+					ERR_FAIL_V(op);
+				}
+			}
+
+		} break;
+		default: {
+			return p_node;
+		} break;
+	}
+}
+
+GDScriptParser::Node *GDScriptParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
+	Node *expr = _parse_expression(p_parent, p_static, p_allow_assign, p_reduce_const);
+	if (!expr || error_set) {
+		return nullptr;
+	}
+	expr = _reduce_expression(expr, p_reduce_const);
+	if (!expr || error_set) {
+		return nullptr;
+	}
+	return expr;
+}
+
+bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
+	if (p_value.get_type() == Variant::ARRAY) {
+		Array arr = p_value;
+		for (int i = 0; i < arr.size(); i++) {
+			if (!_reduce_export_var_type(arr[i], p_line)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	if (p_value.get_type() == Variant::DICTIONARY) {
+		Dictionary dict = p_value;
+		for (int i = 0; i < dict.size(); i++) {
+			Variant value = dict.get_value_at_index(i);
+			if (!_reduce_export_var_type(value, p_line)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// validate type
+	DataType type = _type_from_variant(p_value);
+	if (type.kind == DataType::BUILTIN) {
+		return true;
+	} else if (type.kind == DataType::NATIVE) {
+		if (ClassDB::is_parent_class(type.native_type, "Resource")) {
+			return true;
+		}
+	}
+	_set_error("Invalid export type. Only built-in and native resource types can be exported.", p_line);
+	return false;
+}
+
+bool GDScriptParser::_recover_from_completion() {
+	if (!completion_found) {
+		return false; //can't recover if no completion
+	}
+	//skip stuff until newline
+	while (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token() != GDScriptTokenizer::TK_EOF && tokenizer->get_token() != GDScriptTokenizer::TK_ERROR) {
+		tokenizer->advance();
+	}
+	completion_found = false;
+	error_set = false;
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
+		error_set = true;
+	}
+
+	return true;
+}
+
+GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
+	PatternNode *pattern = alloc_node<PatternNode>();
+
+	GDScriptTokenizer::Token token = tokenizer->get_token();
+	if (error_set) {
+		return nullptr;
+	}
+
+	if (token == GDScriptTokenizer::TK_EOF) {
+		return nullptr;
+	}
+
+	switch (token) {
+		// array
+		case GDScriptTokenizer::TK_BRACKET_OPEN: {
+			tokenizer->advance();
+			pattern->pt_type = GDScriptParser::PatternNode::PT_ARRAY;
+			while (true) {
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					tokenizer->advance();
+					break;
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+					// match everything
+					tokenizer->advance(2);
+					PatternNode *sub_pattern = alloc_node<PatternNode>();
+					sub_pattern->pt_type = GDScriptParser::PatternNode::PT_IGNORE_REST;
+					pattern->array.push_back(sub_pattern);
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+						tokenizer->advance(2);
+						break;
+					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+						tokenizer->advance(1);
+						break;
+					} else {
+						_set_error("'..' pattern only allowed at the end of an array pattern");
+						return nullptr;
+					}
+				}
+
+				PatternNode *sub_pattern = _parse_pattern(p_static);
+				if (!sub_pattern) {
+					return nullptr;
+				}
+
+				pattern->array.push_back(sub_pattern);
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					tokenizer->advance();
+					continue;
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					tokenizer->advance();
+					break;
+				} else {
+					_set_error("Not a valid pattern");
+					return nullptr;
+				}
+			}
+		} break;
+		// bind
+		case GDScriptTokenizer::TK_PR_VAR: {
+			tokenizer->advance();
+			if (!tokenizer->is_token_literal()) {
+				_set_error("Expected identifier for binding variable name.");
+				return nullptr;
+			}
+			pattern->pt_type = GDScriptParser::PatternNode::PT_BIND;
+			pattern->bind = tokenizer->get_token_literal();
+			// Check if variable name is already used
+			BlockNode *bl = current_block;
+			while (bl) {
+				if (bl->variables.has(pattern->bind)) {
+					_set_error("Binding name of '" + pattern->bind.operator String() + "' is already declared in this scope.");
+					return nullptr;
+				}
+				bl = bl->parent_block;
+			}
+			// Create local variable for proper identifier detection later
+			LocalVarNode *lv = alloc_node<LocalVarNode>();
+			lv->name = pattern->bind;
+			current_block->variables.insert(lv->name, lv);
+			tokenizer->advance();
+		} break;
+		// dictionary
+		case GDScriptTokenizer::TK_CURLY_BRACKET_OPEN: {
+			tokenizer->advance();
+			pattern->pt_type = GDScriptParser::PatternNode::PT_DICTIONARY;
+			while (true) {
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					tokenizer->advance();
+					break;
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+					// match everything
+					tokenizer->advance(2);
+					PatternNode *sub_pattern = alloc_node<PatternNode>();
+					sub_pattern->pt_type = PatternNode::PT_IGNORE_REST;
+					pattern->array.push_back(sub_pattern);
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+						tokenizer->advance(2);
+						break;
+					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+						tokenizer->advance(1);
+						break;
+					} else {
+						_set_error("'..' pattern only allowed at the end of a dictionary pattern");
+						return nullptr;
+					}
+				}
+
+				Node *key = _parse_and_reduce_expression(pattern, p_static);
+				if (!key) {
+					_set_error("Not a valid key in pattern");
+					return nullptr;
+				}
+
+				if (key->type != GDScriptParser::Node::TYPE_CONSTANT) {
+					_set_error("Not a constant expression as key");
+					return nullptr;
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+					tokenizer->advance();
+
+					PatternNode *value = _parse_pattern(p_static);
+					if (!value) {
+						_set_error("Expected pattern in dictionary value");
+						return nullptr;
+					}
+
+					pattern->dictionary.insert(static_cast<ConstantNode *>(key), value);
+				} else {
+					pattern->dictionary.insert(static_cast<ConstantNode *>(key), NULL);
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					tokenizer->advance();
+					continue;
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					tokenizer->advance();
+					break;
+				} else {
+					_set_error("Not a valid pattern");
+					return nullptr;
+				}
+			}
+		} break;
+		case GDScriptTokenizer::TK_WILDCARD: {
+			tokenizer->advance();
+			pattern->pt_type = PatternNode::PT_WILDCARD;
+		} break;
+		// all the constants like strings and numbers
+		default: {
+			Node *value = _parse_and_reduce_expression(pattern, p_static);
+			if (!value) {
+				_set_error("Expect constant expression or variables in a pattern");
+				return nullptr;
+			}
+
+			if (value->type == Node::TYPE_OPERATOR) {
+				// Maybe it's SomeEnum.VALUE
+				Node *current_value = value;
+
+				while (current_value->type == Node::TYPE_OPERATOR) {
+					OperatorNode *op_node = static_cast<OperatorNode *>(current_value);
+
+					if (op_node->op != OperatorNode::OP_INDEX_NAMED) {
+						_set_error("Invalid operator in pattern. Only index (`A.B`) is allowed");
+						return nullptr;
+					}
+					current_value = op_node->arguments[0];
+				}
+
+				if (current_value->type != Node::TYPE_IDENTIFIER) {
+					_set_error("Only constant expression or variables allowed in a pattern");
+					return nullptr;
+				}
+
+			} else if (value->type != Node::TYPE_IDENTIFIER && value->type != Node::TYPE_CONSTANT) {
+				_set_error("Only constant expressions or variables allowed in a pattern");
+				return nullptr;
+			}
+
+			pattern->pt_type = PatternNode::PT_CONSTANT;
+			pattern->constant = value;
+		} break;
+	}
+
+	return pattern;
+}
+
+void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static) {
+	IndentLevel current_level = indent_level.back()->get();
+
+	p_block->has_return = true;
+
+	bool catch_all_appeared = false;
+
+	while (true) {
+		while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
+			;
+		}
+
+		// GDScriptTokenizer::Token token = tokenizer->get_token();
+		if (error_set) {
+			return;
+		}
+
+		if (current_level.indent > indent_level.back()->get().indent) {
+			break; // go back a level
+		}
+
+		pending_newline = -1;
+
+		PatternBranchNode *branch = alloc_node<PatternBranchNode>();
+		branch->body = alloc_node<BlockNode>();
+		branch->body->parent_block = p_block;
+		p_block->sub_blocks.push_back(branch->body);
+		current_block = branch->body;
+
+		branch->patterns.push_back(_parse_pattern(p_static));
+		if (!branch->patterns[0]) {
+			break;
+		}
+
+		bool has_binding = branch->patterns[0]->pt_type == PatternNode::PT_BIND;
+		bool catch_all = has_binding || branch->patterns[0]->pt_type == PatternNode::PT_WILDCARD;
+
+#ifdef DEBUG_ENABLED
+		// Branches after a wildcard or binding are unreachable
+		if (catch_all_appeared && !current_function->has_unreachable_code) {
+			_add_warning(GDScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
+			current_function->has_unreachable_code = true;
+		}
+#endif
+
+		while (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+			tokenizer->advance();
+			branch->patterns.push_back(_parse_pattern(p_static));
+			if (!branch->patterns[branch->patterns.size() - 1]) {
+				return;
+			}
+
+			PatternNode::PatternType pt = branch->patterns[branch->patterns.size() - 1]->pt_type;
+
+			if (pt == PatternNode::PT_BIND) {
+				_set_error("Cannot use bindings with multipattern.");
+				return;
+			}
+
+			catch_all = catch_all || pt == PatternNode::PT_WILDCARD;
+		}
+
+		catch_all_appeared = catch_all_appeared || catch_all;
+
+		if (!_enter_indent_block()) {
+			_set_error("Expected block in pattern branch");
+			return;
+		}
+
+		_parse_block(branch->body, p_static);
+
+		current_block = p_block;
+
+		if (!branch->body->has_return) {
+			p_block->has_return = false;
+		}
+
+		p_branches.push_back(branch);
+	}
+
+	// Even if all branches return, there is possibility of default fallthrough
+	if (!catch_all_appeared) {
+		p_block->has_return = false;
+	}
+}
+
+void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings) {
+	const DataType &to_match_type = p_node_to_match->get_datatype();
+
+	switch (p_pattern->pt_type) {
+		case PatternNode::PT_CONSTANT: {
+			DataType pattern_type = _reduce_node_type(p_pattern->constant);
+			if (error_set) {
+				return;
+			}
+
+			OperatorNode *type_comp = nullptr;
+
+			// static type check if possible
+			if (pattern_type.has_type && to_match_type.has_type) {
+				if (!_is_type_compatible(to_match_type, pattern_type) && !_is_type_compatible(pattern_type, to_match_type)) {
+					_set_error("The pattern type (" + pattern_type.to_string() + ") isn't compatible with the type of the value to match (" + to_match_type.to_string() + ").",
+							p_pattern->line);
+					return;
+				}
+			} else {
+				// runtime typecheck
+				BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
+				typeof_node->function = GDScriptFunctions::TYPE_OF;
+
+				OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
+				typeof_match_value->op = OperatorNode::OP_CALL;
+				typeof_match_value->arguments.push_back(typeof_node);
+				typeof_match_value->arguments.push_back(p_node_to_match);
+
+				OperatorNode *typeof_pattern_value = alloc_node<OperatorNode>();
+				typeof_pattern_value->op = OperatorNode::OP_CALL;
+				typeof_pattern_value->arguments.push_back(typeof_node);
+				typeof_pattern_value->arguments.push_back(p_pattern->constant);
+
+				type_comp = alloc_node<OperatorNode>();
+				type_comp->op = OperatorNode::OP_EQUAL;
+				type_comp->arguments.push_back(typeof_match_value);
+				type_comp->arguments.push_back(typeof_pattern_value);
+			}
+
+			// compare the actual values
+			OperatorNode *value_comp = alloc_node<OperatorNode>();
+			value_comp->op = OperatorNode::OP_EQUAL;
+			value_comp->arguments.push_back(p_pattern->constant);
+			value_comp->arguments.push_back(p_node_to_match);
+
+			if (type_comp) {
+				OperatorNode *full_comparison = alloc_node<OperatorNode>();
+				full_comparison->op = OperatorNode::OP_AND;
+				full_comparison->arguments.push_back(type_comp);
+				full_comparison->arguments.push_back(value_comp);
+
+				p_resulting_node = full_comparison;
+			} else {
+				p_resulting_node = value_comp;
+			}
+
+		} break;
+		case PatternNode::PT_BIND: {
+			p_bindings[p_pattern->bind] = p_node_to_match;
+
+			// a bind always matches
+			ConstantNode *true_value = alloc_node<ConstantNode>();
+			true_value->value = Variant(true);
+			p_resulting_node = true_value;
+		} break;
+		case PatternNode::PT_ARRAY: {
+			bool open_ended = false;
+
+			if (p_pattern->array.size() > 0) {
+				if (p_pattern->array[p_pattern->array.size() - 1]->pt_type == PatternNode::PT_IGNORE_REST) {
+					open_ended = true;
+				}
+			}
+
+			// typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() >= length
+			// typeof(value_to_match) == TYPE_ARRAY && value_to_match.size() == length
+
+			{
+				OperatorNode *type_comp = nullptr;
+				// static type check if possible
+				if (to_match_type.has_type) {
+					// must be an array
+					if (to_match_type.kind != DataType::BUILTIN || to_match_type.builtin_type != Variant::ARRAY) {
+						_set_error("Cannot match an array pattern with a non-array expression.", p_pattern->line);
+						return;
+					}
+				} else {
+					// runtime typecheck
+					BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
+					typeof_node->function = GDScriptFunctions::TYPE_OF;
+
+					OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
+					typeof_match_value->op = OperatorNode::OP_CALL;
+					typeof_match_value->arguments.push_back(typeof_node);
+					typeof_match_value->arguments.push_back(p_node_to_match);
+
+					IdentifierNode *typeof_array = alloc_node<IdentifierNode>();
+					typeof_array->name = "TYPE_ARRAY";
+
+					type_comp = alloc_node<OperatorNode>();
+					type_comp->op = OperatorNode::OP_EQUAL;
+					type_comp->arguments.push_back(typeof_match_value);
+					type_comp->arguments.push_back(typeof_array);
+				}
+
+				// size
+				ConstantNode *length = alloc_node<ConstantNode>();
+				length->value = Variant(open_ended ? p_pattern->array.size() - 1 : p_pattern->array.size());
+
+				OperatorNode *call = alloc_node<OperatorNode>();
+				call->op = OperatorNode::OP_CALL;
+				call->arguments.push_back(p_node_to_match);
+
+				IdentifierNode *size = alloc_node<IdentifierNode>();
+				size->name = "size";
+				call->arguments.push_back(size);
+
+				OperatorNode *length_comparison = alloc_node<OperatorNode>();
+				length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
+				length_comparison->arguments.push_back(call);
+				length_comparison->arguments.push_back(length);
+
+				if (type_comp) {
+					OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
+					type_and_length_comparison->op = OperatorNode::OP_AND;
+					type_and_length_comparison->arguments.push_back(type_comp);
+					type_and_length_comparison->arguments.push_back(length_comparison);
+
+					p_resulting_node = type_and_length_comparison;
+				} else {
+					p_resulting_node = length_comparison;
+				}
+			}
+
+			for (int i = 0; i < p_pattern->array.size(); i++) {
+				PatternNode *pattern = p_pattern->array[i];
+
+				Node *condition = nullptr;
+
+				ConstantNode *index = alloc_node<ConstantNode>();
+				index->value = Variant(i);
+
+				OperatorNode *indexed_value = alloc_node<OperatorNode>();
+				indexed_value->op = OperatorNode::OP_INDEX;
+				indexed_value->arguments.push_back(p_node_to_match);
+				indexed_value->arguments.push_back(index);
+
+				_generate_pattern(pattern, indexed_value, condition, p_bindings);
+
+				// concatenate all the patterns with &&
+				OperatorNode *and_node = alloc_node<OperatorNode>();
+				and_node->op = OperatorNode::OP_AND;
+				and_node->arguments.push_back(p_resulting_node);
+				and_node->arguments.push_back(condition);
+
+				p_resulting_node = and_node;
+			}
+
+		} break;
+		case PatternNode::PT_DICTIONARY: {
+			bool open_ended = false;
+
+			if (p_pattern->array.size() > 0) {
+				open_ended = true;
+			}
+
+			// typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() >= length
+			// typeof(value_to_match) == TYPE_DICTIONARY && value_to_match.size() == length
+
+			{
+				OperatorNode *type_comp = nullptr;
+				// static type check if possible
+				if (to_match_type.has_type) {
+					// must be an dictionary
+					if (to_match_type.kind != DataType::BUILTIN || to_match_type.builtin_type != Variant::DICTIONARY) {
+						_set_error("Cannot match an dictionary pattern with a non-dictionary expression.", p_pattern->line);
+						return;
+					}
+				} else {
+					// runtime typecheck
+					BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
+					typeof_node->function = GDScriptFunctions::TYPE_OF;
+
+					OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
+					typeof_match_value->op = OperatorNode::OP_CALL;
+					typeof_match_value->arguments.push_back(typeof_node);
+					typeof_match_value->arguments.push_back(p_node_to_match);
+
+					IdentifierNode *typeof_dictionary = alloc_node<IdentifierNode>();
+					typeof_dictionary->name = "TYPE_DICTIONARY";
+
+					type_comp = alloc_node<OperatorNode>();
+					type_comp->op = OperatorNode::OP_EQUAL;
+					type_comp->arguments.push_back(typeof_match_value);
+					type_comp->arguments.push_back(typeof_dictionary);
+				}
+
+				// size
+				ConstantNode *length = alloc_node<ConstantNode>();
+				length->value = Variant(open_ended ? p_pattern->dictionary.size() - 1 : p_pattern->dictionary.size());
+
+				OperatorNode *call = alloc_node<OperatorNode>();
+				call->op = OperatorNode::OP_CALL;
+				call->arguments.push_back(p_node_to_match);
+
+				IdentifierNode *size = alloc_node<IdentifierNode>();
+				size->name = "size";
+				call->arguments.push_back(size);
+
+				OperatorNode *length_comparison = alloc_node<OperatorNode>();
+				length_comparison->op = open_ended ? OperatorNode::OP_GREATER_EQUAL : OperatorNode::OP_EQUAL;
+				length_comparison->arguments.push_back(call);
+				length_comparison->arguments.push_back(length);
+
+				if (type_comp) {
+					OperatorNode *type_and_length_comparison = alloc_node<OperatorNode>();
+					type_and_length_comparison->op = OperatorNode::OP_AND;
+					type_and_length_comparison->arguments.push_back(type_comp);
+					type_and_length_comparison->arguments.push_back(length_comparison);
+
+					p_resulting_node = type_and_length_comparison;
+				} else {
+					p_resulting_node = length_comparison;
+				}
+			}
+
+			for (Map<ConstantNode *, PatternNode *>::Element *e = p_pattern->dictionary.front(); e; e = e->next()) {
+				Node *condition = nullptr;
+
+				// check for has, then for pattern
+
+				IdentifierNode *has = alloc_node<IdentifierNode>();
+				has->name = "has";
+
+				OperatorNode *has_call = alloc_node<OperatorNode>();
+				has_call->op = OperatorNode::OP_CALL;
+				has_call->arguments.push_back(p_node_to_match);
+				has_call->arguments.push_back(has);
+				has_call->arguments.push_back(e->key());
+
+				if (e->value()) {
+					OperatorNode *indexed_value = alloc_node<OperatorNode>();
+					indexed_value->op = OperatorNode::OP_INDEX;
+					indexed_value->arguments.push_back(p_node_to_match);
+					indexed_value->arguments.push_back(e->key());
+
+					_generate_pattern(e->value(), indexed_value, condition, p_bindings);
+
+					OperatorNode *has_and_pattern = alloc_node<OperatorNode>();
+					has_and_pattern->op = OperatorNode::OP_AND;
+					has_and_pattern->arguments.push_back(has_call);
+					has_and_pattern->arguments.push_back(condition);
+
+					condition = has_and_pattern;
+
+				} else {
+					condition = has_call;
+				}
+
+				// concatenate all the patterns with &&
+				OperatorNode *and_node = alloc_node<OperatorNode>();
+				and_node->op = OperatorNode::OP_AND;
+				and_node->arguments.push_back(p_resulting_node);
+				and_node->arguments.push_back(condition);
+
+				p_resulting_node = and_node;
+			}
+
+		} break;
+		case PatternNode::PT_IGNORE_REST:
+		case PatternNode::PT_WILDCARD: {
+			// simply generate a `true`
+			ConstantNode *true_value = alloc_node<ConstantNode>();
+			true_value->value = Variant(true);
+			p_resulting_node = true_value;
+		} break;
+		default: {
+		} break;
+	}
+}
+
+void GDScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
+	IdentifierNode *id = alloc_node<IdentifierNode>();
+	id->name = "#match_value";
+	id->line = p_match_statement->line;
+	id->datatype = _reduce_node_type(p_match_statement->val_to_match);
+	if (id->datatype.has_type) {
+		_mark_line_as_safe(id->line);
+	} else {
+		_mark_line_as_unsafe(id->line);
+	}
+
+	if (error_set) {
+		return;
+	}
+
+	for (int i = 0; i < p_match_statement->branches.size(); i++) {
+		PatternBranchNode *branch = p_match_statement->branches[i];
+
+		MatchNode::CompiledPatternBranch compiled_branch;
+		compiled_branch.compiled_pattern = nullptr;
+
+		Map<StringName, Node *> binding;
+
+		for (int j = 0; j < branch->patterns.size(); j++) {
+			PatternNode *pattern = branch->patterns[j];
+			_mark_line_as_safe(pattern->line);
+
+			Map<StringName, Node *> bindings;
+			Node *resulting_node = nullptr;
+			_generate_pattern(pattern, id, resulting_node, bindings);
+
+			if (!resulting_node) {
+				return;
+			}
+
+			if (!binding.empty() && !bindings.empty()) {
+				_set_error("Multipatterns can't contain bindings");
+				return;
+			} else {
+				binding = bindings;
+			}
+
+			// Result is always a boolean
+			DataType resulting_node_type;
+			resulting_node_type.has_type = true;
+			resulting_node_type.is_constant = true;
+			resulting_node_type.kind = DataType::BUILTIN;
+			resulting_node_type.builtin_type = Variant::BOOL;
+			resulting_node->set_datatype(resulting_node_type);
+
+			if (compiled_branch.compiled_pattern) {
+				OperatorNode *or_node = alloc_node<OperatorNode>();
+				or_node->op = OperatorNode::OP_OR;
+				or_node->arguments.push_back(compiled_branch.compiled_pattern);
+				or_node->arguments.push_back(resulting_node);
+
+				compiled_branch.compiled_pattern = or_node;
+			} else {
+				// single pattern | first one
+				compiled_branch.compiled_pattern = resulting_node;
+			}
+		}
+
+		// prepare the body ...hehe
+		for (Map<StringName, Node *>::Element *e = binding.front(); e; e = e->next()) {
+			if (!branch->body->variables.has(e->key())) {
+				_set_error("Parser bug: missing pattern bind variable.", branch->line);
+				ERR_FAIL();
+			}
+
+			LocalVarNode *local_var = branch->body->variables[e->key()];
+			local_var->assign = e->value();
+			local_var->set_datatype(local_var->assign->get_datatype());
+			local_var->assignments++;
+
+			IdentifierNode *id2 = alloc_node<IdentifierNode>();
+			id2->name = local_var->name;
+			id2->datatype = local_var->datatype;
+			id2->declared_block = branch->body;
+			id2->set_datatype(local_var->assign->get_datatype());
+
+			OperatorNode *op = alloc_node<OperatorNode>();
+			op->op = OperatorNode::OP_ASSIGN;
+			op->arguments.push_back(id2);
+			op->arguments.push_back(local_var->assign);
+			local_var->assign_op = op;
+
+			branch->body->statements.insert(0, op);
+			branch->body->statements.insert(0, local_var);
+		}
+
+		compiled_branch.body = branch->body;
+
+		p_match_statement->compiled_pattern_branches.push_back(compiled_branch);
+	}
+}
+
+void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
+	IndentLevel current_level = indent_level.back()->get();
+
+#ifdef DEBUG_ENABLED
+
+	pending_newline = -1; // reset for the new block
+
+	NewLineNode *nl = alloc_node<NewLineNode>();
+
+	nl->line = tokenizer->get_token_line();
+	p_block->statements.push_back(nl);
+#endif
+
+	bool is_first_line = true;
+
+	while (true) {
+		if (!is_first_line && indent_level.back()->prev() && indent_level.back()->prev()->get().indent == current_level.indent) {
+			if (indent_level.back()->prev()->get().is_mixed(current_level)) {
+				_set_error("Mixed tabs and spaces in indentation.");
+				return;
+			}
+			// pythonic single-line expression, don't parse future lines
+			indent_level.pop_back();
+			p_block->end_line = tokenizer->get_token_line();
+			return;
+		}
+		is_first_line = false;
+
+		GDScriptTokenizer::Token token = tokenizer->get_token();
+		if (error_set) {
+			return;
+		}
+
+		if (current_level.indent > indent_level.back()->get().indent) {
+			p_block->end_line = tokenizer->get_token_line();
+			return; //go back a level
+		}
+
+		if (pending_newline != -1) {
+			NewLineNode *nl2 = alloc_node<NewLineNode>();
+			nl2->line = pending_newline;
+			p_block->statements.push_back(nl2);
+			pending_newline = -1;
+		}
+
+#ifdef DEBUG_ENABLED
+		switch (token) {
+			case GDScriptTokenizer::TK_EOF:
+			case GDScriptTokenizer::TK_ERROR:
+			case GDScriptTokenizer::TK_NEWLINE:
+			case GDScriptTokenizer::TK_CF_PASS: {
+				// will check later
+			} break;
+			default: {
+				if (p_block->has_return && !current_function->has_unreachable_code) {
+					_add_warning(GDScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
+					current_function->has_unreachable_code = true;
+				}
+			} break;
+		}
+#endif // DEBUG_ENABLED
+		switch (token) {
+			case GDScriptTokenizer::TK_EOF:
+				p_block->end_line = tokenizer->get_token_line();
+			case GDScriptTokenizer::TK_ERROR: {
+				return; //go back
+
+				//end of file!
+
+			} break;
+			case GDScriptTokenizer::TK_NEWLINE: {
+				int line = tokenizer->get_token_line();
+
+				if (!_parse_newline()) {
+					if (!error_set) {
+						p_block->end_line = tokenizer->get_token_line();
+						pending_newline = p_block->end_line;
+					}
+					return;
+				}
+
+				_mark_line_as_safe(line);
+				NewLineNode *nl2 = alloc_node<NewLineNode>();
+				nl2->line = line;
+				p_block->statements.push_back(nl2);
+
+			} break;
+			case GDScriptTokenizer::TK_CF_PASS: {
+				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_SEMICOLON && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF) {
+					_set_error("Expected \";\" or a line break.");
+					return;
+				}
+				_mark_line_as_safe(tokenizer->get_token_line());
+				tokenizer->advance();
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
+					// Ignore semicolon after 'pass'.
+					tokenizer->advance();
+				}
+			} break;
+			case GDScriptTokenizer::TK_PR_VAR: {
+				// Variable declaration and (eventual) initialization.
+
+				tokenizer->advance();
+				int var_line = tokenizer->get_token_line();
+				if (!tokenizer->is_token_literal(0, true)) {
+					_set_error("Expected an identifier for the local variable name.");
+					return;
+				}
+				StringName n = tokenizer->get_token_literal();
+				if (current_function) {
+					for (int i = 0; i < current_function->arguments.size(); i++) {
+						if (n == current_function->arguments[i]) {
+							_set_error("Variable \"" + String(n) + "\" already defined in the scope (at line " + itos(current_function->line) + ").");
+							return;
+						}
+					}
+				}
+				BlockNode *check_block = p_block;
+				while (check_block) {
+					if (check_block->variables.has(n)) {
+						_set_error("Variable \"" + String(n) + "\" already defined in the scope (at line " + itos(check_block->variables[n]->line) + ").");
+						return;
+					}
+					check_block = check_block->parent_block;
+				}
+				tokenizer->advance();
+
+				//must know when the local variable is declared
+				LocalVarNode *lv = alloc_node<LocalVarNode>();
+				lv->name = n;
+				lv->line = var_line;
+				p_block->statements.push_back(lv);
+
+				Node *assigned = nullptr;
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						lv->datatype = DataType();
+						lv->datatype.infer_type = true;
+						tokenizer->advance();
+					} else if (!_parse_type(lv->datatype)) {
+						_set_error("Expected a type for the variable.");
+						return;
+					}
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+					tokenizer->advance();
+					Node *subexpr = _parse_and_reduce_expression(p_block, p_static);
+					if (!subexpr) {
+						if (_recover_from_completion()) {
+							break;
+						}
+						return;
+					}
+
+					lv->assignments++;
+					assigned = subexpr;
+				} else {
+					assigned = _get_default_value_for_type(lv->datatype, var_line);
+				}
+				//must be added later, to avoid self-referencing.
+				p_block->variables.insert(n, lv);
+
+				IdentifierNode *id = alloc_node<IdentifierNode>();
+				id->name = n;
+				id->declared_block = p_block;
+				id->line = var_line;
+
+				OperatorNode *op = alloc_node<OperatorNode>();
+				op->op = OperatorNode::OP_ASSIGN;
+				op->arguments.push_back(id);
+				op->arguments.push_back(assigned);
+				op->line = var_line;
+				p_block->statements.push_back(op);
+				lv->assign_op = op;
+				lv->assign = assigned;
+
+				if (!_end_statement()) {
+					_set_end_statement_error("var");
+					return;
+				}
+
+			} break;
+			case GDScriptTokenizer::TK_CF_IF: {
+				tokenizer->advance();
+
+				Node *condition = _parse_and_reduce_expression(p_block, p_static);
+				if (!condition) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+
+				ControlFlowNode *cf_if = alloc_node<ControlFlowNode>();
+
+				cf_if->cf_type = ControlFlowNode::CF_IF;
+				cf_if->arguments.push_back(condition);
+
+				cf_if->body = alloc_node<BlockNode>();
+				cf_if->body->parent_block = p_block;
+				cf_if->body->if_condition = condition; //helps code completion
+
+				p_block->sub_blocks.push_back(cf_if->body);
+
+				if (!_enter_indent_block(cf_if->body)) {
+					_set_error("Expected an indented block after \"if\".");
+					p_block->end_line = tokenizer->get_token_line();
+					return;
+				}
+
+				current_block = cf_if->body;
+				_parse_block(cf_if->body, p_static);
+				current_block = p_block;
+
+				if (error_set) {
+					return;
+				}
+				p_block->statements.push_back(cf_if);
+
+				bool all_have_return = cf_if->body->has_return;
+				bool have_else = false;
+
+				while (true) {
+					while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
+						;
+					}
+
+					if (indent_level.back()->get().indent < current_level.indent) { //not at current indent level
+						p_block->end_line = tokenizer->get_token_line();
+						return;
+					}
+
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELIF) {
+						if (indent_level.back()->get().indent > current_level.indent) {
+							_set_error("Invalid indentation.");
+							return;
+						}
+
+						tokenizer->advance();
+
+						cf_if->body_else = alloc_node<BlockNode>();
+						cf_if->body_else->parent_block = p_block;
+						p_block->sub_blocks.push_back(cf_if->body_else);
+
+						ControlFlowNode *cf_else = alloc_node<ControlFlowNode>();
+						cf_else->cf_type = ControlFlowNode::CF_IF;
+
+						//condition
+						Node *condition2 = _parse_and_reduce_expression(p_block, p_static);
+						if (!condition2) {
+							if (_recover_from_completion()) {
+								break;
+							}
+							return;
+						}
+						cf_else->arguments.push_back(condition2);
+						cf_else->cf_type = ControlFlowNode::CF_IF;
+
+						cf_if->body_else->statements.push_back(cf_else);
+						cf_if = cf_else;
+						cf_if->body = alloc_node<BlockNode>();
+						cf_if->body->parent_block = p_block;
+						p_block->sub_blocks.push_back(cf_if->body);
+
+						if (!_enter_indent_block(cf_if->body)) {
+							_set_error("Expected an indented block after \"elif\".");
+							p_block->end_line = tokenizer->get_token_line();
+							return;
+						}
+
+						current_block = cf_else->body;
+						_parse_block(cf_else->body, p_static);
+						current_block = p_block;
+						if (error_set) {
+							return;
+						}
+
+						all_have_return = all_have_return && cf_else->body->has_return;
+
+					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELSE) {
+						if (indent_level.back()->get().indent > current_level.indent) {
+							_set_error("Invalid indentation.");
+							return;
+						}
+
+						tokenizer->advance();
+						cf_if->body_else = alloc_node<BlockNode>();
+						cf_if->body_else->parent_block = p_block;
+						p_block->sub_blocks.push_back(cf_if->body_else);
+
+						if (!_enter_indent_block(cf_if->body_else)) {
+							_set_error("Expected an indented block after \"else\".");
+							p_block->end_line = tokenizer->get_token_line();
+							return;
+						}
+						current_block = cf_if->body_else;
+						_parse_block(cf_if->body_else, p_static);
+						current_block = p_block;
+						if (error_set) {
+							return;
+						}
+
+						all_have_return = all_have_return && cf_if->body_else->has_return;
+						have_else = true;
+
+						break; //after else, exit
+
+					} else {
+						break;
+					}
+				}
+
+				cf_if->body->has_return = all_have_return;
+				// If there's no else block, path out of the if might not have a return
+				p_block->has_return = all_have_return && have_else;
+
+			} break;
+			case GDScriptTokenizer::TK_CF_WHILE: {
+				tokenizer->advance();
+				Node *condition2 = _parse_and_reduce_expression(p_block, p_static);
+				if (!condition2) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+
+				ControlFlowNode *cf_while = alloc_node<ControlFlowNode>();
+
+				cf_while->cf_type = ControlFlowNode::CF_WHILE;
+				cf_while->arguments.push_back(condition2);
+
+				cf_while->body = alloc_node<BlockNode>();
+				cf_while->body->parent_block = p_block;
+				cf_while->body->can_break = true;
+				cf_while->body->can_continue = true;
+				p_block->sub_blocks.push_back(cf_while->body);
+
+				if (!_enter_indent_block(cf_while->body)) {
+					_set_error("Expected an indented block after \"while\".");
+					p_block->end_line = tokenizer->get_token_line();
+					return;
+				}
+
+				current_block = cf_while->body;
+				_parse_block(cf_while->body, p_static);
+				current_block = p_block;
+				if (error_set) {
+					return;
+				}
+				p_block->statements.push_back(cf_while);
+			} break;
+			case GDScriptTokenizer::TK_CF_FOR: {
+				tokenizer->advance();
+
+				if (!tokenizer->is_token_literal(0, true)) {
+					_set_error("Identifier expected after \"for\".");
+				}
+
+				IdentifierNode *id = alloc_node<IdentifierNode>();
+				id->name = tokenizer->get_token_identifier();
+#ifdef DEBUG_ENABLED
+				for (int j = 0; j < current_class->variables.size(); j++) {
+					if (current_class->variables[j].identifier == id->name) {
+						_add_warning(GDScriptWarning::SHADOWED_VARIABLE, id->line, id->name, itos(current_class->variables[j].line));
+					}
+				}
+#endif // DEBUG_ENABLED
+
+				BlockNode *check_block = p_block;
+				while (check_block) {
+					if (check_block->variables.has(id->name)) {
+						_set_error("Variable \"" + String(id->name) + "\" already defined in the scope (at line " + itos(check_block->variables[id->name]->line) + ").");
+						return;
+					}
+					check_block = check_block->parent_block;
+				}
+
+				tokenizer->advance();
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_IN) {
+					_set_error("\"in\" expected after identifier.");
+					return;
+				}
+
+				tokenizer->advance();
+
+				Node *container = _parse_and_reduce_expression(p_block, p_static);
+				if (!container) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+
+				DataType iter_type;
+
+				if (container->type == Node::TYPE_OPERATOR) {
+					OperatorNode *op = static_cast<OperatorNode *>(container);
+					if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode *>(op->arguments[0])->function == GDScriptFunctions::GEN_RANGE) {
+						//iterating a range, so see if range() can be optimized without allocating memory, by replacing it by vectors (which can work as iterable too!)
+
+						Vector<Node *> args;
+						Vector<double> constants;
+
+						bool constant = true;
+
+						for (int i = 1; i < op->arguments.size(); i++) {
+							args.push_back(op->arguments[i]);
+							if (op->arguments[i]->type == Node::TYPE_CONSTANT) {
+								ConstantNode *c = static_cast<ConstantNode *>(op->arguments[i]);
+								if (c->value.get_type() == Variant::REAL || c->value.get_type() == Variant::INT) {
+									constants.push_back(c->value);
+								} else {
+									constant = false;
+								}
+							} else {
+								constant = false;
+							}
+						}
+
+						if (args.size() > 0 && args.size() < 4) {
+							if (constant) {
+								ConstantNode *cn = alloc_node<ConstantNode>();
+								switch (args.size()) {
+									case 1:
+										cn->value = (int)constants[0];
+										break;
+									case 2:
+										cn->value = Vector2(constants[0], constants[1]);
+										break;
+									case 3:
+										cn->value = Vector3(constants[0], constants[1], constants[2]);
+										break;
+								}
+								cn->datatype = _type_from_variant(cn->value);
+								container = cn;
+							} else {
+								OperatorNode *on = alloc_node<OperatorNode>();
+								on->op = OperatorNode::OP_CALL;
+
+								TypeNode *tn = alloc_node<TypeNode>();
+								on->arguments.push_back(tn);
+
+								switch (args.size()) {
+									case 1:
+										tn->vtype = Variant::INT;
+										break;
+									case 2:
+										tn->vtype = Variant::VECTOR2;
+										break;
+									case 3:
+										tn->vtype = Variant::VECTOR3;
+										break;
+								}
+
+								for (int i = 0; i < args.size(); i++) {
+									on->arguments.push_back(args[i]);
+								}
+
+								container = on;
+							}
+						}
+
+						iter_type.has_type = true;
+						iter_type.kind = DataType::BUILTIN;
+						iter_type.builtin_type = Variant::INT;
+					}
+				}
+
+				ControlFlowNode *cf_for = alloc_node<ControlFlowNode>();
+
+				cf_for->cf_type = ControlFlowNode::CF_FOR;
+				cf_for->arguments.push_back(id);
+				cf_for->arguments.push_back(container);
+
+				cf_for->body = alloc_node<BlockNode>();
+				cf_for->body->parent_block = p_block;
+				cf_for->body->can_break = true;
+				cf_for->body->can_continue = true;
+				p_block->sub_blocks.push_back(cf_for->body);
+
+				if (!_enter_indent_block(cf_for->body)) {
+					_set_error("Expected indented block after \"for\".");
+					p_block->end_line = tokenizer->get_token_line();
+					return;
+				}
+
+				current_block = cf_for->body;
+
+				// this is for checking variable for redefining
+				// inside this _parse_block
+				LocalVarNode *lv = alloc_node<LocalVarNode>();
+				lv->name = id->name;
+				lv->line = id->line;
+				lv->assignments++;
+				id->declared_block = cf_for->body;
+				lv->set_datatype(iter_type);
+				id->set_datatype(iter_type);
+				cf_for->body->variables.insert(id->name, lv);
+				_parse_block(cf_for->body, p_static);
+				current_block = p_block;
+
+				if (error_set) {
+					return;
+				}
+				p_block->statements.push_back(cf_for);
+			} break;
+			case GDScriptTokenizer::TK_CF_CONTINUE: {
+				BlockNode *upper_block = p_block;
+				bool is_continue_valid = false;
+				while (upper_block) {
+					if (upper_block->can_continue) {
+						is_continue_valid = true;
+						break;
+					}
+					upper_block = upper_block->parent_block;
+				}
+
+				if (!is_continue_valid) {
+					_set_error("Unexpected keyword \"continue\" outside a loop.");
+					return;
+				}
+
+				_mark_line_as_safe(tokenizer->get_token_line());
+				tokenizer->advance();
+				ControlFlowNode *cf_continue = alloc_node<ControlFlowNode>();
+				cf_continue->cf_type = ControlFlowNode::CF_CONTINUE;
+				p_block->statements.push_back(cf_continue);
+				if (!_end_statement()) {
+					_set_end_statement_error("continue");
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_CF_BREAK: {
+				BlockNode *upper_block = p_block;
+				bool is_break_valid = false;
+				while (upper_block) {
+					if (upper_block->can_break) {
+						is_break_valid = true;
+						break;
+					}
+					upper_block = upper_block->parent_block;
+				}
+
+				if (!is_break_valid) {
+					_set_error("Unexpected keyword \"break\" outside a loop.");
+					return;
+				}
+
+				_mark_line_as_safe(tokenizer->get_token_line());
+				tokenizer->advance();
+				ControlFlowNode *cf_break = alloc_node<ControlFlowNode>();
+				cf_break->cf_type = ControlFlowNode::CF_BREAK;
+				p_block->statements.push_back(cf_break);
+				if (!_end_statement()) {
+					_set_end_statement_error("break");
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_CF_RETURN: {
+				tokenizer->advance();
+				ControlFlowNode *cf_return = alloc_node<ControlFlowNode>();
+				cf_return->cf_type = ControlFlowNode::CF_RETURN;
+				cf_return->line = tokenizer->get_token_line(-1);
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON || tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+					//expect end of statement
+					p_block->statements.push_back(cf_return);
+					if (!_end_statement()) {
+						return;
+					}
+				} else {
+					//expect expression
+					Node *retexpr = _parse_and_reduce_expression(p_block, p_static);
+					if (!retexpr) {
+						if (_recover_from_completion()) {
+							break;
+						}
+						return;
+					}
+					cf_return->arguments.push_back(retexpr);
+					p_block->statements.push_back(cf_return);
+					if (!_end_statement()) {
+						_set_end_statement_error("return");
+						return;
+					}
+				}
+				p_block->has_return = true;
+
+			} break;
+			case GDScriptTokenizer::TK_CF_MATCH: {
+				tokenizer->advance();
+
+				MatchNode *match_node = alloc_node<MatchNode>();
+
+				Node *val_to_match = _parse_and_reduce_expression(p_block, p_static);
+
+				if (!val_to_match) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+
+				match_node->val_to_match = val_to_match;
+
+				if (!_enter_indent_block()) {
+					_set_error("Expected indented pattern matching block after \"match\".");
+					return;
+				}
+
+				BlockNode *compiled_branches = alloc_node<BlockNode>();
+				compiled_branches->parent_block = p_block;
+				compiled_branches->parent_class = p_block->parent_class;
+				compiled_branches->can_continue = true;
+
+				p_block->sub_blocks.push_back(compiled_branches);
+
+				_parse_pattern_block(compiled_branches, match_node->branches, p_static);
+
+				if (error_set) {
+					return;
+				}
+
+				ControlFlowNode *match_cf_node = alloc_node<ControlFlowNode>();
+				match_cf_node->cf_type = ControlFlowNode::CF_MATCH;
+				match_cf_node->match = match_node;
+				match_cf_node->body = compiled_branches;
+
+				p_block->has_return = p_block->has_return || compiled_branches->has_return;
+				p_block->statements.push_back(match_cf_node);
+
+				_end_statement();
+			} break;
+			case GDScriptTokenizer::TK_PR_ASSERT: {
+				tokenizer->advance();
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+					_set_error("Expected '(' after assert");
+					return;
+				}
+
+				int assert_line = tokenizer->get_token_line();
+
+				tokenizer->advance();
+
+				Vector<Node *> args;
+				const bool result = _parse_arguments(p_block, args, p_static);
+				if (!result) {
+					return;
+				}
+
+				if (args.empty() || args.size() > 2) {
+					_set_error("Wrong number of arguments, expected 1 or 2", assert_line);
+					return;
+				}
+
+				AssertNode *an = alloc_node<AssertNode>();
+				an->condition = _reduce_expression(args[0], p_static);
+				an->line = assert_line;
+
+				if (args.size() == 2) {
+					an->message = _reduce_expression(args[1], p_static);
+				} else {
+					ConstantNode *message_node = alloc_node<ConstantNode>();
+					message_node->value = String();
+					an->message = message_node;
+				}
+
+				p_block->statements.push_back(an);
+
+				if (!_end_statement()) {
+					_set_end_statement_error("assert");
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_PR_BREAKPOINT: {
+				tokenizer->advance();
+				BreakpointNode *bn = alloc_node<BreakpointNode>();
+				p_block->statements.push_back(bn);
+
+				if (!_end_statement()) {
+					_set_end_statement_error("breakpoint");
+					return;
+				}
+			} break;
+			default: {
+				Node *expression = _parse_and_reduce_expression(p_block, p_static, false, true);
+				if (!expression) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+				p_block->statements.push_back(expression);
+				if (!_end_statement()) {
+					// Attempt to guess a better error message if the user "retypes" a variable
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON && tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						_set_error("Unexpected ':=', use '=' instead. Expected end of statement after expression.");
+					} else {
+						_set_error(vformat("Expected end of statement after expression, got %s instead.", tokenizer->get_token_name(tokenizer->get_token())));
+					}
+					return;
+				}
+
+			} break;
+		}
+	}
+}
+
+bool GDScriptParser::_parse_newline() {
+	if (tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
+		IndentLevel current_level = indent_level.back()->get();
+		int indent = tokenizer->get_token_line_indent();
+		int tabs = tokenizer->get_token_line_tab_indent();
+		IndentLevel new_level(indent, tabs);
+
+		if (new_level.is_mixed(current_level)) {
+			_set_error("Mixed tabs and spaces in indentation.");
+			return false;
+		}
+
+		if (indent > current_level.indent) {
+			_set_error("Unexpected indentation.");
+			return false;
+		}
+
+		if (indent < current_level.indent) {
+			while (indent < current_level.indent) {
+				//exit block
+				if (indent_level.size() == 1) {
+					_set_error("Invalid indentation. Bug?");
+					return false;
+				}
+
+				indent_level.pop_back();
+
+				if (indent_level.back()->get().indent < indent) {
+					_set_error("Unindent does not match any outer indentation level.");
+					return false;
+				}
+
+				if (indent_level.back()->get().is_mixed(current_level)) {
+					_set_error("Mixed tabs and spaces in indentation.");
+					return false;
+				}
+
+				current_level = indent_level.back()->get();
+			}
+
+			tokenizer->advance();
+			return false;
+		}
+	}
+
+	tokenizer->advance();
+	return true;
+}
+
+void GDScriptParser::_parse_extends(ClassNode *p_class) {
+	if (p_class->extends_used) {
+		_set_error("\"extends\" can only be present once per script.");
+		return;
+	}
+
+	if (!p_class->constant_expressions.empty() || !p_class->subclasses.empty() || !p_class->functions.empty() || !p_class->variables.empty()) {
+		_set_error("\"extends\" must be used before anything else.");
+		return;
+	}
+
+	p_class->extends_used = true;
+
+	tokenizer->advance();
+
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type() == Variant::OBJECT) {
+		p_class->extends_class.push_back(Variant::get_type_name(Variant::OBJECT));
+		tokenizer->advance();
+		return;
+	}
+
+	// see if inheritance happens from a file
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+		Variant constant = tokenizer->get_token_constant();
+		if (constant.get_type() != Variant::STRING) {
+			_set_error("\"extends\" constant must be a string.");
+			return;
+		}
+
+		p_class->extends_file = constant;
+		tokenizer->advance();
+
+		// Add parent script as a dependency
+		String parent = constant;
+		if (parent.is_rel_path()) {
+			parent = base_path.plus_file(parent).simplify_path();
+		}
+		dependencies.push_back(parent);
+
+		if (tokenizer->get_token() != GDScriptTokenizer::TK_PERIOD) {
+			return;
+		} else {
+			tokenizer->advance();
+		}
+	}
+
+	while (true) {
+		switch (tokenizer->get_token()) {
+			case GDScriptTokenizer::TK_IDENTIFIER: {
+				StringName identifier = tokenizer->get_token_identifier();
+				p_class->extends_class.push_back(identifier);
+			} break;
+
+			case GDScriptTokenizer::TK_CURSOR:
+			case GDScriptTokenizer::TK_PERIOD:
+				break;
+
+			default: {
+				_set_error("Invalid \"extends\" syntax, expected string constant (path) and/or identifier (parent class).");
+				return;
+			}
+		}
+
+		tokenizer->advance(1);
+
+		switch (tokenizer->get_token()) {
+			case GDScriptTokenizer::TK_IDENTIFIER:
+			case GDScriptTokenizer::TK_PERIOD:
+				continue;
+			case GDScriptTokenizer::TK_CURSOR:
+				completion_type = COMPLETION_EXTENDS;
+				completion_class = current_class;
+				completion_function = current_function;
+				completion_line = tokenizer->get_token_line();
+				completion_block = current_block;
+				completion_ident_is_call = false;
+				completion_found = true;
+				return;
+			default:
+				return;
+		}
+	}
+}
+
+void GDScriptParser::_parse_class(ClassNode *p_class) {
+	IndentLevel current_level = indent_level.back()->get();
+
+	while (true) {
+		GDScriptTokenizer::Token token = tokenizer->get_token();
+		if (error_set) {
+			return;
+		}
+
+		if (current_level.indent > indent_level.back()->get().indent) {
+			p_class->end_line = tokenizer->get_token_line();
+			return; //go back a level
+		}
+
+		switch (token) {
+			case GDScriptTokenizer::TK_CURSOR: {
+				tokenizer->advance();
+			} break;
+			case GDScriptTokenizer::TK_EOF:
+				p_class->end_line = tokenizer->get_token_line();
+			case GDScriptTokenizer::TK_ERROR: {
+				return; //go back
+				//end of file!
+			} break;
+			case GDScriptTokenizer::TK_NEWLINE: {
+				if (!_parse_newline()) {
+					if (!error_set) {
+						p_class->end_line = tokenizer->get_token_line();
+					}
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_PR_EXTENDS: {
+				_mark_line_as_safe(tokenizer->get_token_line());
+				_parse_extends(p_class);
+				if (error_set) {
+					return;
+				}
+				if (!_end_statement()) {
+					_set_end_statement_error("extends");
+					return;
+				}
+
+			} break;
+			case GDScriptTokenizer::TK_PR_CLASS_NAME: {
+				_mark_line_as_safe(tokenizer->get_token_line());
+				if (p_class->owner) {
+					_set_error("\"class_name\" is only valid for the main class namespace.");
+					return;
+				}
+				if (self_path.begins_with("res://") && self_path.find("::") != -1) {
+					_set_error("\"class_name\" isn't allowed in built-in scripts.");
+					return;
+				}
+				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
+					_set_error("\"class_name\" syntax: \"class_name <UniqueName>\"");
+					return;
+				}
+				if (p_class->classname_used) {
+					_set_error("\"class_name\" can only be present once per script.");
+					return;
+				}
+
+				p_class->classname_used = true;
+
+				p_class->name = tokenizer->get_token_identifier(1);
+
+				if (self_path != String() && ScriptServer::is_global_class(p_class->name) && ScriptServer::get_global_class_path(p_class->name) != self_path) {
+					_set_error("Unique global class \"" + p_class->name + "\" already exists at path: " + ScriptServer::get_global_class_path(p_class->name));
+					return;
+				}
+
+				if (ClassDB::class_exists(p_class->name)) {
+					_set_error("The class \"" + p_class->name + "\" shadows a native class.");
+					return;
+				}
+
+				if (p_class->classname_used && ProjectSettings::get_singleton()->has_setting("autoload/" + p_class->name)) {
+					const String autoload_path = ProjectSettings::get_singleton()->get_setting("autoload/" + p_class->name);
+					if (autoload_path.begins_with("*")) {
+						// It's a singleton, and not just a regular AutoLoad script.
+						_set_error("The class \"" + p_class->name + "\" conflicts with the AutoLoad singleton of the same name, and is therefore redundant. Remove the class_name declaration to fix this error.");
+					}
+					return;
+				}
+
+				tokenizer->advance(2);
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					tokenizer->advance();
+
+					if ((tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING)) {
+#ifdef TOOLS_ENABLED
+						if (Engine::get_singleton()->is_editor_hint()) {
+							Variant constant = tokenizer->get_token_constant();
+							String icon_path = constant.operator String();
+
+							String abs_icon_path = icon_path.is_rel_path() ? self_path.get_base_dir().plus_file(icon_path).simplify_path() : icon_path;
+							if (!FileAccess::exists(abs_icon_path)) {
+								_set_error("No class icon found at: " + abs_icon_path);
+								return;
+							}
+
+							p_class->icon_path = icon_path;
+						}
+#endif
+
+						tokenizer->advance();
+					} else {
+						_set_error("The optional parameter after \"class_name\" must be a string constant file path to an icon.");
+						return;
+					}
+
+				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+					_set_error("The class icon must be separated by a comma.");
+					return;
+				}
+
+			} break;
+			case GDScriptTokenizer::TK_PR_TOOL: {
+				if (p_class->tool) {
+					_set_error("The \"tool\" keyword can only be present once per script.");
+					return;
+				}
+
+				p_class->tool = true;
+				tokenizer->advance();
+
+			} break;
+			case GDScriptTokenizer::TK_PR_CLASS: {
+				//class inside class :D
+
+				StringName name;
+
+				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
+					_set_error("\"class\" syntax: \"class <Name>:\" or \"class <Name> extends <BaseClass>:\"");
+					return;
+				}
+				name = tokenizer->get_token_identifier(1);
+				tokenizer->advance(2);
+
+				// Check if name is shadowing something else
+				if (ClassDB::class_exists(name) || ClassDB::class_exists("_" + name.operator String())) {
+					_set_error("The class \"" + String(name) + "\" shadows a native class.");
+					return;
+				}
+				if (ScriptServer::is_global_class(name)) {
+					_set_error("Can't override name of the unique global class \"" + name + "\". It already exists at: " + ScriptServer::get_global_class_path(p_class->name));
+					return;
+				}
+				ClassNode *outer_class = p_class;
+				while (outer_class) {
+					for (int i = 0; i < outer_class->subclasses.size(); i++) {
+						if (outer_class->subclasses[i]->name == name) {
+							_set_error("Another class named \"" + String(name) + "\" already exists in this scope (at line " + itos(outer_class->subclasses[i]->line) + ").");
+							return;
+						}
+					}
+					if (outer_class->constant_expressions.has(name)) {
+						_set_error("A constant named \"" + String(name) + "\" already exists in the outer class scope (at line" + itos(outer_class->constant_expressions[name].expression->line) + ").");
+						return;
+					}
+					for (int i = 0; i < outer_class->variables.size(); i++) {
+						if (outer_class->variables[i].identifier == name) {
+							_set_error("A variable named \"" + String(name) + "\" already exists in the outer class scope (at line " + itos(outer_class->variables[i].line) + ").");
+							return;
+						}
+					}
+
+					outer_class = outer_class->owner;
+				}
+
+				ClassNode *newclass = alloc_node<ClassNode>();
+				newclass->initializer = alloc_node<BlockNode>();
+				newclass->initializer->parent_class = newclass;
+				newclass->ready = alloc_node<BlockNode>();
+				newclass->ready->parent_class = newclass;
+				newclass->name = name;
+				newclass->owner = p_class;
+
+				p_class->subclasses.push_back(newclass);
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_EXTENDS) {
+					_parse_extends(newclass);
+					if (error_set) {
+						return;
+					}
+				}
+
+				if (!_enter_indent_block()) {
+					_set_error("Indented block expected.");
+					return;
+				}
+				current_class = newclass;
+				_parse_class(newclass);
+				current_class = p_class;
+
+			} break;
+			/* this is for functions....
+			case GDScriptTokenizer::TK_CF_PASS: {
+
+				tokenizer->advance(1);
+			} break;
+			*/
+			case GDScriptTokenizer::TK_PR_STATIC: {
+				tokenizer->advance();
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					_set_error("Expected \"func\".");
+					return;
+				}
+
+				FALLTHROUGH;
+			}
+			case GDScriptTokenizer::TK_PR_FUNCTION: {
+				bool _static = false;
+				pending_newline = -1;
+
+				if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_STATIC) {
+					_static = true;
+				}
+
+				tokenizer->advance();
+				StringName name;
+
+				if (_get_completable_identifier(COMPLETION_VIRTUAL_FUNC, name)) {
+				}
+
+				if (name == StringName()) {
+					_set_error("Expected an identifier after \"func\" (syntax: \"func <identifier>([arguments]):\").");
+					return;
+				}
+
+				for (int i = 0; i < p_class->functions.size(); i++) {
+					if (p_class->functions[i]->name == name) {
+						_set_error("The function \"" + String(name) + "\" already exists in this class (at line " + itos(p_class->functions[i]->line) + ").");
+					}
+				}
+				for (int i = 0; i < p_class->static_functions.size(); i++) {
+					if (p_class->static_functions[i]->name == name) {
+						_set_error("The function \"" + String(name) + "\" already exists in this class (at line " + itos(p_class->static_functions[i]->line) + ").");
+					}
+				}
+
+#ifdef DEBUG_ENABLED
+				if (p_class->constant_expressions.has(name)) {
+					_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
+				}
+				for (int i = 0; i < p_class->variables.size(); i++) {
+					if (p_class->variables[i].identifier == name) {
+						_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_VARIABLE, -1, name);
+					}
+				}
+				for (int i = 0; i < p_class->subclasses.size(); i++) {
+					if (p_class->subclasses[i]->name == name) {
+						_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
+					}
+				}
+#endif // DEBUG_ENABLED
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+					_set_error("Expected \"(\" after the identifier (syntax: \"func <identifier>([arguments]):\" ).");
+					return;
+				}
+
+				tokenizer->advance();
+
+				Vector<StringName> arguments;
+				Vector<DataType> argument_types;
+				Vector<Node *> default_values;
+#ifdef DEBUG_ENABLED
+				Vector<int> arguments_usage;
+#endif // DEBUG_ENABLED
+
+				int fnline = tokenizer->get_token_line();
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+					//has arguments
+					bool defaulting = false;
+					while (true) {
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+							tokenizer->advance();
+							continue;
+						}
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_VAR) {
+							tokenizer->advance(); //var before the identifier is allowed
+						}
+
+						if (!tokenizer->is_token_literal(0, true)) {
+							_set_error("Expected an identifier for an argument.");
+							return;
+						}
+
+						StringName argname = tokenizer->get_token_identifier();
+						for (int i = 0; i < arguments.size(); i++) {
+							if (arguments[i] == argname) {
+								_set_error("The argument name \"" + String(argname) + "\" is defined multiple times.");
+								return;
+							}
+						}
+						arguments.push_back(argname);
+#ifdef DEBUG_ENABLED
+						arguments_usage.push_back(0);
+#endif // DEBUG_ENABLED
+
+						tokenizer->advance();
+
+						DataType argtype;
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+							if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+								argtype.infer_type = true;
+								tokenizer->advance();
+							} else if (!_parse_type(argtype)) {
+								_set_error("Expected a type for an argument.");
+								return;
+							}
+						}
+						argument_types.push_back(argtype);
+
+						if (defaulting && tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
+							_set_error("Default parameter expected.");
+							return;
+						}
+
+						//tokenizer->advance();
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+							defaulting = true;
+							tokenizer->advance(1);
+							Node *defval = _parse_and_reduce_expression(p_class, _static);
+							if (!defval || error_set) {
+								return;
+							}
+
+							OperatorNode *on = alloc_node<OperatorNode>();
+							on->op = OperatorNode::OP_ASSIGN;
+							on->line = fnline;
+
+							IdentifierNode *in = alloc_node<IdentifierNode>();
+							in->name = argname;
+							in->line = fnline;
+
+							on->arguments.push_back(in);
+							on->arguments.push_back(defval);
+							/* no ..
+							if (defval->type!=Node::TYPE_CONSTANT) {
+
+								_set_error("default argument must be constant");
+							}
+							*/
+							default_values.push_back(on);
+						}
+
+						while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+							tokenizer->advance();
+						}
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+							tokenizer->advance();
+							continue;
+						} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							_set_error("Expected \",\" or \")\".");
+							return;
+						}
+
+						break;
+					}
+				}
+
+				tokenizer->advance();
+
+				BlockNode *block = alloc_node<BlockNode>();
+				block->parent_class = p_class;
+
+				FunctionNode *function = alloc_node<FunctionNode>();
+				function->name = name;
+				function->arguments = arguments;
+				function->argument_types = argument_types;
+				function->default_values = default_values;
+				function->_static = _static;
+				function->line = fnline;
+#ifdef DEBUG_ENABLED
+				function->arguments_usage = arguments_usage;
+#endif // DEBUG_ENABLED
+				function->rpc_mode = rpc_mode;
+				rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+
+				if (name == "_init") {
+					if (_static) {
+						_set_error("The constructor cannot be static.");
+						return;
+					}
+
+					if (p_class->extends_used) {
+						OperatorNode *cparent = alloc_node<OperatorNode>();
+						cparent->op = OperatorNode::OP_PARENT_CALL;
+						block->statements.push_back(cparent);
+
+						IdentifierNode *id = alloc_node<IdentifierNode>();
+						id->name = "_init";
+						cparent->arguments.push_back(id);
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+							tokenizer->advance();
+							if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+								_set_error("Expected \"(\" for parent constructor arguments.");
+								return;
+							}
+							tokenizer->advance();
+
+							if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+								//has arguments
+								parenthesis++;
+								while (true) {
+									current_function = function;
+									Node *arg = _parse_and_reduce_expression(p_class, _static);
+									if (!arg) {
+										return;
+									}
+									current_function = nullptr;
+									cparent->arguments.push_back(arg);
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+										tokenizer->advance();
+										continue;
+									} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										_set_error("Expected \",\" or \")\".");
+										return;
+									}
+
+									break;
+								}
+								parenthesis--;
+							}
+
+							tokenizer->advance();
+						}
+					} else {
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+							_set_error("Parent constructor call found for a class without inheritance.");
+							return;
+						}
+					}
+				}
+
+				DataType return_type;
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_FORWARD_ARROW) {
+					if (!_parse_type(return_type, true)) {
+						_set_error("Expected a return type for the function.");
+						return;
+					}
+				}
+
+				if (!_enter_indent_block(block)) {
+					_set_error(vformat("Indented block expected after declaration of \"%s\" function.", function->name));
+					return;
+				}
+
+				function->return_type = return_type;
+
+				if (_static) {
+					p_class->static_functions.push_back(function);
+				} else {
+					p_class->functions.push_back(function);
+				}
+
+				current_function = function;
+				function->body = block;
+				current_block = block;
+				_parse_block(block, _static);
+				current_block = nullptr;
+
+				//arguments
+			} break;
+			case GDScriptTokenizer::TK_PR_SIGNAL: {
+				_mark_line_as_safe(tokenizer->get_token_line());
+				tokenizer->advance();
+
+				if (!tokenizer->is_token_literal()) {
+					_set_error("Expected an identifier after \"signal\".");
+					return;
+				}
+
+				ClassNode::Signal sig;
+				sig.name = tokenizer->get_token_identifier();
+				sig.emissions = 0;
+				sig.line = tokenizer->get_token_line();
+
+				for (int i = 0; i < current_class->_signals.size(); i++) {
+					if (current_class->_signals[i].name == sig.name) {
+						_set_error("The signal \"" + sig.name + "\" already exists in this class (at line: " + itos(current_class->_signals[i].line) + ").");
+						return;
+					}
+				}
+
+				tokenizer->advance();
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+					tokenizer->advance();
+					while (true) {
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+							tokenizer->advance();
+							continue;
+						}
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							tokenizer->advance();
+							break;
+						}
+
+						if (!tokenizer->is_token_literal(0, true)) {
+							_set_error("Expected an identifier in a \"signal\" argument.");
+							return;
+						}
+
+						sig.arguments.push_back(tokenizer->get_token_identifier());
+						tokenizer->advance();
+
+						while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+							tokenizer->advance();
+						}
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+							tokenizer->advance();
+						} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							_set_error("Expected \",\" or \")\" after a \"signal\" parameter identifier.");
+							return;
+						}
+					}
+				}
+
+				p_class->_signals.push_back(sig);
+
+				if (!_end_statement()) {
+					_set_end_statement_error("signal");
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_PR_EXPORT: {
+				tokenizer->advance();
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+#define _ADVANCE_AND_CONSUME_NEWLINES \
+	do {                              \
+		tokenizer->advance();         \
+	} while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE)
+
+					_ADVANCE_AND_CONSUME_NEWLINES;
+					parenthesis++;
+
+					String hint_prefix = "";
+					bool is_arrayed = false;
+
+					while (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE &&
+							tokenizer->get_token_type() == Variant::ARRAY &&
+							tokenizer->get_token(1) == GDScriptTokenizer::TK_COMMA) {
+						tokenizer->advance(); // Array
+						tokenizer->advance(); // Comma
+						if (is_arrayed) {
+							hint_prefix += itos(Variant::ARRAY) + ":";
+						} else {
+							is_arrayed = true;
+						}
+					}
+
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+						Variant::Type type = tokenizer->get_token_type();
+						if (type == Variant::NIL) {
+							_set_error("Can't export null type.");
+							return;
+						}
+						if (type == Variant::OBJECT) {
+							_set_error("Can't export raw object type.");
+							return;
+						}
+						current_export.type = type;
+						current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+						_ADVANCE_AND_CONSUME_NEWLINES;
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+							// hint expected next!
+							_ADVANCE_AND_CONSUME_NEWLINES;
+
+							switch (type) {
+								case Variant::INT: {
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											WARN_DEPRECATED_MSG("Exporting bit flags hint requires string constants.");
+											break;
+										}
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+											_set_error("Expected \",\" in the bit flags hint.");
+											return;
+										}
+
+										current_export.hint = PROPERTY_HINT_FLAGS;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+
+										bool first = true;
+										while (true) {
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+												current_export = PropertyInfo();
+												_set_error("Expected a string constant in the named bit flags hint.");
+												return;
+											}
+
+											String c = tokenizer->get_token_constant();
+											if (!first) {
+												current_export.hint_string += ",";
+											} else {
+												first = false;
+											}
+
+											current_export.hint_string += c.xml_escape();
+
+											_ADVANCE_AND_CONSUME_NEWLINES;
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+												break;
+											}
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
+												_set_error("Expected \")\" or \",\" in the named bit flags hint.");
+												return;
+											}
+											_ADVANCE_AND_CONSUME_NEWLINES;
+										}
+
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_RENDER") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the layers 2D render hint.");
+											return;
+										}
+										current_export.hint = PROPERTY_HINT_LAYERS_2D_RENDER;
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_PHYSICS") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the layers 2D physics hint.");
+											return;
+										}
+										current_export.hint = PROPERTY_HINT_LAYERS_2D_PHYSICS;
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_RENDER") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the layers 3D render hint.");
+											return;
+										}
+										current_export.hint = PROPERTY_HINT_LAYERS_3D_RENDER;
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_PHYSICS") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the layers 3D physics hint.");
+											return;
+										}
+										current_export.hint = PROPERTY_HINT_LAYERS_3D_PHYSICS;
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
+										//enumeration
+										current_export.hint = PROPERTY_HINT_ENUM;
+										bool first = true;
+										while (true) {
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+												current_export = PropertyInfo();
+												_set_error("Expected a string constant in the enumeration hint.");
+												return;
+											}
+
+											String c = tokenizer->get_token_constant();
+											if (!first) {
+												current_export.hint_string += ",";
+											} else {
+												first = false;
+											}
+
+											current_export.hint_string += c.xml_escape();
+
+											_ADVANCE_AND_CONSUME_NEWLINES;
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+												break;
+											}
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
+												_set_error("Expected \")\" or \",\" in the enumeration hint.");
+												return;
+											}
+
+											_ADVANCE_AND_CONSUME_NEWLINES;
+										}
+
+										break;
+									}
+
+									FALLTHROUGH;
+								}
+								case Variant::REAL: {
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EASE") {
+										current_export.hint = PROPERTY_HINT_EXP_EASING;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the hint.");
+											return;
+										}
+										break;
+									}
+
+									// range
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EXP") {
+										current_export.hint = PROPERTY_HINT_EXP_RANGE;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											break;
+										} else if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+											_set_error("Expected \")\" or \",\" in the exponential range hint.");
+											return;
+										}
+										_ADVANCE_AND_CONSUME_NEWLINES;
+									} else {
+										current_export.hint = PROPERTY_HINT_RANGE;
+									}
+
+									float sign = 1.0;
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+										sign = -1;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+									}
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+										current_export = PropertyInfo();
+										_set_error("Expected a range in the numeric hint.");
+										return;
+									}
+
+									current_export.hint_string = rtos(sign * double(tokenizer->get_token_constant()));
+									_ADVANCE_AND_CONSUME_NEWLINES;
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										current_export.hint_string = "0," + current_export.hint_string;
+										break;
+									}
+
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+										current_export = PropertyInfo();
+										_set_error("Expected \",\" or \")\" in the numeric range hint.");
+										return;
+									}
+
+									_ADVANCE_AND_CONSUME_NEWLINES;
+
+									sign = 1.0;
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+										sign = -1;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+									}
+
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+										current_export = PropertyInfo();
+										_set_error("Expected a number as upper bound in the numeric range hint.");
+										return;
+									}
+
+									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
+									_ADVANCE_AND_CONSUME_NEWLINES;
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										break;
+									}
+
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+										current_export = PropertyInfo();
+										_set_error("Expected \",\" or \")\" in the numeric range hint.");
+										return;
+									}
+
+									_ADVANCE_AND_CONSUME_NEWLINES;
+									sign = 1.0;
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+										sign = -1;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+									}
+
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+										current_export = PropertyInfo();
+										_set_error("Expected a number as step in the numeric range hint.");
+										return;
+									}
+
+									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
+									_ADVANCE_AND_CONSUME_NEWLINES;
+
+								} break;
+								case Variant::STRING: {
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
+										//enumeration
+										current_export.hint = PROPERTY_HINT_ENUM;
+										bool first = true;
+										while (true) {
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+												current_export = PropertyInfo();
+												_set_error("Expected a string constant in the enumeration hint.");
+												return;
+											}
+
+											String c = tokenizer->get_token_constant();
+											if (!first) {
+												current_export.hint_string += ",";
+											} else {
+												first = false;
+											}
+
+											current_export.hint_string += c.xml_escape();
+											_ADVANCE_AND_CONSUME_NEWLINES;
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+												break;
+											}
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+												current_export = PropertyInfo();
+												_set_error("Expected \")\" or \",\" in the enumeration hint.");
+												return;
+											}
+											_ADVANCE_AND_CONSUME_NEWLINES;
+										}
+
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
+										_ADVANCE_AND_CONSUME_NEWLINES;
+
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											current_export.hint = PROPERTY_HINT_DIR;
+										} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+											_ADVANCE_AND_CONSUME_NEWLINES;
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
+												_set_error("Expected \"GLOBAL\" after comma in the directory hint.");
+												return;
+											}
+											if (!p_class->tool) {
+												_set_error("Global filesystem hints may only be used in tool scripts.");
+												return;
+											}
+											current_export.hint = PROPERTY_HINT_GLOBAL_DIR;
+											_ADVANCE_AND_CONSUME_NEWLINES;
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+												_set_error("Expected \")\" in the hint.");
+												return;
+											}
+										} else {
+											_set_error("Expected \")\" or \",\" in the hint.");
+											return;
+										}
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FILE") {
+										current_export.hint = PROPERTY_HINT_FILE;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+
+										if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+											_ADVANCE_AND_CONSUME_NEWLINES;
+
+											if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "GLOBAL") {
+												if (!p_class->tool) {
+													_set_error("Global filesystem hints may only be used in tool scripts.");
+													return;
+												}
+												current_export.hint = PROPERTY_HINT_GLOBAL_FILE;
+												_ADVANCE_AND_CONSUME_NEWLINES;
+
+												if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+													break;
+												} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+													_ADVANCE_AND_CONSUME_NEWLINES;
+												} else {
+													_set_error("Expected \")\" or \",\" in the hint.");
+													return;
+												}
+											}
+
+											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+												if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE) {
+													_set_error("Expected string constant with filter.");
+												} else {
+													_set_error("Expected \"GLOBAL\" or string constant with filter.");
+												}
+												return;
+											}
+											current_export.hint_string = tokenizer->get_token_constant();
+											_ADVANCE_AND_CONSUME_NEWLINES;
+										}
+
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the hint.");
+											return;
+										}
+										break;
+									}
+
+									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "MULTILINE") {
+										current_export.hint = PROPERTY_HINT_MULTILINE_TEXT;
+										_ADVANCE_AND_CONSUME_NEWLINES;
+										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											_set_error("Expected \")\" in the hint.");
+											return;
+										}
+										break;
+									}
+								} break;
+								case Variant::COLOR: {
+									if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER) {
+										current_export = PropertyInfo();
+										_set_error("Color type hint expects RGB or RGBA as hints.");
+										return;
+									}
+
+									String identifier = tokenizer->get_token_identifier();
+									if (identifier == "RGB") {
+										current_export.hint = PROPERTY_HINT_COLOR_NO_ALPHA;
+									} else if (identifier == "RGBA") {
+										//none
+									} else {
+										current_export = PropertyInfo();
+										_set_error("Color type hint expects RGB or RGBA as hints.");
+										return;
+									}
+									_ADVANCE_AND_CONSUME_NEWLINES;
+
+								} break;
+								default: {
+									current_export = PropertyInfo();
+									_set_error("Type \"" + Variant::get_type_name(type) + "\" can't take hints.");
+									return;
+								} break;
+							}
+						}
+
+					} else {
+						parenthesis++;
+						Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
+						if (!subexpr) {
+							if (_recover_from_completion()) {
+								break;
+							}
+							return;
+						}
+						parenthesis--;
+
+						if (subexpr->type != Node::TYPE_CONSTANT) {
+							current_export = PropertyInfo();
+							_set_error("Expected a constant expression.");
+							return;
+						}
+
+						Variant constant = static_cast<ConstantNode *>(subexpr)->value;
+
+						if (constant.get_type() == Variant::OBJECT) {
+							GDScriptNativeClass *native_class = Object::cast_to<GDScriptNativeClass>(constant);
+
+							if (native_class && ClassDB::is_parent_class(native_class->get_name(), "Resource")) {
+								current_export.type = Variant::OBJECT;
+								current_export.hint = PROPERTY_HINT_RESOURCE_TYPE;
+								current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+
+								current_export.hint_string = native_class->get_name();
+								current_export.class_name = native_class->get_name();
+
+							} else {
+								current_export = PropertyInfo();
+								_set_error("The export hint isn't a resource type.");
+							}
+						} else if (constant.get_type() == Variant::DICTIONARY) {
+							// Enumeration
+							bool is_flags = false;
+
+							if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+								_ADVANCE_AND_CONSUME_NEWLINES;
+
+								if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
+									is_flags = true;
+									_ADVANCE_AND_CONSUME_NEWLINES;
+								} else {
+									current_export = PropertyInfo();
+									_set_error("Expected \"FLAGS\" after comma.");
+								}
+							}
+
+							current_export.type = Variant::INT;
+							current_export.hint = is_flags ? PROPERTY_HINT_FLAGS : PROPERTY_HINT_ENUM;
+							current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+							Dictionary enum_values = constant;
+
+							List<Variant> keys;
+							enum_values.get_key_list(&keys);
+
+							bool first = true;
+							for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+								if (enum_values[E->get()].get_type() == Variant::INT) {
+									if (!first) {
+										current_export.hint_string += ",";
+									} else {
+										first = false;
+									}
+
+									current_export.hint_string += E->get().operator String().capitalize().xml_escape();
+									if (!is_flags) {
+										current_export.hint_string += ":";
+										current_export.hint_string += enum_values[E->get()].operator String().xml_escape();
+									}
+								}
+							}
+						} else {
+							current_export = PropertyInfo();
+							_set_error("Expected type for export.");
+							return;
+						}
+					}
+
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						current_export = PropertyInfo();
+						_set_error("Expected \")\" or \",\" after the export hint.");
+						return;
+					}
+
+					tokenizer->advance();
+					parenthesis--;
+
+					if (is_arrayed) {
+						hint_prefix += itos(current_export.type);
+						if (current_export.hint) {
+							hint_prefix += "/" + itos(current_export.hint);
+						}
+						current_export.hint_string = hint_prefix + ":" + current_export.hint_string;
+						current_export.hint = PROPERTY_HINT_TYPE_STRING;
+						current_export.type = Variant::ARRAY;
+					}
+#undef _ADVANCE_AND_CONSUME_NEWLINES
+				}
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPET && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPETSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVE) {
+					current_export = PropertyInfo();
+					_set_error("Expected \"var\", \"onready\", \"remote\", \"master\", \"puppet\", \"sync\", \"remotesync\", \"mastersync\", \"puppetsync\".");
+					return;
+				}
+
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_ONREADY: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+					_set_error("Expected \"var\".");
+					return;
+				}
+
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_REMOTE: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+						_set_error("Expected \"var\".");
+						return;
+					}
+
+				} else {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+						_set_error("Expected \"var\" or \"func\".");
+						return;
+					}
+				}
+				rpc_mode = MultiplayerAPI::RPC_MODE_REMOTE;
+
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_MASTER: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+						_set_error("Expected \"var\".");
+						return;
+					}
+
+				} else {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+						_set_error("Expected \"var\" or \"func\".");
+						return;
+					}
+				}
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_MASTER;
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_SLAVE:
+#ifdef DEBUG_ENABLED
+				_add_warning(GDScriptWarning::DEPRECATED_KEYWORD, tokenizer->get_token_line(), "slave", "puppet");
+#endif
+				FALLTHROUGH;
+			case GDScriptTokenizer::TK_PR_PUPPET: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (current_export.type) {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+						_set_error("Expected \"var\".");
+						return;
+					}
+
+				} else {
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+						_set_error("Expected \"var\" or \"func\".");
+						return;
+					}
+				}
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_PUPPET;
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_REMOTESYNC:
+			case GDScriptTokenizer::TK_PR_SYNC: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (current_export.type) {
+						_set_error("Expected \"var\".");
+					} else {
+						_set_error("Expected \"var\" or \"func\".");
+					}
+					return;
+				}
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_REMOTESYNC;
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_MASTERSYNC: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (current_export.type) {
+						_set_error("Expected \"var\".");
+					} else {
+						_set_error("Expected \"var\" or \"func\".");
+					}
+					return;
+				}
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_MASTERSYNC;
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_PUPPETSYNC: {
+				//may be fallthrough from export, ignore if so
+				tokenizer->advance();
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (current_export.type) {
+						_set_error("Expected \"var\".");
+					} else {
+						_set_error("Expected \"var\" or \"func\".");
+					}
+					return;
+				}
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_PUPPETSYNC;
+				continue;
+			} break;
+			case GDScriptTokenizer::TK_PR_VAR: {
+				// variable declaration and (eventual) initialization
+
+				ClassNode::Member member;
+
+				bool autoexport = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_EXPORT;
+				if (current_export.type != Variant::NIL) {
+					member._export = current_export;
+					current_export = PropertyInfo();
+				}
+
+				bool onready = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_ONREADY;
+
+				tokenizer->advance();
+				if (!tokenizer->is_token_literal(0, true)) {
+					_set_error("Expected an identifier for the member variable name.");
+					return;
+				}
+
+				member.identifier = tokenizer->get_token_literal();
+				member.expression = nullptr;
+				member._export.name = member.identifier;
+				member.line = tokenizer->get_token_line();
+				member.usages = 0;
+				member.rpc_mode = rpc_mode;
+
+				if (current_class->constant_expressions.has(member.identifier)) {
+					_set_error("A constant named \"" + String(member.identifier) + "\" already exists in this class (at line: " +
+							itos(current_class->constant_expressions[member.identifier].expression->line) + ").");
+					return;
+				}
+
+				for (int i = 0; i < current_class->variables.size(); i++) {
+					if (current_class->variables[i].identifier == member.identifier) {
+						_set_error("Variable \"" + String(member.identifier) + "\" already exists in this class (at line: " +
+								itos(current_class->variables[i].line) + ").");
+						return;
+					}
+				}
+
+				for (int i = 0; i < current_class->subclasses.size(); i++) {
+					if (current_class->subclasses[i]->name == member.identifier) {
+						_set_error("A class named \"" + String(member.identifier) + "\" already exists in this class (at line " + itos(current_class->subclasses[i]->line) + ").");
+						return;
+					}
+				}
+#ifdef DEBUG_ENABLED
+				for (int i = 0; i < current_class->functions.size(); i++) {
+					if (current_class->functions[i]->name == member.identifier) {
+						_add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
+						break;
+					}
+				}
+				for (int i = 0; i < current_class->static_functions.size(); i++) {
+					if (current_class->static_functions[i]->name == member.identifier) {
+						_add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
+						break;
+					}
+				}
+#endif // DEBUG_ENABLED
+				tokenizer->advance();
+
+				rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						member.data_type = DataType();
+						member.data_type.infer_type = true;
+						tokenizer->advance();
+					} else if (!_parse_type(member.data_type)) {
+						_set_error("Expected a type for the class variable.");
+						return;
+					}
+				}
+
+				if (autoexport && member.data_type.has_type) {
+					if (member.data_type.kind == DataType::BUILTIN) {
+						member._export.type = member.data_type.builtin_type;
+					} else if (member.data_type.kind == DataType::NATIVE) {
+						if (ClassDB::is_parent_class(member.data_type.native_type, "Resource")) {
+							member._export.type = Variant::OBJECT;
+							member._export.hint = PROPERTY_HINT_RESOURCE_TYPE;
+							member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+							member._export.hint_string = member.data_type.native_type;
+							member._export.class_name = member.data_type.native_type;
+						} else {
+							_set_error("Invalid export type. Only built-in and native resource types can be exported.", member.line);
+							return;
+						}
+
+					} else {
+						_set_error("Invalid export type. Only built-in and native resource types can be exported.", member.line);
+						return;
+					}
+				}
+
+#ifdef TOOLS_ENABLED
+				Variant::CallError ce;
+				member.default_value = Variant::construct(member._export.type, nullptr, 0, ce);
+#endif
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+#ifdef DEBUG_ENABLED
+					int line = tokenizer->get_token_line();
+#endif
+					tokenizer->advance();
+
+					Node *subexpr = _parse_and_reduce_expression(p_class, false, autoexport || member._export.type != Variant::NIL);
+					if (!subexpr) {
+						if (_recover_from_completion()) {
+							break;
+						}
+						return;
+					}
+
+					//discourage common error
+					if (!onready && subexpr->type == Node::TYPE_OPERATOR) {
+						OperatorNode *op = static_cast<OperatorNode *>(subexpr);
+						if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_SELF && op->arguments[1]->type == Node::TYPE_IDENTIFIER) {
+							IdentifierNode *id = static_cast<IdentifierNode *>(op->arguments[1]);
+							if (id->name == "get_node") {
+								_set_error("Use \"onready var " + String(member.identifier) + " = get_node(...)\" instead.");
+								return;
+							}
+						}
+					}
+
+					member.expression = subexpr;
+
+					if (autoexport && !member.data_type.has_type) {
+						if (subexpr->type != Node::TYPE_CONSTANT) {
+							_set_error("Type-less export needs a constant expression assigned to infer type.");
+							return;
+						}
+
+						ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
+						if (cn->value.get_type() == Variant::NIL) {
+							_set_error("Can't accept a null constant expression for inferring export type.");
+							return;
+						}
+
+						if (!_reduce_export_var_type(cn->value, member.line)) {
+							return;
+						}
+
+						member._export.type = cn->value.get_type();
+						member._export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
+						if (cn->value.get_type() == Variant::OBJECT) {
+							Object *obj = cn->value;
+							Resource *res = Object::cast_to<Resource>(obj);
+							if (res == nullptr) {
+								_set_error("The exported constant isn't a type or resource.");
+								return;
+							}
+							member._export.hint = PROPERTY_HINT_RESOURCE_TYPE;
+							member._export.hint_string = res->get_class();
+						}
+					}
+#ifdef TOOLS_ENABLED
+					// Warn if the default value set is not the same as the export type, since it won't be coerced and
+					// may create wrong expectations.
+					if (subexpr->type == Node::TYPE_CONSTANT && (member._export.type != Variant::NIL || member.data_type.has_type)) {
+						ConstantNode *cn = static_cast<ConstantNode *>(subexpr);
+						if (cn->value.get_type() != Variant::NIL) {
+							if (member._export.type != Variant::NIL && cn->value.get_type() != member._export.type) {
+								if (!Variant::can_convert(cn->value.get_type(), member._export.type)) {
+									_set_error("Can't convert the provided value to the export type.");
+									return;
+								} else if (!member.data_type.has_type) {
+									_add_warning(GDScriptWarning::EXPORT_HINT_TYPE_MISTMATCH, member.line, Variant::get_type_name(cn->value.get_type()), Variant::get_type_name(member._export.type));
+								}
+							}
+						}
+						member.default_value = cn->value;
+					}
+#endif
+
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = member.identifier;
+					id->datatype = member.data_type;
+
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_INIT_ASSIGN;
+					op->arguments.push_back(id);
+					op->arguments.push_back(subexpr);
+
+#ifdef DEBUG_ENABLED
+					NewLineNode *nl2 = alloc_node<NewLineNode>();
+					nl2->line = line;
+					if (onready) {
+						p_class->ready->statements.push_back(nl2);
+					} else {
+						p_class->initializer->statements.push_back(nl2);
+					}
+#endif
+					if (onready) {
+						p_class->ready->statements.push_back(op);
+					} else {
+						p_class->initializer->statements.push_back(op);
+					}
+
+					member.initial_assignment = op;
+
+				} else {
+					if (autoexport && !member.data_type.has_type) {
+						_set_error("Type-less export needs a constant expression assigned to infer type.");
+						return;
+					}
+
+					Node *expr;
+
+					if (member.data_type.has_type) {
+						expr = _get_default_value_for_type(member.data_type);
+					} else {
+						DataType exported_type;
+						exported_type.has_type = true;
+						exported_type.kind = DataType::BUILTIN;
+						exported_type.builtin_type = member._export.type;
+						expr = _get_default_value_for_type(exported_type);
+					}
+
+					IdentifierNode *id = alloc_node<IdentifierNode>();
+					id->name = member.identifier;
+					id->datatype = member.data_type;
+
+					OperatorNode *op = alloc_node<OperatorNode>();
+					op->op = OperatorNode::OP_INIT_ASSIGN;
+					op->arguments.push_back(id);
+					op->arguments.push_back(expr);
+
+					p_class->initializer->statements.push_back(op);
+
+					member.initial_assignment = op;
+				}
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_SETGET) {
+					tokenizer->advance();
+
+					if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+						//just comma means using only getter
+						if (!tokenizer->is_token_literal()) {
+							_set_error("Expected an identifier for the setter function after \"setget\".");
+						}
+
+						member.setter = tokenizer->get_token_literal();
+
+						tokenizer->advance();
+					}
+
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+						//there is a getter
+						tokenizer->advance();
+
+						if (!tokenizer->is_token_literal()) {
+							_set_error("Expected an identifier for the getter function after \",\".");
+						}
+
+						member.getter = tokenizer->get_token_literal();
+						tokenizer->advance();
+					}
+				}
+
+				p_class->variables.push_back(member);
+
+				if (!_end_statement()) {
+					_set_end_statement_error("var");
+					return;
+				}
+			} break;
+			case GDScriptTokenizer::TK_PR_CONST: {
+				// constant declaration and initialization
+
+				ClassNode::Constant constant;
+
+				tokenizer->advance();
+				if (!tokenizer->is_token_literal(0, true)) {
+					_set_error("Expected an identifier for the constant.");
+					return;
+				}
+
+				StringName const_id = tokenizer->get_token_literal();
+				int line = tokenizer->get_token_line();
+
+				if (current_class->constant_expressions.has(const_id)) {
+					_set_error("Constant \"" + String(const_id) + "\" already exists in this class (at line " +
+							itos(current_class->constant_expressions[const_id].expression->line) + ").");
+					return;
+				}
+
+				for (int i = 0; i < current_class->variables.size(); i++) {
+					if (current_class->variables[i].identifier == const_id) {
+						_set_error("A variable named \"" + String(const_id) + "\" already exists in this class (at line " +
+								itos(current_class->variables[i].line) + ").");
+						return;
+					}
+				}
+
+				for (int i = 0; i < current_class->subclasses.size(); i++) {
+					if (current_class->subclasses[i]->name == const_id) {
+						_set_error("A class named \"" + String(const_id) + "\" already exists in this class (at line " + itos(current_class->subclasses[i]->line) + ").");
+						return;
+					}
+				}
+
+				tokenizer->advance();
+
+				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						constant.type = DataType();
+						constant.type.infer_type = true;
+						tokenizer->advance();
+					} else if (!_parse_type(constant.type)) {
+						_set_error("Expected a type for the class constant.");
+						return;
+					}
+				}
+
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
+					_set_error("Constants must be assigned immediately.");
+					return;
+				}
+
+				tokenizer->advance();
+
+				Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
+				if (!subexpr) {
+					if (_recover_from_completion()) {
+						break;
+					}
+					return;
+				}
+
+				if (subexpr->type != Node::TYPE_CONSTANT) {
+					_set_error("Expected a constant expression.", line);
+					return;
+				}
+				subexpr->line = line;
+				constant.expression = subexpr;
+
+				p_class->constant_expressions.insert(const_id, constant);
+
+				if (!_end_statement()) {
+					_set_end_statement_error("const");
+					return;
+				}
+
+			} break;
+			case GDScriptTokenizer::TK_PR_ENUM: {
+				//multiple constant declarations..
+
+				int last_assign = -1; // Incremented by 1 right before the assignment.
+				String enum_name;
+				Dictionary enum_dict;
+				int enum_start_line = tokenizer->get_token_line();
+
+				tokenizer->advance();
+				if (tokenizer->is_token_literal(0, true)) {
+					enum_name = tokenizer->get_token_literal();
+
+					if (current_class->constant_expressions.has(enum_name)) {
+						_set_error("A constant named \"" + String(enum_name) + "\" already exists in this class (at line " +
+								itos(current_class->constant_expressions[enum_name].expression->line) + ").");
+						return;
+					}
+
+					for (int i = 0; i < current_class->variables.size(); i++) {
+						if (current_class->variables[i].identifier == enum_name) {
+							_set_error("A variable named \"" + String(enum_name) + "\" already exists in this class (at line " +
+									itos(current_class->variables[i].line) + ").");
+							return;
+						}
+					}
+
+					for (int i = 0; i < current_class->subclasses.size(); i++) {
+						if (current_class->subclasses[i]->name == enum_name) {
+							_set_error("A class named \"" + String(enum_name) + "\" already exists in this class (at line " + itos(current_class->subclasses[i]->line) + ").");
+							return;
+						}
+					}
+
+					tokenizer->advance();
+				}
+				if (tokenizer->get_token() != GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
+					_set_error("Expected \"{\" in the enum declaration.");
+					return;
+				}
+				tokenizer->advance();
+
+				while (true) {
+					if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+						tokenizer->advance(); // Ignore newlines
+					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+						tokenizer->advance();
+						break; // End of enum
+					} else if (!tokenizer->is_token_literal(0, true)) {
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+							_set_error("Unexpected end of file.");
+						} else {
+							_set_error(String("Unexpected ") + GDScriptTokenizer::get_token_name(tokenizer->get_token()) + ", expected an identifier.");
+						}
+
+						return;
+					} else { // tokenizer->is_token_literal(0, true)
+						StringName const_id = tokenizer->get_token_literal();
+
+						tokenizer->advance();
+
+						ConstantNode *enum_value_expr;
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+							tokenizer->advance();
+
+							Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
+							if (!subexpr) {
+								if (_recover_from_completion()) {
+									break;
+								}
+								return;
+							}
+
+							if (subexpr->type != Node::TYPE_CONSTANT) {
+								_set_error("Expected a constant expression.");
+								return;
+							}
+
+							enum_value_expr = static_cast<ConstantNode *>(subexpr);
+
+							if (enum_value_expr->value.get_type() != Variant::INT) {
+								_set_error("Expected an integer value for \"enum\".");
+								return;
+							}
+
+							last_assign = enum_value_expr->value;
+
+						} else {
+							last_assign = last_assign + 1;
+							enum_value_expr = alloc_node<ConstantNode>();
+							enum_value_expr->value = last_assign;
+							enum_value_expr->datatype = _type_from_variant(enum_value_expr->value);
+						}
+
+						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+							tokenizer->advance();
+						} else if (tokenizer->is_token_literal(0, true)) {
+							_set_error("Unexpected identifier.");
+							return;
+						}
+
+						if (enum_name != "") {
+							enum_dict[const_id] = enum_value_expr->value;
+						} else {
+							if (current_class->constant_expressions.has(const_id)) {
+								_set_error("A constant named \"" + String(const_id) + "\" already exists in this class (at line " +
+										itos(current_class->constant_expressions[const_id].expression->line) + ").");
+								return;
+							}
+
+							for (int i = 0; i < current_class->variables.size(); i++) {
+								if (current_class->variables[i].identifier == const_id) {
+									_set_error("A variable named \"" + String(const_id) + "\" already exists in this class (at line " +
+											itos(current_class->variables[i].line) + ").");
+									return;
+								}
+							}
+
+							for (int i = 0; i < current_class->subclasses.size(); i++) {
+								if (current_class->subclasses[i]->name == const_id) {
+									_set_error("A class named \"" + String(const_id) + "\" already exists in this class (at line " + itos(current_class->subclasses[i]->line) + ").");
+									return;
+								}
+							}
+
+							ClassNode::Constant constant;
+							constant.type.has_type = true;
+							constant.type.kind = DataType::BUILTIN;
+							constant.type.builtin_type = Variant::INT;
+							constant.expression = enum_value_expr;
+							p_class->constant_expressions.insert(const_id, constant);
+						}
+					}
+				}
+
+				if (enum_name != "") {
+					ClassNode::Constant enum_constant;
+					ConstantNode *cn = alloc_node<ConstantNode>();
+					cn->value = enum_dict;
+					cn->datatype = _type_from_variant(cn->value);
+					cn->line = enum_start_line;
+
+					enum_constant.expression = cn;
+					enum_constant.type = cn->datatype;
+					p_class->constant_expressions.insert(enum_name, enum_constant);
+				}
+
+				if (!_end_statement()) {
+					_set_end_statement_error("enum");
+					return;
+				}
+
+			} break;
+
+			case GDScriptTokenizer::TK_CONSTANT: {
+				if (tokenizer->get_token_constant().get_type() == Variant::STRING) {
+					tokenizer->advance();
+					// Ignore
+				} else {
+					_set_error(String() + "Unexpected constant of type: " + Variant::get_type_name(tokenizer->get_token_constant().get_type()));
+					return;
+				}
+			} break;
+
+			case GDScriptTokenizer::TK_CF_PASS: {
+				tokenizer->advance();
+			} break;
+
+			default: {
+				if (token == GDScriptTokenizer::TK_IDENTIFIER) {
+					completion_type = COMPLETION_IDENTIFIER;
+					completion_class = current_class;
+					completion_function = current_function;
+					completion_line = tokenizer->get_token_line();
+					completion_block = current_block;
+					completion_ident_is_call = false;
+					completion_found = true;
+				}
+
+				_set_error(String() + "Unexpected token: " + tokenizer->get_token_name(tokenizer->get_token()) + ":" + tokenizer->get_token_identifier());
+				return;
+
+			} break;
+		}
+	}
+}
+
+void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive) {
+	if (p_class->base_type.has_type) {
+		// Already determined
+	} else if (p_class->extends_used) {
+		//do inheritance
+		String path = p_class->extends_file;
+
+		Ref<GDScript> script;
+		StringName native;
+		ClassNode *base_class = nullptr;
+
+		if (path != "") {
+			//path (and optionally subclasses)
+
+			if (path.is_rel_path()) {
+				String base = base_path;
+
+				if (base == "" || base.is_rel_path()) {
+					_set_error("Couldn't resolve relative path for the parent class: " + path, p_class->line);
+					return;
+				}
+				path = base.plus_file(path).simplify_path();
+			}
+			script = ResourceLoader::load(path);
+			if (script.is_null()) {
+				_set_error("Couldn't load the base class: " + path, p_class->line);
+				return;
+			}
+			if (!script->is_valid()) {
+				_set_error("Script isn't fully loaded (cyclic preload?): " + path, p_class->line);
+				return;
+			}
+
+			if (p_class->extends_class.size()) {
+				for (int i = 0; i < p_class->extends_class.size(); i++) {
+					String sub = p_class->extends_class[i];
+					if (script->get_subclasses().has(sub)) {
+						Ref<Script> subclass = script->get_subclasses()[sub]; //avoid reference from disappearing
+						script = subclass;
+					} else {
+						_set_error("Couldn't find the subclass: " + sub, p_class->line);
+						return;
+					}
+				}
+			}
+
+		} else {
+			if (p_class->extends_class.size() == 0) {
+				_set_error("Parser bug: undecidable inheritance.", p_class->line);
+				ERR_FAIL();
+			}
+			//look around for the subclasses
+
+			int extend_iter = 1;
+			String base = p_class->extends_class[0];
+			ClassNode *p = p_class->owner;
+			Ref<GDScript> base_script;
+
+			if (ScriptServer::is_global_class(base)) {
+				base_script = ResourceLoader::load(ScriptServer::get_global_class_path(base));
+				if (!base_script.is_valid()) {
+					_set_error("The class \"" + base + "\" couldn't be fully loaded (script error or cyclic dependency).", p_class->line);
+					return;
+				}
+				p = nullptr;
+			} else {
+				List<PropertyInfo> props;
+				ProjectSettings::get_singleton()->get_property_list(&props);
+				for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+					String s = E->get().name;
+					if (!s.begins_with("autoload/")) {
+						continue;
+					}
+					String name = s.get_slice("/", 1);
+					if (name == base) {
+						String singleton_path = ProjectSettings::get_singleton()->get(s);
+						if (singleton_path.begins_with("*")) {
+							singleton_path = singleton_path.right(1);
+						}
+						if (!singleton_path.begins_with("res://")) {
+							singleton_path = "res://" + singleton_path;
+						}
+						base_script = ResourceLoader::load(singleton_path);
+						if (!base_script.is_valid()) {
+							_set_error("Class '" + base + "' could not be fully loaded (script error or cyclic inheritance).", p_class->line);
+							return;
+						}
+						p = nullptr;
+					}
+				}
+			}
+
+			while (p) {
+				bool found = false;
+
+				for (int i = 0; i < p->subclasses.size(); i++) {
+					if (p->subclasses[i]->name == base) {
+						ClassNode *test = p->subclasses[i];
+						while (test) {
+							if (test == p_class) {
+								_set_error("Cyclic inheritance.", test->line);
+								return;
+							}
+							if (test->base_type.kind == DataType::CLASS) {
+								test = test->base_type.class_type;
+							} else {
+								break;
+							}
+						}
+						found = true;
+						if (extend_iter < p_class->extends_class.size()) {
+							// Keep looking at current classes if possible
+							base = p_class->extends_class[extend_iter++];
+							p = p->subclasses[i];
+						} else {
+							base_class = p->subclasses[i];
+						}
+						break;
+					}
+				}
+
+				if (base_class) {
+					break;
+				}
+				if (found) {
+					continue;
+				}
+
+				if (p->constant_expressions.has(base)) {
+					if (p->constant_expressions[base].expression->type != Node::TYPE_CONSTANT) {
+						_set_error("Couldn't resolve the constant \"" + base + "\".", p_class->line);
+						return;
+					}
+					const ConstantNode *cn = static_cast<const ConstantNode *>(p->constant_expressions[base].expression);
+					base_script = cn->value;
+					if (base_script.is_null()) {
+						_set_error("Constant isn't a class: " + base, p_class->line);
+						return;
+					}
+					break;
+				}
+
+				p = p->owner;
+			}
+
+			if (base_script.is_valid()) {
+				String ident = base;
+				Ref<GDScript> find_subclass = base_script;
+
+				for (int i = extend_iter; i < p_class->extends_class.size(); i++) {
+					String subclass = p_class->extends_class[i];
+
+					ident += ("." + subclass);
+
+					if (find_subclass->get_subclasses().has(subclass)) {
+						find_subclass = find_subclass->get_subclasses()[subclass];
+					} else if (find_subclass->get_constants().has(subclass)) {
+						Ref<GDScript> new_base_class = find_subclass->get_constants()[subclass];
+						if (new_base_class.is_null()) {
+							_set_error("Constant isn't a class: " + ident, p_class->line);
+							return;
+						}
+						find_subclass = new_base_class;
+					} else {
+						_set_error("Couldn't find the subclass: " + ident, p_class->line);
+						return;
+					}
+				}
+
+				script = find_subclass;
+
+			} else if (!base_class) {
+				if (p_class->extends_class.size() > 1) {
+					_set_error("Invalid inheritance (unknown class + subclasses).", p_class->line);
+					return;
+				}
+				//if not found, try engine classes
+				if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
+					_set_error("Unknown class: \"" + base + "\"", p_class->line);
+					return;
+				}
+
+				native = base;
+			}
+		}
+
+		if (base_class) {
+			p_class->base_type.has_type = true;
+			p_class->base_type.kind = DataType::CLASS;
+			p_class->base_type.class_type = base_class;
+		} else if (script.is_valid()) {
+			p_class->base_type.has_type = true;
+			p_class->base_type.kind = DataType::GDSCRIPT;
+			p_class->base_type.script_type = script;
+			p_class->base_type.native_type = script->get_instance_base_type();
+		} else if (native != StringName()) {
+			p_class->base_type.has_type = true;
+			p_class->base_type.kind = DataType::NATIVE;
+			p_class->base_type.native_type = native;
+		} else {
+			_set_error("Couldn't determine inheritance.", p_class->line);
+			return;
+		}
+
+	} else {
+		// without extends, implicitly extend Reference
+		p_class->base_type.has_type = true;
+		p_class->base_type.kind = DataType::NATIVE;
+		p_class->base_type.native_type = "Reference";
+	}
+
+	if (p_recursive) {
+		// Recursively determine subclasses
+		for (int i = 0; i < p_class->subclasses.size(); i++) {
+			_determine_inheritance(p_class->subclasses[i], p_recursive);
+		}
+	}
+}
+
+String GDScriptParser::DataType::to_string() const {
+	if (!has_type) {
+		return "var";
+	}
+	switch (kind) {
+		case BUILTIN: {
+			if (builtin_type == Variant::NIL) {
+				return "null";
+			}
+			return Variant::get_type_name(builtin_type);
+		} break;
+		case NATIVE: {
+			if (is_meta_type) {
+				return "GDScriptNativeClass";
+			}
+			return native_type.operator String();
+		} break;
+
+		case GDSCRIPT: {
+			Ref<GDScript> gds = script_type;
+			const String &gds_class = gds->get_script_class_name();
+			if (!gds_class.empty()) {
+				return gds_class;
+			}
+			FALLTHROUGH;
+		}
+		case SCRIPT: {
+			if (is_meta_type) {
+				return script_type->get_class_name().operator String();
+			}
+			String name = script_type->get_name();
+			if (name != String()) {
+				return name;
+			}
+			name = script_type->get_path().get_file();
+			if (name != String()) {
+				return name;
+			}
+			return native_type.operator String();
+		} break;
+		case CLASS: {
+			ERR_FAIL_COND_V(!class_type, String());
+			if (is_meta_type) {
+				return "GDScript";
+			}
+			if (class_type->name == StringName()) {
+				return "self";
+			}
+			return class_type->name.operator String();
+		} break;
+		case UNRESOLVED: {
+		} break;
+	}
+
+	return "Unresolved";
+}
+
+bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
+	tokenizer->advance();
+	r_type.has_type = true;
+
+	bool finished = false;
+	bool can_index = false;
+	String full_name;
+
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+		completion_cursor = StringName();
+		completion_type = COMPLETION_TYPE_HINT;
+		completion_class = current_class;
+		completion_function = current_function;
+		completion_line = tokenizer->get_token_line();
+		completion_argument = 0;
+		completion_block = current_block;
+		completion_found = true;
+		completion_ident_is_call = p_can_be_void;
+		tokenizer->advance();
+	}
+
+	switch (tokenizer->get_token()) {
+		case GDScriptTokenizer::TK_PR_VOID: {
+			if (!p_can_be_void) {
+				return false;
+			}
+			r_type.kind = DataType::BUILTIN;
+			r_type.builtin_type = Variant::NIL;
+		} break;
+		case GDScriptTokenizer::TK_BUILT_IN_TYPE: {
+			r_type.builtin_type = tokenizer->get_token_type();
+			if (tokenizer->get_token_type() == Variant::OBJECT) {
+				r_type.kind = DataType::NATIVE;
+				r_type.native_type = "Object";
+			} else {
+				r_type.kind = DataType::BUILTIN;
+			}
+		} break;
+		case GDScriptTokenizer::TK_IDENTIFIER: {
+			r_type.native_type = tokenizer->get_token_identifier();
+			if (ClassDB::class_exists(r_type.native_type) || ClassDB::class_exists("_" + r_type.native_type.operator String())) {
+				r_type.kind = DataType::NATIVE;
+			} else {
+				r_type.kind = DataType::UNRESOLVED;
+				can_index = true;
+				full_name = r_type.native_type;
+			}
+		} break;
+		default: {
+			return false;
+		}
+	}
+
+	tokenizer->advance();
+
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+		completion_cursor = r_type.native_type;
+		completion_type = COMPLETION_TYPE_HINT;
+		completion_class = current_class;
+		completion_function = current_function;
+		completion_line = tokenizer->get_token_line();
+		completion_argument = 0;
+		completion_block = current_block;
+		completion_found = true;
+		completion_ident_is_call = p_can_be_void;
+		tokenizer->advance();
+	}
+
+	if (can_index) {
+		while (!finished) {
+			switch (tokenizer->get_token()) {
+				case GDScriptTokenizer::TK_PERIOD: {
+					if (!can_index) {
+						_set_error("Unexpected \".\".");
+						return false;
+					}
+					can_index = false;
+					tokenizer->advance();
+				} break;
+				case GDScriptTokenizer::TK_IDENTIFIER: {
+					if (can_index) {
+						_set_error("Unexpected identifier.");
+						return false;
+					}
+
+					StringName id;
+					bool has_completion = _get_completable_identifier(COMPLETION_TYPE_HINT_INDEX, id);
+					if (id == StringName()) {
+						id = "@temp";
+					}
+
+					full_name += "." + id.operator String();
+					can_index = true;
+					if (has_completion) {
+						completion_cursor = full_name;
+					}
+				} break;
+				default: {
+					finished = true;
+				} break;
+			}
+		}
+
+		if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PERIOD) {
+			_set_error("Expected a subclass identifier.");
+			return false;
+		}
+
+		r_type.native_type = full_name;
+	}
+
+	return true;
+}
+
+GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source, int p_line) {
+	if (!p_source.has_type) {
+		return p_source;
+	}
+	if (p_source.kind != DataType::UNRESOLVED) {
+		return p_source;
+	}
+
+	Vector<String> full_name = p_source.native_type.operator String().split(".", false);
+	int name_part = 0;
+
+	DataType result;
+	result.has_type = true;
+
+	while (name_part < full_name.size()) {
+		bool found = false;
+		StringName id = full_name[name_part];
+		DataType base_type = result;
+
+		ClassNode *p = nullptr;
+		if (name_part == 0) {
+			if (ScriptServer::is_global_class(id)) {
+				String script_path = ScriptServer::get_global_class_path(id);
+				if (script_path == self_path) {
+					result.kind = DataType::CLASS;
+					result.class_type = static_cast<ClassNode *>(head);
+				} else {
+					Ref<Script> script = ResourceLoader::load(script_path);
+					Ref<GDScript> gds = script;
+					if (gds.is_valid()) {
+						if (!gds->is_valid()) {
+							_set_error("The class \"" + id + "\" couldn't be fully loaded (script error or cyclic dependency).", p_line);
+							return DataType();
+						}
+						result.kind = DataType::GDSCRIPT;
+						result.script_type = gds;
+					} else if (script.is_valid()) {
+						result.kind = DataType::SCRIPT;
+						result.script_type = script;
+					} else {
+						_set_error("The class \"" + id + "\" was found in global scope, but its script couldn't be loaded.", p_line);
+						return DataType();
+					}
+				}
+				name_part++;
+				continue;
+			}
+			List<PropertyInfo> props;
+			ProjectSettings::get_singleton()->get_property_list(&props);
+			String singleton_path;
+			for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+				String s = E->get().name;
+				if (!s.begins_with("autoload/")) {
+					continue;
+				}
+				String name = s.get_slice("/", 1);
+				if (name == id) {
+					singleton_path = ProjectSettings::get_singleton()->get(s);
+					if (singleton_path.begins_with("*")) {
+						singleton_path = singleton_path.right(1);
+					}
+					if (!singleton_path.begins_with("res://")) {
+						singleton_path = "res://" + singleton_path;
+					}
+					break;
+				}
+			}
+			if (!singleton_path.empty()) {
+				Ref<Script> script = ResourceLoader::load(singleton_path);
+				Ref<GDScript> gds = script;
+				if (gds.is_valid()) {
+					if (!gds->is_valid()) {
+						_set_error("Class '" + id + "' could not be fully loaded (script error or cyclic inheritance).", p_line);
+						return DataType();
+					}
+					result.kind = DataType::GDSCRIPT;
+					result.script_type = gds;
+				} else if (script.is_valid()) {
+					result.kind = DataType::SCRIPT;
+					result.script_type = script;
+				} else {
+					_set_error("Couldn't fully load singleton script '" + id + "' (possible cyclic reference or parse error).", p_line);
+					return DataType();
+				}
+				name_part++;
+				continue;
+			}
+
+			p = current_class;
+		} else if (base_type.kind == DataType::CLASS) {
+			p = base_type.class_type;
+		}
+		while (p) {
+			if (p->constant_expressions.has(id)) {
+				if (p->constant_expressions[id].expression->type != Node::TYPE_CONSTANT) {
+					_set_error("Parser bug: unresolved constant.", p_line);
+					ERR_FAIL_V(result);
+				}
+				const ConstantNode *cn = static_cast<const ConstantNode *>(p->constant_expressions[id].expression);
+				Ref<GDScript> gds = cn->value;
+				if (gds.is_valid()) {
+					result.kind = DataType::GDSCRIPT;
+					result.script_type = gds;
+					found = true;
+				} else {
+					Ref<Script> scr = cn->value;
+					if (scr.is_valid()) {
+						result.kind = DataType::SCRIPT;
+						result.script_type = scr;
+						found = true;
+					}
+				}
+				break;
+			}
+
+			// Inner classes
+			ClassNode *outer_class = p;
+			while (outer_class) {
+				if (outer_class->name == id) {
+					found = true;
+					result.kind = DataType::CLASS;
+					result.class_type = outer_class;
+					break;
+				}
+				for (int i = 0; i < outer_class->subclasses.size(); i++) {
+					if (outer_class->subclasses[i] == p) {
+						continue;
+					}
+					if (outer_class->subclasses[i]->name == id) {
+						found = true;
+						result.kind = DataType::CLASS;
+						result.class_type = outer_class->subclasses[i];
+						break;
+					}
+				}
+				if (found) {
+					break;
+				}
+				outer_class = outer_class->owner;
+			}
+
+			if (!found && p->base_type.kind == DataType::CLASS) {
+				p = p->base_type.class_type;
+			} else {
+				base_type = p->base_type;
+				break;
+			}
+		}
+
+		// Still look for class constants in parent scripts
+		if (!found && (base_type.kind == DataType::GDSCRIPT || base_type.kind == DataType::SCRIPT)) {
+			Ref<Script> scr = base_type.script_type;
+			ERR_FAIL_COND_V(scr.is_null(), result);
+			while (scr.is_valid()) {
+				Map<StringName, Variant> constants;
+				scr->get_constants(&constants);
+
+				if (constants.has(id)) {
+					Ref<GDScript> gds = constants[id];
+
+					if (gds.is_valid()) {
+						result.kind = DataType::GDSCRIPT;
+						result.script_type = gds;
+						found = true;
+					} else {
+						Ref<Script> scr2 = constants[id];
+						if (scr2.is_valid()) {
+							result.kind = DataType::SCRIPT;
+							result.script_type = scr2;
+							found = true;
+						}
+					}
+				}
+				if (found) {
+					break;
+				} else {
+					scr = scr->get_base_script();
+				}
+			}
+		}
+
+		if (!found && !for_completion) {
+			String base;
+			if (name_part == 0) {
+				base = "self";
+			} else {
+				base = result.to_string();
+			}
+			_set_error("The identifier \"" + String(id) +
+							"\" isn't a valid type (not a script or class), or couldn't be found on base \"" + base + "\".",
+					p_line);
+			return DataType();
+		}
+
+		name_part++;
+	}
+
+	return result;
+}
+
+GDScriptParser::DataType GDScriptParser::_type_from_variant(const Variant &p_value) const {
+	DataType result;
+	result.has_type = true;
+	result.is_constant = true;
+	result.kind = DataType::BUILTIN;
+	result.builtin_type = p_value.get_type();
+
+	if (result.builtin_type == Variant::OBJECT) {
+		Object *obj = p_value.operator Object *();
+		if (!obj) {
+			return DataType();
+		}
+		result.native_type = obj->get_class_name();
+		Ref<Script> scr = p_value;
+		if (scr.is_valid()) {
+			result.is_meta_type = true;
+		} else {
+			result.is_meta_type = false;
+			scr = obj->get_script();
+		}
+		if (scr.is_valid()) {
+			result.script_type = scr;
+			Ref<GDScript> gds = scr;
+			if (gds.is_valid()) {
+				result.kind = DataType::GDSCRIPT;
+			} else {
+				result.kind = DataType::SCRIPT;
+			}
+			result.native_type = scr->get_instance_base_type();
+		} else {
+			result.kind = DataType::NATIVE;
+		}
+	}
+
+	return result;
+}
+
+GDScriptParser::DataType GDScriptParser::_type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant) const {
+	DataType ret;
+	if (p_property.type == Variant::NIL && (p_nil_is_variant || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
+		// Variant
+		return ret;
+	}
+	ret.has_type = true;
+	ret.builtin_type = p_property.type;
+	if (p_property.type == Variant::OBJECT) {
+		ret.kind = DataType::NATIVE;
+		ret.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
+	} else {
+		ret.kind = DataType::BUILTIN;
+	}
+	return ret;
+}
+
+GDScriptParser::DataType GDScriptParser::_type_from_gdtype(const GDScriptDataType &p_gdtype) const {
+	DataType result;
+	if (!p_gdtype.has_type) {
+		return result;
+	}
+
+	result.has_type = true;
+	result.builtin_type = p_gdtype.builtin_type;
+	result.native_type = p_gdtype.native_type;
+	result.script_type = Ref<Script>(p_gdtype.script_type);
+
+	switch (p_gdtype.kind) {
+		case GDScriptDataType::UNINITIALIZED: {
+			ERR_PRINT("Uninitialized datatype. Please report a bug.");
+		} break;
+		case GDScriptDataType::BUILTIN: {
+			result.kind = DataType::BUILTIN;
+		} break;
+		case GDScriptDataType::NATIVE: {
+			result.kind = DataType::NATIVE;
+		} break;
+		case GDScriptDataType::GDSCRIPT: {
+			result.kind = DataType::GDSCRIPT;
+		} break;
+		case GDScriptDataType::SCRIPT: {
+			result.kind = DataType::SCRIPT;
+		} break;
+	}
+	return result;
+}
+
+GDScriptParser::DataType GDScriptParser::_get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const {
+	if (!p_a.has_type || !p_b.has_type) {
+		r_valid = true;
+		return DataType();
+	}
+
+	Variant::Type a_type = p_a.kind == DataType::BUILTIN ? p_a.builtin_type : Variant::OBJECT;
+	Variant::Type b_type = p_b.kind == DataType::BUILTIN ? p_b.builtin_type : Variant::OBJECT;
+
+	Variant a;
+	REF a_ref;
+	if (a_type == Variant::OBJECT) {
+		a_ref.instance();
+		a = a_ref;
+	} else {
+		Variant::CallError err;
+		a = Variant::construct(a_type, nullptr, 0, err);
+		if (err.error != Variant::CallError::CALL_OK) {
+			r_valid = false;
+			return DataType();
+		}
+	}
+	Variant b;
+	REF b_ref;
+	if (b_type == Variant::OBJECT) {
+		b_ref.instance();
+		b = b_ref;
+	} else {
+		Variant::CallError err;
+		b = Variant::construct(b_type, nullptr, 0, err);
+		if (err.error != Variant::CallError::CALL_OK) {
+			r_valid = false;
+			return DataType();
+		}
+	}
+
+	// Avoid division by zero
+	if (a_type == Variant::INT || a_type == Variant::REAL) {
+		Variant::evaluate(Variant::OP_ADD, a, 1, a, r_valid);
+	}
+	if (b_type == Variant::INT || b_type == Variant::REAL) {
+		Variant::evaluate(Variant::OP_ADD, b, 1, b, r_valid);
+	}
+	if (a_type == Variant::STRING && b_type != Variant::ARRAY) {
+		a = "%s"; // Work around for formatting operator (%)
+	}
+
+	Variant ret;
+	Variant::evaluate(p_op, a, b, ret, r_valid);
+
+	if (r_valid) {
+		return _type_from_variant(ret);
+	}
+
+	return DataType();
+}
+
+Variant::Operator GDScriptParser::_get_variant_operation(const OperatorNode::Operator &p_op) const {
+	switch (p_op) {
+		case OperatorNode::OP_NEG: {
+			return Variant::OP_NEGATE;
+		} break;
+		case OperatorNode::OP_POS: {
+			return Variant::OP_POSITIVE;
+		} break;
+		case OperatorNode::OP_NOT: {
+			return Variant::OP_NOT;
+		} break;
+		case OperatorNode::OP_BIT_INVERT: {
+			return Variant::OP_BIT_NEGATE;
+		} break;
+		case OperatorNode::OP_IN: {
+			return Variant::OP_IN;
+		} break;
+		case OperatorNode::OP_EQUAL: {
+			return Variant::OP_EQUAL;
+		} break;
+		case OperatorNode::OP_NOT_EQUAL: {
+			return Variant::OP_NOT_EQUAL;
+		} break;
+		case OperatorNode::OP_LESS: {
+			return Variant::OP_LESS;
+		} break;
+		case OperatorNode::OP_LESS_EQUAL: {
+			return Variant::OP_LESS_EQUAL;
+		} break;
+		case OperatorNode::OP_GREATER: {
+			return Variant::OP_GREATER;
+		} break;
+		case OperatorNode::OP_GREATER_EQUAL: {
+			return Variant::OP_GREATER_EQUAL;
+		} break;
+		case OperatorNode::OP_AND: {
+			return Variant::OP_AND;
+		} break;
+		case OperatorNode::OP_OR: {
+			return Variant::OP_OR;
+		} break;
+		case OperatorNode::OP_ASSIGN_ADD:
+		case OperatorNode::OP_ADD: {
+			return Variant::OP_ADD;
+		} break;
+		case OperatorNode::OP_ASSIGN_SUB:
+		case OperatorNode::OP_SUB: {
+			return Variant::OP_SUBTRACT;
+		} break;
+		case OperatorNode::OP_ASSIGN_MUL:
+		case OperatorNode::OP_MUL: {
+			return Variant::OP_MULTIPLY;
+		} break;
+		case OperatorNode::OP_ASSIGN_DIV:
+		case OperatorNode::OP_DIV: {
+			return Variant::OP_DIVIDE;
+		} break;
+		case OperatorNode::OP_ASSIGN_MOD:
+		case OperatorNode::OP_MOD: {
+			return Variant::OP_MODULE;
+		} break;
+		case OperatorNode::OP_ASSIGN_BIT_AND:
+		case OperatorNode::OP_BIT_AND: {
+			return Variant::OP_BIT_AND;
+		} break;
+		case OperatorNode::OP_ASSIGN_BIT_OR:
+		case OperatorNode::OP_BIT_OR: {
+			return Variant::OP_BIT_OR;
+		} break;
+		case OperatorNode::OP_ASSIGN_BIT_XOR:
+		case OperatorNode::OP_BIT_XOR: {
+			return Variant::OP_BIT_XOR;
+		} break;
+		case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+		case OperatorNode::OP_SHIFT_LEFT: {
+			return Variant::OP_SHIFT_LEFT;
+		}
+		case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+		case OperatorNode::OP_SHIFT_RIGHT: {
+			return Variant::OP_SHIFT_RIGHT;
+		}
+		default: {
+			return Variant::OP_MAX;
+		} break;
+	}
+}
+
+bool GDScriptParser::_is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion) const {
+	// Ignore for completion
+	if (!check_types || for_completion) {
+		return true;
+	}
+	// Can't test if not all have type
+	if (!p_container.has_type || !p_expression.has_type) {
+		return true;
+	}
+
+	// Should never get here unresolved
+	ERR_FAIL_COND_V(p_container.kind == DataType::UNRESOLVED, false);
+	ERR_FAIL_COND_V(p_expression.kind == DataType::UNRESOLVED, false);
+
+	if (p_container.kind == DataType::BUILTIN && p_expression.kind == DataType::BUILTIN) {
+		bool valid = p_container.builtin_type == p_expression.builtin_type;
+		if (p_allow_implicit_conversion) {
+			valid = valid || Variant::can_convert_strict(p_expression.builtin_type, p_container.builtin_type);
+		}
+		return valid;
+	}
+
+	if (p_container.kind == DataType::BUILTIN && p_container.builtin_type == Variant::OBJECT) {
+		// Object built-in is a special case, it's compatible with any object and with null
+		if (p_expression.kind == DataType::BUILTIN) {
+			return p_expression.builtin_type == Variant::NIL;
+		}
+		// If it's not a built-in, must be an object
+		return true;
+	}
+
+	if (p_container.kind == DataType::BUILTIN || (p_expression.kind == DataType::BUILTIN && p_expression.builtin_type != Variant::NIL)) {
+		// Can't mix built-ins with objects
+		return false;
+	}
+
+	// From now on everything is objects, check polymorphism
+	// The container must be the same class or a superclass of the expression
+
+	if (p_expression.kind == DataType::BUILTIN && p_expression.builtin_type == Variant::NIL) {
+		// Null can be assigned to object types
+		return true;
+	}
+
+	StringName expr_native;
+	Ref<Script> expr_script;
+	ClassNode *expr_class = nullptr;
+
+	switch (p_expression.kind) {
+		case DataType::NATIVE: {
+			if (p_container.kind != DataType::NATIVE) {
+				// Non-native type can't be a superclass of a native type
+				return false;
+			}
+			if (p_expression.is_meta_type) {
+				expr_native = GDScriptNativeClass::get_class_static();
+			} else {
+				expr_native = p_expression.native_type;
+			}
+		} break;
+		case DataType::SCRIPT:
+		case DataType::GDSCRIPT: {
+			if (p_container.kind == DataType::CLASS) {
+				// This cannot be resolved without cyclic dependencies, so just bail out
+				return false;
+			}
+			if (p_expression.is_meta_type) {
+				expr_native = p_expression.script_type->get_class_name();
+			} else {
+				expr_script = p_expression.script_type;
+				expr_native = expr_script->get_instance_base_type();
+			}
+		} break;
+		case DataType::CLASS: {
+			if (p_expression.is_meta_type) {
+				expr_native = GDScript::get_class_static();
+			} else {
+				expr_class = p_expression.class_type;
+				ClassNode *base = expr_class;
+				while (base->base_type.kind == DataType::CLASS) {
+					base = base->base_type.class_type;
+				}
+				expr_native = base->base_type.native_type;
+				expr_script = base->base_type.script_type;
+			}
+		} break;
+		case DataType::BUILTIN: // Already handled above
+		case DataType::UNRESOLVED: // Not allowed, see above
+			break;
+	}
+
+	// Some classes are prefixed with `_` internally
+	if (!ClassDB::class_exists(expr_native)) {
+		expr_native = "_" + expr_native;
+	}
+
+	switch (p_container.kind) {
+		case DataType::NATIVE: {
+			if (p_container.is_meta_type) {
+				return ClassDB::is_parent_class(expr_native, GDScriptNativeClass::get_class_static());
+			} else {
+				StringName container_native = ClassDB::class_exists(p_container.native_type) ? p_container.native_type : StringName("_" + p_container.native_type);
+				return ClassDB::is_parent_class(expr_native, container_native);
+			}
+		} break;
+		case DataType::SCRIPT:
+		case DataType::GDSCRIPT: {
+			if (p_container.is_meta_type) {
+				return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
+			}
+			if (expr_class == head && p_container.script_type->get_path() == self_path) {
+				// Special case: container is self script and expression is self
+				return true;
+			}
+			while (expr_script.is_valid()) {
+				if (expr_script == p_container.script_type) {
+					return true;
+				}
+				expr_script = expr_script->get_base_script();
+			}
+			return false;
+		} break;
+		case DataType::CLASS: {
+			if (p_container.is_meta_type) {
+				return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
+			}
+			if (p_container.class_type == head && expr_script.is_valid() && expr_script->get_path() == self_path) {
+				// Special case: container is self and expression is self script
+				return true;
+			}
+			while (expr_class) {
+				if (expr_class == p_container.class_type) {
+					return true;
+				}
+				expr_class = expr_class->base_type.class_type;
+			}
+			return false;
+		} break;
+		case DataType::BUILTIN: // Already handled above
+		case DataType::UNRESOLVED: // Not allowed, see above
+			break;
+	}
+
+	return false;
+}
+
+GDScriptParser::Node *GDScriptParser::_get_default_value_for_type(const DataType &p_type, int p_line) {
+	Node *result;
+
+	if (p_type.has_type && p_type.kind == DataType::BUILTIN && p_type.builtin_type != Variant::NIL && p_type.builtin_type != Variant::OBJECT) {
+		if (p_type.builtin_type == Variant::ARRAY) {
+			result = alloc_node<ArrayNode>();
+		} else if (p_type.builtin_type == Variant::DICTIONARY) {
+			result = alloc_node<DictionaryNode>();
+		} else {
+			ConstantNode *c = alloc_node<ConstantNode>();
+			Variant::CallError err;
+			c->value = Variant::construct(p_type.builtin_type, nullptr, 0, err);
+			result = c;
+		}
+	} else {
+		ConstantNode *c = alloc_node<ConstantNode>();
+		c->value = Variant();
+		result = c;
+	}
+
+	result->line = p_line;
+
+	return result;
+}
+
+GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
+#ifdef DEBUG_ENABLED
+	if (p_node->get_datatype().has_type && p_node->type != Node::TYPE_ARRAY && p_node->type != Node::TYPE_DICTIONARY) {
+#else
+	if (p_node->get_datatype().has_type) {
+#endif
+		return p_node->get_datatype();
+	}
+
+	DataType node_type;
+
+	switch (p_node->type) {
+		case Node::TYPE_CONSTANT: {
+			node_type = _type_from_variant(static_cast<ConstantNode *>(p_node)->value);
+		} break;
+		case Node::TYPE_TYPE: {
+			TypeNode *tn = static_cast<TypeNode *>(p_node);
+			node_type.has_type = true;
+			node_type.is_meta_type = true;
+			node_type.kind = DataType::BUILTIN;
+			node_type.builtin_type = tn->vtype;
+		} break;
+		case Node::TYPE_ARRAY: {
+			node_type.has_type = true;
+			node_type.kind = DataType::BUILTIN;
+			node_type.builtin_type = Variant::ARRAY;
+#ifdef DEBUG_ENABLED
+			// Check stuff inside the array
+			ArrayNode *an = static_cast<ArrayNode *>(p_node);
+			for (int i = 0; i < an->elements.size(); i++) {
+				_reduce_node_type(an->elements[i]);
+			}
+#endif // DEBUG_ENABLED
+		} break;
+		case Node::TYPE_DICTIONARY: {
+			node_type.has_type = true;
+			node_type.kind = DataType::BUILTIN;
+			node_type.builtin_type = Variant::DICTIONARY;
+#ifdef DEBUG_ENABLED
+			// Check stuff inside the dictionarty
+			DictionaryNode *dn = static_cast<DictionaryNode *>(p_node);
+			for (int i = 0; i < dn->elements.size(); i++) {
+				_reduce_node_type(dn->elements[i].key);
+				_reduce_node_type(dn->elements[i].value);
+			}
+#endif // DEBUG_ENABLED
+		} break;
+		case Node::TYPE_SELF: {
+			node_type.has_type = true;
+			node_type.kind = DataType::CLASS;
+			node_type.class_type = current_class;
+			node_type.is_constant = true;
+		} break;
+		case Node::TYPE_IDENTIFIER: {
+			IdentifierNode *id = static_cast<IdentifierNode *>(p_node);
+			if (id->declared_block) {
+				node_type = id->declared_block->variables[id->name]->get_datatype();
+				id->declared_block->variables[id->name]->usages += 1;
+			} else if (id->name == "#match_value") {
+				// It's a special id just for the match statetement, ignore
+				break;
+			} else if (current_function && current_function->arguments.find(id->name) >= 0) {
+				int idx = current_function->arguments.find(id->name);
+				node_type = current_function->argument_types[idx];
+			} else {
+				node_type = _reduce_identifier_type(nullptr, id->name, id->line, false);
+			}
+		} break;
+		case Node::TYPE_CAST: {
+			CastNode *cn = static_cast<CastNode *>(p_node);
+
+			DataType source_type = _reduce_node_type(cn->source_node);
+			cn->cast_type = _resolve_type(cn->cast_type, cn->line);
+			if (source_type.has_type) {
+				bool valid = false;
+				if (check_types) {
+					if (cn->cast_type.kind == DataType::BUILTIN && source_type.kind == DataType::BUILTIN) {
+						valid = Variant::can_convert(source_type.builtin_type, cn->cast_type.builtin_type);
+					}
+					if (cn->cast_type.kind != DataType::BUILTIN && source_type.kind != DataType::BUILTIN) {
+						valid = _is_type_compatible(cn->cast_type, source_type) || _is_type_compatible(source_type, cn->cast_type);
+					}
+
+					if (!valid) {
+						_set_error("Invalid cast. Cannot convert from \"" + source_type.to_string() +
+										"\" to \"" + cn->cast_type.to_string() + "\".",
+								cn->line);
+						return DataType();
+					}
+				}
+			} else {
+#ifdef DEBUG_ENABLED
+				_add_warning(GDScriptWarning::UNSAFE_CAST, cn->line, cn->cast_type.to_string());
+#endif // DEBUG_ENABLED
+				_mark_line_as_unsafe(cn->line);
+			}
+
+			node_type = cn->cast_type;
+
+		} break;
+		case Node::TYPE_OPERATOR: {
+			OperatorNode *op = static_cast<OperatorNode *>(p_node);
+
+			switch (op->op) {
+				case OperatorNode::OP_CALL:
+				case OperatorNode::OP_PARENT_CALL: {
+					node_type = _reduce_function_call_type(op);
+				} break;
+				case OperatorNode::OP_YIELD: {
+					if (op->arguments.size() == 2) {
+						DataType base_type = _reduce_node_type(op->arguments[0]);
+						DataType signal_type = _reduce_node_type(op->arguments[1]);
+						// TODO: Check if signal exists when it's a constant
+						if (base_type.has_type && base_type.kind == DataType::BUILTIN && base_type.builtin_type != Variant::NIL && base_type.builtin_type != Variant::OBJECT) {
+							_set_error("The first argument of \"yield()\" must be an object.", op->line);
+							return DataType();
+						}
+						if (signal_type.has_type && (signal_type.kind != DataType::BUILTIN || signal_type.builtin_type != Variant::STRING)) {
+							_set_error("The second argument of \"yield()\" must be a string.", op->line);
+							return DataType();
+						}
+					}
+					// yield can return anything
+					node_type.has_type = false;
+				} break;
+				case OperatorNode::OP_IS:
+				case OperatorNode::OP_IS_BUILTIN: {
+					if (op->arguments.size() != 2) {
+						_set_error("Parser bug: binary operation without 2 arguments.", op->line);
+						ERR_FAIL_V(DataType());
+					}
+
+					DataType value_type = _reduce_node_type(op->arguments[0]);
+					DataType type_type = _reduce_node_type(op->arguments[1]);
+
+					if (check_types && type_type.has_type) {
+						if (!type_type.is_meta_type && (type_type.kind != DataType::NATIVE || !ClassDB::is_parent_class(type_type.native_type, "Script"))) {
+							_set_error("Invalid \"is\" test: the right operand isn't a type (neither a native type nor a script).", op->line);
+							return DataType();
+						}
+						type_type.is_meta_type = false; // Test the actual type
+						if (!_is_type_compatible(type_type, value_type) && !_is_type_compatible(value_type, type_type)) {
+							if (op->op == OperatorNode::OP_IS) {
+								_set_error("A value of type \"" + value_type.to_string() + "\" will never be an instance of \"" + type_type.to_string() + "\".", op->line);
+							} else {
+								_set_error("A value of type \"" + value_type.to_string() + "\" will never be of type \"" + type_type.to_string() + "\".", op->line);
+							}
+							return DataType();
+						}
+					}
+
+					node_type.has_type = true;
+					node_type.is_constant = true;
+					node_type.is_meta_type = false;
+					node_type.kind = DataType::BUILTIN;
+					node_type.builtin_type = Variant::BOOL;
+				} break;
+				// Unary operators
+				case OperatorNode::OP_NEG:
+				case OperatorNode::OP_POS:
+				case OperatorNode::OP_NOT:
+				case OperatorNode::OP_BIT_INVERT: {
+					DataType argument_type = _reduce_node_type(op->arguments[0]);
+					if (!argument_type.has_type) {
+						break;
+					}
+
+					Variant::Operator var_op = _get_variant_operation(op->op);
+					bool valid = false;
+					node_type = _get_operation_type(var_op, argument_type, argument_type, valid);
+
+					if (check_types && !valid) {
+						_set_error("Invalid operand type (\"" + argument_type.to_string() +
+										"\") to unary operator \"" + Variant::get_operator_name(var_op) + "\".",
+								op->line, op->column);
+						return DataType();
+					}
+
+				} break;
+				// Binary operators
+				case OperatorNode::OP_IN:
+				case OperatorNode::OP_EQUAL:
+				case OperatorNode::OP_NOT_EQUAL:
+				case OperatorNode::OP_LESS:
+				case OperatorNode::OP_LESS_EQUAL:
+				case OperatorNode::OP_GREATER:
+				case OperatorNode::OP_GREATER_EQUAL:
+				case OperatorNode::OP_AND:
+				case OperatorNode::OP_OR:
+				case OperatorNode::OP_ADD:
+				case OperatorNode::OP_SUB:
+				case OperatorNode::OP_MUL:
+				case OperatorNode::OP_DIV:
+				case OperatorNode::OP_MOD:
+				case OperatorNode::OP_SHIFT_LEFT:
+				case OperatorNode::OP_SHIFT_RIGHT:
+				case OperatorNode::OP_BIT_AND:
+				case OperatorNode::OP_BIT_OR:
+				case OperatorNode::OP_BIT_XOR: {
+					if (op->arguments.size() != 2) {
+						_set_error("Parser bug: binary operation without 2 arguments.", op->line);
+						ERR_FAIL_V(DataType());
+					}
+
+					DataType argument_a_type = _reduce_node_type(op->arguments[0]);
+					DataType argument_b_type = _reduce_node_type(op->arguments[1]);
+					if (!argument_a_type.has_type || !argument_b_type.has_type) {
+						_mark_line_as_unsafe(op->line);
+						break;
+					}
+
+					Variant::Operator var_op = _get_variant_operation(op->op);
+					bool valid = false;
+					node_type = _get_operation_type(var_op, argument_a_type, argument_b_type, valid);
+
+					if (check_types && !valid) {
+						_set_error("Invalid operand types (\"" + argument_a_type.to_string() + "\" and \"" +
+										argument_b_type.to_string() + "\") to operator \"" + Variant::get_operator_name(var_op) + "\".",
+								op->line, op->column);
+						return DataType();
+					}
+#ifdef DEBUG_ENABLED
+					if (var_op == Variant::OP_DIVIDE && argument_a_type.kind == DataType::BUILTIN && argument_a_type.builtin_type == Variant::INT &&
+							argument_b_type.kind == DataType::BUILTIN && argument_b_type.builtin_type == Variant::INT) {
+						_add_warning(GDScriptWarning::INTEGER_DIVISION, op->line);
+					}
+#endif // DEBUG_ENABLED
+
+				} break;
+				// Ternary operators
+				case OperatorNode::OP_TERNARY_IF: {
+					if (op->arguments.size() != 3) {
+						_set_error("Parser bug: ternary operation without 3 arguments.");
+						ERR_FAIL_V(DataType());
+					}
+
+					DataType true_type = _reduce_node_type(op->arguments[1]);
+					DataType false_type = _reduce_node_type(op->arguments[2]);
+					// Check arguments[0] errors.
+					_reduce_node_type(op->arguments[0]);
+
+					// If types are equal, then the expression is of the same type
+					// If they are compatible, return the broader type
+					if (true_type == false_type || _is_type_compatible(true_type, false_type)) {
+						node_type = true_type;
+					} else if (_is_type_compatible(false_type, true_type)) {
+						node_type = false_type;
+					} else {
+#ifdef DEBUG_ENABLED
+						_add_warning(GDScriptWarning::INCOMPATIBLE_TERNARY, op->line);
+#endif // DEBUG_ENABLED
+					}
+				} break;
+				// Assignment should never happen within an expression
+				case OperatorNode::OP_ASSIGN:
+				case OperatorNode::OP_ASSIGN_ADD:
+				case OperatorNode::OP_ASSIGN_SUB:
+				case OperatorNode::OP_ASSIGN_MUL:
+				case OperatorNode::OP_ASSIGN_DIV:
+				case OperatorNode::OP_ASSIGN_MOD:
+				case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+				case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+				case OperatorNode::OP_ASSIGN_BIT_AND:
+				case OperatorNode::OP_ASSIGN_BIT_OR:
+				case OperatorNode::OP_ASSIGN_BIT_XOR:
+				case OperatorNode::OP_INIT_ASSIGN: {
+					_set_error("Assignment inside an expression isn't allowed (parser bug?).", op->line);
+					return DataType();
+
+				} break;
+				case OperatorNode::OP_INDEX_NAMED: {
+					if (op->arguments.size() != 2) {
+						_set_error("Parser bug: named index with invalid arguments.", op->line);
+						ERR_FAIL_V(DataType());
+					}
+					if (op->arguments[1]->type != Node::TYPE_IDENTIFIER) {
+						_set_error("Parser bug: named index without identifier argument.", op->line);
+						ERR_FAIL_V(DataType());
+					}
+
+					DataType base_type = _reduce_node_type(op->arguments[0]);
+					IdentifierNode *member_id = static_cast<IdentifierNode *>(op->arguments[1]);
+
+					if (base_type.has_type) {
+						if (check_types && base_type.kind == DataType::BUILTIN) {
+							// Variant type, just test if it's possible
+							DataType result;
+							switch (base_type.builtin_type) {
+								case Variant::NIL:
+								case Variant::DICTIONARY: {
+									result.has_type = false;
+								} break;
+								default: {
+									Variant::CallError err;
+									Variant temp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+
+									bool valid = false;
+									Variant res = temp.get(member_id->name.operator String(), &valid);
+
+									if (valid) {
+										result = _type_from_variant(res);
+									} else if (check_types) {
+										_set_error("Can't get index \"" + String(member_id->name.operator String()) + "\" on base \"" +
+														base_type.to_string() + "\".",
+												op->line);
+										return DataType();
+									}
+								} break;
+							}
+							result.is_constant = false;
+							node_type = result;
+						} else {
+							node_type = _reduce_identifier_type(&base_type, member_id->name, op->line, true);
+#ifdef DEBUG_ENABLED
+							if (!node_type.has_type) {
+								_mark_line_as_unsafe(op->line);
+								_add_warning(GDScriptWarning::UNSAFE_PROPERTY_ACCESS, op->line, member_id->name.operator String(), base_type.to_string());
+							}
+#endif // DEBUG_ENABLED
+						}
+					} else {
+						_mark_line_as_unsafe(op->line);
+					}
+					if (error_set) {
+						return DataType();
+					}
+				} break;
+				case OperatorNode::OP_INDEX: {
+					if (op->arguments[1]->type == Node::TYPE_CONSTANT) {
+						ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[1]);
+						if (cn->value.get_type() == Variant::STRING) {
+							// Treat this as named indexing
+
+							IdentifierNode *id = alloc_node<IdentifierNode>();
+							id->name = cn->value.operator StringName();
+							id->datatype = cn->datatype;
+
+							op->op = OperatorNode::OP_INDEX_NAMED;
+							op->arguments.write[1] = id;
+
+							return _reduce_node_type(op);
+						}
+					}
+
+					DataType base_type = _reduce_node_type(op->arguments[0]);
+					DataType index_type = _reduce_node_type(op->arguments[1]);
+
+					if (!base_type.has_type) {
+						_mark_line_as_unsafe(op->line);
+						break;
+					}
+
+					if (check_types && index_type.has_type) {
+						if (base_type.kind == DataType::BUILTIN) {
+							// Check if indexing is valid
+							bool error = index_type.kind != DataType::BUILTIN && base_type.builtin_type != Variant::DICTIONARY;
+							if (!error) {
+								switch (base_type.builtin_type) {
+									// Expect int or real as index
+									case Variant::POOL_BYTE_ARRAY:
+									case Variant::POOL_COLOR_ARRAY:
+									case Variant::POOL_INT_ARRAY:
+									case Variant::POOL_REAL_ARRAY:
+									case Variant::POOL_STRING_ARRAY:
+									case Variant::POOL_VECTOR2_ARRAY:
+									case Variant::POOL_VECTOR2I_ARRAY:
+									case Variant::POOL_VECTOR3_ARRAY:
+									case Variant::POOL_VECTOR3I_ARRAY:
+									case Variant::ARRAY:
+									case Variant::STRING: {
+										error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::REAL;
+									} break;
+									// Expect String only
+									case Variant::RECT2:
+									case Variant::RECT2I:
+									case Variant::PLANE:
+									case Variant::QUAT:
+									case Variant::AABB:
+									case Variant::OBJECT: {
+										error = index_type.builtin_type != Variant::STRING;
+									} break;
+									// Expect String or number
+									case Variant::VECTOR2:
+									case Variant::VECTOR2I:
+									case Variant::VECTOR3:
+									case Variant::VECTOR3I:
+									case Variant::TRANSFORM2D:
+									case Variant::BASIS:
+									case Variant::TRANSFORM: {
+										error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::REAL &&
+												index_type.builtin_type != Variant::STRING;
+									} break;
+									// Expect String or int
+									case Variant::COLOR: {
+										error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::STRING;
+									} break;
+									default: {
+									}
+								}
+							}
+							if (error) {
+								_set_error("Invalid index type (" + index_type.to_string() + ") for base \"" + base_type.to_string() + "\".",
+										op->line);
+								return DataType();
+							}
+
+							if (op->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT) {
+								ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[1]);
+								// Index is a constant, just try it if possible
+								switch (base_type.builtin_type) {
+									// Arrays/string have variable indexing, can't test directly
+									case Variant::STRING:
+									case Variant::ARRAY:
+									case Variant::DICTIONARY:
+									case Variant::POOL_BYTE_ARRAY:
+									case Variant::POOL_COLOR_ARRAY:
+									case Variant::POOL_INT_ARRAY:
+									case Variant::POOL_REAL_ARRAY:
+									case Variant::POOL_STRING_ARRAY:
+									case Variant::POOL_VECTOR2_ARRAY:
+									case Variant::POOL_VECTOR3_ARRAY: {
+										break;
+									}
+									default: {
+										Variant::CallError err;
+										Variant temp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+
+										bool valid = false;
+										Variant res = temp.get(cn->value, &valid);
+
+										if (valid) {
+											node_type = _type_from_variant(res);
+											node_type.is_constant = false;
+										} else if (check_types) {
+											_set_error("Can't get index \"" + String(cn->value) + "\" on base \"" +
+															base_type.to_string() + "\".",
+													op->line);
+											return DataType();
+										}
+									} break;
+								}
+							} else {
+								_mark_line_as_unsafe(op->line);
+							}
+						} else if (!for_completion && (index_type.kind != DataType::BUILTIN || index_type.builtin_type != Variant::STRING)) {
+							_set_error("Only strings can be used as an index in the base type \"" + base_type.to_string() + "\".", op->line);
+							return DataType();
+						}
+					}
+					if (check_types && !node_type.has_type && base_type.kind == DataType::BUILTIN) {
+						// Can infer indexing type for some variant types
+						DataType result;
+						result.has_type = true;
+						result.kind = DataType::BUILTIN;
+						switch (base_type.builtin_type) {
+							// Can't index at all
+							case Variant::NIL:
+							case Variant::BOOL:
+							case Variant::INT:
+							case Variant::REAL:
+							case Variant::NODE_PATH:
+							case Variant::_RID: {
+								_set_error("Can't index on a value of type \"" + base_type.to_string() + "\".", op->line);
+								return DataType();
+							} break;
+								// Return int
+							case Variant::POOL_BYTE_ARRAY:
+							case Variant::POOL_INT_ARRAY: {
+								result.builtin_type = Variant::INT;
+							} break;
+								// Return real
+							case Variant::POOL_REAL_ARRAY:
+							case Variant::VECTOR2:
+							case Variant::VECTOR3:
+							case Variant::QUAT: {
+								result.builtin_type = Variant::REAL;
+							} break;
+								// Return color
+							case Variant::POOL_COLOR_ARRAY: {
+								result.builtin_type = Variant::COLOR;
+							} break;
+								// Return string
+							case Variant::POOL_STRING_ARRAY:
+							case Variant::STRING: {
+								result.builtin_type = Variant::STRING;
+							} break;
+								// Return Vector2
+							case Variant::POOL_VECTOR2_ARRAY:
+							case Variant::TRANSFORM2D:
+							case Variant::RECT2: {
+								result.builtin_type = Variant::VECTOR2;
+							} break;
+								// Return Vector3
+							case Variant::POOL_VECTOR3_ARRAY:
+							case Variant::AABB:
+							case Variant::BASIS: {
+								result.builtin_type = Variant::VECTOR3;
+							} break;
+								// Depends on the index
+							case Variant::TRANSFORM:
+							case Variant::PLANE:
+							case Variant::COLOR:
+							default: {
+								result.has_type = false;
+							} break;
+						}
+						node_type = result;
+					}
+				} break;
+				default: {
+					_set_error("Parser bug: unhandled operation.", op->line);
+					ERR_FAIL_V(DataType());
+				}
+			}
+		} break;
+		default: {
+		}
+	}
+
+	node_type = _resolve_type(node_type, p_node->line);
+	p_node->set_datatype(node_type);
+	return node_type;
+}
+
+bool GDScriptParser::_get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const {
+	r_static = false;
+	r_default_arg_count = 0;
+
+	DataType original_type = p_base_type;
+	ClassNode *base = nullptr;
+	FunctionNode *callee = nullptr;
+
+	if (p_base_type.kind == DataType::CLASS) {
+		base = p_base_type.class_type;
+	}
+
+	// Look up the current file (parse tree)
+	while (!callee && base) {
+		for (int i = 0; i < base->static_functions.size(); i++) {
+			FunctionNode *func = base->static_functions[i];
+			if (p_function == func->name) {
+				r_static = true;
+				callee = func;
+				break;
+			}
+		}
+		if (!callee && !p_base_type.is_meta_type) {
+			for (int i = 0; i < base->functions.size(); i++) {
+				FunctionNode *func = base->functions[i];
+				if (p_function == func->name) {
+					callee = func;
+					break;
+				}
+			}
+		}
+		p_base_type = base->base_type;
+		if (p_base_type.kind == DataType::CLASS) {
+			base = p_base_type.class_type;
+		} else {
+			break;
+		}
+	}
+
+	if (callee) {
+		r_return_type = callee->get_datatype();
+		for (int i = 0; i < callee->argument_types.size(); i++) {
+			r_arg_types.push_back(callee->argument_types[i]);
+		}
+		r_default_arg_count = callee->default_values.size();
+		return true;
+	}
+
+	// Nothing in current file, check parent script
+	Ref<GDScript> base_gdscript;
+	Ref<Script> base_script;
+	StringName native;
+	if (p_base_type.kind == DataType::GDSCRIPT) {
+		base_gdscript = p_base_type.script_type;
+		if (base_gdscript.is_null() || !base_gdscript->is_valid()) {
+			// GDScript wasn't properly compíled, don't bother trying
+			return false;
+		}
+	} else if (p_base_type.kind == DataType::SCRIPT) {
+		base_script = p_base_type.script_type;
+	} else if (p_base_type.kind == DataType::NATIVE) {
+		native = p_base_type.native_type;
+	}
+
+	while (base_gdscript.is_valid()) {
+		native = base_gdscript->get_instance_base_type();
+
+		Map<StringName, GDScriptFunction *> funcs = base_gdscript->get_member_functions();
+
+		if (funcs.has(p_function)) {
+			GDScriptFunction *f = funcs[p_function];
+			r_static = f->is_static();
+			r_default_arg_count = f->get_default_argument_count();
+			r_return_type = _type_from_gdtype(f->get_return_type());
+			for (int i = 0; i < f->get_argument_count(); i++) {
+				r_arg_types.push_back(_type_from_gdtype(f->get_argument_type(i)));
+			}
+			return true;
+		}
+
+		base_gdscript = base_gdscript->get_base_script();
+	}
+
+	while (base_script.is_valid()) {
+		native = base_script->get_instance_base_type();
+		MethodInfo mi = base_script->get_method_info(p_function);
+
+		if (!(mi == MethodInfo())) {
+			r_return_type = _type_from_property(mi.return_val, false);
+			r_default_arg_count = mi.default_arguments.size();
+			for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
+				r_arg_types.push_back(_type_from_property(E->get()));
+			}
+			return true;
+		}
+		base_script = base_script->get_base_script();
+	}
+
+	if (native == StringName()) {
+		// Empty native class, might happen in some Script implementations
+		// Just ignore it
+		return false;
+	}
+
+#ifdef DEBUG_METHODS_ENABLED
+
+	// Only native remains
+	if (!ClassDB::class_exists(native)) {
+		native = "_" + native.operator String();
+	}
+	if (!ClassDB::class_exists(native)) {
+		if (!check_types) {
+			return false;
+		}
+		ERR_FAIL_V_MSG(false, "Parser bug: Class '" + String(native) + "' not found.");
+	}
+
+	MethodBind *method = ClassDB::get_method(native, p_function);
+
+	if (!method) {
+		// Try virtual methods
+		List<MethodInfo> virtuals;
+		ClassDB::get_virtual_methods(native, &virtuals);
+
+		for (const List<MethodInfo>::Element *E = virtuals.front(); E; E = E->next()) {
+			const MethodInfo &mi = E->get();
+			if (mi.name == p_function) {
+				r_default_arg_count = mi.default_arguments.size();
+				for (const List<PropertyInfo>::Element *pi = mi.arguments.front(); pi; pi = pi->next()) {
+					r_arg_types.push_back(_type_from_property(pi->get()));
+				}
+				r_return_type = _type_from_property(mi.return_val, false);
+				r_vararg = mi.flags & METHOD_FLAG_VARARG;
+				return true;
+			}
+		}
+
+		// If the base is a script, it might be trying to access members of the Script class itself
+		if (original_type.is_meta_type && !(p_function == "new") && (original_type.kind == DataType::SCRIPT || original_type.kind == DataType::GDSCRIPT)) {
+			method = ClassDB::get_method(original_type.script_type->get_class_name(), p_function);
+
+			if (method) {
+				r_static = true;
+			} else {
+				// Try virtual methods of the script type
+				virtuals.clear();
+				ClassDB::get_virtual_methods(original_type.script_type->get_class_name(), &virtuals);
+				for (const List<MethodInfo>::Element *E = virtuals.front(); E; E = E->next()) {
+					const MethodInfo &mi = E->get();
+					if (mi.name == p_function) {
+						r_default_arg_count = mi.default_arguments.size();
+						for (const List<PropertyInfo>::Element *pi = mi.arguments.front(); pi; pi = pi->next()) {
+							r_arg_types.push_back(_type_from_property(pi->get()));
+						}
+						r_return_type = _type_from_property(mi.return_val, false);
+						r_static = true;
+						r_vararg = mi.flags & METHOD_FLAG_VARARG;
+						return true;
+					}
+				}
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
+	r_default_arg_count = method->get_default_argument_count();
+	if (method->get_name() == "get_script") {
+		r_return_type = DataType(); // Variant for now and let runtime decide.
+	} else {
+		r_return_type = _type_from_property(method->get_return_info(), false);
+	}
+	r_vararg = method->is_vararg();
+
+	for (int i = 0; i < method->get_argument_count(); i++) {
+		r_arg_types.push_back(_type_from_property(method->get_argument_info(i)));
+	}
+	return true;
+#else
+	return false;
+#endif
+}
+
+GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const OperatorNode *p_call) {
+	if (p_call->arguments.size() < 1) {
+		_set_error("Parser bug: function call without enough arguments.", p_call->line);
+		ERR_FAIL_V(DataType());
+	}
+
+	DataType return_type;
+	List<DataType> arg_types;
+	int default_args_count = 0;
+	String callee_name;
+	bool is_vararg = false;
+#ifdef DEBUG_ENABLED
+	int arg_count = p_call->arguments.size();
+#endif
+
+	switch (p_call->arguments[0]->type) {
+		case GDScriptParser::Node::TYPE_TYPE: {
+			// Built-in constructor, special case
+			TypeNode *tn = static_cast<TypeNode *>(p_call->arguments[0]);
+
+			Vector<DataType> par_types;
+			par_types.resize(p_call->arguments.size() - 1);
+			for (int i = 1; i < p_call->arguments.size(); i++) {
+				par_types.write[i - 1] = _reduce_node_type(p_call->arguments[i]);
+			}
+
+			if (error_set) {
+				return DataType();
+			}
+
+			// Special case: check copy constructor. Those are defined implicitly in Variant.
+			if (par_types.size() == 1) {
+				if (!par_types[0].has_type || (par_types[0].kind == DataType::BUILTIN && par_types[0].builtin_type == tn->vtype)) {
+					DataType result;
+					result.has_type = true;
+					result.kind = DataType::BUILTIN;
+					result.builtin_type = tn->vtype;
+					return result;
+				}
+			}
+
+			bool match = false;
+			List<MethodInfo> constructors;
+			Variant::get_constructor_list(tn->vtype, &constructors);
+			PropertyInfo return_type2;
+
+			for (List<MethodInfo>::Element *E = constructors.front(); E; E = E->next()) {
+				MethodInfo &mi = E->get();
+
+				if (p_call->arguments.size() - 1 < mi.arguments.size() - mi.default_arguments.size()) {
+					continue;
+				}
+				if (p_call->arguments.size() - 1 > mi.arguments.size()) {
+					continue;
+				}
+
+				bool types_match = true;
+				for (int i = 0; i < par_types.size(); i++) {
+					DataType arg_type;
+					if (mi.arguments[i].type != Variant::NIL) {
+						arg_type.has_type = true;
+						arg_type.kind = mi.arguments[i].type == Variant::OBJECT ? DataType::NATIVE : DataType::BUILTIN;
+						arg_type.builtin_type = mi.arguments[i].type;
+						arg_type.native_type = mi.arguments[i].class_name;
+					}
+
+					if (!_is_type_compatible(arg_type, par_types[i], true)) {
+						types_match = false;
+						break;
+					} else {
+#ifdef DEBUG_ENABLED
+						if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_types[i].kind == DataType::BUILTIN && par_types[i].builtin_type == Variant::REAL) {
+							_add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, Variant::get_type_name(tn->vtype));
+						}
+						if (par_types[i].may_yield && p_call->arguments[i + 1]->type == Node::TYPE_OPERATOR) {
+							_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i + 1])));
+						}
+#endif // DEBUG_ENABLED
+					}
+				}
+
+				if (types_match) {
+					match = true;
+					return_type2 = mi.return_val;
+					break;
+				}
+			}
+
+			if (match) {
+				return _type_from_property(return_type2, false);
+			} else if (check_types) {
+				String err = "No constructor of '";
+				err += Variant::get_type_name(tn->vtype);
+				err += "' matches the signature '";
+				err += Variant::get_type_name(tn->vtype) + "(";
+				for (int i = 0; i < par_types.size(); i++) {
+					if (i > 0) {
+						err += ", ";
+					}
+					err += par_types[i].to_string();
+				}
+				err += ")'.";
+				_set_error(err, p_call->line, p_call->column);
+				return DataType();
+			}
+			return DataType();
+		} break;
+		case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
+			BuiltInFunctionNode *func = static_cast<BuiltInFunctionNode *>(p_call->arguments[0]);
+			MethodInfo mi = GDScriptFunctions::get_info(func->function);
+
+			return_type = _type_from_property(mi.return_val, false);
+
+			// Check all arguments beforehand to solve warnings
+			for (int i = 1; i < p_call->arguments.size(); i++) {
+				_reduce_node_type(p_call->arguments[i]);
+			}
+
+			// Check arguments
+
+			is_vararg = mi.flags & METHOD_FLAG_VARARG;
+
+			default_args_count = mi.default_arguments.size();
+			callee_name = mi.name;
+#ifdef DEBUG_ENABLED
+			arg_count -= 1;
+#endif
+
+			// Check each argument type
+			for (List<PropertyInfo>::Element *E = mi.arguments.front(); E; E = E->next()) {
+				arg_types.push_back(_type_from_property(E->get()));
+			}
+		} break;
+		default: {
+			if (p_call->op == OperatorNode::OP_CALL && p_call->arguments.size() < 2) {
+				_set_error("Parser bug: self method call without enough arguments.", p_call->line);
+				ERR_FAIL_V(DataType());
+			}
+
+			int arg_id = p_call->op == OperatorNode::OP_CALL ? 1 : 0;
+
+			if (p_call->arguments[arg_id]->type != Node::TYPE_IDENTIFIER) {
+				_set_error("Parser bug: invalid function call argument.", p_call->line);
+				ERR_FAIL_V(DataType());
+			}
+
+			// Check all arguments beforehand to solve warnings
+			for (int i = arg_id + 1; i < p_call->arguments.size(); i++) {
+				_reduce_node_type(p_call->arguments[i]);
+			}
+
+			IdentifierNode *func_id = static_cast<IdentifierNode *>(p_call->arguments[arg_id]);
+			callee_name = func_id->name;
+#ifdef DEBUG_ENABLED
+			arg_count -= 1 + arg_id;
+#endif
+
+			DataType base_type;
+			if (p_call->op == OperatorNode::OP_PARENT_CALL) {
+				base_type = current_class->base_type;
+			} else {
+				base_type = _reduce_node_type(p_call->arguments[0]);
+			}
+
+			if (!base_type.has_type || (base_type.kind == DataType::BUILTIN && base_type.builtin_type == Variant::NIL)) {
+				_mark_line_as_unsafe(p_call->line);
+				return DataType();
+			}
+
+			if (base_type.kind == DataType::BUILTIN) {
+				Variant::CallError err;
+				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
+
+				if (check_types) {
+					if (!tmp.has_method(callee_name)) {
+						_set_error("The method \"" + callee_name + "\" isn't declared on base \"" + base_type.to_string() + "\".", p_call->line);
+						return DataType();
+					}
+
+					default_args_count = Variant::get_method_default_arguments(base_type.builtin_type, callee_name).size();
+					const Vector<Variant::Type> &var_arg_types = Variant::get_method_argument_types(base_type.builtin_type, callee_name);
+
+					for (int i = 0; i < var_arg_types.size(); i++) {
+						DataType argtype;
+						if (var_arg_types[i] != Variant::NIL) {
+							argtype.has_type = true;
+							argtype.kind = DataType::BUILTIN;
+							argtype.builtin_type = var_arg_types[i];
+						}
+						arg_types.push_back(argtype);
+					}
+				}
+
+				bool rets = false;
+				return_type.has_type = true;
+				return_type.kind = DataType::BUILTIN;
+				return_type.builtin_type = Variant::get_method_return_type(base_type.builtin_type, callee_name, &rets);
+				// If the method returns, but it might return any type, (Variant::NIL), pretend we don't know the type.
+				// At least make sure we know that it returns
+				if (rets && return_type.builtin_type == Variant::NIL) {
+					return_type.has_type = false;
+				}
+				break;
+			}
+
+			DataType original_type = base_type;
+			bool is_initializer = callee_name == "new";
+			bool is_get_script = p_call->arguments[0]->type == Node::TYPE_SELF && callee_name == "get_script";
+			bool is_static = false;
+			bool valid = false;
+
+			if (is_initializer && original_type.is_meta_type) {
+				// Try to check it as initializer
+				base_type = original_type;
+				callee_name = "_init";
+				base_type.is_meta_type = false;
+
+				valid = _get_function_signature(base_type, callee_name, return_type, arg_types,
+						default_args_count, is_static, is_vararg);
+
+				return_type = original_type;
+				return_type.is_meta_type = false;
+
+				valid = true; // There's always an initializer, we can assume this is true
+			}
+
+			if (is_get_script) {
+				// get_script() can be considered a meta-type.
+				return_type.kind = DataType::CLASS;
+				return_type.class_type = static_cast<ClassNode *>(head);
+				return_type.is_meta_type = true;
+				valid = true;
+			}
+
+			if (!valid) {
+				base_type = original_type;
+				return_type = DataType();
+				valid = _get_function_signature(base_type, callee_name, return_type, arg_types,
+						default_args_count, is_static, is_vararg);
+			}
+
+			if (!valid) {
+#ifdef DEBUG_ENABLED
+				if (p_call->arguments[0]->type == Node::TYPE_SELF) {
+					_set_error("The method \"" + callee_name + "\" isn't declared in the current class.", p_call->line);
+					return DataType();
+				}
+				DataType tmp_type;
+				valid = _get_member_type(original_type, func_id->name, tmp_type);
+				if (valid) {
+					if (tmp_type.is_constant) {
+						_add_warning(GDScriptWarning::CONSTANT_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
+					} else {
+						_add_warning(GDScriptWarning::PROPERTY_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
+					}
+				}
+				_add_warning(GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->line, callee_name, original_type.to_string());
+				_mark_line_as_unsafe(p_call->line);
+#endif // DEBUG_ENABLED
+				return DataType();
+			}
+
+#ifdef DEBUG_ENABLED
+			if (current_function && !for_completion && !is_static && p_call->arguments[0]->type == Node::TYPE_SELF && current_function->_static) {
+				_set_error("Can't call non-static function from a static function.", p_call->line);
+				return DataType();
+			}
+
+			if (check_types && !is_static && !is_initializer && base_type.is_meta_type) {
+				_set_error("Non-static function \"" + String(callee_name) + "\" can only be called from an instance.", p_call->line);
+				return DataType();
+			}
+
+			// Check signal emission for warnings
+			if (callee_name == "emit_signal" && p_call->op == OperatorNode::OP_CALL && p_call->arguments[0]->type == Node::TYPE_SELF && p_call->arguments.size() >= 3 && p_call->arguments[2]->type == Node::TYPE_CONSTANT) {
+				ConstantNode *sig = static_cast<ConstantNode *>(p_call->arguments[2]);
+				String emitted = sig->value.get_type() == Variant::STRING ? sig->value.operator String() : "";
+				for (int i = 0; i < current_class->_signals.size(); i++) {
+					if (current_class->_signals[i].name == emitted) {
+						current_class->_signals.write[i].emissions += 1;
+						break;
+					}
+				}
+			}
+#endif // DEBUG_ENABLED
+		} break;
+	}
+
+#ifdef DEBUG_ENABLED
+	if (!check_types) {
+		return return_type;
+	}
+
+	if (arg_count < arg_types.size() - default_args_count) {
+		_set_error("Too few arguments for \"" + callee_name + "()\" call. Expected at least " + itos(arg_types.size() - default_args_count) + ".", p_call->line);
+		return return_type;
+	}
+	if (!is_vararg && arg_count > arg_types.size()) {
+		_set_error("Too many arguments for \"" + callee_name + "()\" call. Expected at most " + itos(arg_types.size()) + ".", p_call->line);
+		return return_type;
+	}
+
+	int arg_diff = p_call->arguments.size() - arg_count;
+	for (int i = arg_diff; i < p_call->arguments.size(); i++) {
+		DataType par_type = _reduce_node_type(p_call->arguments[i]);
+
+		if ((i - arg_diff) >= arg_types.size()) {
+			continue;
+		}
+
+		DataType arg_type = arg_types[i - arg_diff];
+
+		if (!par_type.has_type) {
+			_mark_line_as_unsafe(p_call->line);
+			if (par_type.may_yield && p_call->arguments[i]->type == Node::TYPE_OPERATOR) {
+				_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i])));
+			}
+		} else if (!_is_type_compatible(arg_types[i - arg_diff], par_type, true)) {
+			// Supertypes are acceptable for dynamic compliance
+			if (!_is_type_compatible(par_type, arg_types[i - arg_diff])) {
+				_set_error("At \"" + callee_name + "()\" call, argument " + itos(i - arg_diff + 1) + ". The passed argument's type (" +
+								par_type.to_string() + ") doesn't match the function's expected argument type (" +
+								arg_types[i - arg_diff].to_string() + ").",
+						p_call->line);
+				return DataType();
+			} else {
+				_mark_line_as_unsafe(p_call->line);
+			}
+		} else {
+			if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_type.kind == DataType::BUILTIN && par_type.builtin_type == Variant::REAL) {
+				_add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, callee_name);
+			}
+		}
+	}
+#endif // DEBUG_ENABLED
+
+	return return_type;
+}
+
+bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type, bool *r_is_const) const {
+	DataType base_type = p_base_type;
+
+	// Check classes in current file
+	ClassNode *base = nullptr;
+	if (base_type.kind == DataType::CLASS) {
+		base = base_type.class_type;
+	}
+
+	while (base) {
+		if (base->constant_expressions.has(p_member)) {
+			if (r_is_const) {
+				*r_is_const = true;
+			}
+			r_member_type = base->constant_expressions[p_member].expression->get_datatype();
+			return true;
+		}
+
+		if (!base_type.is_meta_type) {
+			for (int i = 0; i < base->variables.size(); i++) {
+				if (base->variables[i].identifier == p_member) {
+					r_member_type = base->variables[i].data_type;
+					base->variables.write[i].usages += 1;
+					return true;
+				}
+			}
+		} else {
+			for (int i = 0; i < base->subclasses.size(); i++) {
+				ClassNode *c = base->subclasses[i];
+				if (c->name == p_member) {
+					DataType class_type;
+					class_type.has_type = true;
+					class_type.is_constant = true;
+					class_type.is_meta_type = true;
+					class_type.kind = DataType::CLASS;
+					class_type.class_type = c;
+					r_member_type = class_type;
+					return true;
+				}
+			}
+		}
+
+		base_type = base->base_type;
+		if (base_type.kind == DataType::CLASS) {
+			base = base_type.class_type;
+		} else {
+			break;
+		}
+	}
+
+	Ref<GDScript> gds;
+	if (base_type.kind == DataType::GDSCRIPT) {
+		gds = base_type.script_type;
+		if (gds.is_null() || !gds->is_valid()) {
+			// GDScript wasn't properly compíled, don't bother trying
+			return false;
+		}
+	}
+
+	Ref<Script> scr;
+	if (base_type.kind == DataType::SCRIPT) {
+		scr = base_type.script_type;
+	}
+
+	StringName native;
+	if (base_type.kind == DataType::NATIVE) {
+		native = base_type.native_type;
+	}
+
+	// Check GDScripts
+	while (gds.is_valid()) {
+		if (gds->get_constants().has(p_member)) {
+			Variant c = gds->get_constants()[p_member];
+			r_member_type = _type_from_variant(c);
+			return true;
+		}
+
+		if (!base_type.is_meta_type) {
+			if (gds->get_members().has(p_member)) {
+				r_member_type = _type_from_gdtype(gds->get_member_type(p_member));
+				return true;
+			}
+		}
+
+		native = gds->get_instance_base_type();
+		if (gds->get_base_script().is_valid()) {
+			gds = gds->get_base_script();
+			scr = gds->get_base_script();
+			bool is_meta = base_type.is_meta_type;
+			base_type = _type_from_variant(scr.operator Variant());
+			base_type.is_meta_type = is_meta;
+		} else {
+			break;
+		}
+	}
+
+#define IS_USAGE_MEMBER(m_usage) (!(m_usage & (PROPERTY_USAGE_GROUP | PROPERTY_USAGE_CATEGORY)))
+
+	// Check other script types
+	while (scr.is_valid()) {
+		Map<StringName, Variant> constants;
+		scr->get_constants(&constants);
+		if (constants.has(p_member)) {
+			r_member_type = _type_from_variant(constants[p_member]);
+			return true;
+		}
+
+		List<PropertyInfo> properties;
+		scr->get_script_property_list(&properties);
+		for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
+			if (E->get().name == p_member && IS_USAGE_MEMBER(E->get().usage)) {
+				r_member_type = _type_from_property(E->get());
+				return true;
+			}
+		}
+
+		base_type = _type_from_variant(scr.operator Variant());
+		native = scr->get_instance_base_type();
+		scr = scr->get_base_script();
+	}
+
+	if (native == StringName()) {
+		// Empty native class, might happen in some Script implementations
+		// Just ignore it
+		return false;
+	}
+
+	// Check ClassDB
+	if (!ClassDB::class_exists(native)) {
+		native = "_" + native.operator String();
+	}
+	if (!ClassDB::class_exists(native)) {
+		if (!check_types) {
+			return false;
+		}
+		ERR_FAIL_V_MSG(false, "Parser bug: Class \"" + String(native) + "\" not found.");
+	}
+
+	bool valid = false;
+	ClassDB::get_integer_constant(native, p_member, &valid);
+	if (valid) {
+		DataType ct;
+		ct.has_type = true;
+		ct.is_constant = true;
+		ct.kind = DataType::BUILTIN;
+		ct.builtin_type = Variant::INT;
+		r_member_type = ct;
+		return true;
+	}
+
+	if (!base_type.is_meta_type) {
+		List<PropertyInfo> properties;
+		ClassDB::get_property_list(native, &properties);
+		for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
+			if (E->get().name == p_member && IS_USAGE_MEMBER(E->get().usage)) {
+				// Check if a getter exists
+				StringName getter_name = ClassDB::get_property_getter(native, p_member);
+				if (getter_name != StringName()) {
+					// Use the getter return type
+#ifdef DEBUG_METHODS_ENABLED
+					MethodBind *getter_method = ClassDB::get_method(native, getter_name);
+					if (getter_method) {
+						r_member_type = _type_from_property(getter_method->get_return_info());
+					} else {
+						r_member_type = DataType();
+					}
+#else
+					r_member_type = DataType();
+#endif
+				} else {
+					r_member_type = _type_from_property(E->get());
+				}
+				return true;
+			}
+		}
+	}
+
+	// If the base is a script, it might be trying to access members of the Script class itself
+	if (p_base_type.is_meta_type && (p_base_type.kind == DataType::SCRIPT || p_base_type.kind == DataType::GDSCRIPT)) {
+		native = p_base_type.script_type->get_class_name();
+		ClassDB::get_integer_constant(native, p_member, &valid);
+		if (valid) {
+			DataType ct;
+			ct.has_type = true;
+			ct.is_constant = true;
+			ct.kind = DataType::BUILTIN;
+			ct.builtin_type = Variant::INT;
+			r_member_type = ct;
+			return true;
+		}
+
+		List<PropertyInfo> properties;
+		ClassDB::get_property_list(native, &properties);
+		for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
+			if (E->get().name == p_member && IS_USAGE_MEMBER(E->get().usage)) {
+				// Check if a getter exists
+				StringName getter_name = ClassDB::get_property_getter(native, p_member);
+				if (getter_name != StringName()) {
+					// Use the getter return type
+#ifdef DEBUG_METHODS_ENABLED
+					MethodBind *getter_method = ClassDB::get_method(native, getter_name);
+					if (getter_method) {
+						r_member_type = _type_from_property(getter_method->get_return_info());
+					} else {
+						r_member_type = DataType();
+					}
+#else
+					r_member_type = DataType();
+#endif
+				} else {
+					r_member_type = _type_from_property(E->get());
+				}
+				return true;
+			}
+		}
+	}
+#undef IS_USAGE_MEMBER
+
+	return false;
+}
+
+GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType *p_base_type, const StringName &p_identifier, int p_line, bool p_is_indexing) {
+	if (p_base_type && !p_base_type->has_type) {
+		return DataType();
+	}
+
+	DataType base_type;
+	DataType member_type;
+
+	if (!p_base_type) {
+		base_type.has_type = true;
+		base_type.is_constant = true;
+		base_type.kind = DataType::CLASS;
+		base_type.class_type = current_class;
+	} else {
+		base_type = DataType(*p_base_type);
+	}
+
+	bool is_const = false;
+	if (_get_member_type(base_type, p_identifier, member_type, &is_const)) {
+		if (!p_base_type && current_function && current_function->_static && !is_const) {
+			_set_error("Can't access member variable (\"" + p_identifier.operator String() + "\") from a static function.", p_line);
+			return DataType();
+		}
+		return member_type;
+	}
+
+	if (p_is_indexing) {
+		// Don't look for globals since this is an indexed identifier
+		return DataType();
+	}
+
+	if (!p_base_type) {
+		// Possibly this is a global, check before failing
+
+		if (ClassDB::class_exists(p_identifier) || ClassDB::class_exists("_" + p_identifier.operator String())) {
+			DataType result;
+			result.has_type = true;
+			result.is_constant = true;
+			result.is_meta_type = true;
+			if (Engine::get_singleton()->has_singleton(p_identifier) || Engine::get_singleton()->has_singleton("_" + p_identifier.operator String())) {
+				result.is_meta_type = false;
+			}
+			result.kind = DataType::NATIVE;
+			result.native_type = p_identifier;
+			return result;
+		}
+
+		ClassNode *outer_class = current_class;
+		while (outer_class) {
+			if (outer_class->name == p_identifier) {
+				DataType result;
+				result.has_type = true;
+				result.is_constant = true;
+				result.is_meta_type = true;
+				result.kind = DataType::CLASS;
+				result.class_type = outer_class;
+				return result;
+			}
+			if (outer_class->constant_expressions.has(p_identifier)) {
+				return outer_class->constant_expressions[p_identifier].type;
+			}
+			for (int i = 0; i < outer_class->subclasses.size(); i++) {
+				if (outer_class->subclasses[i] == current_class) {
+					continue;
+				}
+				if (outer_class->subclasses[i]->name == p_identifier) {
+					DataType result;
+					result.has_type = true;
+					result.is_constant = true;
+					result.is_meta_type = true;
+					result.kind = DataType::CLASS;
+					result.class_type = outer_class->subclasses[i];
+					return result;
+				}
+			}
+			outer_class = outer_class->owner;
+		}
+
+		if (ScriptServer::is_global_class(p_identifier)) {
+			Ref<Script> scr = ResourceLoader::load(ScriptServer::get_global_class_path(p_identifier));
+			if (scr.is_valid()) {
+				DataType result;
+				result.has_type = true;
+				result.script_type = scr;
+				result.is_constant = true;
+				result.is_meta_type = true;
+				Ref<GDScript> gds = scr;
+				if (gds.is_valid()) {
+					if (!gds->is_valid()) {
+						_set_error("The class \"" + p_identifier + "\" couldn't be fully loaded (script error or cyclic dependency).");
+						return DataType();
+					}
+					result.kind = DataType::GDSCRIPT;
+				} else {
+					result.kind = DataType::SCRIPT;
+				}
+				return result;
+			}
+			_set_error("The class \"" + p_identifier + "\" was found in global scope, but its script couldn't be loaded.");
+			return DataType();
+		}
+
+		if (GDScriptLanguage::get_singleton()->get_global_map().has(p_identifier)) {
+			int idx = GDScriptLanguage::get_singleton()->get_global_map()[p_identifier];
+			Variant g = GDScriptLanguage::get_singleton()->get_global_array()[idx];
+			return _type_from_variant(g);
+		}
+
+		if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
+			Variant g = GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier];
+			return _type_from_variant(g);
+		}
+
+		// Non-tool singletons aren't loaded, check project settings
+		List<PropertyInfo> props;
+		ProjectSettings::get_singleton()->get_property_list(&props);
+
+		for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+			String s = E->get().name;
+			if (!s.begins_with("autoload/")) {
+				continue;
+			}
+			String name = s.get_slice("/", 1);
+			if (name == p_identifier) {
+				String script = ProjectSettings::get_singleton()->get(s);
+				if (script.begins_with("*")) {
+					script = script.right(1);
+				}
+				if (!script.begins_with("res://")) {
+					script = "res://" + script;
+				}
+				Ref<Script> singleton = ResourceLoader::load(script);
+				if (singleton.is_valid()) {
+					DataType result;
+					result.has_type = true;
+					result.is_constant = true;
+					result.script_type = singleton;
+
+					Ref<GDScript> gds = singleton;
+					if (gds.is_valid()) {
+						if (!gds->is_valid()) {
+							_set_error("Couldn't fully load the singleton script \"" + p_identifier + "\" (possible cyclic reference or parse error).", p_line);
+							return DataType();
+						}
+						result.kind = DataType::GDSCRIPT;
+					} else {
+						result.kind = DataType::SCRIPT;
+					}
+				}
+			}
+		}
+
+		// This means looking in the current class, which type is always known
+		_set_error("The identifier \"" + p_identifier.operator String() + "\" isn't declared in the current scope.", p_line);
+	}
+
+#ifdef DEBUG_ENABLED
+	{
+		DataType tmp_type;
+		List<DataType> arg_types;
+		int argcount;
+		bool _static;
+		bool vararg;
+		if (_get_function_signature(base_type, p_identifier, tmp_type, arg_types, argcount, _static, vararg)) {
+			_add_warning(GDScriptWarning::FUNCTION_USED_AS_PROPERTY, p_line, p_identifier.operator String(), base_type.to_string());
+		}
+	}
+#endif // DEBUG_ENABLED
+
+	_mark_line_as_unsafe(p_line);
+	return DataType();
+}
+
+void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
+	// Names of internal object properties that we check to avoid overriding them.
+	// "__meta__" could also be in here, but since it doesn't really affect object metadata,
+	// it is okay to override it on script.
+	StringName script_name = CoreStringNames::get_singleton()->_script;
+
+	_mark_line_as_safe(p_class->line);
+
+	// Constants
+	for (Map<StringName, ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
+		ClassNode::Constant &c = E->get();
+		_mark_line_as_safe(c.expression->line);
+		DataType cont = _resolve_type(c.type, c.expression->line);
+		DataType expr = _resolve_type(c.expression->get_datatype(), c.expression->line);
+
+		if (check_types && !_is_type_compatible(cont, expr)) {
+			_set_error("The constant value type (" + expr.to_string() + ") isn't compatible with declared type (" + cont.to_string() + ").",
+					c.expression->line);
+			return;
+		}
+
+		expr.is_constant = true;
+		c.type = expr;
+		c.expression->set_datatype(expr);
+
+		DataType tmp;
+		const StringName &constant_name = E->key();
+		if (constant_name == script_name || _get_member_type(p_class->base_type, constant_name, tmp)) {
+			_set_error("The member \"" + String(constant_name) + "\" already exists in a parent class.", c.expression->line);
+			return;
+		}
+	}
+
+	// Function declarations
+	for (int i = 0; i < p_class->static_functions.size(); i++) {
+		_check_function_types(p_class->static_functions[i]);
+		if (error_set) {
+			return;
+		}
+	}
+
+	for (int i = 0; i < p_class->functions.size(); i++) {
+		_check_function_types(p_class->functions[i]);
+		if (error_set) {
+			return;
+		}
+	}
+
+	// Class variables
+	for (int i = 0; i < p_class->variables.size(); i++) {
+		ClassNode::Member &v = p_class->variables.write[i];
+
+		DataType tmp;
+		if (v.identifier == script_name || _get_member_type(p_class->base_type, v.identifier, tmp)) {
+			_set_error("The member \"" + String(v.identifier) + "\" already exists in a parent class.", v.line);
+			return;
+		}
+
+		_mark_line_as_safe(v.line);
+		v.data_type = _resolve_type(v.data_type, v.line);
+		v.initial_assignment->arguments[0]->set_datatype(v.data_type);
+
+		if (v.expression) {
+			DataType expr_type = _reduce_node_type(v.expression);
+
+			if (check_types && !_is_type_compatible(v.data_type, expr_type)) {
+				// Try supertype test
+				if (_is_type_compatible(expr_type, v.data_type)) {
+					_mark_line_as_unsafe(v.line);
+				} else {
+					// Try with implicit conversion
+					if (v.data_type.kind != DataType::BUILTIN || !_is_type_compatible(v.data_type, expr_type, true)) {
+						_set_error("The assigned expression's type (" + expr_type.to_string() + ") doesn't match the variable's type (" +
+										v.data_type.to_string() + ").",
+								v.line);
+						return;
+					}
+
+					// Replace assignment with implicit conversion
+					BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
+					convert->line = v.line;
+					convert->function = GDScriptFunctions::TYPE_CONVERT;
+
+					ConstantNode *tgt_type = alloc_node<ConstantNode>();
+					tgt_type->line = v.line;
+					tgt_type->value = (int)v.data_type.builtin_type;
+
+					OperatorNode *convert_call = alloc_node<OperatorNode>();
+					convert_call->line = v.line;
+					convert_call->op = OperatorNode::OP_CALL;
+					convert_call->arguments.push_back(convert);
+					convert_call->arguments.push_back(v.expression);
+					convert_call->arguments.push_back(tgt_type);
+
+					v.expression = convert_call;
+					v.initial_assignment->arguments.write[1] = convert_call;
+				}
+			}
+
+			if (v.data_type.infer_type) {
+				if (!expr_type.has_type) {
+					_set_error("The assigned value doesn't have a set type; the variable type can't be inferred.", v.line);
+					return;
+				}
+				if (expr_type.kind == DataType::BUILTIN && expr_type.builtin_type == Variant::NIL) {
+					_set_error("The variable type cannot be inferred because its value is \"null\".", v.line);
+					return;
+				}
+				v.data_type = expr_type;
+				v.data_type.is_constant = false;
+			}
+		}
+
+		// Check export hint
+		if (v.data_type.has_type && v._export.type != Variant::NIL) {
+			DataType export_type = _type_from_property(v._export);
+			if (!_is_type_compatible(v.data_type, export_type, true)) {
+				_set_error("The export hint's type (" + export_type.to_string() + ") doesn't match the variable's type (" +
+								v.data_type.to_string() + ").",
+						v.line);
+				return;
+			}
+		}
+
+		// Setter and getter
+		if (v.setter == StringName() && v.getter == StringName()) {
+			continue;
+		}
+
+		bool found_getter = false;
+		bool found_setter = false;
+		for (int j = 0; j < p_class->functions.size(); j++) {
+			if (v.setter == p_class->functions[j]->name) {
+				found_setter = true;
+				FunctionNode *setter = p_class->functions[j];
+
+				if (setter->get_required_argument_count() != 1 &&
+						!(setter->get_required_argument_count() == 0 && setter->default_values.size() > 0)) {
+					_set_error("The setter function needs to receive exactly 1 argument. See \"" + setter->name +
+									"()\" definition at line " + itos(setter->line) + ".",
+							v.line);
+					return;
+				}
+				if (!_is_type_compatible(v.data_type, setter->argument_types[0])) {
+					_set_error("The setter argument's type (" + setter->argument_types[0].to_string() +
+									") doesn't match the variable's type (" + v.data_type.to_string() + "). See \"" +
+									setter->name + "()\" definition at line " + itos(setter->line) + ".",
+							v.line);
+					return;
+				}
+				continue;
+			}
+			if (v.getter == p_class->functions[j]->name) {
+				found_getter = true;
+				FunctionNode *getter = p_class->functions[j];
+
+				if (getter->get_required_argument_count() != 0) {
+					_set_error("The getter function can't receive arguments. See \"" + getter->name +
+									"()\" definition at line " + itos(getter->line) + ".",
+							v.line);
+					return;
+				}
+				if (!_is_type_compatible(v.data_type, getter->get_datatype())) {
+					_set_error("The getter return type (" + getter->get_datatype().to_string() +
+									") doesn't match the variable's type (" + v.data_type.to_string() +
+									"). See \"" + getter->name + "()\" definition at line " + itos(getter->line) + ".",
+							v.line);
+					return;
+				}
+			}
+			if (found_getter && found_setter) {
+				break;
+			}
+		}
+
+		if ((found_getter || v.getter == StringName()) && (found_setter || v.setter == StringName())) {
+			continue;
+		}
+
+		// Check for static functions
+		for (int j = 0; j < p_class->static_functions.size(); j++) {
+			if (v.setter == p_class->static_functions[j]->name) {
+				FunctionNode *setter = p_class->static_functions[j];
+				_set_error("The setter can't be a static function. See \"" + setter->name + "()\" definition at line " + itos(setter->line) + ".", v.line);
+				return;
+			}
+			if (v.getter == p_class->static_functions[j]->name) {
+				FunctionNode *getter = p_class->static_functions[j];
+				_set_error("The getter can't be a static function. See \"" + getter->name + "()\" definition at line " + itos(getter->line) + ".", v.line);
+				return;
+			}
+		}
+
+		if (!found_setter && v.setter != StringName()) {
+			_set_error("The setter function isn't defined.", v.line);
+			return;
+		}
+
+		if (!found_getter && v.getter != StringName()) {
+			_set_error("The getter function isn't defined.", v.line);
+			return;
+		}
+	}
+
+	// Signals
+	DataType base = p_class->base_type;
+
+	while (base.kind == DataType::CLASS) {
+		ClassNode *base_class = base.class_type;
+		for (int i = 0; i < p_class->_signals.size(); i++) {
+			for (int j = 0; j < base_class->_signals.size(); j++) {
+				if (p_class->_signals[i].name == base_class->_signals[j].name) {
+					_set_error("The signal \"" + p_class->_signals[i].name + "\" already exists in a parent class.", p_class->_signals[i].line);
+					return;
+				}
+			}
+		}
+		base = base_class->base_type;
+	}
+
+	StringName native;
+	if (base.kind == DataType::GDSCRIPT || base.kind == DataType::SCRIPT) {
+		Ref<Script> scr = base.script_type;
+		if (scr.is_valid() && scr->is_valid()) {
+			native = scr->get_instance_base_type();
+			for (int i = 0; i < p_class->_signals.size(); i++) {
+				if (scr->has_script_signal(p_class->_signals[i].name)) {
+					_set_error("The signal \"" + p_class->_signals[i].name + "\" already exists in a parent class.", p_class->_signals[i].line);
+					return;
+				}
+			}
+		}
+	} else if (base.kind == DataType::NATIVE) {
+		native = base.native_type;
+	}
+
+	if (native != StringName()) {
+		for (int i = 0; i < p_class->_signals.size(); i++) {
+			if (ClassDB::has_signal(native, p_class->_signals[i].name)) {
+				_set_error("The signal \"" + p_class->_signals[i].name + "\" already exists in a parent class.", p_class->_signals[i].line);
+				return;
+			}
+		}
+	}
+
+	// Inner classes
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
+		current_class = p_class->subclasses[i];
+		_check_class_level_types(current_class);
+		if (error_set) {
+			return;
+		}
+		current_class = p_class;
+	}
+}
+
+void GDScriptParser::_check_function_types(FunctionNode *p_function) {
+	p_function->return_type = _resolve_type(p_function->return_type, p_function->line);
+
+	// Arguments
+	int defaults_ofs = p_function->arguments.size() - p_function->default_values.size();
+	for (int i = 0; i < p_function->arguments.size(); i++) {
+		if (i < defaults_ofs) {
+			p_function->argument_types.write[i] = _resolve_type(p_function->argument_types[i], p_function->line);
+		} else {
+			if (p_function->default_values[i - defaults_ofs]->type != Node::TYPE_OPERATOR) {
+				_set_error("Parser bug: invalid argument default value.", p_function->line, p_function->column);
+				return;
+			}
+
+			OperatorNode *op = static_cast<OperatorNode *>(p_function->default_values[i - defaults_ofs]);
+
+			if (op->op != OperatorNode::OP_ASSIGN || op->arguments.size() != 2) {
+				_set_error("Parser bug: invalid argument default value operation.", p_function->line);
+				return;
+			}
+
+			DataType def_type = _reduce_node_type(op->arguments[1]);
+
+			if (p_function->argument_types[i].infer_type) {
+				def_type.is_constant = false;
+				p_function->argument_types.write[i] = def_type;
+			} else {
+				p_function->argument_types.write[i] = _resolve_type(p_function->argument_types[i], p_function->line);
+
+				if (!_is_type_compatible(p_function->argument_types[i], def_type, true)) {
+					String arg_name = p_function->arguments[i];
+					_set_error("Value type (" + def_type.to_string() + ") doesn't match the type of argument '" +
+									arg_name + "' (" + p_function->argument_types[i].to_string() + ").",
+							p_function->line);
+				}
+			}
+		}
+#ifdef DEBUG_ENABLED
+		if (p_function->arguments_usage[i] == 0 && !p_function->arguments[i].operator String().begins_with("_")) {
+			_add_warning(GDScriptWarning::UNUSED_ARGUMENT, p_function->line, p_function->name, p_function->arguments[i].operator String());
+		}
+		for (int j = 0; j < current_class->variables.size(); j++) {
+			if (current_class->variables[j].identifier == p_function->arguments[i]) {
+				_add_warning(GDScriptWarning::SHADOWED_VARIABLE, p_function->line, p_function->arguments[i], itos(current_class->variables[j].line));
+			}
+		}
+#endif // DEBUG_ENABLED
+	}
+
+	if (!(p_function->name == "_init")) {
+		// Signature for the initializer may vary
+#ifdef DEBUG_ENABLED
+		DataType return_type;
+		List<DataType> arg_types;
+		int default_arg_count = 0;
+		bool _static = false;
+		bool vararg = false;
+
+		DataType base_type = current_class->base_type;
+		if (_get_function_signature(base_type, p_function->name, return_type, arg_types, default_arg_count, _static, vararg)) {
+			bool valid = _static == p_function->_static;
+			valid = valid && return_type == p_function->return_type;
+			int argsize_diff = p_function->arguments.size() - arg_types.size();
+			valid = valid && argsize_diff >= 0;
+			valid = valid && p_function->default_values.size() >= default_arg_count + argsize_diff;
+			int i = 0;
+			for (List<DataType>::Element *E = arg_types.front(); valid && E; E = E->next()) {
+				valid = valid && E->get() == p_function->argument_types[i++];
+			}
+
+			if (!valid) {
+				String parent_signature = return_type.has_type ? return_type.to_string() : "Variant";
+				if (parent_signature == "null") {
+					parent_signature = "void";
+				}
+				parent_signature += " " + p_function->name + "(";
+				if (arg_types.size()) {
+					int j = 0;
+					for (List<DataType>::Element *E = arg_types.front(); E; E = E->next()) {
+						if (E != arg_types.front()) {
+							parent_signature += ", ";
+						}
+						String arg = E->get().to_string();
+						if (arg == "null" || arg == "var") {
+							arg = "Variant";
+						}
+						parent_signature += arg;
+						if (j == arg_types.size() - default_arg_count) {
+							parent_signature += "=default";
+						}
+
+						j++;
+					}
+				}
+				parent_signature += ")";
+				_set_error("The function signature doesn't match the parent. Parent signature is: \"" + parent_signature + "\".", p_function->line);
+				return;
+			}
+		}
+#endif // DEBUG_ENABLED
+	} else {
+		if (p_function->return_type.has_type && (p_function->return_type.kind != DataType::BUILTIN || p_function->return_type.builtin_type != Variant::NIL)) {
+			_set_error("The constructor can't return a value.", p_function->line);
+			return;
+		}
+	}
+
+	if (p_function->return_type.has_type && (p_function->return_type.kind != DataType::BUILTIN || p_function->return_type.builtin_type != Variant::NIL)) {
+		if (!p_function->body->has_return) {
+			_set_error("A non-void function must return a value in all possible paths.", p_function->line);
+			return;
+		}
+	}
+
+	if (p_function->has_yield) {
+		// yield() will make the function return a GDScriptFunctionState, so the type is ambiguous
+		p_function->return_type.has_type = false;
+		p_function->return_type.may_yield = true;
+	}
+}
+
+void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
+	// Function blocks
+	for (int i = 0; i < p_class->static_functions.size(); i++) {
+		current_function = p_class->static_functions[i];
+		current_block = current_function->body;
+		_mark_line_as_safe(current_function->line);
+		_check_block_types(current_block);
+		current_block = nullptr;
+		current_function = nullptr;
+		if (error_set) {
+			return;
+		}
+	}
+
+	for (int i = 0; i < p_class->functions.size(); i++) {
+		current_function = p_class->functions[i];
+		current_block = current_function->body;
+		_mark_line_as_safe(current_function->line);
+		_check_block_types(current_block);
+		current_block = nullptr;
+		current_function = nullptr;
+		if (error_set) {
+			return;
+		}
+	}
+
+#ifdef DEBUG_ENABLED
+	// Warnings
+	for (int i = 0; i < p_class->variables.size(); i++) {
+		if (p_class->variables[i].usages == 0) {
+			_add_warning(GDScriptWarning::UNUSED_CLASS_VARIABLE, p_class->variables[i].line, p_class->variables[i].identifier);
+		}
+	}
+	for (int i = 0; i < p_class->_signals.size(); i++) {
+		if (p_class->_signals[i].emissions == 0) {
+			_add_warning(GDScriptWarning::UNUSED_SIGNAL, p_class->_signals[i].line, p_class->_signals[i].name);
+		}
+	}
+#endif // DEBUG_ENABLED
+
+	// Inner classes
+	for (int i = 0; i < p_class->subclasses.size(); i++) {
+		current_class = p_class->subclasses[i];
+		_check_class_blocks_types(current_class);
+		if (error_set) {
+			return;
+		}
+		current_class = p_class;
+	}
+}
+
+#ifdef DEBUG_ENABLED
+static String _find_function_name(const GDScriptParser::OperatorNode *p_call) {
+	switch (p_call->arguments[0]->type) {
+		case GDScriptParser::Node::TYPE_TYPE: {
+			return Variant::get_type_name(static_cast<GDScriptParser::TypeNode *>(p_call->arguments[0])->vtype);
+		} break;
+		case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
+			return GDScriptFunctions::get_func_name(static_cast<GDScriptParser::BuiltInFunctionNode *>(p_call->arguments[0])->function);
+		} break;
+		default: {
+			int id_index = p_call->op == GDScriptParser::OperatorNode::OP_PARENT_CALL ? 0 : 1;
+			if (p_call->arguments.size() > id_index && p_call->arguments[id_index]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
+				return static_cast<GDScriptParser::IdentifierNode *>(p_call->arguments[id_index])->name;
+			}
+		} break;
+	}
+	return String();
+}
+#endif // DEBUG_ENABLED
+
+void GDScriptParser::_check_block_types(BlockNode *p_block) {
+	Node *last_var_assign = nullptr;
+
+	// Check each statement
+	for (int z = 0; z < p_block->statements.size(); z++) {
+		Node *statement = p_block->statements[z];
+		switch (statement->type) {
+			case Node::TYPE_NEWLINE:
+			case Node::TYPE_BREAKPOINT: {
+				// Nothing to do
+			} break;
+			case Node::TYPE_ASSERT: {
+				AssertNode *an = static_cast<AssertNode *>(statement);
+				_mark_line_as_safe(an->line);
+				_reduce_node_type(an->condition);
+				_reduce_node_type(an->message);
+			} break;
+			case Node::TYPE_LOCAL_VAR: {
+				LocalVarNode *lv = static_cast<LocalVarNode *>(statement);
+				lv->datatype = _resolve_type(lv->datatype, lv->line);
+				_mark_line_as_safe(lv->line);
+
+				last_var_assign = lv->assign;
+				if (lv->assign) {
+					lv->assign_op->arguments[0]->set_datatype(lv->datatype);
+					DataType assign_type = _reduce_node_type(lv->assign);
+#ifdef DEBUG_ENABLED
+					if (assign_type.has_type && assign_type.kind == DataType::BUILTIN && assign_type.builtin_type == Variant::NIL) {
+						if (lv->assign->type == Node::TYPE_OPERATOR) {
+							OperatorNode *call = static_cast<OperatorNode *>(lv->assign);
+							if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
+								_add_warning(GDScriptWarning::VOID_ASSIGNMENT, lv->line, _find_function_name(call));
+							}
+						}
+					}
+					if (lv->datatype.has_type && assign_type.may_yield && lv->assign->type == Node::TYPE_OPERATOR) {
+						_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, lv->line, _find_function_name(static_cast<OperatorNode *>(lv->assign)));
+					}
+					for (int i = 0; i < current_class->variables.size(); i++) {
+						if (current_class->variables[i].identifier == lv->name) {
+							_add_warning(GDScriptWarning::SHADOWED_VARIABLE, lv->line, lv->name, itos(current_class->variables[i].line));
+						}
+					}
+#endif // DEBUG_ENABLED
+
+					if (!_is_type_compatible(lv->datatype, assign_type)) {
+						// Try supertype test
+						if (_is_type_compatible(assign_type, lv->datatype)) {
+							_mark_line_as_unsafe(lv->line);
+						} else {
+							// Try implicit conversion
+							if (lv->datatype.kind != DataType::BUILTIN || !_is_type_compatible(lv->datatype, assign_type, true)) {
+								_set_error("The assigned value type (" + assign_type.to_string() + ") doesn't match the variable's type (" +
+												lv->datatype.to_string() + ").",
+										lv->line);
+								return;
+							}
+							// Replace assignment with implicit conversion
+							BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
+							convert->line = lv->line;
+							convert->function = GDScriptFunctions::TYPE_CONVERT;
+
+							ConstantNode *tgt_type = alloc_node<ConstantNode>();
+							tgt_type->line = lv->line;
+							tgt_type->value = (int)lv->datatype.builtin_type;
+
+							OperatorNode *convert_call = alloc_node<OperatorNode>();
+							convert_call->line = lv->line;
+							convert_call->op = OperatorNode::OP_CALL;
+							convert_call->arguments.push_back(convert);
+							convert_call->arguments.push_back(lv->assign);
+							convert_call->arguments.push_back(tgt_type);
+
+							lv->assign = convert_call;
+							lv->assign_op->arguments.write[1] = convert_call;
+#ifdef DEBUG_ENABLED
+							if (lv->datatype.builtin_type == Variant::INT && assign_type.builtin_type == Variant::REAL) {
+								_add_warning(GDScriptWarning::NARROWING_CONVERSION, lv->line);
+							}
+#endif // DEBUG_ENABLED
+						}
+					}
+					if (lv->datatype.infer_type) {
+						if (!assign_type.has_type) {
+							_set_error("The assigned value doesn't have a set type; the variable type can't be inferred.", lv->line);
+							return;
+						}
+						if (assign_type.kind == DataType::BUILTIN && assign_type.builtin_type == Variant::NIL) {
+							_set_error("The variable type cannot be inferred because its value is \"null\".", lv->line);
+							return;
+						}
+						lv->datatype = assign_type;
+						lv->datatype.is_constant = false;
+					}
+					if (lv->datatype.has_type && !assign_type.has_type) {
+						_mark_line_as_unsafe(lv->line);
+					}
+				}
+			} break;
+			case Node::TYPE_OPERATOR: {
+				OperatorNode *op = static_cast<OperatorNode *>(statement);
+
+				switch (op->op) {
+					case OperatorNode::OP_ASSIGN:
+					case OperatorNode::OP_ASSIGN_ADD:
+					case OperatorNode::OP_ASSIGN_SUB:
+					case OperatorNode::OP_ASSIGN_MUL:
+					case OperatorNode::OP_ASSIGN_DIV:
+					case OperatorNode::OP_ASSIGN_MOD:
+					case OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+					case OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+					case OperatorNode::OP_ASSIGN_BIT_AND:
+					case OperatorNode::OP_ASSIGN_BIT_OR:
+					case OperatorNode::OP_ASSIGN_BIT_XOR: {
+						if (op->arguments.size() < 2) {
+							_set_error("Parser bug: operation without enough arguments.", op->line, op->column);
+							return;
+						}
+
+						if (op->arguments[1] == last_var_assign) {
+							// Assignment was already checked
+							break;
+						}
+
+						_mark_line_as_safe(op->line);
+
+						DataType lh_type = _reduce_node_type(op->arguments[0]);
+
+						if (error_set) {
+							return;
+						}
+
+						if (check_types) {
+							if (!lh_type.has_type) {
+								if (op->arguments[0]->type == Node::TYPE_OPERATOR) {
+									_mark_line_as_unsafe(op->line);
+								}
+							}
+							if (lh_type.is_constant) {
+								_set_error("Can't assign a new value to a constant.", op->line);
+								return;
+							}
+						}
+
+						DataType rh_type;
+						if (op->op != OperatorNode::OP_ASSIGN) {
+							// Validate operation
+							DataType arg_type = _reduce_node_type(op->arguments[1]);
+							if (!arg_type.has_type) {
+								_mark_line_as_unsafe(op->line);
+								break;
+							}
+
+							Variant::Operator oper = _get_variant_operation(op->op);
+							bool valid = false;
+							rh_type = _get_operation_type(oper, lh_type, arg_type, valid);
+
+							if (check_types && !valid) {
+								_set_error("Invalid operand types (\"" + lh_type.to_string() + "\" and \"" + arg_type.to_string() +
+												"\") to assignment operator \"" + Variant::get_operator_name(oper) + "\".",
+										op->line);
+								return;
+							}
+						} else {
+							rh_type = _reduce_node_type(op->arguments[1]);
+						}
+#ifdef DEBUG_ENABLED
+						if (rh_type.has_type && rh_type.kind == DataType::BUILTIN && rh_type.builtin_type == Variant::NIL) {
+							if (op->arguments[1]->type == Node::TYPE_OPERATOR) {
+								OperatorNode *call = static_cast<OperatorNode *>(op->arguments[1]);
+								if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
+									_add_warning(GDScriptWarning::VOID_ASSIGNMENT, op->line, _find_function_name(call));
+								}
+							}
+						}
+						if (lh_type.has_type && rh_type.may_yield && op->arguments[1]->type == Node::TYPE_OPERATOR) {
+							_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, op->line, _find_function_name(static_cast<OperatorNode *>(op->arguments[1])));
+						}
+
+#endif // DEBUG_ENABLED
+						bool type_match = lh_type.has_type && rh_type.has_type;
+						if (check_types && !_is_type_compatible(lh_type, rh_type)) {
+							type_match = false;
+
+							// Try supertype test
+							if (_is_type_compatible(rh_type, lh_type)) {
+								_mark_line_as_unsafe(op->line);
+							} else {
+								// Try implicit conversion
+								if (lh_type.kind != DataType::BUILTIN || !_is_type_compatible(lh_type, rh_type, true)) {
+									_set_error("The assigned value's type (" + rh_type.to_string() + ") doesn't match the variable's type (" +
+													lh_type.to_string() + ").",
+											op->line);
+									return;
+								}
+								if (op->op == OperatorNode::OP_ASSIGN) {
+									// Replace assignment with implicit conversion
+									BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
+									convert->line = op->line;
+									convert->function = GDScriptFunctions::TYPE_CONVERT;
+
+									ConstantNode *tgt_type = alloc_node<ConstantNode>();
+									tgt_type->line = op->line;
+									tgt_type->value = (int)lh_type.builtin_type;
+
+									OperatorNode *convert_call = alloc_node<OperatorNode>();
+									convert_call->line = op->line;
+									convert_call->op = OperatorNode::OP_CALL;
+									convert_call->arguments.push_back(convert);
+									convert_call->arguments.push_back(op->arguments[1]);
+									convert_call->arguments.push_back(tgt_type);
+
+									op->arguments.write[1] = convert_call;
+
+									type_match = true; // Since we are converting, the type is matching
+								}
+#ifdef DEBUG_ENABLED
+								if (lh_type.builtin_type == Variant::INT && rh_type.builtin_type == Variant::REAL) {
+									_add_warning(GDScriptWarning::NARROWING_CONVERSION, op->line);
+								}
+#endif // DEBUG_ENABLED
+							}
+						}
+#ifdef DEBUG_ENABLED
+						if (!rh_type.has_type && (op->op != OperatorNode::OP_ASSIGN || lh_type.has_type || op->arguments[0]->type == Node::TYPE_OPERATOR)) {
+							_mark_line_as_unsafe(op->line);
+						}
+#endif // DEBUG_ENABLED
+						op->datatype.has_type = type_match;
+					} break;
+					case OperatorNode::OP_CALL:
+					case OperatorNode::OP_PARENT_CALL: {
+						_mark_line_as_safe(op->line);
+						DataType func_type = _reduce_function_call_type(op);
+#ifdef DEBUG_ENABLED
+						if (func_type.has_type && (func_type.kind != DataType::BUILTIN || func_type.builtin_type != Variant::NIL)) {
+							// Figure out function name for warning
+							String func_name = _find_function_name(op);
+							if (func_name.empty()) {
+								func_name = "<undetected name>";
+							}
+							_add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
+						}
+#endif // DEBUG_ENABLED
+						if (error_set) {
+							return;
+						}
+					} break;
+					case OperatorNode::OP_YIELD: {
+						_mark_line_as_safe(op->line);
+						_reduce_node_type(op);
+					} break;
+					default: {
+						_mark_line_as_safe(op->line);
+						_reduce_node_type(op); // Test for safety anyway
+#ifdef DEBUG_ENABLED
+						if (op->op == OperatorNode::OP_TERNARY_IF) {
+							_add_warning(GDScriptWarning::STANDALONE_TERNARY, statement->line);
+						} else {
+							_add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
+						}
+#endif // DEBUG_ENABLED
+					}
+				}
+			} break;
+			case Node::TYPE_CONTROL_FLOW: {
+				ControlFlowNode *cf = static_cast<ControlFlowNode *>(statement);
+				_mark_line_as_safe(cf->line);
+
+				switch (cf->cf_type) {
+					case ControlFlowNode::CF_RETURN: {
+						DataType function_type = current_function->get_datatype();
+
+						DataType ret_type;
+						if (cf->arguments.size() > 0) {
+							ret_type = _reduce_node_type(cf->arguments[0]);
+							if (error_set) {
+								return;
+							}
+						}
+
+						if (!function_type.has_type) {
+							break;
+						}
+
+						if (function_type.kind == DataType::BUILTIN && function_type.builtin_type == Variant::NIL) {
+							// Return void, should not have arguments
+							if (cf->arguments.size() > 0) {
+								_set_error("A void function cannot return a value.", cf->line, cf->column);
+								return;
+							}
+						} else {
+							// Return something, cannot be empty
+							if (cf->arguments.size() == 0) {
+								_set_error("A non-void function must return a value.", cf->line, cf->column);
+								return;
+							}
+
+							if (!_is_type_compatible(function_type, ret_type)) {
+								_set_error("The returned value type (" + ret_type.to_string() + ") doesn't match the function return type (" +
+												function_type.to_string() + ").",
+										cf->line, cf->column);
+								return;
+							}
+						}
+					} break;
+					case ControlFlowNode::CF_MATCH: {
+						MatchNode *match_node = cf->match;
+						_transform_match_statment(match_node);
+					} break;
+					default: {
+						if (cf->body_else) {
+							_mark_line_as_safe(cf->body_else->line);
+						}
+						for (int i = 0; i < cf->arguments.size(); i++) {
+							_reduce_node_type(cf->arguments[i]);
+						}
+					} break;
+				}
+			} break;
+			case Node::TYPE_CONSTANT: {
+				ConstantNode *cn = static_cast<ConstantNode *>(statement);
+				// Strings are fine since they can be multiline comments
+				if (cn->value.get_type() == Variant::STRING) {
+					break;
+				}
+				FALLTHROUGH;
+			}
+			default: {
+				_mark_line_as_safe(statement->line);
+				_reduce_node_type(statement); // Test for safety anyway
+#ifdef DEBUG_ENABLED
+				_add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
+#endif // DEBUG_ENABLED
+			}
+		}
+	}
+
+	// Parse sub blocks
+	for (int i = 0; i < p_block->sub_blocks.size(); i++) {
+		current_block = p_block->sub_blocks[i];
+		_check_block_types(current_block);
+		current_block = p_block;
+		if (error_set) {
+			return;
+		}
+	}
+
+#ifdef DEBUG_ENABLED
+	// Warnings check
+	for (Map<StringName, LocalVarNode *>::Element *E = p_block->variables.front(); E; E = E->next()) {
+		LocalVarNode *lv = E->get();
+		if (!lv->name.operator String().begins_with("_")) {
+			if (lv->usages == 0) {
+				_add_warning(GDScriptWarning::UNUSED_VARIABLE, lv->line, lv->name);
+			} else if (lv->assignments == 0) {
+				_add_warning(GDScriptWarning::UNASSIGNED_VARIABLE, lv->line, lv->name);
+			}
+		}
+	}
+#endif // DEBUG_ENABLED
+}
+
+void GDScriptParser::_set_error(const String &p_error, int p_line, int p_column) {
+	if (error_set) {
+		return; //allow no further errors
+	}
+
+	error = p_error;
+	error_line = p_line < 0 ? tokenizer->get_token_line() : p_line;
+	error_column = p_column < 0 ? tokenizer->get_token_column() : p_column;
+	error_set = true;
+}
+
+#ifdef DEBUG_ENABLED
+void GDScriptParser::_add_warning(int p_code, int p_line, const String &p_symbol1, const String &p_symbol2, const String &p_symbol3, const String &p_symbol4) {
+	Vector<String> symbols;
+	if (!p_symbol1.empty()) {
+		symbols.push_back(p_symbol1);
+	}
+	if (!p_symbol2.empty()) {
+		symbols.push_back(p_symbol2);
+	}
+	if (!p_symbol3.empty()) {
+		symbols.push_back(p_symbol3);
+	}
+	if (!p_symbol4.empty()) {
+		symbols.push_back(p_symbol4);
+	}
+	_add_warning(p_code, p_line, symbols);
+}
+
+void GDScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &p_symbols) {
+	if (GLOBAL_GET("debug/gdscript/warnings/exclude_addons").booleanize() && base_path.begins_with("res://addons/")) {
+		return;
+	}
+	if (tokenizer->is_ignoring_warnings() || !GLOBAL_GET("debug/gdscript/warnings/enable").booleanize()) {
+		return;
+	}
+	String warn_name = GDScriptWarning::get_name_from_code((GDScriptWarning::Code)p_code).to_lower();
+	if (tokenizer->get_warning_global_skips().has(warn_name)) {
+		return;
+	}
+	if (!GLOBAL_GET("debug/gdscript/warnings/" + warn_name)) {
+		return;
+	}
+
+	GDScriptWarning warn;
+	warn.code = (GDScriptWarning::Code)p_code;
+	warn.symbols = p_symbols;
+	warn.line = p_line == -1 ? tokenizer->get_token_line() : p_line;
+
+	List<GDScriptWarning>::Element *before = nullptr;
+	for (List<GDScriptWarning>::Element *E = warnings.front(); E; E = E->next()) {
+		if (E->get().line > warn.line) {
+			break;
+		}
+		before = E;
+	}
+	if (before) {
+		warnings.insert_after(before, warn);
+	} else {
+		warnings.push_front(warn);
+	}
+}
+#endif // DEBUG_ENABLED
+
+String GDScriptParser::get_error() const {
+	return error;
+}
+
+int GDScriptParser::get_error_line() const {
+	return error_line;
+}
+int GDScriptParser::get_error_column() const {
+	return error_column;
+}
+
+bool GDScriptParser::has_error() const {
+	return error_set;
+}
+
+Error GDScriptParser::_parse(const String &p_base_path) {
+	base_path = p_base_path;
+
+	//assume class
+	ClassNode *main_class = alloc_node<ClassNode>();
+	main_class->initializer = alloc_node<BlockNode>();
+	main_class->initializer->parent_class = main_class;
+	main_class->ready = alloc_node<BlockNode>();
+	main_class->ready->parent_class = main_class;
+	current_class = main_class;
+
+	_parse_class(main_class);
+
+	if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
+		error_set = false;
+		_set_error("Parse error: " + tokenizer->get_token_error());
+	}
+
+	bool for_completion_error_set = false;
+	if (error_set && for_completion) {
+		for_completion_error_set = true;
+		error_set = false;
+	}
+
+	if (error_set) {
+		return ERR_PARSE_ERROR;
+	}
+
+	if (dependencies_only) {
+		return OK;
+	}
+
+	_determine_inheritance(main_class);
+
+	if (error_set) {
+		return ERR_PARSE_ERROR;
+	}
+
+	current_class = main_class;
+	current_function = nullptr;
+	current_block = nullptr;
+
+	if (for_completion) {
+		check_types = false;
+	}
+
+	// Resolve all class-level stuff before getting into function blocks
+	_check_class_level_types(main_class);
+
+	if (error_set) {
+		return ERR_PARSE_ERROR;
+	}
+
+	// Resolve the function blocks
+	_check_class_blocks_types(main_class);
+
+	if (for_completion_error_set) {
+		error_set = true;
+	}
+
+	if (error_set) {
+		return ERR_PARSE_ERROR;
+	}
+
+#ifdef DEBUG_ENABLED
+
+	// Resolve warning ignores
+	Vector<Pair<int, String>> warning_skips = tokenizer->get_warning_skips();
+	bool warning_is_error = GLOBAL_GET("debug/gdscript/warnings/treat_warnings_as_errors").booleanize();
+	for (List<GDScriptWarning>::Element *E = warnings.front(); E;) {
+		GDScriptWarning &w = E->get();
+		int skip_index = -1;
+		for (int i = 0; i < warning_skips.size(); i++) {
+			if (warning_skips[i].first > w.line) {
+				break;
+			}
+			skip_index = i;
+		}
+		List<GDScriptWarning>::Element *next = E->next();
+		bool erase = false;
+		if (skip_index != -1) {
+			if (warning_skips[skip_index].second == GDScriptWarning::get_name_from_code(w.code).to_lower()) {
+				erase = true;
+			}
+			warning_skips.remove(skip_index);
+		}
+		if (erase) {
+			warnings.erase(E);
+		} else if (warning_is_error) {
+			_set_error(w.get_message() + " (warning treated as error)", w.line);
+			return ERR_PARSE_ERROR;
+		}
+		E = next;
+	}
+#endif // DEBUG_ENABLED
+
+	return OK;
+}
+
+Error GDScriptParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path, const String &p_self_path) {
+	clear();
+
+	self_path = p_self_path;
+	GDScriptTokenizerBuffer *tb = memnew(GDScriptTokenizerBuffer);
+	tb->set_code_buffer(p_bytecode);
+	tokenizer = tb;
+	Error ret = _parse(p_base_path);
+	memdelete(tb);
+	tokenizer = nullptr;
+	return ret;
+}
+
+Error GDScriptParser::parse(const String &p_code, const String &p_base_path, bool p_just_validate, const String &p_self_path, bool p_for_completion, Set<int> *r_safe_lines, bool p_dependencies_only) {
+	clear();
+
+	self_path = p_self_path;
+	GDScriptTokenizerText *tt = memnew(GDScriptTokenizerText);
+	tt->set_code(p_code);
+
+	validating = p_just_validate;
+	for_completion = p_for_completion;
+	dependencies_only = p_dependencies_only;
+#ifdef DEBUG_ENABLED
+	safe_lines = r_safe_lines;
+#endif // DEBUG_ENABLED
+	tokenizer = tt;
+	Error ret = _parse(p_base_path);
+	memdelete(tt);
+	tokenizer = nullptr;
+	return ret;
+}
+
+bool GDScriptParser::is_tool_script() const {
+	return (head && head->type == Node::TYPE_CLASS && static_cast<const ClassNode *>(head)->tool);
+}
+
+const GDScriptParser::Node *GDScriptParser::get_parse_tree() const {
+	return head;
+}
+
+void GDScriptParser::clear() {
+	while (list) {
+		Node *l = list;
+		list = list->next;
+		memdelete(l);
+	}
+
+	head = nullptr;
+	list = nullptr;
+
+	completion_type = COMPLETION_NONE;
+	completion_node = nullptr;
+	completion_class = nullptr;
+	completion_function = nullptr;
+	completion_block = nullptr;
+	current_block = nullptr;
+	current_class = nullptr;
+
+	completion_found = false;
+	rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+
+	current_function = nullptr;
+
+	validating = false;
+	for_completion = false;
+	error_set = false;
+	indent_level.clear();
+	indent_level.push_back(IndentLevel(0, 0));
+	error_line = 0;
+	error_column = 0;
+	pending_newline = -1;
+	parenthesis = 0;
+	current_export.type = Variant::NIL;
+	check_types = true;
+	dependencies_only = false;
+	dependencies.clear();
+	error = "";
+#ifdef DEBUG_ENABLED
+	safe_lines = nullptr;
+#endif // DEBUG_ENABLED
+}
+
+GDScriptParser::CompletionType GDScriptParser::get_completion_type() {
+	return completion_type;
+}
+
+StringName GDScriptParser::get_completion_cursor() {
+	return completion_cursor;
+}
+
+int GDScriptParser::get_completion_line() {
+	return completion_line;
+}
+
+Variant::Type GDScriptParser::get_completion_built_in_constant() {
+	return completion_built_in_constant;
+}
+
+GDScriptParser::Node *GDScriptParser::get_completion_node() {
+	return completion_node;
+}
+
+GDScriptParser::BlockNode *GDScriptParser::get_completion_block() {
+	return completion_block;
+}
+
+GDScriptParser::ClassNode *GDScriptParser::get_completion_class() {
+	return completion_class;
+}
+
+GDScriptParser::FunctionNode *GDScriptParser::get_completion_function() {
+	return completion_function;
+}
+
+int GDScriptParser::get_completion_argument_index() {
+	return completion_argument;
+}
+
+int GDScriptParser::get_completion_identifier_is_function() {
+	return completion_ident_is_call;
+}
+
+GDScriptParser::GDScriptParser() {
+	head = nullptr;
+	list = nullptr;
+	tokenizer = nullptr;
+	pending_newline = -1;
+	clear();
+}
+
+GDScriptParser::~GDScriptParser() {
+	clear();
+}
diff --git a/modules/cscript/cscript_parser.h b/modules/cscript/cscript_parser.h
new file mode 100644
index 000000000..7b706b784
--- /dev/null
+++ b/modules/cscript/cscript_parser.h
@@ -0,0 +1,699 @@
+#ifndef CSCRIPT_PARSER_H
+#define CSCRIPT_PARSER_H
+/*************************************************************************/
+/*  gdscript_parser.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/map.h"
+#include "core/object.h"
+#include "core/script_language.h"
+#include "cscript_functions.h"
+#include "cscript_tokenizer.h"
+
+struct GDScriptDataType;
+struct GDScriptWarning;
+
+class GDScriptParser {
+public:
+	struct ClassNode;
+
+	struct DataType {
+		enum {
+			BUILTIN,
+			NATIVE,
+			SCRIPT,
+			GDSCRIPT,
+			CLASS,
+			UNRESOLVED
+		} kind;
+
+		bool has_type;
+		bool is_constant;
+		bool is_meta_type; // Whether the value can be used as a type
+		bool infer_type;
+		bool may_yield; // For function calls
+
+		Variant::Type builtin_type;
+		StringName native_type;
+		Ref<Script> script_type;
+		ClassNode *class_type;
+
+		String to_string() const;
+
+		bool operator==(const DataType &other) const {
+			if (!has_type || !other.has_type) {
+				return true; // Can be considered equal for parsing purpose
+			}
+			if (kind != other.kind) {
+				return false;
+			}
+			switch (kind) {
+				case BUILTIN: {
+					return builtin_type == other.builtin_type;
+				} break;
+				case NATIVE: {
+					return native_type == other.native_type;
+				} break;
+				case GDSCRIPT:
+				case SCRIPT: {
+					return script_type == other.script_type;
+				} break;
+				case CLASS: {
+					return class_type == other.class_type;
+				} break;
+				case UNRESOLVED: {
+				} break;
+			}
+			return false;
+		}
+
+		DataType() :
+				kind(UNRESOLVED),
+				has_type(false),
+				is_constant(false),
+				is_meta_type(false),
+				infer_type(false),
+				may_yield(false),
+				builtin_type(Variant::NIL),
+				class_type(nullptr) {}
+	};
+
+	struct Node {
+		enum Type {
+			TYPE_CLASS,
+			TYPE_FUNCTION,
+			TYPE_BUILT_IN_FUNCTION,
+			TYPE_BLOCK,
+			TYPE_IDENTIFIER,
+			TYPE_TYPE,
+			TYPE_CONSTANT,
+			TYPE_ARRAY,
+			TYPE_DICTIONARY,
+			TYPE_SELF,
+			TYPE_OPERATOR,
+			TYPE_CONTROL_FLOW,
+			TYPE_LOCAL_VAR,
+			TYPE_CAST,
+			TYPE_ASSERT,
+			TYPE_BREAKPOINT,
+			TYPE_NEWLINE,
+		};
+
+		Node *next;
+		int line;
+		int column;
+		Type type;
+
+		virtual DataType get_datatype() const { return DataType(); }
+		virtual void set_datatype(const DataType &p_datatype) {}
+
+		virtual ~Node() {}
+	};
+
+	struct FunctionNode;
+	struct BlockNode;
+	struct ConstantNode;
+	struct LocalVarNode;
+	struct OperatorNode;
+
+	struct ClassNode : public Node {
+		bool tool;
+		StringName name;
+		bool extends_used;
+		bool classname_used;
+		StringName extends_file;
+		Vector<StringName> extends_class;
+		DataType base_type;
+		String icon_path;
+
+		struct Member {
+			PropertyInfo _export;
+#ifdef TOOLS_ENABLED
+			Variant default_value;
+#endif
+			StringName identifier;
+			DataType data_type;
+			StringName setter;
+			StringName getter;
+			int line;
+			Node *expression;
+			OperatorNode *initial_assignment;
+			MultiplayerAPI::RPCMode rpc_mode;
+			int usages;
+		};
+
+		struct Constant {
+			Node *expression;
+			DataType type;
+		};
+
+		struct Signal {
+			StringName name;
+			Vector<StringName> arguments;
+			int emissions;
+			int line;
+		};
+
+		Vector<ClassNode *> subclasses;
+		Vector<Member> variables;
+		Map<StringName, Constant> constant_expressions;
+		Vector<FunctionNode *> functions;
+		Vector<FunctionNode *> static_functions;
+		Vector<Signal> _signals;
+		BlockNode *initializer;
+		BlockNode *ready;
+		ClassNode *owner;
+		//Vector<Node*> initializers;
+		int end_line;
+
+		ClassNode() {
+			tool = false;
+			type = TYPE_CLASS;
+			extends_used = false;
+			classname_used = false;
+			end_line = -1;
+			owner = nullptr;
+		}
+	};
+
+	struct FunctionNode : public Node {
+		bool _static;
+		MultiplayerAPI::RPCMode rpc_mode;
+		bool has_yield;
+		bool has_unreachable_code;
+		StringName name;
+		DataType return_type;
+		Vector<StringName> arguments;
+		Vector<DataType> argument_types;
+		Vector<Node *> default_values;
+		BlockNode *body;
+#ifdef DEBUG_ENABLED
+		Vector<int> arguments_usage;
+#endif // DEBUG_ENABLED
+
+		virtual DataType get_datatype() const {
+			return return_type;
+		}
+		virtual void set_datatype(const DataType &p_datatype) {
+			return_type = p_datatype;
+		}
+		int get_required_argument_count() {
+			return arguments.size() - default_values.size();
+		}
+
+		FunctionNode() {
+			type = TYPE_FUNCTION;
+			_static = false;
+			rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
+			has_yield = false;
+			has_unreachable_code = false;
+		}
+	};
+
+	struct BlockNode : public Node {
+		ClassNode *parent_class;
+		BlockNode *parent_block;
+		Vector<Node *> statements;
+		Map<StringName, LocalVarNode *> variables;
+		bool has_return = false;
+		bool can_break = false;
+		bool can_continue = false;
+
+		Node *if_condition; //tiny hack to improve code completion on if () blocks
+
+		//the following is useful for code completion
+		List<BlockNode *> sub_blocks;
+		int end_line;
+		BlockNode() {
+			if_condition = nullptr;
+			type = TYPE_BLOCK;
+			end_line = -1;
+			parent_block = nullptr;
+			parent_class = nullptr;
+		}
+	};
+
+	struct TypeNode : public Node {
+		Variant::Type vtype;
+		TypeNode() { type = TYPE_TYPE; }
+	};
+	struct BuiltInFunctionNode : public Node {
+		GDScriptFunctions::Function function;
+		BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; }
+	};
+
+	struct IdentifierNode : public Node {
+		StringName name;
+		BlockNode *declared_block; // Simplify lookup by checking if it is declared locally
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		IdentifierNode() {
+			type = TYPE_IDENTIFIER;
+			declared_block = nullptr;
+		}
+	};
+
+	struct LocalVarNode : public Node {
+		StringName name;
+		Node *assign;
+		OperatorNode *assign_op;
+		int assignments;
+		int usages;
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		LocalVarNode() {
+			type = TYPE_LOCAL_VAR;
+			assign = nullptr;
+			assign_op = nullptr;
+			assignments = 0;
+			usages = 0;
+		}
+	};
+
+	struct ConstantNode : public Node {
+		Variant value;
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		ConstantNode() { type = TYPE_CONSTANT; }
+	};
+
+	struct ArrayNode : public Node {
+		Vector<Node *> elements;
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		ArrayNode() {
+			type = TYPE_ARRAY;
+			datatype.has_type = true;
+			datatype.kind = DataType::BUILTIN;
+			datatype.builtin_type = Variant::ARRAY;
+		}
+	};
+
+	struct DictionaryNode : public Node {
+		struct Pair {
+			Node *key;
+			Node *value;
+		};
+
+		Vector<Pair> elements;
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		DictionaryNode() {
+			type = TYPE_DICTIONARY;
+			datatype.has_type = true;
+			datatype.kind = DataType::BUILTIN;
+			datatype.builtin_type = Variant::DICTIONARY;
+		}
+	};
+
+	struct SelfNode : public Node {
+		SelfNode() { type = TYPE_SELF; }
+	};
+
+	struct OperatorNode : public Node {
+		enum Operator {
+			//call/constructor operator
+			OP_CALL,
+			OP_PARENT_CALL,
+			OP_YIELD,
+			OP_IS,
+			OP_IS_BUILTIN,
+			//indexing operator
+			OP_INDEX,
+			OP_INDEX_NAMED,
+			//unary operators
+			OP_NEG,
+			OP_POS,
+			OP_NOT,
+			OP_BIT_INVERT,
+			//binary operators (in precedence order)
+			OP_IN,
+			OP_EQUAL,
+			OP_NOT_EQUAL,
+			OP_LESS,
+			OP_LESS_EQUAL,
+			OP_GREATER,
+			OP_GREATER_EQUAL,
+			OP_AND,
+			OP_OR,
+			OP_ADD,
+			OP_SUB,
+			OP_MUL,
+			OP_DIV,
+			OP_MOD,
+			OP_SHIFT_LEFT,
+			OP_SHIFT_RIGHT,
+			OP_INIT_ASSIGN,
+			OP_ASSIGN,
+			OP_ASSIGN_ADD,
+			OP_ASSIGN_SUB,
+			OP_ASSIGN_MUL,
+			OP_ASSIGN_DIV,
+			OP_ASSIGN_MOD,
+			OP_ASSIGN_SHIFT_LEFT,
+			OP_ASSIGN_SHIFT_RIGHT,
+			OP_ASSIGN_BIT_AND,
+			OP_ASSIGN_BIT_OR,
+			OP_ASSIGN_BIT_XOR,
+			OP_BIT_AND,
+			OP_BIT_OR,
+			OP_BIT_XOR,
+			//ternary operators
+			OP_TERNARY_IF,
+			OP_TERNARY_ELSE,
+		};
+
+		Operator op;
+
+		Vector<Node *> arguments;
+		DataType datatype;
+		virtual DataType get_datatype() const { return datatype; }
+		virtual void set_datatype(const DataType &p_datatype) { datatype = p_datatype; }
+		OperatorNode() { type = TYPE_OPERATOR; }
+	};
+
+	struct PatternNode : public Node {
+		enum PatternType {
+			PT_CONSTANT,
+			PT_BIND,
+			PT_DICTIONARY,
+			PT_ARRAY,
+			PT_IGNORE_REST,
+			PT_WILDCARD
+		};
+
+		PatternType pt_type;
+
+		Node *constant;
+		StringName bind;
+		Map<ConstantNode *, PatternNode *> dictionary;
+		Vector<PatternNode *> array;
+	};
+
+	struct PatternBranchNode : public Node {
+		Vector<PatternNode *> patterns;
+		BlockNode *body;
+	};
+
+	struct MatchNode : public Node {
+		Node *val_to_match;
+		Vector<PatternBranchNode *> branches;
+
+		struct CompiledPatternBranch {
+			Node *compiled_pattern;
+			BlockNode *body;
+		};
+
+		Vector<CompiledPatternBranch> compiled_pattern_branches;
+	};
+
+	struct ControlFlowNode : public Node {
+		enum CFType {
+			CF_IF,
+			CF_FOR,
+			CF_WHILE,
+			CF_BREAK,
+			CF_CONTINUE,
+			CF_RETURN,
+			CF_MATCH
+		};
+
+		CFType cf_type;
+		Vector<Node *> arguments;
+		BlockNode *body;
+		BlockNode *body_else;
+
+		MatchNode *match;
+
+		ControlFlowNode *_else; //used for if
+		ControlFlowNode() {
+			type = TYPE_CONTROL_FLOW;
+			cf_type = CF_IF;
+			body = nullptr;
+			body_else = nullptr;
+		}
+	};
+
+	struct CastNode : public Node {
+		Node *source_node;
+		DataType cast_type;
+		DataType return_type;
+		virtual DataType get_datatype() const { return return_type; }
+		virtual void set_datatype(const DataType &p_datatype) { return_type = p_datatype; }
+		CastNode() { type = TYPE_CAST; }
+	};
+
+	struct AssertNode : public Node {
+		Node *condition;
+		Node *message;
+		AssertNode() :
+				condition(nullptr),
+				message(nullptr) {
+			type = TYPE_ASSERT;
+		}
+	};
+
+	struct BreakpointNode : public Node {
+		BreakpointNode() { type = TYPE_BREAKPOINT; }
+	};
+
+	struct NewLineNode : public Node {
+		NewLineNode() { type = TYPE_NEWLINE; }
+	};
+
+	struct Expression {
+		bool is_op;
+		union {
+			OperatorNode::Operator op;
+			Node *node;
+		};
+	};
+
+	enum CompletionType {
+		COMPLETION_NONE,
+		COMPLETION_BUILT_IN_TYPE_CONSTANT,
+		COMPLETION_GET_NODE,
+		COMPLETION_FUNCTION,
+		COMPLETION_IDENTIFIER,
+		COMPLETION_EXTENDS,
+		COMPLETION_PARENT_FUNCTION,
+		COMPLETION_METHOD,
+		COMPLETION_CALL_ARGUMENTS,
+		COMPLETION_RESOURCE_PATH,
+		COMPLETION_INDEX,
+		COMPLETION_VIRTUAL_FUNC,
+		COMPLETION_YIELD,
+		COMPLETION_ASSIGN,
+		COMPLETION_TYPE_HINT,
+		COMPLETION_TYPE_HINT_INDEX,
+	};
+
+private:
+	GDScriptTokenizer *tokenizer;
+
+	Node *head;
+	Node *list;
+	template <class T>
+	T *alloc_node();
+
+	bool validating;
+	bool for_completion;
+	int parenthesis;
+	bool error_set;
+	String error;
+	int error_line;
+	int error_column;
+	bool check_types;
+	bool dependencies_only;
+	List<String> dependencies;
+#ifdef DEBUG_ENABLED
+	Set<int> *safe_lines;
+#endif // DEBUG_ENABLED
+
+#ifdef DEBUG_ENABLED
+	List<GDScriptWarning> warnings;
+#endif // DEBUG_ENABLED
+
+	int pending_newline;
+
+	struct IndentLevel {
+		int indent;
+		int tabs;
+
+		bool is_mixed(IndentLevel other) {
+			return (
+					(indent == other.indent && tabs != other.tabs) ||
+					(indent > other.indent && tabs < other.tabs) ||
+					(indent < other.indent && tabs > other.tabs));
+		}
+
+		IndentLevel() :
+				indent(0),
+				tabs(0) {}
+
+		IndentLevel(int p_indent, int p_tabs) :
+				indent(p_indent),
+				tabs(p_tabs) {}
+	};
+
+	List<IndentLevel> indent_level;
+
+	String base_path;
+	String self_path;
+
+	ClassNode *current_class;
+	FunctionNode *current_function;
+	BlockNode *current_block;
+
+	bool _get_completable_identifier(CompletionType p_type, StringName &identifier);
+	void _make_completable_call(int p_arg);
+
+	CompletionType completion_type;
+	StringName completion_cursor;
+	Variant::Type completion_built_in_constant;
+	Node *completion_node;
+	ClassNode *completion_class;
+	FunctionNode *completion_function;
+	BlockNode *completion_block;
+	int completion_line;
+	int completion_argument;
+	bool completion_found;
+	bool completion_ident_is_call;
+
+	PropertyInfo current_export;
+
+	MultiplayerAPI::RPCMode rpc_mode;
+
+	void _set_error(const String &p_error, int p_line = -1, int p_column = -1);
+#ifdef DEBUG_ENABLED
+	void _add_warning(int p_code, int p_line = -1, const String &p_symbol1 = String(), const String &p_symbol2 = String(), const String &p_symbol3 = String(), const String &p_symbol4 = String());
+	void _add_warning(int p_code, int p_line, const Vector<String> &p_symbols);
+#endif // DEBUG_ENABLED
+	bool _recover_from_completion();
+
+	bool _parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete = false, bool p_parsing_constant = false);
+	bool _enter_indent_block(BlockNode *p_block = nullptr);
+	bool _parse_newline();
+	Node *_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign = false, bool p_parsing_constant = false);
+	Node *_reduce_expression(Node *p_node, bool p_to_const = false);
+	Node *_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const = false, bool p_allow_assign = false);
+	bool _reduce_export_var_type(Variant &p_value, int p_line = 0);
+
+	PatternNode *_parse_pattern(bool p_static);
+	void _parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static);
+	void _transform_match_statment(MatchNode *p_match_statement);
+	void _generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings);
+
+	void _parse_block(BlockNode *p_block, bool p_static);
+	void _parse_extends(ClassNode *p_class);
+	void _parse_class(ClassNode *p_class);
+	bool _end_statement();
+	void _set_end_statement_error(String p_name);
+
+	void _determine_inheritance(ClassNode *p_class, bool p_recursive = true);
+	bool _parse_type(DataType &r_type, bool p_can_be_void = false);
+	DataType _resolve_type(const DataType &p_source, int p_line);
+	DataType _type_from_variant(const Variant &p_value) const;
+	DataType _type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant = true) const;
+	DataType _type_from_gdtype(const GDScriptDataType &p_gdtype) const;
+	DataType _get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const;
+	Variant::Operator _get_variant_operation(const OperatorNode::Operator &p_op) const;
+	bool _get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const;
+	bool _get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type, bool *r_is_const = nullptr) const;
+	bool _is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion = false) const;
+	Node *_get_default_value_for_type(const DataType &p_type, int p_line = -1);
+
+	DataType _reduce_node_type(Node *p_node);
+	DataType _reduce_function_call_type(const OperatorNode *p_call);
+	DataType _reduce_identifier_type(const DataType *p_base_type, const StringName &p_identifier, int p_line, bool p_is_indexing);
+	void _check_class_level_types(ClassNode *p_class);
+	void _check_class_blocks_types(ClassNode *p_class);
+	void _check_function_types(FunctionNode *p_function);
+	void _check_block_types(BlockNode *p_block);
+	_FORCE_INLINE_ void _mark_line_as_safe(int p_line) const {
+#ifdef DEBUG_ENABLED
+		if (safe_lines) {
+			safe_lines->insert(p_line);
+		}
+#endif // DEBUG_ENABLED
+	}
+	_FORCE_INLINE_ void _mark_line_as_unsafe(int p_line) const {
+#ifdef DEBUG_ENABLED
+		if (safe_lines) {
+			safe_lines->erase(p_line);
+		}
+#endif // DEBUG_ENABLED
+	}
+
+	Error _parse(const String &p_base_path);
+
+public:
+	bool has_error() const;
+	String get_error() const;
+	int get_error_line() const;
+	int get_error_column() const;
+#ifdef DEBUG_ENABLED
+	const List<GDScriptWarning> &get_warnings() const {
+		return warnings;
+	}
+#endif // DEBUG_ENABLED
+	Error parse(const String &p_code, const String &p_base_path = "", bool p_just_validate = false, const String &p_self_path = "", bool p_for_completion = false, Set<int> *r_safe_lines = nullptr, bool p_dependencies_only = false);
+	Error parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path = "", const String &p_self_path = "");
+
+	bool is_tool_script() const;
+	const Node *get_parse_tree() const;
+
+	//completion info
+
+	CompletionType get_completion_type();
+	StringName get_completion_cursor();
+	int get_completion_line();
+	Variant::Type get_completion_built_in_constant();
+	Node *get_completion_node();
+	ClassNode *get_completion_class();
+	BlockNode *get_completion_block();
+	FunctionNode *get_completion_function();
+	int get_completion_argument_index();
+	int get_completion_identifier_is_function();
+
+	const List<String> &get_dependencies() const {
+		return dependencies;
+	}
+
+	void clear();
+	GDScriptParser();
+	~GDScriptParser();
+};
+
+#endif // GDSCRIPT_PARSER_H
diff --git a/modules/cscript/cscript_tokenizer.cpp b/modules/cscript/cscript_tokenizer.cpp
new file mode 100644
index 000000000..fd2b4e10b
--- /dev/null
+++ b/modules/cscript/cscript_tokenizer.cpp
@@ -0,0 +1,1498 @@
+/*************************************************************************/
+/*  gdscript_tokenizer.cpp                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "cscript_tokenizer.h"
+
+#include "core/io/marshalls.h"
+#include "core/map.h"
+#include "core/print_string.h"
+#include "cscript_functions.h"
+
+const char *GDScriptTokenizer::token_names[TK_MAX] = {
+	"Empty",
+	"Identifier",
+	"Constant",
+	"Self",
+	"Built-In Type",
+	"Built-In Func",
+	"In",
+	"'=='",
+	"'!='",
+	"'<'",
+	"'<='",
+	"'>'",
+	"'>='",
+	"'and'",
+	"'or'",
+	"'not'",
+	"'+'",
+	"'-'",
+	"'*'",
+	"'/'",
+	"'%'",
+	"'<<'",
+	"'>>'",
+	"'='",
+	"'+='",
+	"'-='",
+	"'*='",
+	"'/='",
+	"'%='",
+	"'<<='",
+	"'>>='",
+	"'&='",
+	"'|='",
+	"'^='",
+	"'&'",
+	"'|'",
+	"'^'",
+	"'~'",
+	//"Plus Plus",
+	//"Minus Minus",
+	"if",
+	"elif",
+	"else",
+	"for",
+	"while",
+	"break",
+	"continue",
+	"pass",
+	"return",
+	"match",
+	"func",
+	"class",
+	"class_name",
+	"extends",
+	"is",
+	"onready",
+	"tool",
+	"static",
+	"export",
+	"setget",
+	"const",
+	"var",
+	"as",
+	"void",
+	"enum",
+	"preload",
+	"assert",
+	"yield",
+	"signal",
+	"breakpoint",
+	"rpc",
+	"sync",
+	"master",
+	"puppet",
+	"slave",
+	"remotesync",
+	"mastersync",
+	"puppetsync",
+	"'['",
+	"']'",
+	"'{'",
+	"'}'",
+	"'('",
+	"')'",
+	"','",
+	"';'",
+	"'.'",
+	"'?'",
+	"':'",
+	"'$'",
+	"'->'",
+	"'\\n'",
+	"PI",
+	"TAU",
+	"_",
+	"INF",
+	"NAN",
+	"Error",
+	"EOF",
+	"Cursor"
+};
+
+struct _bit {
+	Variant::Type type;
+	const char *text;
+};
+//built in types
+
+static const _bit _type_list[] = {
+	//types
+	{ Variant::BOOL, "bool" },
+	{ Variant::INT, "int" },
+	{ Variant::REAL, "float" },
+	{ Variant::STRING, "String" },
+	{ Variant::VECTOR2, "Vector2" },
+	{ Variant::VECTOR2I, "Vector2i" },
+	{ Variant::RECT2, "Rect2" },
+	{ Variant::RECT2I, "Rect2i" },
+	{ Variant::TRANSFORM2D, "Transform2D" },
+	{ Variant::VECTOR3, "Vector3" },
+	{ Variant::VECTOR3I, "Vector3i" },
+	{ Variant::AABB, "AABB" },
+	{ Variant::PLANE, "Plane" },
+	{ Variant::QUAT, "Quat" },
+	{ Variant::BASIS, "Basis" },
+	{ Variant::TRANSFORM, "Transform" },
+	{ Variant::COLOR, "Color" },
+	{ Variant::_RID, "RID" },
+	{ Variant::OBJECT, "Object" },
+	{ Variant::STRING_NAME, "StringName" },
+	{ Variant::NODE_PATH, "NodePath" },
+	{ Variant::DICTIONARY, "Dictionary" },
+	{ Variant::ARRAY, "Array" },
+	{ Variant::POOL_BYTE_ARRAY, "PoolByteArray" },
+	{ Variant::POOL_INT_ARRAY, "PoolIntArray" },
+	{ Variant::POOL_REAL_ARRAY, "PoolRealArray" },
+	{ Variant::POOL_STRING_ARRAY, "PoolStringArray" },
+	{ Variant::POOL_VECTOR2_ARRAY, "PoolVector2Array" },
+	{ Variant::POOL_VECTOR2I_ARRAY, "PoolVector2iArray" },
+	{ Variant::POOL_VECTOR3_ARRAY, "PoolVector3Array" },
+	{ Variant::POOL_VECTOR3I_ARRAY, "PoolVector3iArray" },
+	{ Variant::POOL_COLOR_ARRAY, "PoolColorArray" },
+	{ Variant::VARIANT_MAX, nullptr },
+};
+
+struct _kws {
+	GDScriptTokenizer::Token token;
+	const char *text;
+};
+
+static const _kws _keyword_list[] = {
+	//ops
+	{ GDScriptTokenizer::TK_OP_IN, "in" },
+	{ GDScriptTokenizer::TK_OP_NOT, "not" },
+	{ GDScriptTokenizer::TK_OP_OR, "or" },
+	{ GDScriptTokenizer::TK_OP_AND, "and" },
+	//func
+	{ GDScriptTokenizer::TK_PR_FUNCTION, "func" },
+	{ GDScriptTokenizer::TK_PR_CLASS, "class" },
+	{ GDScriptTokenizer::TK_PR_CLASS_NAME, "class_name" },
+	{ GDScriptTokenizer::TK_PR_EXTENDS, "extends" },
+	{ GDScriptTokenizer::TK_PR_IS, "is" },
+	{ GDScriptTokenizer::TK_PR_ONREADY, "onready" },
+	{ GDScriptTokenizer::TK_PR_TOOL, "tool" },
+	{ GDScriptTokenizer::TK_PR_STATIC, "static" },
+	{ GDScriptTokenizer::TK_PR_EXPORT, "export" },
+	{ GDScriptTokenizer::TK_PR_SETGET, "setget" },
+	{ GDScriptTokenizer::TK_PR_VAR, "var" },
+	{ GDScriptTokenizer::TK_PR_AS, "as" },
+	{ GDScriptTokenizer::TK_PR_VOID, "void" },
+	{ GDScriptTokenizer::TK_PR_PRELOAD, "preload" },
+	{ GDScriptTokenizer::TK_PR_ASSERT, "assert" },
+	{ GDScriptTokenizer::TK_PR_YIELD, "yield" },
+	{ GDScriptTokenizer::TK_PR_SIGNAL, "signal" },
+	{ GDScriptTokenizer::TK_PR_BREAKPOINT, "breakpoint" },
+	{ GDScriptTokenizer::TK_PR_REMOTE, "remote" },
+	{ GDScriptTokenizer::TK_PR_MASTER, "master" },
+	{ GDScriptTokenizer::TK_PR_SLAVE, "slave" },
+	{ GDScriptTokenizer::TK_PR_PUPPET, "puppet" },
+	{ GDScriptTokenizer::TK_PR_SYNC, "sync" },
+	{ GDScriptTokenizer::TK_PR_REMOTESYNC, "remotesync" },
+	{ GDScriptTokenizer::TK_PR_MASTERSYNC, "mastersync" },
+	{ GDScriptTokenizer::TK_PR_PUPPETSYNC, "puppetsync" },
+	{ GDScriptTokenizer::TK_PR_CONST, "const" },
+	{ GDScriptTokenizer::TK_PR_ENUM, "enum" },
+	//controlflow
+	{ GDScriptTokenizer::TK_CF_IF, "if" },
+	{ GDScriptTokenizer::TK_CF_ELIF, "elif" },
+	{ GDScriptTokenizer::TK_CF_ELSE, "else" },
+	{ GDScriptTokenizer::TK_CF_FOR, "for" },
+	{ GDScriptTokenizer::TK_CF_WHILE, "while" },
+	{ GDScriptTokenizer::TK_CF_BREAK, "break" },
+	{ GDScriptTokenizer::TK_CF_CONTINUE, "continue" },
+	{ GDScriptTokenizer::TK_CF_RETURN, "return" },
+	{ GDScriptTokenizer::TK_CF_MATCH, "match" },
+	{ GDScriptTokenizer::TK_CF_PASS, "pass" },
+	{ GDScriptTokenizer::TK_SELF, "self" },
+	{ GDScriptTokenizer::TK_CONST_PI, "PI" },
+	{ GDScriptTokenizer::TK_CONST_TAU, "TAU" },
+	{ GDScriptTokenizer::TK_WILDCARD, "_" },
+	{ GDScriptTokenizer::TK_CONST_INF, "INF" },
+	{ GDScriptTokenizer::TK_CONST_NAN, "NAN" },
+	{ GDScriptTokenizer::TK_ERROR, nullptr }
+};
+
+const char *GDScriptTokenizer::get_token_name(Token p_token) {
+	ERR_FAIL_INDEX_V(p_token, TK_MAX, "<error>");
+	return token_names[p_token];
+}
+
+bool GDScriptTokenizer::is_token_literal(int p_offset, bool variable_safe) const {
+	switch (get_token(p_offset)) {
+		// Can always be literal:
+		case TK_IDENTIFIER:
+
+		case TK_PR_ONREADY:
+		case TK_PR_TOOL:
+		case TK_PR_STATIC:
+		case TK_PR_EXPORT:
+		case TK_PR_SETGET:
+		case TK_PR_SIGNAL:
+		case TK_PR_REMOTE:
+		case TK_PR_MASTER:
+		case TK_PR_PUPPET:
+		case TK_PR_SYNC:
+		case TK_PR_REMOTESYNC:
+		case TK_PR_MASTERSYNC:
+		case TK_PR_PUPPETSYNC:
+			return true;
+
+		// Literal for non-variables only:
+		case TK_BUILT_IN_TYPE:
+		case TK_BUILT_IN_FUNC:
+
+		case TK_OP_IN:
+			//case TK_OP_NOT:
+			//case TK_OP_OR:
+			//case TK_OP_AND:
+
+		case TK_PR_CLASS:
+		case TK_PR_CONST:
+		case TK_PR_ENUM:
+		case TK_PR_PRELOAD:
+		case TK_PR_FUNCTION:
+		case TK_PR_EXTENDS:
+		case TK_PR_ASSERT:
+		case TK_PR_YIELD:
+		case TK_PR_VAR:
+
+		case TK_CF_IF:
+		case TK_CF_ELIF:
+		case TK_CF_ELSE:
+		case TK_CF_FOR:
+		case TK_CF_WHILE:
+		case TK_CF_BREAK:
+		case TK_CF_CONTINUE:
+		case TK_CF_RETURN:
+		case TK_CF_MATCH:
+		case TK_CF_PASS:
+		case TK_SELF:
+		case TK_CONST_PI:
+		case TK_CONST_TAU:
+		case TK_WILDCARD:
+		case TK_CONST_INF:
+		case TK_CONST_NAN:
+		case TK_ERROR:
+			return !variable_safe;
+
+		case TK_CONSTANT: {
+			switch (get_token_constant(p_offset).get_type()) {
+				case Variant::NIL:
+				case Variant::BOOL:
+					return true;
+				default:
+					return false;
+			}
+		}
+		default:
+			return false;
+	}
+}
+
+StringName GDScriptTokenizer::get_token_literal(int p_offset) const {
+	Token token = get_token(p_offset);
+	switch (token) {
+		case TK_IDENTIFIER:
+			return get_token_identifier(p_offset);
+		case TK_BUILT_IN_TYPE: {
+			Variant::Type type = get_token_type(p_offset);
+			int idx = 0;
+
+			while (_type_list[idx].text) {
+				if (type == _type_list[idx].type) {
+					return _type_list[idx].text;
+				}
+				idx++;
+			}
+		} break; // Shouldn't get here, stuff happens
+		case TK_BUILT_IN_FUNC:
+			return GDScriptFunctions::get_func_name(get_token_built_in_func(p_offset));
+		case TK_CONSTANT: {
+			const Variant value = get_token_constant(p_offset);
+
+			switch (value.get_type()) {
+				case Variant::NIL:
+					return "null";
+				case Variant::BOOL:
+					return value ? "true" : "false";
+				default: {
+				}
+			}
+		}
+		case TK_OP_AND:
+		case TK_OP_OR:
+			break; // Don't get into default, since they can be non-literal
+		default: {
+			int idx = 0;
+
+			while (_keyword_list[idx].text) {
+				if (token == _keyword_list[idx].token) {
+					return _keyword_list[idx].text;
+				}
+				idx++;
+			}
+		}
+	}
+	ERR_FAIL_V_MSG("", "Failed to get token literal.");
+}
+
+static bool _is_text_char(CharType c) {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+static bool _is_number(CharType c) {
+	return (c >= '0' && c <= '9');
+}
+
+static bool _is_hex(CharType c) {
+	return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+}
+
+static bool _is_bin(CharType c) {
+	return (c == '0' || c == '1');
+}
+
+void GDScriptTokenizerText::_make_token(Token p_type) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+
+	tk.type = p_type;
+	tk.line = line;
+	tk.col = column;
+
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+void GDScriptTokenizerText::_make_identifier(const StringName &p_identifier) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+
+	tk.type = TK_IDENTIFIER;
+	tk.identifier = p_identifier;
+	tk.line = line;
+	tk.col = column;
+
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+
+void GDScriptTokenizerText::_make_built_in_func(GDScriptFunctions::Function p_func) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+
+	tk.type = TK_BUILT_IN_FUNC;
+	tk.func = p_func;
+	tk.line = line;
+	tk.col = column;
+
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+void GDScriptTokenizerText::_make_constant(const Variant &p_constant) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+
+	tk.type = TK_CONSTANT;
+	tk.constant = p_constant;
+	tk.line = line;
+	tk.col = column;
+
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+
+void GDScriptTokenizerText::_make_type(const Variant::Type &p_type) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+
+	tk.type = TK_BUILT_IN_TYPE;
+	tk.vtype = p_type;
+	tk.line = line;
+	tk.col = column;
+
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+
+void GDScriptTokenizerText::_make_error(const String &p_error) {
+	error_flag = true;
+	last_error = p_error;
+
+	TokenData &tk = tk_rb[tk_rb_pos];
+	tk.type = TK_ERROR;
+	tk.constant = p_error;
+	tk.line = line;
+	tk.col = column;
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+
+void GDScriptTokenizerText::_make_newline(int p_indentation, int p_tabs) {
+	TokenData &tk = tk_rb[tk_rb_pos];
+	tk.type = TK_NEWLINE;
+	tk.constant = Vector2(p_indentation, p_tabs);
+	tk.line = line;
+	tk.col = column;
+	tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
+}
+
+void GDScriptTokenizerText::_advance() {
+	if (error_flag) {
+		//parser broke
+		_make_error(last_error);
+		return;
+	}
+
+	if (code_pos >= len) {
+		_make_token(TK_EOF);
+		return;
+	}
+#define GETCHAR(m_ofs) ((m_ofs + code_pos) >= len ? 0 : _code[m_ofs + code_pos])
+#define INCPOS(m_amount)      \
+	{                         \
+		code_pos += m_amount; \
+		column += m_amount;   \
+	}
+	while (true) {
+		bool is_string_name = false;
+		StringMode string_mode = STRING_DOUBLE_QUOTE;
+
+		switch (GETCHAR(0)) {
+			case 0:
+				_make_token(TK_EOF);
+				break;
+			case '\\':
+				INCPOS(1);
+				if (GETCHAR(0) == '\r') {
+					INCPOS(1);
+				}
+
+				if (GETCHAR(0) != '\n') {
+					_make_error("Expected newline after '\\'.");
+					return;
+				}
+
+				INCPOS(1);
+				line++;
+
+				while (GETCHAR(0) == ' ' || GETCHAR(0) == '\t') {
+					INCPOS(1);
+				}
+
+				continue;
+			case '\t':
+			case '\r':
+			case ' ':
+				INCPOS(1);
+				continue;
+			case '#': { // line comment skip
+#ifdef DEBUG_ENABLED
+				String comment;
+#endif // DEBUG_ENABLED
+				while (GETCHAR(0) != '\n') {
+#ifdef DEBUG_ENABLED
+					comment += GETCHAR(0);
+#endif // DEBUG_ENABLED
+					code_pos++;
+					if (GETCHAR(0) == 0) { //end of file
+						//_make_error("Unterminated Comment");
+						_make_token(TK_EOF);
+						return;
+					}
+				}
+#ifdef DEBUG_ENABLED
+				String comment_content = comment.trim_prefix("#").trim_prefix(" ");
+				if (comment_content.begins_with("warning-ignore:")) {
+					String code = comment_content.get_slice(":", 1);
+					warning_skips.push_back(Pair<int, String>(line, code.strip_edges().to_lower()));
+				} else if (comment_content.begins_with("warning-ignore-all:")) {
+					String code = comment_content.get_slice(":", 1);
+					warning_global_skips.insert(code.strip_edges().to_lower());
+				} else if (comment_content.strip_edges() == "warnings-disable") {
+					ignore_warnings = true;
+				}
+#endif // DEBUG_ENABLED
+				FALLTHROUGH;
+			}
+			case '\n': {
+				line++;
+				INCPOS(1);
+				bool used_spaces = false;
+				int tabs = 0;
+				column = 1;
+				int i = 0;
+				while (true) {
+					if (GETCHAR(i) == ' ') {
+						i++;
+						used_spaces = true;
+					} else if (GETCHAR(i) == '\t') {
+						if (used_spaces) {
+							_make_error("Spaces used before tabs on a line");
+							return;
+						}
+						i++;
+						tabs++;
+					} else {
+						break; // not indentation anymore
+					}
+				}
+
+				_make_newline(i, tabs);
+				return;
+			}
+			case '/': {
+				switch (GETCHAR(1)) {
+					case '=': { // diveq
+
+						_make_token(TK_OP_ASSIGN_DIV);
+						INCPOS(1);
+
+					} break;
+					default:
+						_make_token(TK_OP_DIV);
+				}
+			} break;
+			case '=': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_EQUAL);
+					INCPOS(1);
+
+				} else {
+					_make_token(TK_OP_ASSIGN);
+				}
+
+			} break;
+			case '<': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_LESS_EQUAL);
+					INCPOS(1);
+				} else if (GETCHAR(1) == '<') {
+					if (GETCHAR(2) == '=') {
+						_make_token(TK_OP_ASSIGN_SHIFT_LEFT);
+						INCPOS(1);
+					} else {
+						_make_token(TK_OP_SHIFT_LEFT);
+					}
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_LESS);
+				}
+
+			} break;
+			case '>': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_GREATER_EQUAL);
+					INCPOS(1);
+				} else if (GETCHAR(1) == '>') {
+					if (GETCHAR(2) == '=') {
+						_make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
+						INCPOS(1);
+
+					} else {
+						_make_token(TK_OP_SHIFT_RIGHT);
+					}
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_GREATER);
+				}
+
+			} break;
+			case '!': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_NOT_EQUAL);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_NOT);
+				}
+
+			} break;
+			//case '"' //string - no strings in shader
+			//case '\'' //string - no strings in shader
+			case '{':
+				_make_token(TK_CURLY_BRACKET_OPEN);
+				break;
+			case '}':
+				_make_token(TK_CURLY_BRACKET_CLOSE);
+				break;
+			case '[':
+				_make_token(TK_BRACKET_OPEN);
+				break;
+			case ']':
+				_make_token(TK_BRACKET_CLOSE);
+				break;
+			case '(':
+				_make_token(TK_PARENTHESIS_OPEN);
+				break;
+			case ')':
+				_make_token(TK_PARENTHESIS_CLOSE);
+				break;
+			case ',':
+				_make_token(TK_COMMA);
+				break;
+			case ';':
+				_make_token(TK_SEMICOLON);
+				break;
+			case '?':
+				_make_token(TK_QUESTION_MARK);
+				break;
+			case ':':
+				_make_token(TK_COLON); //for methods maybe but now useless.
+				break;
+			case '$':
+				_make_token(TK_DOLLAR); //for the get_node() shortener
+				break;
+			case '^': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_BIT_XOR);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_BIT_XOR);
+				}
+
+			} break;
+			case '~':
+				_make_token(TK_OP_BIT_INVERT);
+				break;
+			case '&': {
+				if (GETCHAR(1) == '&') {
+					_make_token(TK_OP_AND);
+					INCPOS(1);
+				} else if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_BIT_AND);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_BIT_AND);
+				}
+			} break;
+			case '|': {
+				if (GETCHAR(1) == '|') {
+					_make_token(TK_OP_OR);
+					INCPOS(1);
+				} else if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_BIT_OR);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_BIT_OR);
+				}
+			} break;
+			case '*': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_MUL);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_MUL);
+				}
+			} break;
+			case '+': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_ADD);
+					INCPOS(1);
+					/*
+				}  else if (GETCHAR(1)=='+') {
+					_make_token(TK_OP_PLUS_PLUS);
+					INCPOS(1);
+				*/
+				} else {
+					_make_token(TK_OP_ADD);
+				}
+
+			} break;
+			case '-': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_SUB);
+					INCPOS(1);
+				} else if (GETCHAR(1) == '>') {
+					_make_token(TK_FORWARD_ARROW);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_SUB);
+				}
+			} break;
+			case '%': {
+				if (GETCHAR(1) == '=') {
+					_make_token(TK_OP_ASSIGN_MOD);
+					INCPOS(1);
+				} else {
+					_make_token(TK_OP_MOD);
+				}
+			} break;
+			case '@':
+				if (CharType(GETCHAR(1)) != '"' && CharType(GETCHAR(1)) != '\'') {
+					_make_error("Unexpected '@'");
+					return;
+				}
+				INCPOS(1);
+				is_string_name = true;
+				FALLTHROUGH;
+			case '\'':
+			case '"': {
+				if (GETCHAR(0) == '\'') {
+					string_mode = STRING_SINGLE_QUOTE;
+				}
+
+				int i = 1;
+				if (string_mode == STRING_DOUBLE_QUOTE && GETCHAR(i) == '"' && GETCHAR(i + 1) == '"') {
+					i += 2;
+					string_mode = STRING_MULTILINE;
+				}
+
+				String str;
+				while (true) {
+					if (CharType(GETCHAR(i)) == 0) {
+						_make_error("Unterminated String");
+						return;
+					} else if (string_mode == STRING_DOUBLE_QUOTE && CharType(GETCHAR(i)) == '"') {
+						break;
+					} else if (string_mode == STRING_SINGLE_QUOTE && CharType(GETCHAR(i)) == '\'') {
+						break;
+					} else if (string_mode == STRING_MULTILINE && CharType(GETCHAR(i)) == '\"' && CharType(GETCHAR(i + 1)) == '\"' && CharType(GETCHAR(i + 2)) == '\"') {
+						i += 2;
+						break;
+					} else if (string_mode != STRING_MULTILINE && CharType(GETCHAR(i)) == '\n') {
+						_make_error("Unexpected EOL at String.");
+						return;
+					} else if (CharType(GETCHAR(i)) == 0xFFFF) {
+						//string ends here, next will be TK
+						i--;
+						break;
+					} else if (CharType(GETCHAR(i)) == '\\') {
+						//escaped characters...
+						i++;
+						CharType next = GETCHAR(i);
+						if (next == 0) {
+							_make_error("Unterminated String");
+							return;
+						}
+						CharType res = 0;
+
+						switch (next) {
+							case 'a':
+								res = 7;
+								break;
+							case 'b':
+								res = 8;
+								break;
+							case 't':
+								res = 9;
+								break;
+							case 'n':
+								res = 10;
+								break;
+							case 'v':
+								res = 11;
+								break;
+							case 'f':
+								res = 12;
+								break;
+							case 'r':
+								res = 13;
+								break;
+							case '\'':
+								res = '\'';
+								break;
+							case '\"':
+								res = '\"';
+								break;
+							case '\\':
+								res = '\\';
+								break;
+							case '/':
+								res = '/';
+								break; //wtf
+
+							case 'u': {
+								//hexnumbarh - oct is deprecated
+								i += 1;
+								for (int j = 0; j < 4; j++) {
+									CharType c = GETCHAR(i + j);
+									if (c == 0) {
+										_make_error("Unterminated String");
+										return;
+									}
+
+									CharType v = 0;
+									if (c >= '0' && c <= '9') {
+										v = c - '0';
+									} else if (c >= 'a' && c <= 'f') {
+										v = c - 'a';
+										v += 10;
+									} else if (c >= 'A' && c <= 'F') {
+										v = c - 'A';
+										v += 10;
+									} else {
+										_make_error("Malformed hex constant in string");
+										return;
+									}
+
+									res <<= 4;
+									res |= v;
+								}
+								i += 3;
+
+							} break;
+							default: {
+								_make_error("Invalid escape sequence");
+								return;
+							} break;
+						}
+
+						str += res;
+
+					} else {
+						if (CharType(GETCHAR(i)) == '\n') {
+							line++;
+							column = 1;
+						}
+
+						str += CharType(GETCHAR(i));
+					}
+					i++;
+				}
+				INCPOS(i);
+
+				if (is_string_name) {
+					_make_constant(StringName(str));
+				} else {
+					_make_constant(str);
+				}
+
+			} break;
+			case 0xFFFF: {
+				_make_token(TK_CURSOR);
+			} break;
+			default: {
+				if (_is_number(GETCHAR(0)) || (GETCHAR(0) == '.' && _is_number(GETCHAR(1)))) {
+					// parse number
+					bool period_found = false;
+					bool exponent_found = false;
+					bool hexa_found = false;
+					bool bin_found = false;
+					bool sign_found = false;
+
+					String str;
+					int i = 0;
+
+					while (true) {
+						if (GETCHAR(i) == '.') {
+							if (period_found || exponent_found) {
+								_make_error("Invalid numeric constant at '.'");
+								return;
+							} else if (bin_found) {
+								_make_error("Invalid binary constant at '.'");
+								return;
+							} else if (hexa_found) {
+								_make_error("Invalid hexadecimal constant at '.'");
+								return;
+							}
+							period_found = true;
+						} else if (GETCHAR(i) == 'x') {
+							if (hexa_found || bin_found || str.length() != 1 || !((i == 1 && str[0] == '0') || (i == 2 && str[1] == '0' && str[0] == '-'))) {
+								_make_error("Invalid numeric constant at 'x'");
+								return;
+							}
+							hexa_found = true;
+						} else if (hexa_found && _is_hex(GETCHAR(i))) {
+						} else if (!hexa_found && GETCHAR(i) == 'b') {
+							if (bin_found || str.length() != 1 || !((i == 1 && str[0] == '0') || (i == 2 && str[1] == '0' && str[0] == '-'))) {
+								_make_error("Invalid numeric constant at 'b'");
+								return;
+							}
+							bin_found = true;
+						} else if (!hexa_found && GETCHAR(i) == 'e') {
+							if (exponent_found || bin_found) {
+								_make_error("Invalid numeric constant at 'e'");
+								return;
+							}
+							exponent_found = true;
+						} else if (_is_number(GETCHAR(i))) {
+							//all ok
+
+						} else if (bin_found && _is_bin(GETCHAR(i))) {
+						} else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
+							if (sign_found) {
+								_make_error("Invalid numeric constant at '-'");
+								return;
+							}
+							sign_found = true;
+						} else if (GETCHAR(i) == '_') {
+							i++;
+							continue; // Included for readability, shouldn't be a part of the string
+						} else {
+							break;
+						}
+
+						str += CharType(GETCHAR(i));
+						i++;
+					}
+
+					if (!(_is_number(str[str.length() - 1]) || (hexa_found && _is_hex(str[str.length() - 1])))) {
+						_make_error("Invalid numeric constant: " + str);
+						return;
+					}
+
+					INCPOS(i);
+					if (hexa_found) {
+						int64_t val = str.hex_to_int64();
+						_make_constant(val);
+					} else if (bin_found) {
+						int64_t val = str.bin_to_int64();
+						_make_constant(val);
+					} else if (period_found || exponent_found) {
+						double val = str.to_double();
+						_make_constant(val);
+					} else {
+						int64_t val = str.to_int64();
+						_make_constant(val);
+					}
+
+					return;
+				}
+
+				if (GETCHAR(0) == '.') {
+					//parse period
+					_make_token(TK_PERIOD);
+					break;
+				}
+
+				if (_is_text_char(GETCHAR(0))) {
+					// parse identifier
+					String str;
+					str += CharType(GETCHAR(0));
+
+					int i = 1;
+					while (_is_text_char(GETCHAR(i))) {
+						str += CharType(GETCHAR(i));
+						i++;
+					}
+
+					bool identifier = false;
+
+					if (str == "null") {
+						_make_constant(Variant());
+
+					} else if (str == "true") {
+						_make_constant(true);
+
+					} else if (str == "false") {
+						_make_constant(false);
+					} else {
+						bool found = false;
+
+						{
+							int idx = 0;
+
+							while (_type_list[idx].text) {
+								if (str == _type_list[idx].text) {
+									_make_type(_type_list[idx].type);
+									found = true;
+									break;
+								}
+								idx++;
+							}
+						}
+
+						if (!found) {
+							//built in func?
+
+							for (int j = 0; j < GDScriptFunctions::FUNC_MAX; j++) {
+								if (str == GDScriptFunctions::get_func_name(GDScriptFunctions::Function(j))) {
+									_make_built_in_func(GDScriptFunctions::Function(j));
+									found = true;
+									break;
+								}
+							}
+						}
+
+						if (!found) {
+							//keyword
+
+							int idx = 0;
+							found = false;
+
+							while (_keyword_list[idx].text) {
+								if (str == _keyword_list[idx].text) {
+									_make_token(_keyword_list[idx].token);
+									found = true;
+									break;
+								}
+								idx++;
+							}
+						}
+
+						if (!found) {
+							identifier = true;
+						}
+					}
+
+					if (identifier) {
+						_make_identifier(str);
+					}
+					INCPOS(str.length());
+					return;
+				}
+
+				_make_error("Unknown character");
+				return;
+
+			} break;
+		}
+
+		INCPOS(1);
+		break;
+	}
+}
+
+void GDScriptTokenizerText::set_code(const String &p_code) {
+	code = p_code;
+	len = p_code.length();
+	if (len) {
+		_code = &code[0];
+	} else {
+		_code = nullptr;
+	}
+	code_pos = 0;
+	line = 1; //it is stand-ar-ized that lines begin in 1 in code..
+	column = 1; //the same holds for columns
+	tk_rb_pos = 0;
+	error_flag = false;
+#ifdef DEBUG_ENABLED
+	ignore_warnings = false;
+#endif // DEBUG_ENABLED
+	last_error = "";
+	for (int i = 0; i < MAX_LOOKAHEAD + 1; i++) {
+		_advance();
+	}
+}
+
+GDScriptTokenizerText::Token GDScriptTokenizerText::get_token(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, TK_ERROR);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, TK_ERROR);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	return tk_rb[ofs].type;
+}
+
+int GDScriptTokenizerText::get_token_line(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	return tk_rb[ofs].line;
+}
+
+int GDScriptTokenizerText::get_token_column(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	return tk_rb[ofs].col;
+}
+
+const Variant &GDScriptTokenizerText::get_token_constant(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_CONSTANT, tk_rb[0].constant);
+	return tk_rb[ofs].constant;
+}
+
+StringName GDScriptTokenizerText::get_token_identifier(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, StringName());
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, StringName());
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_IDENTIFIER, StringName());
+	return tk_rb[ofs].identifier;
+}
+
+GDScriptFunctions::Function GDScriptTokenizerText::get_token_built_in_func(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, GDScriptFunctions::FUNC_MAX);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, GDScriptFunctions::FUNC_MAX);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_FUNC, GDScriptFunctions::FUNC_MAX);
+	return tk_rb[ofs].func;
+}
+
+Variant::Type GDScriptTokenizerText::get_token_type(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, Variant::NIL);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, Variant::NIL);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_TYPE, Variant::NIL);
+	return tk_rb[ofs].vtype;
+}
+
+int GDScriptTokenizerText::get_token_line_indent(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_NEWLINE, 0);
+	return tk_rb[ofs].constant.operator Vector2().x;
+}
+
+int GDScriptTokenizerText::get_token_line_tab_indent(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0);
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0);
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_NEWLINE, 0);
+	return tk_rb[ofs].constant.operator Vector2().y;
+}
+
+String GDScriptTokenizerText::get_token_error(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, String());
+	ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, String());
+
+	int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
+	ERR_FAIL_COND_V(tk_rb[ofs].type != TK_ERROR, String());
+	return tk_rb[ofs].constant;
+}
+
+void GDScriptTokenizerText::advance(int p_amount) {
+	ERR_FAIL_COND(p_amount <= 0);
+	for (int i = 0; i < p_amount; i++) {
+		_advance();
+	}
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define BYTECODE_VERSION 13
+
+Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer) {
+	const uint8_t *buf = p_buffer.ptr();
+	int total_len = p_buffer.size();
+	ERR_FAIL_COND_V(p_buffer.size() < 24 || p_buffer[0] != 'G' || p_buffer[1] != 'D' || p_buffer[2] != 'S' || p_buffer[3] != 'C', ERR_INVALID_DATA);
+
+	int version = decode_uint32(&buf[4]);
+	ERR_FAIL_COND_V_MSG(version > BYTECODE_VERSION, ERR_INVALID_DATA, "Bytecode is too recent! Please use a newer engine version.");
+
+	int identifier_count = decode_uint32(&buf[8]);
+	int constant_count = decode_uint32(&buf[12]);
+	int line_count = decode_uint32(&buf[16]);
+	int token_count = decode_uint32(&buf[20]);
+
+	const uint8_t *b = &buf[24];
+	total_len -= 24;
+
+	identifiers.resize(identifier_count);
+	for (int i = 0; i < identifier_count; i++) {
+		int len = decode_uint32(b);
+		ERR_FAIL_COND_V(len > total_len, ERR_INVALID_DATA);
+		b += 4;
+		Vector<uint8_t> cs;
+		cs.resize(len);
+		for (int j = 0; j < len; j++) {
+			cs.write[j] = b[j] ^ 0xb6;
+		}
+
+		cs.write[cs.size() - 1] = 0;
+		String s;
+		s.parse_utf8((const char *)cs.ptr());
+		b += len;
+		total_len -= len + 4;
+		identifiers.write[i] = s;
+	}
+
+	constants.resize(constant_count);
+	for (int i = 0; i < constant_count; i++) {
+		Variant v;
+		int len;
+		// An object cannot be constant, never decode objects
+		Error err = decode_variant(v, b, total_len, &len, false);
+		if (err) {
+			return err;
+		}
+		b += len;
+		total_len -= len;
+		constants.write[i] = v;
+	}
+
+	ERR_FAIL_COND_V(line_count * 8 > total_len, ERR_INVALID_DATA);
+
+	for (int i = 0; i < line_count; i++) {
+		uint32_t token = decode_uint32(b);
+		b += 4;
+		uint32_t linecol = decode_uint32(b);
+		b += 4;
+
+		lines.insert(token, linecol);
+		total_len -= 8;
+	}
+
+	tokens.resize(token_count);
+
+	for (int i = 0; i < token_count; i++) {
+		ERR_FAIL_COND_V(total_len < 1, ERR_INVALID_DATA);
+
+		if ((*b) & TOKEN_BYTE_MASK) { //little endian always
+			ERR_FAIL_COND_V(total_len < 4, ERR_INVALID_DATA);
+
+			tokens.write[i] = decode_uint32(b) & ~TOKEN_BYTE_MASK;
+			b += 4;
+		} else {
+			tokens.write[i] = *b;
+			b += 1;
+			total_len--;
+		}
+	}
+
+	token = 0;
+
+	return OK;
+}
+
+Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code) {
+	Vector<uint8_t> buf;
+
+	Map<StringName, int> identifier_map;
+	HashMap<Variant, int, VariantHasher, VariantComparator> constant_map;
+	Map<uint32_t, int> line_map;
+	Vector<uint32_t> token_array;
+
+	GDScriptTokenizerText tt;
+	tt.set_code(p_code);
+	int line = -1;
+
+	while (true) {
+		if (tt.get_token_line() != line) {
+			line = tt.get_token_line();
+			line_map[line] = token_array.size();
+		}
+
+		uint32_t token = tt.get_token();
+		switch (tt.get_token()) {
+			case TK_IDENTIFIER: {
+				StringName id = tt.get_token_identifier();
+				if (!identifier_map.has(id)) {
+					int idx = identifier_map.size();
+					identifier_map[id] = idx;
+				}
+				token |= identifier_map[id] << TOKEN_BITS;
+			} break;
+			case TK_CONSTANT: {
+				const Variant &c = tt.get_token_constant();
+				if (!constant_map.has(c)) {
+					int idx = constant_map.size();
+					constant_map[c] = idx;
+				}
+				token |= constant_map[c] << TOKEN_BITS;
+			} break;
+			case TK_BUILT_IN_TYPE: {
+				token |= tt.get_token_type() << TOKEN_BITS;
+			} break;
+			case TK_BUILT_IN_FUNC: {
+				token |= tt.get_token_built_in_func() << TOKEN_BITS;
+
+			} break;
+			case TK_NEWLINE: {
+				token |= tt.get_token_line_indent() << TOKEN_BITS;
+			} break;
+			case TK_ERROR: {
+				ERR_FAIL_V(Vector<uint8_t>());
+			} break;
+			default: {
+			}
+		};
+
+		token_array.push_back(token);
+
+		if (tt.get_token() == TK_EOF) {
+			break;
+		}
+		tt.advance();
+	}
+
+	//reverse maps
+
+	Map<int, StringName> rev_identifier_map;
+	for (Map<StringName, int>::Element *E = identifier_map.front(); E; E = E->next()) {
+		rev_identifier_map[E->get()] = E->key();
+	}
+
+	Map<int, Variant> rev_constant_map;
+	const Variant *K = nullptr;
+	while ((K = constant_map.next(K))) {
+		rev_constant_map[constant_map[*K]] = *K;
+	}
+
+	Map<int, uint32_t> rev_line_map;
+	for (Map<uint32_t, int>::Element *E = line_map.front(); E; E = E->next()) {
+		rev_line_map[E->get()] = E->key();
+	}
+
+	//save header
+	buf.resize(24);
+	buf.write[0] = 'G';
+	buf.write[1] = 'D';
+	buf.write[2] = 'S';
+	buf.write[3] = 'C';
+	encode_uint32(BYTECODE_VERSION, &buf.write[4]);
+	encode_uint32(identifier_map.size(), &buf.write[8]);
+	encode_uint32(constant_map.size(), &buf.write[12]);
+	encode_uint32(line_map.size(), &buf.write[16]);
+	encode_uint32(token_array.size(), &buf.write[20]);
+
+	//save identifiers
+
+	for (Map<int, StringName>::Element *E = rev_identifier_map.front(); E; E = E->next()) {
+		CharString cs = String(E->get()).utf8();
+		int len = cs.length() + 1;
+		int extra = 4 - (len % 4);
+		if (extra == 4) {
+			extra = 0;
+		}
+
+		uint8_t ibuf[4];
+		encode_uint32(len + extra, ibuf);
+		for (int i = 0; i < 4; i++) {
+			buf.push_back(ibuf[i]);
+		}
+		for (int i = 0; i < len; i++) {
+			buf.push_back(cs[i] ^ 0xb6);
+		}
+		for (int i = 0; i < extra; i++) {
+			buf.push_back(0 ^ 0xb6);
+		}
+	}
+
+	for (Map<int, Variant>::Element *E = rev_constant_map.front(); E; E = E->next()) {
+		int len;
+		// Objects cannot be constant, never encode objects
+		Error err = encode_variant(E->get(), nullptr, len, false);
+		ERR_FAIL_COND_V_MSG(err != OK, Vector<uint8_t>(), "Error when trying to encode Variant.");
+		int pos = buf.size();
+		buf.resize(pos + len);
+		encode_variant(E->get(), &buf.write[pos], len, false);
+	}
+
+	for (Map<int, uint32_t>::Element *E = rev_line_map.front(); E; E = E->next()) {
+		uint8_t ibuf[8];
+		encode_uint32(E->key(), &ibuf[0]);
+		encode_uint32(E->get(), &ibuf[4]);
+		for (int i = 0; i < 8; i++) {
+			buf.push_back(ibuf[i]);
+		}
+	}
+
+	for (int i = 0; i < token_array.size(); i++) {
+		uint32_t token = token_array[i];
+
+		if (token & ~TOKEN_MASK) {
+			uint8_t buf4[4];
+			encode_uint32(token_array[i] | TOKEN_BYTE_MASK, &buf4[0]);
+			for (int j = 0; j < 4; j++) {
+				buf.push_back(buf4[j]);
+			}
+		} else {
+			buf.push_back(token);
+		}
+	}
+
+	return buf;
+}
+
+GDScriptTokenizerBuffer::Token GDScriptTokenizerBuffer::get_token(int p_offset) const {
+	int offset = token + p_offset;
+
+	if (offset < 0 || offset >= tokens.size()) {
+		return TK_EOF;
+	}
+
+	return GDScriptTokenizerBuffer::Token(tokens[offset] & TOKEN_MASK);
+}
+
+StringName GDScriptTokenizerBuffer::get_token_identifier(int p_offset) const {
+	int offset = token + p_offset;
+
+	ERR_FAIL_INDEX_V(offset, tokens.size(), StringName());
+	uint32_t identifier = tokens[offset] >> TOKEN_BITS;
+	ERR_FAIL_UNSIGNED_INDEX_V(identifier, (uint32_t)identifiers.size(), StringName());
+
+	return identifiers[identifier];
+}
+
+GDScriptFunctions::Function GDScriptTokenizerBuffer::get_token_built_in_func(int p_offset) const {
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), GDScriptFunctions::FUNC_MAX);
+	return GDScriptFunctions::Function(tokens[offset] >> TOKEN_BITS);
+}
+
+Variant::Type GDScriptTokenizerBuffer::get_token_type(int p_offset) const {
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), Variant::NIL);
+
+	return Variant::Type(tokens[offset] >> TOKEN_BITS);
+}
+
+int GDScriptTokenizerBuffer::get_token_line(int p_offset) const {
+	int offset = token + p_offset;
+	int pos = lines.find_nearest(offset);
+
+	if (pos < 0) {
+		return -1;
+	}
+	if (pos >= lines.size()) {
+		pos = lines.size() - 1;
+	}
+
+	uint32_t l = lines.getv(pos);
+	return l & TOKEN_LINE_MASK;
+}
+int GDScriptTokenizerBuffer::get_token_column(int p_offset) const {
+	int offset = token + p_offset;
+	int pos = lines.find_nearest(offset);
+	if (pos < 0) {
+		return -1;
+	}
+	if (pos >= lines.size()) {
+		pos = lines.size() - 1;
+	}
+
+	uint32_t l = lines.getv(pos);
+	return l >> TOKEN_LINE_BITS;
+}
+int GDScriptTokenizerBuffer::get_token_line_indent(int p_offset) const {
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), 0);
+	return tokens[offset] >> TOKEN_BITS;
+}
+const Variant &GDScriptTokenizerBuffer::get_token_constant(int p_offset) const {
+	int offset = token + p_offset;
+	ERR_FAIL_INDEX_V(offset, tokens.size(), nil);
+	uint32_t constant = tokens[offset] >> TOKEN_BITS;
+	ERR_FAIL_UNSIGNED_INDEX_V(constant, (uint32_t)constants.size(), nil);
+	return constants[constant];
+}
+String GDScriptTokenizerBuffer::get_token_error(int p_offset) const {
+	ERR_FAIL_V(String());
+}
+
+void GDScriptTokenizerBuffer::advance(int p_amount) {
+	ERR_FAIL_INDEX(p_amount + token, tokens.size());
+	token += p_amount;
+}
+GDScriptTokenizerBuffer::GDScriptTokenizerBuffer() {
+	token = 0;
+}
diff --git a/modules/cscript/cscript_tokenizer.h b/modules/cscript/cscript_tokenizer.h
new file mode 100644
index 000000000..6859baa05
--- /dev/null
+++ b/modules/cscript/cscript_tokenizer.h
@@ -0,0 +1,306 @@
+#ifndef CSCRIPT_TOKENIZER_H
+#define CSCRIPT_TOKENIZER_H
+/*************************************************************************/
+/*  gdscript_tokenizer.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "core/pair.h"
+#include "core/string_name.h"
+#include "core/ustring.h"
+#include "core/variant.h"
+#include "core/vmap.h"
+#include "cscript_functions.h"
+
+class GDScriptTokenizer {
+public:
+	enum Token {
+
+		TK_EMPTY,
+		TK_IDENTIFIER,
+		TK_CONSTANT,
+		TK_SELF,
+		TK_BUILT_IN_TYPE,
+		TK_BUILT_IN_FUNC,
+		TK_OP_IN,
+		TK_OP_EQUAL,
+		TK_OP_NOT_EQUAL,
+		TK_OP_LESS,
+		TK_OP_LESS_EQUAL,
+		TK_OP_GREATER,
+		TK_OP_GREATER_EQUAL,
+		TK_OP_AND,
+		TK_OP_OR,
+		TK_OP_NOT,
+		TK_OP_ADD,
+		TK_OP_SUB,
+		TK_OP_MUL,
+		TK_OP_DIV,
+		TK_OP_MOD,
+		TK_OP_SHIFT_LEFT,
+		TK_OP_SHIFT_RIGHT,
+		TK_OP_ASSIGN,
+		TK_OP_ASSIGN_ADD,
+		TK_OP_ASSIGN_SUB,
+		TK_OP_ASSIGN_MUL,
+		TK_OP_ASSIGN_DIV,
+		TK_OP_ASSIGN_MOD,
+		TK_OP_ASSIGN_SHIFT_LEFT,
+		TK_OP_ASSIGN_SHIFT_RIGHT,
+		TK_OP_ASSIGN_BIT_AND,
+		TK_OP_ASSIGN_BIT_OR,
+		TK_OP_ASSIGN_BIT_XOR,
+		TK_OP_BIT_AND,
+		TK_OP_BIT_OR,
+		TK_OP_BIT_XOR,
+		TK_OP_BIT_INVERT,
+		//TK_OP_PLUS_PLUS,
+		//TK_OP_MINUS_MINUS,
+		TK_CF_IF,
+		TK_CF_ELIF,
+		TK_CF_ELSE,
+		TK_CF_FOR,
+		TK_CF_WHILE,
+		TK_CF_BREAK,
+		TK_CF_CONTINUE,
+		TK_CF_PASS,
+		TK_CF_RETURN,
+		TK_CF_MATCH,
+		TK_PR_FUNCTION,
+		TK_PR_CLASS,
+		TK_PR_CLASS_NAME,
+		TK_PR_EXTENDS,
+		TK_PR_IS,
+		TK_PR_ONREADY,
+		TK_PR_TOOL,
+		TK_PR_STATIC,
+		TK_PR_EXPORT,
+		TK_PR_SETGET,
+		TK_PR_CONST,
+		TK_PR_VAR,
+		TK_PR_AS,
+		TK_PR_VOID,
+		TK_PR_ENUM,
+		TK_PR_PRELOAD,
+		TK_PR_ASSERT,
+		TK_PR_YIELD,
+		TK_PR_SIGNAL,
+		TK_PR_BREAKPOINT,
+		TK_PR_REMOTE,
+		TK_PR_SYNC,
+		TK_PR_MASTER,
+		TK_PR_SLAVE, // Deprecated by TK_PR_PUPPET, to remove in 4.0
+		TK_PR_PUPPET,
+		TK_PR_REMOTESYNC,
+		TK_PR_MASTERSYNC,
+		TK_PR_PUPPETSYNC,
+		TK_BRACKET_OPEN,
+		TK_BRACKET_CLOSE,
+		TK_CURLY_BRACKET_OPEN,
+		TK_CURLY_BRACKET_CLOSE,
+		TK_PARENTHESIS_OPEN,
+		TK_PARENTHESIS_CLOSE,
+		TK_COMMA,
+		TK_SEMICOLON,
+		TK_PERIOD,
+		TK_QUESTION_MARK,
+		TK_COLON,
+		TK_DOLLAR,
+		TK_FORWARD_ARROW,
+		TK_NEWLINE,
+		TK_CONST_PI,
+		TK_CONST_TAU,
+		TK_WILDCARD,
+		TK_CONST_INF,
+		TK_CONST_NAN,
+		TK_ERROR,
+		TK_EOF,
+		TK_CURSOR, //used for code completion
+		TK_MAX
+	};
+
+protected:
+	enum StringMode {
+		STRING_SINGLE_QUOTE,
+		STRING_DOUBLE_QUOTE,
+		STRING_MULTILINE
+	};
+
+	static const char *token_names[TK_MAX];
+
+public:
+	static const char *get_token_name(Token p_token);
+
+	bool is_token_literal(int p_offset = 0, bool variable_safe = false) const;
+	StringName get_token_literal(int p_offset = 0) const;
+
+	virtual const Variant &get_token_constant(int p_offset = 0) const = 0;
+	virtual Token get_token(int p_offset = 0) const = 0;
+	virtual StringName get_token_identifier(int p_offset = 0) const = 0;
+	virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const = 0;
+	virtual Variant::Type get_token_type(int p_offset = 0) const = 0;
+	virtual int get_token_line(int p_offset = 0) const = 0;
+	virtual int get_token_column(int p_offset = 0) const = 0;
+	virtual int get_token_line_indent(int p_offset = 0) const = 0;
+	virtual int get_token_line_tab_indent(int p_offset = 0) const = 0;
+	virtual String get_token_error(int p_offset = 0) const = 0;
+	virtual void advance(int p_amount = 1) = 0;
+#ifdef DEBUG_ENABLED
+	virtual const Vector<Pair<int, String>> &get_warning_skips() const = 0;
+	virtual const Set<String> &get_warning_global_skips() const = 0;
+	virtual bool is_ignoring_warnings() const = 0;
+#endif // DEBUG_ENABLED
+
+	virtual ~GDScriptTokenizer(){};
+};
+
+class GDScriptTokenizerText : public GDScriptTokenizer {
+	enum {
+		MAX_LOOKAHEAD = 4,
+		TK_RB_SIZE = MAX_LOOKAHEAD * 2 + 1
+
+	};
+
+	struct TokenData {
+		Token type;
+		StringName identifier; //for identifier types
+		Variant constant; //for constant types
+		union {
+			Variant::Type vtype; //for type types
+			GDScriptFunctions::Function func; //function for built in functions
+			int warning_code; //for warning skip
+		};
+		int line, col;
+		TokenData() {
+			type = TK_EMPTY;
+			line = col = 0;
+			vtype = Variant::NIL;
+		}
+	};
+
+	void _make_token(Token p_type);
+	void _make_newline(int p_indentation = 0, int p_tabs = 0);
+	void _make_identifier(const StringName &p_identifier);
+	void _make_built_in_func(GDScriptFunctions::Function p_func);
+	void _make_constant(const Variant &p_constant);
+	void _make_type(const Variant::Type &p_type);
+	void _make_error(const String &p_error);
+
+	String code;
+	int len;
+	int code_pos;
+	const CharType *_code;
+	int line;
+	int column;
+	TokenData tk_rb[TK_RB_SIZE * 2 + 1];
+	int tk_rb_pos;
+	String last_error;
+	bool error_flag;
+
+#ifdef DEBUG_ENABLED
+	Vector<Pair<int, String>> warning_skips;
+	Set<String> warning_global_skips;
+	bool ignore_warnings;
+#endif // DEBUG_ENABLED
+
+	void _advance();
+
+public:
+	void set_code(const String &p_code);
+	virtual Token get_token(int p_offset = 0) const;
+	virtual StringName get_token_identifier(int p_offset = 0) const;
+	virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const;
+	virtual Variant::Type get_token_type(int p_offset = 0) const;
+	virtual int get_token_line(int p_offset = 0) const;
+	virtual int get_token_column(int p_offset = 0) const;
+	virtual int get_token_line_indent(int p_offset = 0) const;
+	virtual int get_token_line_tab_indent(int p_offset = 0) const;
+	virtual const Variant &get_token_constant(int p_offset = 0) const;
+	virtual String get_token_error(int p_offset = 0) const;
+	virtual void advance(int p_amount = 1);
+#ifdef DEBUG_ENABLED
+	virtual const Vector<Pair<int, String>> &get_warning_skips() const {
+		return warning_skips;
+	}
+	virtual const Set<String> &get_warning_global_skips() const {
+		return warning_global_skips;
+	}
+	virtual bool is_ignoring_warnings() const {
+		return ignore_warnings;
+	}
+#endif // DEBUG_ENABLED
+};
+
+class GDScriptTokenizerBuffer : public GDScriptTokenizer {
+	enum {
+
+		TOKEN_BYTE_MASK = 0x80,
+		TOKEN_BITS = 8,
+		TOKEN_MASK = (1 << TOKEN_BITS) - 1,
+		TOKEN_LINE_BITS = 24,
+		TOKEN_LINE_MASK = (1 << TOKEN_LINE_BITS) - 1,
+	};
+
+	Vector<StringName> identifiers;
+	Vector<Variant> constants;
+	VMap<uint32_t, uint32_t> lines;
+	Vector<uint32_t> tokens;
+	Variant nil;
+	int token;
+
+public:
+	Error set_code_buffer(const Vector<uint8_t> &p_buffer);
+	static Vector<uint8_t> parse_code_string(const String &p_code);
+	virtual Token get_token(int p_offset = 0) const;
+	virtual StringName get_token_identifier(int p_offset = 0) const;
+	virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const;
+	virtual Variant::Type get_token_type(int p_offset = 0) const;
+	virtual int get_token_line(int p_offset = 0) const;
+	virtual int get_token_column(int p_offset = 0) const;
+	virtual int get_token_line_indent(int p_offset = 0) const;
+	virtual int get_token_line_tab_indent(int p_offset = 0) const { return 0; }
+	virtual const Variant &get_token_constant(int p_offset = 0) const;
+	virtual String get_token_error(int p_offset = 0) const;
+	virtual void advance(int p_amount = 1);
+#ifdef DEBUG_ENABLED
+	virtual const Vector<Pair<int, String>> &get_warning_skips() const {
+		static Vector<Pair<int, String>> v;
+		return v;
+	}
+	virtual const Set<String> &get_warning_global_skips() const {
+		static Set<String> s;
+		return s;
+	}
+	virtual bool is_ignoring_warnings() const {
+		return true;
+	}
+#endif // DEBUG_ENABLED
+	GDScriptTokenizerBuffer();
+};
+
+#endif // GDSCRIPT_TOKENIZER_H
diff --git a/modules/cscript/doc_classes/@CScript.xml b/modules/cscript/doc_classes/@CScript.xml
new file mode 100644
index 000000000..cbe3934b4
--- /dev/null
+++ b/modules/cscript/doc_classes/@CScript.xml
@@ -0,0 +1,1237 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="@GDScript" version="3.5">
+	<brief_description>
+		Built-in GDScript functions.
+	</brief_description>
+	<description>
+		List of core built-in GDScript functions. Math functions and other utilities. Everything else is provided by objects. (Keywords: builtin, built in, global functions.)
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="Color8">
+			<return type="Color" />
+			<argument index="0" name="r8" type="int" />
+			<argument index="1" name="g8" type="int" />
+			<argument index="2" name="b8" type="int" />
+			<argument index="3" name="a8" type="int" default="255" />
+			<description>
+				Returns a color constructed from integer red, green, blue, and alpha channels. Each channel should have 8 bits of information ranging from 0 to 255.
+				[code]r8[/code] red channel
+				[code]g8[/code] green channel
+				[code]b8[/code] blue channel
+				[code]a8[/code] alpha channel
+				[codeblock]
+				red = Color8(255, 0, 0)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="ColorN">
+			<return type="Color" />
+			<argument index="0" name="name" type="String" />
+			<argument index="1" name="alpha" type="float" default="1.0" />
+			<description>
+				Returns a color according to the standardized [code]name[/code] with [code]alpha[/code] ranging from 0 to 1.
+				[codeblock]
+				red = ColorN("red", 1)
+				[/codeblock]
+				Supported color names are the same as the constants defined in [Color].
+			</description>
+		</method>
+		<method name="abs">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the absolute value of parameter [code]s[/code] (i.e. positive value).
+				[codeblock]
+				a = abs(-1) # a is 1
+				[/codeblock]
+			</description>
+		</method>
+		<method name="acos">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the arc cosine of [code]s[/code] in radians. Use to get the angle of cosine [code]s[/code]. [code]s[/code] must be between [code]-1.0[/code] and [code]1.0[/code] (inclusive), otherwise, [method acos] will return [constant NAN].
+				[codeblock]
+				# c is 0.523599 or 30 degrees if converted with rad2deg(s)
+				c = acos(0.866025)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="asin">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the arc sine of [code]s[/code] in radians. Use to get the angle of sine [code]s[/code]. [code]s[/code] must be between [code]-1.0[/code] and [code]1.0[/code] (inclusive), otherwise, [method asin] will return [constant NAN].
+				[codeblock]
+				# s is 0.523599 or 30 degrees if converted with rad2deg(s)
+				s = asin(0.5)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="assert">
+			<return type="void" />
+			<argument index="0" name="condition" type="bool" />
+			<argument index="1" name="message" type="String" default="&quot;&quot;" />
+			<description>
+				Asserts that the [code]condition[/code] is [code]true[/code]. If the [code]condition[/code] is [code]false[/code], an error is generated. When running from the editor, the running project will also be paused until you resume it. This can be used as a stronger form of [method push_error] for reporting errors to project developers or add-on users.
+				[b]Note:[/b] For performance reasons, the code inside [method assert] is only executed in debug builds or when running the project from the editor. Don't include code that has side effects in an [method assert] call. Otherwise, the project will behave differently when exported in release mode.
+				The optional [code]message[/code] argument, if given, is shown in addition to the generic "Assertion failed" message. You can use this to provide additional details about why the assertion failed.
+				[codeblock]
+				# Imagine we always want speed to be between 0 and 20.
+				var speed = -10
+				assert(speed &lt; 20) # True, the program will continue
+				assert(speed &gt;= 0) # False, the program will stop
+				assert(speed &gt;= 0 and speed &lt; 20) # You can also combine the two conditional statements in one check
+				assert(speed &lt; 20, "speed = %f, but the speed limit is 20" % speed) # Show a message with clarifying details
+				[/codeblock]
+			</description>
+		</method>
+		<method name="atan">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the arc tangent of [code]s[/code] in radians. Use it to get the angle from an angle's tangent in trigonometry: [code]atan(tan(angle)) == angle[/code].
+				The method cannot know in which quadrant the angle should fall. See [method atan2] if you have both [code]y[/code] and [code]x[/code].
+				[codeblock]
+				a = atan(0.5) # a is 0.463648
+				[/codeblock]
+			</description>
+		</method>
+		<method name="atan2">
+			<return type="float" />
+			<argument index="0" name="y" type="float" />
+			<argument index="1" name="x" type="float" />
+			<description>
+				Returns the arc tangent of [code]y/x[/code] in radians. Use to get the angle of tangent [code]y/x[/code]. To compute the value, the method takes into account the sign of both arguments in order to determine the quadrant.
+				Important note: The Y coordinate comes first, by convention.
+				[codeblock]
+				a = atan2(0, -1) # a is 3.141593
+				[/codeblock]
+			</description>
+		</method>
+		<method name="bytes2var">
+			<return type="Variant" />
+			<argument index="0" name="bytes" type="PoolByteArray" />
+			<argument index="1" name="allow_objects" type="bool" default="false" />
+			<description>
+				Decodes a byte array back to a value. When [code]allow_objects[/code] is [code]true[/code] decoding objects is allowed.
+				[b]WARNING:[/b] Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).
+			</description>
+		</method>
+		<method name="cartesian2polar">
+			<return type="Vector2" />
+			<argument index="0" name="x" type="float" />
+			<argument index="1" name="y" type="float" />
+			<description>
+				Converts a 2D point expressed in the cartesian coordinate system (X and Y axis) to the polar coordinate system (a distance from the origin and an angle).
+			</description>
+		</method>
+		<method name="ceil">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Rounds [code]s[/code] upward (towards positive infinity), returning the smallest whole number that is not less than [code]s[/code].
+				[codeblock]
+				a = ceil(1.45)  # a is 2.0
+				a = ceil(1.001) # a is 2.0
+				[/codeblock]
+				See also [method floor], [method round], [method stepify], and [int].
+			</description>
+		</method>
+		<method name="char">
+			<return type="String" />
+			<argument index="0" name="code" type="int" />
+			<description>
+				Returns a character as a String of the given Unicode code point (which is compatible with ASCII code).
+				[codeblock]
+				a = char(65)      # a is "A"
+				a = char(65 + 32) # a is "a"
+				a = char(8364)    # a is "€"
+				[/codeblock]
+				This is the inverse of [method ord].
+			</description>
+		</method>
+		<method name="clamp">
+			<return type="float" />
+			<argument index="0" name="value" type="float" />
+			<argument index="1" name="min" type="float" />
+			<argument index="2" name="max" type="float" />
+			<description>
+				Clamps [code]value[/code] and returns a value not less than [code]min[/code] and not more than [code]max[/code].
+				[codeblock]
+				a = clamp(1000, 1, 20) # a is 20
+				a = clamp(-10, 1, 20)  # a is 1
+				a = clamp(15, 1, 20)   # a is 15
+				[/codeblock]
+			</description>
+		</method>
+		<method name="convert">
+			<return type="Variant" />
+			<argument index="0" name="what" type="Variant" />
+			<argument index="1" name="type" type="int" />
+			<description>
+				Converts from a type to another in the best way possible. The [code]type[/code] parameter uses the [enum Variant.Type] values.
+				[codeblock]
+				a = Vector2(1, 0)
+				# Prints 1
+				print(a.length())
+				a = convert(a, TYPE_STRING)
+				# Prints 6 as "(1, 0)" is 6 characters
+				print(a.length())
+				[/codeblock]
+			</description>
+		</method>
+		<method name="cos">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the cosine of angle [code]s[/code] in radians.
+				[codeblock]
+				a = cos(TAU) # a is 1.0
+				a = cos(PI)  # a is -1.0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="cosh">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the hyperbolic cosine of [code]s[/code] in radians.
+				[codeblock]
+				print(cosh(1)) # Prints 1.543081
+				[/codeblock]
+			</description>
+		</method>
+		<method name="db2linear">
+			<return type="float" />
+			<argument index="0" name="db" type="float" />
+			<description>
+				Converts from decibels to linear energy (audio).
+			</description>
+		</method>
+		<method name="decimals">
+			<return type="int" />
+			<argument index="0" name="step" type="float" />
+			<description>
+				Deprecated alias for [method step_decimals].
+			</description>
+		</method>
+		<method name="dectime">
+			<return type="float" />
+			<argument index="0" name="value" type="float" />
+			<argument index="1" name="amount" type="float" />
+			<argument index="2" name="step" type="float" />
+			<description>
+				[b]Note:[/b] [code]dectime[/code] has been deprecated and will be removed in Pandemonium 4.0, please use [method move_toward] instead.
+				Returns the result of [code]value[/code] decreased by [code]step[/code] * [code]amount[/code].
+				[codeblock]
+				a = dectime(60, 10, 0.1)) # a is 59.0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="deep_equal">
+			<return type="bool" />
+			<argument index="0" name="a" type="Variant" />
+			<argument index="1" name="b" type="Variant" />
+			<description>
+				Compares two values by checking their actual contents, recursing into any `Array` or `Dictionary` up to its deepest level.
+				This compares to [code]==[/code] in a number of ways:
+				- For [code]null[/code], [code]int[/code], [code]float[/code], [code]String[/code], [code]Object[/code] and [code]RID[/code] both [code]deep_equal[/code] and [code]==[/code] work the same.
+				- For [code]Dictionary[/code], [code]==[/code] considers equality if, and only if, both variables point to the very same [code]Dictionary[/code], with no recursion or awareness of the contents at all.
+				- For [code]Array[/code], [code]==[/code] considers equality if, and only if, each item in the first [code]Array[/code] is equal to its counterpart in the second [code]Array[/code], as told by [code]==[/code] itself. That implies that [code]==[/code] recurses into [code]Array[/code], but not into [code]Dictionary[/code].
+				In short, whenever a [code]Dictionary[/code] is potentially involved, if you want a true content-aware comparison, you have to use [code]deep_equal[/code].
+			</description>
+		</method>
+		<method name="deg2rad">
+			<return type="float" />
+			<argument index="0" name="deg" type="float" />
+			<description>
+				Converts an angle expressed in degrees to radians.
+				[codeblock]
+				r = deg2rad(180) # r is 3.141593
+				[/codeblock]
+			</description>
+		</method>
+		<method name="dict2inst">
+			<return type="Object" />
+			<argument index="0" name="dict" type="Dictionary" />
+			<description>
+				Converts a dictionary (previously created with [method inst2dict]) back to an instance. Useful for deserializing.
+			</description>
+		</method>
+		<method name="ease">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<argument index="1" name="curve" type="float" />
+			<description>
+				Returns an "eased" value of [code]x[/code] based on an easing function defined with [code]curve[/code]. This easing function is based on an exponent. The [code]curve[/code] can be any floating-point number, with specific values leading to the following behaviors:
+				[codeblock]
+				- Lower than -1.0 (exclusive): Ease in-out
+				- 1.0: Linear
+				- Between -1.0 and 0.0 (exclusive): Ease out-in
+				- 0.0: Constant
+				- Between 0.0 to 1.0 (exclusive): Ease out
+				- 1.0: Linear
+				- Greater than 1.0 (exclusive): Ease in
+				[/codeblock]
+				[url=https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/ease_cheatsheet.png]ease() curve values cheatsheet[/url]
+				See also [method smoothstep]. If you need to perform more advanced transitions, use [Tween] or [AnimationPlayer].
+			</description>
+		</method>
+		<method name="exp">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				The natural exponential function. It raises the mathematical constant [b]e[/b] to the power of [code]s[/code] and returns it.
+				[b]e[/b] has an approximate value of 2.71828, and can be obtained with [code]exp(1)[/code].
+				For exponents to other bases use the method [method pow].
+				[codeblock]
+				a = exp(2) # Approximately 7.39
+				[/codeblock]
+			</description>
+		</method>
+		<method name="floor">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Rounds [code]s[/code] downward (towards negative infinity), returning the largest whole number that is not more than [code]s[/code].
+				[codeblock]
+				a = floor(2.45)  # a is 2.0
+				a = floor(2.99)  # a is 2.0
+				a = floor(-2.99) # a is -3.0
+				[/codeblock]
+				See also [method ceil], [method round], [method stepify], and [int].
+				[b]Note:[/b] This method returns a float. If you need an integer and [code]s[/code] is a non-negative number, you can use [code]int(s)[/code] directly.
+			</description>
+		</method>
+		<method name="fmod">
+			<return type="float" />
+			<argument index="0" name="a" type="float" />
+			<argument index="1" name="b" type="float" />
+			<description>
+				Returns the floating-point remainder of [code]a/b[/code], keeping the sign of [code]a[/code].
+				[codeblock]
+				r = fmod(7, 5.5) # r is 1.5
+				[/codeblock]
+				For the integer remainder operation, use the % operator.
+			</description>
+		</method>
+		<method name="fposmod">
+			<return type="float" />
+			<argument index="0" name="a" type="float" />
+			<argument index="1" name="b" type="float" />
+			<description>
+				Returns the floating-point modulus of [code]a/b[/code] that wraps equally in positive and negative.
+				[codeblock]
+				for i in 7:
+				    var x = 0.5 * i - 1.5
+				    print("%4.1f %4.1f %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])
+				[/codeblock]
+				Produces:
+				[codeblock]
+				-1.5 -0.0  0.0
+				-1.0 -1.0  0.5
+				-0.5 -0.5  1.0
+				 0.0  0.0  0.0
+				 0.5  0.5  0.5
+				 1.0  1.0  1.0
+				 1.5  0.0  0.0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="funcref">
+			<return type="FuncRef" />
+			<argument index="0" name="instance" type="Object" />
+			<argument index="1" name="funcname" type="String" />
+			<description>
+				Returns a reference to the specified function [code]funcname[/code] in the [code]instance[/code] node. As functions aren't first-class objects in GDscript, use [code]funcref[/code] to store a [FuncRef] in a variable and call it later.
+				[codeblock]
+				func foo():
+				    return("bar")
+
+				a = funcref(self, "foo")
+				print(a.call_func()) # Prints bar
+				[/codeblock]
+			</description>
+		</method>
+		<method name="get_stack">
+			<return type="Array" />
+			<description>
+				Returns an array of dictionaries representing the current call stack.
+				[codeblock]
+				func _ready():
+				    foo()
+
+				func foo():
+				    bar()
+
+				func bar():
+				    print(get_stack())
+				[/codeblock]
+				would print
+				[codeblock]
+				[{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]
+				[/codeblock]
+			</description>
+		</method>
+		<method name="hash">
+			<return type="int" />
+			<argument index="0" name="var" type="Variant" />
+			<description>
+				Returns the integer hash of the variable passed.
+				[codeblock]
+				print(hash("a")) # Prints 177670
+				[/codeblock]
+			</description>
+		</method>
+		<method name="inst2dict">
+			<return type="Dictionary" />
+			<argument index="0" name="inst" type="Object" />
+			<description>
+				Returns the passed instance converted to a dictionary (useful for serializing).
+				[codeblock]
+				var foo = "bar"
+				func _ready():
+				    var d = inst2dict(self)
+				    print(d.keys())
+				    print(d.values())
+				[/codeblock]
+				Prints out:
+				[codeblock]
+				[@subpath, @path, foo]
+				[, res://test.gd, bar]
+				[/codeblock]
+			</description>
+		</method>
+		<method name="instance_from_id">
+			<return type="Object" />
+			<argument index="0" name="instance_id" type="int" />
+			<description>
+				Returns the Object that corresponds to [code]instance_id[/code]. All Objects have a unique instance ID.
+				[codeblock]
+				var foo = "bar"
+				func _ready():
+				    var id = get_instance_id()
+				    var inst = instance_from_id(id)
+				    print(inst.foo) # Prints bar
+				[/codeblock]
+			</description>
+		</method>
+		<method name="inverse_lerp">
+			<return type="float" />
+			<argument index="0" name="from" type="float" />
+			<argument index="1" name="to" type="float" />
+			<argument index="2" name="weight" type="float" />
+			<description>
+				Returns an interpolation or extrapolation factor considering the range specified in [code]from[/code] and [code]to[/code], and the interpolated value specified in [code]weight[/code]. The returned value will be between [code]0.0[/code] and [code]1.0[/code] if [code]weight[/code] is between [code]from[/code] and [code]to[/code] (inclusive). If [code]weight[/code] is located outside this range, then an extrapolation factor will be returned (return value lower than [code]0.0[/code] or greater than [code]1.0[/code]).
+				[codeblock]
+				# The interpolation ratio in the `lerp()` call below is 0.75.
+				var middle = lerp(20, 30, 0.75)
+				# `middle` is now 27.5.
+				# Now, we pretend to have forgotten the original ratio and want to get it back.
+				var ratio = inverse_lerp(20, 30, 27.5)
+				# `ratio` is now 0.75.
+				[/codeblock]
+				See also [method lerp] which performs the reverse of this operation.
+			</description>
+		</method>
+		<method name="is_equal_approx">
+			<return type="bool" />
+			<argument index="0" name="a" type="float" />
+			<argument index="1" name="b" type="float" />
+			<description>
+				Returns [code]true[/code] if [code]a[/code] and [code]b[/code] are approximately equal to each other.
+				Here, approximately equal means that [code]a[/code] and [code]b[/code] are within a small internal epsilon of each other, which scales with the magnitude of the numbers.
+				Infinity values of the same sign are considered equal.
+			</description>
+		</method>
+		<method name="is_inf">
+			<return type="bool" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns whether [code]s[/code] is an infinity value (either positive infinity or negative infinity).
+			</description>
+		</method>
+		<method name="is_instance_valid">
+			<return type="bool" />
+			<argument index="0" name="instance" type="Object" />
+			<description>
+				Returns whether [code]instance[/code] is a valid object (e.g. has not been deleted from memory).
+			</description>
+		</method>
+		<method name="is_nan">
+			<return type="bool" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns whether [code]s[/code] is a NaN ("Not a Number" or invalid) value.
+			</description>
+		</method>
+		<method name="is_zero_approx">
+			<return type="bool" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns [code]true[/code] if [code]s[/code] is zero or almost zero.
+				This method is faster than using [method is_equal_approx] with one value as zero.
+			</description>
+		</method>
+		<method name="len">
+			<return type="int" />
+			<argument index="0" name="var" type="Variant" />
+			<description>
+				Returns length of Variant [code]var[/code]. Length is the character count of String, element count of Array, size of Dictionary, etc.
+				[b]Note:[/b] Generates a fatal error if Variant can not provide a length.
+				[codeblock]
+				a = [1, 2, 3, 4]
+				len(a) # Returns 4
+				[/codeblock]
+			</description>
+		</method>
+		<method name="lerp">
+			<return type="Variant" />
+			<argument index="0" name="from" type="Variant" />
+			<argument index="1" name="to" type="Variant" />
+			<argument index="2" name="weight" type="float" />
+			<description>
+				Linearly interpolates between two values by the factor defined in [code]weight[/code]. To perform interpolation, [code]weight[/code] should be between [code]0.0[/code] and [code]1.0[/code] (inclusive). However, values outside this range are allowed and can be used to perform [i]extrapolation[/i].
+				If the [code]from[/code] and [code]to[/code] arguments are of type [int] or [float], the return value is a [float].
+				If both are of the same vector type ([Vector2], [Vector3] or [Color]), the return value will be of the same type ([code]lerp[/code] then calls the vector type's [code]linear_interpolate[/code] method).
+				[codeblock]
+				lerp(0, 4, 0.75) # Returns 3.0
+				lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # Returns Vector2(2, 3.5)
+				[/codeblock]
+				See also [method inverse_lerp] which performs the reverse of this operation. To perform eased interpolation with [method lerp], combine it with [method ease] or [method smoothstep].
+			</description>
+		</method>
+		<method name="lerp_angle">
+			<return type="float" />
+			<argument index="0" name="from" type="float" />
+			<argument index="1" name="to" type="float" />
+			<argument index="2" name="weight" type="float" />
+			<description>
+				Linearly interpolates between two angles (in radians) by a normalized value.
+				Similar to [method lerp], but interpolates correctly when the angles wrap around [constant @GDScript.TAU]. To perform eased interpolation with [method lerp_angle], combine it with [method ease] or [method smoothstep].
+				[codeblock]
+				extends Sprite
+				var elapsed = 0.0
+				func _process(delta):
+				    var min_angle = deg2rad(0.0)
+				    var max_angle = deg2rad(90.0)
+				    rotation = lerp_angle(min_angle, max_angle, elapsed)
+				    elapsed += delta
+				[/codeblock]
+			</description>
+		</method>
+		<method name="linear2db">
+			<return type="float" />
+			<argument index="0" name="nrg" type="float" />
+			<description>
+				Converts from linear energy to decibels (audio). This can be used to implement volume sliders that behave as expected (since volume isn't linear). Example:
+				[codeblock]
+				# "Slider" refers to a node that inherits Range such as HSlider or VSlider.
+				# Its range must be configured to go from 0 to 1.
+				# Change the bus name if you'd like to change the volume of a specific bus only.
+				AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))
+				[/codeblock]
+			</description>
+		</method>
+		<method name="load">
+			<return type="Resource" />
+			<argument index="0" name="path" type="String" />
+			<description>
+				Loads a resource from the filesystem located at [code]path[/code]. The resource is loaded on the method call (unless it's referenced already elsewhere, e.g. in another script or in the scene), which might cause slight delay, especially when loading scenes. To avoid unnecessary delays when loading something multiple times, either store the resource in a variable or use [method preload].
+				[b]Note:[/b] Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+				[codeblock]
+				# Load a scene called main located in the root of the project directory and cache it in a variable.
+				var main = load("res://main.tscn") # main will contain a PackedScene resource.
+				[/codeblock]
+				[b]Important:[/b] The path must be absolute, a local path will just return [code]null[/code].
+				This method is a simplified version of [method ResourceLoader.load], which can be used for more advanced scenarios.
+			</description>
+		</method>
+		<method name="log">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Natural logarithm. The amount of time needed to reach a certain level of continuous growth.
+				[b]Note:[/b] This is not the same as the "log" function on most calculators, which uses a base 10 logarithm.
+				[codeblock]
+				log(10) # Returns 2.302585
+				[/codeblock]
+				[b]Note:[/b] The logarithm of [code]0[/code] returns [code]-inf[/code], while negative values return [code]-nan[/code].
+			</description>
+		</method>
+		<method name="max">
+			<return type="float" />
+			<argument index="0" name="a" type="float" />
+			<argument index="1" name="b" type="float" />
+			<description>
+				Returns the maximum of two values.
+				[codeblock]
+				max(1, 2) # Returns 2
+				max(-3.99, -4) # Returns -3.99
+				[/codeblock]
+			</description>
+		</method>
+		<method name="min">
+			<return type="float" />
+			<argument index="0" name="a" type="float" />
+			<argument index="1" name="b" type="float" />
+			<description>
+				Returns the minimum of two values.
+				[codeblock]
+				min(1, 2) # Returns 1
+				min(-3.99, -4) # Returns -4
+				[/codeblock]
+			</description>
+		</method>
+		<method name="move_toward">
+			<return type="float" />
+			<argument index="0" name="from" type="float" />
+			<argument index="1" name="to" type="float" />
+			<argument index="2" name="delta" type="float" />
+			<description>
+				Moves [code]from[/code] toward [code]to[/code] by the [code]delta[/code] value.
+				Use a negative [code]delta[/code] value to move away.
+				[codeblock]
+				move_toward(5, 10, 4) # Returns 9
+				move_toward(10, 5, 4) # Returns 6
+				move_toward(10, 5, -1.5) # Returns 11.5
+				[/codeblock]
+			</description>
+		</method>
+		<method name="nearest_po2">
+			<return type="int" />
+			<argument index="0" name="value" type="int" />
+			<description>
+				Returns the nearest equal or larger power of 2 for integer [code]value[/code].
+				In other words, returns the smallest value [code]a[/code] where [code]a = pow(2, n)[/code] such that [code]value &lt;= a[/code] for some non-negative integer [code]n[/code].
+				[codeblock]
+				nearest_po2(3) # Returns 4
+				nearest_po2(4) # Returns 4
+				nearest_po2(5) # Returns 8
+
+				nearest_po2(0) # Returns 0 (this may not be what you expect)
+				nearest_po2(-1) # Returns 0 (this may not be what you expect)
+				[/codeblock]
+				[b]WARNING:[/b] Due to the way it is implemented, this function returns [code]0[/code] rather than [code]1[/code] for non-positive values of [code]value[/code] (in reality, 1 is the smallest integer power of 2).
+			</description>
+		</method>
+		<method name="ord">
+			<return type="int" />
+			<argument index="0" name="char" type="String" />
+			<description>
+				Returns an integer representing the Unicode code point of the given Unicode character [code]char[/code].
+				[codeblock]
+				a = ord("A") # a is 65
+				a = ord("a") # a is 97
+				a = ord("€") # a is 8364
+				[/codeblock]
+				This is the inverse of [method char].
+			</description>
+		</method>
+		<method name="parse_json">
+			<return type="Variant" />
+			<argument index="0" name="json" type="String" />
+			<description>
+				Parse JSON text to a Variant. (Use [method typeof] to check if the Variant's type is what you expect.)
+				[b]Note:[/b] The JSON specification does not define integer or float types, but only a [i]number[/i] type. Therefore, parsing a JSON text will convert all numerical values to [float] types.
+				[b]Note:[/b] JSON objects do not preserve key order like Pandemonium dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements:
+				[codeblock]
+				var p = JSON.parse('["hello", "world", "!"]')
+				if typeof(p.result) == TYPE_ARRAY:
+				    print(p.result[0]) # Prints "hello"
+				else:
+				    push_error("Unexpected results.")
+				[/codeblock]
+				See also [JSON] for an alternative way to parse JSON text.
+			</description>
+		</method>
+		<method name="polar2cartesian">
+			<return type="Vector2" />
+			<argument index="0" name="r" type="float" />
+			<argument index="1" name="th" type="float" />
+			<description>
+				Converts a 2D point expressed in the polar coordinate system (a distance from the origin [code]r[/code] and an angle [code]th[/code]) to the cartesian coordinate system (X and Y axis).
+			</description>
+		</method>
+		<method name="posmod">
+			<return type="int" />
+			<argument index="0" name="a" type="int" />
+			<argument index="1" name="b" type="int" />
+			<description>
+				Returns the integer modulus of [code]a/b[/code] that wraps equally in positive and negative.
+				[codeblock]
+				for i in range(-3, 4):
+				    print("%2d %2d %2d" % [i, i % 3, posmod(i, 3)])
+				[/codeblock]
+				Produces:
+				[codeblock]
+				-3  0  0
+				-2 -2  1
+				-1 -1  2
+				 0  0  0
+				 1  1  1
+				 2  2  2
+				 3  0  0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="pow">
+			<return type="float" />
+			<argument index="0" name="base" type="float" />
+			<argument index="1" name="exp" type="float" />
+			<description>
+				Returns the result of [code]base[/code] raised to the power of [code]exp[/code].
+				[codeblock]
+				pow(2, 5) # Returns 32.0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="preload">
+			<return type="Resource" />
+			<argument index="0" name="path" type="String" />
+			<description>
+				Returns a [Resource] from the filesystem located at [code]path[/code]. The resource is loaded during script parsing, i.e. is loaded with the script and [method preload] effectively acts as a reference to that resource. Note that the method requires a constant path. If you want to load a resource from a dynamic/variable path, use [method load].
+				[b]Note:[/b] Resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
+				[codeblock]
+				# Instance a scene.
+				var diamond = preload("res://diamond.tscn").instance()
+				[/codeblock]
+			</description>
+		</method>
+		<method name="print" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Converts one or more arguments of any type to string in the best way possible and prints them to the console.
+				[codeblock]
+				a = [1, 2, 3]
+				print("a", "=", a) # Prints a=[1, 2, 3]
+				[/codeblock]
+				[b]Note:[/b] Consider using [method push_error] and [method push_warning] to print error and warning messages instead of [method print]. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.
+			</description>
+		</method>
+		<method name="print_debug" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Like [method print], but prints only when used in debug mode.
+			</description>
+		</method>
+		<method name="print_stack">
+			<return type="void" />
+			<description>
+				Prints a stack track at code location, only works when running with debugger turned on.
+				Output in the console would look something like this:
+				[codeblock]
+				Frame 0 - res://test.gd:16 in function '_process'
+				[/codeblock]
+			</description>
+		</method>
+		<method name="printerr" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Prints one or more arguments to strings in the best way possible to standard error line.
+				[codeblock]
+				printerr("prints to stderr")
+				[/codeblock]
+			</description>
+		</method>
+		<method name="printraw" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Prints one or more arguments to strings in the best way possible to console. No newline is added at the end.
+				[codeblock]
+				printraw("A")
+				printraw("B")
+				# Prints AB
+				[/codeblock]
+				[b]Note:[/b] Due to limitations with Pandemonium's built-in console, this only prints to the terminal. If you need to print in the editor, use another method, such as [method print].
+			</description>
+		</method>
+		<method name="prints" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Prints one or more arguments to the console with a space between each argument.
+				[codeblock]
+				prints("A", "B", "C") # Prints A B C
+				[/codeblock]
+			</description>
+		</method>
+		<method name="printt" qualifiers="vararg">
+			<return type="void" />
+			<description>
+				Prints one or more arguments to the console with a tab between each argument.
+				[codeblock]
+				printt("A", "B", "C") # Prints A       B       C
+				[/codeblock]
+			</description>
+		</method>
+		<method name="push_error">
+			<return type="void" />
+			<argument index="0" name="message" type="String" />
+			<description>
+				Pushes an error message to Pandemonium's built-in debugger and to the OS terminal.
+				[codeblock]
+				push_error("test error") # Prints "test error" to debugger and terminal as error call
+				[/codeblock]
+				[b]Note:[/b] Errors printed this way will not pause project execution. To print an error message and pause project execution in debug builds, use [code]assert(false, "test error")[/code] instead.
+			</description>
+		</method>
+		<method name="push_warning">
+			<return type="void" />
+			<argument index="0" name="message" type="String" />
+			<description>
+				Pushes a warning message to Pandemonium's built-in debugger and to the OS terminal.
+				[codeblock]
+				push_warning("test warning") # Prints "test warning" to debugger and terminal as warning call
+				[/codeblock]
+			</description>
+		</method>
+		<method name="rad2deg">
+			<return type="float" />
+			<argument index="0" name="rad" type="float" />
+			<description>
+				Converts an angle expressed in radians to degrees.
+				[codeblock]
+				rad2deg(0.523599) # Returns 30.0
+				[/codeblock]
+			</description>
+		</method>
+		<method name="rand_range">
+			<return type="float" />
+			<argument index="0" name="from" type="float" />
+			<argument index="1" name="to" type="float" />
+			<description>
+				Random range, any floating point value between [code]from[/code] and [code]to[/code].
+				[codeblock]
+				prints(rand_range(0, 1), rand_range(0, 1)) # Prints e.g. 0.135591 0.405263
+				[/codeblock]
+			</description>
+		</method>
+		<method name="rand_seed">
+			<return type="Array" />
+			<argument index="0" name="seed" type="int" />
+			<description>
+				Random from seed: pass a [code]seed[/code], and an array with both number and new seed is returned. "Seed" here refers to the internal state of the pseudo random number generator. The internal state of the current implementation is 64 bits.
+			</description>
+		</method>
+		<method name="randf">
+			<return type="float" />
+			<description>
+				Returns a random floating point value on the interval [code][0, 1][/code].
+				[codeblock]
+				randf() # Returns e.g. 0.375671
+				[/codeblock]
+			</description>
+		</method>
+		<method name="randi">
+			<return type="int" />
+			<description>
+				Returns a random unsigned 32-bit integer. Use remainder to obtain a random value in the interval [code][0, N - 1][/code] (where N is smaller than 2^32).
+				[codeblock]
+				randi()           # Returns random integer between 0 and 2^32 - 1
+				randi() % 20      # Returns random integer between 0 and 19
+				randi() % 100     # Returns random integer between 0 and 99
+				randi() % 100 + 1 # Returns random integer between 1 and 100
+				[/codeblock]
+			</description>
+		</method>
+		<method name="randomize">
+			<return type="void" />
+			<description>
+				Randomizes the seed (or the internal state) of the random number generator. Current implementation reseeds using a number based on time.
+				[codeblock]
+				func _ready():
+				    randomize()
+				[/codeblock]
+			</description>
+		</method>
+		<method name="range" qualifiers="vararg">
+			<return type="Array" />
+			<description>
+				Returns an array with the given range. Range can be 1 argument [code]N[/code] (0 to [code]N[/code] - 1), two arguments ([code]initial[/code], [code]final - 1[/code]) or three arguments ([code]initial[/code], [code]final - 1[/code], [code]increment[/code]). Returns an empty array if the range isn't valid (e.g. [code]range(2, 5, -1)[/code] or [code]range(5, 5, 1)[/code]).
+				Returns an array with the given range. [code]range()[/code] can have 1 argument N ([code]0[/code] to [code]N - 1[/code]), two arguments ([code]initial[/code], [code]final - 1[/code]) or three arguments ([code]initial[/code], [code]final - 1[/code], [code]increment[/code]). [code]increment[/code] can be negative. If [code]increment[/code] is negative, [code]final - 1[/code] will become [code]final + 1[/code]. Also, the initial value must be greater than the final value for the loop to run.
+				[codeblock]
+				print(range(4))
+				print(range(2, 5))
+				print(range(0, 6, 2))
+				[/codeblock]
+				Output:
+				[codeblock]
+				[0, 1, 2, 3]
+				[2, 3, 4]
+				[0, 2, 4]
+				[/codeblock]
+				To iterate over an [Array] backwards, use:
+				[codeblock]
+				var array = [3, 6, 9]
+				var i := array.size() - 1
+				while i &gt;= 0:
+				    print(array[i])
+				    i -= 1
+				[/codeblock]
+				Output:
+				[codeblock]
+				9
+				6
+				3
+				[/codeblock]
+			</description>
+		</method>
+		<method name="range_lerp">
+			<return type="float" />
+			<argument index="0" name="value" type="float" />
+			<argument index="1" name="istart" type="float" />
+			<argument index="2" name="istop" type="float" />
+			<argument index="3" name="ostart" type="float" />
+			<argument index="4" name="ostop" type="float" />
+			<description>
+				Maps a [code]value[/code] from range [code][istart, istop][/code] to [code][ostart, ostop][/code].
+				[codeblock]
+				range_lerp(75, 0, 100, -1, 1) # Returns 0.5
+				[/codeblock]
+			</description>
+		</method>
+		<method name="round">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Rounds [code]s[/code] to the nearest whole number, with halfway cases rounded away from zero.
+				[codeblock]
+				a = round(2.49) # a is 2.0
+				a = round(2.5)  # a is 3.0
+				a = round(2.51) # a is 3.0
+				[/codeblock]
+				See also [method floor], [method ceil], [method stepify], and [int].
+			</description>
+		</method>
+		<method name="seed">
+			<return type="void" />
+			<argument index="0" name="seed" type="int" />
+			<description>
+				Sets seed for the random number generator.
+				[codeblock]
+				my_seed = "Pandemonium Rocks"
+				seed(my_seed.hash())
+				[/codeblock]
+			</description>
+		</method>
+		<method name="sign">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the sign of [code]s[/code]: -1 or 1. Returns 0 if [code]s[/code] is 0.
+				[codeblock]
+				sign(-6) # Returns -1
+				sign(0)  # Returns 0
+				sign(6)  # Returns 1
+				[/codeblock]
+			</description>
+		</method>
+		<method name="sin">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the sine of angle [code]s[/code] in radians.
+				[codeblock]
+				sin(0.523599) # Returns 0.5
+				[/codeblock]
+			</description>
+		</method>
+		<method name="sinh">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the hyperbolic sine of [code]s[/code].
+				[codeblock]
+				a = log(2.0) # Returns 0.693147
+				sinh(a) # Returns 0.75
+				[/codeblock]
+			</description>
+		</method>
+		<method name="smoothstep">
+			<return type="float" />
+			<argument index="0" name="from" type="float" />
+			<argument index="1" name="to" type="float" />
+			<argument index="2" name="s" type="float" />
+			<description>
+				Returns the result of smoothly interpolating the value of [code]s[/code] between [code]0[/code] and [code]1[/code], based on the where [code]s[/code] lies with respect to the edges [code]from[/code] and [code]to[/code].
+				The return value is [code]0[/code] if [code]s &lt;= from[/code], and [code]1[/code] if [code]s &gt;= to[/code]. If [code]s[/code] lies between [code]from[/code] and [code]to[/code], the returned value follows an S-shaped curve that maps [code]s[/code] between [code]0[/code] and [code]1[/code].
+				This S-shaped curve is the cubic Hermite interpolator, given by [code]f(y) = 3*y^2 - 2*y^3[/code] where [code]y = (x-from) / (to-from)[/code].
+				[codeblock]
+				smoothstep(0, 2, -5.0) # Returns 0.0
+				smoothstep(0, 2, 0.5) # Returns 0.15625
+				smoothstep(0, 2, 1.0) # Returns 0.5
+				smoothstep(0, 2, 2.0) # Returns 1.0
+				[/codeblock]
+				Compared to [method ease] with a curve value of [code]-1.6521[/code], [method smoothstep] returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use [Tween] or [AnimationPlayer].
+				[url=https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/smoothstep_ease_comparison.png]Comparison between smoothstep() and ease(x, -1.6521) return values[/url]
+			</description>
+		</method>
+		<method name="sqrt">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the square root of [code]s[/code], where [code]s[/code] is a non-negative number.
+				[codeblock]
+				sqrt(9) # Returns 3
+				[/codeblock]
+				[b]Note:[/b] Negative values of [code]s[/code] return NaN. If you need negative inputs, use [code]System.Numerics.Complex[/code] in C#.
+			</description>
+		</method>
+		<method name="step_decimals">
+			<return type="int" />
+			<argument index="0" name="step" type="float" />
+			<description>
+				Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.
+				[codeblock]
+				n = step_decimals(5)           # n is 0
+				n = step_decimals(1.0005)      # n is 4
+				n = step_decimals(0.000000005) # n is 9
+				[/codeblock]
+			</description>
+		</method>
+		<method name="stepify">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<argument index="1" name="step" type="float" />
+			<description>
+				Snaps float value [code]s[/code] to a given [code]step[/code]. This can also be used to round a floating point number to an arbitrary number of decimals.
+				[codeblock]
+				stepify(100, 32) # Returns 96.0
+				stepify(3.14159, 0.01) # Returns 3.14
+				[/codeblock]
+				See also [method ceil], [method floor], [method round], and [int].
+			</description>
+		</method>
+		<method name="str" qualifiers="vararg">
+			<return type="String" />
+			<description>
+				Converts one or more arguments of any type to string in the best way possible.
+				[codeblock]
+				var a = [10, 20, 30]
+				var b = str(a);
+				len(a) # Returns 3
+				len(b) # Returns 12
+				[/codeblock]
+			</description>
+		</method>
+		<method name="str2var">
+			<return type="Variant" />
+			<argument index="0" name="string" type="String" />
+			<description>
+				Converts a formatted string that was returned by [method var2str] to the original value.
+				[codeblock]
+				a = '{ "a": 1, "b": 2 }'
+				b = str2var(a)
+				print(b["a"]) # Prints 1
+				[/codeblock]
+			</description>
+		</method>
+		<method name="tan">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the tangent of angle [code]s[/code] in radians.
+				[codeblock]
+				tan(deg2rad(45)) # Returns 1
+				[/codeblock]
+			</description>
+		</method>
+		<method name="tanh">
+			<return type="float" />
+			<argument index="0" name="s" type="float" />
+			<description>
+				Returns the hyperbolic tangent of [code]s[/code].
+				[codeblock]
+				a = log(2.0) # a is 0.693147
+				b = tanh(a)  # b is 0.6
+				[/codeblock]
+			</description>
+		</method>
+		<method name="to_json">
+			<return type="String" />
+			<argument index="0" name="var" type="Variant" />
+			<description>
+				Converts a [Variant] [code]var[/code] to JSON text and return the result. Useful for serializing data to store or send over the network.
+				[codeblock]
+				# Both numbers below are integers.
+				a = { "a": 1, "b": 2 }
+				b = to_json(a)
+				print(b) # {"a":1, "b":2}
+				# Both numbers above are floats, even if they display without any decimal places.
+				[/codeblock]
+				[b]Note:[/b] The JSON specification does not define integer or float types, but only a [i]number[/i] type. Therefore, converting a [Variant] to JSON text will convert all numerical values to [float] types.
+				See also [JSON] for an alternative way to convert a [Variant] to JSON text.
+			</description>
+		</method>
+		<method name="type_exists">
+			<return type="bool" />
+			<argument index="0" name="type" type="String" />
+			<description>
+				Returns whether the given class exists in [ClassDB].
+				[codeblock]
+				type_exists("Sprite") # Returns true
+				type_exists("Variant") # Returns false
+				[/codeblock]
+			</description>
+		</method>
+		<method name="typeof">
+			<return type="int" />
+			<argument index="0" name="what" type="Variant" />
+			<description>
+				Returns the internal type of the given Variant object, using the [enum Variant.Type] values.
+				[codeblock]
+				p = parse_json('["a", "b", "c"]')
+				if typeof(p) == TYPE_ARRAY:
+				    print(p[0]) # Prints a
+				else:
+				    print("unexpected results")
+				[/codeblock]
+			</description>
+		</method>
+		<method name="validate_json">
+			<return type="String" />
+			<argument index="0" name="json" type="String" />
+			<description>
+				Checks that [code]json[/code] is valid JSON data. Returns an empty string if valid, or an error message otherwise.
+				[codeblock]
+				j = to_json([1, 2, 3])
+				v = validate_json(j)
+				if not v:
+				    print("Valid JSON.")
+				else:
+				    push_error("Invalid JSON: " + v)
+				[/codeblock]
+			</description>
+		</method>
+		<method name="var2bytes">
+			<return type="PoolByteArray" />
+			<argument index="0" name="var" type="Variant" />
+			<argument index="1" name="full_objects" type="bool" default="false" />
+			<description>
+				Encodes a variable value to a byte array. When [code]full_objects[/code] is [code]true[/code] encoding objects is allowed (and can potentially include code).
+			</description>
+		</method>
+		<method name="var2str">
+			<return type="String" />
+			<argument index="0" name="var" type="Variant" />
+			<description>
+				Converts a Variant [code]var[/code] to a formatted string that can later be parsed using [method str2var].
+				[codeblock]
+				a = { "a": 1, "b": 2 }
+				print(var2str(a))
+				[/codeblock]
+				prints
+				[codeblock]
+				{
+				"a": 1,
+				"b": 2
+				}
+				[/codeblock]
+			</description>
+		</method>
+		<method name="weakref">
+			<return type="WeakRef" />
+			<argument index="0" name="obj" type="Object" />
+			<description>
+				Returns a weak reference to an object.
+				A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it.
+			</description>
+		</method>
+		<method name="wrapf">
+			<return type="float" />
+			<argument index="0" name="value" type="float" />
+			<argument index="1" name="min" type="float" />
+			<argument index="2" name="max" type="float" />
+			<description>
+				Wraps float [code]value[/code] between [code]min[/code] and [code]max[/code].
+				Usable for creating loop-alike behavior or infinite surfaces.
+				[codeblock]
+				# Infinite loop between 5.0 and 9.9
+				value = wrapf(value + 0.1, 5.0, 10.0)
+				[/codeblock]
+				[codeblock]
+				# Infinite rotation (in radians)
+				angle = wrapf(angle + 0.1, 0.0, TAU)
+				[/codeblock]
+				[codeblock]
+				# Infinite rotation (in radians)
+				angle = wrapf(angle + 0.1, -PI, PI)
+				[/codeblock]
+				[b]Note:[/b] If [code]min[/code] is [code]0[/code], this is equivalent to [method fposmod], so prefer using that instead.
+				[code]wrapf[/code] is more flexible than using the [method fposmod] approach by giving the user control over the minimum value.
+			</description>
+		</method>
+		<method name="wrapi">
+			<return type="int" />
+			<argument index="0" name="value" type="int" />
+			<argument index="1" name="min" type="int" />
+			<argument index="2" name="max" type="int" />
+			<description>
+				Wraps integer [code]value[/code] between [code]min[/code] and [code]max[/code].
+				Usable for creating loop-alike behavior or infinite surfaces.
+				[codeblock]
+				# Infinite loop between 5 and 9
+				frame = wrapi(frame + 1, 5, 10)
+				[/codeblock]
+				[codeblock]
+				# result is -2
+				var result = wrapi(-6, -5, -1)
+				[/codeblock]
+				[b]Note:[/b] If [code]min[/code] is [code]0[/code], this is equivalent to [method posmod], so prefer using that instead.
+				[code]wrapi[/code] is more flexible than using the [method posmod] approach by giving the user control over the minimum value.
+			</description>
+		</method>
+		<method name="yield">
+			<return type="GDScriptFunctionState" />
+			<argument index="0" name="object" type="Object" default="null" />
+			<argument index="1" name="signal" type="String" default="&quot;&quot;" />
+			<description>
+				Stops the function execution and returns the current suspended state to the calling function.
+				From the caller, call [method GDScriptFunctionState.resume] on the state to resume execution. This invalidates the state. Within the resumed function, [code]yield()[/code] returns whatever was passed to the [code]resume()[/code] function call.
+				If passed an object and a signal, the execution is resumed when the object emits the given signal. In this case, [code]yield()[/code] returns the argument passed to [code]emit_signal()[/code] if the signal takes only one argument, or an array containing all the arguments passed to [code]emit_signal()[/code] if the signal takes multiple arguments.
+				You can also use [code]yield[/code] to wait for a function to finish:
+				[codeblock]
+				func _ready():
+				    yield(countdown(), "completed") # waiting for the countdown() function to complete
+				    print('Ready')
+
+				func countdown():
+				    yield(get_tree(), "idle_frame") # returns a GDScriptFunctionState object to _ready()
+				    print(3)
+				    yield(get_tree().create_timer(1.0), "timeout")
+				    print(2)
+				    yield(get_tree().create_timer(1.0), "timeout")
+				    print(1)
+				    yield(get_tree().create_timer(1.0), "timeout")
+
+				# prints:
+				# 3
+				# 2
+				# 1
+				# Ready
+				[/codeblock]
+				When yielding on a function, the [code]completed[/code] signal will be emitted automatically when the function returns. It can, therefore, be used as the [code]signal[/code] parameter of the [code]yield[/code] method to resume.
+				In order to yield on a function, the resulting function should also return a [code]GDScriptFunctionState[/code]. Notice [code]yield(get_tree(), "idle_frame")[/code] from the above example.
+			</description>
+		</method>
+	</methods>
+	<constants>
+		<constant name="PI" value="3.141593">
+			Constant that represents how many times the diameter of a circle fits around its perimeter. This is equivalent to [code]TAU / 2[/code].
+		</constant>
+		<constant name="TAU" value="6.283185">
+			The circle constant, the circumference of the unit circle in radians. This is equivalent to [code]PI * 2[/code], or 360 degrees in rotations.
+		</constant>
+		<constant name="INF" value="inf">
+			Positive floating-point infinity. This is the result of floating-point division when the divisor is [code]0.0[/code]. For negative infinity, use [code]-INF[/code]. Dividing by [code]-0.0[/code] will result in negative infinity if the numerator is positive, so dividing by [code]0.0[/code] is not the same as dividing by [code]-0.0[/code] (despite [code]0.0 == -0.0[/code] returning [code]true[/code]).
+			[b]Note:[/b] Numeric infinity is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer number by [code]0[/code] will not result in [constant INF] and will result in a run-time error instead.
+		</constant>
+		<constant name="NAN" value="nan">
+			"Not a Number", an invalid floating-point value. [constant NAN] has special properties, including that it is not equal to itself ([code]NAN == NAN[/code] returns [code]false[/code]). It is output by some invalid operations, such as dividing floating-point [code]0.0[/code] by [code]0.0[/code].
+			[b]Note:[/b] "Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer [code]0[/code] by [code]0[/code] will not result in [constant NAN] and will result in a run-time error instead.
+		</constant>
+	</constants>
+</class>
diff --git a/modules/cscript/doc_classes/CScript.xml b/modules/cscript/doc_classes/CScript.xml
new file mode 100644
index 000000000..fdfd2ee7e
--- /dev/null
+++ b/modules/cscript/doc_classes/CScript.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="GDScript" inherits="Script" version="3.5">
+	<brief_description>
+		A script implemented in the GDScript programming language.
+	</brief_description>
+	<description>
+		A script implemented in the GDScript programming language. The script extends the functionality of all objects that instance it.
+		[method new] creates a new instance of the script. [method Object.set_script] extends an existing object, if that object's class matches one of the script's base classes.
+	</description>
+	<tutorials>
+		<link>$DOCS_URL/tutorials/scripting/gdscript/index.html</link>
+	</tutorials>
+	<methods>
+		<method name="get_as_byte_code" qualifiers="const">
+			<return type="PoolByteArray" />
+			<description>
+				Returns byte code for the script source code.
+			</description>
+		</method>
+		<method name="new" qualifiers="vararg">
+			<return type="Variant" />
+			<description>
+				Returns a new instance of the script.
+				For example:
+				[codeblock]
+				var MyClass = load("myclass.gd")
+				var instance = MyClass.new()
+				assert(instance.get_script() == MyClass)
+				[/codeblock]
+			</description>
+		</method>
+	</methods>
+	<constants>
+	</constants>
+</class>
diff --git a/modules/cscript/editor/cscript_highlighter.cpp b/modules/cscript/editor/cscript_highlighter.cpp
new file mode 100644
index 000000000..020c8c009
--- /dev/null
+++ b/modules/cscript/editor/cscript_highlighter.cpp
@@ -0,0 +1,395 @@
+/*************************************************************************/
+/*  gdscript_highlighter.cpp                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "gdscript_highlighter.h"
+#include "../gdscript_tokenizer.h"
+#include "editor/editor_settings.h"
+#include "scene/gui/text_edit.h"
+
+inline bool _is_symbol(CharType c) {
+	return is_symbol(c);
+}
+
+static bool _is_text_char(CharType c) {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+static bool _is_char(CharType c) {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+}
+
+static bool _is_number(CharType c) {
+	return (c >= '0' && c <= '9');
+}
+
+static bool _is_hex_symbol(CharType c) {
+	return ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
+}
+
+static bool _is_bin_symbol(CharType c) {
+	return (c == '0' || c == '1');
+}
+
+Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_highlighting(int p_line) {
+	Map<int, TextEdit::HighlighterInfo> color_map;
+
+	Type next_type = NONE;
+	Type current_type = NONE;
+	Type previous_type = NONE;
+
+	String previous_text = "";
+	int previous_column = 0;
+
+	bool prev_is_char = false;
+	bool prev_is_number = false;
+	bool in_keyword = false;
+	bool in_word = false;
+	bool in_function_name = false;
+	bool in_variable_declaration = false;
+	bool in_function_args = false;
+	bool in_member_variable = false;
+	bool in_node_path = false;
+	bool is_hex_notation = false;
+	bool is_bin_notation = false;
+	bool expect_type = false;
+	Color keyword_color;
+	Color color;
+
+	int in_region = text_editor->_is_line_in_region(p_line);
+	int deregion = 0;
+
+	const Map<int, TextEdit::Text::ColorRegionInfo> cri_map = text_editor->_get_line_color_region_info(p_line);
+	const String &str = text_editor->get_line(p_line);
+	Color prev_color;
+	for (int j = 0; j < str.length(); j++) {
+		TextEdit::HighlighterInfo highlighter_info;
+
+		if (deregion > 0) {
+			deregion--;
+			if (deregion == 0) {
+				in_region = -1;
+			}
+		}
+
+		if (deregion != 0) {
+			if (color != prev_color) {
+				prev_color = color;
+				highlighter_info.color = color;
+				color_map[j] = highlighter_info;
+			}
+			continue;
+		}
+
+		color = font_color;
+
+		bool is_char = _is_text_char(str[j]);
+		bool is_symbol = _is_symbol(str[j]);
+		bool is_number = _is_number(str[j]);
+
+		// allow ABCDEF in hex notation
+		if (is_hex_notation && (_is_hex_symbol(str[j]) || is_number)) {
+			is_number = true;
+		} else {
+			is_hex_notation = false;
+		}
+
+		// disallow anything not a 0 or 1
+		if (is_bin_notation && (_is_bin_symbol(str[j]))) {
+			is_number = true;
+		} else if (is_bin_notation) {
+			is_bin_notation = false;
+			is_number = false;
+		} else {
+			is_bin_notation = false;
+		}
+
+		// check for dot or underscore or 'x' for hex notation in floating point number or 'e' for scientific notation
+		if ((str[j] == '.' || str[j] == 'x' || str[j] == 'b' || str[j] == '_' || str[j] == 'e') && !in_word && prev_is_number && !is_number) {
+			is_number = true;
+			is_symbol = false;
+			is_char = false;
+
+			if (str[j] == 'x' && str[j - 1] == '0') {
+				is_hex_notation = true;
+			} else if (str[j] == 'b' && str[j - 1] == '0') {
+				is_bin_notation = true;
+			}
+		}
+
+		if (!in_word && _is_char(str[j]) && !is_number) {
+			in_word = true;
+		}
+
+		if ((in_keyword || in_word) && !is_hex_notation) {
+			is_number = false;
+		}
+
+		if (is_symbol && str[j] != '.' && in_word) {
+			in_word = false;
+		}
+
+		if (is_symbol && cri_map.has(j)) {
+			const TextEdit::Text::ColorRegionInfo &cri = cri_map[j];
+
+			if (in_region == -1) {
+				if (!cri.end) {
+					in_region = cri.region;
+				}
+			} else {
+				TextEdit::ColorRegion cr = text_editor->_get_color_region(cri.region);
+				if (in_region == cri.region && !cr.line_only) { //ignore otherwise
+					if (cri.end || cr.eq) {
+						deregion = cr.eq ? cr.begin_key.length() : cr.end_key.length();
+					}
+				}
+			}
+		}
+
+		if (!is_char) {
+			in_keyword = false;
+		}
+
+		if (in_region == -1 && !in_keyword && is_char && !prev_is_char) {
+			int to = j;
+			while (to < str.length() && _is_text_char(str[to])) {
+				to++;
+			}
+
+			String word = str.substr(j, to - j);
+			Color col = Color();
+			if (text_editor->has_keyword_color(word)) {
+				col = text_editor->get_keyword_color(word);
+			} else if (text_editor->has_member_color(word)) {
+				col = text_editor->get_member_color(word);
+			}
+
+			if (col != Color()) {
+				for (int k = j - 1; k >= 0; k--) {
+					if (str[k] == '.') {
+						col = Color(); // keyword & member indexing not allowed
+						break;
+					} else if (str[k] > 32) {
+						break;
+					}
+				}
+				if (col != Color()) {
+					in_keyword = true;
+					keyword_color = col;
+				}
+			}
+		}
+
+		if (!in_function_name && in_word && !in_keyword) {
+			int k = j;
+			while (k < str.length() && !_is_symbol(str[k]) && str[k] != '\t' && str[k] != ' ') {
+				k++;
+			}
+
+			// check for space between name and bracket
+			while (k < str.length() && (str[k] == '\t' || str[k] == ' ')) {
+				k++;
+			}
+
+			if (str[k] == '(') {
+				in_function_name = true;
+			} else if (previous_text == GDScriptTokenizer::get_token_name(GDScriptTokenizer::TK_PR_VAR)) {
+				in_variable_declaration = true;
+			}
+		}
+
+		if (!in_function_name && !in_member_variable && !in_keyword && !is_number && in_word) {
+			int k = j;
+			while (k > 0 && !_is_symbol(str[k]) && str[k] != '\t' && str[k] != ' ') {
+				k--;
+			}
+
+			if (str[k] == '.') {
+				in_member_variable = true;
+			}
+		}
+
+		if (is_symbol) {
+			if (in_function_name) {
+				in_function_args = true;
+			}
+
+			if (in_function_args && str[j] == ')') {
+				in_function_args = false;
+			}
+
+			if (expect_type && (prev_is_char || str[j] == '=')) {
+				expect_type = false;
+			}
+
+			if (j > 0 && str[j] == '>' && str[j - 1] == '-') {
+				expect_type = true;
+			}
+
+			if (in_variable_declaration || in_function_args) {
+				int k = j;
+				// Skip space
+				while (k < str.length() && (str[k] == '\t' || str[k] == ' ')) {
+					k++;
+				}
+
+				if (str[k] == ':') {
+					// has type hint
+					expect_type = true;
+				}
+			}
+
+			in_variable_declaration = false;
+			in_function_name = false;
+			in_member_variable = false;
+		}
+
+		if (!in_node_path && in_region == -1 && str[j] == '$') {
+			in_node_path = true;
+		} else if (in_region != -1 || (is_symbol && str[j] != '/')) {
+			in_node_path = false;
+		}
+
+		if (in_region >= 0) {
+			next_type = REGION;
+			color = text_editor->_get_color_region(in_region).color;
+		} else if (in_node_path) {
+			next_type = NODE_PATH;
+			color = node_path_color;
+		} else if (in_keyword) {
+			next_type = KEYWORD;
+			color = keyword_color;
+		} else if (in_member_variable) {
+			next_type = MEMBER;
+			color = member_color;
+		} else if (in_function_name) {
+			next_type = FUNCTION;
+
+			if (previous_text == GDScriptTokenizer::get_token_name(GDScriptTokenizer::TK_PR_FUNCTION)) {
+				color = function_definition_color;
+			} else {
+				color = function_color;
+			}
+		} else if (is_symbol) {
+			next_type = SYMBOL;
+			color = symbol_color;
+		} else if (is_number) {
+			next_type = NUMBER;
+			color = number_color;
+		} else if (expect_type) {
+			next_type = TYPE;
+			color = type_color;
+		} else {
+			next_type = IDENTIFIER;
+		}
+
+		if (next_type != current_type) {
+			if (current_type == NONE) {
+				current_type = next_type;
+			} else {
+				previous_type = current_type;
+				current_type = next_type;
+
+				// no need to store regions...
+				if (previous_type == REGION) {
+					previous_text = "";
+					previous_column = j;
+				} else {
+					String text = str.substr(previous_column, j - previous_column).strip_edges();
+					previous_column = j;
+
+					// ignore if just whitespace
+					if (text != "") {
+						previous_text = text;
+					}
+				}
+			}
+		}
+
+		prev_is_char = is_char;
+		prev_is_number = is_number;
+
+		if (color != prev_color) {
+			prev_color = color;
+			highlighter_info.color = color;
+			color_map[j] = highlighter_info;
+		}
+	}
+	return color_map;
+}
+
+String GDScriptSyntaxHighlighter::get_name() const {
+	return "GDScript";
+}
+
+List<String> GDScriptSyntaxHighlighter::get_supported_languages() {
+	List<String> languages;
+	languages.push_back("GDScript");
+	return languages;
+}
+
+void GDScriptSyntaxHighlighter::_update_cache() {
+	font_color = text_editor->get_color("font_color");
+	symbol_color = text_editor->get_color("symbol_color");
+	function_color = text_editor->get_color("function_color");
+	number_color = text_editor->get_color("number_color");
+	member_color = text_editor->get_color("member_variable_color");
+
+	const String text_editor_color_theme = EditorSettings::get_singleton()->get("text_editor/theme/color_theme");
+	const bool default_theme = text_editor_color_theme == "Default";
+
+	if (default_theme || EditorSettings::get_singleton()->is_dark_theme()) {
+		function_definition_color = Color(0.4, 0.9, 1.0);
+		node_path_color = Color(0.39, 0.76, 0.35);
+	} else {
+		function_definition_color = Color(0.0, 0.65, 0.73);
+		node_path_color = Color(0.32, 0.55, 0.29);
+	}
+
+	EDITOR_DEF("text_editor/highlighting/gdscript/function_definition_color", function_definition_color);
+	EDITOR_DEF("text_editor/highlighting/gdscript/node_path_color", node_path_color);
+	if (text_editor_color_theme == "Adaptive" || default_theme) {
+		EditorSettings::get_singleton()->set_initial_value(
+				"text_editor/highlighting/gdscript/function_definition_color",
+				function_definition_color,
+				true);
+		EditorSettings::get_singleton()->set_initial_value(
+				"text_editor/highlighting/gdscript/node_path_color",
+				node_path_color,
+				true);
+	}
+
+	function_definition_color = EDITOR_GET("text_editor/highlighting/gdscript/function_definition_color");
+	node_path_color = EDITOR_GET("text_editor/highlighting/gdscript/node_path_color");
+	type_color = EDITOR_GET("text_editor/highlighting/base_type_color");
+}
+
+SyntaxHighlighter *GDScriptSyntaxHighlighter::create() {
+	return memnew(GDScriptSyntaxHighlighter);
+}
diff --git a/modules/cscript/editor/cscript_highlighter.h b/modules/cscript/editor/cscript_highlighter.h
new file mode 100644
index 000000000..d4deef767
--- /dev/null
+++ b/modules/cscript/editor/cscript_highlighter.h
@@ -0,0 +1,71 @@
+#ifndef CSCRIPT_HIGHLIGHTER_H
+#define CSCRIPT_HIGHLIGHTER_H
+/*************************************************************************/
+/*  gdscript_highlighter.h                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "scene/gui/text_edit.h"
+
+class GDScriptSyntaxHighlighter : public SyntaxHighlighter {
+private:
+	enum Type {
+		NONE,
+		REGION,
+		NODE_PATH,
+		SYMBOL,
+		NUMBER,
+		FUNCTION,
+		KEYWORD,
+		MEMBER,
+		IDENTIFIER,
+		TYPE,
+	};
+
+	// colours
+	Color font_color;
+	Color symbol_color;
+	Color function_color;
+	Color function_definition_color;
+	Color built_in_type_color;
+	Color number_color;
+	Color member_color;
+	Color node_path_color;
+	Color type_color;
+
+public:
+	static SyntaxHighlighter *create();
+
+	virtual void _update_cache();
+	virtual Map<int, TextEdit::HighlighterInfo> _get_line_syntax_highlighting(int p_line);
+
+	virtual String get_name() const;
+	virtual List<String> get_supported_languages();
+};
+
+#endif // GDSCRIPT_HIGHLIGHTER_H
diff --git a/modules/cscript/icons/icon_c_script.svg b/modules/cscript/icons/icon_c_script.svg
new file mode 100644
index 000000000..0311fe388
--- /dev/null
+++ b/modules/cscript/icons/icon_c_script.svg
@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="16"
+   height="16"
+   version="1.1"
+   viewBox="0 0 16 16"
+   id="svg6"
+   sodipodi:docname="icon_g_d_script.svg"
+   inkscape:version="1.2 (dc2aedaf03, 2022-05-15)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs10" />
+  <sodipodi:namedview
+     id="namedview8"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="38.404737"
+     inkscape:cx="10.701805"
+     inkscape:cy="7.2126519"
+     inkscape:window-width="1920"
+     inkscape:window-height="1023"
+     inkscape:window-x="3840"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg6" />
+  <g
+     transform="translate(0 -1036.4)"
+     id="g4">
+    <path
+       transform="translate(0 1036.4)"
+       d="m7 1l-0.56445 2.2578a5 5 0 0 0 -0.68945 0.2793l-1.9883-1.1934-1.4141 1.4141 1.1953 1.9941a5 5 0 0 0 -0.28516 0.68555l-2.2539 0.5625v2l2.2578 0.56445a5 5 0 0 0 0.2793 0.6875l-1.1934 1.9902 1.4141 1.4141 1.9941-1.1953a5 5 0 0 0 0.68555 0.28516l0.5625 2.2539h2l0.56445-2.2578a5 5 0 0 0 0.6875 -0.2793l1.9902 1.1934 1.4141-1.4141-1.1953-1.9941a5 5 0 0 0 0.28516 -0.68555l2.2539-0.5625v-2l-2.2578-0.56445a5 5 0 0 0 -0.2793 -0.6875l1.1934-1.9902-1.4141-1.4141-1.9941 1.1953a5 5 0 0 0 -0.68555 -0.28516l-0.5625-2.2539h-2zm1 5a2 2 0 0 1 2 2 2 2 0 0 1 -2 2 2 2 0 0 1 -2 -2 2 2 0 0 1 2 -2z"
+       fill="#e0e0e0"
+       id="path2" />
+  </g>
+  <text
+     xml:space="preserve"
+     style="font-style:normal;font-weight:normal;font-size:40px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none"
+     x="9.4249582"
+     y="10.451061"
+     id="text293"><tspan
+       sodipodi:role="line"
+       id="tspan291"
+       x="9.4249582"
+       y="10.451061"></tspan></text>
+  <text
+     xml:space="preserve"
+     style="font-style:normal;font-weight:normal;font-size:10.6667px;line-height:1.25;font-family:sans-serif;mix-blend-mode:luminosity;fill:#e0e0e0;fill-opacity:1;stroke:#707070;stroke-width:0.4;stroke-dasharray:none;stroke-opacity:1"
+     x="8.6932192"
+     y="15.296833"
+     id="text504-9"><tspan
+       sodipodi:role="line"
+       id="tspan502-2"
+       x="8.6932192"
+       y="15.296833"
+       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:10.6667px;font-family:'Droid Arabic Kufi';-inkscape-font-specification:'Droid Arabic Kufi Bold';fill:#e0e0e0;fill-opacity:1;stroke:#707070;stroke-width:0.4;stroke-dasharray:none;stroke-opacity:1">C</tspan></text>
+</svg>
diff --git a/modules/cscript/register_types.cpp b/modules/cscript/register_types.cpp
new file mode 100644
index 000000000..3b1dba4fd
--- /dev/null
+++ b/modules/cscript/register_types.cpp
@@ -0,0 +1,170 @@
+/*************************************************************************/
+/*  register_types.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "register_types.h"
+
+#include "core/io/file_access_encrypted.h"
+#include "core/io/resource_loader.h"
+#include "core/os/dir_access.h"
+#include "core/os/file_access.h"
+#include "cscript.h"
+#include "cscript_tokenizer.h"
+
+GDScriptLanguage *script_language_gd = nullptr;
+Ref<ResourceFormatLoaderGDScript> resource_loader_gd;
+Ref<ResourceFormatSaverGDScript> resource_saver_gd;
+
+#ifdef TOOLS_ENABLED
+
+#include "editor/editor_export.h"
+#include "editor/editor_node.h"
+#include "editor/editor_settings.h"
+#include "editor/gdscript_highlighter.h"
+
+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) {
+		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
+		String script_key;
+
+		const Ref<EditorExportPreset> &preset = get_export_preset();
+
+		if (preset.is_valid()) {
+			script_mode = preset->get_script_export_mode();
+			script_key = preset->get_script_encryption_key().to_lower();
+		}
+
+		if (!p_path.ends_with(".gd") || script_mode == EditorExportPreset::MODE_SCRIPT_TEXT) {
+			return;
+		}
+
+		Vector<uint8_t> file = FileAccess::get_file_as_array(p_path);
+		if (file.empty()) {
+			return;
+		}
+
+		String txt;
+		txt.parse_utf8((const char *)file.ptr(), file.size());
+		file = GDScriptTokenizerBuffer::parse_code_string(txt);
+
+		if (!file.empty()) {
+			if (script_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) {
+				String tmp_path = EditorSettings::get_singleton()->get_cache_dir().plus_file("script.gde");
+				FileAccess *fa = FileAccess::open(tmp_path, FileAccess::WRITE);
+
+				Vector<uint8_t> key;
+				key.resize(32);
+				for (int i = 0; i < 32; i++) {
+					int v = 0;
+					if (i * 2 < script_key.length()) {
+						CharType ct = script_key[i * 2];
+						if (ct >= '0' && ct <= '9') {
+							ct = ct - '0';
+						} else if (ct >= 'a' && ct <= 'f') {
+							ct = 10 + ct - 'a';
+						}
+						v |= ct << 4;
+					}
+
+					if (i * 2 + 1 < script_key.length()) {
+						CharType ct = script_key[i * 2 + 1];
+						if (ct >= '0' && ct <= '9') {
+							ct = ct - '0';
+						} else if (ct >= 'a' && ct <= 'f') {
+							ct = 10 + ct - 'a';
+						}
+						v |= ct;
+					}
+					key.write[i] = v;
+				}
+				FileAccessEncrypted *fae = memnew(FileAccessEncrypted);
+				Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_WRITE_AES256);
+
+				if (err == OK) {
+					fae->store_buffer(file.ptr(), file.size());
+				}
+
+				memdelete(fae);
+
+				file = FileAccess::get_file_as_array(tmp_path);
+				add_file(p_path.get_basename() + ".gde", file, true);
+
+				// Clean up temporary file.
+				DirAccess::remove_file_or_error(tmp_path);
+
+			} else {
+				add_file(p_path.get_basename() + ".gdc", file, true);
+			}
+		}
+	}
+};
+
+static void _editor_init() {
+	Ref<EditorExportGDScript> gd_export;
+	gd_export.instance();
+	EditorExport::get_singleton()->add_export_plugin(gd_export);
+}
+
+#endif // TOOLS_ENABLED
+
+void register_gdscript_types() {
+	ClassDB::register_class<GDScript>();
+	ClassDB::register_virtual_class<GDScriptFunctionState>();
+
+	script_language_gd = memnew(GDScriptLanguage);
+	ScriptServer::register_language(script_language_gd);
+
+	resource_loader_gd.instance();
+	ResourceLoader::add_resource_format_loader(resource_loader_gd);
+
+	resource_saver_gd.instance();
+	ResourceSaver::add_resource_format_saver(resource_saver_gd);
+
+#ifdef TOOLS_ENABLED
+	ScriptEditor::register_create_syntax_highlighter_function(GDScriptSyntaxHighlighter::create);
+	EditorNode::add_init_callback(_editor_init);
+#endif // TOOLS_ENABLED
+}
+
+void unregister_gdscript_types() {
+	ScriptServer::unregister_language(script_language_gd);
+
+	if (script_language_gd) {
+		memdelete(script_language_gd);
+	}
+
+	ResourceLoader::remove_resource_format_loader(resource_loader_gd);
+	resource_loader_gd.unref();
+
+	ResourceSaver::remove_resource_format_saver(resource_saver_gd);
+	resource_saver_gd.unref();
+}
diff --git a/modules/cscript/register_types.h b/modules/cscript/register_types.h
new file mode 100644
index 000000000..85c806afd
--- /dev/null
+++ b/modules/cscript/register_types.h
@@ -0,0 +1,36 @@
+#ifndef CSCRIPT_REGISTER_TYPES_H
+#define CSCRIPT_REGISTER_TYPES_H
+/*************************************************************************/
+/*  register_types.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+void register_cscript_types();
+void unregister_cscript_types();
+
+#endif // GDSCRIPT_REGISTER_TYPES_H