diff --git a/stl/inc/variant b/stl/inc/variant
index bccf5add82..339410bfd7 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -967,10 +967,25 @@ using _Variant_destroy_layer = conditional_t<conjunction_v<is_trivially_destruct
 #pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch
 #pragma warning(disable : 5215) // '%s' a function parameter with volatile qualified type is deprecated in C++20
 #endif // __clang__
-template <size_t _Idx, class _Ty>
+
+#if _HAS_CXX20
+// build Ti x[] = {std::forward<T>(t)};
+template <size_t _Idx, class _TargetType>
+auto _Construct_array(_TargetType(&&)[1]) -> _Meta_list<integral_constant<size_t, _Idx>, _TargetType>;
+
+template <size_t _Idx, class _TargetType, class _InitializerType>
+using _Variant_type_resolver = decltype(_Construct_array<_Idx, _TargetType>({_STD declval<_InitializerType>()}));
+#endif // _HAS_CXX20
+
+template <size_t _Idx, class _TargetType>
 struct _Variant_init_single_overload {
-    using _FTy = _Meta_list<integral_constant<size_t, _Idx>, _Ty> (*)(_Ty);
-    operator _FTy();
+#if _HAS_CXX20
+    template <class _InitializerType>
+    auto operator()(_TargetType, _InitializerType&&) -> _Variant_type_resolver<_Idx, _TargetType, _InitializerType>;
+#else // _HAS_CXX20
+    template <class _InitializerType>
+    auto operator()(_TargetType, _InitializerType&&) -> _Meta_list<integral_constant<size_t, _Idx>, _TargetType>;
+#endif // _HAS_CXX20
 };
 
 template <class _Indices, class... _Types>
@@ -978,7 +993,9 @@ struct _Variant_init_overload_set_;
 
 template <size_t... _Indices, class... _Types>
 struct _Variant_init_overload_set_<index_sequence<_Indices...>, _Types...>
-    : _Variant_init_single_overload<_Indices, _Types>... {};
+    : _Variant_init_single_overload<_Indices, _Types>... {
+    using _Variant_init_single_overload<_Indices, _Types>::operator()...;
+};
 
 template <class... _Types>
 using _Variant_init_overload_set = _Variant_init_overload_set_<index_sequence_for<_Types...>, _Types...>;
@@ -987,11 +1004,12 @@ template <class Enable, class _Ty, class... _Types>
 struct _Variant_init_helper {}; // failure case (has no member "type")
 
 template <class _Ty, class... _Types>
-struct _Variant_init_helper<void_t<decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>()))>, _Ty,
+struct _Variant_init_helper<
+    void_t<decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()))>, _Ty,
     _Types...> {
     // perform overload resolution to determine the unique alternative that should be initialized in
     // variant<_Types...> from an argument expression with type and value category _Ty
-    using type = decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>()));
+    using type = decltype(_Variant_init_overload_set<_Types...>{}(_STD declval<_Ty>(), _STD declval<_Ty>()));
 };
 
 template <class _Ty, class... _Types> // extract the type from _Variant_init_helper
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 2e8d22b23d..f0591e023b 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -159,6 +159,7 @@
 // P0556R3 <bit> Integral Power-Of-2 Operations (renamed by P1956R1)
 // P0586R2 Integer Comparison Functions
 // P0595R2 is_constant_evaluated()
+// P0608R3 Improving variant's Converting Constructor/Assignment
 // P0616R0 Using move() In <numeric>
 // P0631R8 <numbers> Math Constants
 // P0646R1 list/forward_list remove()/remove_if()/unique() Return size_type
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 7b5e0b2210..a403bb4532 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -251,6 +251,7 @@ tests\P0556R3_bit_integral_power_of_two_operations
 tests\P0586R2_integer_comparison
 tests\P0595R2_is_constant_evaluated
 tests\P0607R0_inline_variables
+tests\P0608R3_improved_variant_converting_constructor
 tests\P0616R0_using_move_in_numeric
 tests\P0631R8_numbers_math_constants
 tests\P0660R10_jthread_and_cv_any
diff --git a/tests/std/tests/P0088R3_variant/env.lst b/tests/std/tests/P0088R3_variant/env.lst
index 48e3b76c74..474ef952dd 100644
--- a/tests/std/tests/P0088R3_variant/env.lst
+++ b/tests/std/tests/P0088R3_variant/env.lst
@@ -10,7 +10,7 @@ RUNALL_CROSSLIST
 PM_CL="/w14640 /Zc:threadSafeInit-"
 RUNALL_CROSSLIST
 PM_CL="/EHsc /MD /D_ITERATOR_DEBUG_LEVEL=0 /std:c++latest /permissive- /Zc:noexceptTypes-"
