Implemented C++17 <variant>.

[mpark]

• Fixed <variant> comparison operators as per P0393.

[mpark]

• Fixed <variant> comparison operators as per P0393.

[mpark]

Rebased off of master.

[EricWF]

Sorry for the delay. I've been looking at this tonight and it looks pretty good. I''ll finish up the review in the morning.

The one big issue I've seen is the handling of special member function SFINAE. I think there are some issues here, but I'll double check the standard docs in the morning.

[EricWF]

CMakeLists.txt

304 ↗

(On Diff #67545)

Please keep libc++ building at C++11. We can't bump it just yet.

include/variant

254

If you want to use macros like this please define it immediately before the first use, and undefine it immediately after.

259

Please scrap this macro and all of its usages entirely. If we want to know if a construction doesn't throw then we should use type traits on the user types, not on our base types.

270

libc++ doesn't put exception types in the versioning namespace. Please define this directly in namespace std. See bad_optional_access for an example.

272

There is no need to declare this destructor.

279

_LIBCPP_TYPE_VIS.

311

add_const<...> has the same effect as __identity<add_const_t<...>>.

1093

Please don't write the SFINAE and noexcept in terms of how the base class acts. The Spec defines the SFINAE/noexcept for this functions as:

The expression inside noexcept is equivalent to is_nothrow_default_constructible_v<T 0 >.
This function shall not participate in overload resolution unless is_default_constructible_v<T 0 > is true.

Please check these conditions are directly as possible, so it's easy to see if they're correct upon inspection.

[mpark]

Made some progress tonight. Will continue tomorrow.

• Updated variant synopsis.
• Removed allocator support from variant.
• Removed support for empty set of alternatives in a variant.
• Removed support for void as an alternative in a variant.
• Removed support for reference types in a variant.
• Removed __all_v.
• Moved bad_variant_access to unversioned namespace.
• Removed unnecessary uses of __identity.

[mpark]

include/variant

279

I've removed the forward declaration of variant. Does the definition need _LIBCPP_TYPE_VIS? or is it only for forward declarations?

[mpark]

Looks like I messed up in updating the diff. Sorry about that :(

[mpark]

Closed namespace std with a comment

[mpark]

• Removed unnecessary use of __size_constant.

[mpark]

TODO:

• Kill _LIBCPP_NOEXCEPT_SFINAE_RETURN
• Kill _LIBCPP_NOEXCEPT_INIT
• Specify the SFINAE / noexcept conditions at the variant level.
• Update unit tests.

[mpark]

This comment was removed by mpark.

[mpark]

• Killed _LIBCPP_NOEXCEPT_SFINAE_RETURN.
• Killed _LIBCPP_NOEXCEPT_INIT.
• Specified the SFINAE / noexcept conditions at the variant level.

[mpark]

This comment was removed by mpark.

[mpark]

include/variant

279

Added it back, since I removed it prematurely.

[mpark]

• Fixed <variant> comparison operators as per P0393.
• Updated variant synopsis.
• Removed allocator support from variant.
• Removed support for empty set of alternatives in a variant.
• Removed support for void as an alternative in a variant.
• Removed support for reference types in a variant.
• Removed __all_v.
• Moved bad_variant_access to unversioned namespace.
• Removed unnecessary uses of __identity.
• Removed unnecessary use of __size_constant.
• Addressed Eric's comments.
• Updated variant tests.
• Adopted to use the new in_place tags.
• variant_alt() should be = default.
• Fixed variant comparison operators test.
• Removed variant's uses_allocator test.

[mpark]

• Fixed <variant> comparison operators as per P0393.
• Updated variant synopsis.
• Removed allocator support from variant.
• Removed support for empty set of alternatives in a variant.
• Removed support for void as an alternative in a variant.
• Removed support for reference types in a variant.
• Removed __all_v.
• Moved bad_variant_access to unversioned namespace.
• Removed unnecessary uses of __identity.
• Removed unnecessary use of __size_constant.
• Addressed Eric's comments.
• Updated variant tests.
• Adopted to use the new in_place tags.
• variant_alt() should be = default.
• Fixed variant comparison operators test.
• Removed variant's uses_allocator test.
• Disallowed array types in variant.
• Added new tests.

[mpark]

• Removed __get_value function which is now unnecessary

[mpark]

test/std/utilities/variant/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp

55 ↗

(On Diff #78689)

This test is currently fails. However, TestTypes::NoCtors inherits from ::ArchetypeBases::TestBase<NoCtors> which defines the following constructors:

template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
  : value(il.size()) {
    ++alive; ++constructed; ++value_constructed;
}
template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(il.size()) {
    ++alive; ++constructed; ++value_constructed;
}

These constructors are not = deleted in NoCtors. So the behavior we observe here is correct.

But I'm not sure which direction we should be solving this, since I don't fully understand the intended semantics of these test classes.

test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp

459–461

I don't think the non-member swap is SFINAE'd out based on the current wording.

537–539

I don't think the non-member swap is SFINAE'd out based on the current wording.

[mpark]

Removed Eric's tests.

[EricWF]

include/variant

274

Please lift this inside the template body, and add a static assert that the index is in range.

334

__variant_best_match_t if it gives you the type back directly please.

335

In order to avoid forming a function which takes an abstract class by value please change this to.

typename result_of_t<__variant_overload<_Types...>(_Tp&&)>::type;

551

Please use _UpperCamelCase for template parameters.

765

Names like __is_nothrow_move_constructible may be the compiler builtin used to implement is_nothrow_move_constructible. Try to avoid them.

802

__assign_alt needs to be public in order to use it in the lambda according to GCC.

852

Seems like an awkward way to make the type dependent. Maybe something like this?

bool _Dummy = true,
class = enable_if_t<
  is_default_constructible_v<
    typename __dependent_type<variant_alternative_t<0, variant>, _Dummy>::type
>>

864

The && is almost always unnecessary. Libc++ usually omits it and you should too.

867

_Arg&& __arg (ie add a space)

1015

Clang and GCC disagree on the type of this expression. Clang produces the reference qualified type but GCC does not. I think a better formulation is:

return ((void)__holds_alternative<_Ip>(__v) ? (void)0 : throw bad_variant_access{}), __variant_access::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;

[mpark]

Addressed a few of the comments.

include/variant

274

Which of the following would you prefer?
I think you're looking for the latter?

template <size_t _Ip, class... _Types>
struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>>
    : __identity<__type_pack_element<_Ip, _Types...>> {
  static_assert(_Ip < sizeof...(_Types));
};

template <size_t _Ip, class... _Types>
struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>> {
  static_assert(_Ip < sizeof...(_Types));
  using type = __type_pack_element<_Ip, _Types...>;
};

[mpark]

Removed test/std/utilities/lit.local.cfg.

[mpark]

Removed the use of &&.

[EricWF]

I think the only thing left to mention are visibility macros.

_LIBCPP_INLINE_VISIBILITY should be applied to most publicly visible functions, especially if they are only a line or two.

Also inline should be added to any non-inline function template. (Note: inline definitions and constexpr functions are both implicitly inline).

include/variant

544

This should be constrained to not pick up __variant_alt

779

Why not forward?

[EricWF]

include/variant

615

I think we get a better layout putting __index second when one of the types in the variant requires more alignment than size_t. In the current layout that will cause 8 bytes of padding between __index and __data. What do you think?

[mpark]

include/variant

779

haha, had done this myself just in time.

[mpark]

Address a few more of Eric's comments.

[mpark]

Use an if statement rather than ternary operator.

[mpark]

Help out GCC.

[mpark]

include/variant

802

Updated to this->__assign_alt(...);

[mpark]

Fix variant swap.

[mpark]

Use member swap to define non-member swap.

[mpark]

Made __variant_alt safer for construction.

[mpark]

include/variant

544

Good catch! I've added an in_place_t tag parameter to avoid this rather than adding a bunch of SFINAE conditions.

[mpark]

include/variant

274

Used the latter.

[mpark]

Pulled out __first_type.

[mpark]

TODO:

• Think about layout
• Implement constexpr copy/move ctors for variant that holds all trivially_copyable types.
• Don't forget about https://reviews.llvm.org/D23263#603887
• Investigate https://reviews.llvm.org/D26899#602539

[ruoka]

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{

bool operator () (bool, bool)
{
  return true;
}
bool operator () (const std::string&, const std::string&)
{
  return true;
}

};

int main()
{

visitor vis;
variant<bool,std::string> var1, var2;
bool b1, b2;
std::string str1, str2;

b1 = b2 = true;
std::invoke(vis, b1, b2);

var1 = var2 = true;
visit(vis, var1, var2);

str1 = str2 = "test";
std::invoke(vis, str1, str2);

var1 = var2 = "test";
visit(vis, var1, var2);

}

[mpark]

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

[ruoka]

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

[mpark]

• Added visibility macro _LIBCPP_INLINE_VISIBILITY + inline.
• Preserved triviality of special member functions.
• Added libcxx tests for the trivial special member functions feature.
• Reorganized the structure of the file.
• Consistently used const T rather than T const in tests.

[mpark]

In D23263#607998, @ruoka wrote:

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

All of the examples on that page perform visitation with a single variant, which satisfies the exhaustive match requirement.
For your multi-visitation example to be exhaustive, you need to handle the bool, const std::string&, and const std::string&, bool
cases. You can achieve that either by adding operator()(bool, const std::string&) and operator()(const std::string&, bool), or
by adding a "default handler", i.e. template <typename T, typename U> operator()(const T&, const U&);.

[mpark]

Rebased

[ruoka]

In D23263#609001, @mpark wrote:

In D23263#607998, @ruoka wrote:

In D23263#606107, @mpark wrote:

In D23263#604565, @ruoka wrote:

This test fails to compile. Shouldn’t the visit work similarly to invoke?

#include <variant>
#include <functional>
#include <string>

using std::variant;
using std::visit;

struct visitor
{
  bool operator () (bool, bool)
  {
    return true;
  }
  bool operator () (const std::string&, const std::string&)
  {
    return true;
  }
};

int main()
{
  visitor vis;
  variant<bool,std::string> var1, var2;
  bool b1, b2;
  std::string str1, str2;

  b1 = b2 = true;
  std::invoke(vis, b1, b2);

  var1 = var2 = true;
  visit(vis, var1, var2);

  str1 = str2 = "test";
  std::invoke(vis, str1, str2);

  var1 = var2 = "test";
  visit(vis, var1, var2);
}

No, I don't believe so. IIUC, visit requires exhaustive matching from a visitor.
In your example, visitor does not have handlers for (bool, const std::string&) and (const std::string&, bool).

Boost had a similar example. There visit seemed to work similarly to the std::invoke. But maybe that is not required from the std::visit in the standard.

http://www.boost.org/doc/libs/1_61_0/doc/html/variant/reference.html#variant.concepts.static-visitor.examples

All of the examples on that page perform visitation with a single variant, which satisfies the exhaustive match requirement.
For your multi-visitation example to be exhaustive, you need to handle the bool, const std::string&, and const std::string&, bool
cases. You can achieve that either by adding operator()(bool, const std::string&) and operator()(const std::string&, bool), or
by adding a "default handler", i.e. template <typename T, typename U> operator()(const T&, const U&);.

I see your point now. I guess this is what the "for all combinations of alternative types of all variants" means. I didn't realise it before. Thanks!

[mpark]

Fixed formatting.

[mpark]

• Used unsigned int rather than size_t for index
• Placed index second so that we have trailing padding rather than in the middle.
• Used __sfinae_ctor_base and` __sfinae_assign_base` for special member SFINAE.

[EricWF]

LGTM.

I've attached a couple of inline comments that I generated a couple of days ago.

include/variant

285

This is beautiful metaprogramming. C++14 constexpr FTW.

814

I really dislike passing uninitialized memory as __variant_alt<_Ip, _Tp>&. I'm pretty sure it's UB. Optimally we should pass this in as a void* but IDK how to easily change this.

You don't need to change this. Just leaving a note.

816

Needs (void*) cast to avoid ADL.

1216

I think we should choose a less common value to hash valueless variants to.

1232

I think we want to return a more interesting hash value than that. 0 seems likely to cause hash collisions. Maybe some large prime?

[EricWF]

Woot! Thanks for all your hard work! I'm sure there will be more <variant> changes and cleanup to come, but this is ready to land in-tree.

[EricWF]

r288547.

include/variant

+// -*- C++ -*-
+//===------------------------------ variant -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_VARIANT
+#define _LIBCPP_VARIANT
+
+/*
+   variant synopsis
+
+namespace std {
+
+  // 20.7.2, class template variant
+  template <class... Types>
+  class variant {
+  public:
+
+    // 20.7.2.1, constructors
+    constexpr variant() noexcept(see below);
+    variant(const variant&);
+    variant(variant&&) noexcept(see below);
+
+    template <class T> constexpr variant(T&&) noexcept(see below);
+
+    template <class T, class... Args>
+    constexpr explicit variant(in_place_type_t<T>, Args&&...);
+
+    template <class T, class U, class... Args>
+    constexpr explicit variant(
+        in_place_type_t<T>, initializer_list<U>, Args&&...);
+
+    template <size_t I, class... Args>
+    constexpr explicit variant(in_place_index_t<I>, Args&&...);
+
+    template <size_t I, class U, class... Args>
+    constexpr explicit variant(
+        in_place_index_t<I>, initializer_list<U>, Args&&...);
+
+    // 20.7.2.2, destructor
+    ~variant();
+
+    // 20.7.2.3, assignment
+    variant& operator=(const variant&);
+    variant& operator=(variant&&) noexcept(see below);
+
+    template <class T> variant& operator=(T&&) noexcept(see below);
+
+    // 20.7.2.4, modifiers
+    template <class T, class... Args>
+    void emplace(Args&&...);
+
+    template <class T, class U, class... Args>
+    void emplace(initializer_list<U>, Args&&...);
+
+    template <size_t I, class... Args>
+    void emplace(Args&&...);
+
+    template <size_t I, class U, class...  Args>
+    void emplace(initializer_list<U>, Args&&...);
+
+    // 20.7.2.5, value status
+    constexpr bool valueless_by_exception() const noexcept;
+    constexpr size_t index() const noexcept;
+
+    // 20.7.2.6, swap
+    void swap(variant&) noexcept(see below);
+  };
+
+  // 20.7.3, variant helper classes
+  template <class T> struct variant_size; // undefined
+
+  template <class T>
+  constexpr size_t variant_size_v = variant_size<T>::value;
+
+  template <class T> struct variant_size<const T>;
+  template <class T> struct variant_size<volatile T>;
+  template <class T> struct variant_size<const volatile T>;
+
+  template <class... Types>
+  struct variant_size<variant<Types...>>;
+
+  template <size_t I, class T> struct variant_alternative; // undefined
+
+  template <size_t I, class T>
+  using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+  template <size_t I, class T> struct variant_alternative<I, const T>;
+  template <size_t I, class T> struct variant_alternative<I, volatile T>;
+  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
+
+  template <size_t I, class... Types>
+  struct variant_alternative<I, variant<Types...>>;
+
+  constexpr size_t variant_npos = -1;
+
+  // 20.7.4, value access
+  template <class T, class... Types>
+  constexpr bool holds_alternative(const variant<Types...>&) noexcept;
+
+  template <size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>>&
+  get(variant<Types...>&);
+
+  template <size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>>&&
+  get(variant<Types...>&&);
+
+  template <size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>> const&
+  get(const variant<Types...>&);
+
+  template <size_t I, class... Types>
+  constexpr variant_alternative_t<I, variant<Types...>> const&&
+  get(const variant<Types...>&&);
+
+  template <class T, class...  Types>
+  constexpr T& get(variant<Types...>&);
+
+  template <class T, class... Types>
+  constexpr T&& get(variant<Types...>&&);
+
+  template <class T, class... Types>
+  constexpr const T& get(const variant<Types...>&);
+
+  template <class T, class... Types>
+  constexpr const T&& get(const variant<Types...>&&);
+
+  template <size_t I, class... Types>
+  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
+  get_if(variant<Types...>*) noexcept;
+
+  template <size_t I, class... Types>
+  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
+  get_if(const variant<Types...>*) noexcept;
+
+  template <class T, class... Types>
+  constexpr add_pointer_t<T>
+  get_if(variant<Types...>*) noexcept;
+
+  template <class T, class... Types>
+  constexpr add_pointer_t<const T>
+  get_if(const variant<Types...>*) noexcept;
+
+  // 20.7.5, relational operators
+  template <class... Types>
+  constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
+
+  template <class... Types>
+  constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
+
+  template <class... Types>
+  constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
+
+  template <class... Types>
+  constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
+
+  template <class... Types>
+  constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
+
+  template <class... Types>
+  constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
+
+  // 20.7.6, visitation
+  template <class Visitor, class... Variants>
+  constexpr see below visit(Visitor&&, Variants&&...);
+
+  // 20.7.7, class monostate
+  struct monostate;
+
+  // 20.7.8, monostate relational operators
+  constexpr bool operator<(monostate, monostate) noexcept;
+  constexpr bool operator>(monostate, monostate) noexcept;
+  constexpr bool operator<=(monostate, monostate) noexcept;
+  constexpr bool operator>=(monostate, monostate) noexcept;
+  constexpr bool operator==(monostate, monostate) noexcept;
+  constexpr bool operator!=(monostate, monostate) noexcept;
+
+  // 20.7.9, specialized algorithms
+  template <class... Types>
+  void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
+
+  // 20.7.10, class bad_variant_access
+  class bad_variant_access;
+
+  // 20.7.11, hash support
+  template <class T> struct hash;
+  template <class... Types> struct hash<variant<Types...>>;
+  template <> struct hash<monostate>;
+
+} // namespace std
+
+*/
+
+#include <__config>
+#include <__tuple>
+#include <array>
+#include <exception>
+#include <functional>
+#include <initializer_list>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+namespace std { // explicitly not using versioning namespace
+
+class _LIBCPP_EXCEPTION_ABI bad_variant_access : public exception {
+public:
+  _LIBCPP_FUNC_VIS virtual const char* what() const noexcept;
+};
+
+} // namespace std
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 14
+
+template <class... _Types>
+class _LIBCPP_TYPE_VIS_ONLY variant;
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size;
+
+template <class _Tp>
+constexpr size_t variant_size_v = variant_size<_Tp>::value;
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<const _Tp> : variant_size<_Tp> {};
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<volatile _Tp> : variant_size<_Tp> {};
+
+template <class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<const volatile _Tp>
+    : variant_size<_Tp> {};
+
+template <class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY variant_size<variant<_Types...>>
+    : integral_constant<size_t, sizeof...(_Types)> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative;
+
+template <size_t _Ip, class _Tp>
+using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, const _Tp>
+    : add_const<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, volatile _Tp>
+    : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, const volatile _Tp>
+    : add_cv<variant_alternative_t<_Ip, _Tp>> {};
+
+template <size_t _Ip, class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY variant_alternative<_Ip, variant<_Types...>> {
+  static_assert(_Ip < sizeof...(_Types));
+  using type = __type_pack_element<_Ip, _Types...>;
+};
+
+constexpr size_t variant_npos = static_cast<size_t>(-1);
+constexpr unsigned int __variant_npos = static_cast<unsigned int>(-1);
+
+namespace __find_detail {
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr size_t __find_index() {
+  constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
+  size_t __result = __not_found;
+  for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
+    if (__matches[__i]) {
+      if (__result != __not_found) {
+        return __ambiguous;
+      }
+      __result = __i;
+    }
+  }
+  return __result;
+}
+
+template <size_t _Index>
+struct __find_unambiguous_index_sfinae_impl
+    : integral_constant<size_t, _Index> {};
+
+template <>
+struct __find_unambiguous_index_sfinae_impl<__not_found> {};
+
+template <>
+struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};
+
+template <class _Tp, class... _Types>
+struct __find_unambiguous_index_sfinae
+    : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
+
+} // namespace __find_detail
+
+namespace __variant_detail {
+
+struct __valueless_t {};
+
+enum class _Trait { _TriviallyAvailable, _Available, _Unavailable };
+
+template <typename _Tp,
+          template <typename> class _IsTriviallyAvailable,
+          template <typename> class _IsAvailable>
+constexpr _Trait __trait =
+    _IsTriviallyAvailable<_Tp>::value
+        ? _Trait::_TriviallyAvailable
+        : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
+  _Trait __result = _Trait::_TriviallyAvailable;
+  for (_Trait __t : __traits) {
+    if (static_cast<int>(__t) > static_cast<int>(__result)) {
+      __result = __t;
+    }
+  }
+  return __result;
+}
+
+template <typename... _Types>
+struct __traits {
+  static constexpr _Trait __copy_constructible_trait =
+      __common_trait({__trait<_Types,
+                              is_trivially_copy_constructible,
+                              is_copy_constructible>...});
+
+  static constexpr _Trait __move_constructible_trait =
+      __common_trait({__trait<_Types,
+                              is_trivially_move_constructible,
+                              is_move_constructible>...});
+
+  static constexpr _Trait __copy_assignable_trait = __common_trait(
+      {__copy_constructible_trait,
+       __move_constructible_trait,
+       __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});
+
+  static constexpr _Trait __move_assignable_trait = __common_trait(
+      {__move_constructible_trait,
+       __trait<_Types, is_trivially_move_assignable, is_move_assignable>...});
+
+  static constexpr _Trait __destructible_trait = __common_trait(
+      {__trait<_Types, is_trivially_destructible, is_destructible>...});
+};
+
+namespace __access {
+
+struct __union {
+  template <class _Vp>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
+    return _VSTD::forward<_Vp>(__v).__head;
+  }
+
+  template <class _Vp, size_t _Ip>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
+    return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
+  }
+};
+
+struct __base {
+  template <size_t _Ip, class _Vp>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
+                              in_place_index<_Ip>);
+  }
+};
+
+struct __variant {
+  template <size_t _Ip, class _Vp>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
+  }
+};
+
+} // namespace __access
+
+namespace __visitation {
+
+struct __base {
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto)
+  __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
+    constexpr auto __fdiagonal =
+        __make_fdiagonal<_Visitor&&,
+                         decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
+    return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
+                                _VSTD::forward<_Vs>(__vs).__as_base()...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
+                                              _Vs&&... __vs) {
+    constexpr auto __fmatrix =
+        __make_fmatrix<_Visitor&&,
+                       decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
+    const size_t __indices[] = {__vs.index()...};
+    return __at(__fmatrix, __indices)(_VSTD::forward<_Visitor>(__visitor),
+                                      _VSTD::forward<_Vs>(__vs).__as_base()...);
+  }
+
+private:
+  template <class _Tp>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr const _Tp& __at_impl(const _Tp& __elem, const size_t*) {
+    return __elem;
+  }
+
+  template <class _Tp, size_t _Np>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __at_impl(const array<_Tp, _Np>& __elems,
+                                    const size_t* __index) {
+    return __at_impl(__elems[*__index], __index + 1);
+  }
+
+  template <class _Tp, size_t _Np, size_t _Ip>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto&& __at(const array<_Tp, _Np>& __elems,
+                               const size_t (&__indices)[_Ip]) {
+    return __at_impl(__elems, begin(__indices));
+  }
+
+  template <class _Fp, class... _Fs>
+  static constexpr void __std_visit_visitor_return_type_check() {
+    static_assert(
+        __all<is_same_v<_Fp, _Fs>...>::value,
+        "`std::visit` requires the visitor to have a single return type.");
+  }
+
+  template <class... _Fs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_farray(_Fs&&... __fs) {
+    __std_visit_visitor_return_type_check<decay_t<_Fs>...>();
+    using __result = array<common_type_t<decay_t<_Fs>...>, sizeof...(_Fs)>;
+    return __result{_VSTD::forward<_Fs>(__fs)...};
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_dispatch(index_sequence<_Is...>) {
+    struct __dispatcher {
+      static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
+        return __invoke_constexpr(
+            static_cast<_Fp>(__f),
+            __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
+      }
+    };
+    return _VSTD::addressof(__dispatcher::__dispatch);
+  }
+
+  template <size_t _Ip, class _Fp, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fdiagonal_impl() {
+    return __make_dispatch<_Fp, _Vs...>(
+        index_sequence<(__identity<_Vs>{}, _Ip)...>{});
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
+    return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
+  }
+
+  template <class _Fp, class _Vp, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fdiagonal() {
+    constexpr size_t _Np = decay_t<_Vp>::__size();
+    static_assert(__all<(_Np == decay_t<_Vs>::__size())...>::value);
+    return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
+    return __make_dispatch<_Fp, _Vs...>(__is);
+  }
+
+  template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
+                                            index_sequence<_Js...>,
+                                            _Ls... __ls) {
+    return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
+        index_sequence<_Is..., _Js>{}, __ls...)...);
+  }
+
+  template <class _Fp, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_fmatrix() {
+    return __make_fmatrix_impl<_Fp, _Vs...>(
+        index_sequence<>{}, make_index_sequence<decay_t<_Vs>::__size()>{}...);
+  }
+};
+
+struct __variant {
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto)
+  __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
+    return __base::__visit_alt_at(__index,
+                                  _VSTD::forward<_Visitor>(__visitor),
+                                  _VSTD::forward<_Vs>(__vs).__impl...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
+                                              _Vs&&... __vs) {
+    return __base::__visit_alt(_VSTD::forward<_Visitor>(__visitor),
+                               _VSTD::forward<_Vs>(__vs).__impl...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto)
+  __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
+    return __visit_alt_at(
+        __index,
+        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
+        _VSTD::forward<_Vs>(__vs)...);
+  }
+
+  template <class _Visitor, class... _Vs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
+                                                _Vs&&... __vs) {
+    return __visit_alt(
+        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
+        _VSTD::forward<_Vs>(__vs)...);
+  }
+
+private:
+  template <class _Visitor, class... _Values>
+  static constexpr void __std_visit_exhaustive_visitor_check() {
+    static_assert(is_callable_v<_Visitor(_Values...)>,
+                  "`std::visit` requires the visitor to be exhaustive.");
+  }
+
+  template <class _Visitor>
+  struct __value_visitor {
+    template <class... _Alts>
+    inline _LIBCPP_INLINE_VISIBILITY
+    constexpr decltype(auto) operator()(_Alts&&... __alts) const {
+      __std_visit_exhaustive_visitor_check<
+          _Visitor,
+          decltype(_VSTD::forward<_Alts>(__alts).__value)...>();
+      return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
+                                _VSTD::forward<_Alts>(__alts).__value...);
+    }
+    _Visitor&& __visitor;
+  };
+
+  template <class _Visitor>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
+    return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
+  }
+};
+
+} // namespace __visitation
+
+template <size_t _Index, class _Tp>
+struct _LIBCPP_TYPE_VIS_ONLY __alt {
+  using __value_type = _Tp;
+
+  template <class... _Args>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr __alt(in_place_t, _Args&&... __args)
+      : __value(_VSTD::forward<_Args>(__args)...) {}
+
+  __value_type __value;
+};
+
+template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
+union _LIBCPP_TYPE_VIS_ONLY __union;
+
+template <_Trait _DestructibleTrait, size_t _Index>
+union _LIBCPP_TYPE_VIS_ONLY __union<_DestructibleTrait, _Index> {};
+
+#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor)                  \
+  template <size_t _Index, class _Tp, class... _Types>                         \
+  union _LIBCPP_TYPE_VIS_ONLY __union<destructible_trait,                      \
+                                      _Index,                                  \
+                                      _Tp,                                     \
+                                      _Types...> {                             \
+  public:                                                                      \
+    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    explicit constexpr __union(__valueless_t) noexcept : __dummy{} {}          \
+                                                                               \
+    template <class... _Args>                                                  \
+    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    explicit constexpr __union(in_place_index_t<0>, _Args&&... __args)         \
+        : __head(in_place, _VSTD::forward<_Args>(__args)...) {}                \
+                                                                               \
+    template <size_t _Ip, class... _Args>                                      \
+    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args)       \
+        : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
+                                                                               \
+    __union(const __union&) = default;                                         \
+    __union(__union&&) = default;                                              \
+                                                                               \
+    destructor                                                                 \
+                                                                               \
+    __union& operator=(const __union&) = default;                              \
+    __union& operator=(__union&&) = default;                                   \
+                                                                               \
+  private:                                                                     \
+    char __dummy;                                                              \
+    __alt<_Index, _Tp> __head;                                                 \
+    __union<destructible_trait, _Index + 1, _Types...> __tail;                 \
+                                                                               \
+    friend struct __access::__union;                                           \
+  }
+
+_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
+_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {});
+_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
+
+#undef _LIBCPP_VARIANT_UNION
+
+template <_Trait _DestructibleTrait, class... _Types>
+class _LIBCPP_TYPE_VIS_ONLY __base {
+public:
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr __base(__valueless_t tag) noexcept
+      : __index(__variant_npos), __data(tag) {}
+
+  template <size_t _Ip, class... _Args>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
+      : __index(_Ip),
+        __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr bool valueless_by_exception() const noexcept {
+    return index() == variant_npos;
+  }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr size_t index() const noexcept {
+    return __index == __variant_npos ? variant_npos : __index;
+  }
+
+protected:
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr auto&& __as_base() & { return *this; }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr auto&& __as_base() && { return _VSTD::move(*this); }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr auto&& __as_base() const & { return *this; }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr auto&& __as_base() const && { return _VSTD::move(*this); }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  static constexpr size_t __size() { return sizeof...(_Types); }
+
+  __union<_DestructibleTrait, 0, _Types...> __data;
+  unsigned int __index;
+
+  friend struct __access::__base;
+  friend struct __visitation::__base;
+};
+
+template <class _Traits, _Trait = _Traits::__destructible_trait>
+class _LIBCPP_TYPE_VIS_ONLY __destructor;
+
+#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy)    \
+  template <class... _Types>                                                   \
+  class _LIBCPP_TYPE_VIS_ONLY __destructor<__traits<_Types...>,                \
+                                           destructible_trait>                 \
+      : public __base<destructible_trait, _Types...> {                         \
+    using __base_type = __base<destructible_trait, _Types...>;                 \
+                                                                               \
+  public:                                                                      \
+    using __base_type::__base_type;                                            \
+    using __base_type::operator=;                                              \
+                                                                               \
+    __destructor(const __destructor&) = default;                               \
+    __destructor(__destructor&&) = default;                                    \
+    destructor                                                                 \
+    __destructor& operator=(const __destructor&) = default;                    \
+    __destructor& operator=(__destructor&&) = default;                         \
+                                                                               \
+  protected:                                                                   \
+    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    destroy                                                                    \
+  }
+
+_LIBCPP_VARIANT_DESTRUCTOR(
+    _Trait::_TriviallyAvailable,
+    ~__destructor() = default;,
+    void __destroy() noexcept { this->__index = __variant_npos; });
+
+_LIBCPP_VARIANT_DESTRUCTOR(
+    _Trait::_Available,
+    ~__destructor() { __destroy(); },
+    void __destroy() noexcept {
+      if (!this->valueless_by_exception()) {
+        __visitation::__base::__visit_alt(
+            [](auto& __alt) noexcept {
+              using __alt_type = decay_t<decltype(__alt)>;
+              __alt.~__alt_type();
+            },
+            *this);
+      }
+      this->__index = __variant_npos;
+    });
+
+_LIBCPP_VARIANT_DESTRUCTOR(
+    _Trait::_Unavailable,
+    ~__destructor() = delete;,
+    void __destroy() noexcept = delete;);
+
+#undef _LIBCPP_VARIANT_DESTRUCTOR
+
+template <class _Traits>
+class _LIBCPP_TYPE_VIS_ONLY __constructor : public __destructor<_Traits> {
+  using __base_type = __destructor<_Traits>;
+
+public:
+  using __base_type::__base_type;
+  using __base_type::operator=;
+
+protected:
+  template <size_t _Ip, class _Tp, class... _Args>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static void __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
+    ::new (_VSTD::addressof(__a))
+        __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
+  }
+
+  template <class _Rhs>
+  inline _LIBCPP_INLINE_VISIBILITY
+  static void __generic_construct(__constructor& __lhs, _Rhs&& __rhs) {
+    __lhs.__destroy();
+    if (!__rhs.valueless_by_exception()) {
+      __visitation::__base::__visit_alt_at(
+          __rhs.index(),
+          [](auto& __lhs_alt, auto&& __rhs_alt) {
+            __construct_alt(
+                __lhs_alt,
+                _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
+          },
+          __lhs, _VSTD::forward<_Rhs>(__rhs));
+      __lhs.__index = __rhs.index();
+    }
+  }
+};
+
+template <class _Traits, _Trait = _Traits::__move_constructible_trait>
+class _LIBCPP_TYPE_VIS_ONLY __move_constructor;
+
+#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait,             \
+                                         move_constructor)                     \
+  template <class... _Types>                                                   \
+  class _LIBCPP_TYPE_VIS_ONLY __move_constructor<__traits<_Types...>,          \
+                                                 move_constructible_trait>     \
+      : public __constructor<__traits<_Types...>> {                            \
+    using __base_type = __constructor<__traits<_Types...>>;                    \
+                                                                               \
+  public:                                                                      \
+    using __base_type::__base_type;                                            \
+    using __base_type::operator=;                                              \
+                                                                               \
+    __move_constructor(const __move_constructor&) = default;                   \
+    move_constructor                                                           \
+    ~__move_constructor() = default;                                           \
+    __move_constructor& operator=(const __move_constructor&) = default;        \
+    __move_constructor& operator=(__move_constructor&&) = default;             \
+  }
+
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
+    _Trait::_TriviallyAvailable,
+    __move_constructor(__move_constructor&& __that) = default;);
+
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
+    _Trait::_Available,
+    __move_constructor(__move_constructor&& __that) noexcept(
+        __all<is_nothrow_move_constructible_v<_Types>...>::value)
+        : __move_constructor(__valueless_t{}) {
+      this->__generic_construct(*this, _VSTD::move(__that));
+    });
+
+_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
+    _Trait::_Unavailable,
+    __move_constructor(__move_constructor&&) = delete;);
+
+#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
+
+template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
+class _LIBCPP_TYPE_VIS_ONLY __copy_constructor;
+
+#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait,             \
+                                         copy_constructor)                     \
+  template <class... _Types>                                                   \
+  class _LIBCPP_TYPE_VIS_ONLY __copy_constructor<__traits<_Types...>,          \
+                                                 copy_constructible_trait>     \
+      : public __move_constructor<__traits<_Types...>> {                       \
+    using __base_type = __move_constructor<__traits<_Types...>>;               \
+                                                                               \
+  public:                                                                      \
+    using __base_type::__base_type;                                            \
+    using __base_type::operator=;                                              \
+                                                                               \
+    copy_constructor                                                           \
+    __copy_constructor(__copy_constructor&&) = default;                        \
+    ~__copy_constructor() = default;                                           \
+    __copy_constructor& operator=(const __copy_constructor&) = default;        \
+    __copy_constructor& operator=(__copy_constructor&&) = default;             \
+  }
+
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
+    _Trait::_TriviallyAvailable,
+    __copy_constructor(const __copy_constructor& __that) = default;);
+
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
+    _Trait::_Available,
+    __copy_constructor(const __copy_constructor& __that)
+        : __copy_constructor(__valueless_t{}) {
+      this->__generic_construct(*this, __that);
+    });
+
+_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
+    _Trait::_Unavailable,
+    __copy_constructor(const __copy_constructor&) = delete;);
+
+#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
+
+template <class _Traits>
+class _LIBCPP_TYPE_VIS_ONLY __assignment : public __copy_constructor<_Traits> {
+  using __base_type = __copy_constructor<_Traits>;
+
+public:
+  using __base_type::__base_type;
+  using __base_type::operator=;
+
+  template <size_t _Ip, class... _Args>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void __emplace(_Args&&... __args) {
+    this->__destroy();
+    this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
+                          _VSTD::forward<_Args>(__args)...);
+    this->__index = _Ip;
+  }
+
+protected:
+  template <bool _CopyAssign, size_t _Ip, class _Tp, class _Arg>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void __assign_alt(__alt<_Ip, _Tp>& __a,
+                    _Arg&& __arg,
+                    bool_constant<_CopyAssign> __tag) {
+    if (this->index() == _Ip) {
+      __a.__value = _VSTD::forward<_Arg>(__arg);
+    } else {
+      struct {
+        void operator()(true_type) const {
+          __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
+        }
+        void operator()(false_type) const {
+          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
+        }
+        __assignment* __this;
+        _Arg&& __arg;
+      } __impl{this, _VSTD::forward<_Arg>(__arg)};
+      __impl(__tag);
+    }
+  }
+
+  template <class _That>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void __generic_assign(_That&& __that) {
+    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
+      // do nothing.
+    } else if (__that.valueless_by_exception()) {
+      this->__destroy();
+    } else {
+      __visitation::__base::__visit_alt_at(
+          __that.index(),
+          [this](auto& __this_alt, auto&& __that_alt) {
+            this->__assign_alt(
+                __this_alt,
+                _VSTD::forward<decltype(__that_alt)>(__that_alt).__value,
+                is_lvalue_reference<_That>{});
+          },
+          *this, _VSTD::forward<_That>(__that));
+    }
+  }
+};
+
+template <class _Traits, _Trait = _Traits::__move_assignable_trait>
+class _LIBCPP_TYPE_VIS_ONLY __move_assignment;
+
+#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait,                 \
+                                        move_assignment)                       \
+  template <class... _Types>                                                   \
+  class _LIBCPP_TYPE_VIS_ONLY __move_assignment<__traits<_Types...>,           \
+                                                move_assignable_trait>         \
+      : public __assignment<__traits<_Types...>> {                             \
+    using __base_type = __assignment<__traits<_Types...>>;                     \
+                                                                               \
+  public:                                                                      \
+    using __base_type::__base_type;                                            \
+    using __base_type::operator=;                                              \
+                                                                               \
+    __move_assignment(const __move_assignment&) = default;                     \
+    __move_assignment(__move_assignment&&) = default;                          \
+    ~__move_assignment() = default;                                            \
+    __move_assignment& operator=(const __move_assignment&) = default;          \
+    move_assignment                                                            \
+  }
+
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
+    _Trait::_TriviallyAvailable,
+    __move_assignment& operator=(__move_assignment&& __that) = default;);
+
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
+    _Trait::_Available,
+    __move_assignment& operator=(__move_assignment&& __that) noexcept(
+        __all<(is_nothrow_move_constructible_v<_Types> &&
+               is_nothrow_move_assignable_v<_Types>)...>::value) {
+      this->__generic_assign(_VSTD::move(__that));
+      return *this;
+    });
+
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
+    _Trait::_Unavailable,
+    __move_assignment& operator=(__move_assignment&&) = delete;);
+
+#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
+
+template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
+class _LIBCPP_TYPE_VIS_ONLY __copy_assignment;
+
+#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait,                 \
+                                        copy_assignment)                       \
+  template <class... _Types>                                                   \
+  class _LIBCPP_TYPE_VIS_ONLY __copy_assignment<__traits<_Types...>,           \
+                                                copy_assignable_trait>         \
+      : public __move_assignment<__traits<_Types...>> {                        \
+    using __base_type = __move_assignment<__traits<_Types...>>;                \
+                                                                               \
+  public:                                                                      \
+    using __base_type::__base_type;                                            \
+    using __base_type::operator=;                                              \
+                                                                               \
+    __copy_assignment(const __copy_assignment&) = default;                     \
+    __copy_assignment(__copy_assignment&&) = default;                          \
+    ~__copy_assignment() = default;                                            \
+    copy_assignment                                                            \
+    __copy_assignment& operator=(__copy_assignment&&) = default;               \
+  }
+
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(
+    _Trait::_TriviallyAvailable,
+    __copy_assignment& operator=(const __copy_assignment& __that) = default;);
+
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(
+    _Trait::_Available,
+    __copy_assignment& operator=(const __copy_assignment& __that) {
+      this->__generic_assign(__that);
+      return *this;
+    });
+
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(
+    _Trait::_Unavailable,
+    __copy_assignment& operator=(const __copy_assignment&) = delete;);
+
+#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
+
+template <class... _Types>
+class _LIBCPP_TYPE_VIS_ONLY __impl
+    : public __copy_assignment<__traits<_Types...>> {
+  using __base_type = __copy_assignment<__traits<_Types...>>;
+
+public:
+  using __base_type::__base_type;
+  using __base_type::operator=;
+
+  template <size_t _Ip, class _Arg>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void __assign(_Arg&& __arg) {
+    this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
+                       _VSTD::forward<_Arg>(__arg),
+                       false_type{});
+  }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  void __swap(__impl& __that)  {
+    if (this->valueless_by_exception() && __that.valueless_by_exception()) {
+      // do nothing.
+    } else if (this->index() == __that.index()) {
+      __visitation::__base::__visit_alt_at(
+          this->index(),
+          [](auto& __this_alt, auto& __that_alt) {
+            using _VSTD::swap;
+            swap(__this_alt.__value, __that_alt.__value);
+          },
+          *this,
+          __that);
+    } else {
+      __impl* __lhs = this;
+      __impl* __rhs = _VSTD::addressof(__that);
+      if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
+        _VSTD::swap(__lhs, __rhs);
+      }
+      __impl __tmp(_VSTD::move(*__rhs));
+#ifndef _LIBCPP_NO_EXCEPTIONS
+      // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
+      // and `__tmp` is nothrow move constructible then we move `__tmp` back
+      // into `__rhs` and provide the strong exception safety guarentee.
+      try {
+        this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
+      } catch (...) {
+        if (__tmp.__move_nothrow()) {
+          this->__generic_construct(*__rhs, _VSTD::move(__tmp));
+        }
+        throw;
+      }
+#else
+      this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
+#endif
+      this->__generic_construct(*__lhs, _VSTD::move(__tmp));
+    }
+  }
+
+private:
+  inline _LIBCPP_INLINE_VISIBILITY
+  bool __move_nothrow() const {
+    constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
+    return this->valueless_by_exception() || __results[this->index()];
+  }
+};
+
+template <class... _Types>
+struct __overload;
+
+template <>
+struct __overload<> { void operator()() const; };
+
+template <class _Tp, class... _Types>
+struct __overload<_Tp, _Types...> : __overload<_Types...> {
+  using __overload<_Types...>::operator();
+  __identity<_Tp> operator()(_Tp) const;
+};
+
+template <class _Tp, class... _Types>
+using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;
+
+} // __variant_detail
+
+template <class... _Types>
+class _LIBCPP_TYPE_VIS_ONLY variant
+    : private __sfinae_ctor_base<
+          __all<is_copy_constructible_v<_Types>...>::value,
+          __all<is_move_constructible_v<_Types>...>::value>,
+      private __sfinae_assign_base<
+          __all<(is_copy_constructible_v<_Types> &&
+                 is_move_constructible_v<_Types> &&
+                 is_copy_assignable_v<_Types>)...>::value,
+          __all<(is_move_constructible_v<_Types> &&
+                 is_move_assignable_v<_Types>)...>::value> {
+  static_assert(0 < sizeof...(_Types),
+                "variant must consist of at least one alternative.");
+
+  static_assert(__all<!is_array_v<_Types>...>::value,
+                "variant can not have an array type as an alternative.");
+
+  static_assert(__all<!is_reference_v<_Types>...>::value,
+                "variant can not have a reference type as an alternative.");
+
+  static_assert(__all<!is_void_v<_Types>...>::value,
+                "variant can not have a void type as an alternative.");
+
+  using __first_type = variant_alternative_t<0, variant>;
+
+public:
+  template <bool _Dummy = true,
+            enable_if_t<__dependent_type<is_default_constructible<__first_type>,
+                                         _Dummy>::value,
+                        int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  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,
+      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)) {}
+
+  template <size_t _Ip, class... _Args,
+            enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+            class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+            enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr variant(
+      in_place_index_t<_Ip>,
+      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
+      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  template <
+      size_t _Ip,
+      class _Up,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr variant(
+      in_place_index_t<_Ip>,
+      initializer_list<_Up> __il,
+      _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
+      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+
+  template <
+      class _Tp,
+      class... _Args,
+      size_t _Ip =
+          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+
+  template <
+      class _Tp,
+      class _Up,
+      class... _Args,
+      size_t _Ip =
+          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  explicit constexpr variant(
+      in_place_type_t<_Tp>,
+      initializer_list<_Up> __il,
+      _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
+      : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+
+  ~variant() = default;
+
+  variant& operator=(const variant&) = default;
+  variant& operator=(variant&&) = default;
+
+  template <
+      class _Arg,
+      enable_if_t<!is_same_v<decay_t<_Arg>, variant>, 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_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
+                  int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  variant& operator=(_Arg&& __arg) noexcept(
+      is_nothrow_assignable_v<_Tp&, _Arg> &&
+      is_nothrow_constructible_v<_Tp, _Arg>) {
+    __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
+    return *this;
+  }
+
+  template <
+      size_t _Ip,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void emplace(_Args&&... __args) {
+    __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      size_t _Ip,
+      class _Up,
+      class... _Args,
+      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      class _Tp,
+      class... _Args,
+      size_t _Ip =
+          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void emplace(_Args&&... __args) {
+    __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  }
+
+  template <
+      class _Tp,
+      class _Up,
+      class... _Args,
+      size_t _Ip =
+          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
+                  int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr bool valueless_by_exception() const noexcept {
+    return __impl.valueless_by_exception();
+  }
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  constexpr size_t index() const noexcept { return __impl.index(); }
+
+  template <
+      bool _Dummy = true,
+      enable_if_t<
+          __all<(
+              __dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
+              __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
+          int> = 0>
+  inline _LIBCPP_INLINE_VISIBILITY
+  void swap(variant& __that) noexcept(
+      __all<(is_nothrow_move_constructible_v<_Types> &&
+             is_nothrow_swappable_v<_Types>)...>::value) {
+    __impl.__swap(__that.__impl);
+  }
+
+private:
+  __variant_detail::__impl<_Types...> __impl;
+
+  friend struct __variant_detail::__access::__variant;
+  friend struct __variant_detail::__visitation::__variant;
+};
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
+  return __v.index() == _Ip;
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
+  return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <size_t _Ip, class _Vp>
+inline _LIBCPP_INLINE_VISIBILITY
+static constexpr auto&& __generic_get(_Vp&& __v) {
+  using __variant_detail::__access::__variant;
+  if (!__holds_alternative<_Ip>(__v)) {
+    throw bad_variant_access{};
+  }
+  return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
+    variant<_Types...>& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
+    variant<_Types...>&& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(_VSTD::move(__v));
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
+    const variant<_Types...>& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
+    const variant<_Types...>&& __v) {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get<_Ip>(_VSTD::move(__v));
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Tp& get(variant<_Types...>& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Tp&& get(variant<_Types...>&& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
+      _VSTD::move(__v));
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr const _Tp& get(const variant<_Types...>& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr const _Tp&& get(const variant<_Types...>&& __v) {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
+      _VSTD::move(__v));
+}
+
+template <size_t _Ip, class _Vp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr auto* __generic_get_if(_Vp* __v) noexcept {
+  using __variant_detail::__access::__variant;
+  return __v && __holds_alternative<_Ip>(*__v)
+             ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
+             : nullptr;
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(variant<_Types...>* __v) noexcept {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get_if<_Ip>(__v);
+}
+
+template <size_t _Ip, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
+get_if(const variant<_Types...>* __v) noexcept {
+  static_assert(_Ip < sizeof...(_Types));
+  static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
+  return __generic_get_if<_Ip>(__v);
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<_Tp>
+get_if(variant<_Types...>* __v) noexcept {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class _Tp, class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<const _Tp>
+get_if(const variant<_Types...>* __v) noexcept {
+  static_assert(!is_void_v<_Tp>);
+  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__lhs.index() != __rhs.index()) return false;
+  if (__lhs.valueless_by_exception()) return true;
+  return __variant::__visit_value_at(__lhs.index(), equal_to<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__lhs.index() != __rhs.index()) return true;
+  if (__lhs.valueless_by_exception()) return false;
+  return __variant::__visit_value_at(
+      __lhs.index(), not_equal_to<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<(const variant<_Types...>& __lhs,
+                         const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__rhs.valueless_by_exception()) return false;
+  if (__lhs.valueless_by_exception()) return true;
+  if (__lhs.index() < __rhs.index()) return true;
+  if (__lhs.index() > __rhs.index()) return false;
+  return __variant::__visit_value_at(__lhs.index(), less<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>(const variant<_Types...>& __lhs,
+                         const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__lhs.valueless_by_exception()) return false;
+  if (__rhs.valueless_by_exception()) return true;
+  if (__lhs.index() > __rhs.index()) return true;
+  if (__lhs.index() < __rhs.index()) return false;
+  return __variant::__visit_value_at(__lhs.index(), greater<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__lhs.valueless_by_exception()) return true;
+  if (__rhs.valueless_by_exception()) return false;
+  if (__lhs.index() < __rhs.index()) return true;
+  if (__lhs.index() > __rhs.index()) return false;
+  return __variant::__visit_value_at(
+      __lhs.index(), less_equal<>{}, __lhs, __rhs);
+}
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(const variant<_Types...>& __lhs,
+                          const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  if (__rhs.valueless_by_exception()) return true;
+  if (__lhs.valueless_by_exception()) return false;
+  if (__lhs.index() > __rhs.index()) return true;
+  if (__lhs.index() < __rhs.index()) return false;
+  return __variant::__visit_value_at(
+      __lhs.index(), greater_equal<>{}, __lhs, __rhs);
+}
+
+template <class _Visitor, class... _Vs>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
+  using __variant_detail::__visitation::__variant;
+  bool __results[] = {__vs.valueless_by_exception()...};
+  for (bool __result : __results) {
+    if (__result) {
+      throw bad_variant_access{};
+    }
+  }
+  return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
+                                  _VSTD::forward<_Vs>(__vs)...);
+}
+
+struct _LIBCPP_TYPE_VIS_ONLY monostate {};
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<(monostate, monostate) noexcept { return false; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>(monostate, monostate) noexcept { return false; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(monostate, monostate) noexcept { return true; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+
+template <class... _Types>
+inline _LIBCPP_INLINE_VISIBILITY
+auto swap(variant<_Types...>& __lhs,
+          variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
+    -> decltype(__lhs.swap(__rhs)) {
+  __lhs.swap(__rhs);
+}
+
+template <class... _Types>
+struct _LIBCPP_TYPE_VIS_ONLY hash<variant<_Types...>> {
+  using argument_type = variant<_Types...>;
+  using result_type = size_t;
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  result_type operator()(const argument_type& __v) const {
+    using __variant_detail::__visitation::__variant;
+    return __v.valueless_by_exception()
+               ? __v.index()
+               : __variant::__visit_alt(
+                     [](const auto& __alt) {
+                       using __alt_type = decay_t<decltype(__alt)>;
+                       using __value_type = typename __alt_type::__value_type;
+                       return hash<__value_type>{}(__alt.__value);
+                     },
+                     __v);
+  }
+};
+
+template <>
+struct _LIBCPP_TYPE_VIS_ONLY hash<monostate> {
+  using argument_type = monostate;
+  using result_type = size_t;
+
+  inline _LIBCPP_INLINE_VISIBILITY
+  result_type operator()(const argument_type&) const { return 0; }
+};
+
+#endif  // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif  // _LIBCPP_VARIANT

src/variant.cpp

+//===------------------------ variant.cpp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "variant"
+
+namespace std {
+
+const char* bad_variant_access::what() const noexcept {
+  return "bad_variant_access";
+}
+
+}  // namespace std

test/libcxx/utilities/variant/variant.variant/variant.assign/copy.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <class ...Types> class variant;
+
+// variant& operator=(variant const&);
+
+#include <type_traits>
+#include <variant>
+
+#include "test_macros.h"
+
+struct NTCopyAssign {
+  constexpr NTCopyAssign(int v) : value(v) {}
+  NTCopyAssign(const NTCopyAssign &) = default;
+  NTCopyAssign(NTCopyAssign &&) = default;
+  NTCopyAssign &operator=(const NTCopyAssign &that) {
+    value = that.value;
+    return *this;
+  };
+  NTCopyAssign &operator=(NTCopyAssign &&) = delete;
+  int value;
+};
+
+static_assert(!std::is_trivially_copy_assignable<NTCopyAssign>::value, "");
+static_assert(std::is_copy_assignable<NTCopyAssign>::value, "");
+
+struct TCopyAssign {
+  constexpr TCopyAssign(int v) : value(v) {}
+  TCopyAssign(const TCopyAssign &) = default;
+  TCopyAssign(TCopyAssign &&) = default;
+  TCopyAssign &operator=(const TCopyAssign &) = default;
+  TCopyAssign &operator=(TCopyAssign &&) = delete;
+  int value;
+};
+
+static_assert(std::is_trivially_copy_assignable<TCopyAssign>::value, "");
+
+struct TCopyAssignNTMoveAssign {
+  constexpr TCopyAssignNTMoveAssign(int v) : value(v) {}
+  TCopyAssignNTMoveAssign(const TCopyAssignNTMoveAssign &) = default;
+  TCopyAssignNTMoveAssign(TCopyAssignNTMoveAssign &&) = default;
+  TCopyAssignNTMoveAssign &operator=(const TCopyAssignNTMoveAssign &) = default;
+  TCopyAssignNTMoveAssign &operator=(TCopyAssignNTMoveAssign &&that) {
+    value = that.value;
+    that.value = -1;
+    return *this;
+  }
+  int value;
+};
+
+static_assert(std::is_trivially_copy_assignable_v<TCopyAssignNTMoveAssign>);
+
+void test_copy_assignment_sfinae() {
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTCopyAssign>;
+    static_assert(!std::is_trivially_copy_assignable<V>::value, "");
+    static_assert(std::is_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyAssign>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyAssignNTMoveAssign>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+}
+
+template <typename T> struct Result { size_t index; T value; };
+
+void test_copy_assignment_same_index() {
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int>;
+        V v(43);
+        V v2(42);
+        v = v2;
+        return {v.index(), std::get<0>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0);
+    static_assert(result.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43l);
+        V v2(42l);
+        v = v2;
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42l);
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssign, unsigned>;
+        V v(std::in_place_type<TCopyAssign>, 43);
+        V v2(std::in_place_type<TCopyAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssignNTMoveAssign, unsigned>;
+        V v(std::in_place_type<TCopyAssignNTMoveAssign>, 43);
+        V v2(std::in_place_type<TCopyAssignNTMoveAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+}
+
+void test_copy_assignment_different_index() {
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43);
+        V v2(42l);
+        v = v2;
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42l);
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssign, unsigned>;
+        V v(std::in_place_type<unsigned>, 43);
+        V v2(std::in_place_type<TCopyAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+}
+
+int main() {
+  test_copy_assignment_same_index();
+  test_copy_assignment_different_index();
+  test_copy_assignment_sfinae();
+}

test/libcxx/utilities/variant/variant.variant/variant.assign/move.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <class ...Types> class variant;
+
+// variant& operator=(variant&&) noexcept(see below);
+
+#include <type_traits>
+#include <variant>
+
+#include "test_macros.h"
+
+struct NTMoveAssign {
+  constexpr NTMoveAssign(int v) : value(v) {}
+  NTMoveAssign(const NTMoveAssign &) = default;
+  NTMoveAssign(NTMoveAssign &&) = default;
+  NTMoveAssign &operator=(const NTMoveAssign &that) = default;
+  NTMoveAssign &operator=(NTMoveAssign &&that) {
+    value = that.value;
+    that.value = -1;
+    return *this;
+  };
+  int value;
+};
+
+static_assert(!std::is_trivially_move_assignable<NTMoveAssign>::value, "");
+static_assert(std::is_move_assignable<NTMoveAssign>::value, "");
+
+struct TMoveAssign {
+  constexpr TMoveAssign(int v) : value(v) {}
+  TMoveAssign(const TMoveAssign &) = delete;
+  TMoveAssign(TMoveAssign &&) = default;
+  TMoveAssign &operator=(const TMoveAssign &) = delete;
+  TMoveAssign &operator=(TMoveAssign &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_assignable<TMoveAssign>::value, "");
+
+struct TMoveAssignNTCopyAssign {
+  constexpr TMoveAssignNTCopyAssign(int v) : value(v) {}
+  TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign &) = default;
+  TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign &&) = default;
+  TMoveAssignNTCopyAssign &operator=(const TMoveAssignNTCopyAssign &that) {
+    value = that.value;
+    return *this;
+  }
+  TMoveAssignNTCopyAssign &operator=(TMoveAssignNTCopyAssign &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_assignable_v<TMoveAssignNTCopyAssign>);
+
+void test_move_assignment_sfinae() {
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTMoveAssign>;
+    static_assert(!std::is_trivially_move_assignable<V>::value, "");
+    static_assert(std::is_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveAssign>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveAssignNTCopyAssign>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+}
+
+template <typename T> struct Result { size_t index; T value; };
+
+void test_move_assignment_same_index() {
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int>;
+        V v(43);
+        V v2(42);
+        v = std::move(v2);
+        return {v.index(), std::get<0>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0);
+    static_assert(result.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43l);
+        V v2(42l);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42l);
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TMoveAssign, unsigned>;
+        V v(std::in_place_type<TMoveAssign>, 43);
+        V v2(std::in_place_type<TMoveAssign>, 42);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+}
+
+void test_move_assignment_different_index() {
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43);
+        V v2(42l);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42l);
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, TMoveAssign, unsigned>;
+        V v(std::in_place_type<unsigned>, 43);
+        V v2(std::in_place_type<TMoveAssign>, 42);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+}
+
+int main() {
+  test_move_assignment_same_index();
+  test_move_assignment_different_index();
+  test_move_assignment_sfinae();
+}

test/libcxx/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <class ...Types> class variant;
+
+// variant(variant const&);
+
+#include <type_traits>
+#include <variant>
+
+#include "test_macros.h"
+
+struct NTCopy {
+  constexpr NTCopy(int v) : value(v) {}
+  NTCopy(const NTCopy &that) : value(that.value) {}
+  NTCopy(NTCopy &&) = delete;
+  int value;
+};
+
+static_assert(!std::is_trivially_copy_constructible<NTCopy>::value, "");
+static_assert(std::is_copy_constructible<NTCopy>::value, "");
+
+struct TCopy {
+  constexpr TCopy(int v) : value(v) {}
+  TCopy(TCopy const &) = default;
+  TCopy(TCopy &&) = delete;
+  int value;
+};
+
+static_assert(std::is_trivially_copy_constructible<TCopy>::value, "");
+
+struct TCopyNTMove {
+  constexpr TCopyNTMove(int v) : value(v) {}
+  TCopyNTMove(const TCopyNTMove&) = default;
+  TCopyNTMove(TCopyNTMove&& that) : value(that.value) { that.value = -1; }
+  int value;
+};
+
+static_assert(std::is_trivially_copy_constructible<TCopyNTMove>::value, "");
+
+void test_copy_ctor_sfinae() {
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTCopy>;
+    static_assert(!std::is_trivially_copy_constructible<V>::value, "");
+    static_assert(std::is_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopy>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyNTMove>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
+}
+
+void test_copy_ctor_basic() {
+  {
+    constexpr std::variant<int> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0);
+    constexpr std::variant<int> v2 = v;
+    static_assert(v2.index() == 0);
+    static_assert(std::get<0>(v2) == 42);
+  }
+  {
+    constexpr std::variant<int, long> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1);
+    constexpr std::variant<int, long> v2 = v;
+    static_assert(v2.index() == 1);
+    static_assert(std::get<1>(v2) == 42);
+  }
+  {
+    constexpr std::variant<TCopy> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0);
+    constexpr std::variant<TCopy> v2(v);
+    static_assert(v2.index() == 0);
+    static_assert(std::get<0>(v2).value == 42);
+  }
+  {
+    constexpr std::variant<int, TCopy> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1);
+    constexpr std::variant<int, TCopy> v2(v);
+    static_assert(v2.index() == 1);
+    static_assert(std::get<1>(v2).value == 42);
+  }
+  {
+    constexpr std::variant<TCopyNTMove> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0);
+    constexpr std::variant<TCopyNTMove> v2(v);
+    static_assert(v2.index() == 0);
+    static_assert(std::get<0>(v2).value == 42);
+  }
+  {
+    constexpr std::variant<int, TCopyNTMove> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1);
+    constexpr std::variant<int, TCopyNTMove> v2(v);
+    static_assert(v2.index() == 1);
+    static_assert(std::get<1>(v2).value == 42);
+  }
+}
+
+int main() {
+  test_copy_ctor_basic();
+  test_copy_ctor_sfinae();
+}

test/libcxx/utilities/variant/variant.variant/variant.ctor/move.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <class ...Types> class variant;
+
+// variant(variant&&) noexcept(see below);
+
+#include <type_traits>
+#include <variant>
+
+#include "test_macros.h"
+
+struct NTMove {
+  constexpr NTMove(int v) : value(v) {}
+  NTMove(const NTMove &) = delete;
+  NTMove(NTMove &&that) : value(that.value) { that.value = -1; }
+  int value;
+};
+
+static_assert(!std::is_trivially_move_constructible<NTMove>::value, "");
+static_assert(std::is_move_constructible<NTMove>::value, "");
+
+struct TMove {
+  constexpr TMove(int v) : value(v) {}
+  TMove(const TMove &) = delete;
+  TMove(TMove &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_constructible<TMove>::value, "");
+
+struct TMoveNTCopy {
+  constexpr TMoveNTCopy(int v) : value(v) {}
+  TMoveNTCopy(const TMoveNTCopy& that) : value(that.value) {}
+  TMoveNTCopy(TMoveNTCopy&&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_constructible<TMoveNTCopy>::value, "");
+
+void test_move_ctor_sfinae() {
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTMove>;
+    static_assert(!std::is_trivially_move_constructible<V>::value, "");
+    static_assert(std::is_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMove>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveNTCopy>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
+}
+
+template <typename T>
+struct Result { size_t index; T value; };
+
+void test_move_ctor_basic() {
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        std::variant<int> v(std::in_place_index<0>, 42);
+        std::variant<int> v2 = std::move(v);
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0);
+    static_assert(result.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        std::variant<int, long> v(std::in_place_index<1>, 42);
+        std::variant<int, long> v2 = std::move(v);
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<TMove> operator()() const {
+        std::variant<TMove> v(std::in_place_index<0>, 42);
+        std::variant<TMove> v2(std::move(v));
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0);
+    static_assert(result.value.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<TMove> operator()() const {
+        std::variant<int, TMove> v(std::in_place_index<1>, 42);
+        std::variant<int, TMove> v2(std::move(v));
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<TMoveNTCopy> operator()() const {
+        std::variant<TMoveNTCopy> v(std::in_place_index<0>, 42);
+        std::variant<TMoveNTCopy> v2(std::move(v));
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0);
+    static_assert(result.value.value == 42);
+  }
+  {
+    struct {
+      constexpr Result<TMoveNTCopy> operator()() const {
+        std::variant<int, TMoveNTCopy> v(std::in_place_index<1>, 42);
+        std::variant<int, TMoveNTCopy> v2(std::move(v));
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1);
+    static_assert(result.value.value == 42);
+  }
+}
+
+int main() {
+  test_move_ctor_basic();
+  test_move_ctor_sfinae();
+}

test/libcxx/utilities/variant/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <variant>
+
+#include <variant>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}

test/std/utilities/variant/lit.local.cfg

-
-# FIXME: Libc++ does not yet implement variant but other STLs benefit from
-# having our tests in-tree. This must be removed when <variant> is added.
-if 'libc++' in config.available_features:
-  config.unsupported = True

test/std/utilities/variant/variant.hash/hash.pass.cpp

 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 namespace std {
 template <> struct hash<::MakeEmptyT> {
-  size_t operator()(::MakeEmptyT const &) const {
+  size_t operator()(const ::MakeEmptyT &) const {
     assert(false);
     return 0;
   }
 };
 }
 #endif
 
 void test_hash_variant() {
   {
     using V = std::variant<int, long, int>;
     using H = std::hash<V>;
     const V v(std::in_place_index<0>, 42);
     const V v_copy = v;
     V v2(std::in_place_index<0>, 100);
-    const V v3(std::in_place_index<2>, 42);
     const H h{};
     assert(h(v) == h(v));
     assert(h(v) != h(v2));
     assert(h(v) == h(v_copy));
     {
       ASSERT_SAME_TYPE(decltype(h(v)), std::size_t);
       static_assert(std::is_copy_constructible<H>::value, "");
     }

test/std/utilities/variant/variant.helpers/variant_alternative.pass.cpp

int main() {
     using V = std::variant<int, void *, const void *, long double>;
     test<V, 0, int>();
     test<V, 1, void *>();
     test<V, 2, const void *>();
     test<V, 3, long double>();
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
-    using V = std::variant<int, int &, int const &, int &&, long double>;
+    using V = std::variant<int, int &, const int &, int &&, long double>;
     test<V, 0, int>();
     test<V, 1, int &>();
-    test<V, 2, int const &>();
+    test<V, 2, const int &>();
     test<V, 3, int &&>();
     test<V, 4, long double>();
   }
 #endif
 }

test/std/utilities/variant/variant.get/get_if_index.pass.cpp

 
 void test_const_get_if() {
   {
     using V = std::variant<int>;
     constexpr const V *v = nullptr;
     static_assert(std::get_if<0>(v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
     ASSERT_NOEXCEPT(std::get_if<0>(&v));
-    ASSERT_SAME_TYPE(decltype(std::get_if<0>(&v)), int const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<0>(&v)), const int *);
     static_assert(*std::get_if<0>(&v) == 42, "");
     static_assert(std::get_if<1>(&v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), long const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), const long *);
     static_assert(*std::get_if<1>(&v) == 42, "");
     static_assert(std::get_if<0>(&v) == nullptr, "");
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
void test_get_if() {
     using V = std::variant<int, long>;
     V v(42);
     ASSERT_NOEXCEPT(std::get_if<0>(&v));
     ASSERT_SAME_TYPE(decltype(std::get_if<0>(&v)), int *);
     assert(*std::get_if<0>(&v) == 42);
     assert(std::get_if<1>(&v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), long *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<1>(&v)), const long *);
     assert(*std::get_if<1>(&v) == 42);
     assert(std::get_if<0>(&v) == nullptr);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;

test/std/utilities/variant/variant.get/get_if_type.pass.cpp

 
 void test_const_get_if() {
   {
     using V = std::variant<int>;
     constexpr const V *v = nullptr;
     static_assert(std::get_if<int>(v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
     ASSERT_NOEXCEPT(std::get_if<int>(&v));
-    ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), int const *);
+    ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), const int *);
     static_assert(*std::get_if<int>(&v) == 42, "");
-    static_assert(std::get_if<long>(&v) == nullptr, "");
+    static_assert(std::get_if<const long>(&v) == nullptr, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<long>(&v)), long const *);
-    static_assert(*std::get_if<long>(&v) == 42, "");
+    ASSERT_SAME_TYPE(decltype(std::get_if<const long>(&v)), const long *);
+    static_assert(*std::get_if<const long>(&v) == 42, "");
     static_assert(std::get_if<int>(&v) == nullptr, "");
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     const V v(x);

 
 void test_get_if() {
   {
     using V = std::variant<int>;
     V *v = nullptr;
     assert(std::get_if<int>(v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOEXCEPT(std::get_if<int>(&v));
     ASSERT_SAME_TYPE(decltype(std::get_if<int>(&v)), int *);
     assert(*std::get_if<int>(&v) == 42);
-    assert(std::get_if<long>(&v) == nullptr);
+    assert(std::get_if<const long>(&v) == nullptr);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get_if<long>(&v)), long *);
-    assert(*std::get_if<long>(&v) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get_if<const long>(&v)), const long *);
+    assert(*std::get_if<const long>(&v) == 42);
     assert(std::get_if<int>(&v) == nullptr);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     V v(x);

test/std/utilities/variant/variant.get/get_index.pass.cpp

 #include "variant_test_helpers.hpp"
 #include <cassert>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 void test_const_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
-    // ASSERT_NOT_NOEXCEPT(std::get<0>(v));
-    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int const &);
+    ASSERT_NOT_NOEXCEPT(std::get<0>(v));
+    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     static_assert(std::get<0>(v) == 42, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), long const &);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
     static_assert(std::get<1>(v) == 42, "");
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     const V v(x);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     assert(&std::get<0>(v) == &x);
   }
 #endif
 }
 
 void test_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(v));
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
     assert(std::get<0>(v) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), long &);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
     assert(std::get<1>(v) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     V v(x);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     assert(&std::get<0>(v) == &x);
   }
 #endif
 }
 
 void test_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &&);
     assert(std::get<0>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), long &&);
+    ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
     assert(std::get<1>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     V v(x);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     const int &&xref = std::get<0>(std::move(v));
     assert(&xref == &x);
   }
 #endif
 }
 
 void test_const_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &&);
     assert(std::get<0>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     const V v(42l);
     ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
     assert(std::get<1>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
#ifndef TEST_HAS_NO_EXCEPTIONS
   const V &cv1 = v1;
   assert(v1.index() == 1);
   std::integral_constant<size_t, 0> zero;
   std::integral_constant<size_t, 1> one;
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
       std::get<Idx::value>(std::forward<decltype(v)>(v));
-    } catch (std::bad_variant_access const &) {
+    } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
     return false;
   };
   { // lvalue test cases
     assert(test(one, v0));
     assert(test(zero, v1));

test/std/utilities/variant/variant.get/get_type.pass.cpp

 #include "variant_test_helpers.hpp"
 #include <cassert>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 void test_const_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     constexpr V v(42);
-    // ASSERT_NOT_NOEXCEPT(std::get<int>(v));
-    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int const &);
+    ASSERT_NOT_NOEXCEPT(std::get<int>(v));
+    ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
     static_assert(std::get<int>(v) == 42, "");
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     constexpr V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(v)), long const &);
-    static_assert(std::get<long>(v) == 42, "");
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);
+    static_assert(std::get<const long>(v) == 42, "");
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     const V v(x);
     ASSERT_SAME_TYPE(decltype(std::get<int &>(v)), int &);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     ASSERT_SAME_TYPE(decltype(std::get<const int &&>(v)), const int &);
     assert(&std::get<const int &&>(v) == &x);
   }
 #endif
 }
 
 void test_lvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(v));
     ASSERT_SAME_TYPE(decltype(std::get<int>(v)), int &);
     assert(std::get<int>(v) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(v)), long &);
