Remove the dependency of the size matcher on HasSize.

This moves the function `count_elements` from the `unordered_elements_matcher` module to its own module so that it can be used by `SizeMatcher` as well.

Now `size` can also be used with slices in addition to all container types over which one can iterate. This includes all standard Rust containers.

This change removes the now unused `has_size` module and its contents.

One slight API change resulting from this is that one now no longer uses a reference when using the size matcher against slices of arrays:

OLD:

```
let value = &[1, 2, 3];
verify_that(&value[0..1], size(eq(1)))?;
```

NEW:

```
let value = &[1, 2, 3];
verify_that(value[0..1], size(eq(1)))?;
```

PiperOrigin-RevId: 515603924

Author: hovinenb

googletest/src/matchers/count_elements.rs

@@ -0,0 +1,32 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Counts the number of elements in `value`.
+///
+/// This uses [`Iterator::size_hint`] when that function returns an
+/// unambiguous answer, i.e., the upper bound exists and the lower and upper
+/// bounds agree. Otherwise it iterates through `value` and counts the
+/// elements.
+pub(crate) fn count_elements<ContainerT: ?Sized>(value: &ContainerT) -> usize
+where
+    for<'b> &'b ContainerT: IntoIterator,
+{
+    let iterator = value.into_iter();
+    if let (lower, Some(higher)) = iterator.size_hint() {
+        if lower == higher {
+            return lower;
+        }
+    }
+    iterator.count()
+}

googletest/src/matchers/has_size.rs

@@ -25,6 +25,8 @@ pub mod contains_matcher;
 #[cfg(not(google3))]
 pub mod contains_regex_matcher;
 #[cfg(not(google3))]
+pub mod count_elements;
+#[cfg(not(google3))]
 pub mod description;
 #[cfg(not(google3))]
 pub mod disjunction_matcher;
@@ -49,8 +51,6 @@ pub mod gt_matcher;
 #[cfg(not(google3))]
 pub mod has_entry_matcher;
 #[cfg(not(google3))]
-pub mod has_size;
-#[cfg(not(google3))]
 pub mod is_nan_matcher;
 #[cfg(not(google3))]
 pub mod le_matcher;

googletest/src/matchers/mod.rs

@@ -29,9 +29,8 @@
 /// verify_that!(value, pointwise!(le, [1, 1, 3]))?; // Fails
 /// ```
 ///
-/// The actual value must be a container implementing [`IntoIterator`] and
-/// [`HasSize`][crate::matchers::has_size::HasSize]. This includes all common
-/// containers in the Rust standard library.
+/// The actual value must be a container implementing [`IntoIterator`]. This
+/// includes standard containers, slices (when dereferenced) and arrays.
 ///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`]

googletest/src/matchers/pointwise_matcher.rs

@@ -14,33 +14,50 @@
 
 #[cfg(not(google3))]
 use crate as googletest;
-use googletest::matcher::{Matcher, MatcherResult};
 #[cfg(not(google3))]
-use googletest::matchers::has_size::HasSize;
+use crate::matchers::count_elements::count_elements;
 #[cfg(google3)]
-use has_size::HasSize;
+use count_elements::count_elements;
+use googletest::matcher::{Matcher, MatcherResult};
 use std::fmt::Debug;
 
 /// Matches a container whose size matches `expected`.
 ///
-/// `T` must be a container and implement the [`HasSize`] trait so that the size
-/// can be extracted.
+/// This matches against a container over which one can iterate. This includes
+/// the standard Rust containers, arrays, and (when dereferenced) slices.
 ///
 /// ```
-/// let value = vec![1,2,3];
-/// verify_that!(value, size(eq(3)))?;
+/// let array = [1,2,3];
+/// verify_that!(array, size(eq(3)))?;
+/// let vec = vec![1,2,3];
+/// verify_that!(vec, size(eq(3)))?;
+/// let slice = value.as_slice();
+/// verify_that!(*slice, size(eq(3)))?;
 /// ```
