From 5f98714fa176be7f8730a4da80dd94a95e5e4080 Mon Sep 17 00:00:00 2001
From: Jovan Gerodetti <jovan.gerodetti@titannano.de>
Date: Fri, 17 Jan 2025 00:46:29 +0100
Subject: [PATCH] Provide safe way for implementing
 IScriptExtension::instance_has

---
 .../special_cases/codegen_special_cases.rs    |   2 +
 godot-core/src/obj/script.rs                  |  41 ++++-
 itest/godot/ScriptInstanceTests.gd            |  56 +++++--
 .../script/script_instance_tests.rs           | 147 +++++++++++++++++-
 4 files changed, 225 insertions(+), 21 deletions(-)

diff --git a/godot-codegen/src/special_cases/codegen_special_cases.rs b/godot-codegen/src/special_cases/codegen_special_cases.rs
index 7e0eadfa5..a05352382 100644
--- a/godot-codegen/src/special_cases/codegen_special_cases.rs
+++ b/godot-codegen/src/special_cases/codegen_special_cases.rs
@@ -173,7 +173,9 @@ const SELECTED_CLASSES: &[&str] = &[
     "SceneTreeTimer",
     "Script",
     "ScriptExtension",
+    "ScriptNameCasing",
     "ScriptLanguage",
+    "ScriptLanguageExtension",
     "Sprite2D",
     "SpriteFrames",
     "TextServer",
diff --git a/godot-core/src/obj/script.rs b/godot-core/src/obj/script.rs
index bbbfe3527..9b3d954cd 100644
--- a/godot-core/src/obj/script.rs
+++ b/godot-core/src/obj/script.rs
@@ -25,7 +25,7 @@ use godot_cell::panicking::{GdCell, MutGuard, RefGuard};
 use godot_cell::blocking::{GdCell, MutGuard, RefGuard};
 
 use crate::builtin::{GString, StringName, Variant, VariantType};
-use crate::classes::{Script, ScriptLanguage};
+use crate::classes::{Object, Script, ScriptLanguage};
 use crate::meta::{MethodInfo, PropertyInfo};
 use crate::obj::{Base, Gd, GodotClass};
 use crate::sys;
@@ -33,6 +33,11 @@ use crate::sys;
 #[cfg(before_api = "4.3")]
 use self::bounded_ptr_list::BoundedPtrList;
 
+#[cfg(since_api = "4.2")]
+use crate::classes::IScriptExtension;
+#[cfg(since_api = "4.2")]
+use crate::obj::Inherits;
+
 /// Implement custom scripts that can be attached to objects in Godot.
 ///
 /// To use script instances, implement this trait for your own type.
@@ -337,6 +342,40 @@ pub unsafe fn create_script_instance<T: ScriptInstance>(
     }
 }
 
+/// Checks if an instance of the script exists for a given object.
+///
+/// This function both checks if the passed script matches the one currently assigned to the passed object, as well as verifies that
+/// there is an instance for the script.
+///
+/// Use this function to implement [`IScriptExtension::instance_has`](crate::classes::IScriptExtension::instance_has).
+#[cfg(since_api = "4.2")]
+pub fn script_instance_exists<O, S>(object: &Gd<O>, script: &Gd<S>) -> bool
+where
+    O: Inherits<Object>,
+    S: Inherits<Script> + IScriptExtension + super::Bounds<Declarer = super::bounds::DeclUser>,
+{
+    let object_script_variant = object.upcast_ref().get_script();
+
+    if object_script_variant.is_nil() {
+        return false;
+    }
+
+    let object_script: Gd<Script> = object_script_variant.to();
+
+    if object_script.upcast_ref::<Script>().__object_ptr() != script.upcast_ref().__object_ptr() {
+        return false;
+    }
+
+    let Some(language) = script.bind().get_language() else {
+        return false;
+    };
+
+    let get_instance_fn = sys::interface_fn!(object_get_script_instance);
+    let instance = unsafe { get_instance_fn(object.obj_sys(), language.obj_sys()) };
+
+    !instance.is_null()
+}
+
 /// Mutable/exclusive reference guard for a `T` where `T` implements [`ScriptInstance`].
 ///
 /// This can be used to access the base object of a [`ScriptInstance`], which in turn can be used to make reentrant calls to engine APIs.