-PM_CL="/EHsc /MD /D_ITERATOR_DEBUG_LEVEL=0 /std:c++17 /DCONSTEXPR_NOTHROW"
+PM_CL="/EHsc /MD /D_ITERATOR_DEBUG_LEVEL=0 /std:c++17 /DCONSTEXPR_NOTHROW /DTEST_PERMISSIVE"
 PM_CL="/EHsc /MD /D_ITERATOR_DEBUG_LEVEL=1 /std:c++latest /permissive-"
 PM_CL="/EHsc /MD /D_ITERATOR_DEBUG_LEVEL=0 /std:c++latest /permissive- /Zc:char8_t- /Zc:preprocessor"
 PM_CL="/EHsc /MDd /D_ITERATOR_DEBUG_LEVEL=0 /std:c++latest /permissive- /Zc:wchar_t-"
@@ -22,15 +22,15 @@ PM_CL="/EHsc /MT /D_ITERATOR_DEBUG_LEVEL=0 /std:c++latest /permissive- /analyze:
 PM_CL="/EHsc /MT /D_ITERATOR_DEBUG_LEVEL=1 /std:c++latest /permissive-"
 PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=0 /std:c++latest /permissive- /fp:strict"
 PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=1 /std:c++latest /permissive-"
-PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /permissive /DCONSTEXPR_NOTHROW"
+PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /permissive /DCONSTEXPR_NOTHROW /DTEST_PERMISSIVE"
 PM_CL="/EHsc /MTd /D_ITERATOR_DEBUG_LEVEL=2 /std:c++latest /permissive- /analyze:only /analyze:autolog-"
 PM_CL="/Za /EHsc /MD /std:c++latest /permissive-"
 PM_CL="/Za /EHsc /MDd /std:c++latest /permissive-"
-PM_CL="/clr /MD /std:c++17 /DCONSTEXPR_NOTHROW"
-PM_CL="/clr /MDd /std:c++17 /DCONSTEXPR_NOTHROW"
+PM_CL="/clr /MD /std:c++17 /DCONSTEXPR_NOTHROW /DTEST_PERMISSIVE"
+PM_CL="/clr /MDd /std:c++17 /DCONSTEXPR_NOTHROW /DTEST_PERMISSIVE"
 PM_CL="/BE /c /EHsc /MD /std:c++latest /permissive-"
 PM_CL="/BE /c /EHsc /MDd /std:c++17 /permissive-"
 PM_CL="/BE /c /EHsc /MTd /std:c++latest /permissive-"
 PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MD /std:c++latest /permissive-"
-PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MDd /std:c++17"
+PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MDd /std:c++17 /DTEST_PERMISSIVE"
 PM_COMPILER="clang-cl" PM_CL="-fno-ms-compatibility -fno-delayed-template-parsing /EHsc /MTd /std:c++latest /permissive- /fp:strict"
