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]>

Author: bors[bot]

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.