Selectively re-export core_type submodules

Switched to explicit re-exports instead of globs for submodules of
`core_types`. This prevents details such as `Iter` and `IntoIter` from
polluting the namespace and causing collisions, and makes it harder to
accidentally introduce such exports in the future.

Some of the submodules are made public to facilitate access to those
types when necessary. The `variant_array` module has been renamed to
`array` prior to this for simplicity.

This is a breaking change, since public re-exports have been removed
from the module.

Author: chitoyuu

gdnative-bindings/src/generated.rs

@@ -7,6 +7,7 @@ use libc::c_char;
 use std::mem;
 use std::ptr;
 
+use gdnative_core::core_types::variant::*;
 use gdnative_core::core_types::*;
 use gdnative_core::object::*;
 use gdnative_core::object::{memory, ownership};

gdnative-core/src/core_types/variant_array.rs renamed to gdnative-core/src/core_types/array.rs

@@ -5,34 +5,36 @@
 //!
 //! godot-rust provides optional serialization support for many core types.  Enable the feature `serde` to make use of it.
 
-mod geom;
-
-mod access;
 mod color;
-mod dictionary;
 mod error;
 mod node_path;
 mod pool_array;
 mod rid;
-mod string;
-mod variant;
-mod variant_array;
 mod vector2;
 mod vector3;
 
-pub use access::*;
-pub use color::*;
-pub use dictionary::*;
+pub mod access;
+pub mod array;
+pub mod dictionary;
+pub mod geom;
+pub mod string;
+pub mod variant;
+
+pub use array::VariantArray;
+pub use color::Color;
+pub use dictionary::Dictionary;
 pub use error::{GodotError, GodotResult};
-pub use geom::*;
-pub use node_path::*;
-pub use pool_array::*;
-pub use rid::*;
-pub use string::*;
-pub use variant::*;
-pub use variant_array::*;
-pub use vector2::*;
-pub use vector3::*;
+pub use geom::{Aabb, Basis, Margin, MarginError, Plane, Quat, Rect2, Transform, Transform2D};
+pub use node_path::NodePath;
+pub use pool_array::{PoolArray, PoolElement};
+pub use rid::Rid;
+pub use string::{GodotString, StringName};
+pub use variant::{
+    CoerceFromVariant, FromVariant, FromVariantError, OwnedToVariant, ToVariant, ToVariantEq,
+    Variant, VariantType,
+};
+pub use vector2::Vector2;
+pub use vector3::{Axis, Vector3};
 
 use approx::relative_eq;
 
@@ -55,3 +57,49 @@ impl IsEqualApprox for f64 {
         relative_eq!(self, to, epsilon = CMP_EPSILON)
     }
 }
+
+#[cfg(feature = "gd-test")]
+#[doc(hidden)]
+#[inline]
+#[must_use]
+pub fn test_core_types() -> bool {
+    let mut status = true;
+
+    status &= string::test_string();
+    status &= string::test_string_name_eq();
+    status &= string::test_string_name_ord();
+
+    status &= array::test_array();
+    status &= array::test_array_debug();
+    status &= array::test_array_clone_clear();
+    status &= dictionary::test_dictionary();
+    status &= dictionary::test_dictionary_clone_clear();
+
+    status &= color::test_color();
+    status &= vector2::test_vector2_variants();
+    status &= vector3::test_vector3_variants();
+
+    status &= variant::test_variant_nil();
+    status &= variant::test_variant_i64();
+    status &= variant::test_variant_bool();
+    status &= variant::test_variant_option();
+    status &= variant::test_variant_result();
+    status &= variant::test_variant_hash_map();
+    status &= variant::test_variant_hash_set();
+    status &= variant::test_variant_vec();
+    status &= variant::test_to_variant_iter();
+    status &= variant::test_variant_tuple();
+    status &= variant::test_variant_dispatch();
+
+    status &= pool_array::test_byte_array_access();
+    status &= pool_array::test_int32_array_access();
+    status &= pool_array::test_float32_array_access();
+    status &= pool_array::test_color_array_access();
+    status &= pool_array::test_string_array_access();
+    status &= pool_array::test_vector2_array_access();
+    status &= pool_array::test_vector3_array_access();
+
+    status &= geom::test_transform2d_behavior();
+
+    status
+}

gdnative-core/src/core_types/mod.rs

