Add GDExtension support to Script

* Ability to create script languages from GDExtension
* Some additions to gdnative_extension.h to make this happen
* Moved the GDExtension binder to core

This now allows creating scripting languages from GDExtension, with the same ease as if it was a module. It replaces the old PluginScript from Godot 3.x.
Warning: GodotCPP will need to be updated to support this (it may be a bit of work as ScriptInstance needs to be created over there again).

core/core_bind.cpp

@@ -2296,6 +2296,18 @@ Vector<String> Engine::get_singleton_list() const {
 	return ret;
 }
 
+void Engine::register_script_language(ScriptLanguage *p_language) {
+	ScriptServer::register_language(p_language);
+}
+
+int Engine::get_script_language_count() {
+	return ScriptServer::get_language_count();
+}
+
+ScriptLanguage *Engine::get_script_language(int p_index) const {
+	return ScriptServer::get_language(p_index);
+}
+
 void Engine::set_editor_hint(bool p_enabled) {
 	::Engine::get_singleton()->set_editor_hint(p_enabled);
 }
@@ -2347,6 +2359,10 @@ void Engine::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("unregister_singleton", "name"), &Engine::unregister_singleton);
 	ClassDB::bind_method(D_METHOD("get_singleton_list"), &Engine::get_singleton_list);
 
+	ClassDB::bind_method(D_METHOD("register_script_language", "language"), &Engine::register_script_language);
+	ClassDB::bind_method(D_METHOD("get_script_language_count"), &Engine::get_script_language_count);
+	ClassDB::bind_method(D_METHOD("get_script_language", "index"), &Engine::get_script_language);
+
 	ClassDB::bind_method(D_METHOD("is_editor_hint"), &Engine::is_editor_hint);
 
 	ClassDB::bind_method(D_METHOD("set_print_error_messages", "enabled"), &Engine::set_print_error_messages);

core/core_bind.h

@@ -38,6 +38,7 @@
 #include "core/io/image.h"
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
+#include "core/object/script_language.h"
 #include "core/os/os.h"
 #include "core/os/semaphore.h"
 #include "core/os/thread.h"
@@ -664,6 +665,10 @@ public:
 	void unregister_singleton(const StringName &p_name);
 	Vector<String> get_singleton_list() const;
 
+	void register_script_language(ScriptLanguage *p_language);
+	int get_script_language_count();
+	ScriptLanguage *get_script_language(int p_index) const;
+
 	void set_editor_hint(bool p_enabled);
 	bool is_editor_hint() const;
 

core/extension/SCsub

@@ -2,6 +2,12 @@
 
 Import("env")
 
+import make_wrappers
+from platform_methods import run_in_subprocess
+
+env.CommandNoCache(["ext_wrappers.gen.inc"], "make_wrappers.py", run_in_subprocess(make_wrappers.run))
+
+
 env_extension = env.Clone()
 
 env_extension.add_source_files(env.core_sources, "*.cpp")

core/extension/gdnative_interface.cpp

@@ -32,6 +32,7 @@
 
 #include "core/config/engine.h"
 #include "core/object/class_db.h"
+#include "core/object/script_language_extension.h"
 #include "core/os/memory.h"
 #include "core/variant/variant.h"
 #include "core/version.h"
@@ -864,6 +865,13 @@ static GDObjectInstanceID gdnative_object_get_instance_id(const GDNativeObjectPt
 	return (GDObjectInstanceID)o->get_instance_id();
 }
 
