Merge #1006 #1007

1006: Expose RPC modes for properties r=chitoyuu a=chitoyuu

This adds:

- The `PropertyBuilder::with_rpc_mode` method
- The `#[property(rpc = "mode")]` syntax for the NativeClass macro

Close #995

1007: Deprecate specialized pool array aliases r=chitoyuu a=chitoyuu

Related: #773

Co-authored-by: Chitose Yuuzaki <chitoyuu@potatoes.gay>

Author: bors[bot]

examples/rpc/src/client.rs

@@ -47,6 +47,7 @@ impl ServerPuppet {
     #[method]
     fn on_connected_to_server(&mut self, #[base] owner: TRef<Node>) {
         owner.rpc("greet_server", &[Variant::new("hello")]);
+        owner.rset("foo", 42);
     }
 
     #[method(rpc = "puppet")]

examples/rpc/src/server.rs

@@ -8,12 +8,15 @@ const OUT_BANDWIDTH: i64 = 1000;
 
 #[derive(NativeClass)]
 #[inherit(Node)]
-pub struct Server;
+pub struct Server {
+    #[property(rpc = "master", set = "Self::set_foo")]
+    foo: i32,
+}
 
 #[methods]
 impl Server {
     fn new(_owner: &Node) -> Self {
-        Self
+        Self { foo: 0 }
     }
 
     #[method]
@@ -41,4 +44,10 @@ impl Server {
             &[Variant::new("hello")],
         );
     }
+
+    #[method]
+    fn set_foo(&mut self, #[base] _owner: TRef<Node>, value: i32) {
+        godot_print!("Client sets foo to: {}", value);
+        self.foo = value;
+    }
 }

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]");
     }
 );

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),

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]");
     }
 );

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]");
     }
 );

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"),

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);
 );
 

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),

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),