diff --git a/tests/std/tests/P0088R3_variant/test.cpp b/tests/std/tests/P0088R3_variant/test.cpp
index 7a66a9f06e..87e482ffec 100644
--- a/tests/std/tests/P0088R3_variant/test.cpp
+++ b/tests/std/tests/P0088R3_variant/test.cpp
@@ -1768,7 +1768,8 @@ int run_test()
 {
   static_assert(!std::is_assignable<std::variant<int, int>, int>::value, "");
   static_assert(!std::is_assignable<std::variant<long, long long>, int>::value, "");
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
   static_assert(std::is_assignable<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
 
   static_assert(std::is_assignable<std::variant<std::string, float>, int>::value
@@ -1778,13 +1779,16 @@ int run_test()
   static_assert(!std::is_assignable<std::variant<std::string, bool>, int>::value, "");
 
   static_assert(!std::is_assignable<std::variant<int, bool>, decltype("meow")>::value, "");
+#endif // !__EDG__
   static_assert(!std::is_assignable<std::variant<int, const bool>, decltype("meow")>::value, "");
   static_assert(!std::is_assignable<std::variant<int, const volatile bool>, decltype("meow")>::value, "");
 
-  static_assert(!std::is_assignable<std::variant<bool>, std::true_type>::value, "");
+  static_assert(std::is_assignable<std::variant<bool>, std::true_type>::value, "");
   static_assert(!std::is_assignable<std::variant<bool>, std::unique_ptr<char> >::value, "");
+#ifndef TEST_PERMISSIVE
   static_assert(!std::is_assignable<std::variant<bool>, decltype(nullptr)>::value, "");
-#endif // TRANSITION, P0608
+#endif // !TEST_PERMISSIVE
+#endif // _HAS_CXX20
 
   return 0;
 }
@@ -3048,7 +3052,8 @@ void test_T_assignment_sfinae() {
     using V = std::variant<std::string, void *>;
     static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
   }
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
   {
     using V = std::variant<std::string, float>;
     static_assert(std::is_assignable<V, int>::value == VariantAllowsNarrowingConversions,
@@ -3063,10 +3068,11 @@ void test_T_assignment_sfinae() {
     };
     static_assert(!std::is_assignable<V, X>::value,
                   "no boolean conversion in operator=");
-    static_assert(!std::is_assignable<V, std::false_type>::value,
+    static_assert(std::is_assignable<V, std::false_type>::value,
                   "no converted to bool in operator=");
   }
-#endif // TRANSITION, P0608
+#endif // !__EDG__
+#endif // _HAS_CXX20
   {
     struct X {};
     struct Y {
@@ -3104,7 +3110,8 @@ void test_T_assignment_basic() {
     assert(v.index() == 1);
     assert(std::get<1>(v) == 43);
   }
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
 #ifndef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
   {
     std::variant<unsigned, long> v;
@@ -3116,19 +3123,22 @@ void test_T_assignment_basic() {
     assert(std::get<0>(v) == 43);
   }
 #endif
+#endif // !__EDG__
   {
     std::variant<std::string, bool> v = true;
     v = "bar";
     assert(v.index() == 0);
     assert(std::get<0>(v) == "bar");
   }
+#ifndef TEST_PERMISSIVE
   {
     std::variant<bool, std::unique_ptr<int>> v;
     v = nullptr;
     assert(v.index() == 1);
     assert(std::get<1>(v) == nullptr);
   }
-#endif // TRANSITION, P0608
+#endif // !TEST_PERMISSIVE
+#endif // _HAS_CXX20
   {
     std::variant<bool volatile, int> v = 42;
     v = false;
@@ -3266,7 +3276,8 @@ int run_test()
 {
   static_assert(!std::is_constructible<std::variant<int, int>, int>::value, "");
   static_assert(!std::is_constructible<std::variant<long, long long>, int>::value, "");
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
   static_assert(std::is_constructible<std::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
 
   static_assert(std::is_constructible<std::variant<std::string, float>, int>::value
@@ -3278,11 +3289,13 @@ int run_test()
   static_assert(!std::is_constructible<std::variant<int, bool>, decltype("meow")>::value, "");
   static_assert(!std::is_constructible<std::variant<int, const bool>, decltype("meow")>::value, "");
   static_assert(!std::is_constructible<std::variant<int, const volatile bool>, decltype("meow")>::value, "");
-
-  static_assert(!std::is_constructible<std::variant<bool>, std::true_type>::value, "");
+#endif // !__EDG__
+  static_assert(std::is_constructible<std::variant<bool>, std::true_type>::value, "");
   static_assert(!std::is_constructible<std::variant<bool>, std::unique_ptr<char> >::value, "");
+#ifndef TEST_PERMISSIVE
   static_assert(!std::is_constructible<std::variant<bool>, decltype(nullptr)>::value, "");
-#endif // TRANSITION, P0608
+#endif // !TEST_PERMISSIVE
+#endif // _HAS_CXX20
 
   return 0;
 }
@@ -4567,7 +4580,8 @@ void test_T_ctor_sfinae() {
     static_assert(!std::is_constructible<V, int>::value,
                   "no matching constructor");
   }
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
   {
     using V = std::variant<std::string, float>;
     static_assert(std::is_constructible<V, int>::value == VariantAllowsNarrowingConversions,
@@ -4582,10 +4596,11 @@ void test_T_ctor_sfinae() {
     };
     static_assert(!std::is_constructible<V, X>::value,
                   "no boolean conversion in constructor");
-    static_assert(!std::is_constructible<V, std::false_type>::value,
+    static_assert(std::is_constructible<V, std::false_type>::value,
                   "no converted to bool in constructor");
   }
-#endif // TRANSITION, P0608
+#endif // !__EDG__
+#endif // _HAS_CXX20
   {
     struct X {};
     struct Y {
@@ -4629,7 +4644,8 @@ void test_T_ctor_basic() {
     static_assert(v.index() == 1, "");
     static_assert(std::get<1>(v) == 42, "");
   }
-#if 0 // TRANSITION, P0608
+#if _HAS_CXX20
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
 #ifndef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
   {
     constexpr std::variant<unsigned, long> v(42);
@@ -4637,17 +4653,20 @@ void test_T_ctor_basic() {
     static_assert(std::get<1>(v) == 42, "");
   }
 #endif
+#endif // !__EDG__
   {
     std::variant<std::string, bool const> v = "meow";
     assert(v.index() == 0);
     assert(std::get<0>(v) == "meow");
   }
+#ifndef TEST_PERMISSIVE
   {
     std::variant<bool volatile, std::unique_ptr<int>> v = nullptr;
     assert(v.index() == 1);
     assert(std::get<1>(v) == nullptr);
   }
-#endif // TRANSITION, P0608
+#endif // !TEST_PERMISSIVE
+#endif // _HAS_CXX20
   {
     std::variant<bool volatile const, int> v = true;
     assert(v.index() == 0);
@@ -4681,6 +4700,7 @@ void test_T_ctor_basic() {
 #endif
 }
 
+#if !_HAS_CXX20 // Narrowing check occurs with P0608R3
 struct BoomOnAnything {
   template <class T>
   constexpr BoomOnAnything(T) { static_assert(!std::is_same<T, T>::value, ""); }
@@ -4692,6 +4712,7 @@ void test_no_narrowing_check_for_class_types() {
   assert(v.index() == 0);
   assert(std::get<0>(v) == 42);
 }
+#endif // Narrowing check occurs with P0608R3
 
 struct Bar {};
 struct Baz {};
@@ -4708,7 +4729,9 @@ int run_test() {
   test_T_ctor_basic();
   test_T_ctor_noexcept();
   test_T_ctor_sfinae();
+#if !_HAS_CXX20 // Narrowing check occurs with P0608R3
   test_no_narrowing_check_for_class_types();
+#endif // Narrowing check occurs with P0608R3
   test_construction_with_repeated_types();
   return 0;
 }
diff --git a/tests/std/tests/P0608R3_improved_variant_converting_constructor/env.lst b/tests/std/tests/P0608R3_improved_variant_converting_constructor/env.lst
new file mode 100644
index 0000000000..642f530ffa
--- /dev/null
+++ b/tests/std/tests/P0608R3_improved_variant_converting_constructor/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst
diff --git a/tests/std/tests/P0608R3_improved_variant_converting_constructor/test.cpp b/tests/std/tests/P0608R3_improved_variant_converting_constructor/test.cpp
new file mode 100644
index 0000000000..2d407f7d1e
--- /dev/null
+++ b/tests/std/tests/P0608R3_improved_variant_converting_constructor/test.cpp
@@ -0,0 +1,263 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Also tests for P1957R2: Converting from T* to bool should be considered narrowing
+
+#include <assert.h>
+#include <bitset>
+#include <functional>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+using namespace std;
+
+struct double_double {
+    double_double(double x) : x_(x) {}
+
+    double x_;
+};
+struct convertible_bool {
+    convertible_bool(bool x) : x_(x) {}
+    ~convertible_bool() = default;
+
+    operator bool() const noexcept {
+        return x_;
+    }
+
+    bool x_;
+};
+struct default_struct {};
+
+void assert_P0608R3() {
+    // P0608R3 examples
+    static_assert(is_constructible_v<variant<string, bool>, const char*>);
+    static_assert(is_constructible_v<variant<string, bool>, string>);
+    static_assert(is_constructible_v<variant<char, optional<char16_t>>, char16_t>);
+    static_assert(is_constructible_v<variant<int, reference_wrapper<double>>, double&>);
+    static_assert(is_constructible_v<variant<float, int>, char>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    static_assert(is_constructible_v<variant<float, long>, int>);
+    static_assert(is_constructible_v<variant<float, long long>, int>);
+    static_assert(is_constructible_v<variant<float, long, double>, int>);
+    static_assert(is_constructible_v<variant<float, vector<int>, long long>, int>);
+#endif // !__EDG__
+    static_assert(is_constructible_v<variant<float, int, long long>, char>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    static_assert(!is_constructible_v<variant<float>, int>);
+    static_assert(!is_constructible_v<variant<float, vector<int>>, int>);
+#endif // !__EDG__
+    static_assert(!is_constructible_v<variant<float, char>, int>);
+
+    static_assert(is_assignable_v<variant<string, bool>, const char*>);
+    static_assert(is_assignable_v<variant<string, bool>, string>);
+    static_assert(is_assignable_v<variant<char, optional<char16_t>>, char16_t>);
+    static_assert(is_assignable_v<variant<int, reference_wrapper<double>>, double&>);
+    static_assert(is_assignable_v<variant<float, int>, char>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    static_assert(is_assignable_v<variant<float, long>, int>);
+    static_assert(is_assignable_v<variant<float, long long>, int>);
+    static_assert(is_assignable_v<variant<float, long, double>, int>);
+    static_assert(is_assignable_v<variant<float, vector<int>, long long>, int>);
+#endif // !__EDG__
+    static_assert(is_assignable_v<variant<float, int, long long>, char>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    static_assert(!is_assignable_v<variant<float>, int>);
+    static_assert(!is_assignable_v<variant<float, vector<int>>, int>);
+#endif // !__EDG__
+    static_assert(!is_assignable_v<variant<float, char>, int>);
+}
+
+void assert_P1957R2() {
+    // P1957R2 examples
+    static_assert(is_constructible_v<variant<bool, int>, bool>);
+    static_assert(is_constructible_v<variant<bool, int>, bitset<4>::reference>);
+    static_assert(is_constructible_v<variant<bool>, bitset<4>::reference>);
+
+    static_assert(is_assignable_v<variant<bool, int>, bool>);
+    static_assert(is_assignable_v<variant<bool, int>, bitset<4>::reference>);
+    static_assert(is_assignable_v<variant<bool>, bitset<4>::reference>);
+}
+
+void assert_more_examples() {
+    // More examples
+    static_assert(is_constructible_v<variant<double_double>, double>);
+    static_assert(is_constructible_v<variant<vector<vector<int>>, optional<int>, int>, int>);
+    static_assert(is_constructible_v<variant<vector<vector<int>>, optional<int>>, int>);
+    static_assert(is_constructible_v<variant<vector<int>, optional<int>, float>, int>);
+    static_assert(is_constructible_v<variant<bool>, convertible_bool>);
+    static_assert(is_constructible_v<variant<bool, int>, convertible_bool>);
+    static_assert(is_constructible_v<variant<convertible_bool>, bool>);
+    static_assert(is_constructible_v<variant<float, bool, convertible_bool>, convertible_bool>);
+    static_assert(is_constructible_v<variant<float, bool, convertible_bool>, bool>);
+    static_assert(is_constructible_v<variant<char, int>, bool>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+#ifdef __clang__ // TRANSITION, DevCom-1338628
+    static_assert(is_constructible_v<variant<double_double>, int>);
+#endif // __clang__
+    static_assert(!is_constructible_v<variant<float>, unsigned int>);
+    static_assert(!is_constructible_v<variant<char, default_struct>, int>);
+#endif // !__EDG__
+    static_assert(!is_constructible_v<variant<float, long, long long>, int>);
+
+    static_assert(is_assignable_v<variant<double_double>, double>);
+    static_assert(is_assignable_v<variant<vector<vector<int>>, optional<int>, int>, int>);
+    static_assert(is_assignable_v<variant<vector<vector<int>>, optional<int>>, int>);
+    static_assert(is_assignable_v<variant<vector<int>, optional<int>, float>, int>);
+    static_assert(is_assignable_v<variant<bool>, convertible_bool>);
+    static_assert(is_assignable_v<variant<bool, int>, convertible_bool>);
+    static_assert(is_assignable_v<variant<convertible_bool>, bool>);
+    static_assert(is_assignable_v<variant<float, bool, convertible_bool>, convertible_bool>);
+    static_assert(is_assignable_v<variant<float, bool, convertible_bool>, bool>);
+    static_assert(is_assignable_v<variant<char, int>, bool>);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+#ifdef __clang__ // TRANSITION, DevCom-1338628
+    static_assert(is_assignable_v<variant<double_double>, int>);
+#endif // __clang__
+    static_assert(!is_assignable_v<variant<float>, unsigned int>);
+    static_assert(!is_assignable_v<variant<char, default_struct>, int>);
+#endif // !__EDG__
+    static_assert(!is_assignable_v<variant<float, long, long long>, int>);
+}
+
+void test_variant_constructor_P0608R3() {
+    // P0608R3 runtime checks
+    variant<string, bool> a = "abc"; // string
+    assert(a.index() == 0);
+    assert(get<0>(a) == "abc");
+
+    variant<char, optional<char16_t>> b = u'\u2043'; // optional<char16_t>
+    assert(b.index() == 1);
+    assert(get<optional<char16_t>>(b) == u'\u2043');
+
+    double c_data                             = 3.14;
+    variant<int, reference_wrapper<double>> c = c_data; // reference_wrapper<double>
+    assert(c.index() == 1);
+    assert(get<1>(c) == c_data);
+
+    variant<float, int> d;
+    assert(d.index() == 0);
+    d = 0; // int
+    assert(d.index() == 1);
+
+    variant<float, long> e;
+    assert(e.index() == 0);
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    e = 0; // long
+    assert(e.index() == 1);
+#endif // !__EDG__
+
+    variant<float, int> f = 'a'; // int
+    assert(f.index() == 1);
+    assert(get<int>(f) == 97);
+
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    variant<float, long> g = 0; // long
+    assert(g.index() == 1);
+
+    variant<float, long, double> h = 0; // long
+    assert(h.index() == 1);
+
+    variant<float, vector<int>, long long> i = 0; // long long
+    assert(i.index() == 2);
+#endif // !__EDG__
+
+    variant<float, int, long long> j = 'a'; // int
+    assert(j.index() == 1);
+    assert(get<int>(j) == 97);
+}
+
+void test_variant_constructor_P1957R2() {
+    bitset<4> a_bitset("0101");
+    bool a_data          = a_bitset[2];
+    variant<bool, int> a = a_data; // bool
+    assert(a.index() == 0);
+    assert(get<0>(a));
+
+    bitset<4> b_bitset("0101");
+    variant<bool, int> b  = b_bitset[2]; // bool
+    variant<bool, int> b2 = b_bitset[1]; // bool
+    assert(b.index() == 0);
+    assert(get<0>(b));
+    assert(b2.index() == 0);
+    assert(!get<0>(b2));
+}
+
+void test_variant_constructor_more_examples() {
+    variant<char, int, float, bool, vector<bool>> a = true; // bool
+    assert(a.index() == 3);
+
+    variant<bool, int> b = convertible_bool{true}; // bool
+    assert(b.index() == 0);
+    assert(get<0>(b));
+
+    variant<char, int, bool> c = false; // bool
+    assert(c.index() == 2);
+
+    variant<float, bool, convertible_bool> d = convertible_bool{true}; // convertible_bool
+    assert(d.index() == 2);
+
+    variant<float, bool, convertible_bool> e = bool{}; // bool
+    assert(e.index() == 1);
+    assert(!get<1>(e));
+
+    variant<float, bool> f = convertible_bool{false}; // bool
+    assert(f.index() == 1);
+    assert(!get<1>(f));
+
+    variant<bool, int> g = true_type{}; // bool
+    assert(g.index() == 0);
+    assert(get<0>(g));
+}
+
+void test_assignment_operator() {
+    variant<string, bool, int> a; // string
+    assert(a.index() == 0);
+    assert(get<string>(a) == "");
+    a = 3; // int
+    assert(a.index() == 2);
+    assert(get<int>(a) == 3);
+    a = true; // bool
+    assert(a.index() == 1);
+    assert(get<bool>(a) == true);
+
+#ifndef __EDG__ // TRANSITION, DevCom-1337958
+    bool b_data                         = true;
+    variant<bool, int, double_double> b = b_data; // bool
+    assert(b.index() == 0);
+    assert(get<0>(b) == b_data);
+    b = 12; // int
+    assert(b.index() == 1);
+    assert(get<1>(b) == 12);
+    b = 12.5; // double_double
+    assert(b.index() == 2);
+    assert(get<2>(b).x_ == 12.5);
+#endif // !__EDG__
+
+#ifdef __clang__ // TRANSITION, DevCom-1338628
+    variant<void*, bool, double_double> c;
+    assert(c.index() == 0);
+    c = false; // bool
+    assert(c.index() == 1);
+    assert(get<1>(c) == false);
+    c = 5.12; // double_double
+    assert(c.index() == 2);
+    assert(get<2>(c).x_ == 5.12);
+    double_double c_data{1.2};
+    c = static_cast<void*>(&c_data); // void*
+    assert(c.index() == 0);
+    assert(static_cast<double_double*>(get<0>(c))->x_ == 1.2);
+#endif // __clang__
+}
+
+int main() {
+    assert_P0608R3();
+    assert_P1957R2();
+    assert_more_examples();
+    test_variant_constructor_P0608R3();
+    test_variant_constructor_P1957R2();
+    test_variant_constructor_more_examples();
+    test_assignment_operator();
+}