Support borrowed data inside matchers.

With the previous changes to use `Box` to own matchers in `AllMatcher`, `ElementsAreMatcher`, `UnorderedElementsAreMatcher` and `UnorderedElementsOfMapAreMatcher`, these matchers lost the ability to contain borrowed data with a lifetime other than `'static`. This is because `Box` implicitly assumes that its inner type has lifetime `'static`. In particular, one could not nest `eq_deref_of` inside these matchers. That should not be necessary as long as the `Box` instances are dropped before the references they contain become invalid. Such a limitation is therefore surprising.

This change introduces explicit lifetimes for the content of the `Box` instances. Doing so allows the borrow checker to apply the lifetime of the contained references to prove that they outlive the `Box` instances. This change also introduces integration tests which demonstrate that this works.

PiperOrigin-RevId: 532422248

Author: hovinenb

googletest/src/matchers/all_matcher.rs

@@ -73,20 +73,20 @@ pub mod internal {
     ///
     /// For internal use only. API stablility is not guaranteed!
     #[doc(hidden)]
-    pub struct AllMatcher<T: Debug + ?Sized, const N: usize> {
-        components: [Box<dyn Matcher<ActualT = T>>; N],
+    pub struct AllMatcher<'a, T: Debug + ?Sized, const N: usize> {
+        components: [Box<dyn Matcher<ActualT = T> + 'a>; N],
     }
 
-    impl<T: Debug + ?Sized, const N: usize> AllMatcher<T, N> {
+    impl<'a, T: Debug + ?Sized, const N: usize> AllMatcher<'a, T, N> {
         /// Constructs an [`AllMatcher`] with the given component matchers.
         ///
         /// Intended for use only by the [`all`] macro.
-        pub fn new(components: [Box<dyn Matcher<ActualT = T>>; N]) -> Self {
+        pub fn new(components: [Box<dyn Matcher<ActualT = T> + 'a>; N]) -> Self {
             Self { components }
         }
     }
 
-    impl<T: Debug + ?Sized, const N: usize> Matcher for AllMatcher<T, N> {
+    impl<'a, T: Debug + ?Sized, const N: usize> Matcher for AllMatcher<'a, T, N> {
         type ActualT = T;
 
         fn matches(&self, actual: &Self::ActualT) -> MatcherResult {

googletest/src/matchers/elements_are_matcher.rs

@@ -72,24 +72,24 @@ pub mod internal {
     ///
     /// **For internal use only. API stablility is not guaranteed!**
     #[doc(hidden)]
-    pub struct ElementsAre<ContainerT: ?Sized, T: Debug> {
-        elements: Vec<Box<dyn Matcher<ActualT = T>>>,
+    pub struct ElementsAre<'a, ContainerT: ?Sized, T: Debug> {
+        elements: Vec<Box<dyn Matcher<ActualT = T> + 'a>>,
         phantom: PhantomData<ContainerT>,
     }
 
-    impl<ContainerT: ?Sized, T: Debug> ElementsAre<ContainerT, T> {
+    impl<'a, ContainerT: ?Sized, T: Debug> ElementsAre<'a, ContainerT, T> {
         /// Factory only intended for use in the macro `elements_are!`.
         ///
         /// **For internal use only. API stablility is not guaranteed!**
         #[doc(hidden)]
-        pub fn new(elements: Vec<Box<dyn Matcher<ActualT = T>>>) -> Self {
+        pub fn new(elements: Vec<Box<dyn Matcher<ActualT = T> + 'a>>) -> Self {
             Self { elements, phantom: Default::default() }
         }
     }
 
-    impl<T: Debug, ContainerT: Debug + ?Sized> Matcher for ElementsAre<ContainerT, T>
+    impl<'a, T: Debug, ContainerT: Debug + ?Sized> Matcher for ElementsAre<'a, ContainerT, T>
     where
-        for<'a> &'a ContainerT: IntoIterator<Item = &'a T>,
+        for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
     {
         type ActualT = ContainerT;
 

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -341,15 +341,17 @@ pub mod internal {
     ///
     /// **For internal use only. API stablility is not guaranteed!**
     #[doc(hidden)]
-    pub struct UnorderedElementsAreMatcher<ContainerT: ?Sized, T: Debug, const N: usize> {
-        elements: [Box<dyn Matcher<ActualT = T>>; N],
+    pub struct UnorderedElementsAreMatcher<'a, ContainerT: ?Sized, T: Debug, const N: usize> {
+        elements: [Box<dyn Matcher<ActualT = T> + 'a>; N],
         requirements: Requirements,
         phantom: PhantomData<ContainerT>,
     }
 
-    impl<ContainerT: ?Sized, T: Debug, const N: usize> UnorderedElementsAreMatcher<ContainerT, T, N> {
+    impl<'a, ContainerT: ?Sized, T: Debug, const N: usize>
+        UnorderedElementsAreMatcher<'a, ContainerT, T, N>
+    {
         pub fn new(
-            elements: [Box<dyn Matcher<ActualT = T>>; N],
+            elements: [Box<dyn Matcher<ActualT = T> + 'a>; N],
             requirements: Requirements,
         ) -> Self {
             Self { elements, requirements, phantom: Default::default() }
@@ -365,10 +367,10 @@ pub mod internal {
     // least one expected element and vice versa.
     // 3. `UnorderedElementsAreMatcher` verifies that a perfect matching exists
     // using Ford-Fulkerson.
-    impl<T: Debug, ContainerT: Debug + ?Sized, const N: usize> Matcher
-        for UnorderedElementsAreMatcher<ContainerT, T, N>
+    impl<'a, T: Debug, ContainerT: Debug + ?Sized, const N: usize> Matcher
+        for UnorderedElementsAreMatcher<'a, ContainerT, T, N>
     where
-        for<'a> &'a ContainerT: IntoIterator<Item = &'a T>,
+        for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
     {
         type ActualT = ContainerT;
 
@@ -411,40 +413,40 @@ pub mod internal {
         }
     }
 
-    type KeyValueMatcher<KeyT, ValueT> =
-        (Box<dyn Matcher<ActualT = KeyT>>, Box<dyn Matcher<ActualT = ValueT>>);
+    type KeyValueMatcher<'a, KeyT, ValueT> =
+        (Box<dyn Matcher<ActualT = KeyT> + 'a>, Box<dyn Matcher<ActualT = ValueT> + 'a>);
 
     /// This is the analogue to [UnorderedElementsAreMatcher] for maps and
     /// map-like collections.
     ///
     /// **For internal use only. API stablility is not guaranteed!**
     #[doc(hidden)]
-    pub struct UnorderedElementsOfMapAreMatcher<ContainerT, KeyT, ValueT, const N: usize>
+    pub struct UnorderedElementsOfMapAreMatcher<'a, ContainerT, KeyT, ValueT, const N: usize>
     where
         ContainerT: ?Sized,
         KeyT: Debug,
         ValueT: Debug,
     {
-        elements: [KeyValueMatcher<KeyT, ValueT>; N],
+        elements: [KeyValueMatcher<'a, KeyT, ValueT>; N],
         requirements: Requirements,
         phantom: PhantomData<ContainerT>,
     }
 
-    impl<ContainerT, KeyT: Debug, ValueT: Debug, const N: usize>
-        UnorderedElementsOfMapAreMatcher<ContainerT, KeyT, ValueT, N>
+    impl<'a, ContainerT, KeyT: Debug, ValueT: Debug, const N: usize>
+        UnorderedElementsOfMapAreMatcher<'a, ContainerT, KeyT, ValueT, N>
     {
         pub fn new(
-            elements: [KeyValueMatcher<KeyT, ValueT>; N],
+            elements: [KeyValueMatcher<'a, KeyT, ValueT>; N],
             requirements: Requirements,
         ) -> Self {
             Self { elements, requirements, phantom: Default::default() }
         }
     }
 
-    impl<KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized, const N: usize> Matcher
-        for UnorderedElementsOfMapAreMatcher<ContainerT, KeyT, ValueT, N>
+    impl<'a, KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized, const N: usize> Matcher
+        for UnorderedElementsOfMapAreMatcher<'a, ContainerT, KeyT, ValueT, N>
     where
-        for<'a> &'a ContainerT: IntoIterator<Item = (&'a KeyT, &'a ValueT)>,
+        for<'b> &'b ContainerT: IntoIterator<Item = (&'b KeyT, &'b ValueT)>,
     {
         type ActualT = ContainerT;
 
@@ -561,12 +563,12 @@ pub mod internal {
     struct MatchMatrix<const N: usize>(Vec<[MatcherResult; N]>);
 
     impl<const N: usize> MatchMatrix<N> {
-        fn generate<T: Debug, ContainerT: Debug + ?Sized>(
+        fn generate<'a, T: Debug + 'a, ContainerT: Debug + ?Sized>(
             actual: &ContainerT,
-            expected: &[Box<dyn Matcher<ActualT = T>>; N],
+            expected: &[Box<dyn Matcher<ActualT = T> + 'a>; N],
         ) -> Self
         where
-            for<'a> &'a ContainerT: IntoIterator<Item = &'a T>,
+            for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
         {
             let mut matrix =
                 MatchMatrix(vec![[MatcherResult::DoesNotMatch; N]; count_elements(actual)]);
@@ -578,12 +580,12 @@ pub mod internal {
             matrix
         }
 
-        fn generate_for_map<KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized>(
+        fn generate_for_map<'a, KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized>(
             actual: &ContainerT,
-            expected: &[KeyValueMatcher<KeyT, ValueT>; N],
+            expected: &[KeyValueMatcher<'a, KeyT, ValueT>; N],
         ) -> Self
         where
-            for<'a> &'a ContainerT: IntoIterator<Item = (&'a KeyT, &'a ValueT)>,
+            for<'b> &'b ContainerT: IntoIterator<Item = (&'b KeyT, &'b ValueT)>,
         {
             let mut matrix =
                 MatchMatrix(vec![[MatcherResult::DoesNotMatch; N]; count_elements(actual)]);
@@ -921,14 +923,14 @@ pub mod internal {
             (0..N).filter(|expected_idx| !matched_expected.contains(expected_idx)).collect()
         }
 
-        fn get_explanation<T: Debug, ContainerT: Debug + ?Sized>(
+        fn get_explanation<'a, T: Debug, ContainerT: Debug + ?Sized>(
             &self,
             actual: &ContainerT,
-            expected: &[Box<dyn Matcher<ActualT = T>>; N],
+            expected: &[Box<dyn Matcher<ActualT = T> + 'a>; N],
             requirements: Requirements,
         ) -> Option<String>
         where
-            for<'a> &'a ContainerT: IntoIterator<Item = &'a T>,
+            for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
         {
             let actual: Vec<_> = actual.into_iter().collect();
             if self.is_full_match() {
@@ -968,14 +970,14 @@ pub mod internal {
             ))
         }
 
-        fn get_explanation_for_map<KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized>(
+        fn get_explanation_for_map<'a, KeyT: Debug, ValueT: Debug, ContainerT: Debug + ?Sized>(
             &self,
             actual: &ContainerT,
-            expected: &[KeyValueMatcher<KeyT, ValueT>; N],
+            expected: &[KeyValueMatcher<'a, KeyT, ValueT>; N],
             requirements: Requirements,
         ) -> Option<String>
         where
-            for<'a> &'a ContainerT: IntoIterator<Item = (&'a KeyT, &'a ValueT)>,
+            for<'b> &'b ContainerT: IntoIterator<Item = (&'b KeyT, &'b ValueT)>,
         {
             let actual: Vec<_> = actual.into_iter().collect();
             if self.is_full_match() {

googletest/tests/all_matcher_test.rs

@@ -49,6 +49,14 @@ fn supports_trailing_comma() -> Result<()> {
     )
 }
 
+#[test]
+fn admits_matchers_without_static_lifetime() -> Result<()> {
+    #[derive(Debug, PartialEq)]
+    struct AStruct(i32);
+    let expected_value = AStruct(123);
+    verify_that!(AStruct(123), all![eq_deref_of(&expected_value)])
+}
+
 #[test]
 fn mismatch_description_two_failed_matchers() -> Result<()> {
     verify_that!(

googletest/tests/elements_are_matcher_test.rs

@@ -46,6 +46,14 @@ fn elements_are_returns_no_match_when_expected_and_actual_sizes_differ() -> Resu
     verify_that!(value, not(elements_are![eq(1), eq(2), eq(3)]))
 }
 
+#[test]
+fn elements_are_admits_matchers_without_static_lifetime() -> Result<()> {
+    #[derive(Debug, PartialEq)]
+    struct AStruct(i32);
+    let expected_value = AStruct(123);
+    verify_that!(vec![AStruct(123)], elements_are![eq_deref_of(&expected_value)])
+}
+
 #[test]
 fn elements_are_produces_correct_failure_message() -> Result<()> {
     let result = verify_that!(vec![1, 4, 3], elements_are![eq(1), eq(2), eq(3)]);

googletest/tests/unordered_elements_are_matcher_test.rs

@@ -44,8 +44,7 @@ fn unordered_elements_are_matches_slice() -> Result<()> {
 
 #[test]
 fn unordered_elements_are_matches_hash_map() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Three")]);
     verify_that!(
         value,
         unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))]
@@ -54,8 +53,7 @@ fn unordered_elements_are_matches_hash_map() -> Result<()> {
 
 #[test]
 fn unordered_elements_are_matches_hash_map_with_trailing_comma() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Three")]);
     verify_that!(
         value,
         unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three")),]
@@ -64,8 +62,7 @@ fn unordered_elements_are_matches_hash_map_with_trailing_comma() -> Result<()> {
 
 #[test]
 fn unordered_elements_are_does_not_match_hash_map_with_wrong_key() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (4, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (4, "Three")]);
     verify_that!(
         value,
         not(unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))])
@@ -74,8 +71,7 @@ fn unordered_elements_are_does_not_match_hash_map_with_wrong_key() -> Result<()>
 
 #[test]
 fn unordered_elements_are_does_not_match_hash_map_with_wrong_value() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Four")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Four")]);
     verify_that!(
         value,
         not(unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))])
@@ -84,7 +80,7 @@ fn unordered_elements_are_does_not_match_hash_map_with_wrong_value() -> Result<(
 
 #[test]
 fn unordered_elements_are_does_not_match_hash_map_missing_element() -> Result<()> {
-    let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two")]);
     verify_that!(
         value,
         not(unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))])
@@ -93,15 +89,13 @@ fn unordered_elements_are_does_not_match_hash_map_missing_element() -> Result<()
 
 #[test]
 fn unordered_elements_are_does_not_match_hash_map_with_extra_element() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Three")]);
     verify_that!(value, not(unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One"))]))
 }
 
 #[test]
 fn unordered_elements_are_does_not_match_hash_map_with_mismatched_key_and_value() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Three"), (3, "Two")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Three"), (3, "Two")]);
     verify_that!(
         value,
         not(unordered_elements_are![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))])
@@ -120,6 +114,25 @@ fn unordered_elements_are_matches_size() -> Result<()> {
     verify_that!(value, not(unordered_elements_are![eq(1), eq(2), eq(3)]))
 }
 
+#[test]
+fn unordered_elements_are_admits_matchers_without_static_lifetime() -> Result<()> {
+    #[derive(Debug, PartialEq)]
+    struct AStruct(i32);
+    let expected_value = AStruct(123);
+    verify_that!(vec![AStruct(123)], unordered_elements_are![eq_deref_of(&expected_value)])
+}
+
+#[test]
+fn unordered_elements_are_with_map_admits_matchers_without_static_lifetime() -> Result<()> {
+    #[derive(Debug, PartialEq)]
+    struct AStruct(i32);
+    let expected_value = AStruct(123);
+    verify_that!(
+        HashMap::from([(1, AStruct(123))]),
+        unordered_elements_are![(eq(1), eq_deref_of(&expected_value))]
+    )
+}
+
 #[test]
 fn unordered_elements_are_description_mismatch() -> Result<()> {
     let result = verify_that!(vec![1, 4, 3], unordered_elements_are![eq(1), eq(2), eq(3)]);
@@ -219,15 +232,13 @@ fn contains_each_supports_trailing_comma() -> Result<()> {
 
 #[test]
 fn contains_each_matches_hash_map() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Three")]);
     verify_that!(value, contains_each![(eq(2), eq("Two")), (eq(1), eq("One"))])
 }
 
 #[test]
 fn contains_each_matches_hash_map_with_trailing_comma() -> Result<()> {
-    let value: HashMap<u32, &'static str> =
-        HashMap::from_iter([(1, "One"), (2, "Two"), (3, "Three")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two"), (3, "Three")]);
     verify_that!(value, contains_each![(eq(2), eq("Two")), (eq(1), eq("One")),])
 }
 
@@ -317,7 +328,7 @@ fn is_contained_supports_trailing_comma() -> Result<()> {
 
 #[test]
 fn is_contained_in_matches_hash_map() -> Result<()> {
-    let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two")]);
     verify_that!(
         value,
         is_contained_in![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three"))]
@@ -326,7 +337,7 @@ fn is_contained_in_matches_hash_map() -> Result<()> {
 
 #[test]
 fn is_contained_in_matches_hash_map_with_trailing_comma() -> Result<()> {
-    let value: HashMap<u32, &'static str> = HashMap::from_iter([(1, "One"), (2, "Two")]);
+    let value: HashMap<u32, &'static str> = HashMap::from([(1, "One"), (2, "Two")]);
     verify_that!(
         value,
         is_contained_in![(eq(2), eq("Two")), (eq(1), eq("One")), (eq(3), eq("Three")),]