In property_matcher! and field_matcher!, support explicit type parameters in structs and method calls. This effectively also adds support for these in matches_pattern!.

marcianx · copybara-github · commit f4b64c1fe737 · 2025-06-18T19:44:21.000-07:00
PiperOrigin-RevId: 708364017
diff --git a/googletest/src/internal/mod.rs b/googletest/src/internal/mod.rs
@@ -16,6 +16,7 @@
 
 pub(crate) mod description_renderer;
 pub mod glob;
+pub mod test_data;
 pub mod test_filter;
 pub mod test_outcome;
 pub mod test_sharding;
diff --git a/googletest/src/internal/test_data.rs b/googletest/src/internal/test_data.rs
@@ -0,0 +1,29 @@
+//! This is for testing only to provide fully-qualified struct paths to macros.
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct TestStruct {
+    #[doc(hidden)]
+    pub value: u32,
+}
+
+impl TestStruct {
+    #[doc(hidden)]
+    pub fn get_value(&self) -> u32 {
+        self.value
+    }
+}
+
+#[doc(hidden)]
+#[derive(Debug)]
+pub struct GenericTestStruct<T> {
+    #[doc(hidden)]
+    pub value: T,
+}
+
+impl<T> GenericTestStruct<T> {
+    #[doc(hidden)]
+    pub fn get_value<U>(&self, a: U) -> U {
+        a
+    }
+}
diff --git a/googletest/src/matchers/field_matcher.rs b/googletest/src/matchers/field_matcher.rs
@@ -196,41 +196,42 @@ macro_rules! __field {
 #[doc(hidden)]
 #[macro_export]
 macro_rules! field_internal {
-    (&$($t:ident)::+.$field:tt, ref $m:expr) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::field_matcher(
-            |o: &_| {
-                match o {
-                    &$($t)::* {$field: ref value, .. } => Some(value),
-                    // The pattern below is unreachable if the type is a struct (as opposed to an
-                    // enum). Since the macro can't know which it is, we always include it and just
-                    // tell the compiler not to complain.
-                    #[allow(unreachable_patterns)]
-                    _ => None,
-                }
-            },
-            &stringify!($field),
-            $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
+    (&$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, ref $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&_] [&$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [ref] [$m])
     }};
-    (&$($t:ident)::+.$field:tt, $m:expr) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::field_matcher(
-            |o: &&_| {
-                match o {
-                    &$($t)::* {$field: value, .. } => Some(value),
-                    // The pattern below is unreachable if the type is a struct (as opposed to an
-                    // enum). Since the macro can't know which it is, we always include it and just
-                    // tell the compiler not to complain.
-                    #[allow(unreachable_patterns)]
-                    _ => None,
-                }
-            },
-            &stringify!($field),
-            $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
+    (&$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&&_] [&$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [] [$m])
     }};
