Add a missing SFINAE condition to the `variant`'s converting constructor.

[mpark]

Summary

Remarks: This function shall not participate in overload resolution unless is_­same_­v<decay_­t<T>, variant> is false, unless decay_­t<T> is neither a specialization of in_­place_­type_­t nor a specialization of in_­place_­index_­t, unless is_­constructible_­v<Tj, T> is true, and unless the expression FUN(​std​::​forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well formed.

Depends on D34111.

[mpark]

Add tests.

[EricWF]

LGTM.

libcxx/trunk/include/variant

constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
       : __impl(in_place_index<0>) {}
 
   variant(const variant&) = default;
   variant(variant&&) = default;
 
   template <
       class _Arg,
       enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
+      enable_if_t<!__is_inplace_type<decay_t<_Arg>>::value, int> = 0,
+      enable_if_t<!__is_inplace_index<decay_t<_Arg>>::value, int> = 0,
       class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
   inline _LIBCPP_INLINE_VISIBILITY
   constexpr variant(_Arg&& __arg) noexcept(
       is_nothrow_constructible_v<_Tp, _Arg>)
       : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}

libcxx/trunk/test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp

 struct ThrowsT {
   ThrowsT(int) noexcept(false) {}
 };
 
 struct NoThrowT {
   NoThrowT(int) noexcept(true) {}
 };
 
+struct AnyConstructible { template <typename T> AnyConstructible(T&&) {} };
+struct NoConstructible { NoConstructible() = delete; };
+
 void test_T_ctor_noexcept() {
   {
     using V = std::variant<Dummy, NoThrowT>;
     static_assert(std::is_nothrow_constructible<V, int>::value, "");
   }
   {
     using V = std::variant<Dummy, ThrowsT>;
     static_assert(!std::is_nothrow_constructible<V, int>::value, "");
void test_T_ctor_sfinae() {
     using V = std::variant<std::string, std::string>;
     static_assert(!std::is_constructible<V, const char *>::value, "ambiguous");
   }
   {
     using V = std::variant<std::string, void *>;
     static_assert(!std::is_constructible<V, int>::value,
                   "no matching constructor");
   }
+  {
+    using V = std::variant<AnyConstructible, NoConstructible>;
+    static_assert(
+        !std::is_constructible<V, std::in_place_type_t<NoConstructible>>::value,
+        "no matching constructor");
+    static_assert(!std::is_constructible<V, std::in_place_index_t<1>>::value,
+                  "no matching constructor");
+  }
+
+
+
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, int &&>;
     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
   }
   {
     using V = std::variant<int, const int &>;
     static_assert(!std::is_constructible<V, int>::value, "ambiguous");