implement mut bindings for match_class

Author: sylbeth

godot-core/src/classes/match_class.rs

@@ -35,7 +35,8 @@
 ///
 /// // More diverse dispatch patterns are also supported.
 /// let fancy_dispatch: i32 = match_class! { some_input(),
-///     button @ InputEventMouseButton => 1,
+///     // Mutable bindings supported:
+///     mut button @ InputEventMouseButton => 1,
 ///
 ///     // Block syntax for multiple statements:
 ///     motion @ InputEventMouseMotion => {
@@ -48,6 +49,8 @@
 ///
 ///     // Fallback with variable -- retrieves original Gd<InputEvent>.
 ///     original => 0,
+///     // Can also be used with mut:
+///     // mut original => 0,
 /// };
 ///
 /// // event_type is now 0, 1, 2, or 3
@@ -73,13 +76,24 @@ macro_rules! match_class {
 #[macro_export]
 macro_rules! match_class_muncher {
     /*
-    // If we want to support `var @ _ => { ... }` syntax, use this branch first (to not match `_` as type).
+    // If we want to support `variable @ _ => { ... }` syntax, use this branch first (to not match `_` as type).
     ($subject:ident, $var:ident @ _ => $block:expr $(,)?) => {{
         let $var = $subject;
         $block
     }};
      */
 
+    // mut variable @ Class => { ... }.
+    ($subject:ident, mut $var:ident @ $Ty:ty => $block:expr, $($rest:tt)*) => {{
+        match $subject.try_cast::<$Ty>() {
+            Ok(mut $var) => $block,
+            Err(__obj) => {
+                $crate::match_class_muncher!(__obj, $($rest)*)
+            }
+        }
+    }};
+
+    // variable @ Class => { ... }.
     ($subject:ident, $var:ident @ $Ty:ty => $block:expr, $($rest:tt)*) => {{
         match $subject.try_cast::<$Ty>() {
             Ok($var) => $block,
@@ -89,11 +103,19 @@ macro_rules! match_class_muncher {
         }
     }};
 
+    // mut variable => { ... }.
+    ($subject:ident, mut $var:ident => $block:expr $(,)?) => {{
+        let mut $var = $subject;
+        $block
+    }};
+
+    // variable => { ... }.
     ($subject:ident, $var:ident => $block:expr $(,)?) => {{
         let $var = $subject;
         $block
     }};
 
+    // _ => { ... }.
     ($subject:ident, _ => $block:expr $(,)?) => {{
         $block
     }};

itest/rust/src/engine_tests/match_class_test.rs

@@ -10,8 +10,10 @@ use godot::prelude::*; // Expect match_class! to be in prelude.
 
 // Ensure static types are as expected.
 fn require_object(_: &Object) {}
+fn require_mut_object(_: &mut Object) {}
 fn require_node(_: &Node) {}
 fn require_node2d(_: &Node2D) {}
+fn require_mut_node2d(_: &mut Node2D) {}
 
 #[itest]
 fn match_class_basic_dispatch() {
@@ -35,6 +37,28 @@ fn match_class_basic_dispatch() {
     to_free.free();
 }
 
+#[itest]
+fn match_class_basic_mut_dispatch() {
+    let node2d = Node2D::new_alloc();
+    let obj: Gd<Object> = node2d.upcast();
+    let to_free = obj.clone();
+
+    let result = match_class! { obj,
+        mut node @ Node2D => {
+            require_mut_node2d(&mut node);
+            1
+        },
+        node @ Node => {
+            require_node(&node);
+            2
+        },
+        _ => 3 // No comma.
+    };
+
+    assert_eq!(result, 1);
+    to_free.free();
+}
+
 #[itest]
 fn match_class_shadowed_by_more_general() {
     let node2d = Node2D::new_alloc();
@@ -86,6 +110,25 @@ fn match_class_named_fallback_matched() {
     assert_eq!(result, 3);
 }
 
+#[itest]
+fn match_class_named_mut_fallback_matched() {
+    let obj: Gd<Object> = Resource::new_gd().upcast();
+
+    let result = match_class! { obj,
+        _node @ Node => 1,
+        _node @ Node2D => 2,
+
+        // Named fallback with access to original object.
+        mut other => {
+            require_mut_object(&mut other);
+            assert_eq!(other.get_class(), "Resource".into());
+            3
+        }
+    };
+
+    assert_eq!(result, 3);
+}
+
 #[itest]
 fn match_class_named_fallback_unmatched() {
     // Test complex inline expression.