Rename MatcherResult::into_bool to MatcheResult::is_match.

This also pulls the proper implementation from the `impl From<MatcherResult> for bool` block into `is_match` and has the former implementation defer to this method.

The naming `is_match` is closer to other Rust idioms such as `Result::is_ok`, `Result::is_err`, etc. It makes more sense to define the method explicitly according to its intended behaviour and then add a `From` implementation as a convenience.

Author: hovinen

googletest/src/matcher.rs

@@ -251,22 +251,17 @@ impl From<bool> for MatcherResult {
 
 impl From<MatcherResult> for bool {
     fn from(matcher_result: MatcherResult) -> Self {
-        match matcher_result {
-            MatcherResult::Match => true,
-            MatcherResult::NoMatch => false,
-        }
+        matcher_result.is_match()
     }
 }
 
 impl MatcherResult {
     /// Returns `true` if `self` is [`MatcherResult::Match`], otherwise
     /// `false`.
-    ///
-    /// This delegates to `Into<bool>` but coerce the return type to `bool`
-    /// instead only calling `into()`. This is useful in `if
-    /// !matcher_result.into()`, which requires a constraint on the result
-    /// type of `into()` to compile.
-    pub fn into_bool(self) -> bool {
-        self.into()
+    pub fn is_match(self) -> bool {
+        match self {
+            MatcherResult::Match => true,
+            MatcherResult::NoMatch => false,
+        }
     }
 }

googletest/src/matchers/all_matcher.rs

@@ -109,7 +109,7 @@ pub mod internal {
                     let failures = self
                         .components
                         .iter()
-                        .filter(|component| !component.matches(actual).into_bool())
+                        .filter(|component| !component.matches(actual).is_match())
                         .map(|component| component.explain_match(actual))
                         .collect::<Description>();
                     if failures.len() == 1 {

googletest/src/matchers/each_matcher.rs

@@ -80,7 +80,7 @@ where
 
     fn matches(&self, actual: &ActualT) -> MatcherResult {
         for element in actual {
-            if !self.inner.matches(element).into_bool() {
+            if !self.inner.matches(element).is_match() {
                 return MatcherResult::NoMatch;
             }
         }
@@ -90,7 +90,7 @@ where
     fn explain_match(&self, actual: &ActualT) -> String {
         let mut non_matching_elements = Vec::new();
         for (index, element) in actual.into_iter().enumerate() {
-            if !self.inner.matches(element).into_bool() {
+            if !self.inner.matches(element).is_match() {
                 non_matching_elements.push((index, element, self.inner.explain_match(element)));
             }
         }

googletest/src/matchers/elements_are_matcher.rs

@@ -122,7 +122,7 @@ pub mod internal {
         fn matches(&self, actual: &ContainerT) -> MatcherResult {
             let mut zipped_iterator = zip(actual.into_iter(), self.elements.iter());
             for (a, e) in zipped_iterator.by_ref() {
-                if !e.matches(a).into_bool() {
+                if !e.matches(a).is_match() {
                     return MatcherResult::NoMatch;
                 }
             }
@@ -138,7 +138,7 @@ pub mod internal {
             let mut zipped_iterator = zip(actual_iterator, self.elements.iter());
             let mut mismatches = Vec::new();
             for (idx, (a, e)) in zipped_iterator.by_ref().enumerate() {
-                if !e.matches(a).into_bool() {
+                if !e.matches(a).is_match() {
                     mismatches.push(format!("element #{idx} is {a:?}, {}", e.explain_match(a)));
                 }
             }

googletest/src/matchers/pointwise_matcher.rs

@@ -179,7 +179,7 @@ pub mod internal {
         fn matches(&self, actual: &ContainerT) -> MatcherResult {
             let mut zipped_iterator = zip(actual.into_iter(), self.matchers.iter());
             for (element, matcher) in zipped_iterator.by_ref() {
-                if !matcher.matches(element).into_bool() {
+                if !matcher.matches(element).is_match() {
                     return MatcherResult::NoMatch;
                 }
             }
@@ -198,7 +198,7 @@ pub mod internal {
             let mut zipped_iterator = zip(actual_iterator, self.matchers.iter());
             let mut mismatches = Vec::new();
             for (idx, (a, e)) in zipped_iterator.by_ref().enumerate() {
-                if !e.matches(a).into_bool() {
+                if !e.matches(a).is_match() {
                     mismatches.push(format!("element #{idx} is {a:?}, {}", e.explain_match(a)));
                 }
             }

googletest/src/matchers/unordered_elements_are_matcher.rs

@@ -656,25 +656,25 @@ pub mod internal {
         // than `find_best_match()`.
         fn find_unmatchable_elements(&self) -> UnmatchableElements<N> {
             let unmatchable_actual =
-                self.0.iter().map(|row| row.iter().all(|&e| !e.into_bool())).collect();
+                self.0.iter().map(|row| row.iter().all(|&e| !e.is_match())).collect();
             let mut unmatchable_expected = [false; N];
             for (col_idx, expected) in unmatchable_expected.iter_mut().enumerate() {
-                *expected = self.0.iter().map(|row| row[col_idx]).all(|e| !e.into_bool());
+                *expected = self.0.iter().map(|row| row[col_idx]).all(|e| !e.is_match());
             }
             UnmatchableElements { unmatchable_actual, unmatchable_expected }
         }
 
         fn find_unmatched_expected(&self) -> UnmatchableElements<N> {
             let mut unmatchable_expected = [false; N];
             for (col_idx, expected) in unmatchable_expected.iter_mut().enumerate() {
-                *expected = self.0.iter().map(|row| row[col_idx]).all(|e| !e.into_bool());
+                *expected = self.0.iter().map(|row| row[col_idx]).all(|e| !e.is_match());
             }
             UnmatchableElements { unmatchable_actual: vec![false; N], unmatchable_expected }
         }
 
         fn find_unmatched_actual(&self) -> UnmatchableElements<N> {
             let unmatchable_actual =
-                self.0.iter().map(|row| row.iter().all(|e| !e.into_bool())).collect();
+                self.0.iter().map(|row| row.iter().all(|e| !e.is_match())).collect();
             UnmatchableElements { unmatchable_actual, unmatchable_expected: [false; N] }
         }
 
@@ -795,7 +795,7 @@ pub mod internal {
                 if seen[expected_idx] {
                     continue;
                 }
-                if !self.0[actual_idx][expected_idx].into_bool() {
+                if !self.0[actual_idx][expected_idx].is_match() {
                     continue;
                 }
                 // There is an edge between `actual_idx` and `expected_idx`.