Deprecate specialized pool array aliases

chitoyuu · chitoyuu · commit 246e5f201963 · 2023-01-09T15:07:19.000Z
diff --git a/gdnative-core/src/core_types/byte_array.rs b/gdnative-core/src/core_types/byte_array.rs
@@ -3,13 +3,14 @@ use crate::core_types::PoolArray;
 /// A reference-counted vector of `u8` that uses Godot's pool allocator.
 ///
 /// See [`PoolByteArray`](https://docs.godotengine.org/en/stable/classes/class_poolbytearray.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type ByteArray = PoolArray<u8>;
 
 godot_test!(
     test_byte_array_access {
         use crate::object::NewRef as _;
 
-        let arr = (0..8).collect::<ByteArray>();
+        let arr = (0..8).collect::<PoolArray<u8>>();
 
         let original_read = {
             let read = arr.read();
@@ -48,7 +49,7 @@ godot_test!(
 
 godot_test!(
     test_byte_array_debug {
-        let arr = (0..8).collect::<ByteArray>();
+        let arr = (0..8).collect::<PoolArray<u8>>();
         assert_eq!(format!("{arr:?}"), "[0, 1, 2, 3, 4, 5, 6, 7]");
     }
 );
diff --git a/gdnative-core/src/core_types/color_array.rs b/gdnative-core/src/core_types/color_array.rs
@@ -4,13 +4,14 @@ use crate::core_types::PoolArray;
 /// A reference-counted vector of `Color` that uses Godot's pool allocator.
 ///
 /// See [`PoolColorArray`](https://docs.godotengine.org/en/stable/classes/class_poolcolorarray.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type ColorArray = PoolArray<Color>;
 
 godot_test!(
     test_color_array_access {
         use crate::object::NewRef as _;
 
-        let arr = ColorArray::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Color::from_rgb(1.0, 0.0, 0.0),
             Color::from_rgb(0.0, 1.0, 0.0),
             Color::from_rgb(0.0, 0.0, 1.0),
@@ -51,7 +52,7 @@ godot_test!(
 
 godot_test!(
     test_color_array_debug {
-        let arr = ColorArray::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Color::from_rgb(1.0, 0.0, 0.0),
             Color::from_rgb(0.0, 1.0, 0.0),
             Color::from_rgb(0.0, 0.0, 1.0),
diff --git a/gdnative-core/src/core_types/float32_array.rs b/gdnative-core/src/core_types/float32_array.rs
@@ -3,13 +3,14 @@ use crate::core_types::PoolArray;
 /// A reference-counted vector of `f32` that uses Godot's pool allocator.
 ///
 /// See [`PoolRealArray`](https://docs.godotengine.org/en/stable/classes/class_poolrealarray.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type Float32Array = PoolArray<f32>;
 
 godot_test!(
     test_float32_array_access {
         use crate::object::NewRef as _;
 
-        let arr = (0..8).map(|i| i as f32).collect::<Float32Array>();
+        let arr = (0..8).map(|i| i as f32).collect::<PoolArray<f32>>();
 
         let original_read = {
             let read = arr.read();
@@ -42,7 +43,7 @@ godot_test!(
 
 godot_test!(
     test_float32_array_debug {
-        let arr = (0..8).map(|i| i as f32).collect::<Float32Array>();
+        let arr = (0..8).map(|i| i as f32).collect::<PoolArray<f32>>();
         assert_eq!(format!("{arr:?}"), "[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]");
     }
 );
diff --git a/gdnative-core/src/core_types/int32_array.rs b/gdnative-core/src/core_types/int32_array.rs
@@ -3,13 +3,14 @@ use crate::core_types::PoolArray;
 /// A reference-counted vector of `i32` that uses Godot's pool allocator.
 ///
 /// See [`PoolIntArray`](https://docs.godotengine.org/en/stable/classes/class_poolintarray.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type Int32Array = PoolArray<i32>;
 
 godot_test!(
     test_int32_array_access {
         use crate::object::NewRef as _;
 
-        let arr = (0..8).collect::<Int32Array>();
+        let arr = (0..8).collect::<PoolArray<i32>>();
 
         let original_read = {
             let read = arr.read();
@@ -38,7 +39,7 @@ godot_test!(
 
 godot_test!(
     test_int32_array_debug {
-        let arr = (0..8).collect::<Int32Array>();
+        let arr = (0..8).collect::<PoolArray<i32>>();
         assert_eq!(format!("{arr:?}"), "[0, 1, 2, 3, 4, 5, 6, 7]");
     }
 );
diff --git a/gdnative-core/src/core_types/string_array.rs b/gdnative-core/src/core_types/string_array.rs
@@ -4,13 +4,14 @@ use crate::core_types::PoolArray;
 /// A reference-counted vector of `GodotString` that uses Godot's pool allocator.
 ///
 /// See [`PoolStringArray`](https://docs.godotengine.org/en/stable/classes/class_poolstringarray.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type StringArray = PoolArray<GodotString>;
 
 godot_test!(
     test_string_array_access {
         use crate::object::NewRef as _;
 
-        let arr = StringArray::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             GodotString::from("foo"),
             GodotString::from("bar"),
             GodotString::from("baz"),
@@ -51,7 +52,7 @@ godot_test!(
 
 godot_test!(
     test_string_array_debug {
-        let arr = StringArray::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             GodotString::from("foo"),
             GodotString::from("bar"),
             GodotString::from("baz"),
diff --git a/gdnative-core/src/core_types/variant.rs b/gdnative-core/src/core_types/variant.rs
@@ -155,13 +155,13 @@ decl_variant_type!(
         Object(Variant) = sys::godot_variant_type_GODOT_VARIANT_TYPE_OBJECT,
         Dictionary(Dictionary) = sys::godot_variant_type_GODOT_VARIANT_TYPE_DICTIONARY,
         VariantArray(VariantArray) = sys::godot_variant_type_GODOT_VARIANT_TYPE_ARRAY,
-        ByteArray(ByteArray) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY,
-        Int32Array(Int32Array) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_INT_ARRAY,
-        Float32Array(Float32Array) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_REAL_ARRAY,
-        StringArray(StringArray) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_STRING_ARRAY,
-        Vector2Array(Vector2Array) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY,
-        Vector3Array(Vector3Array) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY,
-        ColorArray(ColorArray) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY,
+        ByteArray(PoolArray<u8>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY,
+        Int32Array(PoolArray<i32>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_INT_ARRAY,
+        Float32Array(PoolArray<f32>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_REAL_ARRAY,
+        StringArray(PoolArray<GodotString>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_STRING_ARRAY,
+        Vector2Array(PoolArray<Vector2>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY,
+        Vector3Array(PoolArray<Vector3>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY,
+        ColorArray(PoolArray<Color>) = sys::godot_variant_type_GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY,
     }
 );
 
@@ -598,13 +598,13 @@ impl_coerce_from_variant!(
     impl CoerceFromVariant for GodotString = from_sys(godot_variant_as_string);
     impl CoerceFromVariant for Rid = from_sys(godot_variant_as_rid);
     impl CoerceFromVariant for VariantArray<Shared> = from_sys(godot_variant_as_array);
-    impl CoerceFromVariant for ByteArray = from_sys(godot_variant_as_pool_byte_array);
-    impl CoerceFromVariant for Int32Array = from_sys(godot_variant_as_pool_int_array);
-    impl CoerceFromVariant for Float32Array = from_sys(godot_variant_as_pool_real_array);
-    impl CoerceFromVariant for StringArray = from_sys(godot_variant_as_pool_string_array);
-    impl CoerceFromVariant for Vector2Array = from_sys(godot_variant_as_pool_vector2_array);
-    impl CoerceFromVariant for Vector3Array = from_sys(godot_variant_as_pool_vector3_array);
-    impl CoerceFromVariant for ColorArray = from_sys(godot_variant_as_pool_color_array);
+    impl CoerceFromVariant for PoolArray<u8> = from_sys(godot_variant_as_pool_byte_array);
+    impl CoerceFromVariant for PoolArray<i32> = from_sys(godot_variant_as_pool_int_array);
+    impl CoerceFromVariant for PoolArray<f32> = from_sys(godot_variant_as_pool_real_array);
+    impl CoerceFromVariant for PoolArray<GodotString> = from_sys(godot_variant_as_pool_string_array);
+    impl CoerceFromVariant for PoolArray<Vector2> = from_sys(godot_variant_as_pool_vector2_array);
+    impl CoerceFromVariant for PoolArray<Vector3> = from_sys(godot_variant_as_pool_vector3_array);
+    impl CoerceFromVariant for PoolArray<Color> = from_sys(godot_variant_as_pool_color_array);
     impl CoerceFromVariant for Dictionary<Shared> = from_sys(godot_variant_as_dictionary);
 );
 
diff --git a/gdnative-core/src/core_types/vector2_array.rs b/gdnative-core/src/core_types/vector2_array.rs
@@ -4,13 +4,14 @@ use crate::core_types::Vector2;
 /// A reference-counted vector of `Vector2` that uses Godot's pool allocator.
 ///
 /// See [`PoolVector2Array`](https://docs.godotengine.org/en/stable/classes/class_poolvector2array.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type Vector2Array = PoolArray<Vector2>;
 
 godot_test!(
     test_vector2_array_access {
         use crate::object::NewRef as _;
 
-        let arr = Vector2Array::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Vector2::new(1.0, 2.0),
             Vector2::new(3.0, 4.0),
             Vector2::new(5.0, 6.0),
@@ -51,7 +52,7 @@ godot_test!(
 
 godot_test!(
     test_vector2_array_debug {
-        let arr = Vector2Array::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Vector2::new(1.0, 2.0),
             Vector2::new(3.0, 4.0),
             Vector2::new(5.0, 6.0),
diff --git a/gdnative-core/src/core_types/vector3_array.rs b/gdnative-core/src/core_types/vector3_array.rs
@@ -4,13 +4,14 @@ use crate::core_types::Vector3;
 /// A reference-counted vector of `Vector3` that uses Godot's pool allocator.
 ///
 /// See [`PoolVector3Array`](https://docs.godotengine.org/en/stable/classes/class_poolvector3array.html) in Godot.
+#[deprecated = "Specialized pool array aliases will be removed in a future godot-rust version. Use PoolArray<T> instead."]
 pub type Vector3Array = PoolArray<Vector3>;
 
 godot_test!(
     test_vector3_array_access {
         use crate::object::NewRef as _;
 
-        let arr = Vector3Array::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Vector3::new(1.0, 2.0, 3.0),
             Vector3::new(3.0, 4.0, 5.0),
             Vector3::new(5.0, 6.0, 7.0),
@@ -52,7 +53,7 @@ godot_test!(
 
 godot_test!(
     test_vector3_array_debug {
-        let arr = Vector3Array::from_vec(vec![
+        let arr = PoolArray::from_vec(vec![
             Vector3::new(1.0, 2.0, 3.0),
             Vector3::new(3.0, 4.0, 5.0),
             Vector3::new(5.0, 6.0, 7.0),
diff --git a/gdnative-core/src/export/property.rs b/gdnative-core/src/export/property.rs
@@ -537,13 +537,13 @@ mod impl_export {
     impl_export_for_core_type_without_hint!(NodePath);
     impl_export_for_core_type_without_hint!(Rid);
     impl_export_for_core_type_without_hint!(Dictionary);
-    impl_export_for_core_type_without_hint!(ByteArray);
-    impl_export_for_core_type_without_hint!(Int32Array);
-    impl_export_for_core_type_without_hint!(Float32Array);
-    impl_export_for_core_type_without_hint!(StringArray);
-    impl_export_for_core_type_without_hint!(Vector2Array);
-    impl_export_for_core_type_without_hint!(Vector3Array);
-    impl_export_for_core_type_without_hint!(ColorArray);
+    impl_export_for_core_type_without_hint!(PoolArray<u8>: ByteArray);
+    impl_export_for_core_type_without_hint!(PoolArray<i32>: Int32Array);
+    impl_export_for_core_type_without_hint!(PoolArray<f32>: Float32Array);
+    impl_export_for_core_type_without_hint!(PoolArray<GodotString>: StringArray);
+    impl_export_for_core_type_without_hint!(PoolArray<Vector2>: Vector2Array);
+    impl_export_for_core_type_without_hint!(PoolArray<Vector3>: Vector3Array);
+    impl_export_for_core_type_without_hint!(PoolArray<Color>: ColorArray);
 
     impl Export for Color {
         type Hint = hint::ColorHint;
diff --git a/gdnative/src/prelude.rs b/gdnative/src/prelude.rs
@@ -5,10 +5,13 @@ pub use gdnative_bindings::{
     ResourceLoader, SceneTree, Shader, Spatial, Sprite, Texture, Timer, Tween, Viewport,
 };
 pub use gdnative_core::core_types::{
-    Aabb, Basis, ByteArray, Color, ColorArray, Dictionary, Float32Array, GodotError, GodotString,
-    Int32Array, NodePath, Plane, PoolArray, Quat, Rect2, Rid, StringArray, StringName, Transform,
-    Transform2D, Variant, VariantArray, VariantDispatch, VariantOperator, VariantType, Vector2,
-    Vector2Array, Vector3, Vector3Array,
+    Aabb, Basis, Color, Dictionary, GodotError, GodotString, NodePath, Plane, PoolArray, Quat,
+    Rect2, Rid, StringName, Transform, Transform2D, Variant, VariantArray, VariantDispatch,
+    VariantOperator, VariantType, Vector2, Vector3,
+};
+#[allow(deprecated)]
+pub use gdnative_core::core_types::{
+    ByteArray, ColorArray, Float32Array, Int32Array, StringArray, Vector2Array, Vector3Array,
 };
 pub use gdnative_core::core_types::{
     FromVariant, FromVariantError, OwnedToVariant, ToVariant, ToVariantEq,
