Merge #788

788: Simplify module structure (redundant re-exports) r=Bromeon a=Bromeon

Simplifies the module structure and closes #771.

## Changes

**TLDR:**
* Every symbol lives in exactly one module (+ optionally the prelude)
* No symbols except modules at `gdnative` crate root (not even macros)
* Some module renamings for clarification
* No semantic changes -- may break imports however

**Detailed list:**
* Change `gdnative::object`
   * Now official home for `Ref`, `TRef` etc.
   * Move several verifying traits: `object` -> object::bounds
   * Move/rename `gdnative::thread_access` -> `gdnative::object::ownership`
   * Move/rename `gdnative::ref_kind` -> `gdnative::object::memory`
* Change `gdnative::core_types`
   * No more nested modules
   * Move `gdnative::GodotError` to `gdnative::object::GodotError` 
* Change `gdnative::nativescript`
   * Rename `init` -> `export`
   * Rename `profiling` -> `profiler`
   * `export` and `user_data` no longer re-exported to `nativescript`
   * `class` now private, symbols re-exported to `nativescript`
   * Macro `profile_sig!` now in `profiler`
   * Improve documentation + fix doc tests
* **Add** `gdnative::macros`
   * replaces crate root for `godot_init!` etc.
* **Add** `gdnative::derive`
   * contains derive macros and macro attributes
* Document feature flags in lib.rs and `Variant`

## Things not (yet) done
Those could be discussed in separate PRs.
* Changes to the prelude
* Clean up the modules inside `gdnative::api`
   The issue here is that the modules under `api` are used for grouping related symbols. For example, `api::node` has 3 structs `Node`, `DuplicateFlags` and `PauseMode`. In C++, they would be represented as enum/struct inside a `class Node`, however Rust does not support nested types in struct, hence the module is used. An alternative would be to remove `api::Node` and just use `api::node::Node`, but this is less ergonomic.
* Some very deep nestings, such as `gdnative::nativescript::export::property::hint::ArrayHint`

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

bindings_generator/src/api.rs

@@ -422,7 +422,7 @@ impl Ty {
             Ty::Bool => syn::parse_quote! { bool },
             Ty::Vector2 => syn::parse_quote! { Vector2 },
             Ty::Vector3 => syn::parse_quote! { Vector3 },
-            Ty::Vector3Axis => syn::parse_quote! { vector3::Axis },
+            Ty::Vector3Axis => syn::parse_quote! { Axis },
             Ty::Quat => syn::parse_quote! { Quat },
             Ty::Transform => syn::parse_quote! { Transform },
             Ty::Transform2D => syn::parse_quote! { Transform2D },
@@ -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()
             }
         }

examples/array_export/src/lib.rs

@@ -1,12 +1,12 @@
-use gdnative::nativescript::init::property::hint::{ArrayHint, IntHint, RangeHint};
+use gdnative::nativescript::export::property::hint::{ArrayHint, IntHint, RangeHint};
 use gdnative::prelude::*;
 
 #[derive(NativeClass)]
 #[inherit(Node)]
 #[register_with(Self::register)]
 struct ExportsArrays;
 