-    assert(std::get<long>(v) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(v)), const long &);
+    assert(std::get<const long>(v) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     V v(x);
     ASSERT_SAME_TYPE(decltype(std::get<int &>(v)), int &);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     ASSERT_SAME_TYPE(decltype(std::get<const int &&>(v)), const int &);
     assert(&std::get<const int &&>(v) == &x);
   }
 #endif
 }
 
 void test_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<int>(std::move(v))), int &&);
     assert(std::get<int>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(std::move(v))), long &&);
-    assert(std::get<long>(std::move(v)) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(std::move(v))),
+                     const long &&);
+    assert(std::get<const long>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     V v(x);
     ASSERT_SAME_TYPE(decltype(std::get<int &>(std::move(v))), int &);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     const int &&xref = std::get<const int &&>(std::move(v));
     assert(&xref == &x);
   }
 #endif
 }
 
 void test_const_rvalue_get() {
   {
-    using V = std::variant<int>;
+    using V = std::variant<int, const long>;
     const V v(42);
     ASSERT_NOT_NOEXCEPT(std::get<int>(std::move(v)));
     ASSERT_SAME_TYPE(decltype(std::get<int>(std::move(v))), const int &&);
     assert(std::get<int>(std::move(v)) == 42);
   }
   {
-    using V = std::variant<int, long>;
+    using V = std::variant<int, const long>;
     const V v(42l);
-    ASSERT_SAME_TYPE(decltype(std::get<long>(std::move(v))), const long &&);
-    assert(std::get<long>(std::move(v)) == 42);
+    ASSERT_SAME_TYPE(decltype(std::get<const long>(std::move(v))),
+                     const long &&);
+    assert(std::get<const long>(std::move(v)) == 42);
   }
 // FIXME: Remove these once reference support is reinstated
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &>;
     int x = 42;
     const V v(x);
     ASSERT_SAME_TYPE(decltype(std::get<int &>(std::move(v))), int &);
#ifndef TEST_HAS_NO_EXCEPTIONS
   const V &cv1 = v1;
   assert(v1.index() == 1);
   identity<int> zero;
   identity<long> one;
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
       std::get<typename Idx::type>(std::forward<decltype(v)>(v));
-    } catch (std::bad_variant_access const &) {
+    } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
     }
     return false;
   };
   { // lvalue test cases
     assert(test(one, v0));
     assert(test(zero, v1));

test/std/utilities/variant/variant.get/holds_alternative.pass.cpp

 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <variant>
 
 // template <class T, class... Types>
 // constexpr bool holds_alternative(const variant<Types...>& v) noexcept;
 
+#include "test_macros.h"
 #include <variant>
 
 int main() {
   {
     using V = std::variant<int>;
     constexpr V v;
     static_assert(std::holds_alternative<int>(v), "");
   }
   {
     using V = std::variant<int, long>;
     constexpr V v;
     static_assert(std::holds_alternative<int>(v), "");
     static_assert(!std::holds_alternative<long>(v), "");
   }
   { // noexcept test
     using V = std::variant<int>;
     const V v;
-    static_assert(noexcept(std::holds_alternative<int>(v)), "must be noexcept");
+    ASSERT_NOEXCEPT(std::holds_alternative<int>(v));
   }
 }

test/std/utilities/variant/variant.monostate.relops/relops.pass.cpp

 
 // constexpr bool operator<(monostate, monostate) noexcept { return false; }
 // constexpr bool operator>(monostate, monostate) noexcept { return false; }
 // constexpr bool operator<=(monostate, monostate) noexcept { return true; }
 // constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 // constexpr bool operator==(monostate, monostate) noexcept { return true; }
 // constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 
+#include "test_macros.h"
 #include <cassert>
 #include <type_traits>
 #include <variant>
 
 int main() {
   using M = std::monostate;
   constexpr M m1{};
   constexpr M m2{};
   {
     static_assert((m1 < m2) == false, "");
-    static_assert(noexcept(m1 < m2), "");
+    ASSERT_NOEXCEPT(m1 < m2);
   }
   {
     static_assert((m1 > m2) == false, "");
-    static_assert(noexcept(m1 > m2), "");
+    ASSERT_NOEXCEPT(m1 > m2);
   }
   {
     static_assert((m1 <= m2) == true, "");
-    static_assert(noexcept(m1 <= m2), "");
+    ASSERT_NOEXCEPT(m1 <= m2);
   }
   {
     static_assert((m1 >= m2) == true, "");
-    static_assert(noexcept(m1 >= m2), "");
+    ASSERT_NOEXCEPT(m1 >= m2);
   }
   {
     static_assert((m1 == m2) == true, "");
-    static_assert(noexcept(m1 == m2), "");
+    ASSERT_NOEXCEPT(m1 == m2);
   }
   {
     static_assert((m1 != m2) == false, "");
-    static_assert(noexcept(m1 != m2), "");
+    ASSERT_NOEXCEPT(m1 != m2);
   }
 }

test/std/utilities/variant/variant.relops/relops.pass.cpp

 #include "test_macros.h"
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   MakeEmptyT() = default;
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
 };
