Merge #828

828: Remove deprecated symbols from v0.9 r=Bromeon a=Bromeon

Changes:
* `PoolArray` type aliases: document name of Godot equivalent + API link
* `ClassBuilder`
  * Remove `add_method()`
  * Remove `add_method_advanced()` -- now private
  * Remove `add_method_with_rpc_mode()`
  * Rename `add_property()` -> `property()`
  * Rename `build_method()` -> `method()`
  * Add `signal()`
* Add `SignalBuilder` + `with_param*()` methods
* Remove `ScriptMethod`, `ScriptMethodFn`, `ScriptMethodAttributes`
* Remove `Color::rgb()`, `Color::rgba()`
* Remove `Reference::init_ref()` (unsound to call directly)
* Remove `FloatHint::Enum` (has no effect)
* Rename `Element` -> `PoolElement`
* Rename `SignalArgument` -> `SignalParam`
* Rename `String::forget()` -> `leak()`
* Rename `Variant::forget()` -> `leak()`
* Fix bug with signal parameter types annotated in builder not propagated to Godot
* Annotate 3 builders with `#[must_use]` to avoid forgetting building
   * Not done for `ClassBuilder`; it's not a builder in that sense

Co-authored-by: Jan Haller <[email protected]>

Author: bors[bot]

bindings_generator/src/methods.rs

@@ -136,7 +136,7 @@ impl MethodSig {
 }
 
 fn skip_method(method: &GodotMethod, name: &str) -> bool {
-    const METHODS: &[&str] = &["free", "reference", "unreference"];
+    const METHODS: &[&str] = &["free", "reference", "unreference", "init_ref"];
     METHODS.contains(&name) || method.is_virtual
 }
 

examples/array_export/src/lib.rs

