allow unnamed variables in match class + tests

Author: sylbeth

godot-core/src/classes/match_class.rs

@@ -26,13 +26,15 @@
 /// # // Hack to keep amount of SELECTED_CLASSES limited:
 /// # type InputEventMouseButton = InputEventAction;
 /// # type InputEventMouseMotion = InputEventAction;
+/// # type InputEventKey = InputEventAction;
 /// // Basic syntax.
 /// let event: Gd<InputEvent> = some_input();
 ///
 /// let simple_dispatch: i32 = match_class! { event,
 ///    button @ InputEventMouseButton => 1,
 ///    motion @ InputEventMouseMotion => 2,
 ///    action @ InputEventAction => 3,
+///    key @ InputEventKey => 4,
 ///    _ => 0, // Fallback.
 /// };
 ///
@@ -50,14 +52,18 @@
 ///     // Qualified types supported:
 ///     action @ godot::classes::InputEventAction => 3,
 ///
+///     // If you're only interested in the class and not the object,
+///     // discard it with either `_` or `_variable`:
+///     _ @ InputEventKey => 4,
+///
 ///     // Fallback with variable -- retrieves original Gd<InputEvent>.
 ///     original => 0,
 ///     // Can also be used with mut:
 ///     // mut original => 0,
 ///     // If the match arms have type (), we can also omit the fallback branch.
 /// };
 ///
-/// // event_type is now 0, 1, 2, or 3
+/// // event_type is now 0, 1, 2, 3 or 4
 /// ```
 ///
 /// # Expression and control flow
@@ -99,6 +105,16 @@ macro_rules! match_class_muncher {
         }
     }};
 
+    // _ @ Class => { ... }.
+    ($subject:ident, _ @ $Ty:ty => $block:expr, $($rest:tt)*) => {{
+        match $subject.try_cast::<$Ty>() {
+            Ok(_) => $block,
+            Err(__obj) => {
+                $crate::match_class_muncher!(__obj, $($rest)*)
+            }
+        }
+    }};
+
     // mut variable => { ... }.
     ($subject:ident, mut $var:ident => $block:expr $(,)?) => {{
         let mut $var = $subject;

itest/rust/src/engine_tests/match_class_test.rs

@@ -59,6 +59,29 @@ fn match_class_basic_mut_dispatch() {
     to_free.free();
 }
 
+#[itest]
+fn match_class_basic_unnamed_dispatch() {
+    let node3d = Node3D::new_alloc();
+    let obj: Gd<Object> = node3d.upcast();
+    let to_free = obj.clone();
+
+    let result = match_class! { obj,
+        node @ Node2D => {
+            require_node2d(&node);
+            1
+        },
+        _ @ Node3D => 2,
+        node @ Node => {
+            require_node(&node);
+            3
+        },
+        _ => 4 // No comma.
+    };
+
+    assert_eq!(result, 2);
+    to_free.free();
+}
+
 #[itest]
 fn match_class_shadowed_by_more_general() {
     let node2d = Node2D::new_alloc();
@@ -172,13 +195,16 @@ fn match_class_unit_type() {
     let mut val = 0;
 
     match_class! { obj,
+        _ @ Node3D => {
+            val = 1;
+        },
         mut node @ Node2D => {
             require_mut_node2d(&mut node);
-            val = 1;
+            val = 2;
         },
         node @ Node => {
             require_node(&node);
-            val = 2;
+            val = 3;
         },
         // No need for _ branch since all branches return ().
     }