Merge #815

815: Rename symbols for increased clarity r=Bromeon a=Bromeon

Addressing the first few of the pending renames in #773.
Changes are separated by commits.

bors try


Co-authored-by: Jan Haller <[email protected]>

Author: bors[bot]

bindings_generator/src/documentation.rs

@@ -129,8 +129,8 @@ This class is used to interact with Godot's editor."#
 All types in the Godot API have _interior mutability_ in Rust parlance.
 To enforce that the official [thread-safety guidelines][thread-safety] are
 followed, the typestate pattern is used in the `Ref` and `TRef` smart pointers,
-and the `Instance` API. The typestate `Access` in these types tracks whether the
-access is unique, shared, or exclusive to the current thread. For more information,
+and the `Instance` API. The typestate `Ownership` in these types tracks whether
+ownership is unique, shared, or exclusive to the current thread. For more information,
 see the type-level documentation on `Ref`.
 
 [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html"#;

bindings_generator/src/special_methods.rs

@@ -52,7 +52,7 @@ pub fn generate_godot_object_impl(class: &GodotClass) -> TokenStream {
         impl gdnative_core::private::godot_object::Sealed for #class_name {}
 
         unsafe impl GodotObject for #class_name {
-            type RefKind = #memory;
+            type Memory = #memory;
 
             #[inline]
             fn class_name() -> &'static str {

examples/dodge_the_creeps/src/main_scene.rs

@@ -140,7 +140,7 @@ impl Main {
 ///   scene as the root. For instance Spatial is used for this example.
 fn instance_scene<Root>(scene: &Ref<PackedScene, Shared>) -> Ref<Root, Unique>
 where
-    Root: gdnative::object::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
+    Root: gdnative::object::GodotObject<Memory = ManuallyManaged> + SubClass<Node>,
 {
     let scene = unsafe { scene.assume_safe() };
 

examples/native_plugin/src/lib.rs

@@ -58,7 +58,7 @@ impl MyButton {
 
 unsafe fn load<T>(path: &str, hint: &str) -> Option<Ref<T, Shared>>
 where
-    T: GodotObject<RefKind = RefCounted> + SubClass<Resource>,
+    T: GodotObject<Memory = RefCounted> + SubClass<Resource>,
 {
     let resource = ResourceLoader::godot_singleton().load(path, hint, false)?;
     let resource = resource.assume_safe().claim();

examples/scene_create/src/lib.rs

@@ -116,7 +116,7 @@ pub fn load_scene(path: &str) -> Option<Ref<PackedScene, ThreadLocal>> {
 ///   scene as the root. For instance Spatial is used for this example.
 fn instance_scene<Root>(scene: &PackedScene) -> Result<Ref<Root, Unique>, ManageErrs>
 where
-    Root: gdnative::object::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
+    Root: gdnative::object::GodotObject<Memory = ManuallyManaged> + SubClass<Node>,
 {
     let instance = scene
         .instance(PackedScene::GEN_EDIT_STATE_DISABLED)

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/core_types/access.rs

@@ -50,12 +50,12 @@ pub unsafe trait Guard: private::Sealed {
 pub unsafe trait WritePtr: Guard + private::Sealed {}
 
 pub(crate) mod private {
-    use crate::core_types::typed_array::Element;
+    use crate::core_types::pool_array::Element;
 
     pub trait Sealed {}
 
-    impl<'a, T: Element> Sealed for crate::core_types::typed_array::ReadGuard<'a, T> {}
-    impl<'a, T: Element> Sealed for crate::core_types::typed_array::WriteGuard<'a, T> {}
+    impl<'a, T: Element> Sealed for crate::core_types::pool_array::ReadGuard<'a, T> {}
+    impl<'a, T: Element> Sealed for crate::core_types::pool_array::WriteGuard<'a, T> {}
 }
 
 impl<G: Guard> MaybeUnaligned<G> {

gdnative-core/src/core_types/byte_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `u8` that uses Godot's pool allocator.
-pub type ByteArray = TypedArray<u8>;
+pub type ByteArray = PoolArray<u8>;
 
 godot_test!(
     test_byte_array_access {

gdnative-core/src/core_types/color_array.rs

@@ -1,8 +1,8 @@
 use crate::core_types::Color;
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `Color` that uses Godot's pool allocator.
-pub type ColorArray = TypedArray<Color>;
+pub type ColorArray = PoolArray<Color>;
 
 godot_test!(
     test_color_array_access {

gdnative-core/src/core_types/dictionary.rs

@@ -20,21 +20,21 @@ use crate::object::ownership::*;
 ///
 /// This is a reference-counted collection with "interior mutability" in Rust parlance.
 /// To enforce that the official [thread-safety guidelines][thread-safety] are
-/// followed this type uses the *typestate* pattern. The typestate `Access` tracks
+/// followed this type uses the *typestate* pattern. The typestate `Ownership` tracks
 /// whether there is thread-local or unique access (where pretty much all operations are safe)
 /// or whether the value might be "shared", in which case not all operations are
 /// safe.
 ///
 /// [thread-safety]: https://docs.godotengine.org/en/stable/tutorials/threads/thread_safe_apis.html
-pub struct Dictionary<Access: ThreadAccess = Shared> {
+pub struct Dictionary<Own: Ownership = Shared> {
     sys: sys::godot_dictionary,
 
     /// Marker preventing the compiler from incorrectly deriving `Send` and `Sync`.
-    _marker: PhantomData<Access>,
+    _marker: PhantomData<Own>,
 }
 
 /// Operations allowed on all Dictionaries at any point in time.
-impl<Access: ThreadAccess> Dictionary<Access> {
+impl<Own: Ownership> Dictionary<Own> {
     /// Returns `true` if the `Dictionary` contains no elements.
     #[inline]
     pub fn is_empty(&self) -> bool {
@@ -58,7 +58,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
 
     /// Returns true if the `Dictionary` has all of the keys in the given array.
     #[inline]
-    pub fn contains_all<ArrAccess: ThreadAccess>(&self, keys: &VariantArray<ArrAccess>) -> bool {
+    pub fn contains_all<ArrayOws: Ownership>(&self, keys: &VariantArray<ArrayOws>) -> bool {
         unsafe { (get_api().godot_dictionary_has_all)(self.sys(), keys.sys()) }
     }
 
@@ -200,7 +200,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
     /// Modifying the same underlying collection while observing the safety assumptions will
     /// not violate memory safely, but may lead to surprising behavior in the iterator.
     #[inline]
-    pub fn iter(&self) -> Iter<Access> {
+    pub fn iter(&self) -> Iter<Own> {
         Iter::new(self)
     }
 
@@ -238,7 +238,7 @@ impl<Access: ThreadAccess> Dictionary<Access> {
         }
     }
 
-    unsafe fn cast_access<A: ThreadAccess>(self) -> Dictionary<A> {
+    unsafe fn cast_access<A: Ownership>(self) -> Dictionary<A> {
         let sys = self.sys;
         std::mem::forget(self);
         Dictionary::from_sys(sys)
@@ -264,7 +264,7 @@ impl Dictionary<ThreadLocal> {
 }
 
 /// Operations allowed on Dictionaries that are not unique.
-impl<Access: NonUniqueThreadAccess> Dictionary<Access> {
+impl<Own: NonUniqueOwnership> Dictionary<Own> {
     /// Assume that this is the only reference to this dictionary, on which
     /// operations that change the container size can be safely performed.
     ///
@@ -282,7 +282,7 @@ impl<Access: NonUniqueThreadAccess> Dictionary<Access> {
 }
 
 /// Operations allowed on Dictionaries that can only be referenced to from the current thread.
-impl<Access: LocalThreadAccess> Dictionary<Access> {
+impl<Own: LocalThreadOwnership> Dictionary<Own> {
     #[inline]
     /// Inserts or updates the value of the element corresponding to the key.
     pub fn insert<K, V>(&self, key: K, val: V)
@@ -340,7 +340,7 @@ impl Dictionary<Unique> {
     }
 }
 
-impl<Access: ThreadAccess> Drop for Dictionary<Access> {
+impl<Own: Ownership> Drop for Dictionary<Own> {
     #[inline]
     fn drop(&mut self) {
         unsafe { (get_api().godot_dictionary_destroy)(self.sys_mut()) }
@@ -368,7 +368,7 @@ impl Default for Dictionary<ThreadLocal> {
     }
 }
 
-impl<Access: NonUniqueThreadAccess> NewRef for Dictionary<Access> {
+impl<Own: NonUniqueOwnership> NewRef for Dictionary<Own> {
     #[inline]
     fn new_ref(&self) -> Self {
         unsafe {
@@ -393,15 +393,15 @@ impl From<Dictionary<Unique>> for Dictionary<ThreadLocal> {
     }
 }
 
-impl<Access: ThreadAccess> fmt::Debug for Dictionary<Access> {
+impl<Own: Ownership> fmt::Debug for Dictionary<Own> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         self.to_json().to_string().fmt(f)
     }
 }
 
-unsafe fn iter_next<Access: ThreadAccess>(
-    dic: &Dictionary<Access>,
+unsafe fn iter_next<Own: Ownership>(
+    dic: &Dictionary<Own>,
     last_key: &mut Option<Variant>,
 ) -> Option<(Variant, Variant)> {
     let last_ptr = last_key.as_ref().map_or(std::ptr::null(), Variant::sys);
@@ -421,22 +421,22 @@ unsafe fn iter_next<Access: ThreadAccess>(
 ///
 /// This struct is created by the `iter` method on `Dictionary<Unique>`.
 #[derive(Debug)]
-pub struct Iter<'a, Access: ThreadAccess> {
-    dic: &'a Dictionary<Access>,
+pub struct Iter<'a, Own: Ownership> {
+    dic: &'a Dictionary<Own>,
     last_key: Option<Variant>,
 }
 
-impl<'a, Access: ThreadAccess> Iter<'a, Access> {
+impl<'a, Own: Ownership> Iter<'a, Own> {
     /// Create an Iterator from a unique Dictionary.
-    fn new(dic: &'a Dictionary<Access>) -> Self {
+    fn new(dic: &'a Dictionary<Own>) -> Self {
         Iter {
             dic,
             last_key: None,
         }
     }
 }
 
-impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
+impl<'a, Own: Ownership> Iterator for Iter<'a, Own> {
     type Item = (Variant, Variant);
 
     #[inline]
@@ -451,9 +451,9 @@ impl<'a, Access: ThreadAccess> Iterator for Iter<'a, Access> {
     }
 }
 
-impl<'a, Access: ThreadAccess> IntoIterator for &'a Dictionary<Access> {
+impl<'a, Own: Ownership> IntoIterator for &'a Dictionary<Own> {
     type Item = (Variant, Variant);
-    type IntoIter = Iter<'a, Access>;
+    type IntoIter = Iter<'a, Own>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -517,7 +517,7 @@ where
     }
 }
 
-impl<K, V, Access: LocalThreadAccess> Extend<(K, V)> for Dictionary<Access>
+impl<K, V, Own: LocalThreadOwnership> Extend<(K, V)> for Dictionary<Own>
 where
     K: ToVariantEq + OwnedToVariant,
     V: OwnedToVariant,

gdnative-core/src/core_types/float32_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `f32` that uses Godot's pool allocator.
-pub type Float32Array = TypedArray<f32>;
+pub type Float32Array = PoolArray<f32>;
 
 godot_test!(
     test_float32_array_access {

gdnative-core/src/core_types/int32_array.rs

@@ -1,7 +1,7 @@
-use crate::core_types::TypedArray;
+use crate::core_types::PoolArray;
 
 /// A reference-counted vector of `i32` that uses Godot's pool allocator.
-pub type Int32Array = TypedArray<i32>;
+pub type Int32Array = PoolArray<i32>;
 
 godot_test!(
     test_int32_array_access {