-#[gdnative::methods]
+#[methods]
 impl ExportsArrays {
     fn new(_owner: &Node) -> Self {
         ExportsArrays

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::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
+    Root: gdnative::object::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
 {
     let scene = unsafe { scene.assume_safe() };
 

examples/hello_world/src/lib.rs

@@ -4,7 +4,7 @@ use gdnative::prelude::*;
 #[inherit(Node)]
 struct HelloWorld;
 
-#[gdnative::methods]
+#[methods]
 impl HelloWorld {
     fn new(_owner: &Node) -> Self {
         HelloWorld

examples/resource/src/lib.rs

@@ -8,7 +8,7 @@ struct GreetingResource {
     name: String,
 }
 
-#[gdnative::methods]
+#[methods]
 impl GreetingResource {
     fn new(_owner: &Resource) -> Self {
         Self { name: "".into() }
@@ -29,7 +29,7 @@ struct Greeter {
     greeting_resource: Option<Instance<GreetingResource, Shared>>,
 }
 
-#[gdnative::methods]
+#[methods]
 impl Greeter {
     fn new(_owner: &Node) -> Self {
         Greeter {

examples/scene_create/src/lib.rs

@@ -6,7 +6,7 @@ pub enum ManageErrs {
     RootClassNotSpatial(String),
 }
 
-#[derive(gdnative::NativeClass)]
+#[derive(gdnative::derive::NativeClass)]
 #[inherit(Spatial)]
 struct SceneCreate {
     // Store the loaded scene for a very slight performance boost but mostly to show you how.
@@ -24,7 +24,7 @@ struct SceneCreate {
 //  Note, the same mechanism which is used to call from panel into spawn_one and remove_one can be
 //   used to call other GDNative classes here in rust.
 
-#[gdnative::methods]
+#[gdnative::derive::methods]
 impl SceneCreate {
     fn new(_owner: &Spatial) -> Self {
         SceneCreate {
@@ -33,7 +33,7 @@ impl SceneCreate {
         }
     }
 
-    #[export]
+    #[gdnative::derive::export]
     fn _ready(&mut self, _owner: &Spatial) {
         self.template = load_scene("res://Child_scene.tscn");
         match &self.template {
@@ -42,7 +42,7 @@ impl SceneCreate {
         }
     }
 
-    #[export]
+    #[gdnative::derive::export]
     fn spawn_one(&mut self, owner: &Spatial, message: GodotString) {
         godot_print!("Called spawn_one({})", message.to_string());
 
@@ -77,7 +77,7 @@ impl SceneCreate {
         update_panel(owner, num_children);
     }
 
-    #[export]
+    #[gdnative::derive::export]
     fn remove_one(&mut self, owner: &Spatial, str: GodotString) {
         godot_print!("Called remove_one({})", str);
         let num_children = owner.get_child_count();
@@ -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::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
+    Root: gdnative::object::GodotObject<RefKind = ManuallyManaged> + SubClass<Node>,
 {
     let instance = scene
         .instance(PackedScene::GEN_EDIT_STATE_DISABLED)

examples/spinning_cube/src/lib.rs

@@ -1,9 +1,9 @@
 use gdnative::api::MeshInstance;
 use gdnative::prelude::*;
 
-use gdnative::nativescript::init::property::{EnumHint, IntHint, StringHint};
+use gdnative::nativescript::export::property::{EnumHint, IntHint, StringHint};
 
-#[derive(gdnative::NativeClass)]
+#[derive(gdnative::derive::NativeClass)]
 #[inherit(MeshInstance)]
 #[register_with(register_properties)]
 struct RustTest {
@@ -36,7 +36,7 @@ fn register_properties(builder: &ClassBuilder<RustTest>) {
         .done();
 }
 
-#[gdnative::methods]
+#[methods]
 impl RustTest {
     fn new(_owner: &MeshInstance) -> Self {
         RustTest {

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::sys;
 use gdnative_core::sys::GodotApi;
-use gdnative_core::thread_access;
-use gdnative_core::{ref_kind, GodotResult};
 
 include!(concat!(env!("OUT_DIR"), "/generated.rs"));

gdnative-bindings/src/utils.rs

@@ -2,9 +2,8 @@
 
 use super::generated::{Engine, Node, SceneTree};
 use gdnative_core::nativescript::{NativeClass, RefInstance};
-use gdnative_core::object::SubClass;
-use gdnative_core::thread_access::Shared;
-use gdnative_core::TRef;
+use gdnative_core::object::ownership::Shared;
+use gdnative_core::object::{SubClass, TRef};
 
 /// 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/Cargo.toml

@@ -18,16 +18,17 @@ type_tag_fallback = []
 
 [dependencies]
 gdnative-sys = { path = "../gdnative-sys", version = "0.9.3" }
-libc = "0.2.98"
+gdnative-impl-proc-macros = { path = "../impl/proc_macros", version = "=0.9.3" }
+ahash = "=0.7.4" # TODO use flexible version as soon as https://github.com/tkaitchuck/aHash/issues/99 is fixed
 approx = "0.5.0"
+atomic-take = "1.0.0"
+bitflags = { version = "1.2.1", optional = true }
 glam = "0.18.0"
 indexmap = "1.7.0"
-ahash = "0.7.4"
+libc = "0.2.98"
 once_cell = "1.8.0"
+parking_lot = { version = "0.11.1", optional = true }
 serde = { version = "1", features = ["derive"], optional = true }
 
-gdnative-impl-proc-macros = { path = "../impl/proc_macros", version = "=0.9.3" }
-
-bitflags = { version = "1.2.1", optional = true }
-parking_lot = { version = "0.11.1", optional = true }
-atomic-take = "1.0.0"
+[dev-dependencies]
+gdnative = { path = "../gdnative", version = "0.9.3" } # for doc-tests

gdnative-core/src/core_types/access.rs

@@ -5,21 +5,21 @@ use std::ops::{Deref, DerefMut};
 use std::ptr;
 use std::slice;
 
+/// A pool array access that may be unaligned.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-/// An pool array access that may be unaligned.
 pub struct MaybeUnaligned<G> {
     guard: G,
 }
 
+/// A pool array access that is (assumed to be) aligned.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-/// An pool array access that is (assumed to be) aligned.
 pub struct Aligned<G> {
     guard: G,
 }
 
-#[derive(Debug)]
-/// An pool array write access with an owned aligned copy. The data is written back when this is
+/// A pool array write access with an owned aligned copy. The data is written back when this is
 /// dropped.
+#[derive(Debug)]
 pub struct Owned<G>
 where
     G: Guard + WritePtr,

gdnative-core/src/core_types/byte_array.rs

@@ -1,11 +1,11 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `u8` that uses Godot's pool allocator.
 pub type ByteArray = TypedArray<u8>;
 
 godot_test!(
     test_byte_array_access {
-        use crate::NewRef as _;
+        use crate::object::NewRef as _;
 
         let arr = (0..8).collect::<ByteArray>();
 

gdnative-core/src/core_types/color_array.rs

@@ -1,12 +1,12 @@
-use crate::core_types::typed_array::TypedArray;
 use crate::core_types::Color;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `Color` that uses Godot's pool allocator.
 pub type ColorArray = TypedArray<Color>;
 
 godot_test!(
     test_color_array_access {
-        use crate::NewRef as _;
+        use crate::object::NewRef as _;
 
         let arr = ColorArray::from_vec(vec![
             Color::from_rgb(1.0, 0.0, 0.0),

gdnative-core/src/core_types/dictionary.rs

@@ -12,10 +12,10 @@ use crate::core_types::ToVariant;
 use crate::core_types::ToVariantEq;
 use crate::core_types::Variant;
 use crate::core_types::VariantArray;
-use crate::NewRef;
+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/error.rs

@@ -82,3 +82,6 @@ impl std::fmt::Display for GodotError {
 }
 
 impl std::error::Error for GodotError {}
+
+/// Result type with [GodotError]
+pub type GodotResult = Result<(), GodotError>;

gdnative-core/src/core_types/float32_array.rs

@@ -1,11 +1,11 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `f32` that uses Godot's pool allocator.
 pub type Float32Array = TypedArray<f32>;
 
 godot_test!(
     test_float32_array_access {
-        use crate::NewRef as _;
+        use crate::object::NewRef as _;
 
         let arr = (0..8).map(|i| i as f32).collect::<Float32Array>();
 

gdnative-core/src/core_types/int32_array.rs

@@ -1,11 +1,11 @@
-use crate::core_types::typed_array::TypedArray;
+use crate::core_types::TypedArray;
 
 /// A reference-counted vector of `i32` that uses Godot's pool allocator.
 pub type Int32Array = TypedArray<i32>;
 
 godot_test!(
     test_int32_array_access {
-        use crate::NewRef as _;
+        use crate::object::NewRef as _;
 
         let arr = (0..8).collect::<Int32Array>();