Move thread_access -> object::ownership, ref_kind -> object::memory

Author: Bromeon

bindings_generator/src/api.rs

@@ -448,7 +448,7 @@ impl Ty {
             Ty::VariantOperator => syn::parse_quote! { VariantOperator },
             Ty::Enum(path) => syn::parse_quote! { #path },
             Ty::Object(path) => {
-                syn::parse_quote! { Option<Ref<#path, thread_access::Shared>> }
+                syn::parse_quote! { Option<Ref<#path, ownership::Shared>> }
             }
         }
     }
@@ -597,7 +597,7 @@ impl Ty {
             Ty::Object(ref path) => {
                 quote! {
                     ptr::NonNull::new(ret)
-                        .map(|sys| <Ref<#path, thread_access::Shared>>::move_from_sys(sys))
+                        .map(|sys| <Ref<#path, ownership::Shared>>::move_from_sys(sys))
                 }
             }
             Ty::Result => {

bindings_generator/src/special_methods.rs

@@ -26,7 +26,7 @@ destroying the object) or destroyed manually using `Ref::free`, or preferably
     quote! {
         #[doc=#documentation]
         #[inline]
-        pub fn new() -> Ref<Self, thread_access::Unique> {
+        pub fn new() -> Ref<Self, ownership::Unique> {
             unsafe {
                 let gd_api = get_api();
                 let ctor = #method_table::get(gd_api).class_constructor.unwrap();
@@ -42,17 +42,17 @@ pub fn generate_godot_object_impl(class: &GodotClass) -> TokenStream {
     let name = &class.name;
     let class_name = format_ident!("{}", class.name);
 
-    let ref_kind = if class.is_refcounted() {
-        quote! { ref_kind::RefCounted }
+    let memory = if class.is_refcounted() {
+        quote! { memory::RefCounted }
     } else {
-        quote! { ref_kind::ManuallyManaged }
+        quote! { memory::ManuallyManaged }
     };
 
     quote! {
         impl gdnative_core::private::godot_object::Sealed for #class_name {}
 
         unsafe impl GodotObject for #class_name {
-            type RefKind = #ref_kind;
+            type RefKind = #memory;
 
             #[inline]
             fn class_name() -> &'static str {
@@ -69,7 +69,7 @@ pub fn generate_instantiable_impl(class: &GodotClass) -> TokenStream {
     quote! {
         impl Instanciable for #class_name {
             #[inline]
-            fn construct() -> Ref<Self, thread_access::Unique> {
+            fn construct() -> Ref<Self, ownership::Unique> {
                 #class_name::new()
             }
         }

gdnative-bindings/src/generated.rs

@@ -8,10 +8,9 @@ use std::sync::Once;
 
 use gdnative_core::core_types::*;
 use gdnative_core::object::*;
+use gdnative_core::object::{memory, ownership};
 use gdnative_core::private::get_api;
-use gdnative_core::ref_kind;
 use gdnative_core::sys;
 use gdnative_core::sys::GodotApi;
-use gdnative_core::thread_access;
 
 include!(concat!(env!("OUT_DIR"), "/generated.rs"));

gdnative-bindings/src/utils.rs

@@ -2,8 +2,8 @@
 
 use super::generated::{Engine, Node, SceneTree};
 use gdnative_core::nativescript::{NativeClass, RefInstance};
+use gdnative_core::object::ownership::Shared;
 use gdnative_core::object::{SubClass, TRef};
-use gdnative_core::thread_access::Shared;
 
 /// Convenience method  to obtain a reference to an "auto-load" node, that is a child of the root
 /// node. Returns `None` if the node does not exist or is not of the correct type.

gdnative-core/src/core_types/dictionary.rs

@@ -15,7 +15,7 @@ use crate::core_types::VariantArray;
 use crate::object::NewRef;
 use std::fmt;
 
-use crate::thread_access::*;
+use crate::object::ownership::*;
 
 /// A reference-counted `Dictionary` of `Variant` key-value pairs.
 ///

gdnative-core/src/core_types/variant.rs

@@ -5,9 +5,9 @@ use std::mem::{forget, transmute};
 use std::ptr;
 
 use crate::core_types::*;
+use crate::object::ownership::*;
 use crate::object::*;
 use crate::private::{get_api, ManuallyManagedClassPlaceholder};
-use crate::thread_access::*;
 
 #[cfg(feature = "serde")]
 mod serialize;

gdnative-core/src/core_types/variant_array.rs

@@ -11,7 +11,7 @@ use crate::core_types::ToVariant;
 use crate::core_types::Variant;
 use crate::object::NewRef;
 
-use crate::thread_access::*;
+use crate::object::ownership::*;
 
 use std::fmt;
 

gdnative-core/src/lib.rs

@@ -45,8 +45,6 @@ pub mod nativescript;
 #[doc(hidden)]
 pub mod log;
 pub mod object;
-pub mod ref_kind;
-pub mod thread_access;
 
 /// Internal low-level API for use by macros and generated bindings. Not a part of the public API.
 #[doc(hidden)]
@@ -58,6 +56,6 @@ pub mod private;
 
 pub use init::{InitializeInfo, TerminateInfo};
 
-#[deprecated(since = "0.10", note = "use core_types::GodotResult")]
+#[deprecated(since = "0.10.0", note = "use core_types::GodotResult")]
 #[doc(hidden)]
 pub type GodotResult = core_types::GodotResult;

gdnative-core/src/nativescript/class.rs

@@ -5,14 +5,14 @@ use crate::core_types::{
 };
 use crate::nativescript::init::ClassBuilder;
 use crate::nativescript::{Map, MapMut, MapOwned, UserData};
+use crate::object::memory::{ManuallyManaged, RefCounted};
+use crate::object::ownership::{NonUniqueThreadAccess, Shared, ThreadAccess, ThreadLocal, Unique};
 use crate::object::{
     AssumeSafeLifetime, LifetimeConstraint, QueueFree, RawObject, Ref, RefImplBound, SafeAsRaw,
     SafeDeref, TRef,
 };
 use crate::object::{GodotObject, Instanciable};
 use crate::private::{get_api, ReferenceCountedClassPlaceholder};
-use crate::ref_kind::{ManuallyManaged, RefCounted};
-use crate::thread_access::{NonUniqueThreadAccess, Shared, ThreadAccess, ThreadLocal, Unique};
 
 use super::class_registry;
 use super::emplace;

gdnative-core/src/nativescript/init/method.rs

@@ -10,8 +10,8 @@ use std::marker::PhantomData;
 use crate::core_types::{FromVariant, FromVariantError, Variant};
 use crate::log::Site;
 use crate::nativescript::class::{NativeClass, RefInstance};
+use crate::object::ownership::Shared;
 use crate::object::{Ref, TRef};
-use crate::thread_access::Shared;
 
 use super::ClassBuilder;