@@ -14,25 +14,28 @@ impl ExportsArrays {
 
     fn register(builder: &ClassBuilder<Self>) {
         builder
-            .add_property::<VariantArray>("single_array")
+            .property::<VariantArray>("single_array")
             .with_setter(ExportsArrays::set_single_array)
             .done();
+
         builder
-            .add_property::<VariantArray>("single_array_range")
+            .property::<VariantArray>("single_array_range")
             .with_setter(ExportsArrays::set_single_array_range)
             .with_hint(ArrayHint::with_element_hint::<i64>(IntHint::Range(
                 RangeHint::new(-5, 5),
             )))
             .done();
+
         builder
-            .add_property::<VariantArray>("double_array")
+            .property::<VariantArray>("double_array")
             .with_setter(ExportsArrays::set_double_array)
             .with_hint(ArrayHint::with_element_hint::<VariantArray>(
                 ArrayHint::new(),
             ))
             .done();
+
         builder
-            .add_property::<VariantArray>("double_array_range")
+            .property::<VariantArray>("double_array_range")
             .with_setter(ExportsArrays::set_double_array_range)
             .with_hint(ArrayHint::with_element_hint::<VariantArray>(
                 ArrayHint::with_element_hint::<i64>(IntHint::Range(RangeHint::new(-5, 5))),

examples/dodge_the_creeps/src/hud.rs

@@ -9,10 +9,7 @@ pub struct Hud;
 #[methods]
 impl Hud {
     fn register_hud(builder: &ClassBuilder<Self>) {
-        builder.add_signal(Signal {
-            name: "start_game",
-            args: &[],
-        });
+        builder.signal("start_game").done();
     }
 
     fn new(_owner: &CanvasLayer) -> Self {

examples/dodge_the_creeps/src/player.rs

@@ -16,10 +16,7 @@ pub struct Player {
 #[methods]
 impl Player {
     fn register_player(builder: &ClassBuilder<Self>) {
-        builder.add_signal(Signal {
-            name: "hit",
-            args: &[],
-        });
+        builder.signal("hit").done()
     }
 
     fn new(_owner: &Area2D) -> Self {

examples/signals/src/lib.rs

@@ -12,21 +12,13 @@ struct SignalEmitter {
 #[methods]
 impl SignalEmitter {
     fn register_signals(builder: &ClassBuilder<Self>) {
-        builder.add_signal(Signal {
-            name: "tick",
-            args: &[],
-        });
+        builder.signal("tick").done();
 
-        builder.add_signal(Signal {
-            name: "tick_with_data",
+        builder
+            .signal("tick_with_data")
             // Argument list used by the editor for GUI and generation of GDScript handlers. It can be omitted if the signal is only used from code.
-            args: &[SignalArgument {
-                name: "data",
-                default: Variant::new(100),
-                export_info: ExportInfo::new(VariantType::I64),
-                usage: PropertyUsage::DEFAULT,
-            }],
-        });
+            .with_param_default("data", Variant::new(100))
+            .done();
     }
 
     fn new(_owner: &Node) -> Self {

examples/spinning_cube/src/lib.rs

@@ -15,7 +15,7 @@ struct RustTest {
 
 fn register_properties(builder: &ClassBuilder<RustTest>) {
     builder
-        .add_property::<String>("test/test_enum")
+        .property::<String>("test/test_enum")
         .with_hint(StringHint::Enum(EnumHint::new(vec![
             "Hello".into(),
             "World".into(),
@@ -25,7 +25,7 @@ fn register_properties(builder: &ClassBuilder<RustTest>) {
         .done();
 
     builder
-        .add_property("test/test_flags")
+        .property("test/test_flags")
         .with_hint(IntHint::Flags(EnumHint::new(vec![
             "A".into(),
             "B".into(),

gdnative-async/src/rt/bridge.rs

@@ -134,8 +134,6 @@ impl Method<SignalBridge> for OnSignalFn {
 
 impl NativeClassMethods for SignalBridge {
     fn register(builder: &ClassBuilder<Self>) {
-        builder
-            .build_method("_on_signal", OnSignalFn)
-            .done_stateless();
+        builder.method("_on_signal", OnSignalFn).done_stateless();
     }
 }

gdnative-async/src/rt/func_state.rs

@@ -1,9 +1,8 @@
 use gdnative_bindings::Reference;
-use gdnative_core::core_types::{ToVariant, Variant, VariantType};
+use gdnative_core::core_types::{ToVariant, Variant};
 use gdnative_core::export::user_data::{LocalCellData, Map, MapMut};
 use gdnative_core::export::{
-    ClassBuilder, ExportInfo, NativeClass, NativeClassMethods, PropertyUsage, Signal,
-    SignalArgument, StaticArgs, StaticArgsMethod,
+    ClassBuilder, NativeClass, NativeClassMethods, StaticArgs, StaticArgsMethod,
 };
 use gdnative_core::godot_site;
 use gdnative_core::object::ownership::Unique;
@@ -32,20 +31,12 @@ impl NativeClass for FuncState {
     }
 
     fn register_properties(builder: &ClassBuilder<Self>) {
-        builder.add_signal(Signal {
-            name: "completed",
-            args: &[SignalArgument {
-                name: "value",
-                default: Variant::nil(),
-                export_info: ExportInfo::new(VariantType::Nil),
-                usage: PropertyUsage::DEFAULT,
-            }],
-        });
-
-        builder.add_signal(Signal {
-            name: "resumable",
-            args: &[],
-        });
+        builder
+            .signal("completed")
+            .with_param_untyped("value")
+            .done();
+
+        builder.signal("resumable").done();
     }
 }
 
@@ -169,10 +160,10 @@ impl StaticArgsMethod<FuncState> for ResumeFn {
 impl NativeClassMethods for FuncState {
     fn register(builder: &ClassBuilder<Self>) {
         builder
-            .build_method("is_valid", StaticArgs::new(IsValidFn))
+            .method("is_valid", StaticArgs::new(IsValidFn))
             .done_stateless();
         builder
-            .build_method("resume", StaticArgs::new(ResumeFn))
+            .method("resume", StaticArgs::new(ResumeFn))
             .done_stateless();
     }
 }

gdnative-core/src/core_types/access.rs

@@ -50,12 +50,12 @@ pub unsafe trait Guard: private::Sealed {
 pub unsafe trait WritePtr: Guard + private::Sealed {}
 
 pub(crate) mod private {
-    use crate::core_types::pool_array::Element;
+    use crate::core_types::PoolElement;
 
     pub trait Sealed {}
 
-    impl<'a, T: Element> Sealed for crate::core_types::pool_array::ReadGuard<'a, T> {}
-    impl<'a, T: Element> Sealed for crate::core_types::pool_array::WriteGuard<'a, T> {}
+    impl<'a, T: PoolElement> Sealed for crate::core_types::pool_array::ReadGuard<'a, T> {}
+    impl<'a, T: PoolElement> Sealed for crate::core_types::pool_array::WriteGuard<'a, T> {}
 }
 
 impl<G: Guard> MaybeUnaligned<G> {

gdnative-core/src/core_types/byte_array.rs

@@ -1,6 +1,8 @@
 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.
 pub type ByteArray = PoolArray<u8>;
 
 godot_test!(