-inline bool operator==(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator==(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
-inline bool operator!=(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator!=(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
-inline bool operator<(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator<(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
-inline bool operator<=(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator<=(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
-inline bool operator>(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator>(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
-inline bool operator>=(MakeEmptyT const &, MakeEmptyT const &) {
+inline bool operator>=(const MakeEmptyT &, const MakeEmptyT &) {
   assert(false);
   return false;
 }
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);
   try {
     v = std::move(v2);
#ifndef TEST_HAS_NO_EXCEPTIONS
     assert(v2 == v1);
     assert(!(v1 != v2));
     assert(!(v2 != v1));
   }
 #endif
 }
 
 template <class Var>
-constexpr bool test_less(Var const &l, Var const &r, bool expect_less,
+constexpr bool test_less(const Var &l, const Var &r, bool expect_less,
                          bool expect_greater) {
   return ((l < r) == expect_less) && (!(l >= r) == expect_less) &&
          ((l > r) == expect_greater) && (!(l <= r) == expect_greater);
 }
 
 void test_relational() {
   { // same index, same value
     using V = std::variant<int, long>;

test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp

void test_T_assignment_sfinae() {
     static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, int &&>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
   {
-    using V = std::variant<int, int const &>;
+    using V = std::variant<int, const int &>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
 #endif
 }
 
 void test_T_assignment_basic() {
   {
     std::variant<int> v(43);
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
     int x = 42;
     V v(43l);
     v = x;
     assert(v.index() == 0);
     assert(&std::get<0>(v) == &x);
     v = std::move(x);
     assert(v.index() == 1);
     assert(&std::get<1>(v) == &x);
-    // 'long' is selected by FUN(int const&) since 'int const&' cannot bind
+    // 'long' is selected by FUN(const int &) since 'const int &' cannot bind
     // to 'int&'.
-    int const &cx = x;
+    const int &cx = x;
     v = cx;
     assert(v.index() == 2);
     assert(std::get<2>(v) == 42);
   }
 #endif
 }
 
 void test_T_assignment_performs_construction() {

test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp

 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 
 struct NoCopy {
-  NoCopy(NoCopy const &) = delete;
-  NoCopy &operator=(NoCopy const &) = default;
+  NoCopy(const NoCopy &) = delete;
+  NoCopy &operator=(const NoCopy &) = default;
 };
 
 struct NothrowCopy {
-  NothrowCopy(NothrowCopy const &) noexcept = default;
-  NothrowCopy &operator=(NothrowCopy const &) noexcept = default;
+  NothrowCopy(const NothrowCopy &) noexcept = default;
+  NothrowCopy &operator=(const NothrowCopy &) noexcept = default;
 };
 
 struct CopyOnly {
-  CopyOnly(CopyOnly const &) = default;
+  CopyOnly(const CopyOnly &) = default;
   CopyOnly(CopyOnly &&) = delete;
-  CopyOnly &operator=(CopyOnly const &) = default;
+  CopyOnly &operator=(const CopyOnly &) = default;
   CopyOnly &operator=(CopyOnly &&) = delete;
 };
 
 struct MoveOnly {
-  MoveOnly(MoveOnly const &) = delete;
+  MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
-  MoveOnly &operator=(MoveOnly const &) = default;
+  MoveOnly &operator=(const MoveOnly &) = default;
 };
 
 struct MoveOnlyNT {
-  MoveOnlyNT(MoveOnlyNT const &) = delete;
+  MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
-  MoveOnlyNT &operator=(MoveOnlyNT const &) = default;
+  MoveOnlyNT &operator=(const MoveOnlyNT &) = default;
 };
 
 struct CopyAssign {
   static int alive;
   static int copy_construct;
   static int copy_assign;
   static int move_construct;
   static int move_assign;
   static void reset() {
     copy_construct = copy_assign = move_construct = move_assign = alive = 0;
   }
   CopyAssign(int v) : value(v) { ++alive; }
-  CopyAssign(CopyAssign const &o) : value(o.value) {
+  CopyAssign(const CopyAssign &o) : value(o.value) {
     ++alive;
     ++copy_construct;
   }
   CopyAssign(CopyAssign &&o) : value(o.value) {
     o.value = -1;
     ++alive;
     ++move_construct;
   }
-  CopyAssign &operator=(CopyAssign const &o) {
+  CopyAssign &operator=(const CopyAssign &o) {
     value = o.value;
     ++copy_assign;
     return *this;
   }
   CopyAssign &operator=(CopyAssign &&o) {
     value = o.value;
     o.value = -1;
     ++move_assign;
     return *this;
   }
   ~CopyAssign() { --alive; }
   int value;
 };
 
 int CopyAssign::alive = 0;
 int CopyAssign::copy_construct = 0;
 int CopyAssign::copy_assign = 0;
 int CopyAssign::move_construct = 0;
 int CopyAssign::move_assign = 0;
 
 struct CopyMaybeThrows {
-  CopyMaybeThrows(CopyMaybeThrows const &);
-  CopyMaybeThrows &operator=(CopyMaybeThrows const &);
+  CopyMaybeThrows(const CopyMaybeThrows &);
+  CopyMaybeThrows &operator=(const CopyMaybeThrows &);
 };
 struct CopyDoesThrow {
-  CopyDoesThrow(CopyDoesThrow const &) noexcept(false);
-  CopyDoesThrow &operator=(CopyDoesThrow const &) noexcept(false);
+  CopyDoesThrow(const CopyDoesThrow &) noexcept(false);
+  CopyDoesThrow &operator=(const CopyDoesThrow &) noexcept(false);
 };
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct CopyThrows {
   CopyThrows() = default;
-  CopyThrows(CopyThrows const &) { throw 42; }
-  CopyThrows &operator=(CopyThrows const &) { throw 42; }
+  CopyThrows(const CopyThrows &) { throw 42; }
+  CopyThrows &operator=(const CopyThrows &) { throw 42; }
 };
 
 struct MoveThrows {
   static int alive;
   MoveThrows() { ++alive; }
-  MoveThrows(MoveThrows const &) { ++alive; }
+  MoveThrows(const MoveThrows &) { ++alive; }
   MoveThrows(MoveThrows &&) { throw 42; }
-  MoveThrows &operator=(MoveThrows const &) { return *this; }
+  MoveThrows &operator=(const MoveThrows &) { return *this; }
   MoveThrows &operator=(MoveThrows &&) { throw 42; }
   ~MoveThrows() { --alive; }
 };
 
 int MoveThrows::alive = 0;
 
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
-  MakeEmptyT(MakeEmptyT const &) {
+  MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
-  MakeEmptyT &operator=(MakeEmptyT const &) { throw 42; }
+  MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);

 }
 
 void test_copy_assignment_sfinae() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_copy_assignable<V>::value, "");
   }
   {
-    // variant only provides copy assignment when beth the copy and move
+    // variant only provides copy assignment when both the copy and move
     // constructors are well formed
     using V = std::variant<int, CopyOnly>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }

test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp

 #include <type_traits>
 #include <utility>
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 struct NoCopy {
-  NoCopy(NoCopy const &) = delete;
-  NoCopy &operator=(NoCopy const &) = default;
+  NoCopy(const NoCopy &) = delete;
+  NoCopy &operator=(const NoCopy &) = default;
 };
 
 struct CopyOnly {
-  CopyOnly(CopyOnly const &) = default;
+  CopyOnly(const CopyOnly &) = default;
   CopyOnly(CopyOnly &&) = delete;
-  CopyOnly &operator=(CopyOnly const &) = default;
+  CopyOnly &operator=(const CopyOnly &) = default;
   CopyOnly &operator=(CopyOnly &&) = delete;
 };
 
 struct MoveOnly {
-  MoveOnly(MoveOnly const &) = delete;
+  MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
-  MoveOnly &operator=(MoveOnly const &) = delete;
+  MoveOnly &operator=(const MoveOnly &) = delete;
   MoveOnly &operator=(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
-  MoveOnlyNT(MoveOnlyNT const &) = delete;
+  MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
-  MoveOnlyNT &operator=(MoveOnlyNT const &) = delete;
+  MoveOnlyNT &operator=(const MoveOnlyNT &) = delete;
   MoveOnlyNT &operator=(MoveOnlyNT &&) = default;
 };
 
 struct MoveOnlyOddNothrow {
   MoveOnlyOddNothrow(MoveOnlyOddNothrow &&) noexcept(false) {}
-  MoveOnlyOddNothrow(MoveOnlyOddNothrow const &) = delete;
+  MoveOnlyOddNothrow(const MoveOnlyOddNothrow &) = delete;
   MoveOnlyOddNothrow &operator=(MoveOnlyOddNothrow &&) noexcept = default;
-  MoveOnlyOddNothrow &operator=(MoveOnlyOddNothrow const &) = delete;
+  MoveOnlyOddNothrow &operator=(const MoveOnlyOddNothrow &) = delete;
 };
 
 struct MoveAssignOnly {
   MoveAssignOnly(MoveAssignOnly &&) = delete;
   MoveAssignOnly &operator=(MoveAssignOnly &&) = default;
 };
 
 struct MoveAssign {

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

static_assert(!std::is_constructible<V, int>::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, int const &>;
+    using V = std::variant<int, const int &>;
     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
   }
 #endif
 }
 
 void test_T_ctor_basic() {
   {
     constexpr std::variant<int> v(42);
     static_assert(v.index() == 0, "");
     static_assert(std::get<0>(v) == 42, "");
   }
   {
     constexpr std::variant<int, long> v(42l);
     static_assert(v.index() == 1, "");
     static_assert(std::get<1>(v) == 42, "");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
-    using V = std::variant<int const &, int &&, long>;
+    using V = std::variant<const int &, int &&, long>;
     static_assert(std::is_convertible<int &, V>::value, "must be implicit");
     int x = 42;
     V v(x);
     assert(v.index() == 0);
     assert(&std::get<0>(v) == &x);
   }
   {
-    using V = std::variant<int const &, int &&, long>;
+    using V = std::variant<const int &, int &&, long>;
     static_assert(std::is_convertible<int, V>::value, "must be implicit");
     int x = 42;
     V v(std::move(x));
     assert(v.index() == 1);
     assert(&std::get<1>(v) == &x);
   }
 #endif
 }
 
 int main() {
   test_T_ctor_basic();
   test_T_ctor_noexcept();
   test_T_ctor_sfinae();
 }

test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp

 #include <cassert>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 
 struct NonT {
   NonT(int v) : value(v) {}
-  NonT(NonT const &o) : value(o.value) {}
+  NonT(const NonT &o) : value(o.value) {}
   int value;
 };
 static_assert(!std::is_trivially_copy_constructible<NonT>::value, "");
 
 struct NoCopy {
-  NoCopy(NoCopy const &) = delete;
+  NoCopy(const NoCopy &) = delete;
 };
 
 struct MoveOnly {
-  MoveOnly(MoveOnly const &) = delete;
+  MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
-  MoveOnlyNT(MoveOnlyNT const &) = delete;
+  MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
 };
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
-  MakeEmptyT(MakeEmptyT const &) {
+  MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
-  MakeEmptyT &operator=(MakeEmptyT const &) { throw 42; }
+  MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);
void test_copy_ctor_basic() {
   }
 }
 
 void test_copy_ctor_valueless_by_exception() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<int, MakeEmptyT>;
   V v1;
   makeEmpty(v1);
-  V const &cv1 = v1;
+  const V &cv1 = v1;
   V v(cv1);
   assert(v.valueless_by_exception());
 #endif
 }
 
 template <size_t Idx>
 constexpr bool test_constexpr_copy_ctor_extension_imp(
     std::variant<long, void*, const int> const& v)

test/std/utilities/variant/variant.variant/variant.ctor/default.pass.cpp

 }
 
 void test_default_ctor_throws() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<DefaultCtorThrows, int>;
   try {
     V v;
     assert(false);
-  } catch (int const &ex) {
+  } catch (const int &ex) {
     assert(ex == 42);
   } catch (...) {
     assert(false);
   }
 #endif
 }
 
 void test_default_ctor_basic() {

test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp

 
 #include "test_macros.h"
 
 struct ThrowsMove {
   ThrowsMove(ThrowsMove &&) noexcept(false) {}
 };
 
 struct NoCopy {
-  NoCopy(NoCopy const &) = delete;
+  NoCopy(const NoCopy &) = delete;
 };
 
 struct MoveOnly {
   int value;
   MoveOnly(int v) : value(v) {}
-  MoveOnly(MoveOnly const &) = delete;
+  MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
   int value;
   MoveOnlyNT(int v) : value(v) {}
-  MoveOnlyNT(MoveOnlyNT const &) = delete;
+  MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&other) : value(other.value) { other.value = -1; }
 };
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
-  MakeEmptyT(MakeEmptyT const &) {
+  MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
-  MakeEmptyT &operator=(MakeEmptyT const &) { throw 42; }
+  MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);

test/std/utilities/variant/variant.variant/variant.dtor/dtor.pass.cpp

struct NonTDtor1 {
   static int count;
   NonTDtor1() = default;
   ~NonTDtor1() { ++count; }
 };
 int NonTDtor1::count = 0;
 static_assert(!std::is_trivially_destructible<NonTDtor1>::value, "");
 
 struct TDtor {
-  TDtor(TDtor const &) {} // non-trivial copy
+  TDtor(const TDtor &) {} // non-trivial copy
   ~TDtor() = default;
 };
 static_assert(!std::is_trivially_copy_constructible<TDtor>::value, "");
 static_assert(std::is_trivially_destructible<TDtor>::value, "");
 
 int main() {
   {
     using V = std::variant<int, long, TDtor>;

test/std/utilities/variant/variant.variant/variant.mod/emplace_index_args.pass.cpp

void test_emplace_sfinae() {
     static_assert(!emplace_exists<V, 1, const int *>(), "");
     static_assert(!emplace_exists<V, 1, int>(), "cannot construct");
     static_assert(emplace_exists<V, 2, const int *>(), "");
     static_assert(emplace_exists<V, 2, int *>(), "");
     static_assert(!emplace_exists<V, 3>(), "cannot construct");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
-    using V = std::variant<int, int &, int const &, int &&, TestTypes::NoCtors>;
+    using V = std::variant<int, int &, const int &, int &&, TestTypes::NoCtors>;
     static_assert(emplace_exists<V, 0>(), "");
     static_assert(emplace_exists<V, 0, int>(), "");
     static_assert(emplace_exists<V, 0, long long>(), "");
     static_assert(!emplace_exists<V, 0, int, int>(), "too many args");
     static_assert(emplace_exists<V, 1, int &>(), "");
     static_assert(!emplace_exists<V, 1>(), "cannot default construct ref");
-    static_assert(!emplace_exists<V, 1, int const &>(), "cannot bind ref");
+    static_assert(!emplace_exists<V, 1, const int &>(), "cannot bind ref");
     static_assert(!emplace_exists<V, 1, int &&>(), "cannot bind ref");
     static_assert(emplace_exists<V, 2, int &>(), "");
     static_assert(emplace_exists<V, 2, const int &>(), "");
     static_assert(emplace_exists<V, 2, int &&>(), "");
     static_assert(!emplace_exists<V, 2, void *>(),
                   "not constructible from void*");
     static_assert(emplace_exists<V, 3, int>(), "");
     static_assert(!emplace_exists<V, 3, int &>(), "cannot bind ref");
-    static_assert(!emplace_exists<V, 3, int const &>(), "cannot bind ref");
-    static_assert(!emplace_exists<V, 3, int const &&>(), "cannot bind ref");
+    static_assert(!emplace_exists<V, 3, const int &>(), "cannot bind ref");
+    static_assert(!emplace_exists<V, 3, const int &&>(), "cannot bind ref");
     static_assert(!emplace_exists<V, 4>(), "no ctors");
   }
 #endif
 }
 
 void test_basic() {
   {
     using V = std::variant<int>;
void test_basic() {
     v.emplace<2>(&x);
     assert(std::get<2>(v) == &x);
     // emplace with multiple args
     v.emplace<4>(3, 'a');
     assert(std::get<4>(v) == "aaa");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
-    using V = std::variant<int, long, int const &, int &&, TestTypes::NoCtors,
+    using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
                            std::string>;
     const int x = 100;
     int y = 42;
     int z = 43;
     V v(std::in_place_index<0>, -1);
     // default emplace a value
     v.emplace<1>();
     assert(std::get<1>(v) == 0);

test/std/utilities/variant/variant.variant/variant.mod/emplace_type_args.pass.cpp

void test_emplace_sfinae() {
     static_assert(emplace_exists<V, int>(), "");
     static_assert(emplace_exists<V, int, int>(), "");
     static_assert(!emplace_exists<V, int, decltype(nullptr)>(),
                   "cannot construct");
     static_assert(emplace_exists<V, void *, decltype(nullptr)>(), "");
     static_assert(!emplace_exists<V, void *, int>(), "cannot construct");
     static_assert(emplace_exists<V, void *, int *>(), "");
     static_assert(!emplace_exists<V, void *, const int *>(), "");
-    static_assert(emplace_exists<V, void const *, const int *>(), "");
-    static_assert(emplace_exists<V, void const *, int *>(), "");
+    static_assert(emplace_exists<V, const void *, const int *>(), "");
+    static_assert(emplace_exists<V, const void *, int *>(), "");
     static_assert(!emplace_exists<V, TestTypes::NoCtors>(), "cannot construct");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
-  using V = std::variant<int, int &, int const &, int &&, long, long,
+  using V = std::variant<int, int &, const int &, int &&, long, long,
                          TestTypes::NoCtors>;
   static_assert(emplace_exists<V, int>(), "");
   static_assert(emplace_exists<V, int, int>(), "");
   static_assert(emplace_exists<V, int, long long>(), "");
   static_assert(!emplace_exists<V, int, int, int>(), "too many args");
   static_assert(emplace_exists<V, int &, int &>(), "");
   static_assert(!emplace_exists<V, int &>(), "cannot default construct ref");
-  static_assert(!emplace_exists<V, int &, int const &>(), "cannot bind ref");
+  static_assert(!emplace_exists<V, int &, const int &>(), "cannot bind ref");
   static_assert(!emplace_exists<V, int &, int &&>(), "cannot bind ref");
-  static_assert(emplace_exists<V, int const &, int &>(), "");
-  static_assert(emplace_exists<V, int const &, const int &>(), "");
-  static_assert(emplace_exists<V, int const &, int &&>(), "");
-  static_assert(!emplace_exists<V, int const &, void *>(),
+  static_assert(emplace_exists<V, const int &, int &>(), "");
+  static_assert(emplace_exists<V, const int &, const int &>(), "");
+  static_assert(emplace_exists<V, const int &, int &&>(), "");
+  static_assert(!emplace_exists<V, const int &, void *>(),
                 "not constructible from void*");
   static_assert(emplace_exists<V, int &&, int>(), "");
   static_assert(!emplace_exists<V, int &&, int &>(), "cannot bind ref");
-  static_assert(!emplace_exists<V, int &&, int const &>(), "cannot bind ref");
-  static_assert(!emplace_exists<V, int &&, int const &&>(), "cannot bind ref");
+  static_assert(!emplace_exists<V, int &&, const int &>(), "cannot bind ref");
+  static_assert(!emplace_exists<V, int &&, const int &&>(), "cannot bind ref");
   static_assert(!emplace_exists<V, long, long>(), "ambiguous");
   static_assert(!emplace_exists<V, TestTypes::NoCtors>(),
                 "cannot construct void");
 #endif
 }
 
 void test_basic() {
   {
void test_basic() {
     v.emplace<const void *>(&x);
     assert(std::get<2>(v) == &x);
     // emplace with multiple args
     v.emplace<std::string>(3, 'a');
     assert(std::get<4>(v) == "aaa");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
-    using V = std::variant<int, long, int const &, int &&, TestTypes::NoCtors,
+    using V = std::variant<int, long, const int &, int &&, TestTypes::NoCtors,
                            std::string>;
     const int x = 100;
     int y = 42;
     int z = 43;
     V v(std::in_place_index<0>, -1);
     // default emplace a value
     v.emplace<long>();
     assert(std::get<long>(v) == 0);
     // emplace a reference
-    v.emplace<int const &>(x);
-    assert(&std::get<int const &>(v) == &x);
+    v.emplace<const int &>(x);
+    assert(&std::get<const int &>(v) == &x);
     // emplace an rvalue reference
     v.emplace<int &&>(std::move(y));
     assert(&std::get<int &&>(v) == &y);
     // re-emplace a new reference over the active member
     v.emplace<int &&>(std::move(z));
     assert(&std::get<int &&>(v) == &z);
     // emplace with multiple args
     v.emplace<std::string>(3, 'a');

test/std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp

 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 struct NotSwappable {};
 void swap(NotSwappable &, NotSwappable &) = delete;
 
 struct NotCopyable {
   NotCopyable() = default;
-  NotCopyable(NotCopyable const &) = delete;
-  NotCopyable &operator=(NotCopyable const &) = delete;
+  NotCopyable(const NotCopyable &) = delete;
+  NotCopyable &operator=(const NotCopyable &) = delete;
 };
 
 struct NotCopyableWithSwap {
   NotCopyableWithSwap() = default;
-  NotCopyableWithSwap(NotCopyableWithSwap const &) = delete;
-  NotCopyableWithSwap &operator=(NotCopyableWithSwap const &) = delete;
+  NotCopyableWithSwap(const NotCopyableWithSwap &) = delete;
+  NotCopyableWithSwap &operator=(const NotCopyableWithSwap &) = delete;
 };
 void swap(NotCopyableWithSwap &, NotCopyableWithSwap) {}
 
 struct NotMoveAssignable {
   NotMoveAssignable() = default;
   NotMoveAssignable(NotMoveAssignable &&) = default;
   NotMoveAssignable &operator=(NotMoveAssignable &&) = delete;
 };
template <bool NT_Copy, bool NT_Move, bool NT_CopyAssign, bool NT_MoveAssign,
           bool NT_Swap, bool EnableSwap = true>
 struct NothrowTypeImp {
   static int move_called;
   static int move_assign_called;
   static int swap_called;
   static void reset() { move_called = move_assign_called = swap_called = 0; }
   NothrowTypeImp() = default;
   explicit NothrowTypeImp(int v) : value(v) {}
-  NothrowTypeImp(NothrowTypeImp const &o) noexcept(NT_Copy) : value(o.value) {
+  NothrowTypeImp(const NothrowTypeImp &o) noexcept(NT_Copy) : value(o.value) {
     assert(false);
   } // never called by test
   NothrowTypeImp(NothrowTypeImp &&o) noexcept(NT_Move) : value(o.value) {
     ++move_called;
     do_throw<!NT_Move>();
     o.value = -1;
   }
-  NothrowTypeImp &operator=(NothrowTypeImp const &) noexcept(NT_CopyAssign) {
+  NothrowTypeImp &operator=(const NothrowTypeImp &) noexcept(NT_CopyAssign) {
     assert(false);
     return *this;
   } // never called by the tests
   NothrowTypeImp &operator=(NothrowTypeImp &&o) noexcept(NT_MoveAssign) {
     ++move_assign_called;
     do_throw<!NT_MoveAssign>();
     value = o.value;
     o.value = -1;
#ifdef _LIBCPP_VERSION
     // swap again, but call v2's swap.
     T1::reset();
     T2::reset();
     try {
       v2.swap(v1);
       assert(false);
     } catch (int) {
     }
     assert(T1::swap_called == 0);
     assert(T1::move_called == 1);
     assert(T1::move_assign_called == 0);
     assert(T2::swap_called == 0);
     assert(T2::move_called == 2);
     assert(T2::move_assign_called == 0);
     assert(std::get<0>(v1).value == 42);
     assert(std::get<1>(v2).value == 100);
   }
 #endif // _LIBCPP_VERSION
 #endif
void test_swap_noexcept() {
     swap(v1, v2);
   }
   {
     using V = std::variant<int, ThrowingTypeWithNothrowSwap>;
     static_assert(std::is_swappable_v<V> && has_swap_member<V>(), "");
     static_assert(!std::is_nothrow_swappable_v<V>, "");
     // instantiate swap
     V v1, v2;
     v1.swap(v2);
     swap(v1, v2);
   }
   {
     using V = std::variant<int, ThrowingMoveAssignNothrowMoveCtor>;
     static_assert(std::is_swappable_v<V> && has_swap_member<V>(), "");
     static_assert(!std::is_nothrow_swappable_v<V>, "");
     // instantiate swap
     V v1, v2;
     v1.swap(v2);
     swap(v1, v2);

test/std/utilities/variant/variant.variant/variant_reference.fail.cpp

 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 int main()
 {
     // expected-error@variant:* 3 {{static_assert failed}}
     std::variant<int, int&> v; // expected-note {{requested here}}
-    std::variant<int, int const&> v2; // expected-note {{requested here}}
+    std::variant<int, const int &> v2; // expected-note {{requested here}}
     std::variant<int, int&&> v3; // expected-note {{requested here}}
 }

test/std/utilities/variant/variant.visit/visit.pass.cpp

template <class... Args> static bool check_call(CallType type) {
     bool result = last_call_type == type && last_call_args &&
                   *last_call_args == makeArgumentID<Args...>();
     last_call_type = CT_None;
     last_call_args = nullptr;
     return result;
   }
 
   static CallType last_call_type;
-  static TypeID const *last_call_args;
+  static const TypeID *last_call_args;
 };
 
 CallType ForwardingCallObject::last_call_type = CT_None;
-TypeID const *ForwardingCallObject::last_call_args = nullptr;
+const TypeID *ForwardingCallObject::last_call_args = nullptr;
 
 void test_call_operator_forwarding() {
   using Fn = ForwardingCallObject;
   Fn obj{};
-  Fn const &cobj = obj;
+  const Fn &cobj = obj;
   { // test call operator forwarding - single variant, single arg
     using V = std::variant<int>;
     V v(42);
     std::visit(obj, v);
     assert(Fn::check_call<int &>(CT_NonConst | CT_LValue));
     std::visit(cobj, v);
     assert(Fn::check_call<int &>(CT_Const | CT_LValue));
     std::visit(std::move(obj), v);

 
 void test_argument_forwarding() {
   using Fn = ForwardingCallObject;
   Fn obj{};
   const auto Val = CT_LValue | CT_NonConst;
   { // single argument - value type
     using V = std::variant<int>;
     V v(42);
-    V const &cv = v;
+    const V &cv = v;
     std::visit(obj, v);
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, cv);
-    assert(Fn::check_call<int const &>(Val));
+    assert(Fn::check_call<const int &>(Val));
     std::visit(obj, std::move(v));
     assert(Fn::check_call<int &&>(Val));
     std::visit(obj, std::move(cv));
     assert(Fn::check_call<const int &&>(Val));
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   { // single argument - lvalue reference
     using V = std::variant<int &>;
     int x = 42;
     V v(x);
-    V const &cv = v;
+    const V &cv = v;
     std::visit(obj, v);
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, cv);
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, std::move(v));
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, std::move(cv));
     assert(Fn::check_call<int &>(Val));
   }
   { // single argument - rvalue reference
     using V = std::variant<int &&>;
     int x = 42;
     V v(std::move(x));
-    V const &cv = v;
+    const V &cv = v;
     std::visit(obj, v);
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, cv);
     assert(Fn::check_call<int &>(Val));
     std::visit(obj, std::move(v));
     assert(Fn::check_call<int &&>(Val));
     std::visit(obj, std::move(cv));
     assert(Fn::check_call<int &&>(Val));
   }
   { // multi argument - multi variant
-    using S = std::string const &;
+    using S = const std::string &;
     using V = std::variant<int, S, long &&>;
-    std::string const str = "hello";
+    const std::string str = "hello";
     long l = 43;
     V v1(42);
-    V const &cv1 = v1;
+    const V &cv1 = v1;
     V v2(str);
-    V const &cv2 = v2;
+    const V &cv2 = v2;
     V v3(std::move(l));
-    V const &cv3 = v3;
+    const V &cv3 = v3;
     std::visit(obj, v1, v2, v3);
     assert((Fn::check_call<int &, S, long &>(Val)));
     std::visit(obj, cv1, cv2, std::move(v3));
     assert((Fn::check_call<const int &, S, long &&>(Val)));
   }
 #endif
 }
 

 }
 
 void test_exceptions() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   ReturnArity obj{};
   auto test = [&](auto &&... args) {
     try {
       std::visit(obj, args...);
-    } catch (std::bad_variant_access const &) {
+    } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) {
     }
     return false;
   };
   {
     using V = std::variant<int, MakeEmptyT>;
     V v;