+static GDNativeScriptInstancePtr gdnative_script_instance_create(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data) {
+	ScriptInstanceExtension *script_instance_extension = memnew(ScriptInstanceExtension);
+	script_instance_extension->instance = p_instance_data;
+	script_instance_extension->native_info = p_info;
+	return reinterpret_cast<GDNativeScriptInstancePtr>(script_instance_extension);
+}
+
 static GDNativeMethodBindPtr gdnative_classdb_get_method_bind(const char *p_classname, const char *p_methodname, GDNativeInt p_hash) {
 	MethodBind *mb = ClassDB::get_method(StringName(p_classname), StringName(p_methodname));
 	ERR_FAIL_COND_V(!mb, nullptr);
@@ -1032,6 +1040,10 @@ void gdnative_setup_interface(GDNativeInterface *p_interface) {
 	gdni.object_get_instance_from_id = gdnative_object_get_instance_from_id;
 	gdni.object_get_instance_id = gdnative_object_get_instance_id;
 
+	/* SCRIPT INSTANCE */
+
+	gdni.script_instance_create = gdnative_script_instance_create;
+
 	/* CLASSDB */
 
 	gdni.classdb_construct_object = gdnative_classdb_construct_object;

core/extension/gdnative_interface.h

@@ -205,6 +205,17 @@ typedef struct {
 	uint32_t usage;
 } GDNativePropertyInfo;
 
+typedef struct {
+	const char *name;
+	GDNativePropertyInfo return_value;
+	uint32_t flags; // From GDNativeExtensionClassMethodFlags
+	int32_t id;
+	GDNativePropertyInfo *arguments;
+	uint32_t argument_count;
+	GDNativeVariantPtr default_arguments;
+	uint32_t default_argument_count;
+} GDNativeMethodInfo;
+
 typedef const GDNativePropertyInfo *(*GDNativeExtensionClassGetPropertyList)(GDExtensionClassInstancePtr p_instance, uint32_t *r_count);
 typedef void (*GDNativeExtensionClassFreePropertyList)(GDExtensionClassInstancePtr p_instance, const GDNativePropertyInfo *p_list);
 typedef void (*GDNativeExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what);
@@ -289,6 +300,79 @@ typedef struct {
 	GDNativeVariantPtr *default_arguments;
 } GDNativeExtensionClassMethodInfo;
 
+/* SCRIPT INSTANCE EXTENSION */
+
+typedef void *GDNativeExtensionScriptInstanceDataPtr; // Pointer to custom ScriptInstance native implementation
+
+typedef GDNativeBool (*GDNativeExtensionScriptInstanceSet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value);
+typedef GDNativeBool (*GDNativeExtensionScriptInstanceGet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret);
+typedef const GDNativePropertyInfo *(*GDNativeExtensionScriptInstanceGetPropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count);
+typedef void (*GDNativeExtensionScriptInstanceFreePropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativePropertyInfo *p_list);
+typedef GDNativeVariantType (*GDNativeExtensionScriptInstanceGetPropertyType)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeBool *r_is_valid);
+
+typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetOwner)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+typedef void (*GDNativeExtensionScriptInstancePropertyStateAdd)(const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value, void *p_userdata);
+typedef void (*GDNativeExtensionScriptInstanceGetPropertyState)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeExtensionScriptInstancePropertyStateAdd p_add_func, void *p_userdata);
+
+typedef const GDNativeMethodInfo *(*GDNativeExtensionScriptInstanceGetMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count);
+typedef void (*GDNativeExtensionScriptInstanceFreeMethodList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeMethodInfo *p_list);
+
+typedef GDNativeBool (*GDNativeExtensionScriptInstanceHasMethod)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name);
+
+typedef void (*GDNativeExtensionScriptInstanceCall)(GDNativeExtensionScriptInstanceDataPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error);
+typedef void (*GDNativeExtensionScriptInstanceNotification)(GDNativeExtensionScriptInstanceDataPtr p_instance, int32_t p_what);
+typedef const char *(*GDNativeExtensionScriptInstanceToString)(GDNativeExtensionScriptInstanceDataPtr p_instance, GDNativeBool *r_is_valid);
+
+typedef void (*GDNativeExtensionScriptInstanceRefCountIncremented)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+typedef GDNativeBool (*GDNativeExtensionScriptInstanceRefCountDecremented)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+
+typedef GDNativeObjectPtr (*GDNativeExtensionScriptInstanceGetScript)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+typedef GDNativeBool (*GDNativeExtensionScriptInstanceIsPlaceholder)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+
+typedef void *GDNativeExtensionScriptLanguagePtr;
+
+typedef GDNativeExtensionScriptLanguagePtr (*GDNativeExtensionScriptInstanceGetLanguage)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+
+typedef void (*GDNativeExtensionScriptInstanceFree)(GDNativeExtensionScriptInstanceDataPtr p_instance);
+
+typedef void *GDNativeScriptInstancePtr; // Pointer to ScriptInstance.
+
+typedef struct {
+	GDNativeExtensionScriptInstanceSet set_func;
+	GDNativeExtensionScriptInstanceGet get_func;
+	GDNativeExtensionScriptInstanceGetPropertyList get_property_list_func;
+	GDNativeExtensionScriptInstanceFreePropertyList free_property_list_func;
+	GDNativeExtensionScriptInstanceGetPropertyType get_property_type_func;
+
+	GDNativeExtensionScriptInstanceGetOwner get_owner_func;
+	GDNativeExtensionScriptInstanceGetPropertyState get_property_state_func;
+
+	GDNativeExtensionScriptInstanceGetMethodList get_method_list_func;
+	GDNativeExtensionScriptInstanceFreeMethodList free_method_list_func;
+
+	GDNativeExtensionScriptInstanceHasMethod has_method_func;
+
+	GDNativeExtensionScriptInstanceCall call_func;
+	GDNativeExtensionScriptInstanceNotification notification_func;
+
+	GDNativeExtensionScriptInstanceToString to_string_func;
+
+	GDNativeExtensionScriptInstanceRefCountIncremented refcount_incremented_func;
+	GDNativeExtensionScriptInstanceRefCountDecremented refcount_decremented_func;
+
+	GDNativeExtensionScriptInstanceGetScript get_script_func;
+
+	GDNativeExtensionScriptInstanceIsPlaceholder is_placeholder_func;
+
+	GDNativeExtensionScriptInstanceSet set_fallback_func;
+	GDNativeExtensionScriptInstanceGet get_fallback_func;
+
+	GDNativeExtensionScriptInstanceGetLanguage get_language_func;
+
+	GDNativeExtensionScriptInstanceFree free_func;
+
+} GDNativeExtensionScriptInstanceInfo;
+
 /* INTERFACE */
 
 typedef struct {
@@ -441,6 +525,10 @@ typedef struct {
 	GDNativeObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id);
 	GDObjectInstanceID (*object_get_instance_id)(const GDNativeObjectPtr p_object);
 
+	/* SCRIPT INSTANCE */
+
+	GDNativeScriptInstancePtr (*script_instance_create)(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data);
+
 	/* CLASSDB */
 	GDNativeObjectPtr (*classdb_construct_object)(const char *p_classname); /* The passed class must be a built-in godot class, or an already-registered extension class. In both case, object_set_instance should be called to fully initialize the object. */
 	GDNativeMethodBindPtr (*classdb_get_method_bind)(const char *p_classname, const char *p_methodname, GDNativeInt p_hash);

core/object/class_db.cpp

@@ -1485,9 +1485,10 @@ void ClassDB::add_virtual_method(const StringName &p_class, const MethodInfo &p_
 	if (p_object_core) {
 		mi.flags |= METHOD_FLAG_OBJECT_CORE;
 	}
-	if (p_arg_names.size()) {
+
+	if (!p_object_core) {
 		if (p_arg_names.size() != mi.arguments.size()) {
-			WARN_PRINT("Mismatch argument name count for virtual function: " + String(p_class) + "::" + p_method.name);
+			WARN_PRINT("Mismatch argument name count for virtual method: " + String(p_class) + "::" + p_method.name);
 		} else {
 			for (int i = 0; i < p_arg_names.size(); i++) {
 				mi.arguments[i].name = p_arg_names[i];
@@ -1495,6 +1496,10 @@ void ClassDB::add_virtual_method(const StringName &p_class, const MethodInfo &p_
 		}
 	}
 
+	if (classes[p_class].virtual_methods_map.has(p_method.name)) {
+		// overloading not supported
+		ERR_FAIL_MSG("Virtual method already bound '" + String(p_class) + "::" + p_method.name + "'.");
+	}
 	classes[p_class].virtual_methods.push_back(mi);
 	classes[p_class].virtual_methods_map[p_method.name] = mi;
 

core/object/script_language.h

@@ -132,7 +132,7 @@ public:
 	virtual Error reload(bool p_keep_state = false) = 0;
 
 #ifdef TOOLS_ENABLED
-	virtual const Vector<DocData::ClassDoc> &get_documentation() const = 0;
+	virtual Vector<DocData::ClassDoc> get_documentation() const = 0;
 #endif // TOOLS_ENABLED
 
 	virtual bool has_method(const StringName &p_method) const = 0;
@@ -212,44 +212,12 @@ public:
 	virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid);
 	virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid);
 
-	virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const = 0;
+	virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const { return get_script()->get_rpc_methods(); }
 
 	virtual ScriptLanguage *get_language() = 0;
 	virtual ~ScriptInstance();
 };
 
-struct ScriptCodeCompletionOption {
-	/* Keep enum in Sync with:                               */
-	/* /scene/gui/code_edit.h - CodeEdit::CodeCompletionKind */
-	enum Kind {
-		KIND_CLASS,
-		KIND_FUNCTION,
-		KIND_SIGNAL,
-		KIND_VARIABLE,
-		KIND_MEMBER,
-		KIND_ENUM,
-		KIND_CONSTANT,
-		KIND_NODE_PATH,
-		KIND_FILE_PATH,
-		KIND_PLAIN_TEXT,
-	};
-	Kind kind = KIND_PLAIN_TEXT;
-	String display;
-	String insert_text;
-	Color font_color;
-	RES icon;
-	Variant default_value;
-	Vector<Pair<int, int>> matches;
-
-	ScriptCodeCompletionOption() {}
-
-	ScriptCodeCompletionOption(const String &p_text, Kind p_kind) {
-		display = p_text;
-		insert_text = p_text;
-		kind = p_kind;
-	}
-};
-
 class ScriptCodeCompletionCache {
 	static ScriptCodeCompletionCache *singleton;
 
@@ -261,7 +229,8 @@ public:
 	virtual ~ScriptCodeCompletionCache() {}
 };
 
-class ScriptLanguage {
+class ScriptLanguage : public Object {
+	GDCLASS(ScriptLanguage, Object)
 public:
 	virtual String get_name() const = 0;
 
@@ -326,19 +295,55 @@ public:
 	virtual Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) { return ERR_UNAVAILABLE; }
 	virtual bool overrides_external_editor() { return false; }
 
-	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; }
+	/* Keep enum in Sync with:                               */
+	/* /scene/gui/code_edit.h - CodeEdit::CodeCompletionKind */
+	enum CodeCompletionKind {
+		CODE_COMPLETION_KIND_CLASS,
+		CODE_COMPLETION_KIND_FUNCTION,
+		CODE_COMPLETION_KIND_SIGNAL,
+		CODE_COMPLETION_KIND_VARIABLE,
+		CODE_COMPLETION_KIND_MEMBER,
+		CODE_COMPLETION_KIND_ENUM,
+		CODE_COMPLETION_KIND_CONSTANT,
+		CODE_COMPLETION_KIND_NODE_PATH,
+		CODE_COMPLETION_KIND_FILE_PATH,
+		CODE_COMPLETION_KIND_PLAIN_TEXT,
+		CODE_COMPLETION_KIND_MAX
+	};
+
+	struct CodeCompletionOption {
+		CodeCompletionKind kind = CODE_COMPLETION_KIND_PLAIN_TEXT;
+		String display;
+		String insert_text;
+		Color font_color;
+		RES icon;
+		Variant default_value;
+		Vector<Pair<int, int>> matches;
+
+		CodeCompletionOption() {}
+
+		CodeCompletionOption(const String &p_text, CodeCompletionKind p_kind) {
+			display = p_text;
+			insert_text = p_text;
+			kind = p_kind;
+		}
+	};
+
+	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; }
+
+	enum LookupResultType {
+		LOOKUP_RESULT_SCRIPT_LOCATION,
+		LOOKUP_RESULT_CLASS,
+		LOOKUP_RESULT_CLASS_CONSTANT,
+		LOOKUP_RESULT_CLASS_PROPERTY,
+		LOOKUP_RESULT_CLASS_METHOD,
+		LOOKUP_RESULT_CLASS_ENUM,
+		LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE,
+		LOOKUP_RESULT_MAX
+	};
 
 	struct LookupResult {
-		enum Type {
+		LookupResultType type;
-			RESULT_SCRIPT_LOCATION,
-			RESULT_CLASS,
-			RESULT_CLASS_CONSTANT,
-			RESULT_CLASS_PROPERTY,
-			RESULT_CLASS_METHOD,
-			RESULT_CLASS_ENUM,
-			RESULT_CLASS_TBD_GLOBALSCOPE
-		};
-		Type type;
 		Ref<Script> script;
 		String class_name;
 		String class_member;

core/object/script_language_extension.cpp

@@ -0,0 +1,175 @@
+/*************************************************************************/
+/*  script_language_extension.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 "script_language_extension.h"
+
+void ScriptExtension::_bind_methods() {
+	GDVIRTUAL_BIND(_editor_can_reload_from_file);
+	GDVIRTUAL_BIND(_placeholder_erased, "placeholder");
+
+	GDVIRTUAL_BIND(_can_instantiate);
+	GDVIRTUAL_BIND(_get_base_script);
+	GDVIRTUAL_BIND(_inherits_script, "script");
+
+	GDVIRTUAL_BIND(_get_instance_base_type);
+	GDVIRTUAL_BIND(_instance_create, "for_object");
+	GDVIRTUAL_BIND(_placeholder_instance_create, "for_object");
+
+	GDVIRTUAL_BIND(_instance_has, "object");
+
+	GDVIRTUAL_BIND(_has_source_code);
+	GDVIRTUAL_BIND(_get_source_code);
+
+	GDVIRTUAL_BIND(_set_source_code, "code");
+	GDVIRTUAL_BIND(_reload, "keep_state");
+
+	GDVIRTUAL_BIND(_get_documentation);
+
+	GDVIRTUAL_BIND(_has_method, "method");
+	GDVIRTUAL_BIND(_get_method_info, "method");
+
+	GDVIRTUAL_BIND(_is_tool);
+	GDVIRTUAL_BIND(_is_valid);
+	GDVIRTUAL_BIND(_get_language);
+
+	GDVIRTUAL_BIND(_has_script_signal, "signal");
+	GDVIRTUAL_BIND(_get_script_signal_list);
+
+	GDVIRTUAL_BIND(_get_property_default_value, "property");
+
+	GDVIRTUAL_BIND(_update_exports);
+	GDVIRTUAL_BIND(_get_script_method_list);
+	GDVIRTUAL_BIND(_get_script_property_list);
+
+	GDVIRTUAL_BIND(_get_member_line, "member");
+
+	GDVIRTUAL_BIND(_get_constants);
+	GDVIRTUAL_BIND(_get_members);
+	GDVIRTUAL_BIND(_is_placeholder_fallback_enabled);
+
+	GDVIRTUAL_BIND(_get_rpc_methods);
+}
+
+void ScriptLanguageExtension::_bind_methods() {
+	GDVIRTUAL_BIND(_get_name);
+	GDVIRTUAL_BIND(_init);
+	GDVIRTUAL_BIND(_get_type);
+	GDVIRTUAL_BIND(_get_extension);
+	GDVIRTUAL_BIND(_execute_file, "path");
+	GDVIRTUAL_BIND(_finish);
+
+	GDVIRTUAL_BIND(_get_reserved_words);
+	GDVIRTUAL_BIND(_is_control_flow_keyword, "keyword");
+	GDVIRTUAL_BIND(_get_comment_delimiters);
+	GDVIRTUAL_BIND(_get_string_delimiters);
+	GDVIRTUAL_BIND(_make_template, "template", "class_name", "base_class_name");
+	GDVIRTUAL_BIND(_get_built_in_templates, "object");
+	GDVIRTUAL_BIND(_is_using_templates);
+	GDVIRTUAL_BIND(_validate, "script", "path", "validate_functions", "validate_errors", "validate_warnings", "validate_safe_lines");
+
+	GDVIRTUAL_BIND(_validate_path, "path");
+	GDVIRTUAL_BIND(_create_script);
+	GDVIRTUAL_BIND(_has_named_classes);
+	GDVIRTUAL_BIND(_supports_builtin_mode);
+	GDVIRTUAL_BIND(_supports_documentation);
+	GDVIRTUAL_BIND(_can_inherit_from_file);
+	GDVIRTUAL_BIND(_find_function, "class_name", "function_name");
+	GDVIRTUAL_BIND(_make_function, "class_name", "function_name", "function_args");
+	GDVIRTUAL_BIND(_open_in_external_editor, "script", "line", "column");
+	GDVIRTUAL_BIND(_overrides_external_editor);
+
+	GDVIRTUAL_BIND(_complete_code, "code", "path", "owner");
+	GDVIRTUAL_BIND(_lookup_code, "code", "symbol", "path", "owner");
+	GDVIRTUAL_BIND(_auto_indent_code, "code", "from_line", "to_line");
+
+	GDVIRTUAL_BIND(_add_global_constant, "name", "value");
+	GDVIRTUAL_BIND(_add_named_global_constant, "name", "value");
+	GDVIRTUAL_BIND(_remove_named_global_constant, "name");
+
+	GDVIRTUAL_BIND(_thread_enter);
+	GDVIRTUAL_BIND(_thread_exit);
+	GDVIRTUAL_BIND(_debug_get_error);
+	GDVIRTUAL_BIND(_debug_get_stack_level_count);
+
+	GDVIRTUAL_BIND(_debug_get_stack_level_line, "level");
+	GDVIRTUAL_BIND(_debug_get_stack_level_function, "level");
+	GDVIRTUAL_BIND(_debug_get_stack_level_locals, "level", "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_get_stack_level_members, "level", "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_get_stack_level_instance, "level");
+	GDVIRTUAL_BIND(_debug_get_globals, "max_subitems", "max_depth");
+	GDVIRTUAL_BIND(_debug_parse_stack_level_expression, "level", "expression", "max_subitems", "max_depth");
+
+	GDVIRTUAL_BIND(_debug_get_current_stack_info);
+
+	GDVIRTUAL_BIND(_reload_all_scripts);
+	GDVIRTUAL_BIND(_reload_tool_script, "script", "soft_reload");
+
+	GDVIRTUAL_BIND(_get_recognized_extensions);
+	GDVIRTUAL_BIND(_get_public_functions);
+	GDVIRTUAL_BIND(_get_public_constants);
+
+	GDVIRTUAL_BIND(_profiling_start);
+	GDVIRTUAL_BIND(_profiling_stop);
+
+	GDVIRTUAL_BIND(_profiling_get_accumulated_data, "info_array", "info_max");
+	GDVIRTUAL_BIND(_profiling_get_frame_data, "info_array", "info_max");
+
+	GDVIRTUAL_BIND(_alloc_instance_binding_data, "object");
+	GDVIRTUAL_BIND(_free_instance_binding_data, "data");
+
+	GDVIRTUAL_BIND(_refcount_incremented_instance_binding, "object");
+	GDVIRTUAL_BIND(_refcount_decremented_instance_binding, "object");
+
+	GDVIRTUAL_BIND(_frame);
+
+	GDVIRTUAL_BIND(_handles_global_class_type, "type");
+	GDVIRTUAL_BIND(_get_global_class_name, "path");
+
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_SCRIPT_LOCATION);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_CONSTANT);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_PROPERTY);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_METHOD);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_ENUM);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE);
+	BIND_ENUM_CONSTANT(LOOKUP_RESULT_MAX);
+
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_CLASS);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_FUNCTION);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_SIGNAL);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_VARIABLE);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MEMBER);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_ENUM);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_CONSTANT);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_NODE_PATH);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_FILE_PATH);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_PLAIN_TEXT);
+	BIND_ENUM_CONSTANT(CODE_COMPLETION_KIND_MAX);
+}

core/object/script_language_extension.h

@@ -0,0 +1,832 @@
+/*************************************************************************/
+/*  script_language_extension.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.                */
+/*************************************************************************/
+
+#ifndef SCRIPT_LANGUAGE_EXTENSION_H
+#define SCRIPT_LANGUAGE_EXTENSION_H
+
+#include "core/extension/ext_wrappers.gen.inc"
+#include "core/object/gdvirtual.gen.inc"
+#include "core/object/script_language.h"
+#include "core/variant/native_ptr.h"
+#include "core/variant/typed_array.h"
+
+class ScriptExtension : public Script {
+	GDCLASS(ScriptExtension, Script)
+
+protected:
+	EXBIND0R(bool, editor_can_reload_from_file)
+
+	GDVIRTUAL1(_placeholder_erased, GDNativePtr<void>)
+	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override {
+		GDVIRTUAL_CALL(_placeholder_erased, p_placeholder);
+	}
+
+	static void _bind_methods();
+
+public:
+	EXBIND0RC(bool, can_instantiate)
+	EXBIND0RC(Ref<Script>, get_base_script)
+	EXBIND1RC(bool, inherits_script, const Ref<Script> &)
+	EXBIND0RC(StringName, get_instance_base_type)
+
+	GDVIRTUAL1RC(GDNativePtr<void>, _instance_create, Object *)
+	virtual ScriptInstance *instance_create(Object *p_this) override {
+		GDNativePtr<void> ret = nullptr;
+		GDVIRTUAL_REQUIRED_CALL(_instance_create, p_this, ret);
+		return reinterpret_cast<ScriptInstance *>(ret.operator void *());
+	}
+	GDVIRTUAL1RC(GDNativePtr<void>, _placeholder_instance_create, Object *)
+	PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this) override {
+		GDNativePtr<void> ret = nullptr;
+		GDVIRTUAL_REQUIRED_CALL(_placeholder_instance_create, p_this, ret);
+		return reinterpret_cast<PlaceHolderScriptInstance *>(ret.operator void *());
+	}
+
+	EXBIND1RC(bool, instance_has, const Object *)
+	EXBIND0RC(bool, has_source_code)
+	EXBIND0RC(String, get_source_code)
+	EXBIND1(set_source_code, const String &)
+	EXBIND1R(Error, reload, bool)
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_documentation)
+#ifdef TOOLS_ENABLED
+	virtual Vector<DocData::ClassDoc> get_documentation() const override {
+		TypedArray<Dictionary> doc;
+		GDVIRTUAL_REQUIRED_CALL(_get_documentation, doc);
+
+		Vector<DocData::ClassDoc> class_doc;
+#ifndef _MSC_VER
+#warning missing conversion from documentation to ClassDoc
+#endif
+		return class_doc;
+	}
+#endif // TOOLS_ENABLED
+
+	EXBIND1RC(bool, has_method, const StringName &)
+
+	GDVIRTUAL1RC(Dictionary, _get_method_info, const StringName &)
+	virtual MethodInfo get_method_info(const StringName &p_method) const override {
+		Dictionary mi;
+		GDVIRTUAL_REQUIRED_CALL(_get_method_info, p_method, mi);
+		return MethodInfo::from_dict(mi);
+	}
+
+	EXBIND0RC(bool, is_tool)
+	EXBIND0RC(bool, is_valid)
+
+	EXBIND0RC(ScriptLanguage *, get_language)
+	EXBIND1RC(bool, has_script_signal, const StringName &)
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_signal_list)
+
+	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const override {
+		TypedArray<Dictionary> sl;
+		GDVIRTUAL_REQUIRED_CALL(_get_script_signal_list, sl);
+		for (int i = 0; i < sl.size(); i++) {
+			r_signals->push_back(MethodInfo::from_dict(sl[i]));
+		}
+	}
+
+	GDVIRTUAL1RC(bool, _has_property_default_value, const StringName &)
+	GDVIRTUAL1RC(Variant, _get_property_default_value, const StringName &)
+
+	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const override {
+		bool has_dv = false;
+		if (!GDVIRTUAL_REQUIRED_CALL(_has_property_default_value, p_property, has_dv) || !has_dv) {
+			return false;
+		}
+		Variant ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_property_default_value, p_property, ret);
+		return ret;
+	}
+
+	EXBIND0(update_exports)
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_method_list)
+
+	virtual void get_script_method_list(List<MethodInfo> *r_methods) const override {
+		TypedArray<Dictionary> sl;
+		GDVIRTUAL_REQUIRED_CALL(_get_script_method_list, sl);
+		for (int i = 0; i < sl.size(); i++) {
+			r_methods->push_back(MethodInfo::from_dict(sl[i]));
+		}
+	}
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_script_property_list)
+
+	virtual void get_script_property_list(List<PropertyInfo> *r_propertys) const override {
+		TypedArray<Dictionary> sl;
+		GDVIRTUAL_REQUIRED_CALL(_get_script_property_list, sl);
+		for (int i = 0; i < sl.size(); i++) {
+			r_propertys->push_back(PropertyInfo::from_dict(sl[i]));
+		}
+	}
+
+	EXBIND1RC(int, get_member_line, const StringName &)
+
+	GDVIRTUAL0RC(Dictionary, _get_constants)
+
+	virtual void get_constants(Map<StringName, Variant> *p_constants) override {
+		Dictionary constants;
+		GDVIRTUAL_REQUIRED_CALL(_get_constants, constants);
+		List<Variant> keys;
+		constants.get_key_list(&keys);
+		for (const Variant &K : keys) {
+			p_constants->insert(K, constants[K]);
+		}
+	}
+	GDVIRTUAL0RC(TypedArray<StringName>, _get_members)
+	virtual void get_members(Set<StringName> *p_members) override {
+		TypedArray<StringName> members;
+		GDVIRTUAL_REQUIRED_CALL(_get_members, members);
+		for (int i = 0; i < members.size(); i++) {
+			p_members->insert(members[i]);
+		}
+	}
+
+	EXBIND0RC(bool, is_placeholder_fallback_enabled)
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_rpc_methods)
+
+	virtual const Vector<Multiplayer::RPCConfig> get_rpc_methods() const override {
+		TypedArray<Dictionary> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_rpc_methods, ret);
+		Vector<Multiplayer::RPCConfig> rpcret;
+		for (int i = 0; i < ret.size(); i++) {
+			Dictionary d = ret[i];
+			Multiplayer::RPCConfig rpc;
+			ERR_CONTINUE(!d.has("name"));
+			rpc.name = d["name"];
+			ERR_CONTINUE(!d.has("rpc_mode"));
+			rpc.rpc_mode = Multiplayer::RPCMode(int(d["rpc_mode"]));
+			ERR_CONTINUE(!d.has("call_local"));
+			rpc.call_local = d["call_local"];
+			ERR_CONTINUE(!d.has("transfer_mode"));
+			rpc.transfer_mode = Multiplayer::TransferMode(int(d["transfer_mode"]));
+			ERR_CONTINUE(!d.has("channel"));
+			rpc.channel = d["channel"];
+			rpcret.push_back(rpc);
+		}
+		return rpcret;
+	}
+
+	ScriptExtension() {}
+};
+
+typedef ScriptLanguage::ProfilingInfo ScriptLanguageExtensionProfilingInfo;
+
+GDVIRTUAL_NATIVE_PTR(ScriptLanguageExtensionProfilingInfo)
+
+class ScriptLanguageExtension : public ScriptLanguage {
+	GDCLASS(ScriptLanguageExtension, ScriptLanguage)
+protected:
+	static void _bind_methods();
+
+public:
+	EXBIND0RC(String, get_name)
+
+	EXBIND0(init)
+	EXBIND0RC(String, get_type)
+	EXBIND0RC(String, get_extension)
+	EXBIND1R(Error, execute_file, const String &)
+	EXBIND0(finish)
+
+	/* EDITOR FUNCTIONS */
+
+	GDVIRTUAL0RC(Vector<String>, _get_reserved_words)
+
+	virtual void get_reserved_words(List<String> *p_words) const override {
+		Vector<String> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_reserved_words, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			p_words->push_back(ret[i]);
+		}
+	}
+	EXBIND1RC(bool, is_control_flow_keyword, String)
+
+	GDVIRTUAL0RC(Vector<String>, _get_comment_delimiters)
+
+	virtual void get_comment_delimiters(List<String> *p_words) const override {
+		Vector<String> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_comment_delimiters, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			p_words->push_back(ret[i]);
+		}
+	}
+
+	GDVIRTUAL0RC(Vector<String>, _get_string_delimiters)
+
+	virtual void get_string_delimiters(List<String> *p_words) const override {
+		Vector<String> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_string_delimiters, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			p_words->push_back(ret[i]);
+		}
+	}
+
+	EXBIND3RC(Ref<Script>, make_template, const String &, const String &, const String &)
+
+	GDVIRTUAL1RC(TypedArray<Dictionary>, _get_built_in_templates, StringName)
+
+	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override {
+		TypedArray<Dictionary> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_built_in_templates, p_object, ret);
+		Vector<ScriptTemplate> stret;
+		for (int i = 0; i < ret.size(); i++) {
+			Dictionary d = ret[i];
+			ScriptTemplate st;
+			ERR_CONTINUE(!d.has("inherit"));
+			st.inherit = d["inherit"];
+			ERR_CONTINUE(!d.has("name"));
+			st.name = d["name"];
+			ERR_CONTINUE(!d.has("description"));
+			st.description = d["description"];
+			ERR_CONTINUE(!d.has("content"));
+			st.content = d["content"];
+			ERR_CONTINUE(!d.has("id"));
+			st.id = d["id"];
+			ERR_CONTINUE(!d.has("origin"));
+			st.origin = TemplateLocation(int(d["origin"]));
+			stret.push_back(st);
+		}
+		return stret;
+	}
+
+	EXBIND0R(bool, is_using_templates)
+
+	GDVIRTUAL6RC(Dictionary, _validate, const String &, const String &, bool, bool, bool, bool)
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, Set<int> *r_safe_lines = nullptr) const override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_validate, p_script, p_path, r_functions != nullptr, r_errors != nullptr, r_warnings != nullptr, r_safe_lines != nullptr, ret);
+		if (!ret.has("valid")) {
+			return false;
+		}
+		if (r_functions != nullptr && ret.has("functions")) {
+			Vector<String> functions = ret["functions"];
+			for (int i = 0; i < functions.size(); i++) {
+				r_functions->push_back(functions[i]);
+			}
+		}
+		if (r_errors != nullptr && ret.has("errors")) {
+			Array errors = ret["errors"];
+			for (int i = 0; i < errors.size(); i++) {
+				Dictionary err = errors[i];
+				ERR_CONTINUE(!err.has("line"));
+				ERR_CONTINUE(!err.has("column"));
+				ERR_CONTINUE(!err.has("message"));
+
+				ScriptError serr;
+				serr.line = err["line"];
+				serr.column = err["column"];
+				serr.message = err["message"];
+
+				r_errors->push_back(serr);
+			}
+		}
+		if (r_warnings != nullptr && ret.has("warnings")) {
+			ERR_FAIL_COND_V(!ret.has("warnings"), false);
+			Array warnings = ret["warnings"];
+			for (int i = 0; i < warnings.size(); i++) {
+				Dictionary warn = warnings[i];
+				ERR_CONTINUE(!warn.has("start_line"));
+				ERR_CONTINUE(!warn.has("end_line"));
+				ERR_CONTINUE(!warn.has("leftmost_column"));
+				ERR_CONTINUE(!warn.has("rightmost_column"));
+				ERR_CONTINUE(!warn.has("code"));
+				ERR_CONTINUE(!warn.has("string_code"));
+				ERR_CONTINUE(!warn.has("message"));
+
+				Warning swarn;
+				swarn.start_line = warn["start_line"];
+				swarn.end_line = warn["end_line"];
+				swarn.leftmost_column = warn["leftmost_column"];
+				swarn.rightmost_column = warn["rightmost_column"];
+				swarn.code = warn["code"];
+				swarn.string_code = warn["string_code"];
+				swarn.message = warn["message"];
+
+				r_warnings->push_back(swarn);
+			}
+		}
+		if (r_safe_lines != nullptr && ret.has("safe_lines")) {
+			PackedInt32Array safe_lines = ret["safe_lines"];
+			for (int i = 0; i < safe_lines.size(); i++) {
+				r_safe_lines->insert(safe_lines[i]);
+			}
+		}
+		return ret["valid"];
+	}
+
+	EXBIND1RC(String, validate_path, const String &)
+	GDVIRTUAL0RC(Object *, _create_script)
+	Script *create_script() const override {
+		Object *ret = nullptr;
+		GDVIRTUAL_REQUIRED_CALL(_create_script, ret);
+		return Object::cast_to<Script>(ret);
+	}
+	EXBIND0RC(bool, has_named_classes)
+	EXBIND0RC(bool, supports_builtin_mode)
+	EXBIND0RC(bool, supports_documentation)
+	EXBIND0RC(bool, can_inherit_from_file)
+
+	EXBIND2RC(int, find_function, const String &, const String &)
+	EXBIND3RC(String, make_function, const String &, const String &, const PackedStringArray &)
+	EXBIND3R(Error, open_in_external_editor, const Ref<Script> &, int, int)
+	EXBIND0R(bool, overrides_external_editor)
+
+	GDVIRTUAL3RC(Dictionary, _complete_code, const String &, const String &, Object *)
+
+	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<CodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_complete_code, p_code, p_path, p_owner, ret);
+		if (!ret.has("result")) {
+			return ERR_UNAVAILABLE;
+		}
+
+		if (r_options != nullptr && ret.has("options")) {
+			Array options = ret["options"];
+			for (int i = 0; i < options.size(); i++) {
+				Dictionary op = options[i];
+				CodeCompletionOption option;
+				ERR_CONTINUE(!op.has("kind"));
+				option.kind = CodeCompletionKind(int(op["kind"]));
+				ERR_CONTINUE(!op.has("display"));
+				option.display = op["display"];
+				ERR_CONTINUE(!op.has("insert_text"));
+				option.insert_text = op["insert_text"];
+				ERR_CONTINUE(!op.has("font_color"));
+				option.font_color = op["font_color"];
+				ERR_CONTINUE(!op.has("icon"));
+				option.icon = op["icon"];
+				ERR_CONTINUE(!op.has("default_value"));
+				option.default_value = op["default_value"];
+				if (op.has("matches")) {
+					PackedInt32Array matches = op["matches"];
+					ERR_CONTINUE(matches.size() & 1);
+					for (int j = 0; j < matches.size(); j += 2) {
+						option.matches.push_back(Pair<int, int>(matches[j], matches[j + 1]));
+					}
+				}
+				r_options->push_back(option);
+			}
+		}
+
+		ERR_FAIL_COND_V(!ret.has("force"), ERR_UNAVAILABLE);
+		r_force = ret["force"];
+		ERR_FAIL_COND_V(!ret.has("call_hint"), ERR_UNAVAILABLE);
+		r_call_hint = ret["call_hint"];
+		ERR_FAIL_COND_V(!ret.has("result"), ERR_UNAVAILABLE);
+		Error result = Error(int(ret["result"]));
+
+		return result;
+	}
+
+	GDVIRTUAL4RC(Dictionary, _lookup_code, const String &, const String &, const String &, Object *)
+
+	virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_lookup_code, p_code, p_symbol, p_path, p_owner, ret);
+		if (!ret.has("result")) {
+			return ERR_UNAVAILABLE;
+		}
+
+		ERR_FAIL_COND_V(!ret.has("type"), ERR_UNAVAILABLE);
+		r_result.type = LookupResultType(int(ret["type"]));
+		ERR_FAIL_COND_V(!ret.has("script"), ERR_UNAVAILABLE);
+		r_result.script = ret["script"];
+		ERR_FAIL_COND_V(!ret.has("class_name"), ERR_UNAVAILABLE);
+		r_result.class_name = ret["class_name"];
+		ERR_FAIL_COND_V(!ret.has("class_path"), ERR_UNAVAILABLE);
+		r_result.class_path = ret["class_path"];
+		ERR_FAIL_COND_V(!ret.has("location"), ERR_UNAVAILABLE);
+		r_result.location = ret["location"];
+
+		Error result = Error(int(ret["result"]));
+
+		return result;
+	}
+
+	GDVIRTUAL3RC(String, _auto_indent_code, const String &, int, int)
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override {
+		String ret;
+		GDVIRTUAL_REQUIRED_CALL(_auto_indent_code, p_code, p_from_line, p_to_line, ret);
+		p_code = ret;
+	}
+	EXBIND2(add_global_constant, const StringName &, const Variant &)
+	EXBIND2(add_named_global_constant, const StringName &, const Variant &)
+	EXBIND1(remove_named_global_constant, const StringName &)
+
+	/* MULTITHREAD FUNCTIONS */
+
+	//some VMs need to be notified of thread creation/exiting to allocate a stack
+	EXBIND0(thread_enter)
+	EXBIND0(thread_exit)
+
+	EXBIND0RC(String, debug_get_error)
+	EXBIND0RC(int, debug_get_stack_level_count)
+	EXBIND1RC(int, debug_get_stack_level_line, int)
+	EXBIND1RC(String, debug_get_stack_level_function, int)
+	EXBIND1RC(String, debug_get_stack_level_source, int)
+
+	GDVIRTUAL3R(Dictionary, _debug_get_stack_level_locals, int, int, int)
+	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) override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_locals, p_level, p_max_subitems, p_max_depth, ret);
+		if (ret.size() == 0) {
+			return;
+		}
+		if (p_locals != nullptr && ret.has("locals")) {
+			PackedStringArray strings = ret["locals"];
+			for (int i = 0; i < strings.size(); i++) {
+				p_locals->push_back(strings[i]);
+			}
+		}
+		if (p_values != nullptr && ret.has("values")) {
+			Array values = ret["values"];
+			for (int i = 0; i < values.size(); i++) {
+				p_values->push_back(values[i]);
+			}
+		}
+	}
+	GDVIRTUAL3R(Dictionary, _debug_get_stack_level_members, int, int, int)
+	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) override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_members, p_level, p_max_subitems, p_max_depth, ret);
+		if (ret.size() == 0) {
+			return;
+		}
+		if (p_members != nullptr && ret.has("members")) {
+			PackedStringArray strings = ret["members"];
+			for (int i = 0; i < strings.size(); i++) {
+				p_members->push_back(strings[i]);
+			}
+		}
+		if (p_values != nullptr && ret.has("values")) {
+			Array values = ret["values"];
+			for (int i = 0; i < values.size(); i++) {
+				p_values->push_back(values[i]);
+			}
+		}
+	}
+	GDVIRTUAL1R(GDNativePtr<void>, _debug_get_stack_level_instance, int)
+
+	virtual ScriptInstance *debug_get_stack_level_instance(int p_level) override {
+		GDNativePtr<void> ret = nullptr;
+		GDVIRTUAL_REQUIRED_CALL(_debug_get_stack_level_instance, p_level, ret);
+		return reinterpret_cast<ScriptInstance *>(ret.operator void *());
+	}
+	GDVIRTUAL2R(Dictionary, _debug_get_globals, int, int)
+	virtual void debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1) override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_debug_get_globals, p_max_subitems, p_max_depth, ret);
+		if (ret.size() == 0) {
+			return;
+		}
+		if (p_globals != nullptr && ret.has("globals")) {
+			PackedStringArray strings = ret["globals"];
+			for (int i = 0; i < strings.size(); i++) {
+				p_globals->push_back(strings[i]);
+			}
+		}
+		if (p_values != nullptr && ret.has("values")) {
+			Array values = ret["values"];
+			for (int i = 0; i < values.size(); i++) {
+				p_values->push_back(values[i]);
+			}
+		}
+	}
+
+	EXBIND4R(String, debug_parse_stack_level_expression, int, const String &, int, int)
+
+	GDVIRTUAL0R(TypedArray<Dictionary>, _debug_get_current_stack_info)
+	virtual Vector<StackInfo> debug_get_current_stack_info() override {
+		TypedArray<Dictionary> ret;
+		GDVIRTUAL_REQUIRED_CALL(_debug_get_current_stack_info, ret);
+		Vector<StackInfo> sret;
+		for (int i = 0; i < ret.size(); i++) {
+			StackInfo si;
+			Dictionary d = ret[i];
+			ERR_CONTINUE(!d.has("file"));
+			ERR_CONTINUE(!d.has("func"));
+			ERR_CONTINUE(!d.has("line"));
+			si.file = d["file"];
+			si.func = d["func"];
+			si.line = d["line"];
+			sret.push_back(si);
+		}
+		return sret;
+	}
+
+	EXBIND0(reload_all_scripts)
+	EXBIND2(reload_tool_script, const Ref<Script> &, bool)
+	/* LOADER FUNCTIONS */
+
+	GDVIRTUAL0RC(PackedStringArray, _get_recognized_extensions)
+
+	virtual void get_recognized_extensions(List<String> *p_extensions) const override {
+		PackedStringArray ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_recognized_extensions, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			p_extensions->push_back(ret[i]);
+		}
+	}
+
+	GDVIRTUAL0RC(TypedArray<Dictionary>, _get_public_functions)
+	virtual void get_public_functions(List<MethodInfo> *p_functions) const override {
+		TypedArray<Dictionary> ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_public_functions, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			MethodInfo mi = MethodInfo::from_dict(ret[i]);
+			p_functions->push_back(mi);
+		}
+	}
+	GDVIRTUAL0RC(Dictionary, _get_public_constants)
+	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_public_constants, ret);
+		for (int i = 0; i < ret.size(); i++) {
+			Dictionary d = ret[i];
+			ERR_CONTINUE(!d.has("name"));
+			ERR_CONTINUE(!d.has("value"));
+			p_constants->push_back(Pair<String, Variant>(d["name"], d["value"]));
+		}
+	}
+
+	EXBIND0(profiling_start)
+	EXBIND0(profiling_stop)
+
+	GDVIRTUAL2R(int, _profiling_get_accumulated_data, GDNativePtr<ScriptLanguageExtensionProfilingInfo>, int)
+
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override {
+		int ret = 0;
+		GDVIRTUAL_REQUIRED_CALL(_profiling_get_accumulated_data, p_info_arr, p_info_max, ret);
+		return ret;
+	}
+
+	GDVIRTUAL2R(int, _profiling_get_frame_data, GDNativePtr<ScriptLanguageExtensionProfilingInfo>, int)
+
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override {
+		int ret = 0;
+		GDVIRTUAL_REQUIRED_CALL(_profiling_get_accumulated_data, p_info_arr, p_info_max, ret);
+		return ret;
+	}
+
+	GDVIRTUAL1R(GDNativePtr<void>, _alloc_instance_binding_data, Object *)
+
+	virtual void *alloc_instance_binding_data(Object *p_object) override {
+		GDNativePtr<void> ret = nullptr;
+		GDVIRTUAL_REQUIRED_CALL(_alloc_instance_binding_data, p_object, ret);
+		return ret.operator void *();
+	}
+
+	GDVIRTUAL1(_free_instance_binding_data, GDNativePtr<void>)
+
+	virtual void free_instance_binding_data(void *p_data) override {
+		GDVIRTUAL_REQUIRED_CALL(_free_instance_binding_data, p_data);
+	}
+
+	EXBIND1(refcount_incremented_instance_binding, Object *)
+	EXBIND1R(bool, refcount_decremented_instance_binding, Object *)
+
+	EXBIND0(frame)
+
+	EXBIND1RC(bool, handles_global_class_type, const String &)
+
+	GDVIRTUAL1RC(Dictionary, _get_global_class_name, const String &)
+
+	virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const override {
+		Dictionary ret;
+		GDVIRTUAL_REQUIRED_CALL(_get_global_class_name, p_path, ret);
+		if (!ret.has("name")) {
+			return String();
+		}
+		if (r_base_type != nullptr && ret.has("base_type")) {
+			*r_base_type = ret["base_type"];
+		}
+		if (r_icon_path != nullptr && ret.has("icon_path")) {
+			*r_icon_path = ret["icon_path"];
+		}
+		return ret["name"];
+	}
+};
+
+VARIANT_ENUM_CAST(ScriptLanguageExtension::LookupResultType)
+VARIANT_ENUM_CAST(ScriptLanguageExtension::CodeCompletionKind)
+
+class ScriptInstanceExtension : public ScriptInstance {
+public:
+	const GDNativeExtensionScriptInstanceInfo *native_info;
+	GDNativeExtensionScriptInstanceDataPtr instance = nullptr;
+
+// There should not be warnings on explicit casts.
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wignored-qualifiers"
+#endif
+
+	virtual bool set(const StringName &p_name, const Variant &p_value) override {
+		if (native_info->set_func) {
+			return native_info->set_func(instance, (const GDNativeStringNamePtr)&p_name, (const GDNativeVariantPtr)&p_value);
+		}
+		return false;
+	}
+	virtual bool get(const StringName &p_name, Variant &r_ret) const override {
+		if (native_info->get_func) {
+			return native_info->get_func(instance, (const GDNativeStringNamePtr)&p_name, (GDNativeVariantPtr)&r_ret);
+		}
+		return false;
+	}
+	virtual void get_property_list(List<PropertyInfo> *p_list) const override {
+		if (native_info->get_property_list_func) {
+			uint32_t pcount;
+			const GDNativePropertyInfo *pinfo = native_info->get_property_list_func(instance, &pcount);
+			for (uint32_t i = 0; i < pcount; i++) {
+				p_list->push_back(PropertyInfo(Variant::Type(pinfo[i].type), pinfo[i].class_name, PropertyHint(pinfo[i].hint), pinfo[i].hint_string, pinfo[i].usage, pinfo[i].class_name));
+			}
+			if (native_info->free_property_list_func) {
+				native_info->free_property_list_func(instance, pinfo);
+			}
+		}
+	}
+	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const override {
+		if (native_info->get_property_type_func) {
+			GDNativeBool is_valid = 0;
+			GDNativeVariantType type = native_info->get_property_type_func(instance, (const GDNativeStringNamePtr)&p_name, &is_valid);
+			if (r_is_valid) {
+				*r_is_valid = is_valid != 0;
+			}
+
+			return Variant::Type(type);
+		}
+		return Variant::NIL;
+	}
+
+	virtual Object *get_owner() override {
+		if (native_info->get_owner_func) {
+			return (Object *)native_info->get_owner_func(instance);
+		}
+		return nullptr;
+	}
+	static void _add_property_with_state(const GDNativeStringNamePtr p_name, const GDNativeVariantPtr p_value, void *p_userdata) {
+		List<Pair<StringName, Variant>> *state = (List<Pair<StringName, Variant>> *)p_userdata;
+		state->push_back(Pair<StringName, Variant>(*(const StringName *)p_name, *(const Variant *)p_value));
+	}
+	virtual void get_property_state(List<Pair<StringName, Variant>> &state) override {
+		if (native_info->get_property_state_func) {
+			native_info->get_property_state_func(instance, _add_property_with_state, &state);
+		}
+	}
+
+	virtual void get_method_list(List<MethodInfo> *p_list) const override {
+		if (native_info->get_method_list_func) {
+			uint32_t mcount;
+			const GDNativeMethodInfo *minfo = native_info->get_method_list_func(instance, &mcount);
+			for (uint32_t i = 0; i < mcount; i++) {
+				MethodInfo m;
+				m.name = minfo[i].name;
+				m.flags = minfo[i].flags;
+				m.id = minfo[i].id;
+				m.return_val = PropertyInfo(Variant::Type(minfo[i].return_value.type), minfo[i].return_value.class_name, PropertyHint(minfo[i].return_value.hint), minfo[i].return_value.hint_string, minfo[i].return_value.usage, minfo[i].return_value.class_name);
+				for (uint32_t j = 0; j < minfo[i].argument_count; j++) {
+					m.arguments.push_back(PropertyInfo(Variant::Type(minfo[i].arguments[j].type), minfo[i].arguments[j].class_name, PropertyHint(minfo[i].arguments[j].hint), minfo[i].arguments[j].hint_string, minfo[i].arguments[j].usage, minfo[i].arguments[j].class_name));
+				}
+				const Variant *def_values = (const Variant *)minfo[i].default_arguments;
+				for (uint32_t j = 0; j < minfo[i].default_argument_count; j++) {
+					m.default_arguments.push_back(def_values[j]);
+				}
+				p_list->push_back(m);
+			}
+			if (native_info->free_method_list_func) {
+				native_info->free_method_list_func(instance, minfo);
+			}
+		}
+	}
+	virtual bool has_method(const StringName &p_method) const override {
+		if (native_info->has_method_func) {
+			return native_info->has_method_func(instance, (GDNativeStringNamePtr)&p_method);
+		}
+		return false;
+	}
+
+	virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override {
+		Variant ret;
+		if (native_info->call_func) {
+			GDNativeCallError ce;
+			native_info->call_func(instance, (const GDNativeStringNamePtr)&p_method, (const GDNativeVariantPtr *)p_args, p_argcount, (GDNativeVariantPtr)&ret, &ce);
+			r_error.error = Callable::CallError::Error(ce.error);
+			r_error.argument = ce.argument;
+			r_error.expected = ce.expected;
+		}
+		return ret;
+	}
+
+	virtual void notification(int p_notification) override {
+		if (native_info->notification_func) {
+			native_info->notification_func(instance, p_notification);
+		}
+	}
+	virtual String to_string(bool *r_valid) override {
+		if (native_info->to_string_func) {
+			GDNativeBool valid;
+			String ret = native_info->to_string_func(instance, &valid);
+			if (r_valid) {
+				*r_valid = valid != 0;
+			}
+			return ret;
+		}
+		return String();
+	}
+
+	virtual void refcount_incremented() override {
+		if (native_info->refcount_incremented_func) {
+			native_info->refcount_incremented_func(instance);
+		}
+	}
+	virtual bool refcount_decremented() override {
+		if (native_info->refcount_decremented_func) {
+			return native_info->refcount_decremented_func(instance);
+		}
+		return false;
+	}
+
+	virtual Ref<Script> get_script() const override {
+		if (native_info->get_script_func) {
+			GDNativeObjectPtr script = native_info->get_script_func(instance);
+			return Ref<Script>(reinterpret_cast<Script *>(script));
+		}
+		return Ref<Script>();
+	}
+
+	virtual bool is_placeholder() const override {
+		if (native_info->is_placeholder_func) {
+			return native_info->is_placeholder_func(instance);
+		}
+		return false;
+	}
+
+	virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) override {
+		if (native_info->set_fallback_func) {
+			bool ret = native_info->set_fallback_func(instance, (const GDNativeStringNamePtr)&p_name, (const GDNativeVariantPtr)&p_value);
+			if (r_valid) {
+				*r_valid = ret;
+			}
+		}
+	}
+	virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid) override {
+		Variant ret;
+		if (native_info->get_fallback_func) {
+			bool valid = native_info->get_fallback_func(instance, (const GDNativeStringNamePtr)&p_name, (GDNativeVariantPtr)&ret);
+			if (r_valid) {
+				*r_valid = valid;
+			}
+		}
+		return ret;
+	}
+
+	virtual ScriptLanguage *get_language() override {
+		if (native_info->get_language_func) {
+			GDNativeExtensionScriptLanguagePtr lang = native_info->get_language_func(instance);
+			return reinterpret_cast<ScriptLanguage *>(lang);
+		}
+		return nullptr;
+		;
+	}
+	virtual ~ScriptInstanceExtension() {
+		if (native_info->free_func) {
+			native_info->free_func(instance);
+		}
+	}
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+};
+
+#endif // SCRIPT_LANGUAGE_EXTENSION_H

