Rename RefInstance -> TInstance

Author: hesuteia

gdnative-async/src/method.rs

@@ -8,7 +8,7 @@ use gdnative_core::core_types::{ToVariant, Variant};
 use gdnative_core::export::{Method, NativeClass, Varargs};
 use gdnative_core::log::{self, Site};
 use gdnative_core::object::ownership::Shared;
-use gdnative_core::object::RefInstance;
+use gdnative_core::object::TInstance;
 
 use crate::rt::Context;
 
@@ -41,7 +41,7 @@ pub trait AsyncMethod<C: NativeClass>: Send + Sync + 'static {
 pub struct Spawner<'a, C: NativeClass> {
     sp: &'static dyn LocalSpawn,
     ctx: Context,
-    this: RefInstance<'a, C, Shared>,
+    this: TInstance<'a, C, Shared>,
     args: Varargs<'a>,
     result: &'a mut Option<Result<(), SpawnError>>,
     /// Remove Send and Sync
@@ -54,7 +54,7 @@ impl<'a, C: NativeClass> Spawner<'a, C> {
     /// future types.
     pub fn spawn<F, R>(self, f: F)
     where
-        F: FnOnce(Arc<Context>, RefInstance<'_, C, Shared>, Varargs<'_>) -> R,
+        F: FnOnce(Arc<Context>, TInstance<'_, C, Shared>, Varargs<'_>) -> R,
         R: Future<Output = Variant> + 'static,
     {
         let ctx = Arc::new(self.ctx);
@@ -84,7 +84,7 @@ impl<F> Async<F> {
 }
 
 impl<C: NativeClass, F: AsyncMethod<C>> Method<C> for Async<F> {
-    fn call(&self, this: RefInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant {
+    fn call(&self, this: TInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant {
         if let Some(sp) = crate::executor::local_spawn() {
             let ctx = Context::new();
             let func_state = ctx.func_state();

gdnative-async/src/rt.rs

@@ -5,7 +5,7 @@ use gdnative_bindings::Object;
 use gdnative_core::core_types::{GodotError, Variant};
 use gdnative_core::init::InitHandle;
 use gdnative_core::object::ownership::Shared;
-use gdnative_core::object::{Instance, RefInstance, SubClass, TRef};
+use gdnative_core::object::{Instance, SubClass, TInstance, TRef};
 
 use crate::future;
 
@@ -31,7 +31,7 @@ impl Context {
         self.func_state.clone()
     }
 
-    fn safe_func_state(&self) -> RefInstance<'_, FuncState, Shared> {
+    fn safe_func_state(&self) -> TInstance<'_, FuncState, Shared> {
         // SAFETY: FuncState objects are bound to their origin threads in Rust, and
         // Context is !Send, so this is safe to call within this type.
         // Non-Rust code is expected to be following the official guidelines as per

gdnative-async/src/rt/bridge.rs

@@ -9,7 +9,7 @@ use gdnative_core::export::user_data::{ArcData, Map};
 use gdnative_core::export::{ClassBuilder, Method, NativeClass, NativeClassMethods, Varargs};
 use gdnative_core::godot_site;
 use gdnative_core::object::ownership::Shared;
-use gdnative_core::object::{Instance, RefInstance, TRef};
+use gdnative_core::object::{Instance, TInstance, TRef};
 
 use crate::future::Resume;
 
@@ -97,7 +97,7 @@ impl SignalBridge {
 struct OnSignalFn;
 
 impl Method<SignalBridge> for OnSignalFn {
-    fn call(&self, this: RefInstance<'_, SignalBridge, Shared>, args: Varargs<'_>) -> Variant {
+    fn call(&self, this: TInstance<'_, SignalBridge, Shared>, args: Varargs<'_>) -> Variant {
         let args = args.cloned().collect();
 
         let this_persist = this.clone().claim();

gdnative-async/src/rt/func_state.rs

@@ -7,7 +7,7 @@ use gdnative_core::export::{
 };
 use gdnative_core::godot_site;
 use gdnative_core::object::ownership::{Shared, Unique};
-use gdnative_core::object::{Instance, RefInstance};
+use gdnative_core::object::{Instance, TInstance};
 use gdnative_derive::FromVarargs;
 
 use crate::future::Resume;
@@ -57,7 +57,7 @@ impl FuncState {
     }
 }
 
-pub(super) fn resolve(this: RefInstance<'_, FuncState, Shared>, value: Variant) {
+pub(super) fn resolve(this: TInstance<'_, FuncState, Shared>, value: Variant) {
     this.script()
         .map_mut(|s| {
             match s.kind {
@@ -80,7 +80,7 @@ pub(super) fn resolve(this: RefInstance<'_, FuncState, Shared>, value: Variant)
     this.base().emit_signal("completed", &[value]);
 }
 
-pub(super) fn make_resumable(this: RefInstance<'_, FuncState, Shared>, resume: Resume<Variant>) {
+pub(super) fn make_resumable(this: TInstance<'_, FuncState, Shared>, resume: Resume<Variant>) {
     let kind = this
         .script()
         .map_mut(|s| std::mem::replace(&mut s.kind, Kind::Resumable(resume)))
@@ -113,7 +113,7 @@ struct IsValidArgs {
 
 impl StaticArgsMethod<FuncState> for IsValidFn {
     type Args = IsValidArgs;
-    fn call(&self, this: RefInstance<'_, FuncState, Shared>, args: Self::Args) -> Variant {
+    fn call(&self, this: TInstance<'_, FuncState, Shared>, args: Self::Args) -> Variant {
         if args.extended_check.is_some() {
             gdnative_core::log::warn(
                 Self::site().unwrap(),
@@ -145,7 +145,7 @@ struct ResumeArgs {
 
 impl StaticArgsMethod<FuncState> for ResumeFn {
     type Args = ResumeArgs;
-    fn call(&self, this: RefInstance<'_, FuncState, Shared>, args: Self::Args) -> Variant {
+    fn call(&self, this: TInstance<'_, FuncState, Shared>, args: Self::Args) -> Variant {
         this.map_mut(
             |s, owner| match std::mem::replace(&mut s.kind, Kind::Pending) {
                 Kind::Resumable(resume) => {

gdnative-bindings/src/utils.rs

@@ -2,7 +2,7 @@
 
 use gdnative_core::export::NativeClass;
 use gdnative_core::object::ownership::Shared;
-use gdnative_core::object::{RefInstance, SubClass, TRef};
+use gdnative_core::object::{SubClass, TInstance, TRef};
 
 use super::generated::{Engine, Node, SceneTree};
 
@@ -58,7 +58,7 @@ pub trait NodeExt {
     /// invariants must be observed for the resulting node during `'a`, if any.
     ///
     /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-    unsafe fn get_node_as_instance<'a, T>(&self, path: &str) -> Option<RefInstance<'a, T, Shared>>
+    unsafe fn get_node_as_instance<'a, T>(&self, path: &str) -> Option<TInstance<'a, T, Shared>>
     where
         T: NativeClass,
         T::Base: SubClass<Node>,

gdnative-core/src/export/class_builder.rs

@@ -140,7 +140,7 @@ impl<C: NativeClass> ClassBuilder<C> {
     /// // Now, wrap the method (this can do anything and does not need to actually call a method)
     /// struct MyMethod;
     /// impl Method<MyType> for MyMethod {
-    ///     fn call(&self, this: RefInstance<'_, MyType, Shared>, _args: Varargs<'_>) -> Variant {
+    ///     fn call(&self, this: TInstance<'_, MyType, Shared>, _args: Varargs<'_>) -> Variant {
     ///         this.map(|obj: &MyType, _| {
     ///             let result = obj.my_method();
     ///             Variant::from_i64(result)

gdnative-core/src/export/macros.rs

@@ -29,7 +29,7 @@ macro_rules! godot_wrap_method_inner {
             struct ThisMethod;
 
             use $crate::export::{NativeClass, OwnerArg};
-            use $crate::object::{Instance, RefInstance};
+            use $crate::object::{Instance, TInstance};
             use ::gdnative::derive::FromVarargs;
 
             #[derive(FromVarargs)]
@@ -44,7 +44,7 @@ macro_rules! godot_wrap_method_inner {
                 type Args = Args;
                 fn call(
                     &self,
-                    this: RefInstance<'_, $type_name, $crate::object::ownership::Shared>,
+                    this: TInstance<'_, $type_name, $crate::object::ownership::Shared>,
                     Args { $($pname,)* $($opt_pname,)* }: Args,
                 ) -> $crate::core_types::Variant {
                     this

gdnative-core/src/export/method.rs

@@ -12,7 +12,7 @@ use crate::export::class::NativeClass;
 use crate::export::ClassBuilder;
 use crate::log::Site;
 use crate::object::ownership::Shared;
-use crate::object::{Ref, RefInstance, TRef};
+use crate::object::{Ref, TInstance, TRef};
 
 /// Builder type used to register a method on a `NativeClass`.
 pub struct MethodBuilder<'a, C, F> {
@@ -140,7 +140,7 @@ pub struct ScriptMethod<'l> {
 /// Safe low-level trait for stateful, variadic methods that can be called on a native script type.
 pub trait Method<C: NativeClass>: Send + Sync + 'static {
     /// Calls the method on `this` with `args`.
-    fn call(&self, this: RefInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant;
+    fn call(&self, this: TInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant;
 
     /// Returns an optional site where this method is defined. Used for logging errors in FFI wrappers.
     ///
@@ -157,7 +157,7 @@ struct Stateless<F> {
 }
 
 impl<C: NativeClass, F: Method<C> + Copy + Default> Method<C> for Stateless<F> {
-    fn call(&self, this: RefInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant {
+    fn call(&self, this: TInstance<'_, C, Shared>, args: Varargs<'_>) -> Variant {
         let f = F::default();
         f.call(this, args)
     }
@@ -182,7 +182,7 @@ impl<F> StaticArgs<F> {
 /// "static method".
 pub trait StaticArgsMethod<C: NativeClass>: Send + Sync + 'static {
     type Args: FromVarargs;
-    fn call(&self, this: RefInstance<'_, C, Shared>, args: Self::Args) -> Variant;
+    fn call(&self, this: TInstance<'_, C, Shared>, args: Self::Args) -> Variant;
 
     /// Returns an optional site where this method is defined. Used for logging errors in FFI wrappers.
     ///
@@ -195,7 +195,7 @@ pub trait StaticArgsMethod<C: NativeClass>: Send + Sync + 'static {
 
 impl<C: NativeClass, F: StaticArgsMethod<C>> Method<C> for StaticArgs<F> {
     #[inline]
-    fn call(&self, this: RefInstance<'_, C, Shared>, mut args: Varargs<'_>) -> Variant {
+    fn call(&self, this: TInstance<'_, C, Shared>, mut args: Varargs<'_>) -> Variant {
         match args.read_many::<F::Args>() {
             Ok(parsed) => {
                 if let Err(err) = args.done() {
@@ -583,7 +583,7 @@ unsafe extern "C" fn method_wrapper<C: NativeClass, F: Method<C>>(
 
         let this: Ref<C::Base, Shared> = Ref::from_sys(this);
         let this: TRef<'_, C::Base, _> = this.assume_safe_unchecked();
-        let this: RefInstance<'_, C, _> = RefInstance::from_raw_unchecked(this, user_data);
+        let this: TInstance<'_, C, _> = TInstance::from_raw_unchecked(this, user_data);
 
         let args = Varargs::from_sys(num_args, args);
 

gdnative-core/src/object/instance.rs

@@ -16,7 +16,7 @@ use crate::private::{get_api, ReferenceCountedClassPlaceholder};
 /// A persistent reference to a GodotObject with a rust NativeClass attached.
 ///
 /// `Instance`s can be worked on directly using `map` and `map_mut` if the base object is
-/// reference-counted. Otherwise, use `assume_safe` to obtain a temporary `RefInstance`.
+/// reference-counted. Otherwise, use `assume_safe` to obtain a temporary `TInstance`.
 ///
 /// See the type-level documentation on `Ref` for more information on typed thread accesses.
 #[derive(Debug)]
@@ -30,7 +30,7 @@ pub struct Instance<T: NativeClass, Access: ThreadAccess> {
 ///
 /// See the type-level documentation on `Ref` for more information on typed thread accesses.
 #[derive(Debug)]
-pub struct RefInstance<'a, T: NativeClass, Access: ThreadAccess> {
+pub struct TInstance<'a, T: NativeClass, Access: ThreadAccess> {
     owner: TRef<'a, T::Base, Access>,
     script: T::UserData,
 }
@@ -312,11 +312,11 @@ impl<T: NativeClass> Instance<T, Shared> {
     /// It's safe to call `assume_safe` only if the constraints of `Ref::assume_safe`
     /// are satisfied for the base object.
     #[inline]
-    pub unsafe fn assume_safe<'a, 'r>(&'r self) -> RefInstance<'a, T, Shared>
+    pub unsafe fn assume_safe<'a, 'r>(&'r self) -> TInstance<'a, T, Shared>
     where
         AssumeSafeLifetime<'a, 'r>: LifetimeConstraint<<T::Base as GodotObject>::RefKind>,
     {
-        RefInstance {
+        TInstance {
             owner: self.owner.assume_safe(),
             script: self.script.clone(),
         }
@@ -434,7 +434,7 @@ where
     }
 }
 
-impl<'a, T: NativeClass, Access: ThreadAccess> RefInstance<'a, T, Access> {
+impl<'a, T: NativeClass, Access: ThreadAccess> TInstance<'a, T, Access> {
     /// Returns a reference to the base object with the same lifetime.
     #[inline]
     pub fn base(&self) -> TRef<'a, T::Base, Access> {
@@ -447,7 +447,7 @@ impl<'a, T: NativeClass, Access: ThreadAccess> RefInstance<'a, T, Access> {
         &self.script
     }
 
-    /// Try to downcast `TRef<'a, T::Base, Access>` to `RefInstance<T>`.
+    /// Try to downcast `TRef<'a, T::Base, Access>` to `TInstance<T>`.
     #[inline]
     pub fn try_from_base(owner: TRef<'a, T::Base, Access>) -> Option<Self> {
         let user_data = try_get_user_data_ptr::<T>(owner.as_raw())?;
@@ -462,11 +462,11 @@ impl<'a, T: NativeClass, Access: ThreadAccess> RefInstance<'a, T, Access> {
         user_data: *mut libc::c_void,
     ) -> Self {
         let script = T::UserData::clone_from_user_data_unchecked(user_data);
-        RefInstance { owner, script }
+        TInstance { owner, script }
     }
 }
 
-impl<'a, T: NativeClass, Access: NonUniqueThreadAccess> RefInstance<'a, T, Access> {
+impl<'a, T: NativeClass, Access: NonUniqueThreadAccess> TInstance<'a, T, Access> {
     /// Persists this into a persistent `Instance` with the same thread access, without cloning
     /// the userdata wrapper.
     ///
@@ -481,7 +481,7 @@ impl<'a, T: NativeClass, Access: NonUniqueThreadAccess> RefInstance<'a, T, Acces
 }
 
 /// Methods for instances with reference-counted base classes.
-impl<'a, T: NativeClass, Access: ThreadAccess> RefInstance<'a, T, Access>
+impl<'a, T: NativeClass, Access: ThreadAccess> TInstance<'a, T, Access>
 where
     T::Base: GodotObject,
 {
@@ -533,13 +533,13 @@ where
     }
 }
 
-impl<'a, T, Access: ThreadAccess> Clone for RefInstance<'a, T, Access>
+impl<'a, T, Access: ThreadAccess> Clone for TInstance<'a, T, Access>
 where
     T: NativeClass,
 {
     #[inline]
     fn clone(&self) -> Self {
-        RefInstance {
+        TInstance {
             owner: self.owner,
             script: self.script.clone(),
         }

gdnative-core/src/object/mod.rs

@@ -933,13 +933,13 @@ impl<'a, T: GodotObject, Access: ThreadAccess> TRef<'a, T, Access> {
         TRef::new(self.obj.upcast())
     }
 
-    /// Convenience method to downcast to `RefInstance` where `self` is the base object.
+    /// Convenience method to downcast to `TInstance` where `self` is the base object.
     #[inline]
-    pub fn cast_instance<C>(self) -> Option<RefInstance<'a, C, Access>>
+    pub fn cast_instance<C>(self) -> Option<TInstance<'a, C, Access>>
     where
         C: NativeClass<Base = T>,
     {
-        RefInstance::try_from_base(self)
+        TInstance::try_from_base(self)
     }
 }