Script call context is incomplete (#44)

TitanNano · web-flow · commit 6b38c9e6ac48 · 2024-08-06T08:28:28.000+02:00
diff --git a/derive/src/impl_attribute.rs b/derive/src/impl_attribute.rs
@@ -151,8 +151,10 @@ pub fn godot_script_impl(
     let trait_impl = quote_spanned! {
         current_type.span() =>
         impl ::godot_rust_script::GodotScriptImpl for #current_type {
+            type ImplBase = <Self as GodotScript>::Base;
+
             #[allow(unused_variables)]
-            fn call_fn(&mut self, name: #string_name_ty, args: &[&#variant_ty], ctx: ::godot_rust_script::Context) -> ::std::result::Result<#variant_ty, #call_error_ty> {
+            fn call_fn(&mut self, name: #string_name_ty, args: &[&#variant_ty], ctx: ::godot_rust_script::Context<Self>) -> ::std::result::Result<#variant_ty, #call_error_ty> {
                 match name.to_string().as_str() {
                     #method_dispatch
 
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
@@ -128,11 +128,13 @@ pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     
     let output = quote! {
         impl ::godot_rust_script::GodotScript for #script_type_ident {
+            type Base = #base_class;
+            
             #get_fields_impl
 
             #set_fields_impl
 
-            fn call(&mut self, name: #string_name_ty, args: &[&#variant_ty], ctx: ::godot_rust_script::Context) -> ::std::result::Result<#variant_ty, #call_error_ty> {
+            fn call(&mut self, name: #string_name_ty, args: &[&#variant_ty], ctx: ::godot_rust_script::Context<Self>) -> ::std::result::Result<#variant_ty, #call_error_ty> {
                 ::godot_rust_script::GodotScriptImpl::call_fn(self, name, args, ctx)
             }
 
diff --git a/rust-script/src/runtime/mod.rs b/rust-script/src/runtime/mod.rs
@@ -29,7 +29,7 @@ use crate::{
 
 use self::rust_script_language::RustScriptLanguage;
 
-pub use rust_script_instance::Context;
+pub use rust_script_instance::{Context, GenericContext};
 
 #[macro_export]
 macro_rules! setup {
diff --git a/rust-script/src/runtime/rust_script_instance.rs b/rust-script/src/runtime/rust_script_instance.rs
@@ -5,16 +5,18 @@
  */
 
 use core::panic;
+use std::marker::PhantomData;
 use std::{collections::HashMap, fmt::Debug, ops::DerefMut};
 
 use godot::classes::Script;
 use godot::meta::{MethodInfo, PropertyInfo};
-use godot::obj::script::{ScriptInstance, SiMut};
+use godot::obj::script::{ScriptBaseMut, ScriptInstance, SiMut};
+use godot::obj::GodotClass;
 use godot::prelude::{GString, Gd, Object, StringName, Variant, VariantType};
 use godot_cell::blocking::GdCell;
 
 use super::{rust_script::RustScript, rust_script_language::RustScriptLanguage, SCRIPT_REGISTRY};
-use crate::script_registry::GodotScriptObject;
+use crate::script_registry::{GodotScriptImpl, GodotScriptObject};
 
 fn script_method_list(script: &Gd<RustScript>) -> Box<[MethodInfo]> {
     let rs = script.bind();
@@ -48,30 +50,45 @@ fn script_property_list(script: &Gd<RustScript>) -> Box<[PropertyInfo]> {
     props
 }
 
-pub struct Context<'a> {
-    cell: &'a GdCell<Box<dyn GodotScriptObject>>,
+pub struct GenericContext<'a> {
+    cell: *const GdCell<Box<dyn GodotScriptObject>>,
     data_ptr: *mut Box<dyn GodotScriptObject>,
+    base: ScriptBaseMut<'a, RustScriptInstance>,
 }
 
-impl<'a> Debug for Context<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("Context { <Call Context> }")
-    }
-}
-
-impl<'a> Context<'a> {
+impl<'a> GenericContext<'a> {
     unsafe fn new(
-        cell: &'a GdCell<Box<dyn GodotScriptObject>>,
+        cell: *const GdCell<Box<dyn GodotScriptObject>>,
         data_ptr: *mut Box<dyn GodotScriptObject>,
+        base: ScriptBaseMut<'a, RustScriptInstance>,
     ) -> Self {
-        Self { cell, data_ptr }
+        Self {
+            cell,
+            data_ptr,
+            base,
+        }
+    }
+}
+
+pub struct Context<'a, Script: GodotScriptImpl + ?Sized> {
+    cell: *const GdCell<Box<dyn GodotScriptObject>>,
+    data_ptr: *mut Box<dyn GodotScriptObject>,
+    base: ScriptBaseMut<'a, RustScriptInstance>,
+    base_type: PhantomData<Script>,
+}
+
+impl<'a, Script: GodotScriptImpl> Debug for Context<'a, Script> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Context { <Call Context> }")
     }
+}
 
-    pub fn reentrant_scope<T: GodotScriptObject + 'static, R>(
+impl<'a, Script: GodotScriptImpl> Context<'a, Script> {
+    pub fn reentrant_scope<T: GodotScriptObject + 'static, Args, Return>(
         &mut self,
         self_ref: &mut T,
-        cb: impl FnOnce() -> R,
-    ) -> R {
+        scope: impl ReentrantScope<Script::ImplBase, Args, Return>,
+    ) -> Return {
         let known_ptr = unsafe {
             let any = (*self.data_ptr).as_any_mut();
 
@@ -84,19 +101,51 @@ impl<'a> Context<'a> {
             panic!("unable to create reentrant scope with unrelated self reference!");
         }
 
-        let guard = self
-            .cell
-            .make_inaccessible(unsafe { &mut *self.data_ptr })
-            .unwrap();
+        let current_ref = unsafe { &mut *self.data_ptr };
+        let cell = unsafe { &*self.cell };
+        let guard = cell.make_inaccessible(current_ref).unwrap();
 
-        let result = cb();
+        let result = scope.run(self.base.deref_mut().clone().cast::<Script::ImplBase>());
 
         drop(guard);
 
         result
     }
 }
 
+impl<'a, Script: GodotScriptImpl> From<GenericContext<'a>> for Context<'a, Script> {
+    fn from(value: GenericContext<'a>) -> Self {
+        let GenericContext {
+            cell,
+            data_ptr,
+            base,
+        } = value;
+
+        Self {
+            cell,
+            data_ptr,
+            base,
+            base_type: PhantomData,
+        }
+    }
+}
+
+pub trait ReentrantScope<Base: GodotClass, Args, Return> {
+    fn run(self, base: Gd<Base>) -> Return;
+}
+
+impl<Base: GodotClass, F: FnOnce() -> R, R> ReentrantScope<Base, (), R> for F {
+    fn run(self, _base: Gd<Base>) -> R {
+        self()
+    }
+}
+
+impl<Base: GodotClass, F: FnOnce(Gd<Base>) -> R, R> ReentrantScope<Base, Gd<Base>, R> for F {
+    fn run(self, base: Gd<Base>) -> R {
+        self(base)
+    }
+}
+
 pub(super) struct RustScriptInstance {
     data: GdCell<Box<dyn GodotScriptObject>>,
 
@@ -151,16 +200,19 @@ impl ScriptInstance for RustScriptInstance {
     }
 
     fn call(
-        this: SiMut<Self>,
+        mut this: SiMut<Self>,
         method: StringName,
         args: &[&Variant],
     ) -> Result<Variant, godot::sys::GDExtensionCallErrorType> {
-        let cell = &this.data;
-        let mut data_guard = cell.borrow_mut().unwrap();
+        let cell: *const _ = &this.data;
+
+        let base = this.base_mut();
+
+        let mut data_guard = unsafe { &*cell }.borrow_mut().unwrap();
         let data = data_guard.deref_mut();
         let data_ptr = data as *mut _;
 
-        let context = unsafe { Context::new(cell, data_ptr) };
+        let context = unsafe { GenericContext::new(cell, data_ptr, base) };
 
         data.call(method, args, context)
     }
diff --git a/rust-script/src/script_registry.rs b/rust-script/src/script_registry.rs
@@ -8,20 +8,22 @@ use std::{any::Any, collections::HashMap, fmt::Debug, sync::Arc};
 
 use godot::global::{MethodFlags, PropertyHint, PropertyUsageFlags};
 use godot::meta::{ClassName, MethodInfo, PropertyInfo};
-use godot::obj::{EngineBitfield, EngineEnum};
+use godot::obj::{EngineBitfield, EngineEnum, Inherits};
 use godot::prelude::{GString, Gd, Object, StringName, Variant};
 use godot::sys::VariantType;
 
-use crate::Context;
+use crate::runtime::{Context, GenericContext};
+
+pub trait GodotScript: Debug + GodotScriptImpl<ImplBase = Self::Base> {
+    type Base: Inherits<Object>;
 
-pub trait GodotScript: Debug + GodotScriptImpl {
     fn set(&mut self, name: StringName, value: Variant) -> bool;
     fn get(&self, name: StringName) -> Option<Variant>;
     fn call(
         &mut self,
         method: StringName,
         args: &[&Variant],
-        context: Context,
+        context: Context<'_, Self>,
     ) -> Result<Variant, godot::sys::GDExtensionCallErrorType>;
 
     fn to_string(&self) -> String;
@@ -31,11 +33,13 @@ pub trait GodotScript: Debug + GodotScriptImpl {
 }
 
 pub trait GodotScriptImpl {
+    type ImplBase: Inherits<Object>;
+
     fn call_fn(
         &mut self,
         name: StringName,
         args: &[&Variant],
-        context: Context,
+        context: Context<Self>,
     ) -> Result<Variant, godot::sys::GDExtensionCallErrorType>;
 }
 
@@ -46,7 +50,7 @@ pub trait GodotScriptObject {
         &mut self,
         method: StringName,
         args: &[&Variant],
-        context: Context,
+        context: GenericContext,
     ) -> Result<Variant, godot::sys::GDExtensionCallErrorType>;
     fn to_string(&self) -> String;
     fn property_state(&self) -> HashMap<StringName, Variant>;
@@ -67,9 +71,9 @@ impl<T: GodotScript + 'static> GodotScriptObject for T {
         &mut self,
         method: StringName,
         args: &[&Variant],
-        context: Context,
+        context: GenericContext,
     ) -> Result<Variant, godot::sys::GDExtensionCallErrorType> {
-        GodotScript::call(self, method, args, context)
+        GodotScript::call(self, method, args, Context::from(context))
     }
 
     fn to_string(&self) -> String {
diff --git a/rust-script/tests/script_derive.rs b/rust-script/tests/script_derive.rs
@@ -6,7 +6,7 @@
 
 use godot::builtin::{GString, StringName};
 use godot::classes::Node;
-use godot::obj::Gd;
+use godot::obj::{Gd, NewAlloc};
 use godot_rust_script::{godot_script_impl, Context, GodotScript};
 
 #[derive(GodotScript, Debug)]
@@ -19,7 +19,7 @@ struct TestScript {
     #[export(enum_options = ["inactive", "water", "teargas"])]
     pub enum_prop: u8,
 
-    base: Gd<Node>,
+    base: Gd<<Self as GodotScript>::Base>,
 }
 
 #[godot_script_impl]
@@ -28,14 +28,18 @@ impl TestScript {
         value > 2
     }
 
-    pub fn action(&mut self, input: GString, mut ctx: Context) -> bool {
+    pub fn action(&mut self, input: GString, mut ctx: Context<Self>) -> bool {
         let result = input.len() > 2;
         let mut base = self.base.clone();
 
         ctx.reentrant_scope(self, || {
             base.emit_signal(StringName::from("hit"), &[]);
         });
 
+        ctx.reentrant_scope(self, |mut base: Gd<Node>| {
+            base.set_owner(Node::new_alloc());
+        });
+
         result
     }
 }