core/register_core_types.cpp

@@ -71,6 +71,7 @@
 #include "core/multiplayer/multiplayer_api.h"
 #include "core/multiplayer/multiplayer_peer.h"
 #include "core/object/class_db.h"
+#include "core/object/script_language_extension.h"
 #include "core/object/undo_redo.h"
 #include "core/os/main_loop.h"
 #include "core/os/time.h"
@@ -142,6 +143,10 @@ void register_core_types() {
 	GDREGISTER_CLASS(Object);
 
 	GDREGISTER_ABSTRACT_CLASS(Script);
+	GDREGISTER_ABSTRACT_CLASS(ScriptLanguage);
+
+	GDREGISTER_VIRTUAL_CLASS(ScriptExtension);
+	GDREGISTER_VIRTUAL_CLASS(ScriptLanguageExtension);
 
 	GDREGISTER_CLASS(RefCounted);
 	GDREGISTER_CLASS(WeakRef);
@@ -263,6 +268,7 @@ void register_core_types() {
 	_engine_debugger = memnew(core_bind::EngineDebugger);
 
 	GDREGISTER_NATIVE_STRUCT(AudioFrame, "float left;float right");
+	GDREGISTER_NATIVE_STRUCT(ScriptLanguageExtensionProfilingInfo, "StringName signature;uint64_t call_count;uint64_t total_time;uint64_t self_time");
 }
 
 void register_core_settings() {

doc/classes/Engine.xml

@@ -94,6 +94,17 @@
 				[/codeblock]
 			</description>
 		</method>
+		<method name="get_script_language" qualifiers="const">
+			<return type="ScriptLanguage" />
+			<argument index="0" name="index" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="get_script_language_count">
+			<return type="int" />
+			<description>
+			</description>
+		</method>
 		<method name="get_singleton" qualifiers="const">
 			<return type="Object" />
 			<argument index="0" name="name" type="StringName" />
@@ -167,6 +178,12 @@
 				Returns [code]true[/code] if the game is inside the fixed process and physics phase of the game loop.
 			</description>
 		</method>
+		<method name="register_script_language">
+			<return type="void" />
+			<argument index="0" name="language" type="ScriptLanguage" />
+			<description>
+			</description>
+		</method>
 		<method name="register_singleton">
 			<return type="void" />
 			<argument index="0" name="name" type="StringName" />

doc/classes/Range.xml

@@ -11,7 +11,7 @@
 	<methods>
 		<method name="_value_changed" qualifiers="virtual">
 			<return type="void" />
-			<argument index="0" name="" type="float" />
+			<argument index="0" name="new_value" type="float" />
 			<description>
 				Called when the [Range]'s value is changed (following the same conditions as [signal value_changed]).
 			</description>

doc/classes/ScriptExtension.xml

@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="ScriptExtension" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+	</brief_description>
+	<description>
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="_can_instantiate" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_editor_can_reload_from_file" qualifiers="virtual">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_base_script" qualifiers="virtual const">
+			<return type="Script" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_constants" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_documentation" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_instance_base_type" qualifiers="virtual const">
+			<return type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_language" qualifiers="virtual const">
+			<return type="ScriptLanguage" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_member_line" qualifiers="virtual const">
+			<return type="int" />
+			<argument index="0" name="member" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_members" qualifiers="virtual const">
+			<return type="StringName[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_method_info" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<argument index="0" name="method" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_property_default_value" qualifiers="virtual const">
+			<return type="Variant" />
+			<argument index="0" name="property" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_rpc_methods" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_script_method_list" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_script_property_list" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_script_signal_list" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_source_code" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_has_method" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="method" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_has_script_signal" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="signal" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_has_source_code" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_inherits_script" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="script" type="Script" />
+			<description>
+			</description>
+		</method>
+		<method name="_instance_create" qualifiers="virtual const">
+			<return type="void*" />
+			<argument index="0" name="for_object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_instance_has" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_is_placeholder_fallback_enabled" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_is_tool" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_is_valid" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_placeholder_erased" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="placeholder" type="void*" />
+			<description>
+			</description>
+		</method>
+		<method name="_placeholder_instance_create" qualifiers="virtual const">
+			<return type="void*" />
+			<argument index="0" name="for_object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_reload" qualifiers="virtual">
+			<return type="int" enum="Error" />
+			<argument index="0" name="keep_state" type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_set_source_code" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="code" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_update_exports" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+	</methods>
+</class>

doc/classes/ScriptLanguage.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="ScriptLanguage" inherits="Object" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+	</brief_description>
+	<description>
+	</description>
+	<tutorials>
+	</tutorials>
+</class>

doc/classes/ScriptLanguageExtension.xml

@@ -0,0 +1,404 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="ScriptLanguageExtension" inherits="ScriptLanguage" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+	<brief_description>
+	</brief_description>
+	<description>
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="_add_global_constant" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
+			<argument index="1" name="value" type="Variant" />
+			<description>
+			</description>
+		</method>
+		<method name="_add_named_global_constant" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
+			<argument index="1" name="value" type="Variant" />
+			<description>
+			</description>
+		</method>
+		<method name="_alloc_instance_binding_data" qualifiers="virtual">
+			<return type="void*" />
+			<argument index="0" name="object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_auto_indent_code" qualifiers="virtual const">
+			<return type="String" />
+			<argument index="0" name="code" type="String" />
+			<argument index="1" name="from_line" type="int" />
+			<argument index="2" name="to_line" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_can_inherit_from_file" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_complete_code" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<argument index="0" name="code" type="String" />
+			<argument index="1" name="path" type="String" />
+			<argument index="2" name="owner" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_create_script" qualifiers="virtual const">
+			<return type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_current_stack_info" qualifiers="virtual">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_error" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_globals" qualifiers="virtual">
+			<return type="Dictionary" />
+			<argument index="0" name="max_subitems" type="int" />
+			<argument index="1" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_count" qualifiers="virtual const">
+			<return type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_function" qualifiers="virtual const">
+			<return type="String" />
+			<argument index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_instance" qualifiers="virtual">
+			<return type="void*" />
+			<argument index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_line" qualifiers="virtual const">
+			<return type="int" />
+			<argument index="0" name="level" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_locals" qualifiers="virtual">
+			<return type="Dictionary" />
+			<argument index="0" name="level" type="int" />
+			<argument index="1" name="max_subitems" type="int" />
+			<argument index="2" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_get_stack_level_members" qualifiers="virtual">
+			<return type="Dictionary" />
+			<argument index="0" name="level" type="int" />
+			<argument index="1" name="max_subitems" type="int" />
+			<argument index="2" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_debug_parse_stack_level_expression" qualifiers="virtual">
+			<return type="String" />
+			<argument index="0" name="level" type="int" />
+			<argument index="1" name="expression" type="String" />
+			<argument index="2" name="max_subitems" type="int" />
+			<argument index="3" name="max_depth" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_execute_file" qualifiers="virtual">
+			<return type="int" enum="Error" />
+			<argument index="0" name="path" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_find_function" qualifiers="virtual const">
+			<return type="int" />
+			<argument index="0" name="class_name" type="String" />
+			<argument index="1" name="function_name" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_finish" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_frame" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_free_instance_binding_data" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="data" type="void*" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_built_in_templates" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<argument index="0" name="object" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_comment_delimiters" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_extension" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_global_class_name" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<argument index="0" name="path" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_name" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_public_constants" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_public_functions" qualifiers="virtual const">
+			<return type="Dictionary[]" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_recognized_extensions" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_reserved_words" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_string_delimiters" qualifiers="virtual const">
+			<return type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
+		<method name="_get_type" qualifiers="virtual const">
+			<return type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_handles_global_class_type" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="type" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_has_named_classes" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_init" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_is_control_flow_keyword" qualifiers="virtual const">
+			<return type="bool" />
+			<argument index="0" name="keyword" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_is_using_templates" qualifiers="virtual">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_lookup_code" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<argument index="0" name="code" type="String" />
+			<argument index="1" name="symbol" type="String" />
+			<argument index="2" name="path" type="String" />
+			<argument index="3" name="owner" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_make_function" qualifiers="virtual const">
+			<return type="String" />
+			<argument index="0" name="class_name" type="String" />
+			<argument index="1" name="function_name" type="String" />
+			<argument index="2" name="function_args" type="PackedStringArray" />
+			<description>
+			</description>
+		</method>
+		<method name="_make_template" qualifiers="virtual const">
+			<return type="Script" />
+			<argument index="0" name="template" type="String" />
+			<argument index="1" name="class_name" type="String" />
+			<argument index="2" name="base_class_name" type="String" />
+			<description>
+			</description>
+		</method>
+		<method name="_open_in_external_editor" qualifiers="virtual">
+			<return type="int" enum="Error" />
+			<argument index="0" name="script" type="Script" />
+			<argument index="1" name="line" type="int" />
+			<argument index="2" name="column" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_overrides_external_editor" qualifiers="virtual">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_profiling_get_accumulated_data" qualifiers="virtual">
+			<return type="int" />
+			<argument index="0" name="info_array" type="ScriptLanguageExtensionProfilingInfo*" />
+			<argument index="1" name="info_max" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_profiling_get_frame_data" qualifiers="virtual">
+			<return type="int" />
+			<argument index="0" name="info_array" type="ScriptLanguageExtensionProfilingInfo*" />
+			<argument index="1" name="info_max" type="int" />
+			<description>
+			</description>
+		</method>
+		<method name="_profiling_start" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_profiling_stop" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_refcount_decremented_instance_binding" qualifiers="virtual">
+			<return type="bool" />
+			<argument index="0" name="object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_refcount_incremented_instance_binding" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="object" type="Object" />
+			<description>
+			</description>
+		</method>
+		<method name="_reload_all_scripts" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_reload_tool_script" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="script" type="Script" />
+			<argument index="1" name="soft_reload" type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_remove_named_global_constant" qualifiers="virtual">
+			<return type="void" />
+			<argument index="0" name="name" type="StringName" />
+			<description>
+			</description>
+		</method>
+		<method name="_supports_builtin_mode" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_supports_documentation" qualifiers="virtual const">
+			<return type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_thread_enter" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_thread_exit" qualifiers="virtual">
+			<return type="void" />
+			<description>
+			</description>
+		</method>
+		<method name="_validate" qualifiers="virtual const">
+			<return type="Dictionary" />
+			<argument index="0" name="script" type="String" />
+			<argument index="1" name="path" type="String" />
+			<argument index="2" name="validate_functions" type="bool" />
+			<argument index="3" name="validate_errors" type="bool" />
+			<argument index="4" name="validate_warnings" type="bool" />
+			<argument index="5" name="validate_safe_lines" type="bool" />
+			<description>
+			</description>
+		</method>
+		<method name="_validate_path" qualifiers="virtual const">
+			<return type="String" />
+			<argument index="0" name="path" type="String" />
+			<description>
+			</description>
+		</method>
+	</methods>
+	<constants>
+		<constant name="LOOKUP_RESULT_SCRIPT_LOCATION" value="0" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS" value="1" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS_CONSTANT" value="2" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS_PROPERTY" value="3" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS_METHOD" value="4" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS_ENUM" value="5" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE" value="6" enum="LookupResultType">
+		</constant>
+		<constant name="LOOKUP_RESULT_MAX" value="7" enum="LookupResultType">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_CLASS" value="0" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_FUNCTION" value="1" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_SIGNAL" value="2" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_VARIABLE" value="3" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_MEMBER" value="4" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_ENUM" value="5" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_CONSTANT" value="6" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_NODE_PATH" value="7" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_FILE_PATH" value="8" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_PLAIN_TEXT" value="9" enum="CodeCompletionKind">
+		</constant>
+		<constant name="CODE_COMPLETION_KIND_MAX" value="10" enum="CodeCompletionKind">
+		</constant>
+	</constants>
+</class>

editor/code_editor.cpp

@@ -854,7 +854,7 @@ void CodeTextEditor::_code_complete_timer_timeout() {
 }
 
 void CodeTextEditor::_complete_request() {
-	List<ScriptCodeCompletionOption> entries;
+	List<ScriptLanguage::CodeCompletionOption> entries;
 	String ctext = text_editor->get_text_for_code_completion();
 	_code_complete_script(ctext, &entries);
 	bool forced = false;
@@ -865,7 +865,7 @@ void CodeTextEditor::_complete_request() {
 		return;
 	}
 
-	for (const ScriptCodeCompletionOption &e : entries) {
+	for (const ScriptLanguage::CodeCompletionOption &e : entries) {
 		Color font_color = completion_font_color;
 		if (e.insert_text.begins_with("\"") || e.insert_text.begins_with("\'")) {
 			font_color = completion_string_color;
@@ -877,41 +877,41 @@ void CodeTextEditor::_complete_request() {
 	text_editor->update_code_completion_options(forced);
 }
 
-Ref<Texture2D> CodeTextEditor::_get_completion_icon(const ScriptCodeCompletionOption &p_option) {
+Ref<Texture2D> CodeTextEditor::_get_completion_icon(const ScriptLanguage::CodeCompletionOption &p_option) {
 	Ref<Texture2D> tex;
 	switch (p_option.kind) {
-		case ScriptCodeCompletionOption::KIND_CLASS: {
+		case ScriptLanguage::CODE_COMPLETION_KIND_CLASS: {
 			if (has_theme_icon(p_option.display, SNAME("EditorIcons"))) {
 				tex = get_theme_icon(p_option.display, SNAME("EditorIcons"));
 			} else {
 				tex = get_theme_icon(SNAME("Object"), SNAME("EditorIcons"));
 			}
 		} break;
-		case ScriptCodeCompletionOption::KIND_ENUM:
+		case ScriptLanguage::CODE_COMPLETION_KIND_ENUM:
 			tex = get_theme_icon(SNAME("Enum"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_FILE_PATH:
+		case ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH:
 			tex = get_theme_icon(SNAME("File"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_NODE_PATH:
+		case ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH:
 			tex = get_theme_icon(SNAME("NodePath"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_VARIABLE:
+		case ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE:
 			tex = get_theme_icon(SNAME("Variant"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_CONSTANT:
+		case ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT:
 			tex = get_theme_icon(SNAME("MemberConstant"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_MEMBER:
+		case ScriptLanguage::CODE_COMPLETION_KIND_MEMBER:
 			tex = get_theme_icon(SNAME("MemberProperty"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_SIGNAL:
+		case ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL:
 			tex = get_theme_icon(SNAME("MemberSignal"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_FUNCTION:
+		case ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION:
 			tex = get_theme_icon(SNAME("MemberMethod"), SNAME("EditorIcons"));
 			break;
-		case ScriptCodeCompletionOption::KIND_PLAIN_TEXT:
+		case ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT:
 			tex = get_theme_icon(SNAME("BoxMesh"), SNAME("EditorIcons"));
 			break;
 		default:

editor/code_editor.h

@@ -134,7 +134,7 @@ public:
 	FindReplaceBar();
 };
 
-typedef void (*CodeTextEditorCodeCompleteFunc)(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_forced);
+typedef void (*CodeTextEditorCodeCompleteFunc)(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced);
 
 class CodeTextEditor : public VBoxContainer {
 	GDCLASS(CodeTextEditor, VBoxContainer);
@@ -166,7 +166,7 @@ class CodeTextEditor : public VBoxContainer {
 
 	void _update_text_editor_theme();
 	void _complete_request();
-	Ref<Texture2D> _get_completion_icon(const ScriptCodeCompletionOption &p_option);
+	Ref<Texture2D> _get_completion_icon(const ScriptLanguage::CodeCompletionOption &p_option);
 	void _font_resize_timeout();
 	bool _add_font_size(int p_delta);
 
@@ -197,7 +197,7 @@ class CodeTextEditor : public VBoxContainer {
 protected:
 	virtual void _load_theme_settings() {}
 	virtual void _validate_script() {}
-	virtual void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) {}
+	virtual void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) {}
 
 	void _text_changed_idle_timeout();
 	void _code_complete_timer_timeout();

editor/editor_file_system.cpp

@@ -888,7 +888,7 @@ void EditorFileSystem::_scan_new_dir(EditorFileSystemDirectory *p_dir, DirAccess
 				if (script == nullptr) {
 					continue;
 				}
-				const Vector<DocData::ClassDoc> &docs = script->get_documentation();
+				Vector<DocData::ClassDoc> docs = script->get_documentation();
 				for (int j = 0; j < docs.size(); j++) {
 					EditorHelp::get_doc_data()->add_doc(docs[j]);
 				}

editor/plugins/script_editor_plugin.cpp

@@ -1348,7 +1348,7 @@ void ScriptEditor::_menu_option(int p_option) {
 				}
 
 				if (script != nullptr) {
-					const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+					Vector<DocData::ClassDoc> documentations = script->get_documentation();
 					for (int j = 0; j < documentations.size(); j++) {
 						const DocData::ClassDoc &doc = documentations.get(j);
 						if (EditorHelp::get_doc_data()->has_doc(doc.name)) {
@@ -1361,7 +1361,7 @@ void ScriptEditor::_menu_option(int p_option) {
 				EditorNode::get_singleton()->save_resource_as(resource);
 
 				if (script != nullptr) {
-					const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+					Vector<DocData::ClassDoc> documentations = script->get_documentation();
 					for (int j = 0; j < documentations.size(); j++) {
 						const DocData::ClassDoc &doc = documentations.get(j);
 						EditorHelp::get_doc_data()->add_doc(doc);
@@ -2464,7 +2464,7 @@ void ScriptEditor::save_current_script() {
 	}
 
 	if (script != nullptr) {
-		const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+		Vector<DocData::ClassDoc> documentations = script->get_documentation();
 		for (int j = 0; j < documentations.size(); j++) {
 			const DocData::ClassDoc &doc = documentations.get(j);
 			if (EditorHelp::get_doc_data()->has_doc(doc.name)) {
@@ -2486,7 +2486,7 @@ void ScriptEditor::save_current_script() {
 	}
 
 	if (script != nullptr) {
-		const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+		Vector<DocData::ClassDoc> documentations = script->get_documentation();
 		for (int j = 0; j < documentations.size(); j++) {
 			const DocData::ClassDoc &doc = documentations.get(j);
 			EditorHelp::get_doc_data()->add_doc(doc);
@@ -2537,7 +2537,7 @@ void ScriptEditor::save_all_scripts() {
 			}
 
 			if (script != nullptr) {
-				const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+				Vector<DocData::ClassDoc> documentations = script->get_documentation();
 				for (int j = 0; j < documentations.size(); j++) {
 					const DocData::ClassDoc &doc = documentations.get(j);
 					if (EditorHelp::get_doc_data()->has_doc(doc.name)) {
@@ -2549,7 +2549,7 @@ void ScriptEditor::save_all_scripts() {
 			EditorNode::get_singleton()->save_resource(edited_res); //external script, save it
 
 			if (script != nullptr) {
-				const Vector<DocData::ClassDoc> &documentations = script->get_documentation();
+				Vector<DocData::ClassDoc> documentations = script->get_documentation();
 				for (int j = 0; j < documentations.size(); j++) {
 					const DocData::ClassDoc &doc = documentations.get(j);
 					EditorHelp::get_doc_data()->add_doc(doc);

editor/plugins/script_text_editor.cpp

@@ -684,12 +684,12 @@ void ScriptEditor::_update_modified_scripts_for_external_editor(Ref<Script> p_fo
 	}
 }
 
-void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) {
+void ScriptTextEditor::_code_complete_scripts(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force) {
 	ScriptTextEditor *ste = (ScriptTextEditor *)p_ud;
 	ste->_code_complete_script(p_code, r_options, r_force);
 }
 
-void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force) {
+void ScriptTextEditor::_code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force) {
 	if (color_panel->is_visible()) {
 		return;
 	}
@@ -771,7 +771,7 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c
 		_goto_line(p_row);
 
 		switch (result.type) {
-			case ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION: {
+			case ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION: {
 				if (result.script.is_valid()) {
 					emit_signal(SNAME("request_open_script_at_line"), result.script, result.location - 1);
 				} else {
@@ -779,10 +779,10 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c
 					goto_line_centered(result.location - 1);
 				}
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS: {
 				emit_signal(SNAME("go_to_help"), "class_name:" + result.class_name);
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT: {
 				StringName cname = result.class_name;
 				bool success;
 				while (true) {
@@ -798,11 +798,11 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c
 				emit_signal(SNAME("go_to_help"), "class_constant:" + result.class_name + ":" + result.class_member);
 
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY: {
 				emit_signal(SNAME("go_to_help"), "class_property:" + result.class_name + ":" + result.class_member);
 
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS_METHOD: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD: {
 				StringName cname = result.class_name;
 
 				while (true) {
@@ -817,7 +817,7 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c
 				emit_signal(SNAME("go_to_help"), "class_method:" + result.class_name + ":" + result.class_member);
 
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS_ENUM: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM: {
 				StringName cname = result.class_name;
 				StringName success;
 				while (true) {
@@ -833,9 +833,11 @@ void ScriptTextEditor::_lookup_symbol(const String &p_symbol, int p_row, int p_c
 				emit_signal(SNAME("go_to_help"), "class_enum:" + result.class_name + ":" + result.class_member);
 
 			} break;
-			case ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE: {
+			case ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE: {
 				emit_signal(SNAME("go_to_help"), "class_global:" + result.class_name + ":" + result.class_member);
 			} break;
+			default: {
+			}
 		}
 	} else if (ProjectSettings::get_singleton()->has_autoload(p_symbol)) {
 		// Check for Autoload scenes.

editor/plugins/script_text_editor.h

@@ -162,8 +162,8 @@ protected:
 	void _update_bookmark_list();
 	void _bookmark_item_pressed(int p_idx);
 
-	static void _code_complete_scripts(void *p_ud, const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force);
+	static void _code_complete_scripts(void *p_ud, const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force);
-	void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options, bool &r_force);
+	void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_force);
 
 	void _load_theme_settings();
 	void _set_theme_for_script();

editor/plugins/shader_editor_plugin.cpp

@@ -222,7 +222,7 @@ static ShaderLanguage::DataType _get_global_variable_type(const StringName &p_va
 	return (ShaderLanguage::DataType)RS::global_variable_type_get_shader_datatype(gvt);
 }
 
-void ShaderTextEditor::_code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) {
+void ShaderTextEditor::_code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) {
 	_check_shader_mode();
 
 	ShaderLanguage sl;

editor/plugins/shader_editor_plugin.h

@@ -65,7 +65,7 @@ protected:
 	static void _bind_methods();
 	virtual void _load_theme_settings() override;
 
-	virtual void _code_complete_script(const String &p_code, List<ScriptCodeCompletionOption> *r_options) override;
+	virtual void _code_complete_script(const String &p_code, List<ScriptLanguage::CodeCompletionOption> *r_options) override;
 
 public:
 	virtual void _validate_script() override;

modules/gdscript/gdscript.h

@@ -212,7 +212,7 @@ public:
 	virtual void update_exports() override;
 
 #ifdef TOOLS_ENABLED
-	virtual const Vector<DocData::ClassDoc> &get_documentation() const override {
+	virtual Vector<DocData::ClassDoc> get_documentation() const override {
 		return docs;
 	}
 #endif // TOOLS_ENABLED
@@ -455,7 +455,7 @@ public:
 	virtual bool can_inherit_from_file() const override { return true; }
 	virtual int find_function(const String &p_function, const String &p_code) const override;
 	virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override;
-	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) override;
+	virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) override;
 #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) override;
 #endif

modules/gdscript/gdscript_editor.cpp

@@ -637,11 +637,11 @@ static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_functio
 	return arghint;
 }
 
-static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptCodeCompletionOption> &r_list) {
+static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String, ScriptLanguage::CodeCompletionOption> &r_list) {
 	const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
 
 	for (int i = 0; i < p_dir->get_file_count(); i++) {
-		ScriptCodeCompletionOption option(p_dir->get_file_path(i), ScriptCodeCompletionOption::KIND_FILE_PATH);
+		ScriptLanguage::CodeCompletionOption option(p_dir->get_file_path(i), ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH);
 		option.insert_text = option.display.quote(quote_style);
 		r_list.insert(option.display, option);
 	}
@@ -651,29 +651,29 @@ static void _get_directory_contents(EditorFileSystemDirectory *p_dir, Map<String
 	}
 }
 
-static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, Map<String, ScriptCodeCompletionOption> &r_result) {
+static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_annotation, int p_argument, const String p_quote_style, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	if (p_annotation->name == SNAME("@export_range")) {
 		if (p_argument == 3 || p_argument == 4) {
 			// Slider hint.
-			ScriptCodeCompletionOption slider1("or_greater", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption slider1("or_greater", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			slider1.insert_text = slider1.display.quote(p_quote_style);
 			r_result.insert(slider1.display, slider1);
-			ScriptCodeCompletionOption slider2("or_lesser", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption slider2("or_lesser", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			slider2.insert_text = slider2.display.quote(p_quote_style);
 			r_result.insert(slider2.display, slider2);
 		}
 	} else if (p_annotation->name == SNAME("@export_exp_easing")) {
 		if (p_argument == 0 || p_argument == 1) {
 			// Easing hint.
-			ScriptCodeCompletionOption hint1("attenuation", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption hint1("attenuation", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			hint1.insert_text = hint1.display.quote(p_quote_style);
 			r_result.insert(hint1.display, hint1);
-			ScriptCodeCompletionOption hint2("inout", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption hint2("inout", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			hint2.insert_text = hint2.display.quote(p_quote_style);
 			r_result.insert(hint2.display, hint2);
 		}
 	} else if (p_annotation->name == SNAME("@export_node_path")) {
-		ScriptCodeCompletionOption node("Node", ScriptCodeCompletionOption::KIND_CLASS);
+		ScriptLanguage::CodeCompletionOption node("Node", ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 		r_result.insert(node.display, node);
 		List<StringName> node_types;
 		ClassDB::get_inheriters_from_class("Node", &node_types);
@@ -681,23 +681,23 @@ static void _find_annotation_arguments(const GDScriptParser::AnnotationNode *p_a
 			if (!ClassDB::is_class_exposed(E)) {
 				continue;
 			}
-			ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS);
+			ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 			r_result.insert(option.display, option);
 		}
 	} else if (p_annotation->name == SNAME("@warning_ignore")) {
 		for (int warning_code = 0; warning_code < GDScriptWarning::WARNING_MAX; warning_code++) {
-			ScriptCodeCompletionOption warning(GDScriptWarning::get_name_from_code((GDScriptWarning::Code)warning_code).to_lower(), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption warning(GDScriptWarning::get_name_from_code((GDScriptWarning::Code)warning_code).to_lower(), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			r_result.insert(warning.display, warning);
 		}
 	}
 }
 
-static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, Map<String, ScriptCodeCompletionOption> &r_result) {
+static void _list_available_types(bool p_inherit_only, GDScriptParser::CompletionContext &p_context, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	List<StringName> native_types;
 	ClassDB::get_class_list(&native_types);
 	for (const StringName &E : native_types) {
 		if (ClassDB::is_class_exposed(E) && !Engine::get_singleton()->has_singleton(E)) {
-			ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS);
+			ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 			r_result.insert(option.display, option);
 		}
 	}
@@ -708,7 +708,7 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 			List<StringName> enums;
 			ClassDB::get_enum_list(p_context.current_class->base_type.native_type, &enums);
 			for (const StringName &E : enums) {
-				ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_ENUM);
+				ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 				r_result.insert(option.display, option);
 			}
 		}
@@ -719,18 +719,18 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 				const GDScriptParser::ClassNode::Member &member = current->members[i];
 				switch (member.type) {
 					case GDScriptParser::ClassNode::Member::CLASS: {
-						ScriptCodeCompletionOption option(member.m_class->identifier->name, ScriptCodeCompletionOption::KIND_CLASS);
+						ScriptLanguage::CodeCompletionOption option(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 						r_result.insert(option.display, option);
 					} break;
 					case GDScriptParser::ClassNode::Member::ENUM: {
 						if (!p_inherit_only) {
-							ScriptCodeCompletionOption option(member.m_enum->identifier->name, ScriptCodeCompletionOption::KIND_ENUM);
+							ScriptLanguage::CodeCompletionOption option(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 							r_result.insert(option.display, option);
 						}
 					} break;
 					case GDScriptParser::ClassNode::Member::CONSTANT: {
 						if (member.constant->get_datatype().is_meta_type && p_context.current_class->outer != nullptr) {
-							ScriptCodeCompletionOption option(member.constant->identifier->name, ScriptCodeCompletionOption::KIND_CLASS);
+							ScriptLanguage::CodeCompletionOption option(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 							r_result.insert(option.display, option);
 						}
 					} break;
@@ -746,7 +746,7 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 	List<StringName> global_classes;
 	ScriptServer::get_global_class_list(&global_classes);
 	for (const StringName &E : global_classes) {
-		ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CLASS);
+		ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 		r_result.insert(option.display, option);
 	}
 
@@ -757,19 +757,19 @@ static void _list_available_types(bool p_inherit_only, GDScriptParser::Completio
 		if (!info.is_singleton || info.path.get_extension().to_lower() != "gd") {
 			continue;
 		}
-		ScriptCodeCompletionOption option(info.name, ScriptCodeCompletionOption::KIND_CLASS);
+		ScriptLanguage::CodeCompletionOption option(info.name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 		r_result.insert(option.display, option);
 	}
 }
 
-static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, Map<String, ScriptCodeCompletionOption> &r_result) {
+static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	for (int i = 0; i < p_suite->locals.size(); i++) {
-		ScriptCodeCompletionOption option;
+		ScriptLanguage::CodeCompletionOption option;
 		if (p_suite->locals[i].type == GDScriptParser::SuiteNode::Local::CONSTANT) {
-			option = ScriptCodeCompletionOption(p_suite->locals[i].name, ScriptCodeCompletionOption::KIND_CONSTANT);
+			option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 			option.default_value = p_suite->locals[i].constant->initializer->reduced_value;
 		} else {
-			option = ScriptCodeCompletionOption(p_suite->locals[i].name, ScriptCodeCompletionOption::KIND_VARIABLE);
+			option = ScriptLanguage::CodeCompletionOption(p_suite->locals[i].name, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE);
 		}
 		r_result.insert(option.display, option);
 	}
@@ -778,9 +778,9 @@ static void _find_identifiers_in_suite(const GDScriptParser::SuiteNode *p_suite,
 	}
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth);
+static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth);
 
-static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class, bool p_only_functions, bool p_static, bool p_parent_only, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
 
 	if (!p_parent_only) {
@@ -789,13 +789,13 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 		while (clss) {
 			for (int i = 0; i < clss->members.size(); i++) {
 				const GDScriptParser::ClassNode::Member &member = clss->members[i];
-				ScriptCodeCompletionOption option;
+				ScriptLanguage::CodeCompletionOption option;
 				switch (member.type) {
 					case GDScriptParser::ClassNode::Member::VARIABLE:
 						if (p_only_functions || outer || (p_static)) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.variable->identifier->name, ScriptCodeCompletionOption::KIND_MEMBER);
+						option = ScriptLanguage::CodeCompletionOption(member.variable->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 						break;
 					case GDScriptParser::ClassNode::Member::CONSTANT:
 						if (p_only_functions) {
@@ -804,7 +804,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 						if (r_result.has(member.constant->identifier->name)) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.constant->identifier->name, ScriptCodeCompletionOption::KIND_CONSTANT);
+						option = ScriptLanguage::CodeCompletionOption(member.constant->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 						if (member.constant->initializer) {
 							option.default_value = member.constant->initializer->reduced_value;
 						}
@@ -813,25 +813,25 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 						if (p_only_functions) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.m_class->identifier->name, ScriptCodeCompletionOption::KIND_CLASS);
+						option = ScriptLanguage::CodeCompletionOption(member.m_class->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 						break;
 					case GDScriptParser::ClassNode::Member::ENUM_VALUE:
 						if (p_only_functions) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.enum_value.identifier->name, ScriptCodeCompletionOption::KIND_CONSTANT);
+						option = ScriptLanguage::CodeCompletionOption(member.enum_value.identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 						break;
 					case GDScriptParser::ClassNode::Member::ENUM:
 						if (p_only_functions) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.m_enum->identifier->name, ScriptCodeCompletionOption::KIND_ENUM);
+						option = ScriptLanguage::CodeCompletionOption(member.m_enum->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 						break;
 					case GDScriptParser::ClassNode::Member::FUNCTION:
 						if (outer || (p_static && !member.function->is_static) || member.function->identifier->name.operator String().begins_with("@")) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.function->identifier->name, ScriptCodeCompletionOption::KIND_FUNCTION);
+						option = ScriptLanguage::CodeCompletionOption(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 						if (member.function->parameters.size() > 0) {
 							option.insert_text += "(";
 						} else {
@@ -842,7 +842,7 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 						if (p_only_functions || outer) {
 							continue;
 						}
-						option = ScriptCodeCompletionOption(member.signal->identifier->name, ScriptCodeCompletionOption::KIND_SIGNAL);
+						option = ScriptLanguage::CodeCompletionOption(member.signal->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL);
 						break;
 					case GDScriptParser::ClassNode::Member::UNDEFINED:
 						break;
@@ -862,14 +862,14 @@ static void _find_identifiers_in_class(const GDScriptParser::ClassNode *p_class,
 	_find_identifiers_in_base(base_type, p_only_functions, r_result, p_recursion_depth + 1);
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	ERR_FAIL_COND(p_recursion_depth > COMPLETION_RECURSION_LIMIT);
 
 	GDScriptParser::DataType base_type = p_base.type;
 	bool _static = base_type.is_meta_type;
 
 	if (_static && base_type.kind != GDScriptParser::DataType::BUILTIN) {
-		ScriptCodeCompletionOption option("new", ScriptCodeCompletionOption::KIND_FUNCTION);
+		ScriptLanguage::CodeCompletionOption option("new", ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 		option.insert_text += "(";
 		r_result.insert(option.display, option);
 	}
@@ -889,21 +889,21 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 							List<PropertyInfo> members;
 							scr->get_script_property_list(&members);
 							for (const PropertyInfo &E : members) {
-								ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER);
+								ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 								r_result.insert(option.display, option);
 							}
 						}
 						Map<StringName, Variant> constants;
 						scr->get_constants(&constants);
 						for (const KeyValue<StringName, Variant> &E : constants) {
-							ScriptCodeCompletionOption option(E.key.operator String(), ScriptCodeCompletionOption::KIND_CONSTANT);
+							ScriptLanguage::CodeCompletionOption option(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 							r_result.insert(option.display, option);
 						}
 
 						List<MethodInfo> signals;
 						scr->get_script_signal_list(&signals);
 						for (const MethodInfo &E : signals) {
-							ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_SIGNAL);
+							ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL);
 							r_result.insert(option.display, option);
 						}
 					}
@@ -914,7 +914,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 						if (E.name.begins_with("@")) {
 							continue;
 						}
-						ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION);
+						ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 						if (E.arguments.size()) {
 							option.insert_text += "(";
 						} else {
@@ -944,7 +944,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 					List<String> constants;
 					ClassDB::get_integer_constant_list(type, &constants);
 					for (const String &E : constants) {
-						ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CONSTANT);
+						ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 						r_result.insert(option.display, option);
 					}
 
@@ -958,7 +958,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 							if (E.name.contains("/")) {
 								continue;
 							}
-							ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER);
+							ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 							r_result.insert(option.display, option);
 						}
 					}
@@ -971,7 +971,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 						if (E.name.begins_with("_")) {
 							continue;
 						}
-						ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION);
+						ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 						if (E.arguments.size()) {
 							option.insert_text += "(";
 						} else {
@@ -1001,7 +1001,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 
 					for (const PropertyInfo &E : members) {
 						if (!String(E.name).contains("/")) {
-							ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_MEMBER);
+							ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 							r_result.insert(option.display, option);
 						}
 					}
@@ -1010,7 +1010,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 				List<MethodInfo> methods;
 				tmp.get_method_list(&methods);
 				for (const MethodInfo &E : methods) {
-					ScriptCodeCompletionOption option(E.name, ScriptCodeCompletionOption::KIND_FUNCTION);
+					ScriptLanguage::CodeCompletionOption option(E.name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 					if (E.arguments.size()) {
 						option.insert_text += "(";
 					} else {
@@ -1028,7 +1028,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionIdentifier &p_base
 	}
 }
 
-static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result, int p_recursion_depth) {
+static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool p_only_functions, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, int p_recursion_depth) {
 	if (!p_only_functions && p_context.current_suite) {
 		// This includes function parameters, since they are also locals.
 		_find_identifiers_in_suite(p_context.current_suite, r_result);
@@ -1043,7 +1043,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 
 	for (const StringName &E : functions) {
 		MethodInfo function = GDScriptUtilityFunctions::get_function_info(E);
-		ScriptCodeCompletionOption option(String(E), ScriptCodeCompletionOption::KIND_FUNCTION);
+		ScriptLanguage::CodeCompletionOption option(String(E), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 		if (function.arguments.size() || (function.flags & METHOD_FLAG_VARARG)) {
 			option.insert_text += "(";
 		} else {
@@ -1064,7 +1064,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 	static_assert((sizeof(_type_names) / sizeof(*_type_names)) == Variant::VARIANT_MAX, "Completion for builtin types is incomplete");
 
 	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
-		ScriptCodeCompletionOption option(_type_names[i], ScriptCodeCompletionOption::KIND_CLASS);
+		ScriptLanguage::CodeCompletionOption option(_type_names[i], ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 		r_result.insert(option.display, option);
 	}
 
@@ -1076,7 +1076,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 
 	const char **kw = _keywords;
 	while (*kw) {
-		ScriptCodeCompletionOption option(*kw, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+		ScriptLanguage::CodeCompletionOption option(*kw, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 		r_result.insert(option.display, option);
 		kw++;
 	}
@@ -1089,7 +1089,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 
 	const char **kws = _keywords_with_space;
 	while (*kws) {
-		ScriptCodeCompletionOption option(*kws, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+		ScriptLanguage::CodeCompletionOption option(*kws, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 		option.insert_text += " ";
 		r_result.insert(option.display, option);
 		kws++;
@@ -1102,7 +1102,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 
 	const char **kwa = _keywords_with_args;
 	while (*kwa) {
-		ScriptCodeCompletionOption option(*kwa, ScriptCodeCompletionOption::KIND_FUNCTION);
+		ScriptLanguage::CodeCompletionOption option(*kwa, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 		option.insert_text += "(";
 		r_result.insert(option.display, option);
 		kwa++;
@@ -1112,7 +1112,7 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 	Variant::get_utility_function_list(&utility_func_names);
 
 	for (List<StringName>::Element *E = utility_func_names.front(); E; E = E->next()) {
-		ScriptCodeCompletionOption option(E->get(), ScriptCodeCompletionOption::KIND_FUNCTION);
+		ScriptLanguage::CodeCompletionOption option(E->get(), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 		option.insert_text += "(";
 		r_result.insert(option.display, option);
 	}
@@ -1122,17 +1122,17 @@ static void _find_identifiers(GDScriptParser::CompletionContext &p_context, bool
 		if (!E.value().is_singleton) {
 			continue;
 		}
-		ScriptCodeCompletionOption option(E.key(), ScriptCodeCompletionOption::KIND_CONSTANT);
+		ScriptLanguage::CodeCompletionOption option(E.key(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 		r_result.insert(option.display, option);
 	}
 
 	// Native classes and global constants.
 	for (const KeyValue<StringName, int> &E : GDScriptLanguage::get_singleton()->get_global_map()) {
-		ScriptCodeCompletionOption option;
+		ScriptLanguage::CodeCompletionOption option;
 		if (ClassDB::class_exists(E.key) || Engine::get_singleton()->has_singleton(E.key)) {
-			option = ScriptCodeCompletionOption(E.key.operator String(), ScriptCodeCompletionOption::KIND_CLASS);
+			option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CLASS);
 		} else {
-			option = ScriptCodeCompletionOption(E.key.operator String(), ScriptCodeCompletionOption::KIND_CONSTANT);
+			option = ScriptLanguage::CodeCompletionOption(E.key.operator String(), ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 		}
 		r_result.insert(option.display, option);
 	}
@@ -2210,20 +2210,20 @@ static bool _guess_method_return_type_from_base(GDScriptParser::CompletionContex
 	return false;
 }
 
-static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, Map<String, ScriptCodeCompletionOption> &r_result) {
+static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_context, const String &p_enum_hint, Map<String, ScriptLanguage::CodeCompletionOption> &r_result) {
 	if (!p_enum_hint.contains(".")) {
 		// Global constant or in the current class.
 		StringName current_enum = p_enum_hint;
 		if (p_context.current_class && p_context.current_class->has_member(current_enum) && p_context.current_class->get_member(current_enum).type == GDScriptParser::ClassNode::Member::ENUM) {
 			const GDScriptParser::EnumNode *_enum = p_context.current_class->get_member(current_enum).m_enum;
 			for (int i = 0; i < _enum->values.size(); i++) {
-				ScriptCodeCompletionOption option(_enum->values[i].identifier->name, ScriptCodeCompletionOption::KIND_ENUM);
+				ScriptLanguage::CodeCompletionOption option(_enum->values[i].identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 				r_result.insert(option.display, option);
 			}
 		} else {
 			for (int i = 0; i < CoreConstants::get_global_constant_count(); i++) {
 				if (CoreConstants::get_global_constant_enum(i) == current_enum) {
-					ScriptCodeCompletionOption option(CoreConstants::get_global_constant_name(i), ScriptCodeCompletionOption::KIND_ENUM);
+					ScriptLanguage::CodeCompletionOption option(CoreConstants::get_global_constant_name(i), ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 					r_result.insert(option.display, option);
 				}
 			}
@@ -2240,13 +2240,13 @@ static void _find_enumeration_candidates(GDScriptParser::CompletionContext &p_co
 		ClassDB::get_enum_constants(class_name, enum_name, &enum_constants);
 		for (const StringName &E : enum_constants) {
 			String candidate = class_name + "." + E;
-			ScriptCodeCompletionOption option(candidate, ScriptCodeCompletionOption::KIND_ENUM);
+			ScriptLanguage::CodeCompletionOption option(candidate, ScriptLanguage::CODE_COMPLETION_KIND_ENUM);
 			r_result.insert(option.display, option);
 		}
 	}
 }
 
-static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptCodeCompletionOption> &r_result, String &r_arghint) {
+static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, String &r_arghint) {
 	Variant base = p_base.value;
 	GDScriptParser::DataType base_type = p_base.type;
 
@@ -2287,7 +2287,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 								if (opt.is_quoted()) {
 									opt = opt.unquote().quote(quote_style); // Handle user preference.
 								}
-								ScriptCodeCompletionOption option(opt, ScriptCodeCompletionOption::KIND_FUNCTION);
+								ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 								r_result.insert(option.display, option);
 							}
 						}
@@ -2314,7 +2314,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 							continue;
 						}
 						String name = s.get_slice("/", 1);
-						ScriptCodeCompletionOption option("/root/" + name, ScriptCodeCompletionOption::KIND_NODE_PATH);
+						ScriptLanguage::CodeCompletionOption option("/root/" + name, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
 						option.insert_text = option.display.quote(quote_style);
 						r_result.insert(option.display, option);
 					}
@@ -2330,7 +2330,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 							continue;
 						}
 						String name = s.get_slice("/", 1);
-						ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_CONSTANT);
+						ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 						option.insert_text = option.display.quote(quote_style);
 						r_result.insert(option.display, option);
 					}
@@ -2365,7 +2365,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 	}
 }
 
-static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, Map<String, ScriptCodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
+static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, const GDScriptParser::Node *p_call, int p_argidx, Map<String, ScriptLanguage::CodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
 	if (p_call->type == GDScriptParser::Node::PRELOAD) {
 		if (p_argidx == 0 && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) {
 			_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result);
@@ -2444,7 +2444,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 	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) {
+::Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
 	const String quote_style = EDITOR_GET("text_editor/completion/use_single_quotes") ? "'" : "\"";
 
 	GDScriptParser parser;
@@ -2454,7 +2454,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 	analyzer.analyze();
 
 	r_forced = false;
-	Map<String, ScriptCodeCompletionOption> options;
+	Map<String, ScriptLanguage::CodeCompletionOption> options;
 
 	GDScriptParser::CompletionContext completion_context = parser.get_completion_context();
 	completion_context.base = p_owner;
@@ -2467,7 +2467,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 			List<MethodInfo> annotations;
 			parser.get_annotation_list(&annotations);
 			for (const MethodInfo &E : annotations) {
-				ScriptCodeCompletionOption option(E.name.substr(1), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				ScriptLanguage::CodeCompletionOption option(E.name.substr(1), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 				if (E.arguments.size() > 0) {
 					option.insert_text += "(";
 				}
@@ -2487,7 +2487,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 			List<StringName> constants;
 			Variant::get_constants_for_type(completion_context.builtin_type, &constants);
 			for (const StringName &E : constants) {
-				ScriptCodeCompletionOption option(E, ScriptCodeCompletionOption::KIND_CONSTANT);
+				ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 				bool valid = false;
 				Variant default_value = Variant::get_constant_value(completion_context.builtin_type, E, &valid);
 				if (valid) {
@@ -2501,7 +2501,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 			r_forced = true;
 		} break;
 		case GDScriptParser::COMPLETION_TYPE_NAME_OR_VOID: {
-			ScriptCodeCompletionOption option("void", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption option("void", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(option.display, option);
 		}
 			[[fallthrough]];
@@ -2511,16 +2511,16 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 		} break;
 		case GDScriptParser::COMPLETION_PROPERTY_DECLARATION_OR_TYPE: {
 			_list_available_types(false, completion_context, options);
-			ScriptCodeCompletionOption get("get", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(get.display, get);
-			ScriptCodeCompletionOption set("set", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(set.display, set);
 			r_forced = true;
 		} break;
 		case GDScriptParser::COMPLETION_PROPERTY_DECLARATION: {
-			ScriptCodeCompletionOption get("get", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption get("get", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(get.display, get);
-			ScriptCodeCompletionOption set("set", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+			ScriptLanguage::CodeCompletionOption set("set", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 			options.insert(set.display, set);
 			r_forced = true;
 		} break;
@@ -2536,7 +2536,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 				if (member.function->is_static) {
 					continue;
 				}
-				ScriptCodeCompletionOption option(member.function->identifier->name, ScriptCodeCompletionOption::KIND_FUNCTION);
+				ScriptLanguage::CodeCompletionOption option(member.function->identifier->name, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 				options.insert(option.display, option);
 			}
 			r_forced = true;
@@ -2706,7 +2706,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 				}
 				method_hint += ":";
 
-				ScriptCodeCompletionOption option(method_hint, ScriptCodeCompletionOption::KIND_FUNCTION);
+				ScriptLanguage::CodeCompletionOption option(method_hint, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 				options.insert(option.display, option);
 			}
 		} break;
@@ -2729,7 +2729,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 					if (!opt.replace("/", "_").is_valid_identifier()) {
 						opt = opt.quote(quote_style); // Handle user preference.
 					}
-					ScriptCodeCompletionOption option(opt, ScriptCodeCompletionOption::KIND_NODE_PATH);
+					ScriptLanguage::CodeCompletionOption option(opt, ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
 					options.insert(option.display, option);
 				}
 
@@ -2738,7 +2738,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 
 				for (OrderedHashMap<StringName, ProjectSettings::AutoloadInfo>::Element E = autoloads.front(); E; E = E.next()) {
 					String path = "/root/" + E.key();
-					ScriptCodeCompletionOption option(path.quote(quote_style), ScriptCodeCompletionOption::KIND_NODE_PATH);
+					ScriptLanguage::CodeCompletionOption option(path.quote(quote_style), ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH);
 					options.insert(option.display, option);
 				}
 			}
@@ -2751,7 +2751,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 		} break;
 	}
 
-	for (const KeyValue<String, ScriptCodeCompletionOption> &E : options) {
+	for (const KeyValue<String, ScriptLanguage::CodeCompletionOption> &E : options) {
 		r_options->push_back(E.value);
 	}
 
@@ -2760,7 +2760,7 @@ static void _find_call_arguments(GDScriptParser::CompletionContext &p_context, c
 
 #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) {
+Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptLanguage::CodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
 	return OK;
 }
 
@@ -2859,7 +2859,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 			case GDScriptParser::DataType::CLASS: {
 				if (base_type.class_type) {
 					if (base_type.class_type->has_member(p_symbol)) {
-						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
 						r_result.location = base_type.class_type->get_member(p_symbol).get_line();
 						r_result.class_path = base_type.script_path;
 						r_result.script = GDScriptCache::get_shallow_script(r_result.class_path);
@@ -2873,7 +2873,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				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.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
 						r_result.location = line;
 						r_result.script = scr;
 						return OK;
@@ -2897,7 +2897,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				}
 
 				if (ClassDB::has_method(class_name, p_symbol, true)) {
-					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+					r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
 					r_result.class_name = base_type.native_type;
 					r_result.class_member = p_symbol;
 					return OK;
@@ -2907,7 +2907,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				ClassDB::get_virtual_methods(class_name, &virtual_methods, true);
 				for (const MethodInfo &E : virtual_methods) {
 					if (E.name == p_symbol) {
-						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+						r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
 						r_result.class_name = base_type.native_type;
 						r_result.class_member = p_symbol;
 						return OK;
@@ -2916,7 +2916,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 
 				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.type = ScriptLanguage::LOOKUP_RESULT_CLASS_ENUM;
 					r_result.class_name = base_type.native_type;
 					r_result.class_member = enum_name;
 					return OK;
@@ -2926,7 +2926,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				ClassDB::get_integer_constant_list(class_name, &constants, true);
 				for (const String &E : constants) {
 					if (E == p_symbol) {
-						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+						r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
 						r_result.class_name = base_type.native_type;
 						r_result.class_member = p_symbol;
 						return OK;
@@ -2934,7 +2934,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				}
 
 				if (ClassDB::has_property(class_name, p_symbol, true)) {
-					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+					r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY;
 					r_result.class_name = base_type.native_type;
 					r_result.class_member = p_symbol;
 					return OK;
@@ -2951,7 +2951,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				base_type.kind = GDScriptParser::DataType::UNRESOLVED;
 
 				if (Variant::has_constant(base_type.builtin_type, p_symbol)) {
-					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+					r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
 					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
 					r_result.class_member = p_symbol;
 					return OK;
@@ -2971,7 +2971,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				}
 
 				if (v.has_method(p_symbol)) {
-					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+					r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
 					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
 					r_result.class_member = p_symbol;
 					return OK;
@@ -2980,7 +2980,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				bool valid = false;
 				v.get(p_symbol, &valid);
 				if (valid) {
-					r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_PROPERTY;
+					r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_PROPERTY;
 					r_result.class_name = Variant::get_type_name(base_type.builtin_type);
 					r_result.class_member = p_symbol;
 					return OK;
@@ -2998,7 +2998,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 ::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.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
 		r_result.class_name = p_symbol;
 		return OK;
 	}
@@ -3006,21 +3006,21 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 	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.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
 			r_result.class_name = Variant::get_type_name(t);
 			return OK;
 		}
 	}
 
 	if (GDScriptUtilityFunctions::function_exists(p_symbol)) {
-		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
+		r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_METHOD;
 		r_result.class_name = "@GDScript";
 		r_result.class_member = p_symbol;
 		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.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
 		r_result.class_name = "@GDScript";
 		r_result.class_member = p_symbol;
 		return OK;
@@ -3037,7 +3037,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 		bool success = false;
 		ClassDB::get_integer_constant(context.current_class->extends[0], p_symbol, &success);
 		if (success) {
-			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+			r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
 			r_result.class_name = context.current_class->extends[0];
 			r_result.class_member = p_symbol;
 			return OK;
@@ -3048,7 +3048,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 
 	switch (context.type) {
 		case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
-			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
+			r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_CONSTANT;
 			r_result.class_name = Variant::get_type_name(context.builtin_type);
 			r_result.class_member = p_symbol;
 			return OK;
@@ -3076,7 +3076,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 				const GDScriptParser::SuiteNode *suite = context.current_suite;
 				while (suite) {
 					if (suite->has_local(p_symbol)) {
-						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+						r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
 						r_result.location = suite->get_local(p_symbol).start_line;
 						return OK;
 					}
@@ -3101,7 +3101,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 						}
 
 						if (FileAccess::exists(script)) {
-							r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
+							r_result.type = ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION;
 							r_result.location = 0;
 							r_result.script = ResourceLoader::load(script);
 							return OK;
@@ -3117,10 +3117,10 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 						Object *obj = value;
 						if (obj) {
 							if (Object::cast_to<GDScriptNativeClass>(obj)) {
-								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+								r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
 								r_result.class_name = Object::cast_to<GDScriptNativeClass>(obj)->get_name();
 							} else {
-								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
+								r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS;
 								r_result.class_name = obj->get_class();
 							}
 
@@ -3137,18 +3137,18 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 						// Otherwise these codes would work
 						StringName enumName = ClassDB::get_integer_constant_enum("@GlobalScope", p_symbol, true);
 						if (enumName != nullptr) {
-							r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_ENUM;
+							r_result.type = ScriptLanguage::LOOKUP_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.type = ScriptLanguage::LOOKUP_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.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE;
 						r_result.class_name = "@GlobalScope";
 						r_result.class_member = p_symbol;
 						return OK;
@@ -3157,7 +3157,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					List<StringName> utility_functions;
 					Variant::get_utility_function_list(&utility_functions);
 					if (utility_functions.find(p_symbol) != nullptr) {
-						r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_TBD_GLOBALSCOPE;
+						r_result.type = ScriptLanguage::LOOKUP_RESULT_CLASS_TBD_GLOBALSCOPE;
 						r_result.class_name = "@GlobalScope";
 						r_result.class_member = p_symbol;
 						return OK;

modules/gdscript/language_server/gdscript_text_document.cpp

@@ -166,49 +166,51 @@ Array GDScriptTextDocument::completion(const Dictionary &p_params) {
 	params.load(p_params);
 	Dictionary request_data = params.to_json();
 
-	List<ScriptCodeCompletionOption> options;
+	List<ScriptLanguage::CodeCompletionOption> options;
 	GDScriptLanguageProtocol::get_singleton()->get_workspace()->completion(params, &options);
 
 	if (!options.is_empty()) {
 		int i = 0;
 		arr.resize(options.size());
 
-		for (const ScriptCodeCompletionOption &option : options) {
+		for (const ScriptLanguage::CodeCompletionOption &option : options) {
 			lsp::CompletionItem item;
 			item.label = option.display;
 			item.data = request_data;
 
 			switch (option.kind) {
-				case ScriptCodeCompletionOption::KIND_ENUM:
+				case ScriptLanguage::CODE_COMPLETION_KIND_ENUM:
 					item.kind = lsp::CompletionItemKind::Enum;
 					break;
-				case ScriptCodeCompletionOption::KIND_CLASS:
+				case ScriptLanguage::CODE_COMPLETION_KIND_CLASS:
 					item.kind = lsp::CompletionItemKind::Class;
 					break;
-				case ScriptCodeCompletionOption::KIND_MEMBER:
+				case ScriptLanguage::CODE_COMPLETION_KIND_MEMBER:
 					item.kind = lsp::CompletionItemKind::Property;
 					break;
-				case ScriptCodeCompletionOption::KIND_FUNCTION:
+				case ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION:
 					item.kind = lsp::CompletionItemKind::Method;
 					break;
-				case ScriptCodeCompletionOption::KIND_SIGNAL:
+				case ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL:
 					item.kind = lsp::CompletionItemKind::Event;
 					break;
-				case ScriptCodeCompletionOption::KIND_CONSTANT:
+				case ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT:
 					item.kind = lsp::CompletionItemKind::Constant;
 					break;
-				case ScriptCodeCompletionOption::KIND_VARIABLE:
+				case ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE:
 					item.kind = lsp::CompletionItemKind::Variable;
 					break;
-				case ScriptCodeCompletionOption::KIND_FILE_PATH:
+				case ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH:
 					item.kind = lsp::CompletionItemKind::File;
 					break;
-				case ScriptCodeCompletionOption::KIND_NODE_PATH:
+				case ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH:
 					item.kind = lsp::CompletionItemKind::Snippet;
 					break;
-				case ScriptCodeCompletionOption::KIND_PLAIN_TEXT:
+				case ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT:
 					item.kind = lsp::CompletionItemKind::Text;
 					break;
+				default: {
+				}
 			}
 
 			arr[i] = item.to_json();

modules/gdscript/language_server/gdscript_workspace.cpp

@@ -571,7 +571,7 @@ Node *GDScriptWorkspace::_get_owner_scene_node(String p_path) {
 	return owner_scene_node;
 }
 
-void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options) {
+void GDScriptWorkspace::completion(const lsp::CompletionParams &p_params, List<ScriptLanguage::CodeCompletionOption> *r_options) {
 	String path = get_file_path(p_params.textDocument.uri);
 	String call_hint;
 	bool forced = false;
@@ -638,7 +638,7 @@ const lsp::DocumentSymbol *GDScriptWorkspace::resolve_symbol(const lsp::TextDocu
 					symbol_identifier = "_init";
 				}
 				if (OK == GDScriptLanguage::get_singleton()->lookup_code(parser->get_text_for_lookup_symbol(pos, symbol_identifier, p_func_required), symbol_identifier, path, nullptr, ret)) {
-					if (ret.type == ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION) {
+					if (ret.type == ScriptLanguage::LOOKUP_RESULT_SCRIPT_LOCATION) {
 						String target_script_path = path;
 						if (!ret.script.is_null()) {
 							target_script_path = ret.script->get_path();

modules/gdscript/language_server/gdscript_workspace.h

@@ -85,7 +85,7 @@ public:
 	String get_file_uri(const String &p_path) const;
 
 	void publish_diagnostics(const String &p_path);
-	void completion(const lsp::CompletionParams &p_params, List<ScriptCodeCompletionOption> *r_options);
+	void completion(const lsp::CompletionParams &p_params, List<ScriptLanguage::CodeCompletionOption> *r_options);
 
 	const lsp::DocumentSymbol *resolve_symbol(const lsp::TextDocumentPositionParams &p_doc_pos, const String &p_symbol_name = "", bool p_func_required = false);
 	void resolve_related_symbols(const lsp::TextDocumentPositionParams &p_doc_pos, List<const lsp::DocumentSymbol *> &r_list);

modules/mono/csharp_script.h

@@ -202,9 +202,9 @@ public:
 	void set_source_code(const String &p_code) override;
 
 #ifdef TOOLS_ENABLED
-	virtual const Vector<DocData::ClassDoc> &get_documentation() const override {
+	virtual Vector<DocData::ClassDoc> get_documentation() const override {
 		// TODO
-		static Vector<DocData::ClassDoc> docs;
+		Vector<DocData::ClassDoc> docs;
 		return docs;
 	}
 #endif // TOOLS_ENABLED

modules/visual_script/visual_script.h

@@ -338,8 +338,8 @@ public:
 	virtual Error reload(bool p_keep_state = false) override;
 
 #ifdef TOOLS_ENABLED
-	virtual const Vector<DocData::ClassDoc> &get_documentation() const override {
+	virtual Vector<DocData::ClassDoc> get_documentation() const override {
-		static Vector<DocData::ClassDoc> docs;
+		Vector<DocData::ClassDoc> docs;
 		return docs;
 	}
 #endif // TOOLS_ENABLED

scene/gui/code_edit.cpp

@@ -1782,10 +1782,10 @@ void CodeEdit::request_code_completion(bool p_force) {
 	/* Don't re-query if all existing options are quoted types, eg path, signal. */
 	bool ignored = code_completion_active && !code_completion_options.is_empty();
 	if (ignored) {
-		ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_PLAIN_TEXT;
+		ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT;
-		const ScriptCodeCompletionOption *previous_option = nullptr;
+		const ScriptLanguage::CodeCompletionOption *previous_option = nullptr;
 		for (int i = 0; i < code_completion_options.size(); i++) {
-			const ScriptCodeCompletionOption &current_option = code_completion_options[i];
+			const ScriptLanguage::CodeCompletionOption &current_option = code_completion_options[i];
 			if (!previous_option) {
 				previous_option = &current_option;
 				kind = current_option.kind;
@@ -1795,7 +1795,7 @@ void CodeEdit::request_code_completion(bool p_force) {
 				break;
 			}
 		}
-		ignored = ignored && (kind == ScriptCodeCompletionOption::KIND_FILE_PATH || kind == ScriptCodeCompletionOption::KIND_NODE_PATH || kind == ScriptCodeCompletionOption::KIND_SIGNAL);
+		ignored = ignored && (kind == ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL);
 	}
 
 	if (ignored) {
@@ -1818,8 +1818,8 @@ void CodeEdit::request_code_completion(bool p_force) {
 }
 
 void CodeEdit::add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color, const RES &p_icon, const Variant &p_value) {
-	ScriptCodeCompletionOption completion_option;
+	ScriptLanguage::CodeCompletionOption completion_option;
-	completion_option.kind = (ScriptCodeCompletionOption::Kind)p_type;
+	completion_option.kind = (ScriptLanguage::CodeCompletionKind)p_type;
 	completion_option.display = p_display_text;
 	completion_option.insert_text = p_insert_text;
 	completion_option.font_color = p_text_color;
@@ -2702,7 +2702,7 @@ void CodeEdit::_filter_code_completion_candidates_impl() {
 		TypedArray<Dictionary> completion_options_sources;
 		completion_options_sources.resize(code_completion_option_sources.size());
 		int i = 0;
-		for (const ScriptCodeCompletionOption &E : code_completion_option_sources) {
+		for (const ScriptLanguage::CodeCompletionOption &E : code_completion_option_sources) {
 			Dictionary option;
 			option["kind"] = E.kind;
 			option["display_text"] = E.display;
@@ -2727,8 +2727,8 @@ void CodeEdit::_filter_code_completion_candidates_impl() {
 		/* Convert back into options. */
 		int max_width = 0;
 		for (i = 0; i < completion_options.size(); i++) {
-			ScriptCodeCompletionOption option;
+			ScriptLanguage::CodeCompletionOption option;
-			option.kind = (ScriptCodeCompletionOption::Kind)(int)completion_options[i].get("kind");
+			option.kind = (ScriptLanguage::CodeCompletionKind)(int)completion_options[i].get("kind");
 			option.display = completion_options[i].get("display_text");
 			option.insert_text = completion_options[i].get("insert_text");
 			option.font_color = completion_options[i].get("font_color");
@@ -2821,15 +2821,15 @@ void CodeEdit::_filter_code_completion_candidates_impl() {
 	code_completion_options.clear();
 	code_completion_base = string_to_complete;
 
-	Vector<ScriptCodeCompletionOption> completion_options_casei;
+	Vector<ScriptLanguage::CodeCompletionOption> completion_options_casei;
-	Vector<ScriptCodeCompletionOption> completion_options_substr;
+	Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr;
-	Vector<ScriptCodeCompletionOption> completion_options_substr_casei;
+	Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr_casei;
-	Vector<ScriptCodeCompletionOption> completion_options_subseq;
+	Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq;
-	Vector<ScriptCodeCompletionOption> completion_options_subseq_casei;
+	Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq_casei;
 
 	int max_width = 0;
 	String string_to_complete_lower = string_to_complete.to_lower();
-	for (ScriptCodeCompletionOption &option : code_completion_option_sources) {
+	for (ScriptLanguage::CodeCompletionOption &option : code_completion_option_sources) {
 		if (single_quote && option.display.is_quoted()) {
 			option.display = option.display.unquote().quote("'");
 		}

scene/gui/code_edit.h

@@ -38,7 +38,7 @@ class CodeEdit : public TextEdit {
 
 public:
 	/* Keep enum in sync with:                                           */
-	/* /core/object/script_language.h - ScriptCodeCompletionOption::Kind */
+	/* /core/object/script_language.h - ScriptLanguage::CodeCompletionKind */
 	enum CodeCompletionKind {
 		KIND_CLASS,
 		KIND_FUNCTION,
@@ -208,15 +208,15 @@ private:
 	Color code_completion_existing_color = Color(0, 0, 0, 0);
 
 	bool code_completion_active = false;
-	Vector<ScriptCodeCompletionOption> code_completion_options;
+	Vector<ScriptLanguage::CodeCompletionOption> code_completion_options;
 	int code_completion_line_ofs = 0;
 	int code_completion_current_selected = 0;
 	int code_completion_longest_line = 0;
 	Rect2i code_completion_rect;
 
 	Set<char32_t> code_completion_prefixes;
-	List<ScriptCodeCompletionOption> code_completion_option_submitted;
+	List<ScriptLanguage::CodeCompletionOption> code_completion_option_submitted;
-	List<ScriptCodeCompletionOption> code_completion_option_sources;
+	List<ScriptLanguage::CodeCompletionOption> code_completion_option_sources;
 	String code_completion_base;
 
 	void _filter_code_completion_candidates_impl();

scene/gui/range.cpp

@@ -282,7 +282,7 @@ void Range::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "allow_greater"), "set_allow_greater", "is_greater_allowed");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "allow_lesser"), "set_allow_lesser", "is_lesser_allowed");
 
-	GDVIRTUAL_BIND(_value_changed);
+	GDVIRTUAL_BIND(_value_changed, "new_value");
 
 	ADD_LINKED_PROPERTY("min_value", "value");
 	ADD_LINKED_PROPERTY("min_value", "max_value");

servers/extensions/SCsub

@@ -2,11 +2,6 @@
 
 Import("env")
 
-import make_wrappers
-from platform_methods import run_in_subprocess
-
-env.CommandNoCache(["ext_wrappers.gen.inc"], "make_wrappers.py", run_in_subprocess(make_wrappers.run))
-
 env_object = env.Clone()
 
 env_object.add_source_files(env.servers_sources, "*.cpp")

servers/extensions/physics_server_3d_extension.h

@@ -31,11 +31,11 @@
 #ifndef PHYSICS_SERVER_3D_EXTENSION_H
 #define PHYSICS_SERVER_3D_EXTENSION_H
 
+#include "core/extension/ext_wrappers.gen.inc"
 #include "core/object/script_language.h"
 #include "core/variant/native_ptr.h"
 #include "core/variant/type_info.h"
 #include "core/variant/typed_array.h"
-#include "servers/extensions/ext_wrappers.gen.inc"
 #include "servers/physics_server_3d.h"
 
 class PhysicsDirectBodyState3DExtension : public PhysicsDirectBodyState3D {

servers/rendering/shader_language.cpp

@@ -9034,7 +9034,7 @@ Error ShaderLanguage::compile(const String &p_code, const ShaderCompileInfo &p_i
 	return OK;
 }
 
-Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint) {
+Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint) {
 	clear();
 
 	code = p_code;
@@ -9053,7 +9053,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 		} break;
 		case COMPLETION_SHADER_TYPE: {
 			for (const String &shader_type : p_info.shader_types) {
-				ScriptCodeCompletionOption option(shader_type, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				ScriptLanguage::CodeCompletionOption option(shader_type, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 				r_options->push_back(option);
 			}
 			return OK;
@@ -9073,7 +9073,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 
 					if (!found) {
 						for (int j = 0; j < info.options.size(); j++) {
-							ScriptCodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+							ScriptLanguage::CodeCompletionOption option(String(info.name) + "_" + String(info.options[j]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 							r_options->push_back(option);
 						}
 					}
@@ -9081,7 +9081,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 					const String name = String(info.name);
 
 					if (!shader->render_modes.has(name)) {
-						ScriptCodeCompletionOption option(name, ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+						ScriptLanguage::CodeCompletionOption option(name, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 						r_options->push_back(option);
 					}
 				}
@@ -9093,7 +9093,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 			if (shader->structs.has(completion_struct)) {
 				StructNode *node = shader->structs[completion_struct].shader_struct;
 				for (int i = 0; i < node->members.size(); i++) {
-					ScriptCodeCompletionOption option(node->members[i]->name, ScriptCodeCompletionOption::KIND_MEMBER);
+					ScriptLanguage::CodeCompletionOption option(node->members[i]->name, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 					r_options->push_back(option);
 				}
 			}
@@ -9115,7 +9115,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 				if (found) {
 					continue;
 				}
-				ScriptCodeCompletionOption option(E.key, ScriptCodeCompletionOption::KIND_FUNCTION);
+				ScriptLanguage::CodeCompletionOption option(E.key, ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 				r_options->push_back(option);
 			}
 
@@ -9124,7 +9124,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 		case COMPLETION_IDENTIFIER:
 		case COMPLETION_FUNCTION_CALL: {
 			bool comp_ident = completion_type == COMPLETION_IDENTIFIER;
-			Map<String, ScriptCodeCompletionOption::Kind> matches;
+			Map<String, ScriptLanguage::CodeCompletionKind> matches;
 			StringName skip_function;
 			BlockNode *block = completion_block;
 
@@ -9133,7 +9133,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 					if (comp_ident) {
 						for (const KeyValue<StringName, BlockNode::Variable> &E : block->variables) {
 							if (E.value.line < completion_line) {
-								matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE);
+								matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE);
 							}
 						}
 					}
@@ -9141,7 +9141,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 					if (block->parent_function) {
 						if (comp_ident) {
 							for (int i = 0; i < block->parent_function->arguments.size(); i++) {
-								matches.insert(block->parent_function->arguments[i].name, ScriptCodeCompletionOption::KIND_VARIABLE);
+								matches.insert(block->parent_function->arguments[i].name, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE);
 							}
 						}
 						skip_function = block->parent_function->name;
@@ -9152,9 +9152,9 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 				if (comp_ident) {
 					if (p_info.functions.has("global")) {
 						for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["global"].built_ins) {
-							ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
+							ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
 							if (E.value.constant) {
-								kind = ScriptCodeCompletionOption::KIND_CONSTANT;
+								kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
 							}
 							matches.insert(E.key, kind);
 						}
@@ -9162,9 +9162,9 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 
 					if (p_info.functions.has("constants")) {
 						for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions["constants"].built_ins) {
-							ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
+							ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
 							if (E.value.constant) {
-								kind = ScriptCodeCompletionOption::KIND_CONSTANT;
+								kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
 							}
 							matches.insert(E.key, kind);
 						}
@@ -9172,22 +9172,22 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 
 					if (skip_function != StringName() && p_info.functions.has(skip_function)) {
 						for (const KeyValue<StringName, BuiltInInfo> &E : p_info.functions[skip_function].built_ins) {
-							ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_MEMBER;
+							ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_MEMBER;
 							if (E.value.constant) {
-								kind = ScriptCodeCompletionOption::KIND_CONSTANT;
+								kind = ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT;
 							}
 							matches.insert(E.key, kind);
 						}
 					}
 
 					for (const KeyValue<StringName, ShaderNode::Constant> &E : shader->constants) {
-						matches.insert(E.key, ScriptCodeCompletionOption::KIND_CONSTANT);
+						matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_CONSTANT);
 					}
 					for (const KeyValue<StringName, ShaderNode::Varying> &E : shader->varyings) {
-						matches.insert(E.key, ScriptCodeCompletionOption::KIND_VARIABLE);
+						matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_VARIABLE);
 					}
 					for (const KeyValue<StringName, ShaderNode::Uniform> &E : shader->uniforms) {
-						matches.insert(E.key, ScriptCodeCompletionOption::KIND_MEMBER);
+						matches.insert(E.key, ScriptLanguage::CODE_COMPLETION_KIND_MEMBER);
 					}
 				}
 
@@ -9195,7 +9195,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 					if (!shader->functions[i].callable || shader->functions[i].name == skip_function) {
 						continue;
 					}
-					matches.insert(String(shader->functions[i].name), ScriptCodeCompletionOption::KIND_FUNCTION);
+					matches.insert(String(shader->functions[i].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 				}
 
 				int idx = 0;
@@ -9203,7 +9203,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 
 				if (stages && stages->has(skip_function)) {
 					for (const KeyValue<StringName, StageFunctionInfo> &E : (*stages)[skip_function].stage_functions) {
-						matches.insert(String(E.key), ScriptCodeCompletionOption::KIND_FUNCTION);
+						matches.insert(String(E.key), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 					}
 				}
 
@@ -9212,7 +9212,7 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 						idx++;
 						continue;
 					}
-					matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
+					matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 					idx++;
 				}
 
@@ -9226,15 +9226,15 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 						continue;
 					}
 					if (builtin_func_defs[idx].tag == completion_class) {
-						matches.insert(String(builtin_func_defs[idx].name), ScriptCodeCompletionOption::KIND_FUNCTION);
+						matches.insert(String(builtin_func_defs[idx].name), ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION);
 					}
 					idx++;
 				}
 			}
 
-			for (const KeyValue<String, ScriptCodeCompletionOption::Kind> &E : matches) {
+			for (const KeyValue<String, ScriptLanguage::CodeCompletionKind> &E : matches) {
-				ScriptCodeCompletionOption option(E.key, E.value);
+				ScriptLanguage::CodeCompletionOption option(E.key, E.value);
-				if (E.value == ScriptCodeCompletionOption::KIND_FUNCTION) {
+				if (E.value == ScriptLanguage::CODE_COMPLETION_KIND_FUNCTION) {
 					option.insert_text += "(";
 				}
 				r_options->push_back(option);
@@ -9483,18 +9483,18 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 			}
 
 			for (int i = 0; i < limit; i++) {
-				r_options->push_back(ScriptCodeCompletionOption(String::chr(colv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
+				r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(colv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT));
-				r_options->push_back(ScriptCodeCompletionOption(String::chr(coordv[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
+				r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordv[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT));
-				r_options->push_back(ScriptCodeCompletionOption(String::chr(coordt[i]), ScriptCodeCompletionOption::KIND_PLAIN_TEXT));
+				r_options->push_back(ScriptLanguage::CodeCompletionOption(String::chr(coordt[i]), ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT));
 			}
 
 		} break;
 		case COMPLETION_HINT: {
 			if (completion_base == DataType::TYPE_VEC4) {
-				ScriptCodeCompletionOption option("hint_color", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				ScriptLanguage::CodeCompletionOption option("hint_color", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 				r_options->push_back(option);
 			} else if ((completion_base == DataType::TYPE_INT || completion_base == DataType::TYPE_FLOAT) && !completion_base_array) {
-				ScriptCodeCompletionOption option("hint_range", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				ScriptLanguage::CodeCompletionOption option("hint_range", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 
 				if (completion_base == DataType::TYPE_INT) {
 					option.insert_text = "hint_range(0, 100, 1)";
@@ -9530,12 +9530,12 @@ Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_
 				}
 
 				for (int i = 0; i < options.size(); i++) {
-					ScriptCodeCompletionOption option(options[i], ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+					ScriptLanguage::CodeCompletionOption option(options[i], ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 					r_options->push_back(option);
 				}
 			}
 			if (!completion_base_array) {
-				ScriptCodeCompletionOption option("instance_index", ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
+				ScriptLanguage::CodeCompletionOption option("instance_index", ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
 				option.insert_text = "instance_index(0)";
 				r_options->push_back(option);
 			}

servers/rendering/shader_language.h

@@ -1091,7 +1091,7 @@ public:
 	};
 
 	Error compile(const String &p_code, const ShaderCompileInfo &p_info);
-	Error complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptCodeCompletionOption> *r_options, String &r_call_hint);
+	Error complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint);
 
 	String get_error_text();
 	int get_error_line();