@@ -248,7 +248,7 @@ impl<'de> Visitor<'de> for VariantDispatchVisitor {
                 v.newtype_variant::<Vec<VariantDispatch>>()?
                     .iter()
                     .map(Into::<Variant>::into)
-                    .collect::<variant_array::VariantArray<Unique>>()
+                    .collect::<array::VariantArray<Unique>>()
                     .into_shared(),
             ),
             ByteArray => VariantDispatch::ByteArray(v.newtype_variant()?),

gdnative-core/src/core_types/variant/serialize.rs

@@ -149,8 +149,8 @@ pub(crate) fn expand_from_variant(derive_data: DeriveData) -> Result<TokenStream
                 use ::gdnative::core_types::ToVariant;
                 use ::gdnative::core_types::FromVariant;
                 use ::gdnative::core_types::FromVariantError as FVE;
-                use ::gdnative::core_types::VariantEnumRepr;
-                use ::gdnative::core_types::VariantStructRepr;
+                use ::gdnative::core_types::variant::VariantEnumRepr;
+                use ::gdnative::core_types::variant::VariantStructRepr;
 
                 #return_expr
             }

gdnative-derive/src/variant/from.rs

@@ -6,8 +6,8 @@ pub use gdnative_bindings::{
 };
 pub use gdnative_core::core_types::{
     Aabb, Basis, Color, Dictionary, GodotError, GodotString, NodePath, Plane, PoolArray, Quat,
-    Rect2, Rid, StringName, Transform, Transform2D, Variant, VariantArray, VariantDispatch,
-    VariantOperator, VariantType, Vector2, Vector3,
+    Rect2, Rid, StringName, Transform, Transform2D, Variant, VariantArray, VariantType, Vector2,
+    Vector3,
 };
 pub use gdnative_core::core_types::{
     FromVariant, FromVariantError, OwnedToVariant, ToVariant, ToVariantEq,

gdnative/src/prelude.rs

@@ -25,42 +25,8 @@ pub extern "C" fn run_tests(
     _args: *mut gdnative::sys::godot_array,
 ) -> gdnative::sys::godot_variant {
     let mut status = true;
-    status &= gdnative::core_types::test_string();
-    status &= gdnative::core_types::test_string_name_eq();
-    status &= gdnative::core_types::test_string_name_ord();
-
-    status &= gdnative::core_types::test_dictionary();
-    status &= gdnative::core_types::test_dictionary_clone_clear();
-    status &= gdnative::core_types::test_color();
-    status &= gdnative::core_types::test_array();
-    status &= gdnative::core_types::test_array_debug();
-    status &= gdnative::core_types::test_array_clone_clear();
-
-    status &= gdnative::core_types::test_variant_nil();
-    status &= gdnative::core_types::test_variant_i64();
-    status &= gdnative::core_types::test_variant_bool();
-
-    status &= gdnative::core_types::test_vector2_variants();
-
-    status &= gdnative::core_types::test_vector3_variants();
-
-    status &= gdnative::core_types::test_variant_option();
-    status &= gdnative::core_types::test_variant_result();
-    status &= gdnative::core_types::test_variant_hash_map();
-    status &= gdnative::core_types::test_variant_hash_set();
-    status &= gdnative::core_types::test_variant_vec();
-    status &= gdnative::core_types::test_to_variant_iter();
-    status &= gdnative::core_types::test_variant_tuple();
-    status &= gdnative::core_types::test_variant_dispatch();
-
-    status &= gdnative::core_types::test_byte_array_access();
-    status &= gdnative::core_types::test_int32_array_access();
-    status &= gdnative::core_types::test_float32_array_access();
-    status &= gdnative::core_types::test_color_array_access();
-    status &= gdnative::core_types::test_string_array_access();
-    status &= gdnative::core_types::test_vector2_array_access();
-    status &= gdnative::core_types::test_vector3_array_access();
-    status &= gdnative::core_types::test_transform2d_behavior();
+
+    status &= gdnative::core_types::test_core_types();
 
     status &= test_from_instance_id();
     status &= test_nil_object_return_value();

test/src/lib.rs

@@ -1,3 +1,4 @@
+use gdnative::core_types::variant::VariantDispatch;
 use gdnative::prelude::*;
 use serde::{Deserialize, Serialize};
 

test/src/test_serde.rs

@@ -1,4 +1,4 @@
-use gdnative::core_types::InvalidOp;
+use gdnative::core_types::variant::{InvalidOp, VariantOperator};
 use gdnative::prelude::*;
 
 pub(crate) fn run_tests() -> bool {