Support enum variants and structs with no fields in matches_pattern!.

Previously, attempting to match a pattern on an enum variant with no fields would not be matched by `matches_pattern!`, resulting in a recursion error during compilation:

```
enum MyEnum {
    A
}
verify_that!(value, matches_pattern!(MyEnum::A))
                                     ^^^^^^^^^ Error! Maximum recursion depth exceeded.
```

The support had simply been omitted from `matches_pattern!`. This adds support for such cases to the macro, using the `predicate` matcher to handle them.

PiperOrigin-RevId: 539567060

Author: hovinenb

googletest/src/matchers/matches_pattern.rs

@@ -387,6 +387,16 @@ macro_rules! matches_pattern_internal {
         )
     };
 
+    (
+        [$($struct_name:tt)*],
+    ) => {
+        $crate::matchers::predicate(|v| matches!(v, $($struct_name)*))
+            .with_description(
+                concat!("is ", stringify!($($struct_name)*)),
+                concat!("is not ", stringify!($($struct_name)*)),
+            )
+    };
+
     (
         [$($struct_name:tt)*],
         ($matcher:expr $(,)?)

googletest/tests/matches_pattern_test.rs

@@ -366,7 +366,46 @@ fn matches_tuple_struct_with_two_fields_and_trailing_comma() -> Result<()> {
 }
 
 #[test]
-fn matches_enum_value() -> Result<()> {
+fn matches_enum_without_field() -> Result<()> {
+    #[derive(Debug)]
+    enum AnEnum {
+        A,
+    }
+    let actual = AnEnum::A;
+
+    verify_that!(actual, matches_pattern!(AnEnum::A))
+}
+
+#[test]
+fn generates_correct_failure_output_when_enum_variant_without_field_is_not_matched() -> Result<()> {
+    #[derive(Debug)]
+    enum AnEnum {
+        #[allow(unused)]
+        A,
+        B,
+    }
+    let actual = AnEnum::B;
+
+    let result = verify_that!(actual, matches_pattern!(AnEnum::A));
+
+    verify_that!(result, err(displays_as(contains_substring("is not AnEnum :: A"))))
+}
+
+#[test]
+fn generates_correct_failure_output_when_enum_variant_without_field_is_matched() -> Result<()> {
+    #[derive(Debug)]
+    enum AnEnum {
+        A,
+    }
+    let actual = AnEnum::A;
+
+    let result = verify_that!(actual, not(matches_pattern!(AnEnum::A)));
+
+    verify_that!(result, err(displays_as(contains_substring("is AnEnum :: A"))))
+}
+
+#[test]
+fn matches_enum_with_field() -> Result<()> {
     #[derive(Debug)]
     enum AnEnum {
         A(u32),