Merge pull request #735 from godot-rust/feature/streamlined-modules-4

Streamline modules - part IV: `godot::meta`, `godot::builtin::iter`

Author: Bromeon

godot-codegen/src/generator/builtins.rs

@@ -150,7 +150,7 @@ fn make_special_builtin_methods(class_name: &TyName, _ctx: &Context) -> TokenStr
         quote! {
             pub fn from_outer_typed<T>(outer: &Array<T>) -> Self
                 where
-                    T: crate::builtin::meta::ArrayElement
+                    T: crate::meta::ArrayElement
             {
                 Self {
                     _outer_lifetime: std::marker::PhantomData,

godot-codegen/src/generator/enums.rs

@@ -107,20 +107,20 @@ pub fn make_enum_definition_with(
             #index_enum_impl
             #bitwise_impls
 
-            impl crate::builtin::meta::GodotConvert for #name {
+            impl crate::meta::GodotConvert for #name {
                 type Via = #ord_type;
             }
 
-            impl crate::builtin::meta::ToGodot for #name {
+            impl crate::meta::ToGodot for #name {
                 fn to_godot(&self) -> Self::Via {
                     <Self as #engine_trait>::ord(*self)
                 }
             }
 
-            impl crate::builtin::meta::FromGodot for #name {
-                fn try_from_godot(via: Self::Via) -> std::result::Result<Self, crate::builtin::meta::ConvertError> {
+            impl crate::meta::FromGodot for #name {
+                fn try_from_godot(via: Self::Via) -> std::result::Result<Self, crate::meta::error::ConvertError> {
                     <Self as #engine_trait>::try_from_ord(via)
-                        .ok_or_else(|| crate::builtin::meta::FromGodotError::InvalidEnum.into_error(via))
+                        .ok_or_else(|| crate::meta::error::FromGodotError::InvalidEnum.into_error(via))
                 }
             }
         }

godot-codegen/src/generator/native_structures.rs

@@ -71,7 +71,7 @@ fn make_native_structure(
     // mod re_export needed, because class should not appear inside the file module, and we can't re-export private struct as pub
     let tokens = quote! {
         #imports
-        use crate::builtin::meta::{GodotConvert, FromGodot, ToGodot};
+        use crate::meta::{GodotConvert, FromGodot, ToGodot};
 
         /// Native structure; can be passed via pointer in APIs that are not exposed to GDScript.
         ///
@@ -93,7 +93,7 @@ fn make_native_structure(
         }
 
         impl FromGodot for *mut #class_name {
-            fn try_from_godot(via: Self::Via) -> Result<Self, crate::builtin::meta::ConvertError> {
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
                 Ok(via as Self)
             }
         }
@@ -109,7 +109,7 @@ fn make_native_structure(
         }
 
         impl FromGodot for *const #class_name {
-            fn try_from_godot(via: Self::Via) -> Result<Self, crate::builtin::meta::ConvertError> {
+            fn try_from_godot(via: Self::Via) -> Result<Self, crate::meta::error::ConvertError> {
                 Ok(via as Self)
             }
         }

godot-codegen/src/generator/virtual_traits.rs

@@ -114,7 +114,7 @@ fn make_special_virtual_methods(notification_enum_name: &Ident) -> TokenStream {
         /// See also in Godot docs:
         /// * [`Object::_get_property_list`](https://docs.godotengine.org/en/latest/classes/class_object.html#class-object-private-method-get-property-list)
         #[cfg(since_api = "4.3")]
-        fn get_property_list(&mut self) -> Vec<crate::builtin::meta::PropertyInfo> {
+        fn get_property_list(&mut self) -> Vec<crate::meta::PropertyInfo> {
             unimplemented!()
         }
 

godot-codegen/src/models/domain.rs

@@ -560,7 +560,7 @@ impl FnReturn {
 
     pub fn call_result_decl(&self) -> TokenStream {
         let ret = self.type_tokens();
-        quote! { -> Result<#ret, crate::builtin::meta::CallError> }
+        quote! { -> Result<#ret, crate::meta::error::CallError> }
     }
 }
 

godot-codegen/src/util.rs

@@ -23,7 +23,7 @@ pub fn make_imports() -> TokenStream {
     quote! {
         use godot_ffi as sys;
         use crate::builtin::*;
-        use crate::builtin::meta::{ClassName, PtrcallSignatureTuple, VarcallSignatureTuple};
+        use crate::meta::{ClassName, PtrcallSignatureTuple, VarcallSignatureTuple};
         use crate::classes::native::*;
         use crate::classes::Object;
         use crate::obj::Gd;

godot-core/src/builtin/aabb.rs

@@ -11,8 +11,6 @@ use sys::{ffi_methods, GodotFfi};
 use crate::builtin::math::ApproxEq;
 use crate::builtin::{real, Plane, Vector3, Vector3Axis};
 
-use super::meta::impl_godot_as_self;
-
 /// Axis-aligned bounding box in 3D space.
 ///
 /// `Aabb` consists of a position, a size, and several utility functions. It is typically used for
@@ -406,7 +404,7 @@ unsafe impl GodotFfi for Aabb {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-impl_godot_as_self!(Aabb);
+crate::meta::impl_godot_as_self!(Aabb);
 
 impl ApproxEq for Aabb {
     /// Returns `true` if the two `Aabb`s are approximately equal, by calling `is_equal_approx` on

godot-core/src/builtin/basis.rs

@@ -15,8 +15,6 @@ use std::cmp::Ordering;
 use std::fmt::Display;
 use std::ops::{Mul, MulAssign};
 
-use super::meta::impl_godot_as_self;
-
 /// A 3x3 matrix, typically used as an orthogonal basis for [`Transform3D`](crate::builtin::Transform3D).
 ///
 /// Indexing into a `Basis` is done in row-major order. So `mat[1]` would return the first *row* and not
@@ -604,7 +602,7 @@ unsafe impl GodotFfi for Basis {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-impl_godot_as_self!(Basis);
+crate::meta::impl_godot_as_self!(Basis);
 
 #[cfg(test)]
 mod test {

godot-core/src/builtin/callable.rs

@@ -7,9 +7,9 @@
 
 use godot_ffi as sys;
 
-use crate::builtin::meta::{impl_godot_as_self, GodotType, ToGodot};
 use crate::builtin::{inner, StringName, Variant, VariantArray};
 use crate::classes::Object;
+use crate::meta::{GodotType, ToGodot};
 use crate::obj::bounds::DynMemory;
 use crate::obj::Bounds;
 use crate::obj::{Gd, GodotClass, InstanceId};
@@ -310,7 +310,7 @@ unsafe impl GodotFfi for Callable {
     }
 }
 
-impl_godot_as_self!(Callable);
+crate::meta::impl_godot_as_self!(Callable);
 
 impl fmt::Debug for Callable {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -391,7 +391,7 @@ mod custom_callable {
         let c: &mut C = CallableUserdata::inner_from_raw(callable_userdata);
 
         let result = c.invoke(arg_refs);
-        crate::builtin::meta::varcall_return_checked(result, r_return, r_error);
+        crate::meta::varcall_return_checked(result, r_return, r_error);
     }
 
     pub unsafe extern "C" fn rust_callable_call_fn<F>(
@@ -408,7 +408,7 @@ mod custom_callable {
         let w: &mut FnWrapper<F> = CallableUserdata::inner_from_raw(callable_userdata);
 
         let result = (w.rust_function)(arg_refs);
-        crate::builtin::meta::varcall_return_checked(result, r_return, r_error);
+        crate::meta::varcall_return_checked(result, r_return, r_error);
     }
 
     pub unsafe extern "C" fn rust_callable_destroy<T>(callable_userdata: *mut std::ffi::c_void) {

godot-core/src/builtin/array.rs renamed to godot-core/src/builtin/collections/array.rs

@@ -5,19 +5,20 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use godot_ffi as sys;
-
-use crate::builtin::*;
-use crate::obj::EngineEnum;
-use crate::property::{builtin_type_string, Export, PropertyHintInfo, TypeStringHint, Var};
 use std::fmt;
 use std::marker::PhantomData;
-use sys::{ffi_methods, interface_fn, GodotFfi};
 
-use super::meta::{
-    ArrayElement, ConvertError, FromGodot, FromGodotError, FromVariantError, GodotConvert,
-    GodotFfiVariant, GodotType, ToGodot,
+use crate::builtin::*;
+use crate::meta::error::{ConvertError, FromGodotError, FromVariantError};
+use crate::meta::{
+    ArrayElement, ArrayTypeInfo, FromGodot, GodotConvert, GodotFfiVariant, GodotType, ToGodot,
+};
+use crate::obj::EngineEnum;
+use crate::registry::property::{
+    builtin_type_string, Export, PropertyHintInfo, TypeStringHint, Var,
 };
+use godot_ffi as sys;
+use sys::{ffi_methods, interface_fn, GodotFfi};
 
 /// Godot's `Array` type.
 ///
@@ -682,13 +683,13 @@ impl<T: ArrayElement> Array<T> {
     }
 
     /// Returns the runtime type info of this array.
-    fn type_info(&self) -> TypeInfo {
+    fn type_info(&self) -> ArrayTypeInfo {
         let variant_type = VariantType::from_sys(
             self.as_inner().get_typed_builtin() as sys::GDExtensionVariantType
         );
         let class_name = self.as_inner().get_typed_class_name();
 
-        TypeInfo {
+        ArrayTypeInfo {
             variant_type,
             class_name,
         }
@@ -697,7 +698,7 @@ impl<T: ArrayElement> Array<T> {
     /// Checks that the inner array has the correct type set on it for storing elements of type `T`.
     fn with_checked_type(self) -> Result<Self, ConvertError> {
         let self_ty = self.type_info();
-        let target_ty = TypeInfo::of::<T>();
+        let target_ty = ArrayTypeInfo::of::<T>();
 
         if self_ty == target_ty {
             Ok(self)
@@ -719,7 +720,7 @@ impl<T: ArrayElement> Array<T> {
         debug_assert!(self.is_empty());
         debug_assert!(!self.type_info().is_typed());
 
-        let type_info = TypeInfo::of::<T>();
+        let type_info = ArrayTypeInfo::of::<T>();
         if type_info.is_typed() {
             let script = Variant::nil();
 
@@ -1047,6 +1048,7 @@ impl<T: ArrayElement + FromGodot> From<&Array<T>> for Vec<T> {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
+/// An iterator over typed elements of an [`Array`].
 pub struct Iter<'a, T: ArrayElement> {
     array: &'a Array<T>,
     next_idx: usize,
@@ -1163,7 +1165,7 @@ macro_rules! varray {
     // Note: use to_variant() and not Variant::from(), as that works with both references and values
     ($($elements:expr),* $(,)?) => {
         {
-            use $crate::builtin::meta::ToGodot as _;
+            use $crate::meta::ToGodot as _;
             let mut array = $crate::builtin::VariantArray::default();
             $(
                 array.push($elements.to_variant());
@@ -1175,52 +1177,6 @@ macro_rules! varray {
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
-/// Represents the type information of a Godot array. See
-/// [`set_typed`](https://docs.godotengine.org/en/latest/classes/class_array.html#class-array-method-set-typed).
-///
-/// We ignore the `script` parameter because it has no impact on typing in Godot.
-#[derive(Eq, PartialEq)]
-pub(crate) struct TypeInfo {
-    variant_type: VariantType,
-
-    /// Not a `ClassName` because some values come from Godot engine API.
-    class_name: StringName,
-}
-
-impl TypeInfo {
-    fn of<T: GodotType>() -> Self {
-        Self {
-            variant_type: <T::Via as GodotType>::Ffi::variant_type(),
-            class_name: T::Via::class_name().to_string_name(),
-        }
-    }
-
-    pub fn is_typed(&self) -> bool {
-        self.variant_type != VariantType::NIL
-    }
-
-    pub fn variant_type(&self) -> VariantType {
-        self.variant_type
-    }
-
-    pub fn class_name(&self) -> &StringName {
-        &self.class_name
-    }
-}
-
-impl fmt::Debug for TypeInfo {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let class = self.class_name.to_string();
-        let class_str = if class.is_empty() {
-            String::new()
-        } else {
-            format!(" (class={class})")
-        };
-
-        write!(f, "{:?}{}", self.variant_type, class_str)
-    }
-}
-
 #[cfg(feature = "serde")]
 mod serialize {
     use super::*;