-pub fn size<T: HasSize + Debug, E: Matcher<usize>>(expected: E) -> impl Matcher<T> {
+///
+/// The parameter `expected` can be any integer numeric matcher.
+///
+/// ```
+/// let vec = vec![1,2,3];
+/// verify_that!(vec, size(gt(1)))?;
+/// ```
+pub fn size<T: Debug + ?Sized, E: Matcher<usize>>(expected: E) -> impl Matcher<T>
+where
+    for<'b> &'b T: IntoIterator,
+{
     SizeMatcher { expected }
 }
 
 struct SizeMatcher<E> {
     expected: E,
 }
 
-impl<T: Debug + HasSize, E: Matcher<usize>> Matcher<T> for SizeMatcher<E> {
+impl<T: Debug + ?Sized, E: Matcher<usize>> Matcher<T> for SizeMatcher<E>
+where
+    for<'b> &'b T: IntoIterator,
+{
     fn matches(&self, actual: &T) -> MatcherResult {
-        self.expected.matches(&actual.size())
+        self.expected.matches(&count_elements(actual))
     }
 
     fn describe(&self, matcher_result: MatcherResult) -> String {
@@ -75,9 +92,22 @@ mod tests {
     }
 
     #[google_test]
-    fn size_matcher_match_slice() -> Result<()> {
+    fn size_matcher_match_array_reference() -> Result<()> {
+        let value = &[1, 2, 3];
+        verify_that!(*value, size(eq(3)))
+    }
+
+    #[google_test]
+    fn size_matcher_match_slice_of_array() -> Result<()> {
         let value = &[1, 2, 3];
-        verify_that!(&value[0..1], size(eq(1)))
+        verify_that!(value[0..1], size(eq(1)))
+    }
+
+    #[google_test]
+    fn size_matcher_match_slice_of_vec() -> Result<()> {
+        let value = vec![1, 2, 3];
+        let slice = value.as_slice();
+        verify_that!(*slice, size(eq(3)))
     }
 
     #[google_test]

googletest/src/matchers/size_matcher.rs

@@ -26,9 +26,8 @@
 /// verify_that!(vec![3, 2, 1], unordered_elements_are![ge(3), ge(3), ge(3)])?; // Fails: no 1:1 correspondence
 /// ```
 ///
-/// The actual value must be a container implementing [`IntoIterator`] and
-/// [`HasSize`][crate::matchers::has_size::HasSize]. This includes all common
-/// containers in the Rust standard library.
+/// The actual value must be a container implementing [`IntoIterator`]. This
+/// includes standard containers, slices (when dereferenced) and arrays.
 ///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
@@ -85,9 +84,8 @@ macro_rules! unordered_elements_are {
 /// verify_that!(vec![3, 2, 1], contains_each![ge(3), ge(3), ge(3)])?; // Fails: no matching
 /// ```
 ///
-/// The actual value must be a container implementing [`IntoIterator`] and
-/// [`HasSize`][crate::matchers::has_size::HasSize]. This includes all common
-/// containers in the Rust standard library.
+/// The actual value must be a container implementing [`IntoIterator`]. This
+/// includes standard containers, slices (when dereferenced) and arrays.
 ///
 /// This matcher does not support matching directly against an [`Iterator`]. To
 /// match against an iterator, use [`Iterator::collect`] to build a [`Vec`].
@@ -185,6 +183,10 @@ macro_rules! is_contained_in {
 pub mod internal {
     #[cfg(not(google3))]
     use crate as googletest;
+    #[cfg(not(google3))]
+    use crate::matchers::count_elements::count_elements;
+    #[cfg(google3)]
+    use count_elements::count_elements;
     #[cfg(google3)]
     use description::Description;
     use googletest::matcher::{MatchExplanation, Matcher, MatcherResult};
@@ -576,25 +578,6 @@ pub mod internal {
         }
     }
 
-    /// Counts the number of elements in `value`.
-    ///
-    /// This uses [`Iterator::size_hint`] when that function returns an
-    /// unambiguous answer, i.e., the upper bound exists and the lower and upper
-    /// bounds agree. Otherwise it iterates through `value` and counts the
-    /// elements.
-    fn count_elements<T, ContainerT: ?Sized>(value: &ContainerT) -> usize
-    where
-        for<'b> &'b ContainerT: IntoIterator<Item = &'b T>,
-    {
-        let iterator = value.into_iter();
-        if let (lower, Some(higher)) = iterator.size_hint() {
-            if lower == higher {
-                return lower;
-            }
-        }
-        iterator.count()
-    }
-
     /// The list of elements that do not match any element in the corresponding
     /// set.
     /// These lists are represented as fixed sized bit set to avoid