<tuple>: Make std::make_from_tuple SFINAE friendly

stl/inc/tuple

@@ -1079,24 +1079,27 @@ constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
 }
 
-#if _HAS_CXX23
-template <class _Ty, _Tuple_like _Tuple, size_t... _Indices>
-#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Ty, class _Tuple, class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>>
+inline constexpr bool _Can_make_from_tuple = false;
+template <class _Ty, class _Tuple, size_t... _Indices>
+inline constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
+    is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD declval<_Tuple>()))...>;
+
 template <class _Ty, class _Tuple, size_t... _Indices>
-#endif // ^^^ !_HAS_CXX23 ^^^
 constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
     is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
-    // construct _Ty from the elements of _Tpl
-    static_assert(is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>,
-        "the target type must be constructible from the fields of the argument tuple (N4950 [tuple.apply]/4).");
     return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
 #if _HAS_CXX23
 _EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
-#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#elif _HAS_CXX20
 _EXPORT_STD template <class _Ty, class _Tuple>
-#endif // ^^^ !_HAS_CXX23 ^^^
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Tuple, enable_if_t<_Can_make_from_tuple<_Ty, _Tuple>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
 _NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_STD _Make_from_tuple_impl<_Ty>(
     _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
     // construct _Ty from the elements of _Tpl

tests/std/test.lst

@@ -249,6 +249,7 @@ tests\LWG3146_excessive_unwrapping_ref_cref
 tests\LWG3234_math_special_overloads
 tests\LWG3422_seed_seq_ctors
 tests\LWG3480_directory_iterator_range
+tests\LWG3528_make_from_tuple_impl
 tests\LWG3545_pointer_traits_sfinae
 tests\LWG3561_discard_block_engine_counter
 tests\LWG3610_iota_view_size_and_integer_class

tests/std/tests/LWG3528_make_from_tuple_impl/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_17_matrix.lst

tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//===----------------------------------------------------------------------===//
+
+// derived from libc++'s test files:
+// * std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
+
+#include <array>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+struct A {
+    int a;
+};
+
+enum class D {
+    one,
+    two,
+};
+
+template <class T, class Tuple, class = void>
+inline constexpr bool has_make_from_tuple = false;
+
+template <class T, class Tuple>
+inline constexpr bool
+    has_make_from_tuple<T, Tuple, std::void_t<decltype(std::make_from_tuple<T>(std::declval<Tuple>()))>> = true;
+
+// Test std::make_from_tuple.
+
+// reinterpret_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<int*, std::tuple<A*>>);
+static_assert(has_make_from_tuple<A*, std::tuple<A*>>);
+
+// reinterpret_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<int*, std::array<A*, 1>>);
+static_assert(has_make_from_tuple<A*, std::array<A*, 1>>);
+
+// const_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<char*, std::tuple<const char*>>);
+static_assert(!has_make_from_tuple<volatile char*, std::tuple<const volatile char*>>);
+static_assert(has_make_from_tuple<volatile char*, std::tuple<volatile char*>>);
+static_assert(has_make_from_tuple<char*, std::tuple<char*>>);
+static_assert(has_make_from_tuple<const char*, std::tuple<char*>>);
+static_assert(has_make_from_tuple<const volatile char*, std::tuple<volatile char*>>);
+
+// const_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<char*, std::array<const char*, 1>>);
+static_assert(!has_make_from_tuple<volatile char*, std::array<const volatile char*, 1>>);
+static_assert(has_make_from_tuple<volatile char*, std::array<volatile char*, 1>>);
+static_assert(has_make_from_tuple<char*, std::array<char*, 1>>);
+static_assert(has_make_from_tuple<const char*, std::array<char*, 1>>);
+static_assert(has_make_from_tuple<const volatile char*, std::array<volatile char*, 1>>);
+
+// static_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<int, std::tuple<D>>);
+static_assert(!has_make_from_tuple<D, std::tuple<int>>);
+static_assert(has_make_from_tuple<long, std::tuple<int>>);
+static_assert(has_make_from_tuple<double, std::tuple<float>>);
+static_assert(has_make_from_tuple<float, std::tuple<double>>);
+
+// static_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<int, std::array<D, 1>>);
+static_assert(!has_make_from_tuple<D, std::array<int, 1>>);
+static_assert(has_make_from_tuple<long, std::array<int, 1>>);
+static_assert(has_make_from_tuple<double, std::array<float, 1>>);
+static_assert(has_make_from_tuple<float, std::array<double, 1>>);