Index: include/variant
===================================================================
--- include/variant
+++ include/variant
@@ -1097,11 +1097,40 @@
 template <class _Tp, class... _Types>
 struct __overload<_Tp, _Types...> : __overload<_Types...> {
   using __overload<_Types...>::operator();
-  __identity<_Tp> operator()(_Tp) const;
+
+  template <class _Up>
+  auto operator()(_Tp, _Up&& __t) const
+      -> decltype(_Tp{_VSTD::forward<_Up>(__t)}, __identity<_Tp>());
+};
+
+template <class _Base, class _Tp>
+struct __overload_bool : _Base {
+  using _Base::operator();
+
+  template <class _Up, class _Ap = __uncvref_t<_Up>>
+  auto operator()(bool, _Up&&, int _Ap::* = 0) const -> __identity<_Tp>;
+
+  template <class _Up, class _Ap = __uncvref_t<_Up>>
+  auto operator()(bool, _Up&&) const
+      -> enable_if_t<is_same_v<_Ap, bool>, __identity<_Tp>>;
 };
 
+template <class... _Types>
+struct __overload<bool, _Types...>
+    : __overload_bool<__overload<_Types...>, bool> {};
+template <class... _Types>
+struct __overload<bool const, _Types...>
+    : __overload_bool<__overload<_Types...>, bool const> {};
+template <class... _Types>
+struct __overload<bool volatile, _Types...>
+    : __overload_bool<__overload<_Types...>, bool volatile> {};
+template <class... _Types>
+struct __overload<bool const volatile, _Types...>
+    : __overload_bool<__overload<_Types...>, bool const volatile> {};
+
 template <class _Tp, class... _Types>
-using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;
+using __best_match_t =
+    typename invoke_result_t<__overload<_Types...>, _Tp, _Tp>::type;
 
 } // __variant_detail
 
Index: test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
@@ -28,6 +28,7 @@
 #include <string>
 #include <type_traits>
 #include <variant>
+#include <memory>
 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
@@ -128,7 +129,7 @@
 
 void test_T_assignment_sfinae() {
   {
-    using V = std::variant<long, unsigned>;
+    using V = std::variant<long, long long>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
   {
@@ -139,6 +140,15 @@
     using V = std::variant<std::string, void *>;
     static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
   }
+  {
+    using V = std::variant<std::string, float>;
+    static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
+  }
+  {
+    using V = std::variant<std::unique_ptr<int>, bool>;
+    static_assert(!std::is_assignable<V, std::unique_ptr<char>>::value,
+                  "no explicit bool in operator=");
+  }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, int &&>;
@@ -167,6 +177,44 @@
     assert(v.index() == 1);
     assert(std::get<1>(v) == 43);
   }
+  {
+    std::variant<unsigned, long> v;
+    v = 42;
+    assert(v.index() == 1);
+    assert(std::get<1>(v) == 42);
+    v = 43u;
+    assert(v.index() == 0);
+    assert(std::get<0>(v) == 43);
+  }
+  {
+    std::variant<std::string, bool> v = true;
+    v = std::false_type();
+    assert(v.index() == 1);
+    assert(std::get<1>(v) == false);
+    v = "bar";
+    assert(v.index() == 0);
+    assert(std::get<0>(v) == "bar");
+  }
+  {
+    std::variant<bool, std::unique_ptr<int>> v;
+    v = nullptr;
+    assert(v.index() == 1);
+    assert(std::get<1>(v) == nullptr);
+    v = std::true_type();
+    assert(v.index() == 0);
+    assert(std::get<0>(v));
+  }
+  {
+    std::variant<bool volatile, int> v = 42;
+    assert(v.index() == 1);
+    assert(std::get<1>(v) == 42);
+    v = std::false_type();
+    assert(v.index() == 0);
+    assert(!std::get<0>(v));
+    v = true;
+    assert(v.index() == 0);
+    assert(std::get<0>(v));
+  }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &, int &&, long>;
Index: test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
===================================================================
--- test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
+++ test/std/utilities/variant/variant.variant/variant.ctor/T.pass.cpp
@@ -20,6 +20,7 @@
 #include <string>
 #include <type_traits>
 #include <variant>
+#include <memory>
 
 #include "test_convertible.hpp"
 #include "test_macros.h"
@@ -40,6 +41,11 @@
 struct AnyConstructible { template <typename T> AnyConstructible(T&&) {} };
 struct NoConstructible { NoConstructible() = delete; };
 
+template <class T>
+struct RValueConvertibleFrom {
+    RValueConvertibleFrom(T&&) {}
+};
+
 void test_T_ctor_noexcept() {
   {
     using V = std::variant<Dummy, NoThrowT>;
@@ -53,7 +59,7 @@
 
 void test_T_ctor_sfinae() {
   {
-    using V = std::variant<long, unsigned>;
+    using V = std::variant<long, long long>;
     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
   }
   {
@@ -66,6 +72,16 @@
                   "no matching constructor");
   }
   {
+    using V = std::variant<std::string, float>;
+    static_assert(!std::is_constructible<V, int>::value,
+                  "no matching constructor");
+  }
+  {
+    using V = std::variant<std::unique_ptr<int>, bool>;
+    static_assert(!std::is_constructible<V, std::unique_ptr<char>>::value,
+                  "no explicit bool in constructor");
+  }
+  {
     using V = std::variant<AnyConstructible, NoConstructible>;
     static_assert(
         !std::is_constructible<V, std::in_place_type_t<NoConstructible>>::value,
@@ -99,6 +115,34 @@
     static_assert(v.index() == 1, "");
     static_assert(std::get<1>(v) == 42, "");
   }
+  {
+    constexpr std::variant<unsigned, long> v(42);
+    static_assert(v.index() == 1, "");
+    static_assert(std::get<1>(v) == 42, "");
+  }
+  {
+    std::variant<std::string, bool const> v = "foo";
+    assert(v.index() == 0);
+    assert(std::get<0>(v) == "foo");
+  }
+  {
+    std::variant<bool volatile, std::unique_ptr<int>> v = nullptr;
+    assert(v.index() == 1);
+    assert(std::get<1>(v) == nullptr);
+  }
+  {
+    std::variant<bool volatile const, int> v = true;
+    assert(v.index() == 0);
+    assert(std::get<0>(v));
+  }
+  {
+    std::variant<RValueConvertibleFrom<int>> v1 = 42;
+    assert(v1.index() == 0);
+
+    int x = 42;
+    std::variant<RValueConvertibleFrom<int>, AnyConstructible> v2 = x;
+    assert(v2.index() == 1);
+  }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<const int &, int &&, long>;