Merge e1a97d4c234d55f301c2d2ae3945a2205b3d4203 into add971c7cb497d40985b48641891bf9b51423730

docs/gmock_cook_book.md

@@ -3386,6 +3386,30 @@ With this definition, the above assertion will give a better message:
     Actual: 27 (the remainder is 6)
 ```
 
+#### Using EXPECT_ Statements in Matchers
+
+You can also use `EXPECT_...` statements inside custom matcher definitions. In
+many cases, this allows you to write your matcher more concisely while still
+providing an informative error message. For example:
+
+```cpp
+MATCHER(IsDivisibleBy7, "") {
+  const auto remainder = arg % 7;
+  EXPECT_EQ(remainder, 0);
+  return true;
+}
+```
+
+If you write a test that includes the line `EXPECT_THAT(27, IsDivisibleBy7());`,
+you will get an error something like the following:
+
+```shell
+Expected equality of these values:
+  remainder
+    Which is: 6
+  0
+```
+
 #### `MatchAndExplain`
 
 You should let `MatchAndExplain()` print *any additional information* that can
@@ -3405,66 +3429,6 @@ the value of `(arg % 7) == 0` can be implicitly converted to a `bool`. In the
 `arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will be
 `unsigned long`; and so on.
 
-#### Anti-pattern: Using EXPECT_ Statements in Matchers
-
-Using `EXPECT_...` statements inside custom matcher definitions is an
-**anti-pattern** and should be avoided.
-
-While it might appear to write matchers more concisely and generate informative
-messages, this pattern has critical issues:
-
-1.  **Negation Breakage (`Not`):** If wrapped in `Not(IsDivisibleBy7())`,
-    evaluating it still triggers the internal `EXPECT_EQ`, registering a test
-    failure on the runner even when the overall assertion is expected to
-    succeed.
-2.  **Composition / Container Breakage (`AnyOf`, `AllOf`, `Contains`):** When
-    composed or used inside container matchers, elements that are expected
-    mismatches will trigger the internal `EXPECT_` and register spurious
-    failures.
-3.  **ASSERT_* compilation errors:** `ASSERT_*` macros use `return;` to abort
-    from a void function. Since matchers return `bool`, using `ASSERT_` inside
-    them triggers a compilation error.
-4.  **Purity Violations:** Matchers must be functionally pure (side-effect
-    free), whereas registering global failures is a major side effect.
-5.  **Line Number Confusion:** Failure reports point to the matcher's definition
-    line rather than the calling `EXPECT_THAT`
-    line.
-
-##### The Anti-Pattern
-
-```cpp
-// Anti-pattern: Do not do this!
-MATCHER(IsDivisibleBy7, "") {
-  const auto remainder = arg % 7;
-  EXPECT_EQ(remainder, 0);  // Spurious failures if negated/composed!
-  return true;
-}
-```
-
-##### The Correct Solution
-
-To write concise matchers that delegate to other matchers and safely propagate
-the mismatch explanation, use **`::testing::ExplainMatchResult`** instead,
-passing it the sub-matcher, the value to check, and the `result_listener`:
-
-```cpp
-MATCHER(IsDivisibleBy7, "") {
-  const auto remainder = arg % 7;
-  return ::testing::ExplainMatchResult(::testing::Eq(0), remainder,
-                                       result_listener);
-}
-```
-
-If you write a test that includes the line:
-
-```cpp
-EXPECT_THAT(28, Not(IsDivisibleBy7()));
-```
-
-it will correctly report the mismatch, properly point to the `EXPECT_THAT` line
-number, and support negation (`Not`) and composition (`AllOf`, `AnyOf`, etc.)
-without registering spurious failures.
-
 ### Writing New Parameterized Matchers Quickly
 
 Sometimes you'll want to define a matcher that has parameters. For that you can

googlemock/include/gmock/gmock-spec-builders.h

@@ -1957,11 +1957,6 @@ struct SignatureOf<R(Args...)> {
   using type = R(Args...);
 };
 
