Similar to native match pattern for braced structs, make matches_pattern enforce exhaustive field checks for braced structs by default, to be suppressed by explicit .. at the end of the pattern.

This change is not backward-compatible since:
* It enforces field exhaustiveness by default in the absence of a trailing `..` in the pattern.
* Things that previously fell back to `match` pattern matching now use `match_pattern!`'s specialized matching, which requires the matched object to implement `Debug`.

Toward #447

PiperOrigin-RevId: 700843379

Author: marcianx

googletest/src/matchers/matches_pattern.rs

@@ -44,8 +44,11 @@
 /// #     .unwrap();
 /// ```
 ///
-/// It is not required to include all named fields in the specification. Omitted
-/// fields have no effect on the output of the matcher.
+/// If any fields are provided in the pattern, then all fields must be
+/// specified, or the pattern must end with `..`, just like regular match
+/// patterns. Omitted fields have no effect on the output of the matcher.
+/// The `..` is unnecessary when no fields are provided and only method
+/// values are checked.
 ///
 /// ```
 /// # use googletest::prelude::*;
@@ -61,7 +64,7 @@
 /// # };
 /// verify_that!(my_struct, matches_pattern!(MyStruct {
 ///     a_field: starts_with("Something"),
-///     // another_field is missing, so it may be anything.
+///     .. // another_field is missing, so it may be anything.
 /// }))
 /// #     .unwrap();
 /// ```
@@ -367,3 +370,34 @@ pub mod internal {
         }
     }
 }
+
+mod compile_fail_tests {
+    /// ```compile_fail
+    /// use ::googletest::prelude::*;
+    /// #[derive(Debug)]
+    /// struct Foo { a: u32, b: u32 }
+    /// let actual = Foo { a: 1, b: 2 };
+    /// verify_that!(actual, matches_pattern!(Foo { a: eq(&1), .., }));
+    /// ```
+    fn _dot_dot_supported_only_at_end_of_struct_pattern() {}
+
+    /// ```compile_fail
+    /// use ::googletest::prelude::*;
+    /// #[derive(Debug)]
+    /// struct Foo { a: u32, b: u32 }
+    /// let actual = Foo { a: 1, b: 2 };
+    /// verify_that!(actual, matches_pattern!(Foo { a: eq(&1) }));
+    /// ```
+    fn _unexhaustive_struct_field_check_requires_dot_dot() {}
+
+    /// ```compile_fail
+    /// use ::googletest::prelude::*;
+    /// #[derive(Debug)]
+    /// enum Foo {
+    ///     Bar { a: u32, b: u32 }
+    /// }
+    /// let actual = Foo::Bar { a: 1, b: 2 };
+    /// verify_that!(actual, matches_pattern!(Foo::Bar { a: eq(&1) }));
+    /// ```
+    fn _unexhaustive_enum_struct_field_check_requires_dot_dot() {}
+}