Googletest export

googlemock/include/gmock/gmock-generated-actions.h

@@ -520,7 +520,8 @@ struct InvokeArgumentAction {
   auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
       std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
       std::declval<const Params&>()...)) {
-    internal::FlatTuple<Args&&...> args_tuple(std::forward<Args>(args)...);
+    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{},
+                                              std::forward<Args>(args)...);
     return params.Apply([&](const Params&... unpacked_params) {
       auto&& callable = args_tuple.template Get<index>();
       return internal::InvokeArgument(
@@ -564,7 +565,7 @@ template <std::size_t index, typename... Params>
 internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
 InvokeArgument(Params&&... params) {
   return {internal::FlatTuple<typename std::decay<Params>::type...>(
-      std::forward<Params>(params)...)};
+      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
 }
 
 #ifdef _MSC_VER

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

@@ -1285,14 +1285,9 @@ class FlatTuple
 
  public:
   FlatTuple() = default;
-  template <typename... Args,
-            typename = typename std::enable_if<
-                !std::is_same<void(FlatTuple), void(typename std::decay<
-                                                    Args>::type...)>::value &&
-                (sizeof...(T) >= 1)>::type>
-  explicit FlatTuple(Args&&... args)
-      : FlatTuple::FlatTupleBase(FlatTupleConstructTag{},
-                                 std::forward<Args>(args)...) {}
+  template <typename... Args>
+  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
+      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
 
   using FlatTuple::FlatTupleBase::Apply;
   using FlatTuple::FlatTupleBase::Get;

googletest/include/gtest/internal/gtest-param-util.h

@@ -791,7 +791,7 @@ namespace internal {
 template <typename... Ts>
 class ValueArray {
  public:
-  explicit ValueArray(Ts... v) : v_(std::move(v)...) {}
+  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
 
   template <typename T>
   operator ParamGenerator<T>() const {  // NOLINT

googletest/test/gtest_unittest.cc

@@ -7555,7 +7555,8 @@ TEST(FlatTuple, Basic) {
   EXPECT_EQ(0.0, tuple.Get<1>());
   EXPECT_EQ(nullptr, tuple.Get<2>());
 
-  tuple = FlatTuple<int, double, const char*>(7, 3.2, "Foo");
+  tuple = FlatTuple<int, double, const char*>(
+      testing::internal::FlatTupleConstructTag{}, 7, 3.2, "Foo");
   EXPECT_EQ(7, tuple.Get<0>());
   EXPECT_EQ(3.2, tuple.Get<1>());
   EXPECT_EQ(std::string("Foo"), tuple.Get<2>());
@@ -7573,7 +7574,8 @@ std::string AddIntToString(int i, const std::string& s) {
 TEST(FlatTuple, Apply) {
   using testing::internal::FlatTuple;
 
-  FlatTuple<int, std::string> tuple{5, "Hello"};
+  FlatTuple<int, std::string> tuple{testing::internal::FlatTupleConstructTag{},
+                                    5, "Hello"};
 
   // Lambda.
   EXPECT_TRUE(tuple.Apply([](int i, const std::string& s) -> bool {
@@ -7647,7 +7649,8 @@ TEST(FlatTuple, ConstructorCalls) {
   ConstructionCounting::Reset();
   {
     ConstructionCounting elem;
-    FlatTuple<ConstructionCounting> tuple{elem};
+    FlatTuple<ConstructionCounting> tuple{
+        testing::internal::FlatTupleConstructTag{}, elem};
   }
   EXPECT_EQ(ConstructionCounting::default_ctor_calls, 1);
   EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
@@ -7658,7 +7661,10 @@ TEST(FlatTuple, ConstructorCalls) {
 
   // Move construction.
   ConstructionCounting::Reset();
-  { FlatTuple<ConstructionCounting> tuple{ConstructionCounting{}}; }
+  {
+    FlatTuple<ConstructionCounting> tuple{
+        testing::internal::FlatTupleConstructTag{}, ConstructionCounting{}};
+  }
   EXPECT_EQ(ConstructionCounting::default_ctor_calls, 1);
   EXPECT_EQ(ConstructionCounting::dtor_calls, 2);
   EXPECT_EQ(ConstructionCounting::copy_ctor_calls, 0);