-template <typename R, typename... Args>
-struct SignatureOf<R(Args...) const> {
-  using type = R(Args...);
-};
-
 template <template <typename> class C, typename F>
 struct SignatureOf<C<F>,
                    typename std::enable_if<std::is_function<F>::value>::type>

googlemock/test/gmock-function-mocker_test.cc

@@ -942,15 +942,6 @@ static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
 
 }  // namespace
 
-// Like std::add_const, but for function types.
-template <typename F>
-struct AddConstToFunction;
-
-template <typename R, typename... Args>
-struct AddConstToFunction<R(Args...)> {
-  using type = R(Args...) const;
-};
-
 template <typename F>
 class MockMethodMockFunctionSignatureTest : public Test {};
 
@@ -962,69 +953,25 @@ TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest,
 
 TYPED_TEST(MockMethodMockFunctionSignatureTest,
            IsMockFunctionTemplateArgumentDeducedForRawSignature) {
-  // Non-const
-  {
-    using Argument = TypeParam;
-    MockFunction<Argument> foo;
-    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
-  }
-
-  // Const
-  {
-    using Argument = typename AddConstToFunction<TypeParam>::type;
-    MockFunction<Argument> foo;
-    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
-  }
+  using Argument = TypeParam;
+  MockFunction<Argument> foo;
+  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
 }
 
 TYPED_TEST(MockMethodMockFunctionSignatureTest,
            IsMockFunctionTemplateArgumentDeducedForStdFunction) {
-  // Non-const
-  {
-    using Argument = std::function<TypeParam>;
-    MockFunction<Argument> foo;
-    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
-  }
-
-// As of 2026-05 MSVC doesn't know how to deal with this, providing pages of
-// inscrutable errors about std::_Get_function_impl. But this is fine, since
-// std::function<R(Args...) const> doesn't apply the const qualifier correctly
-// anyway.
-#if !defined(_MSC_VER)
-
-  // Const
-  {
-    using Argument =
-        std::function<typename AddConstToFunction<TypeParam>::type>;
-
-    MockFunction<Argument> foo;
-    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
-  }
-
-#endif
+  using Argument = std::function<TypeParam>;
+  MockFunction<Argument> foo;
+  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
 }
 
 TYPED_TEST(
     MockMethodMockFunctionSignatureTest,
     IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) {
-  // Non-const
-  {
-    using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
-    using ForStdFunction =
-        decltype(&MockFunction<std::function<TypeParam>>::Call);
-    EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
-  }
-
-  // Const
-  {
-    using ConstTypeParam = typename AddConstToFunction<TypeParam>::type;
-    using ForRawSignature = decltype(&MockFunction<ConstTypeParam>::Call);
-
-    using ForStdFunction =
-        decltype(&MockFunction<std::function<ConstTypeParam>>::Call);
-
-    EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
-  }
+  using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
+  using ForStdFunction =
+      decltype(&MockFunction<std::function<TypeParam>>::Call);
+  EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
 }
 
 template <typename F>

googletest/include/gtest/gtest-message.h

@@ -129,7 +129,7 @@ class GTEST_API_ Message {
                               int>::type = 0
 #endif  // GTEST_HAS_ABSL
       >
-  Message& operator<<(const T& val) {
+  inline Message& operator<<(const T& val) {
         // Some libraries overload << for STL containers.  These
     // overloads are defined in the global namespace instead of ::std.
     //
@@ -155,7 +155,7 @@ class GTEST_API_ Message {
   template <typename T,
             typename std::enable_if<absl::HasAbslStringify<T>::value,  // NOLINT
                                     int>::type = 0>
-  Message& operator<<(const T& val) {
+  inline Message& operator<<(const T& val) {
     // ::operator<< is needed here for a similar reason as with the non-Abseil
     // version above
     using ::operator<<;

googletest/include/gtest/internal/gtest-death-test-internal.h

@@ -229,8 +229,7 @@ GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
       goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
     }                                                                          \
     if (gtest_dt != nullptr) {                                                 \
-      const std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(     \
-          gtest_dt);                                                           \
+      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
       switch (gtest_dt->AssumeRole()) {                                        \
         case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
           if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \