feat: rework script api implementation for gdextension

Author: piiertho

src/api/language/gdj_language.cpp

@@ -4,8 +4,8 @@
 #include "api/script/language/gdj_script.h"
 #include "godot_jvm.h"
 #include "jvm/wrapper/memory/memory_manager.h"
-#include "lifecycle/paths.h"
 #include "names.h"
+#include "paths.h"
 
 using namespace godot;
 
@@ -28,114 +28,108 @@ GdjLanguage* GdjLanguage::get_instance() {
     return instance;
 }
 
-void GdjLanguage::init() {
+void GdjLanguage::_init() {
     GodotJvm::get_instance().initialize_up_to(GodotJvm::State::JVM_SCRIPTS_INITIALIZED);
 
 #ifdef DEBUG_ENABLED
     GodotJvm::get_instance().validate_state();
 #endif
 }
 
-void GdjLanguage::frame() {
+void GdjLanguage::_frame() {
     if (unlikely(GodotJvm::get_instance().state < GodotJvm::State::CORE_LIBRARY_INITIALIZED)) { return; }
     if (unlikely(GodotJvm::get_instance().user_configuration.disable_gc)) { return; }
 
     jni::Env env {jni::Jvm::current_env()};
     MemoryManager::get_instance().sync_memory(env);
 }
 
-void GdjLanguage::finish() {
+void GdjLanguage::_finish() {
     GodotJvm::get_instance().finalize_down_to(GodotJvm::State::NOT_STARTED);
 }
 
-void GdjLanguage::thread_enter() {
+void GdjLanguage::_thread_enter() {
     jni::Jvm::attach();
 }
 
-void GdjLanguage::thread_exit() {
+void GdjLanguage::_thread_exit() {
     jni::Jvm::detach();
 }
 
-String GdjLanguage::get_name() const {
+String GdjLanguage::_get_name() const {
     return GODOT_JVM_LANGUAGE_NAME;
 }
 
-String GdjLanguage::get_type() const {
+String GdjLanguage::_get_type() const {
     return GODOT_JVM_SCRIPT_NAME;
 }
 
-String GdjLanguage::get_extension() const {
+String GdjLanguage::_get_extension() const {
     return GODOT_JVM_REGISTRATION_FILE_EXTENSION;
 }
 
-void GdjLanguage::get_recognized_extensions(List<String>* p_extensions) const {
-    p_extensions->push_back(GODOT_JVM_REGISTRATION_FILE_EXTENSION);
+PackedStringArray GdjLanguage::_get_recognized_extensions() const {
+    PackedStringArray ret;
+    ret.append(GODOT_JVM_REGISTRATION_FILE_EXTENSION);
+    return ret;
 }
 
-bool GdjLanguage::handles_global_class_type(const String& p_type) const {
+bool GdjLanguage::_handles_global_class_type(const String& p_type) const {
     return p_type == GODOT_JVM_SCRIPT_NAME;
 }
 
-bool GdjLanguage::has_named_classes() const {
+bool GdjLanguage::_has_named_classes() const {
     return true;
 }
 
-bool GdjLanguage::supports_builtin_mode() const {
-    return false;
-}
-
-Script* GdjLanguage::create_script() const {
+Object* GdjLanguage::_create_script() const {
     return memnew(GdjScript);
 }
 
-String GdjLanguage::get_global_class_name(const String& p_path, String* r_base_type, String* r_icon_path, bool *r_is_abstract, bool *r_is_tool) const {
-    if (p_path.begins_with(ENTRY_DIRECTORY) || !p_path.ends_with(GODOT_JVM_REGISTRATION_FILE_EXTENSION)) { return {}; }
-
-    if(r_is_abstract){
-        *r_is_abstract = false;
-    }
-    if(r_is_tool){
-        *r_is_tool = false;
+Dictionary GdjLanguage::_get_global_class_name(const String& p_path) const {
+    Dictionary ret;
+    if (p_path.begins_with(ENTRY_DIRECTORY) || !p_path.ends_with(GODOT_JVM_REGISTRATION_FILE_EXTENSION)) {
+        return ret;
     }
 
+    ret["is_abstract"] = false;
+    ret["is_tool"] = false;
+
     String script_name = JvmScript::get_script_file_name(p_path);
     Ref<NamedScript> named_script = JvmScriptManager::get_instance()->get_script_from_name(script_name);
     if (!named_script.is_null() && named_script.is_valid()) {
-        if (r_base_type) {
-            if (named_script->get_base_script().is_null()) {
-                *r_base_type = named_script->get_instance_base_type();
-            } else {
-                *r_base_type = named_script->get_base_script()->get_global_name();
-            }
-        }
-        return named_script->get_global_name();
+        ret["base_type"] = named_script->get_base_script().is_null()
+                           ? named_script->get_instance_base_type()
+                           : named_script->get_base_script()->get_global_name();
+        ret["name"] = named_script->get_global_name();
     }
 
-    return {};
+    return ret;
 }
 
-Vector<String> GdjLanguage::get_reserved_words() const {
-    static const Vector<String> ret = {
-        "registeredName",
-        "fqName",
-        "relativeSourcePath ",
-        "baseType ",
-        "supertypes",
-        "signals",
-        "properties",
-        "functions"
+PackedStringArray GdjLanguage::_get_reserved_words() const {
+    static PackedStringArray reserved_words {
+      "registeredName",
+      "fqName",
+      "relativeSourcePath ",
+      "baseType ",
+      "supertypes",
+      "signals",
+      "properties",
+      "functions"
     };
-
-    return ret;
+    return reserved_words;
 }
 
-bool GdjLanguage::is_control_flow_keyword(const String& p_keyword) const {
+bool GdjLanguage::_is_control_flow_keyword(const String& p_keyword) const {
     return false;
 }
 
-Vector<String> GdjLanguage::get_comment_delimiters() const {
-    static const Vector<String> ret = {"//"};
-    return ret;
+PackedStringArray GdjLanguage::_get_comment_delimiters() const {
+    static PackedStringArray delimiters {
+      "//"
+    };
+    return delimiters;
 }
 
 Vector<String> GdjLanguage::get_doc_comment_delimiters() const {return {};}
@@ -151,12 +145,4 @@ Ref<Script> GdjLanguage::make_template(const String& p_template, const String& p
     gdj_script->set_source_code(processed_template);
     gdj_script->set_name(p_class_name);
     return gdj_script;
-}
-
-Vector<ScriptLanguage::ScriptTemplate> GdjLanguage::get_built_in_templates(const StringName& p_object) {
-    return {};
-}
-
-bool GdjLanguage::is_using_templates() {
-    return false;
 }

src/api/language/gdj_language.h

@@ -12,32 +12,29 @@ namespace godot {
 
         static GdjLanguage* get_instance();
 
-        void init() override;
-        void frame() override;
-        void finish() override;
-
-        void thread_enter() override;
-        void thread_exit() override;
-
-        String get_name() const override;
-        String get_type() const override;
-        String get_extension() const override;
-        void get_recognized_extensions(List<String>* p_extensions) const override;
-
-        bool handles_global_class_type(const String& p_type) const override;
-        String get_global_class_name(const String& p_path, String* r_base_type, String* r_icon_path, bool* r_is_abstract = nullptr, bool* r_is_tool = nullptr) const override;
-        bool has_named_classes() const override;
-        bool supports_builtin_mode() const override;
-        Script* create_script() const override;
-
-    Vector<String> get_reserved_words() const override;
-    bool is_control_flow_keyword(const String& p_keyword) const override;
-    Vector<String> get_comment_delimiters() const override;
-    Vector<String> get_doc_comment_delimiters() const override;
-    Vector<String> get_string_delimiters() const override;
-    Ref<Script> make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const override;
-    Vector<ScriptTemplate> get_built_in_templates(const StringName& p_object) override;
-    bool is_using_templates() override;
-};
-
+        void _init() override;
+        void _frame() override;
+        void _finish() override;
+
+        void _thread_enter() override;
+        void _thread_exit() override;
+
+        String _get_name() const override;
+        String _get_type() const override;
+        String _get_extension() const override;
+        PackedStringArray _get_recognized_extensions() const override;
+
+        bool _handles_global_class_type(const String& p_type) const override;
+        Dictionary _get_global_class_name(const String& p_path) const override;
+        bool _has_named_classes() const override;
+        Object* _create_script() const override;
+
+        PackedStringArray _get_reserved_words() const override;
+        bool _is_control_flow_keyword(const String& p_keyword) const override;
+        PackedStringArray _get_comment_delimiters() const override;
+        void get_doc_comment_delimiters(List<String>* p_delimiters) const override;
+        void get_string_delimiters(List<String>* p_delimiters) const override;
+        Ref<Script> _make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const override;
+    };
+}
 #endif// GODOT_JVM_GDJ_LANGUAGE_H

src/api/language/java_language.cpp

@@ -3,7 +3,7 @@
 #include "names.h"
 #include "api/script/language/java_script.h"
 
-#include <core/io/resource_loader.hpp>
+#include <classes/resource_loader.hpp>
 
 using namespace godot;
 
@@ -41,24 +41,27 @@ JavaLanguage* JavaLanguage::get_instance() {
     return instance;
 }
 
-String JavaLanguage::get_name() const {
+String JavaLanguage::_get_name() const {
     return GODOT_JAVA_LANGUAGE_NAME;
 }
 
-String JavaLanguage::get_type() const {
+String JavaLanguage::_get_type() const {
     return GODOT_JAVA_SCRIPT_NAME;
 }
 
-String JavaLanguage::get_extension() const {
+String JavaLanguage::_get_extension() const {
     return GODOT_JAVA_SCRIPT_EXTENSION;
 }
 
-void JavaLanguage::get_recognized_extensions(List<String>* p_extensions) const {
-    p_extensions->push_back(GODOT_JAVA_SCRIPT_EXTENSION);
+PackedStringArray JavaLanguage::_get_recognized_extensions() const {
+    static PackedStringArray extensions {
+      GODOT_JAVA_SCRIPT_EXTENSION
+    };
+    return extensions;
 }
 
 Vector<String> JavaLanguage::get_reserved_words() const {
-    static const Vector<String> ret = {
+    return {
         "abstract",
         "assert",
         "boolean",
@@ -109,32 +112,39 @@ Vector<String> JavaLanguage::get_reserved_words() const {
         "volatile",
         "while"
     };
-
-    return ret;
+    return reserved_words;
 }
 
-bool JavaLanguage::is_control_flow_keyword(const String& p_keyword) const {
+bool JavaLanguage::_is_control_flow_keyword(const String& p_keyword) const {
     return p_keyword == "break" || p_keyword == "catch" || p_keyword == "continue" || p_keyword == "do"
         || p_keyword == "else" || p_keyword == "finally" || p_keyword == "for" || p_keyword == "if" || p_keyword == "return"
         || p_keyword == "when" || p_keyword == "throw" || p_keyword == "try" || p_keyword == "while";
 }
 
-Vector<String> JavaLanguage::get_comment_delimiters() const {
-    static const Vector<String> ret = {"//", "/* */"};
-    return ret;
+PackedStringArray JavaLanguage::_get_comment_delimiters() const {
+    static PackedStringArray delimiters {
+      "//",
+      "/* */"
+    };
+    return delimiters;
 }
 
-Vector<String> JavaLanguage::get_doc_comment_delimiters() const {
-    static const Vector<String> ret = {"/** */"};
-    return ret;
+PackedStringArray JavaLanguage::_get_doc_comment_delimiters() const {
+    PackedStringArray delimiters {
+      "/** */"
+    };
+    return delimiters;
 }
 
-Vector<String> JavaLanguage::get_string_delimiters() const {
-    static const Vector<String> ret = {"' '", "\" \""};
-    return ret;
+PackedStringArray JavaLanguage::_get_string_delimiters() const {
+    PackedStringArray delimiters {
+      "' '",
+      "\" \""
+    };
+    return delimiters;
 }
 
-Ref<Script> JavaLanguage::make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const {
+Ref<Script> JavaLanguage::_make_template(const String& p_template, const String& p_class_name, const String& p_base_class_name) const {
     Ref<JavaScript> java_script;
     java_script.instantiate();
     String processed_template {p_template.replace(CLASS_TEMPLATE, p_class_name.to_pascal_case())};
@@ -143,40 +153,23 @@ Ref<Script> JavaLanguage::make_template(const String& p_template, const String&
     return java_script;
 }
 
-Vector<ScriptLanguage::ScriptTemplate> JavaLanguage::get_built_in_templates(const StringName& p_object) {
-    Vector<ScriptLanguage::ScriptTemplate> templates;
+TypedArray<Dictionary> JavaLanguage::_get_built_in_templates(const StringName& p_object) const {
+    TypedArray<Dictionary> templates;
     if (ClassDB::is_parent_class(p_object, "Node")) {
-        ScriptLanguage::ScriptTemplate script_template {
-          String(p_object),
-          String("Default"),
-          String("Base template for Node based scripts with default Godot cycle methods"),
-          String(JAVA_TEMPLATE).replace(BASE_TEMPLATE, p_object)
-        };
+        Dictionary script_template;
+        script_template["inherit"] = String(p_object);
+        script_template["name"] = "Default";
+        script_template["description"] = "Base template for Node based scripts with default Godot cycle methods";
+        script_template["content"] = String(JAVA_TEMPLATE).replace(BASE_TEMPLATE, p_object);
         templates.append(script_template);
     }
     return templates;
 }
 
-bool JavaLanguage::is_using_templates() {
+bool JavaLanguage::_is_using_templates() {
     return true;
 }
 
-Script* JavaLanguage::create_script() const {
+Object* JavaLanguage::_create_script() const {
     return memnew(JavaScript);
-}
-
-bool JavaLanguage::has_named_classes() const {
-    return false;
-}
-
-bool JavaLanguage::supports_builtin_mode() const {
-    return false;
-}
-
-String JavaLanguage::get_global_class_name(const String& p_path, String* r_base_type, String* r_icon_path, bool *r_is_abstract, bool *r_is_too) const {
-    return {};
-}
-
-bool JavaLanguage::handles_global_class_type(const String& p_type) const {
-    return false;
 }