diff --git a/itest/godot/ScriptInstanceTests.gd b/itest/godot/ScriptInstanceTests.gd
index 1a4a4cfac..81081d0c4 100644
--- a/itest/godot/ScriptInstanceTests.gd
+++ b/itest/godot/ScriptInstanceTests.gd
@@ -5,35 +5,44 @@
 
 extends TestSuite
 
-func create_script_instance() -> RefCounted:
-	var script = TestScript.new()
+func create_script_instance() -> Array:
+	var language: TestScriptLanguage = TestScriptLanguage.new()
+	var script: TestScript = language.new_script()
 	var script_owner = RefCounted.new()
 
 	script_owner.script = script
 
-	return script_owner
+	return [script_owner, language]
 
 
 func test_script_instance_get_property():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	var value: int = object.script_property_a
 
 	assert_eq(value, 10)
+	language.free()
 
 
 func test_script_instance_set_property():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	assert_eq(object.script_property_b, false)
 
 	object.script_property_b = true
 
 	assert_eq(object.script_property_b, true)
+	language.free()
 
 
 func test_script_instance_call():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	var arg_a = "test string"
 	var arg_b = 5
@@ -41,63 +50,83 @@ func test_script_instance_call():
 	var result = object.script_method_a(arg_a, arg_b)
 
 	assert_eq(result, "{0}{1}".format([arg_a, arg_b]))
+	language.free()
 
 
 func test_script_instance_property_list():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	var list = object.get_property_list()
 
 	assert_eq(list[-1]["name"], "script_property_a");
 	assert_eq(list[-1]["type"], Variant.Type.TYPE_INT)
+	language.free()
 
 
 func test_script_instance_method_list():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	var list = object.get_method_list()
 
 	assert_eq(list[-1]["name"], "script_method_a")
 	assert_eq(list[-1]["args"][0]["type"], Variant.Type.TYPE_STRING)
 	assert_eq(list[-1]["args"][1]["type"], Variant.Type.TYPE_INT)
+	language.free()
 
 
 func test_script_instance_has_method():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	assert(object.has_method("script_method_a"));
 	assert(!object.has_method("script_method_z"));
+	language.free()
 
 
 func test_script_instance_to_string():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 
 	assert_eq(object.to_string(), "script instance to string")
+	language.free()
 
 
 func test_script_instance_mut_call():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 	var before = object.script_property_b
 	
 	var result = object.script_method_toggle_property_b()
 
 	assert(result)
 	assert_eq(object.script_property_b, !before)
+	language.free()
 
 
 func test_script_instance_re_entering_call():
-	var object = create_script_instance()
+	var tuple := create_script_instance()
+	var object: RefCounted = tuple[0]
+	var language: TestScriptLanguage = tuple[1]
 	var before = object.script_property_b
 	
 	var result = object.script_method_re_entering()
 
 	assert(result)
 	assert_eq(object.script_property_b, !before)
+	language.free()
 
 
 func test_object_script_instance():
 	var object = Node.new()
-	var script = TestScript.new()
+	var language: TestScriptLanguage = TestScriptLanguage.new()
+	var script: TestScript = language.new_script()
 
 	object.script = script
 
@@ -105,3 +134,4 @@ func test_object_script_instance():
 
 	assert(result)
 	object.free()
+	language.free()
diff --git a/itest/rust/src/builtin_tests/script/script_instance_tests.rs b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
index 835eb5db5..47321d721 100644
--- a/itest/rust/src/builtin_tests/script/script_instance_tests.rs
+++ b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
@@ -8,23 +8,36 @@
 use std::ffi::c_void;
 
 use godot::builtin::{Array, Dictionary, GString, StringName, Variant, VariantType};
-use godot::classes::{IScriptExtension, Object, Script, ScriptExtension, ScriptLanguage};
+use godot::classes::{
+    IScriptExtension, IScriptLanguageExtension, Object, Script, ScriptExtension, ScriptLanguage,
+    ScriptLanguageExtension,
+};
 use godot::global::{Error, MethodFlags};
 use godot::meta::{ClassName, FromGodot, MethodInfo, PropertyInfo, ToGodot};
 use godot::obj::script::{create_script_instance, ScriptInstance, SiMut};
-use godot::obj::{Base, Gd, WithBaseField};
+use godot::obj::{Base, Gd, NewAlloc, WithBaseField};
 use godot::register::{godot_api, GodotClass};
 use godot::sys;
 
+use crate::framework::itest;
+
 #[derive(GodotClass)]
-#[class(base = ScriptExtension, init, tool)]
+#[class(base = ScriptExtension, no_init, tool)]
 struct TestScript {
+    language: Gd<TestScriptLanguage>,
     base: Base<ScriptExtension>,
 }
 
+impl TestScript {
+    fn new(language: Gd<TestScriptLanguage>) -> Gd<Self> {
+        Gd::from_init_fn(|base| Self { language, base })
+    }
+}
+
 #[rustfmt::skip]
 #[godot_api]
 impl IScriptExtension for TestScript {
+    
     fn can_instantiate(&self) -> bool {
         true
     }
@@ -33,6 +46,10 @@ impl IScriptExtension for TestScript {
         create_script_instance(TestScriptInstance::new(self.to_gd().upcast()), for_object)
     }
 
+    fn get_language(&self) -> Option<Gd<ScriptLanguage>> {
+        Some(self.language.clone().upcast())
+    }
+
     fn editor_can_reload_from_file(&mut self) -> bool { unreachable!() }
     fn get_base_script(&self) -> Option<Gd<Script>> { unreachable!() }
     fn get_global_name(&self) -> StringName { unreachable!() }
@@ -51,7 +68,6 @@ impl IScriptExtension for TestScript {
     fn get_method_info(&self, _method: StringName) -> Dictionary { unreachable!() }
     fn is_tool(&self) -> bool { unreachable!() }
     fn is_valid(&self) -> bool { unreachable!() }
-    fn get_language(&self) -> Option<Gd<ScriptLanguage>> { unreachable!() }
     fn has_script_signal(&self, _signall: StringName) -> bool { unreachable!() }
     fn get_script_signal_list(&self) -> Array<Dictionary> { unreachable!() }
     fn has_property_default_value(&self, _property: StringName) -> bool { unreachable!() }
@@ -75,12 +91,18 @@ struct TestScriptInstance {
     prop_list: Vec<PropertyInfo>,
     method_list: Vec<MethodInfo>,
     script: Gd<Script>,
+    script_language: Gd<ScriptLanguage>,
 }
 
 impl TestScriptInstance {
-    fn new(script: Gd<Script>) -> Self {
+    fn new(script: Gd<TestScript>) -> Self {
         Self {
-            script,
+            script_language: {
+                let s = script.bind();
+
+                s.get_language().unwrap()
+            },
+            script: script.upcast(),
             script_property_b: false,
             prop_list: vec![PropertyInfo::new_var::<i64>("script_property_a")],
 
@@ -200,7 +222,7 @@ impl ScriptInstance for TestScriptInstance {
     }
 
     fn get_language(&self) -> Gd<ScriptLanguage> {
-        panic!("language is not implemented")
+        self.script_language.clone()
     }
 
     fn on_refcount_decremented(&self) -> bool {
@@ -222,3 +244,114 @@ impl ScriptInstance for TestScriptInstance {
         None
     }
 }
+
+#[derive(GodotClass)]
+#[class(base = ScriptLanguageExtension, tool, init)]
+struct TestScriptLanguage {
+    base: Base<ScriptLanguageExtension>,
+}
+
+#[godot_api]
+impl TestScriptLanguage {
+    // In a real implementation the script would be created by the engine via ScriptLanguageExtension::create_script(), via a
+    // ResourceFormatLoader or by creating a new instance of TestScript. Most likely the script language would be registered as an engine
+    // singleton to make it globally available.
+    #[func]
+    fn new_script(&self) -> Gd<TestScript> {
+        TestScript::new(self.to_gd().cast())
+    }
+}
+
+#[godot_api]
+#[rustfmt::skip]
+impl IScriptLanguageExtension for TestScriptLanguage {
+    fn get_name(&self) -> GString { unreachable!() }
+    fn init_ext(&mut self) { unreachable!() }
+    fn get_type(&self) -> GString { unreachable!() }
+    fn get_extension(&self) -> GString { unreachable!() }
+    fn finish(&mut self) { unreachable!() }
+    fn get_reserved_words(&self) -> godot::prelude::PackedStringArray { unreachable!() }
+    fn is_control_flow_keyword(&self, _keyword: GString) -> bool { unreachable!() }
+    fn get_comment_delimiters(&self) -> godot::prelude::PackedStringArray { unreachable!() }
+    fn get_string_delimiters(&self) -> godot::prelude::PackedStringArray { unreachable!() }
+    fn make_template(&self, _template: GString, _class_name: GString, _base_class_name: GString) -> Option<Gd<Script>> { unreachable!() }
+    fn get_built_in_templates(&self, _object: StringName) -> Array<Dictionary> { unreachable!() }
+    fn is_using_templates(&mut self) -> bool { unreachable!() }
+    fn validate(&self, _script: GString, _path: GString, _validate_functions: bool, _validate_errors: bool, _validate_warnings: bool, _validate_safe_lines: bool) -> Dictionary { unreachable!() }
+    fn validate_path(&self, _path: GString) -> GString { unreachable!() }
+    fn create_script(&self) -> Option<Gd<Object>> { unreachable!() }
+    fn has_named_classes(&self) -> bool { unreachable!() }
+    fn supports_builtin_mode(&self) -> bool { unreachable!() }
+    fn supports_documentation(&self) -> bool { unreachable!() }
+    fn can_inherit_from_file(&self) -> bool { unreachable!() }
+    fn find_function(&self, _class_name: GString, _function_namee: GString) -> i32 { unreachable!() }
+    fn make_function(&self, _class_name: GString, _function_name: GString, _function_args: godot::prelude::PackedStringArray) -> GString { unreachable!() }
+    fn open_in_external_editor(&mut self, _script: Option<Gd<Script>>, _line: i32, _column: i32) -> godot::global::Error { unreachable!() }
+    fn overrides_external_editor(&mut self) -> bool { unreachable!() }
+    fn complete_code(&self, _code: GString,_pathh: GString, _ownerer: Option<Gd<Object>>) -> Dictionary { unreachable!() }
+    fn lookup_code(&self, _code: GString, _symbol: GString, _path: GString, _owner: Option<Gd<Object>>) -> Dictionary { unreachable!() }
+    fn auto_indent_code(&self, _code: GString, _from_linee: i32, _to_line: i32) -> GString { unreachable!() }
+    fn add_global_constant(&mut self, _name: StringName,_valuee: Variant) { unreachable!() }
+    fn add_named_global_constant(&mut self, _name: StringName,_valuee: Variant) { unreachable!() }
+    fn remove_named_global_constant(&mut self, _name: StringName) { unreachable!() }
+    fn thread_enter(&mut self) { unreachable!() }
+    fn thread_exit(&mut self) { unreachable!() }
+    fn debug_get_error(&self) -> GString { unreachable!() }
+    fn debug_get_stack_level_count(&self) -> i32 { unreachable!() }
+    fn debug_get_stack_level_line(&self, _level: i32) -> i32 { unreachable!() }
+    fn debug_get_stack_level_function(&self, _level: i32) -> GString { unreachable!() }
+    fn debug_get_stack_level_locals(&mut self, _level: i32, _max_subitems: i32, _max_depth: i32) -> Dictionary { unreachable!() }
+    fn debug_get_stack_level_members(&mut self, _level: i32, _max_subitems: i32, _max_depth: i32) -> Dictionary { unreachable!() }
+    unsafe fn debug_get_stack_level_instance(&mut self, _level: i32) -> *mut c_void { unreachable!() }
+    fn debug_get_globals(&mut self, _max_subitems: i32,_max_depthh: i32) -> Dictionary { unreachable!() }
+    fn debug_parse_stack_level_expression(&mut self, _level: i32, _expression: GString, _max_subitems: i32, _max_depth: i32) -> GString { unreachable!() }
+    fn debug_get_current_stack_info(&mut self) -> Array<Dictionary> { unreachable!() }
+    fn reload_all_scripts(&mut self) { unreachable!() }
+    fn reload_tool_script(&mut self, _script: Option<Gd<Script>>,_soft_reloadd: bool) { unreachable!() }
+    fn get_recognized_extensions(&self) -> godot::prelude::PackedStringArray { unreachable!() }
+    fn get_public_functions(&self) -> Array<Dictionary> { unreachable!() }
+    fn get_public_constants(&self) -> Dictionary { unreachable!() }
+    fn get_public_annotations(&self) -> Array<Dictionary> { unreachable!() }
+    fn profiling_start(&mut self) { unreachable!() }
+    fn profiling_stop(&mut self) { unreachable!() }
+    unsafe fn profiling_get_accumulated_data(&mut self, _info_array: *mut godot::classes::native::ScriptLanguageExtensionProfilingInfo, _info_max: i32) -> i32 { unreachable!() }
+    unsafe fn profiling_get_frame_data(&mut self, _info_array: *mut godot::classes::native::ScriptLanguageExtensionProfilingInfo, _info_max: i32) -> i32 { unreachable!() }
+    fn frame(&mut self) { unreachable!() }
+    fn handles_global_class_type(&self, _type_: GString) -> bool { unreachable!() }
+    fn get_global_class_name(&self, _path: GString) -> Dictionary { unreachable!() }
+    #[cfg(since_api = "4.3")]
+    fn profiling_set_save_native_calls(&mut self, _enable: bool) { unreachable!() }
+    #[cfg(since_api = "4.3")]
+    fn debug_get_stack_level_source(&self, _level: i32) -> GString { unreachable!() }
+    #[cfg(since_api = "4.3")]
+    fn can_make_function(&self) -> bool { unreachable!() }
+    #[cfg(since_api = "4.3")]
+    fn preferred_file_name_casing(&self) -> godot::classes::script_language::ScriptNameCasing { unreachable!() }
+    #[cfg(since_api = "4.4")]
+    fn reload_scripts(&mut self, _scripts: Array<Variant>, _soft: bool) { unreachable!() }
+}
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+// Test Cases
+
+// Test that [`script_instance_exists`] returns true if a instance of a script exists for the given object.
+#[itest]
+#[cfg(since_api = "4.2")]
+fn script_instance_exists() {
+    let language = TestScriptLanguage::new_alloc();
+    let script = TestScript::new(language.clone());
+    let mut object = Object::new_alloc();
+
+    object.set_script(&script.to_variant());
+
+    let instance_exists = godot::obj::script::script_instance_exists(&object, &script);
+    assert!(instance_exists);
+
+    object.set_script(&Variant::nil());
+
+    let instance_exists = godot::obj::script::script_instance_exists(&object, &script);
+    assert!(!instance_exists);
+
+    object.free();
+    language.free();
+}