-    ($($t:ident)::+.$field:tt, $m:expr) => {{
+    ($($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&_] [$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [] [$m])
+    }};
+    (& :: $($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, ref $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&_] [&::$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [ref] [$m])
+    }};
+    (& :: $($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&&_] [&::$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [] [$m])
+    }};
+    (:: $($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)? .$field:tt, $m:expr) => {{
+        $crate::field_internal!(@internal
+            [&_] [::$($t)::* $(::<$($t_ty_args),*>)*]
+            [$field] [] [$m])
+    }};
+
+    (@internal [$struct_ty:ty] [$($field_prefix:tt)*] [$field:tt] [$($ref:tt)?] [$m:expr]) => {{
         $crate::matchers::__internal_unstable_do_not_depend_on_these::field_matcher(
-            |o: &_| {
+            |o: $struct_ty| {
                 match o {
-                    $($t)::* {$field: value, .. } => Some(value),
+                    $($field_prefix)* {$field: $($ref)* value, .. } => Some(value),
                     // The pattern below is unreachable if the type is a struct (as opposed to an
                     // enum). Since the macro can't know which it is, we always include it and just
                     // tell the compiler not to complain.
@@ -240,7 +241,8 @@ macro_rules! field_internal {
             },
             &stringify!($field),
             $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
-    }};
+
+    }}
 }
 
 /// Functions for use only by the declarative macros in this module.
diff --git a/googletest/src/matchers/property_matcher.rs b/googletest/src/matchers/property_matcher.rs
@@ -176,29 +176,82 @@ macro_rules! __property {
 #[doc(hidden)]
 #[macro_export]
 macro_rules! property_internal {
+    (& $($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        ref $m:expr) => {{
+        $crate::property_internal!(@self_arg
+            struct_type:   [&$($t)::+ $(  <$($t_ty_args),*>)*]
+            method_prefix: [ $($t)::+ $(::<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
+    ($($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        ref $m:expr) => {{
+        $crate::property_internal!(@self_arg
+            struct_type:   [$($t)::+ $(  <$($t_ty_args),*>)*]
+            method_prefix: [$($t)::+ $(::<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
+    (& ::$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        ref $m:expr) => {{
+        $crate::property_internal!(@self_arg
+            struct_type:   [&::$($t)::+ $(  <$($t_ty_args),*>)*]
+            method_prefix: [ ::$($t)::+ $(::<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
+    (::$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        ref $m:expr) => {{
+        $crate::property_internal!(@self_arg
+            struct_type:   [::$($t)::+ $(  <$($t_ty_args),*>)*]
+            method_prefix: [::$($t)::+ $(::<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
 
-    (&$($t:ident)::+.$method:tt($($argument:expr),* $(,)?), ref $m:expr) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::property_ref_matcher(
-            |o: &$($t)::+| $($t)::+::$method(o, $($argument),*),
-            &stringify!($method($($argument),*)),
-            $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
+    (& $($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        $m:expr) => {{
+        $crate::property_internal!(@self_dot
+            struct_type: [&&$($t)::+ $(<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
     }};
-    ($($t:ident)::+.$method:tt($($argument:expr),* $(,)?), ref $m:expr) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::property_ref_matcher(
-            |o: $($t)::+| $($t)::+::$method(o, $($argument),*),
-            &stringify!($method($($argument),*)),
-            $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
+    ($($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        $m:expr) => {{
+        $crate::property_internal!(@self_dot
+            struct_type: [&$($t)::+ $(<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
     }};
-    (& $($t:ident)::+.$method:tt($($argument:expr),* $(,)?), $m:expr) => {{
-        $crate::matchers::__internal_unstable_do_not_depend_on_these::property_matcher(
-            |o: &&$($t)::+| o.$method($($argument),*),
-            &stringify!($method($($argument),*)),
+    (& ::$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        $m:expr) => {{
+        $crate::property_internal!(@self_dot
+            struct_type: [&&::$($t)::+ $(<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
+    (::$($t:ident)::+ $(::<$($t_ty_args:ty),* $(,)?>)?
+        .$method:tt $(::<$($m_ty_args:ty),* $(,)?>)? ($($argument:expr),* $(,)?),
+        $m:expr) => {{
+        $crate::property_internal!(@self_dot
+            struct_type: [&::$($t)::+ $(<$($t_ty_args),*>)*]
+            [$method $(::<$($m_ty_args),*>)*] [$($argument),*] [$m])
+    }};
+
+    (@self_arg struct_type: [$struct_ty:ty]
+               method_prefix: [$($method_prefix:tt)+]
+               [$($method:tt)*] [$($argument:expr),*] [$m:expr]) => {{
+        $crate::matchers::__internal_unstable_do_not_depend_on_these::property_ref_matcher(
+            |o: $struct_ty| $($method_prefix)*::$($method)* (o, $($argument),*),
+            &stringify!($($method)* ($($argument),*)),
             $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
     }};
-    ($($t:ident)::+.$method:tt($($argument:expr),* $(,)?), $m:expr) => {{
+
+    (@self_dot struct_type: [$struct_ty:ty]
+               [$($method:tt)*] [$($argument:expr),*] [$m:expr]) => {{
         $crate::matchers::__internal_unstable_do_not_depend_on_these::property_matcher(
-            |o: &$($t)::+| o.$method($($argument),*),
-            &stringify!($method($($argument),*)),
+            |o: $struct_ty| o.$($method)* ($($argument),*),
+            &stringify!($($method)* ($($argument),*)),
             $crate::matcher_support::__internal_unstable_do_not_depend_on_these::auto_eq!($m))
     }};
 }
diff --git a/googletest/tests/field_matcher_test.rs b/googletest/tests/field_matcher_test.rs
@@ -263,3 +263,52 @@ fn matches_enum_with_auto_eq_with_wrapper() -> Result<()> {
         field!(Wrapper.wrapped, field!(Wrapper.wrapped, &23))
     )
 }
+
+#[test]
+fn supports_fully_qualified_struct_path() -> Result<()> {
+    // Ensure that the macro expands to the fully-qualified struct path.
+    mod googletest {}
+
+    let value = ::googletest::internal::test_data::TestStruct { value: 10 };
+    verify_that!(value, field!(&::googletest::internal::test_data::TestStruct.value, ref eq(&10)))?;
+    verify_that!(value, field!(&::googletest::internal::test_data::TestStruct.value, eq(10)))?;
+    verify_that!(value, field!(::googletest::internal::test_data::TestStruct.value, eq(&10)))?;
+    Ok(())
+}
+
+#[test]
+fn supports_generic_struct() -> Result<()> {
+    #[derive(Debug)]
+    struct Struct<S, T> {
+        #[allow(dead_code)] // The property1 field is used only for adding the type parameter.
+        property1: S,
+        property2: T,
+    }
+
+    let value = Struct { property1: 1, property2: 10 };
+    verify_that!(&value, field!(&Struct::<i32, u32>.property2, ref eq(&10)))?;
+    verify_that!(value, field!(&Struct::<i32, u32>.property2, eq(10)))?;
+    verify_that!(value, field!(Struct::<i32, u32>.property2, eq(&10)))?;
+    Ok(())
+}
+
+#[test]
+fn supports_fully_qualified_generic_struct() -> Result<()> {
+    // Ensure that the macro expands to the fully-qualified struct path.
+    mod googletest {}
+
+    let value = ::googletest::internal::test_data::GenericTestStruct { value: 10 };
+    verify_that!(
+        &value,
+        field!(&::googletest::internal::test_data::GenericTestStruct::<i32>.value, ref eq(&10))
+    )?;
+    verify_that!(
+        value,
+        field!(&::googletest::internal::test_data::GenericTestStruct::<i32>.value, eq(10))
+    )?;
+    verify_that!(
+        value,
+        field!(::googletest::internal::test_data::GenericTestStruct::<i32>.value, eq(&10))
+    )?;
+    Ok(())
+}
diff --git a/googletest/tests/lib.rs b/googletest/tests/lib.rs
diff --git a/googletest/tests/matches_pattern_struct_test.rs b/googletest/tests/matches_pattern_struct_test.rs
@@ -1194,3 +1194,57 @@ fn matches_struct_with_a_method_taking_two_parameters_ret_ref_and_field() -> Res
         matches_pattern!(&AStruct { get_field_ref(2, 3): eq(&1), another_field: eq(123), .. })
     )
 }
+
+#[test]
+fn matches_with_fully_qualified_struct_path() -> Result<()> {
+    // Ensure that the macro expands to the fully-qualified struct path.
+    mod googletest {}
+
+    let value = ::googletest::internal::test_data::TestStruct { value: 10 };
+    verify_that!(
+        value,
+        matches_pattern!(
+            &::googletest::internal::test_data::TestStruct {
+                 value: eq(10),
+                 get_value(): eq(10)
+            }
+        )
+    )
+}
+
+#[test]
+fn matches_with_explicit_type_parameters() -> Result<()> {
+    #[derive(Debug)]
+    struct AStruct<T> {
+        field: T,
+    }
+
+    impl<T: Copy> AStruct<T> {
+        fn get_default<U: Default>(&self) -> U {
+            Default::default()
+        }
+    }
+
+    let actual = AStruct::<i32> { field: 1 };
+    verify_that!(
+        actual,
+        matches_pattern!(&AStruct::<i32> { field: eq(1), get_default::<i16>(): eq(0) })
+    )
+}
+
+#[test]
+fn matches_with_fully_qualified_generic_struct_path() -> Result<()> {
+    // Ensure that the macro expands to the fully-qualified struct path.
+    mod googletest {}
+
+    let value = ::googletest::internal::test_data::GenericTestStruct { value: 10 };
+    verify_that!(
+        value,
+        matches_pattern!(
+            &::googletest::internal::test_data::GenericTestStruct::<i16> {
+                 value: eq(10),
+                 get_value::<i16>(20): eq(20)
+            }
+        )
+    )
+}
diff --git a/googletest/tests/property_matcher_test.rs b/googletest/tests/property_matcher_test.rs
diff --git a/googletest_macro/src/matches_pattern.rs b/googletest_macro/src/matches_pattern.rs
