Fix the parsing of matches_pattern! to properly support enums like Option. Previously, the pattern Some(_) would be parsed as None. Now the Some variant with wildcard will be parsed correctly.

Toward #626

PiperOrigin-RevId: 748656817

Author: Googler

googletest/src/matchers/matches_pattern.rs

@@ -268,6 +268,17 @@
 /// # should_fail().unwrap_err();
 /// ```
 ///
+/// When matching against enums like `Option`, the `matches_pattern!` macro now
+/// correctly handles patterns like `Some(_)` and `Some(value)`.
+/// For example:
+///
+/// ```
+/// # use googletest::prelude::*;
+/// let result: Option<i8> = None;
+/// verify_that!(result, matches_pattern!(Some(_))).is_err(); // Fails
+/// verify_that!(result, matches_pattern!(Some(123))).is_err(); // Fails
+/// ```
+
 /// This macro does not support plain (non-struct) tuples. But it should not be
 /// necessary as tuple of matchers are matchers of tuple. In other words, if
 /// `MatcherU: Matcher<U>` and `MatcherT: Matcher<T>`, then `(MatcherU,

googletest/tests/matches_pattern_test.rs

@@ -494,7 +494,7 @@ fn matches_tuple_struct_with_two_fields_and_trailing_comma() -> Result<()> {
 
 #[test]
 fn matches_tuple_struct_with_interleaved_underscore() -> Result<()> {
-    #[derive(Debug)]
+    #[derive(Debug, Copy, Clone)]
     struct NonCopy;
     #[derive(Debug)]
     struct AStruct(u32, NonCopy, u32);
@@ -1870,3 +1870,47 @@ fn matches_struct_auto_eq() -> Result<()> {
         matches_pattern!(&AStruct { int: 123, string: ref "123", option: Some(123) })
     )
 }
+
+#[test]
+fn matches_enum_none_with_wildcard() -> Result<()> {
+    let result: Option<i8> = None;
+    let result = verify_that!(result, matches_pattern!(Some(_)));
+
+    const EXPECTED: &str = indoc!(
+        "
+        Expected: is Some which has field `0`, which is anything
+        Actual: None,
+          which has the wrong enum variant `None`
+        "
+    );
+
+    verify_that!(result, err(displays_as(contains_substring(EXPECTED))))
+}
+
+#[test]
+fn matches_enum_none_with_value() -> Result<()> {
+    let result: Option<i8> = None;
+    let result = verify_that!(result, matches_pattern!(Some(123)));
+
+    const EXPECTED: &str = indoc!(
+        "
+        Expected: is Some which has field `0`, which is equal to 123
+        Actual: None,
+          which has the wrong enum variant `None`
+        "
+    );
+
+    verify_that!(result, err(displays_as(contains_substring(EXPECTED))))
+}
+
+#[test]
+fn matches_enum_none_with_none() -> Result<()> {
+    let result: Option<i8> = None;
+    verify_that!(result, matches_pattern!(None))
+}
+
+#[test]
+fn matches_value_with_wildcard() -> Result<()> {
+    let result: Option<i8> = Some(123);
+    verify_that!(result, matches_pattern!(Some(_)))
+}

googletest_macro/src/matches_pattern.rs

@@ -16,7 +16,7 @@ use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
 use quote::{quote, ToTokens};
 use syn::{
     parse::{Parse, ParseStream, Parser as _},
-    parse_macro_input,
+    parse_macro_input, parse_quote,
     token::DotDot,
     Expr, ExprCall, Pat, Token,
 };
@@ -131,7 +131,9 @@ fn into_match_pattern_expr(stream: TokenStream) -> syn::Result<TokenStream> {
     Pat::parse_multi.parse2(stream.clone())?;
     Ok(quote! {
         googletest::matchers::__internal_unstable_do_not_depend_on_these::pattern_only(
-            |v| matches!(v, #stream),
+            |v| {
+                matches!(v, #stream)
+            },
             concat!("is ", stringify!(#stream)),
             concat!("is not ", stringify!(#stream)))
     })
@@ -140,8 +142,7 @@ fn into_match_pattern_expr(stream: TokenStream) -> syn::Result<TokenStream> {
 ////////////////////////////////////////////////////////////////////////////////
 // Parse tuple struct patterns
 
-/// Each part in a tuple matcher pattern that's between the commas. When `None`,
-/// it represents `_` which matches anything.
+/// Each part in a tuple matcher pattern that's between the commas.
 struct MaybeTupleFieldPattern(Option<TupleFieldPattern>);
 
 struct TupleFieldPattern {
@@ -152,7 +153,7 @@ struct TupleFieldPattern {
 impl Parse for MaybeTupleFieldPattern {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let pattern = match input.parse::<Option<Token![_]>>()? {
-            Some(_) => None,
+            Some(_) => Some(TupleFieldPattern { ref_token: None, matcher: parse_quote!(_) }),
             None => Some(TupleFieldPattern { ref_token: input.parse()?, matcher: input.parse()? }),
         };
         Ok(MaybeTupleFieldPattern(pattern))
@@ -173,7 +174,13 @@ fn parse_tuple_pattern_args(
         .filter_map(|(index, maybe_pattern)| maybe_pattern.0.map(|pattern| (index, pattern)))
         .map(|(index, TupleFieldPattern { ref_token, matcher })| {
             let index = syn::Index::from(index);
-            quote! { googletest::matchers::field!(#struct_name.#index, #ref_token #matcher) }
+            // `_` matches anything, so we can use anything as the matcher.
+            let matcher_to_use = if matches!(syn::parse2::<Expr>(quote! {#matcher}), Ok(parsed_matcher) if parsed_matcher == parse_quote!(_)) {
+                quote! { googletest::matchers::anything() }
+            } else {
+                quote! { #matcher }
+            };
+            quote! { googletest::matchers::field!(#struct_name.#index, #ref_token #matcher_to_use) }
         });
 
     let matcher = quote! {