Merge #872

872: New syntax for #[export] methods and #[base] parameters r=Bromeon a=B-head

Resolve #850

### Feature
Allows onwer argument to be omitted.
```rust
#[method]
fn foo(&self, a: i32, b: i32) -> i32 {
    a + b
}
```

By adding the #[base] attribute to the argument, it is defined as the owner argument. Only the second argument can be the owner argument. Also, there is no way to define the owner argument without #[base].
```rust
#[method]
fn foo(&self, #[base] base: TRef<&Node>, value: i32) {
    base.do_something(value);
}
```

All optional parameters that can be used with the #[export] attribute can also be used with #[method].

### Compatibility
The old syntax #[export] attribute will continue to be supported. (It does _not_ support omission of the owner argument.)
```rust
#[export]
fn foo(&self, base: TRef<&Node>, value: i32) {
    base.do_something(value);
}
```

The `godot_wrap_method!` macro is not compatible because its definition has changed. (Can be fixed for compatibility if needed)

Written tests. (B-head#1)

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

Author: 3 people

examples/dodge-the-creeps/src/hud.rs

@@ -16,8 +16,8 @@ impl Hud {
         Hud
     }
 
-    #[export]
-    pub fn show_message(&self, owner: &CanvasLayer, text: String) {
+    #[godot]
+    pub fn show_message(&self, #[base] owner: &CanvasLayer, text: String) {
         let message_label = unsafe { owner.get_node_as::<Label>("message_label").unwrap() };
         message_label.set_text(text);
         message_label.show();
@@ -37,21 +37,21 @@ impl Hud {
         button.show();
     }
 
-    #[export]
-    pub fn update_score(&self, owner: &CanvasLayer, score: i64) {
+    #[godot]
+    pub fn update_score(&self, #[base] owner: &CanvasLayer, score: i64) {
         let label = unsafe { owner.get_node_as::<Label>("score_label").unwrap() };
         label.set_text(score.to_string());
     }
 
-    #[export]
-    fn on_start_button_pressed(&self, owner: &CanvasLayer) {
+    #[godot]
+    fn on_start_button_pressed(&self, #[base] owner: &CanvasLayer) {
         let button = unsafe { owner.get_node_as::<Button>("start_button").unwrap() };
         button.hide();
         owner.emit_signal("start_game", &[]);
     }
 
-    #[export]
-    fn on_message_timer_timeout(&self, owner: &CanvasLayer) {
+    #[godot]
+    fn on_message_timer_timeout(&self, #[base] owner: &CanvasLayer) {
         let message_label = unsafe { owner.get_node_as::<Label>("message_label").unwrap() };
         message_label.hide()
     }

examples/dodge-the-creeps/src/main_scene.rs

@@ -24,8 +24,8 @@ impl Main {
         }
     }
 
-    #[export]
-    fn game_over(&self, owner: &Node) {
+    #[godot]
+    fn game_over(&self, #[base] owner: &Node) {
         let score_timer = unsafe { owner.get_node_as::<Timer>("score_timer").unwrap() };
         let mob_timer = unsafe { owner.get_node_as::<Timer>("mob_timer").unwrap() };
 
@@ -38,8 +38,8 @@ impl Main {
             .unwrap_or_else(|| godot_print!("Unable to get hud"));
     }
 
-    #[export]
-    fn new_game(&mut self, owner: &Node) {
+    #[godot]
+    fn new_game(&mut self, #[base] owner: &Node) {
         let start_position = unsafe { owner.get_node_as::<Position2D>("start_position").unwrap() };
         let player = unsafe {
             owner
@@ -66,16 +66,16 @@ impl Main {
         .unwrap_or_else(|| godot_print!("Unable to get hud"));
     }
 
-    #[export]
-    fn on_start_timer_timeout(&self, owner: &Node) {
+    #[godot]
+    fn on_start_timer_timeout(&self, #[base] owner: &Node) {
         let mob_timer = unsafe { owner.get_node_as::<Timer>("mob_timer").unwrap() };
         let score_timer = unsafe { owner.get_node_as::<Timer>("score_timer").unwrap() };
         mob_timer.start(0.0);
         score_timer.start(0.0);
     }
 
-    #[export]
-    fn on_score_timer_timeout(&mut self, owner: &Node) {
+    #[godot]
+    fn on_score_timer_timeout(&mut self, #[base] owner: &Node) {
         self.score += 1;
 
         let hud = unsafe { owner.get_node_as_instance::<hud::Hud>("hud").unwrap() };
@@ -84,8 +84,8 @@ impl Main {
             .unwrap_or_else(|| godot_print!("Unable to get hud"));
     }
 
-    #[export]
-    fn on_mob_timer_timeout(&self, owner: &Node) {
+    #[godot]
+    fn on_mob_timer_timeout(&self, #[base] owner: &Node) {
         let mob_spawn_location = unsafe {
             owner
                 .get_node_as::<PathFollow2D>("mob_path/mob_spawn_locations")

examples/dodge-the-creeps/src/mob.rs

@@ -40,8 +40,8 @@ impl Mob {
         }
     }
 
-    #[export]
-    fn _ready(&mut self, owner: &RigidBody2D) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: &RigidBody2D) {
         let mut rng = rand::thread_rng();
         let animated_sprite = unsafe {
             owner
@@ -51,15 +51,15 @@ impl Mob {
         animated_sprite.set_animation(MOB_TYPES.choose(&mut rng).unwrap().to_str())
     }
 
-    #[export]
-    fn on_visibility_screen_exited(&self, owner: &RigidBody2D) {
+    #[godot]
+    fn on_visibility_screen_exited(&self, #[base] owner: &RigidBody2D) {
         unsafe {
             owner.assume_unique().queue_free();
         }
     }
 
-    #[export]
-    fn on_start_game(&self, owner: &RigidBody2D) {
+    #[godot]
+    fn on_start_game(&self, #[base] owner: &RigidBody2D) {
         unsafe {
             owner.assume_unique().queue_free();
         }

examples/dodge-the-creeps/src/player.rs

@@ -26,15 +26,15 @@ impl Player {
         }
     }
 
-    #[export]
-    fn _ready(&mut self, owner: &Area2D) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: &Area2D) {
         let viewport = owner.get_viewport_rect();
         self.screen_size = viewport.size;
         owner.hide();
     }
 
-    #[export]
-    fn _process(&mut self, owner: &Area2D, delta: f32) {
+    #[godot]
+    fn _process(&mut self, #[base] owner: &Area2D, delta: f32) {
         let animated_sprite = unsafe {
             owner
                 .get_node_as::<AnimatedSprite>("animated_sprite")
@@ -88,8 +88,8 @@ impl Player {
         owner.set_global_position(position);
     }
 
-    #[export]
-    fn on_player_body_entered(&self, owner: &Area2D, _body: Ref<PhysicsBody2D>) {
+    #[godot]
+    fn on_player_body_entered(&self, #[base] owner: &Area2D, _body: Ref<PhysicsBody2D>) {
         owner.hide();
         owner.emit_signal("hit", &[]);
 
@@ -102,8 +102,8 @@ impl Player {
         collision_shape.set_deferred("disabled", true);
     }
 
-    #[export]
-    pub fn start(&self, owner: &Area2D, pos: Vector2) {
+    #[godot]
+    pub fn start(&self, #[base] owner: &Area2D, pos: Vector2) {
         owner.set_global_position(pos);
         owner.show();
 

examples/hello-world/src/lib.rs

@@ -10,8 +10,8 @@ impl HelloWorld {
         HelloWorld
     }
 
-    #[export]
-    fn _ready(&self, _owner: &Node) {
+    #[godot]
+    fn _ready(&self) {
         godot_print!("hello, world.")
     }
 }

examples/native-plugin/src/lib.rs

@@ -14,8 +14,8 @@ impl CustomNode {
         CustomNode
     }
 
-    #[export]
-    fn _enter_tree(&self, owner: TRef<EditorPlugin>) {
+    #[godot]
+    fn _enter_tree(&self, #[base] owner: TRef<EditorPlugin>) {
         // Initialization of the plugin goes here.
         // Add the new type with a name, a parent type, a script and an icon.
         let script = unsafe { load::<Script>("res://my_button.gdns", "Script").unwrap() };
@@ -25,8 +25,8 @@ impl CustomNode {
         owner.add_custom_type("MyButton", "Button", script, texture);
     }
 
-    #[export]
-    fn _exit_tree(&self, owner: TRef<EditorPlugin>) {
+    #[godot]
+    fn _exit_tree(&self, #[base] owner: TRef<EditorPlugin>) {
         // Clean-up of the plugin goes here.
         // Always remember to remove it from the engine when deactivated.
         owner.remove_custom_type("MyButton");
@@ -43,15 +43,15 @@ impl MyButton {
         MyButton
     }
 
-    #[export]
-    fn _enter_tree(&self, owner: TRef<Button>) {
+    #[godot]
+    fn _enter_tree(&self, #[base] owner: TRef<Button>) {
         owner
             .connect("pressed", owner, "clicked", VariantArray::new_shared(), 0)
             .unwrap();
     }
 
-    #[export]
-    fn clicked(&self, _owner: TRef<Button>) {
+    #[godot]
+    fn clicked(&self) {
         godot_print!("You clicked me!");
     }
 }

examples/resource/src/lib.rs

@@ -37,8 +37,8 @@ impl Greeter {
         }
     }
 
-    #[export]
-    fn _ready(&self, _owner: &Node) {
+    #[godot]
+    fn _ready(&self) {
         if let Some(greeting_resource) = self.greeting_resource.as_ref() {
             let greeting_resource = unsafe { greeting_resource.assume_safe() };
             greeting_resource.map(|s, o| s.say_hello(&*o)).unwrap();

examples/rpc/src/client.rs

@@ -17,8 +17,8 @@ impl ServerPuppet {
         Self
     }
 
-    #[export]
-    fn _ready(&mut self, owner: TRef<Node>) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: TRef<Node>) {
         let peer = NetworkedMultiplayerENet::new();
         peer.create_client(
             GodotString::from(ADDRESS),
@@ -44,13 +44,13 @@ impl ServerPuppet {
         .unwrap();
     }
 
-    #[export]
-    fn on_connected_to_server(&mut self, owner: TRef<Node>) {
+    #[godot]
+    fn on_connected_to_server(&mut self, #[base] owner: TRef<Node>) {
         owner.rpc("greet_server", &[Variant::new("hello")]);
     }
 
-    #[export(rpc = "puppet")]
-    fn return_greeting(&mut self, _owner: &Node, msg: GodotString) {
+    #[godot(rpc = "puppet")]
+    fn return_greeting(&mut self, msg: GodotString) {
         godot_print!("Server says: {}", msg);
     }
 }

examples/rpc/src/server.rs

@@ -16,8 +16,8 @@ impl Server {
         Self
     }
 
-    #[export]
-    fn _ready(&mut self, owner: &Node) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: &Node) {
         let peer = NetworkedMultiplayerENet::new();
         peer.create_server(PORT, MAX_CLIENTS, IN_BANDWIDTH, OUT_BANDWIDTH)
             .unwrap();
@@ -28,8 +28,8 @@ impl Server {
         tree.set_network_peer(peer);
     }
 
-    #[export(rpc = "master")]
-    fn greet_server(&mut self, owner: &Node, msg: GodotString) {
+    #[godot(rpc = "master")]
+    fn greet_server(&mut self, #[base] owner: &Node, msg: GodotString) {
         godot_print!("Client says: {}", msg);
 
         let tree = owner.get_tree().expect("could not retreive Scene Tree");

examples/scene-create/src/lib.rs

@@ -33,17 +33,17 @@ impl SceneCreate {
         }
     }
 
-    #[gdnative::derive::export]
-    fn _ready(&mut self, _owner: &Spatial) {
+    #[gdnative::derive::godot]
+    fn _ready(&mut self) {
         self.template = load_scene("res://Child_scene.tscn");
         match &self.template {
             Some(_scene) => godot_print!("Loaded child scene successfully!"),
             None => godot_print!("Could not load child scene. Check name."),
         }
     }
 
-    #[gdnative::derive::export]
-    fn spawn_one(&mut self, owner: &Spatial, message: GodotString) {
+    #[gdnative::derive::godot]
+    fn spawn_one(&mut self, #[base] owner: &Spatial, message: GodotString) {
         godot_print!("Called spawn_one({})", message.to_string());
 
         let template = if let Some(template) = &self.template {
@@ -77,8 +77,8 @@ impl SceneCreate {
         update_panel(owner, num_children);
     }
 
-    #[gdnative::derive::export]
-    fn remove_one(&mut self, owner: &Spatial, str: GodotString) {
+    #[gdnative::derive::godot]
+    fn remove_one(&mut self, #[base] owner: &Spatial, str: GodotString) {
         godot_print!("Called remove_one({})", str);
         let num_children = owner.get_child_count();
         if num_children <= 0 {

examples/signals/src/lib.rs

@@ -28,8 +28,8 @@ impl SignalEmitter {
         }
     }
 
-    #[export]
-    fn _process(&mut self, owner: &Node, delta: f64) {
+    #[godot]
+    fn _process(&mut self, #[base] owner: &Node, delta: f64) {
         if self.timer < 1.0 {
             self.timer += delta;
             return;
@@ -57,8 +57,8 @@ impl SignalSubscriber {
         SignalSubscriber { times_received: 0 }
     }
 
-    #[export]
-    fn _ready(&mut self, owner: TRef<Label>) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: TRef<Label>) {
         let emitter = &mut owner.get_node("../SignalEmitter").unwrap();
         let emitter = unsafe { emitter.assume_safe() };
 
@@ -76,16 +76,16 @@ impl SignalSubscriber {
             .unwrap();
     }
 
-    #[export]
-    fn notify(&mut self, owner: &Label) {
+    #[godot]
+    fn notify(&mut self, #[base] owner: &Label) {
         self.times_received += 1;
         let msg = format!("Received signal \"tick\" {} times", self.times_received);
 
         owner.set_text(msg);
     }
 
-    #[export]
-    fn notify_with_data(&mut self, owner: &Label, data: Variant) {
+    #[godot]
+    fn notify_with_data(&mut self, #[base] owner: &Label, data: Variant) {
         let msg = format!(
             "Received signal \"tick_with_data\" with data {}",
             data.try_to::<u64>().unwrap()

examples/spinning-cube/src/lib.rs

@@ -46,13 +46,13 @@ impl RustTest {
         }
     }
 
-    #[export]
-    fn _ready(&mut self, owner: &MeshInstance) {
+    #[godot]
+    fn _ready(&mut self, #[base] owner: &MeshInstance) {
         owner.set_physics_process(true);
     }
 
-    #[export]
-    fn _physics_process(&mut self, owner: &MeshInstance, delta: f64) {
+    #[godot]
+    fn _physics_process(&mut self, #[base] owner: &MeshInstance, delta: f64) {
         use gdnative::api::SpatialMaterial;
 
         self.time += delta as f32;