[libc++] experimental variant class for review

[ruoka]

Summary

Th libc++ SVN trunk is still seems to be missing the variant class. It would be great to have it included. Here's a my implementation of the variant class and test cases in case libc++ needs one and in case you want to use mine. I believe I did write it libc++ compatible way. Cheers!

Patch by Kaius Ruokonen.

[EricWF]

We already have a <variant> implementation in the pipeline (https://reviews.llvm.org/D23263). And I would much rather not have two entirely separate variant implementations in libc++.

[ruoka]

Hi Eric,
Well, that is kind of a good news. I have been following the status of variant in http://libcxx.llvm.org/cxx1z_status.html and being worried because it isn’t even “In progress”. (I’m using it in one of my libraries) I guess the C++1z implementation the status was just outdated. I agree there is no point of having two variant implementations in libc++. Naturally, it’s your choice what implementation you prefer in the end. Cheers.
Br, Kaius

[ruoka]

D23263 doesn’t seem to be completely aligned with the latest standard draft
https://github.com/cplusplus/draft/blob/master/papers/n4606.pdf as it doesn’t support references, void, allocators and is_move_assignable_v returned false when it should had returned true.

//All types in Types... shall be (possibly cv-qualified) object types, (possibly cv-qualified) void, or references. [ Note: Implementations could decide to store references in a wrapper. — end note ] 

template <class... Types, class Alloc> struct uses_allocator<variant<Types...>, Alloc> : true_type { };

allocator-extended constructors
It seems that it will take some more time before it’s available in SVN.

[mpark]

Hello,

as it doesn’t support references, void, allocators

Support for references, void, and allocators were removed at the latest meeting in Issaquah.

is_move_assignable_v returned false when it should had returned true.

This sounds like it may be a bug. Could you please comment on D23263 and point out the problematic case?

[ruoka]

Hi mpark,

Sorry, my bad.

I didn’t know that void, and allocators were removed.

And the below test failed with your implementation but that is what the standard draft required?

#include <variant>

using std::variant;

struct foo
{

// foo(foo&&) {};
foo& operator = (foo&&) noexcept {return *this;};

};

int main()
{

// static_assert(std::is_move_constructible_v<foo>);
static_assert(std::is_move_assignable_v<foo>);
static_assert(std::is_move_assignable_v<variant<foo>>);

}

“Remarks: This function shall not participate in overload resolution unless is_move_constructible_v<Ti> && is_move_assignable_v<Ti> is true for all i.”

I didn’t check the is_move_constructible in my own implementation.

Let’s hope that the variant ships soon with LIBCPP!

[mpark]

In D26899#602539, @ruoka wrote:

Hi mpark,

Sorry, my bad.

I didn’t know that void, and allocators were removed.

And the below test failed with your implementation but that is what the standard draft required?

#include <variant>

using std::variant;

struct foo
{
  // foo(foo&&) {};
  foo& operator = (foo&&) noexcept {return *this;};
};

int main()
{
  // static_assert(std::is_move_constructible_v<foo>);
  static_assert(std::is_move_assignable_v<foo>);
  static_assert(std::is_move_assignable_v<variant<foo>>);
}

“Remarks: This function shall not participate in overload resolution unless is_move_constructible_v<Ti> && is_move_assignable_v<Ti> is true for all i.”

I didn’t check the is_move_constructible in my own implementation.

Let’s hope that the variant ships soon with LIBCPP!

I don't see a problem here. The example (as commented out) should, and does fail.
Since foo's move assignment operator is defined, the move constructor is not.
Therefore is_move_constructible_v<foo> returns false.
As you quoted, variant<foo> is move assignable, if foo is move constructible and move assignable.
Since foo is not move constructible, variant<foo> is not move assignable.

[ruoka]

In D26899#606108, @mpark wrote:

In D26899#602539, @ruoka wrote:

Hi mpark,

Sorry, my bad.

I didn’t know that void, and allocators were removed.

And the below test failed with your implementation but that is what the standard draft required?

#include <variant>

using std::variant;

struct foo
{
  // foo(foo&&) {};
  foo& operator = (foo&&) noexcept {return *this;};
};

int main()
{
  // static_assert(std::is_move_constructible_v<foo>);
  static_assert(std::is_move_assignable_v<foo>);
  static_assert(std::is_move_assignable_v<variant<foo>>);
}

“Remarks: This function shall not participate in overload resolution unless is_move_constructible_v<Ti> && is_move_assignable_v<Ti> is true for all i.”

I didn’t check the is_move_constructible in my own implementation.

Let’s hope that the variant ships soon with LIBCPP!

I don't see a problem here. The example (as commented out) should, and does fail.
Since foo's move assignment operator is defined, the move constructor is not.
Therefore is_move_constructible_v<foo> returns false.
As you quoted, variant<foo> is move assignable, if foo is move constructible and move assignable.
Since foo is not move constructible, variant<foo> is not move assignable.

Sorry, I was not clear enough. The issue was indeed in my test cases and there was no problem here.

[EricWF]

I'm very sorry to do this after all your hard work, but I don't think this patch can proceed.

First , and most importantly, <experimental/variant> isn't part of any standard or technical specification AFAIK. We can't just implement new <experimental/foo> headers without a specification.

Secondly, if <experimental/variant> ever gets added its implementation should mirror`<variant>` as closely as possible.

[ruoka]

In D26899#613168, @EricWF wrote:

I'm very sorry to do this after all your hard work, but I don't think this patch can proceed.

First , and most importantly, <experimental/variant> isn't part of any standard or technical specification AFAIK. We can't just implement new <experimental/foo> headers without a specification.

Secondly, if <experimental/variant> ever gets added its implementation should mirror`<variant>` as closely as possible.

Hi Erik,

Yes, I got it already.

My intention was just to progress the class varian in libcpp as it wasn’t yet included in svn back then.

Great that you managed to include it there now. Good work!

Br, Kaius

include/experimental/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_EXPERIMENTAL_VARIANT
+#define _LIBCPP_EXPERIMENTAL_VARIANT
+
+/*
+
+// Header <variant> synopsis
+
+namespace std {
+// 20.7.2, variant of value types
+template <class... Types>
+class variant;
+// 20.7.3, variant helper classes
+template <class T>
+struct variant_size; // undefined
+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 T>
+constexpr size_t variant_size_v = variant_size<T>::value;
+template <class... Types>
+struct variant_size<variant<Types...>>;
+template <size_t I, class T>
+struct variant_alternative; // undefined
+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 T>
+using variant_alternative_t = typename variant_alternative<I, T>::type;
+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>;
+// 20.7.12, allocator-related traits
+// template <class T, class Alloc> struct uses_allocator;
+template <class... Types, class Alloc>
+struct uses_allocator<variant<Types...>, Alloc>;
+} // namespace std
+
+namespace std {
+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&&...);
+  // allocator-extended constructors
+  template <class Alloc>
+  variant(allocator_arg_t, const Alloc&);
+  template <class Alloc>
+  variant(allocator_arg_t, const Alloc&, const variant&);
+  template <class Alloc>
+  variant(allocator_arg_t, const Alloc&, variant&&);
+  template <class Alloc, class T>
+  variant(allocator_arg_t, const Alloc&, T&&);
+  template <class Alloc, class T, class... Args>
+  variant(allocator_arg_t, const Alloc&, in_place_type_t<T>, Args&&...);
+  template <class Alloc, class T, class U, class... Args>
+  variant(allocator_arg_t, const Alloc&, in_place_type_t<T>, initializer_list<U>, Args&&...);
+  template <class Alloc, size_t I, class... Args>
+  variant(allocator_arg_t, const Alloc&, in_place_index_t<I>, Args&&...);
+  template <class Alloc, size_t I, class U, class... Args>
+  variant(allocator_arg_t, const Alloc&, 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)
+  };
+} // namespace std
+
+*/
+
+#include <experimental/__config>
+#include <tuple>
+#include <array>
+#include <utility>
+#include <functional>
+#include <cassert>
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#if _LIBCPP_STD_VER > 14
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+
+// 20.7.10, class bad_variant_access
+class _LIBCPP_EXCEPTION_ABI bad_variant_access : logic_error {
+public:
+  bad_variant_access() : logic_error{"Bad variant Access"} {};
+  virtual ~bad_variant_access() noexcept {};
+};
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+constexpr size_t variant_npos = -1;
+
+template <class _Type, class... _Types>
+union __variant_storage; // undefined
+
+struct __trivial{};
+
+struct __non_trivial{};
+
+template <class _Type>
+union __variant_storage<_Type,__trivial>
+{
+  _Type m_type;
+
+  constexpr __variant_storage() : m_type{}
+  {}
+
+  template<class... _Args>
+  constexpr __variant_storage(in_place_type_t<_Type>, _Args&&... __args) :
+    m_type{forward<_Args>(__args)...}
+  {}
+};
+
+template <class _Type>
+union __variant_storage<_Type,__non_trivial>
+{
+  aligned_storage_t<sizeof(_Type), alignof(_Type)> __m_storage;
+
+  constexpr __variant_storage() : __m_storage{}
+  {}
+
+  template<class... _Args>
+  __variant_storage(in_place_type_t<_Type>, _Args&&... __args) :
+    __m_storage{}
+  {
+    new(&__m_storage)_Type(forward<_Args>(__args)...);
+  }
+};
+
+template <>
+union __variant_storage<void,__trivial>
+{
+  constexpr __variant_storage() = default;
+};
+
+template <class _Type>
+union __variant_storage<_Type&,__trivial>
+{
+  reference_wrapper<remove_reference_t<_Type>> m_type;
+
+  constexpr __variant_storage() : m_type{}
+  {}
+
+  template<class... _Args>
+  constexpr __variant_storage(in_place_type_t<_Type&>, _Args&&... __args) :
+    m_type{forward<_Args>(__args)...}
+  {}
+};
+
+template <class _Type>
+union __variant_storage<_Type>
+{
+  static constexpr bool trivial = is_trivially_destructible_v<_Type> ||
+                                  is_same_v<_Type,void>;
+
+  __variant_storage<_Type, conditional_t<trivial, __trivial, __non_trivial>>
+  m_head;
+
+  constexpr __variant_storage() : m_head{}
+  {}
+
+  template <class _T,
+            class... _Args,
+            enable_if_t<is_same_v<_T,_Type>, int> = 0
+            >
+  constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) :
+    m_head{in_place_type<_T>, forward<_Args>(__args)...}
+  {}
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && trivial, int> = 0>
+  constexpr _T& get()
+  {
+    return m_head.m_type;
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && trivial, int> = 0>
+  constexpr const _T& get() const
+  {
+    return m_head.m_type;
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && !trivial, int> = 0>
+  constexpr _T& get()
+  {
+    return *reinterpret_cast<_T*>(&m_head.__m_storage);
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && !trivial, int> = 0>
+  constexpr const _T& get() const
+  {
+    return *reinterpret_cast<const _T*>(&m_head.__m_storage);
+  }
+};
+
+template <class _Type, class... _Types>
+union __variant_storage
+{
+  static constexpr bool trivial = is_trivially_destructible_v<_Type> ||
+                                  is_same_v<_Type,void>;
+
+  __variant_storage<_Type, conditional_t<trivial, __trivial, __non_trivial>>
+  m_head;
+
+  __variant_storage<_Types...>
+  m_tail;
+
+  __variant_storage()
+  {}
+
+  template <class _T,
+            class... _Args,
+            enable_if_t<is_same_v<_T,_Type>, int> = 0
+            >
+  constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) :
+    m_head{in_place_type<_T>, forward<_Args>(__args)...}
+  {}
+
+  template <class _T,
+            class... _Args,
+            enable_if_t<!is_same_v<_T,_Type>, int> = 0
+            >
+  constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) :
+    m_tail{in_place_type<_T>, forward<_Args>(__args)...}
+  {}
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && trivial, int> = 0>
+  constexpr _T& get()
+  {
+    return m_head.m_type;
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && trivial, int> = 0>
+  constexpr const _T& get() const
+  {
+    return m_head.m_type;
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && !trivial, int> = 0>
+  constexpr _T& get()
+  {
+    return *reinterpret_cast<_T*>(&m_head.__m_storage);
+  }
+
+  template <class _T, enable_if_t<is_same_v<_T,_Type> && !trivial, int> = 0>
+  constexpr const _T& get() const
+  {
+    return *reinterpret_cast<const _T*>(&m_head.__m_storage);
+  }
+
+  template <class _T, enable_if_t<!is_same_v<_T,_Type>, int> = 0>
+  constexpr _T& get()
+  {
+    return m_tail.template get<_T>();
+  }
+
+  template <class _T, enable_if_t<!is_same_v<_T,_Type>, int> = 0>
+  constexpr const _T& get() const
+  {
+    return m_tail.template get<_T>();
+  }
+};
+
+template <class _T, class... _Types>
+struct __variant_index; // undefined
+
+template <class _T, class... _Types>
+constexpr size_t __variant_index_v = __variant_index<_T, _Types...>::value;
+
+template <class _T>
+struct __variant_index<_T> :
+  integral_constant<size_t, 1> {};
+
+template <class _T, class... _Types>
+struct __variant_index<_T, _T, _Types...> :
+  integral_constant<size_t, 0> {};
+
+template <class _T, class _U, class... _Types>
+struct __variant_index<_T, _U, _Types...> :
+  integral_constant<size_t, 1 + __variant_index_v<_T, _Types...>> {};
+
+// Variant Base Class
+
+template <bool _CopyConstructible,
+          bool _MoveConstructible,
+          bool _CopyAssignable,
+          bool _MoveAssignable,
+          bool _TiviallyDestructible,
+          class... _Types>
+class __variant_base; // undefined
+
+// Non_TiviallyDestructible Specialisation
+
+template <class... _Types>
+class __variant_base<false,false,false,false,false, _Types...>
+{
+public:
+
+  __variant_storage<_Types...> __m_storage;
+
+protected:
+
+  size_t __m_index = variant_npos;
+
+  __variant_base(const __variant_base&) = delete;
+  __variant_base(__variant_base&&) = delete;
+  __variant_base& operator=(const __variant_base&) = delete;
+  __variant_base& operator=(__variant_base&&) = delete;
+
+  __variant_base() :
+    __m_storage{},
+    __m_index{variant_npos}
+  {}
+
+  template <class _T, class... _Args>
+  __variant_base(in_place_type_t<_T>, _Args&&... __args) :
+    __m_storage{},
+    __m_index{variant_npos}
+  {
+    __construct(in_place_type<_T>, forward<_Args>(__args) ...);
+  }
+
+  template <class _Alloc, class _T, class... _Args>
+  __variant_base(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) :
+    __m_storage{},
+    __m_index{variant_npos}
+  {
+    __construct(allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...);
+  }
+
+  ~__variant_base()
+  {
+    if(__m_index != variant_npos)
+      __destroy();
+  }
+
+  template <class _T,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T,_Args...>,int> = 0
+            >
+  void __construct(in_place_type_t<_T>, _Args&&... __args)
+  {
+    assert(__m_index == variant_npos);
+    new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ...};
+    __m_index = __variant_index_v<_T, _Types...>;
+  };
+
+  template <class _Alloc,
+            class _T,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T,allocator_arg_t,const _Alloc&,_Args...>,int> = 0
+            >
+  void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args)
+  {
+    assert(__m_index == variant_npos);
+    new(&__m_storage) decay_t<_T>{allocator_arg, __a, forward<_Args>(__args) ...};
+    __m_index = __variant_index_v<_T, _Types...>;
+  };
+
+  template <class _Alloc,
+            class _T,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T,_Args...,const _Alloc&>,int> = 0
+            >
+  void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args)
+  {
+    assert(__m_index == variant_npos);
+    new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ...,  __a};
+    __m_index = __variant_index_v<_T, _Types...>;
+  };
+
+  template <class _Alloc,
+            class _T,
+            class... _Args,
+            enable_if_t<!is_constructible_v<_T,allocator_arg_t,const _Alloc&,_Args...> &&
+                        !is_constructible_v<_T,_Args...,const _Alloc&>,int> = 0
+            >
+  void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args)
+  {
+    assert(__m_index == variant_npos);
+    new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ...};
+    __m_index = __variant_index_v<_T, _Types...>;
+  };
+
+private:
+
+  template<class _T>
+  void __private_copy(const __variant_base& __v)
+  {
+    __construct(in_place_type<_T>, __v.__m_storage.template get<_T>());
+  }
+
+  template <class _Alloc,
+            class _T
+            >
+  void __private_copy(allocator_arg_t, const _Alloc& __a, const __variant_base& __v)
+  {
+    __construct(allocator_arg, __a, in_place_type<_T>, __v.__m_storage.template get<_T>());
+  }
+
+protected:
+
+  void __copy(const __variant_base& __v)
+  {
+    assert(__v.__m_index != variant_npos);
+    assert(__v.__m_index < sizeof...(_Types));
+    assert(__m_index == variant_npos);
+    using function = void(__variant_base::*)(const __variant_base&);
+    constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Types> ...};
+    (this->*__array[__v.__m_index])(__v);
+  }
+
+  template <class _Alloc>
+  void __copy(allocator_arg_t, const _Alloc& __a, const __variant_base& __v)
+  {
+    assert(__v.__m_index != variant_npos);
+    assert(__v.__m_index < sizeof...(_Types));
+    assert(__m_index == variant_npos);
+    using function = void(__variant_base::*)(allocator_arg_t, const _Alloc&, const __variant_base&);
+    constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Alloc, _Types> ...};
+    (this->*__array[__v.__m_index])(allocator_arg, __a, __v);
+  }
+
+private:
+
+  template<class _T>
+  void __private_move(__variant_base&& __v)
+  {
+    __construct(in_place_type<_T>, move(__v.__m_storage.template get<_T>()));
+  }
+
+  template <class _Alloc,
+            class _T
+            >
+  void __private_move(allocator_arg_t, const _Alloc& __a, __variant_base&& __v)
+  {
+    __construct(allocator_arg, __a, in_place_type<_T>, move(__v.__m_storage.template get<_T>()));
+  }
+
+protected:
+
+  void __move(__variant_base&& __v)
+  {
+    assert(__v.__m_index != variant_npos);
+    assert(__v.__m_index < sizeof...(_Types));
+    assert(__m_index == variant_npos);
+    using function = void(__variant_base::*)(__variant_base&&);
+    constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_move<_Types> ...};
+    (this->*__array[__v.__m_index])(forward<__variant_base>(__v));
+    __v.__m_index = variant_npos;
+  }
+
+  template <class _Alloc>
+  void __move(allocator_arg_t, const _Alloc& __a, __variant_base&& __v)
+  {
+    assert(__v.__m_index != variant_npos);
+    assert(__v.__m_index < sizeof...(_Types));
+    assert(__m_index == variant_npos);
+    using function = void(__variant_base::*)(allocator_arg_t, const _Alloc&, __variant_base&&);
+    constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_move<_Alloc, _Types> ...};
+    (this->*__array[__v.__m_index])(allocator_arg, __a, forward<__variant_base>(__v));
+    __v.__m_index = variant_npos;
+  }
+
+private:
+
+  template<class _T, enable_if_t<is_class_v<decay_t<_T>>,int> = 0>
+  void __private_destroy()
+  {
+    assert(__m_index != variant_npos);
+    reinterpret_cast<add_pointer_t<_T>>(&__m_storage)->~_T();
+    __m_index = variant_npos;
+  };
+
+  template<class _T, enable_if_t<!is_class_v<decay_t<_T>>,int> = 0>
+  void __private_destroy()
+  {
+    assert(__m_index != variant_npos);
+    __m_index = variant_npos;
+  };
+
+protected:
+
+  void __destroy()
+  {
+    assert(__m_index != variant_npos);
+    assert(__m_index < sizeof...(_Types));
+    using function = void(__variant_base::*)();
+    constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_destroy<_Types> ...};
+    (this->*__array[__m_index])();
+  };
+};
+
+// _TiviallyDestructible Specialisation
+
+template <class... _Types>
+class __variant_base<false,false,false,false,true, _Types...>
+{
+public:
+
+  __variant_storage<_Types...> __m_storage;
+
+protected:
+
+  size_t __m_index = variant_npos;
+
+  __variant_base(const __variant_base&) = delete;
+  __variant_base(__variant_base&&) = delete;
+  __variant_base& operator=(const __variant_base&) = delete;
+  __variant_base& operator=(__variant_base&&) = delete;
+  ~__variant_base() = default;
+
+  __variant_base() :
+    __m_storage{},
+    __m_index{variant_npos}
+  {}
+
+  template <class _T, class... _Args>
+  constexpr __variant_base(in_place_type_t<_T>, _Args&&... __args) :
+    __m_storage{in_place_type<_T>, forward<_Args>(__args) ...},
+    __m_index{__variant_index_v<_T, _Types...>}
+  {}
+
+  template <class _T, class... _Args>
+  void __construct(in_place_type_t<_T>, _Args&&... __args)
+  {
+    assert(__m_index == variant_npos);
+    new(&__m_storage) remove_reference_t<_T>{forward<_Args>(__args) ...};
+    __m_index = __variant_index_v<_T, _Types...>;
+  };
+
+private:
+
+  template<class _T>
+  void __private_copy(const __variant_base& __v)
+  {
+    __construct(in_place_type<_T>, __v.__m_storage.template get<_T>());
+  }
+
+protected:
+
+  void __copy(const __variant_base& __v)
+  {
+    assert(__v.__m_index != variant_npos && __v.__m_index < sizeof...(_Types));
+    assert(__m_index == variant_npos);
+    using __function = void(__variant_base::*)(const __variant_base&);
+    constexpr __function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Types> ...};
+    (this->*__array[__v.__m_index])(__v);
+  }
+
+  void __move(__variant_base&& __v)
+  {
+    __copy(__v);
+    __v.__m_index = variant_npos;
+  }
+
+  void __destroy()
+  {
+    assert(__m_index != variant_npos);
+    __m_index = variant_npos;
+  };
+};
+
+// _MoveAssignable Specialisation
+
+template <bool _TiviallyDestructible,
+          class... _Types>
+class __variant_base<false,false,false,true,_TiviallyDestructible,_Types...> :
+public __variant_base<false,false,false,false,_TiviallyDestructible,_Types...>
+{
+  using __base =
+  __variant_base<false,false,false,false,_TiviallyDestructible,_Types...>;
+
+protected:
+
+  using __base::__base;
+  using __base::__move;
+  using __base::__destroy;
+  using __base::__m_index;
+
+  __variant_base&
+  operator=(__variant_base&& __rhs)
+    noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...,
+                           is_nothrow_move_assignable<_Types>...   >)
+  {
+    static_assert(conjunction_v<is_move_constructible<_Types> ...> &&
+                  conjunction_v<is_move_assignable   <_Types> ...> ,
+      R"(This function shall not participate in overload resolution
+      unless is_move_constructible_v<_Ti> && s_move_assignable_v<_Ti> is true for all i.)");
+    if(__m_index != variant_npos)
+      __destroy();
+    if(__rhs.__m_index != variant_npos)
+      __move(move(__rhs));
+    return *this;
+  }
+};
+
+// _CopyAssignable Specialisation
+
+template <bool _MoveAssignable,
+          bool _TiviallyDestructible,
+          class... _Types>
+class __variant_base<false,false,true,_MoveAssignable,_TiviallyDestructible,_Types...> :
+public __variant_base<false,false,false,_MoveAssignable,_TiviallyDestructible,_Types...>
+{
+  using __base =
+  __variant_base<false,false,false,_MoveAssignable,_TiviallyDestructible,_Types...>;
+
+protected:
+
+  using __base::__base;
+  using __base::__copy;
+  using __base::__destroy;
+  using __base::__m_index;
+
+  __variant_base& operator=(const __variant_base& __rhs)
+  {
+    static_assert(conjunction_v<is_copy_constructible<_Types>...,
+                                is_move_constructible<_Types>...,
+                                is_copy_assignable   <_Types>...>,
+      R"(This function shall not participate in overload resolution
+      unless is_copy_constructible_v<_Ti> && is_move_constructible_v<_Ti> &&
+      is_copy_assignable_v<_Ti> is true for all i.)");
+    if(__m_index != variant_npos)
+      __destroy();
+    if(__rhs.__m_index != variant_npos)
+      __copy(__rhs);
+    return *this;
+  }
+  __variant_base& operator=(__variant_base&&) = default;
+};
+
+// _MoveConstructible Specialisation
+
+template <bool _CopyAssignable,
+          bool _MoveAssignable,
+          bool _TiviallyDestructible,
+          class... _Types>
+class __variant_base<false,true,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...> :
+public __variant_base<false,false,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...>
+{
+  using __base =
+  __variant_base<false,false,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...>;
+
+protected:
+
+  using __base::__base;
+  using __base::__move;
+  using __base::__m_index;
+
+  __variant_base(__variant_base&& __v) :
+      __base{}
+  {
+    static_assert(conjunction_v<is_copy_constructible<_Types> ...>,
+      R"(This function shall not participate in overload resolution
+      unless is_copy_constructible_v<_Ti> is true for all i.)");
+    if(__v.__m_index != variant_npos)
+    {
+      __move(forward<__variant_base>(__v));
+      __v.__m_index = variant_npos;
+    }
+  }
+
+  __variant_base& operator=(const __variant_base&) = default;
+  __variant_base& operator=(__variant_base&&) = default;
+};
+
+// _CopyConstructible Specialisation
+
+template <bool _MoveConstructible,
+          bool _CopyAssignable,
+          bool _MoveAssignable,
+          bool _TiviallyDestructible,
+          class... _Types>
+class __variant_base<true,_MoveConstructible,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...> :
+public __variant_base<false,_MoveConstructible,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...>
+{
+  using __base =
+  __variant_base<false,_MoveConstructible,_CopyAssignable,_MoveAssignable,_TiviallyDestructible,_Types...>;
+
+protected:
+
+  using __base::__base;
+  using __base::__copy;
+
+  __variant_base(const __variant_base& __v) :
+      __base{}
+  {
+    static_assert(conjunction_v<is_move_constructible<_Types> ...>,
+      R"(This function shall not participate in overload resolution
+      unless is_move_constructible_v<_Ti> is true for all i.)");
+    if(__v.__m_index != variant_npos)
+      __copy(__v);
+  }
+
+  __variant_base(__variant_base&&) = default;
+  __variant_base& operator=(const __variant_base&) = default;
+  __variant_base& operator=(__variant_base&&) = default;
+};
+
+// Some helper templates
+
+template < template <class> class _Test, class... _Types>
+struct __first_or_last;
+
+template < template <class> class _Test, class... _Types>
+using __first_or_last_t = typename __first_or_last<_Test, _Types...>::type;
+
+template < template <class> class _Test, class _T>
+struct __first_or_last<_Test, _T> {using type = _T;};
+
+template < template <class> class _Test, class _T, class... _Types>
+struct __first_or_last<_Test, _T, _Types...>
+{
+  static constexpr _Test<_T> test;
+  using type = conditional_t<!test, _T, __first_or_last_t<_Test, _Types...>>;
+};
+
+template <typename _T>
+struct __argument {using type = _T;};
+
+template <typename... _Ts>
+struct __imaginary_function; // undefined
+
+template <>
+struct __imaginary_function<> {constexpr void operator()() const noexcept;};
+
+template <typename... _Ts>
+struct __imaginary_function<void, _Ts...> : __imaginary_function<_Ts...>
+{
+  using __imaginary_function<_Ts...>::operator();
+  constexpr __argument<void> operator()() const noexcept;
+};
+
+template <typename _T, typename... _Ts>
+struct __imaginary_function<_T, _Ts...> : __imaginary_function<_Ts...>
+{
+  using __imaginary_function<_Ts...>::operator();
+  constexpr __argument<_T> operator()(_T) const noexcept;
+};
+
+template <class _T, class... _Types>
+using __imaginary_function_argument_t =
+  typename result_of_t<__imaginary_function<_Types...>(_T)>::type;
+
+template <class _T, class... _Types>
+struct __count; // undefined
+
+template <class _T, class... _Types>
+constexpr size_t __count_v = __count<_T, _Types...>::value;
+
+template <class _T,class _U>
+struct __count<_T,_U> :
+  integral_constant<size_t, is_same_v<_T,_U >> {};
+
+template <class _T, class _U, class... _Types>
+struct __count<_T, _U, _Types...> :
+  integral_constant<size_t, is_same_v<_T,_U > + __count_v<_T, _Types...>> {};
+
+template <class _T, class... _Types>
+struct __is_imaginary_function_well_formed :
+  bool_constant<(__count_v<_T, _Types...> == 1)> {};
+
+template <class _T, class... _Types>
+constexpr bool __is_imaginary_function_well_formed_v =
+  __is_imaginary_function_well_formed<_T, _Types...>::value;
+
+// 20.7.2, variant of value types
+template <class... _Types>
+class variant;
+
+// 20.7.3, variant helper classes
+template <class _T> struct variant_size; // undefined
+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 _T> constexpr size_t variant_size_v = variant_size<_T>::value;
+
+template <class... _Types>
+struct variant_size<variant<_Types...>> :
+  integral_constant<size_t, sizeof...(_Types)> {};
+
+template <size_t _I, class _T> struct variant_alternative; // undefined
+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 _T>
+using variant_alternative_t = typename variant_alternative<_I, _T>::type;
+
+template <size_t _I, class... _Types>
+struct variant_alternative<_I, variant<_Types...>>
+{
+  static_assert(_I < sizeof...(_Types), "variant_alternative index out of range");
+  using type = tuple_element_t<_I, tuple<_Types...>>;
+};
+
+// 20.7.4, value access
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept
+{
+  return __variant_index_v<_T, _Types...> == __v.index();
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_I, variant<_Types...>>&
+get(variant<_Types...>& __v)
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return get<_T>(__v);
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_I, variant<_Types...>>&&
+get(variant<_Types...>&& __v)
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return move(get<_T>(__v));
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_I, variant<_Types...>> const&
+get(const variant<_Types...>& __v)
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return get<_T>(__v);
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr variant_alternative_t<_I, variant<_Types...>> const&&
+get(const variant<_Types...>&& __v)
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return move(get<_T>(__v));
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr _T&
+get(variant<_Types...>& __v)
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(__v))
+  return __v.__m_storage.template get<_T>();
+  throw bad_variant_access{};
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr _T&&
+get(variant<_Types...>&& __v)
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(__v))
+  return __v.__m_storage.template get<_T>();
+  throw bad_variant_access{};
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr const _T&
+get(const variant<_Types...>& __v)
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(__v))
+  return __v.__m_storage.template get<_T>();
+  throw bad_variant_access{};
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr const _T&&
+get(const variant<_Types...>&& __v)
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(__v))
+  return __v.__m_storage.template get<_T>();
+  throw bad_variant_access{};
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<variant_alternative_t<_I, variant<_Types...>>>
+get_if(variant<_Types...>* __v) noexcept
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return get_if<_T>(__v);
+};
+
+template <size_t _I, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<const variant_alternative_t<_I, variant<_Types...>>>
+get_if(const variant<_Types...>* __v) noexcept
+{
+  using _T = variant_alternative_t<_I, variant<_Types...>>;
+  return get_if<_T>(__v);
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<_T>
+get_if(variant<_Types...>* __v) noexcept
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(*__v))
+  return &(__v->__m_storage.template get<_T>());
+  return nullptr;
+};
+
+template <class _T, class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr add_pointer_t<const _T>
+get_if(const variant<_Types...>* __v) noexcept
+{
+  static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+  if(holds_alternative<_T>(*__v))
+  return &(__v->__m_storage.template get<_T>());
+  return nullptr;
+};
+
+template <class... _Types>
+using __comparison_function_type =
+  bool(*)(const variant<_Types...>&, const variant<_Types...>&);
+
+template <class _T, class... _Types>
+constexpr bool
+__variant_equal_to(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return get<_T>(__v) == get<_T>(__w);
+}
+
+template <class... _Types>
+constexpr array<__comparison_function_type<_Types...>, sizeof...(_Types)>
+__make_equal_to_array()
+{
+  return { __variant_equal_to<_Types, _Types...> ... };
+}
+
+template <class _T, class... _Types>
+constexpr bool
+__variant_less(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return get<_T>(__v) < get<_T>(__w);
+}
+
+template <class... _Types>
+constexpr array<__comparison_function_type<_Types...>, sizeof...(_Types)>
+__make_less_array()
+{
+  return { __variant_less<_Types, _Types...> ... };
+}
+
+template <class _Visitor, class... _Variants>
+using __invoker_function_type = auto(*)(_Visitor&&, _Variants&&...)
+-> result_of_t<_Visitor(variant_alternative_t<0, decay_t<_Variants>> ...)>;
+
+template <size_t _I, class _Visitor, class... _Variants>
+auto
+__alternative_invoker(_Visitor&& __vis, _Variants&&... __vars)
+{
+    return invoke(forward<_Visitor>(__vis), get<_I>(forward<_Variants>(__vars)) ...);
+}
+
+template <class _Visitor, class... _Variants, size_t... _I>
+constexpr array<__invoker_function_type<_Visitor, _Variants...>, sizeof...(_I)>
+__make_invoker_array(index_sequence<_I...>)
+{
+    return { __alternative_invoker<_I, _Visitor, _Variants...> ... };
+}
+
+template <class _Visitor, class... _Types, class... _Variants>
+auto
+__variant_invoke(_Visitor&& __vis, variant<_Types...>& __var, _Variants&&... __vars)
+{
+  constexpr auto __array =
+    __make_invoker_array<_Visitor, variant<_Types...>, _Variants...>
+    (index_sequence_for<_Types...>{});
+
+  return __array[__var.index()](forward<_Visitor>(__vis),
+                              forward<variant<_Types...>>(__var),
+                              forward<_Variants>(__vars)...);
+}
+
+template <class _Visitor, class... _Types, class... _Variants>
+auto
+__variant_invoke(_Visitor&& __vis, const variant<_Types...>& __var, _Variants&&... __vars)
+{
+  constexpr auto __array =
+    __make_invoker_array<_Visitor, const variant<_Types...>&, _Variants...>
+    (index_sequence_for<_Types...>{});
+
+  return __array[__var.index()](forward<_Visitor>(__vis), __var, __vars...);
+}
+
+template <class... _Types>
+using __swap_function_type = void(*)(variant<_Types...>&, variant<_Types...>&);
+
+template <class _T, class... _Types>
+constexpr void
+__swap(variant<_Types...>& __v, variant<_Types...>& __w) noexcept
+{
+  swap(get<_T>(__v), get<_T>(__w));
+}
+
+template <class... _Types>
+constexpr array<__swap_function_type<_Types...>, sizeof...(_Types)>
+__make_swap_array()
+{
+  return { __swap<_Types, _Types...> ... };
+}
+
+template <class... _Types>
+using __hash_function_type = size_t(*)(const variant<_Types...>&);
+
+template <class _T, class... _Types>
+constexpr size_t __hash(const variant<_Types...>& __v)
+{
+  return hash<_T>{}(get<_T>(__v));
+}
+
+template <class... _Types>
+constexpr array<__hash_function_type<_Types...>, sizeof...(_Types)>
+__make_hash_array()
+{
+  return { __hash<_Types, _Types...> ... };
+}
+
+// 20.7.5, relational operators
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  constexpr auto __equals_to = __make_equal_to_array<_Types...>();
+  return (__v.valueless_by_exception() && __w.valueless_by_exception()) ||
+         (__v.index() == __w.index() && __equals_to[__v.index()](__v,__w));
+};
+
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return !(__v == __w);
+};
+
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  constexpr auto __less = __make_less_array<_Types...>();
+  return (__v.index() < __w.index()) || (__v.index() == __w.index() &&
+          !__v.valueless_by_exception() && __less[__v.index()](__v,__w));
+};
+
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return __w < __v;
+}
+
+template <class... _Types>
+constexpr bool operator<=(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return !(__v > __w);
+}
+
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(const variant<_Types...>& __v, const variant<_Types...>& __w)
+{
+  return !(__v < __w);
+}
+
+// 20.7.6, visitation
+template <class _Visitor, class... _Variants>
+_LIBCPP_INLINE_VISIBILITY
+constexpr auto visit(_Visitor&& __vis, _Variants&&... __vars)
+{
+  return __variant_invoke(forward<_Visitor>(__vis), forward<_Variants>(__vars) ...);
+};
+
+// 20.7.7, class monostate
+struct monostate {};
+
+// 20.7.8, monostate relational operators
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<(monostate, monostate) noexcept {return false;};
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>(monostate, monostate) noexcept {return false;};
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator<=(monostate, monostate) noexcept {return true;};
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator>=(monostate, monostate) noexcept {return true;};
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator==(monostate, monostate) noexcept {return true;};
+_LIBCPP_INLINE_VISIBILITY
+constexpr bool operator!=(monostate, monostate) noexcept {return false;};
+
+// 20.7.9, specialized algorithms
+template <class... _Types>
+_LIBCPP_INLINE_VISIBILITY
+void swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
+  noexcept(conjunction_v<is_nothrow_move_constructible<_Types> ...> &&
+           conjunction_v<is_nothrow_swappable<_Types> ...>)
+{
+  __lhs.swap(__rhs);
+};
+
+template <class... _Types>
+class variant : public __variant_base<conjunction_v<is_copy_constructible<_Types>...>,
+                                      conjunction_v<is_move_constructible<_Types>...>,
+                                      conjunction_v<is_copy_assignable<_Types>...>,
+                                      conjunction_v<is_move_assignable<_Types>...>,
+                                      conjunction_v<is_trivially_destructible<_Types>...>,
+                                      _Types...>
+{
+  using __base = __variant_base<conjunction_v<is_copy_constructible<_Types>...>,
+                                conjunction_v<is_move_constructible<_Types>...>,
+                                conjunction_v<is_copy_assignable<_Types>...>,
+                                conjunction_v<is_move_assignable<_Types>...>,
+                                conjunction_v<is_trivially_destructible<_Types>...>,
+                                _Types...>;
+  using __base::__copy;
+  using __base::__move;
+  using __base::__construct;
+  using __base::__destroy;
+  using __base::__m_index;
+
+public:
+
+  // 20.7.2.1, constructors
+
+  template <class _T0 = variant_alternative_t<0,variant>,
+            enable_if_t<is_default_constructible_v<_T0>, int> = 0>
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr
+  variant() noexcept(is_nothrow_default_constructible_v<_T0>) :
+    __base{in_place_type<_T0>}
+  {
+    static_assert(is_default_constructible_v<_T0>,
+      R"(This function shall not participate in overload resolution
+      unless is_default_constructible_v<_T0> is true.)");
+  };
+
+  template <class _T0 = variant_alternative_t<0,variant>,
+            enable_if_t<!is_default_constructible_v<_T0>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr
+  variant() noexcept(is_nothrow_default_constructible_v<_T0>) = delete;
+
+  // We'll inherit the copy and move constructors from the __base
+
+  _LIBCPP_INLINE_VISIBILITY
+  variant(const variant&) = default;
+
+  _LIBCPP_INLINE_VISIBILITY
+  variant(variant&&) = default;
+
+  template <class _T,
+            class _Tj = __imaginary_function_argument_t<_T, _Types...>,
+            enable_if_t<conjunction_v<negation<is_same<decay_t<_T>,variant>>,
+                                      is_constructible<_Tj, _T>,
+                                      __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr
+  variant(_T&&  __t) noexcept(is_nothrow_constructible_v<_Tj, _T>) :
+      __base{in_place_type<_Tj>, forward<_T>(__t)}
+  {
+    static_assert(!is_same_v<decay_t<_T>,variant> &&
+                  is_constructible_v<_Tj, _T> &&
+                  __is_imaginary_function_well_formed_v<_Tj, _Types...>,
+      R"(This function shall not participate in overload resolution
+      unless is_same_v<decay_t<_T>, variant> is false,
+      unless is_constructible_v<_Tj, _T> is true, and
+      unless the expression FUN(std::forward<_T>(__t))
+      (with FUN being the above-mentioned set of imaginary functions)
+      is well formed.)");
+  };
+
+  template <class _T,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit
+  variant(in_place_type_t<_T>, _Args&&... __args) :
+    __base{in_place_type<_T>, forward<_Args>(__args)...}
+  {};
+
+  template <class _T,
+            class _U,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T, initializer_list<_U>&, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit
+  variant(in_place_type_t<_T>, initializer_list<_U> __il, _Args&&... __args) :
+    __base{in_place_type<_T>, forward<initializer_list<_U>>(__il), forward<_Args>(__args)...}
+  {};
+
+  template <size_t _I,
+            class... _Args,
+            class _T = variant_alternative_t<_I, variant>,
+            enable_if_t<is_constructible_v<_T, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit
+  variant(in_place_index_t<_I>, _Args&&... __args) :
+    __base{in_place_type<_T>, forward<_Args>(__args)...}
+  {};
+
+  template <size_t _I,
+            class _U,
+            class... _Args,
+            class _Ti = variant_alternative_t<_I, variant>,
+            enable_if_t<is_constructible_v<_Ti, initializer_list<_U>&, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit
+  variant(in_place_index_t<_I>, initializer_list<_U> __il, _Args&&... __args) :
+    __base{in_place_type<_Ti>, forward<initializer_list<_U>>(__il), forward<_Args>(__args)...}
+  {};
+
+  // allocator-extended constructors
+  template <class _Alloc,
+            class _T0 = variant_alternative_t<0,variant>,
+            enable_if_t<is_constructible_v<_T0>, int> = 0>
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a) :
+      __base{allocator_arg, __a, in_place_type<_T0>}
+  {
+    static_assert(is_default_constructible_v<_T0>,
+      R"(This function shall not participate in overload resolution
+      unless is_default_constructible_v<_T0> is true.)");
+  };
+
+  template <class _Alloc,
+            class _TN = __first_or_last_t<is_copy_constructible,_Types...>,
+            enable_if_t<is_copy_constructible_v<_TN>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, const variant& __v) :
+      __base{}
+  {
+    static_assert(conjunction_v<is_copy_constructible<_Types> ...>,
+      R"(This function shall not participate in overload resolution
+      unless is_copy_constructible_v<_Ti> is true for all i.)");
+    if(!__v.valueless_by_exception())
+      __copy(allocator_arg, __a, __v);
+  }
+
+  template <class _Alloc,
+            class _TN = __first_or_last_t<is_move_constructible,_Types...>,
+            enable_if_t<is_move_constructible_v<_TN>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, variant&& __v) :
+      __base{}
+  {
+    static_assert(conjunction_v<is_move_constructible<_Types> ...>,
+      R"(This function shall not participate in overload resolution
+        unless is_move_constructible_v<_Ti> is true for all i.)");
+    if(!__v.valueless_by_exception())
+      __move(allocator_arg, __a, forward<variant>(__v));
+  }
+
+  template <class _Alloc,
+            class _T,
+            class _Tj = __imaginary_function_argument_t<_T, _Types...>,
+            enable_if_t<conjunction_v<negation<is_same<decay_t<_T>,variant>>,
+                                             is_constructible<_Tj, _T>,
+                                             __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, _T&&  __t) :
+      __base{allocator_arg, __a, in_place_type<_Tj>, forward<_T>(__t)}
+  {
+    static_assert(!is_same_v<decay_t<_T>,variant> &&
+                  is_constructible_v<_Tj, _T> &&
+                  __is_imaginary_function_well_formed_v<_Tj, _Types...>,
+      R"(This function shall not participate in overload resolution
+      unless is_same_v<decay_t<_T>, variant> is false,
+      unless is_constructible_v<_Tj, _T> is true, and
+      unless the expression FUN( std::forward<_T>(__t))
+      (with FUN being the above-mentioned set of imaginary functions)
+      is well formed.)");
+  };
+
+  template <class _Alloc,
+            class _T,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) :
+      __base{allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...}
+  {};
+
+  template <class _Alloc,
+            class _T,
+            class _U,
+            class... _Args,
+            enable_if_t<is_constructible_v<_T, initializer_list<_U>&, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a,
+          in_place_type_t<_T>, initializer_list<_U> __il, _Args&&... __args) :
+    __base{allocator_arg, __a,
+           in_place_type<_T>, forward<initializer_list<_U>>(__il), forward<_Args>(__args) ...}
+  {};
+
+  template <class _Alloc,
+            size_t _I,
+            class... _Args,
+            class _T = variant_alternative_t<_I, variant>,
+            enable_if_t<is_constructible_v<_T, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_I>, _Args&&... __args) :
+    __base{allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...}
+  {};
+
+  template <class _Alloc,
+            size_t _I,
+            class _U,
+            class... _Args,
+            class _T = variant_alternative_t<_I, variant>,
+            enable_if_t<is_constructible_v<_T, initializer_list<_U>&, _Args...>, int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_I>, initializer_list<_U> __il, _Args&&... __args) :
+    __base{allocator_arg, __a, in_place_type<_T>, forward<initializer_list<_U>>(__il), forward<_Args>(__args) ...}
+  {};
+
+  // 20.7.2.2, destructor
+  _LIBCPP_INLINE_VISIBILITY
+  ~variant() = default;
+
+  // 20.7.2.3, assignment
+  _LIBCPP_INLINE_VISIBILITY
+  variant& operator=(const variant&) = default;
+
+  _LIBCPP_INLINE_VISIBILITY
+  variant& operator=(variant&&) = default;
+
+  template <class _T,
+            class _Tj = __imaginary_function_argument_t<_T, _Types...>,
+            enable_if_t<conjunction_v<negation<is_same<decay_t<_T>,variant>>,
+                                      is_assignable_v<_Tj&, _T>,
+                                      is_constructible<_Tj, _T>,
+                                      __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0
+            >
+  _LIBCPP_INLINE_VISIBILITY
+  variant& operator=(_T&& __rhs)
+    noexcept(conjunction_v<is_nothrow_assignable<_Types&, _Types>...,
+                           is_nothrow_constructible<_Types&, _Types>...>)
+  {
+    static_assert(!is_same_v<decay_t<_T>, variant> &&
+                  is_assignable_v<_Tj&, _T> && is_constructible_v<_Tj, _T> &&
+                  __is_imaginary_function_well_formed_v<_Tj, _Types...>,
+      R"(This function shall not participate in overload resolution
+         unless is_same_v<decay_t<_T>, variant> is false,
+         unless is_assignable_v<_Tj&, _T> && is_constructible_v<_Tj, _T> is true, and
+         unless the expression FUN (std::forward<_T>(__t))
+         (with FUN being the above-mentioned set of imaginary functions) is well formed.)");
+    if(!valueless_by_exception())
+      __destroy();
+    __construct(in_place_type<_Tj>, forward<_T>(__rhs));
+    return *this;
+  };
+
+  // 20.7.2.4, modifiers
+
+  template <class _T, class... _Args>
+  _LIBCPP_INLINE_VISIBILITY
+  void emplace(_Args&&... __args)
+  {
+    static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+    static_assert(!is_lvalue_reference_v<_T>, "references cannot be reassigned");
+    if(!valueless_by_exception())
+      __destroy();
+    __construct(in_place_type<_T>, forward<_Args>(__args)...);
+  };
+
+  template <class _T, class _U, class... _Args>
+  _LIBCPP_INLINE_VISIBILITY
+  void emplace(initializer_list<_U> __il, _Args&&... __args)
+  {
+    static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative");
+    static_assert(!is_lvalue_reference_v<_T>, "references cannot be reassigned");
+    if(!valueless_by_exception())
+      __destroy();
+    __construct(in_place_type<_T>, __il, forward<_Args>(__args)...);
+  };
+
+  template <size_t _I, class... _Args>
+  _LIBCPP_INLINE_VISIBILITY
+  void emplace(_Args&&... __args)
+  {
+    using _T = variant_alternative_t<_I, variant>;
+    emplace<_T>(forward<_Args>(__args)...);
+  };
+
+  template <size_t _I, class _U, class... _Args>
+  _LIBCPP_INLINE_VISIBILITY
+  void emplace(initializer_list<_U> __il, _Args&&... __args)
+  {
+    using _T = variant_alternative_t<_I, variant>;
+    emplace<_T>(__il, forward<_Args>(__args)...);
+  };
+
+  // 20.7.2.5, value status
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr bool valueless_by_exception() const noexcept
+  {
+    return __m_index == variant_npos;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr size_t index() const noexcept
+  {
+    return __m_index;
+  };
+
+  // 20.7.2.6, swap
+  _LIBCPP_INLINE_VISIBILITY
+  void swap(variant& __rhs)
+    noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...,
+                           is_nothrow_swappable<_Types>...>)
+  {
+    constexpr auto __swap = __make_swap_array<_Types...>();
+    variant& __lhs = *this;
+    if(__lhs.valueless_by_exception() && __rhs.valueless_by_exception())
+      return;
+    if(__lhs.__m_index == __rhs.__m_index)
+      __swap[__lhs.__m_index](__lhs,__rhs);
+    else
+    {
+      variant __tmp{__rhs};
+      __rhs.__m_index = __lhs.__m_index;
+      __swap[__lhs.__m_index](__rhs,__lhs);
+      __lhs.__m_index = __tmp.__m_index;
+      __swap[__lhs.__m_index](__lhs,__tmp);
+    }
+  }
+};
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// 20.7.11, hash support
+// template <class _T> struct hash;
+template <class... _Types>
+struct hash<_VSTD_LFTS::variant<_Types...>>
+{
+  _LIBCPP_INLINE_VISIBILITY
+  size_t operator()(const _VSTD_LFTS::variant<_Types...>& __v) noexcept
+  {
+    constexpr auto __hash = _VSTD_LFTS::__make_hash_array<_Types...>();
+    return __hash[__v.index()](__v);
+  }
+};
+
+template <>
+struct hash<_VSTD_LFTS::monostate>
+{
+  _LIBCPP_INLINE_VISIBILITY
+  size_t operator()(_VSTD_LFTS::monostate) noexcept
+  {
+    return 42;
+  }
+};
+
+// 20.7.12, allocator-related traits
+// template <class _T, class _Alloc> struct uses_allocator;
+
+template <class... _Types, class _Alloc>
+struct uses_allocator<_VSTD_LFTS::variant<_Types...>, _Alloc> : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 14
+
+#endif // _LIBCPP__EXPERIMENTAL_VARIANT

test/std/experimental/variant/variant.general/variant.hash/hash.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo{};
+
+int main()
+{
+  std::hash<variant<unsigned,double,char>> hv;
+  std::hash<unsigned> hu;
+  std::hash<double> hd;
+  std::hash<char> hc;
+
+  variant<unsigned,double,char> v;
+
+  v = 123u;
+  assert(hv(v) == hu(123u));
+
+  v = 123.456;
+  assert(hv(v) == hd(123.456));
+
+  v = 'R';
+  assert(hv(v) == hc('R'));
+}

test/std/experimental/variant/variant.general/variant.helper/helper.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <string>
+#include <vector>
+
+using std::experimental::variant;
+using std::experimental::variant_size_v;
+using std::experimental::variant_alternative_t;
+
+int main()
+{
+  using V = variant<unsigned, double, char, float, std::string, std::vector<int>>;
+  static_assert(variant_size_v<V> == 6);
+  static_assert(std::is_same_v<variant_alternative_t<5, V>, std::vector<int>>);
+}

test/std/experimental/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::bad_variant_access;
+
+int main()
+{
+  try
+  {
+    variant<unsigned,double,char> v{9u};
+    get<char>(v);
+    assert(false);
+  }
+  catch(bad_variant_access& bad)
+  {}
+
+    try
+    {
+      variant<unsigned,double,char> v{9u};
+      get<2>(v);
+      assert(false);
+    }
+    catch(bad_variant_access& bad)
+    {}
+
+      try
+      {
+        variant<unsigned,double,char> v{9u};
+        get<unsigned>(v);
+      }
+      catch(bad_variant_access& bad)
+      {
+        assert(false);
+      }
+
+      try
+      {
+        variant<unsigned,double,char> v{9u};
+        get<0>(v);
+      }
+      catch(bad_variant_access& bad)
+      {
+        assert(false);
+      }
+    }

test/std/experimental/variant/variant.general/variant.get/get.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::get_if;
+
+void test_constexpr_get()
+{
+  using test = variant<bool,int,double>;
+
+  constexpr test t1{};
+  static_assert(get<0>(t1)    == false);
+  static_assert(get<bool>(t1) == false);
+
+  constexpr test t2{true};
+  static_assert(get<0>(t2)   == true);
+  static_assert(get<bool>(t2) == true);
+
+  constexpr test t3{11};
+  static_assert(get<1>(t3)   == 11);
+  static_assert(get<int>(t3) == 11);
+
+  constexpr test t4{22.22};
+  static_assert(get<2>(t4)      == 22.22);
+  static_assert(get<double>(t4) == 22.22);
+
+  static_assert(get<2>(test{3.3}) == 3.3);
+}
+
+void test_constexpr_get_if()
+{
+  using test = variant<bool,int,double>;
+
+  constexpr test t1{};
+  static_assert(get_if<0>(&t1)      != nullptr);
+  static_assert(get_if<bool>(&t1)   != nullptr);
+  static_assert(get_if<1>(&t1)      == nullptr);
+  static_assert(get_if<int>(&t1)    == nullptr);
+  static_assert(get_if<2>(&t1)      == nullptr);
+  static_assert(get_if<double>(&t1) == nullptr);
+
+  constexpr test t2{true};
+  static_assert(*get_if<0>(&t2)      == true);
+  static_assert(get_if<0>(&t2)      != nullptr);
+  static_assert(get_if<bool>(&t2)   != nullptr);
+  static_assert(get_if<1>(&t2)      == nullptr);
+  static_assert(get_if<int>(&t2)    == nullptr);
+  static_assert(get_if<2>(&t2)      == nullptr);
+  static_assert(get_if<double>(&t2) == nullptr);
+
+  constexpr test t3{11};
+  static_assert(*get_if<1>(&t3)     == 11);
+  static_assert(get_if<0>(&t3)      == nullptr);
+  static_assert(get_if<bool>(&t3)   == nullptr);
+  static_assert(get_if<1>(&t3)      != nullptr);
+  static_assert(get_if<int>(&t3)    != nullptr);
+  static_assert(get_if<2>(&t3)      == nullptr);
+  static_assert(get_if<double>(&t3) == nullptr);
+
+  constexpr test t4{22.22};
+  static_assert(*get_if<2>(&t4)     == 22.22);
+  static_assert(get_if<0>(&t4)      == nullptr);
+  static_assert(get_if<bool>(&t4)   == nullptr);
+  static_assert(get_if<1>(&t4)      == nullptr);
+  static_assert(get_if<int>(&t4)    == nullptr);
+  static_assert(get_if<2>(&t4)      != nullptr);
+  static_assert(get_if<double>(&t4) != nullptr);
+}
+
+void test_get()
+{
+  using test = variant<bool,int,double,std::string>;
+
+  test t1{false};
+  get<0>(t1) = true;
+  assert(get<0>(t1) == true);
+
+  test t2{std::string{}};
+  get<3>(t2) = "ABCDEFG";
+  assert(get<3>(t2) == "ABCDEFG");
+
+  const test t3{1};
+  assert(get<1>(t3) == 1);
+}
+
+void test_get_if()
+{
+  using test = variant<bool,int,double,std::string>;
+
+  test t1{false};
+  *get_if<0>(&t1) = true;
+  assert(*get_if<0>(&t1) == true);
+
+  test t2{std::string{}};
+  *get_if<3>(&t2) = "ABCDEFG";
+  assert(*get_if<3>(&t2) == "ABCDEFG");
+
+  const test t3{1};
+  assert(*get_if<1>(&t3) == 1);
+}
+
+int main()
+{
+  test_constexpr_get();
+  test_constexpr_get_if();
+  test_get();
+  // test_get_if();
+}

test/std/experimental/variant/variant.general/variant.monostate/monostate.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <string>
+#include <vector>
+
+using std::experimental::variant;
+using std::experimental::monostate;
+using std::experimental::holds_alternative;
+
+struct foo
+{
+  foo() = delete;
+  foo(const foo&) = delete;
+  foo(foo&&) = delete;
+  foo(bool){}
+  virtual ~foo(){}
+};
+
+int main()
+{
+  variant<monostate,foo> v;
+  assert(holds_alternative<monostate>(v));
+  v.emplace<foo>(true);
+  assert(holds_alternative<foo>(v));
+}

test/std/experimental/variant/variant.general/variant.relops/equal_to.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+void test_comple_time_equal_to()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{1};
+  constexpr test t2{1};
+  constexpr test t3{true};
+  static_assert(t1 == t2);
+  static_assert(!(t1 != t2));
+  static_assert(!(t1 == t3));
+  static_assert(t2 != t3);
+}
+
+int main()
+{
+  test_comple_time_equal_to();
+}

test/std/experimental/variant/variant.general/variant.specalg/swap.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::swap;
+
+struct foo{};
+
+int main()
+{
+  variant<float,unsigned,double,char> v1, v2;
+  v1 = 123456u;
+  v2 = 'A';
+  assert(get<1>(v1) == 123456u);
+  assert(get<3>(v2) == 'A');
+  swap<float,unsigned,double,char>(v1,v2);
+  assert(get<1>(v2) == 123456u);
+  assert(get<3>(v1) == 'A');
+}

test/std/experimental/variant/variant.general/variant.traits/uses_allocator.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include<experimental/variant>
+#include<string>
+
+using std::experimental::variant;
+using std::uses_allocator_v;
+
+int main()
+{
+  struct foo {};
+  static_assert(uses_allocator_v<variant<bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<std::string,bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo,bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo,std::string,bool>,std::allocator<char>>);
+}

test/std/experimental/variant/variant.general/variant.visit/visit.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <string>
+#include <chrono>
+#include <iostream>
+
+using std::experimental::variant;
+using std::experimental::monostate;
+using std::experimental::visit;
+
+using test = variant<bool,int,double,std::string>;
+
+struct visitor
+{
+  bool operator () (bool b1, bool b2, bool b3)
+  {
+    call = "bool";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (int i1, int i2, int i3)
+  {
+    call = "int";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (double d1, double d2, double d3)
+  {
+    call = "double";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (const std::string& str1, const std::string& str2, const std::string& str3)
+  {
+    call = "string";
+    std::cout << call << "\n";
+    return true;
+  }
+  std::string call;
+};
+
+void test_functor()
+{
+  visitor vis;
+  test var1, var2, var3;
+
+  var1 = var2 = var3 = true;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "bool");
+
+  var1 = var2 = var3 = 13;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "int");
+
+  var1 = var2 = var3 = 21.12;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "double");
+
+  var1 = var2 = var3 = std::string{};
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "string");
+}
+
+void test_lambda()
+{
+  std::string call;
+  test var1, var2;
+
+  var1 = var2 = true;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "x");
+
+  var1 = var2 = 13;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xx");
+
+  var1 = var2 = 21.12;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xxx");
+
+  var1 = var2 = std::string{"Hello!"};
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xxxx");
+}
+
+void test_complex()
+{
+  using type = variant<monostate,
+                      std::nullptr_t,
+                      double,
+                      std::string,
+                      bool,
+                      std::chrono::system_clock::time_point,
+                      long,
+                      long long
+  >;
+
+  const auto value = type{};
+
+  visit([](const auto& arg){return "pöö";}, value);
+}
+
+int main()
+{
+  test_functor();
+  test_lambda();
+  test_complex();
+}

test/std/experimental/variant/variant.variant/variant.assign/assignment.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include<experimental/variant>
+#include<string>
+#include<iostream>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+void test_copy_assign()
+{
+  variant<int,bool,std::string,double> v1, v2;
+
+  v1 = 21.12;
+  assert(get<double>(v1) == 21.12);
+  assert(get<3>(v1)   == 21.12);
+
+  v2 = v1;
+  assert(get<double>(v2) == 21.12);
+  assert(get<3>(v2)   == 21.12);
+}
+
+void test_move_assign()
+{
+  variant<int,bool,std::string,double> v;
+  v = variant<int,bool,std::string,double>{std::string{"rush"}};
+
+  assert(get<std::string>(v) == "rush");
+  assert(get<2>(v)           == "rush");
+}
+
+void test_alternative_assign()
+{
+  variant<int,bool,std::string,double> v;
+
+  v = 13;
+  assert(get<int>(v) == 13);
+  assert(get<0>(v)   == 13);
+
+  v = false;
+  assert(get<bool>(v) == false);
+  assert(get<1>(v)    == false);
+
+  v = std::string{"abc"};
+  assert(get<std::string>(v) == "abc");
+  assert(get<2>(v)           == "abc");
+
+  v = 21.12;
+  assert(get<double>(v) == 21.12);
+  assert(get<3>(v)      == 21.12);
+}
+
+int main()
+{
+  test_copy_assign();
+  test_move_assign();
+  test_alternative_assign();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo& operator = (const foo&) = default;
+};
+
+struct bar
+{
+  bar& operator = (const bar&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_copy_assignable_v<variant<foo>>);
+  static_assert(std::is_copy_assignable_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_copy_assignable_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_copy_assignable_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_copy_assignable_v<variant<bar>>);
+  static_assert(!std::is_copy_assignable_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_copy_assignable_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_copy_assignable_v<variant<int,bool,bar,double>>);
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo& operator = (foo&&) = default;
+};
+
+struct bar
+{
+  bar& operator = (bar&&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_move_assignable_v<variant<foo>>);
+  static_assert(std::is_move_assignable_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_move_assignable_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_move_assignable_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_move_assignable_v<variant<bar>>);
+  static_assert(!std::is_move_assignable_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_move_assignable_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_move_assignable_v<variant<int,bool,bar,double>>);
+}

test/std/experimental/variant/variant.variant/variant.ctor/allocators.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <vector>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+struct foo
+{
+  foo(const foo&) = default;
+  foo(foo&&) = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  bar(const bar&) = delete;
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  // Default
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, foo>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, std::allocator<char>, bar>);
+
+  // Copy
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, variant<int,foo>&>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, std::allocator<char>, variant<int,bar>&>);
+
+  // Move
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, variant<int,foo>&&>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, const std::allocator<char>&, variant<int,bar>&&>);
+}
+
+void test_constructors()
+{
+  using variant = variant<bool,int,double,std::vector<int>,std::string>;
+  std::allocator<char> a;
+
+  variant v1{std::allocator_arg_t{}, a};
+  assert(v1.index() == 0);
+  assert(get<0>(v1) == false);
+
+  variant v2{std::allocator_arg_t{}, a, 1};
+  assert(v2.index() == 1);
+  assert(get<1>(v2) == 1);
+
+  variant v3{std::allocator_arg_t{}, a, 2.2};
+  assert(v3.index() == 2);
+  assert(get<2>(v3) == 2.2);
+
+  variant v4{std::allocator_arg_t{}, a, std::in_place_type<std::vector<int>>, {1,2,3,4,5,6,7}};
+  assert(v4.index() == 3);
+  assert(get<3>(v4).size() == 7);
+
+  variant v5{std::allocator_arg_t{}, a, std::in_place_index<3>, {1,2,3,4,5,6,7,8}};
+  assert(v5.index() == 3);
+  assert(get<3>(v5).size() == 8);
+
+  variant v6{std::allocator_arg_t{}, a, std::in_place_type<std::string>, "foo"};
+  assert(v6.index() == 4);
+  assert(get<4>(v6) == "foo");
+
+  variant v7{std::allocator_arg_t{}, a, std::in_place_index<4>, "bar"};
+  assert(v7.index() == 4);
+  assert(get<4>(v7) == "bar");
+
+  variant v8{std::allocator_arg_t{}, a, std::in_place_type<std::string>, {'a','b','c','d'}};
+  assert(v8.index() == 4);
+  assert(get<4>(v8) == "abcd");
+
+  variant v9{std::allocator_arg_t{}, a, std::in_place_index<4>, std::size_t{10}, 'a'};
+  assert(v9.index() == 4);
+  assert(get<4>(v9) == "aaaaaaaaaa");
+
+  variant v22{std::allocator_arg_t{}, a, v2};
+  assert(v22.index() == 1);
+  assert(get<1>(v22) == 1);
+
+  variant v23{std::allocator_arg_t{}, a, std::move(v3)};
+  assert(v23.index() == 2);
+  assert(get<2>(v23) == 2.2);
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors();
+}

test/std/experimental/variant/variant.variant/variant.ctor/constexpr.fail.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <vector>
+#include <cassert>
+
+using std::experimental::variant;
+
+int main()
+{
+  // constexpr variant<bool,int,double,std::vector<int>> v1{};
+}

test/std/experimental/variant/variant.variant/variant.ctor/constexpr.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <vector>
+#include <cassert>
+
+using std::experimental::variant;
+
+int main()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{};
+  static_assert(t1.index() == 0);
+
+  constexpr test t2{true};
+  static_assert(t2.index() == 0);
+
+  constexpr test t3{1};
+  static_assert(t3.index() == 1);
+
+  constexpr test t4{2.2};
+  static_assert(t4.index() == 2);
+}

test/std/experimental/variant/variant.variant/variant.ctor/conversions.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo() noexcept = default;
+  foo(const foo&) noexcept = default;
+  foo(foo&&) noexcept = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  bar(const bar&) = delete;
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  // Well formed
+  static_assert(std::is_nothrow_constructible_v<variant<foo>,foo>);
+  static_assert(std::is_nothrow_constructible_v<variant<int,bool,double,foo>,int>);
+  static_assert(std::is_nothrow_constructible_v<variant<foo,int,bool,double>,bool>);
+
+  static_assert(!std::is_nothrow_constructible_v<variant<bar>,bar>);
+  static_assert(std::is_nothrow_constructible_v<variant<int,bool,double,bar>,double>);
+  static_assert(!std::is_nothrow_constructible_v<variant<bar,int,bool,double>,bar>);
+
+  static_assert(std::is_constructible_v<variant<std::string,foo>,std::string>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,const std::string&>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,std::string&&>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,char*>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,const char*>);
+
+  // Ill formed
+  static_assert(!std::is_nothrow_constructible_v<variant<bool,bool>,bool>);
+  static_assert(!std::is_nothrow_constructible_v<variant<std::string,std::string>,const char*>);
+}
+
+int main()
+{
+  test_type_traits();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo(const foo&) = default;
+};
+
+struct bar
+{
+  bar(const bar&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_copy_constructible_v<variant<foo>>);
+  static_assert(std::is_copy_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_copy_constructible_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_copy_constructible_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_copy_constructible_v<variant<bar>>);
+  static_assert(!std::is_copy_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_copy_constructible_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_copy_constructible_v<variant<int,bool,bar,double>>);
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::holds_alternative;
+
+struct foo
+{
+  foo() noexcept = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  ~bar() = default;
+};
+
+void test_type_traits()
+{
+  static_assert(std::is_default_constructible_v<variant<foo>>);
+  static_assert(std::is_default_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_default_constructible_v<variant<foo,int,bool,double>>);
+
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo,int,bool,double>>);
+
+  static_assert(!std::is_default_constructible_v<variant<bar>>);
+  static_assert(std::is_default_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_default_constructible_v<variant<bar,int,bool,double>>);
+
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar,int,bool,double>>);
+
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo,bar>>);
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar,foo>>);
+}
+
+void test_constructors()
+{
+  constexpr variant<foo,int,bool,double> v1;
+  static_assert(v1.index() == 0);
+  static_assert(holds_alternative<foo>(v1));
+
+  constexpr variant<int,foo,bar,bool,double> v2;
+  static_assert(v2.index() == 0);
+  static_assert(holds_alternative<int>(v2));
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <iostream>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::holds_alternative;
+using std::experimental::variant_npos;
+
+struct foo
+{
+  foo(foo&&) = default;
+};
+
+struct bar
+{
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  static_assert(std::is_move_constructible_v<variant<foo>>);
+  static_assert(std::is_move_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_move_constructible_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_move_constructible_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_move_constructible_v<variant<bar>>);
+  static_assert(!std::is_move_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_move_constructible_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_move_constructible_v<variant<int,bool,bar,double>>);
+}
+
+void test_constructors()
+{
+  variant<int,bool,double> v1{2.2};
+  assert(v1.index() == 2);
+  assert(holds_alternative<double>(v1));
+
+  variant<int,bool,double> v2{std::move(v1)};
+  assert(v2.index() == 2);
+  assert(holds_alternative<double>(v2));
+
+  std::cout << v1.index() << " vs " << variant_npos << std::endl;
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors();
+}

test/std/experimental/variant/variant.variant/variant.dtor/dtor.pss.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+
+using std::experimental::variant;
+
+static int count = 0;
+
+struct foo
+{
+  ~foo() = default;
+};
+
+struct bar
+{
+  bar() {++count;} // count == 1
+  ~bar(){++count;} // count == 2
+};
+
+int main()
+{
+  static_assert(std::is_trivially_destructible_v<variant<int,foo>> == true);
+
+  static_assert(std::is_trivially_destructible_v<variant<int,bar>> == false);
+
+  assert(count == 0);
+  {
+    variant<bar> v{std::in_place_type<bar>};
+    assert(count == 1);
+  }
+  assert(count == 2);
+}

test/std/experimental/variant/variant.variant/variant.mod/emplace.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+
+using std::experimental::variant;
+
+static int count = 0;
+
+struct foo
+{
+  foo(int) {++count;} // count == 1
+  ~foo(){++count;} // count == 2
+};
+
+int main()
+{
+  variant<bool,foo> v{};
+  assert(count == 0);
+  v.emplace<foo>(13);
+  assert(count == 1);
+  v.emplace<bool>(true);
+  assert(count == 2);
+  v.emplace<foo>(13);
+  assert(count == 3);
+  v.emplace<bool>(true);
+  assert(count == 4);
+}

test/std/experimental/variant/variant.variant/variant.status/index.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+void test_ctor()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{};
+  static_assert(t1.index() == 0);
+  constexpr test t2{true};
+  static_assert(t2.index() == 0);
+  constexpr test t3{1};
+  static_assert(t3.index() == 1);
+  constexpr test t4{2.2};
+  static_assert(t4.index() == 2);
+}
+
+void test_assign()
+{
+  using test = variant<bool,int,double>;
+  test t1{};
+  assert(t1.index() == 0);
+  t1 = true;
+  assert(t1.index() == 0);
+  t1 = 1;
+  assert(t1.index() == 1);
+  t1 = 2.2;
+  assert(t1.index() == 2);
+}
+
+int main()
+{
+  test_ctor();
+  test_assign();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+struct foo{};
+
+int main()
+{
+  variant<float,unsigned,foo,char> v1, v2;
+  v1 = 123456u;
+  v2 = 'A';
+  assert(get<1>(v1) == 123456u);
+  assert(get<3>(v2) == 'A');
+  v1.swap(v2);
+  assert(get<1>(v2) == 123456u);
+  assert(get<3>(v1) == 'A');
+}

test/std/experimental/variant/variant/variant.general/variant.hash/hash.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo{};
+
+int main()
+{
+  std::hash<variant<unsigned,double,char>> hv;
+  std::hash<unsigned> hu;
+  std::hash<double> hd;
+  std::hash<char> hc;
+
+  variant<unsigned,double,char> v;
+
+  v = 123u;
+  assert(hv(v) == hu(123u));
+
+  v = 123.456;
+  assert(hv(v) == hd(123.456));
+
+  v = 'R';
+  assert(hv(v) == hc('R'));
+}

test/std/experimental/variant/variant/variant.general/variant.helper/helper.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <vector>
+
+using std::experimental::variant;
+using std::experimental::variant_size_v;
+using std::experimental::variant_alternative_t;
+
+int main()
+{
+  using V = variant<unsigned, double, char, float, std::string, std::vector<int>>;
+  static_assert(variant_size_v<V> == 6);
+  static_assert(std::is_same_v<variant_alternative_t<5, V>, std::vector<int>>);
+}

test/std/experimental/variant/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::bad_variant_access;
+
+int main()
+{
+  try
+  {
+    variant<unsigned,double,char> v{9u};
+    get<char>(v);
+    assert(false);
+  }
+  catch(bad_variant_access& bad)
+  {}
+
+    try
+    {
+      variant<unsigned,double,char> v{9u};
+      get<2>(v);
+      assert(false);
+    }
+    catch(bad_variant_access& bad)
+    {}
+
+      try
+      {
+        variant<unsigned,double,char> v{9u};
+        get<unsigned>(v);
+      }
+      catch(bad_variant_access& bad)
+      {
+        assert(false);
+      }
+
+      try
+      {
+        variant<unsigned,double,char> v{9u};
+        get<0>(v);
+      }
+      catch(bad_variant_access& bad)
+      {
+        assert(false);
+      }
+    }

test/std/experimental/variant/variant/variant.general/variant.get/get.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::get_if;
+
+void test_constexpr_get()
+{
+  using test = variant<bool,int,double>;
+
+  constexpr test t1{};
+  static_assert(get<0>(t1)    == false);
+  static_assert(get<bool>(t1) == false);
+
+  constexpr test t2{true};
+  static_assert(get<0>(t2)   == true);
+  static_assert(get<bool>(t2) == true);
+
+  constexpr test t3{11};
+  static_assert(get<1>(t3)   == 11);
+  static_assert(get<int>(t3) == 11);
+
+  constexpr test t4{22.22};
+  static_assert(get<2>(t4)      == 22.22);
+  static_assert(get<double>(t4) == 22.22);
+
+  static_assert(get<2>(test{3.3}) == 3.3);
+}
+
+void test_constexpr_get_if()
+{
+  using test = variant<bool,int,double>;
+
+  constexpr test t1{};
+  static_assert(get_if<0>(&t1)      != nullptr);
+  static_assert(get_if<bool>(&t1)   != nullptr);
+  static_assert(get_if<1>(&t1)      == nullptr);
+  static_assert(get_if<int>(&t1)    == nullptr);
+  static_assert(get_if<2>(&t1)      == nullptr);
+  static_assert(get_if<double>(&t1) == nullptr);
+
+  constexpr test t2{true};
+  static_assert(*get_if<0>(&t2)      == true);
+  static_assert(get_if<0>(&t2)      != nullptr);
+  static_assert(get_if<bool>(&t2)   != nullptr);
+  static_assert(get_if<1>(&t2)      == nullptr);
+  static_assert(get_if<int>(&t2)    == nullptr);
+  static_assert(get_if<2>(&t2)      == nullptr);
+  static_assert(get_if<double>(&t2) == nullptr);
+
+  constexpr test t3{11};
+  static_assert(*get_if<1>(&t3)     == 11);
+  static_assert(get_if<0>(&t3)      == nullptr);
+  static_assert(get_if<bool>(&t3)   == nullptr);
+  static_assert(get_if<1>(&t3)      != nullptr);
+  static_assert(get_if<int>(&t3)    != nullptr);
+  static_assert(get_if<2>(&t3)      == nullptr);
+  static_assert(get_if<double>(&t3) == nullptr);
+
+  constexpr test t4{22.22};
+  static_assert(*get_if<2>(&t4)     == 22.22);
+  static_assert(get_if<0>(&t4)      == nullptr);
+  static_assert(get_if<bool>(&t4)   == nullptr);
+  static_assert(get_if<1>(&t4)      == nullptr);
+  static_assert(get_if<int>(&t4)    == nullptr);
+  static_assert(get_if<2>(&t4)      != nullptr);
+  static_assert(get_if<double>(&t4) != nullptr);
+}
+
+void test_get()
+{
+  using test = variant<bool,int,double,std::string>;
+
+  test t1{false};
+  get<0>(t1) = true;
+  assert(get<0>(t1) == true);
+
+  test t2{std::string{}};
+  get<3>(t2) = "ABCDEFG";
+  assert(get<3>(t2) == "ABCDEFG");
+
+  const test t3{1};
+  assert(get<1>(t3) == 1);
+}
+
+void test_get_if()
+{
+  using test = variant<bool,int,double,std::string>;
+
+  test t1{false};
+  *get_if<0>(&t1) = true;
+  assert(*get_if<0>(&t1) == true);
+
+  test t2{std::string{}};
+  *get_if<3>(&t2) = "ABCDEFG";
+  assert(*get_if<3>(&t2) == "ABCDEFG");
+
+  const test t3{1};
+  assert(*get_if<1>(&t3) == 1);
+}
+
+void test_get_odds()
+{
+  auto vola1 = variant<bool,bool,volatile int>{33};
+  assert(get<volatile int>(vola1) == 33);
+
+  variant<bool,const bool,const std::string> vola2{"Variant"};
+  assert(get<const std::string>(vola2) == std::string{"Variant"});
+  assert(get<2>(vola2) == std::string{"Variant"});
+
+  auto vola3 = variant<bool,const bool,const volatile int>{44};
+  assert(get<const volatile int>(vola3) == 44);
+  assert(get<2>(vola3) == 44);
+}
+
+int main()
+{
+  test_constexpr_get();
+  test_constexpr_get_if();
+  test_get();
+  test_get_if();
+  test_get_odds();
+}

test/std/experimental/variant/variant/variant.general/variant.monostate/monostate.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <vector>
+
+using std::experimental::variant;
+using std::experimental::monostate;
+using std::experimental::holds_alternative;
+
+struct foo
+{
+  foo() = delete;
+  foo(const foo&) = delete;
+  foo(foo&&) = delete;
+  foo(bool){}
+  virtual ~foo(){}
+};
+
+int main()
+{
+  variant<monostate,foo> v;
+  assert(holds_alternative<monostate>(v));
+  v.emplace<foo>(true);
+  assert(holds_alternative<foo>(v));
+}

test/std/experimental/variant/variant/variant.general/variant.relops/equal_to.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+void test_comple_time_equal_to()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{1};
+  constexpr test t2{1};
+  constexpr test t3{true};
+  static_assert(t1 == t2);
+  static_assert(!(t1 != t2));
+  static_assert(!(t1 == t3));
+  static_assert(t2 != t3);
+}
+
+int main()
+{
+  test_comple_time_equal_to();
+}

test/std/experimental/variant/variant/variant.general/variant.specalg/swap.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::swap;
+
+struct foo{};
+
+int main()
+{
+  variant<float,unsigned,double,char> v1, v2;
+  v1 = 123456u;
+  v2 = 'A';
+  assert(get<1>(v1) == 123456u);
+  assert(get<3>(v2) == 'A');
+  swap<float,unsigned,double,char>(v1,v2);
+  assert(get<1>(v2) == 123456u);
+  assert(get<3>(v1) == 'A');
+}

test/std/experimental/variant/variant/variant.general/variant.traits/uses_allocator.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include<experimental/variant>
+#include<string>
+
+using std::experimental::variant;
+using std::uses_allocator_v;
+
+int main()
+{
+  struct foo {};
+  static_assert(uses_allocator_v<variant<bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<std::string,bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo,bool>,std::allocator<char>>);
+  static_assert(uses_allocator_v<variant<foo,std::string,bool>,std::allocator<char>>);
+}

test/std/experimental/variant/variant/variant.general/variant.visit/visit.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <chrono>
+#include <iostream>
+
+using std::experimental::variant;
+using std::experimental::monostate;
+using std::experimental::visit;
+
+using test = variant<bool,int,double,std::string>;
+
+struct visitor
+{
+  bool operator () (bool b1, bool b2, bool b3)
+  {
+    call = "bool";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (int i1, int i2, int i3)
+  {
+    call = "int";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (double d1, double d2, double d3)
+  {
+    call = "double";
+    std::cout << call << "\n";
+    return true;
+  }
+  bool operator () (const std::string& str1, const std::string& str2, const std::string& str3)
+  {
+    call = "string";
+    std::cout << call << "\n";
+    return true;
+  }
+  std::string call;
+};
+
+void test_functor()
+{
+  visitor vis;
+  test var1, var2, var3;
+
+  var1 = var2 = var3 = true;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "bool");
+
+  var1 = var2 = var3 = 13;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "int");
+
+  var1 = var2 = var3 = 21.12;
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "double");
+
+  var1 = var2 = var3 = std::string{};
+  visit(vis, var1, var2, var3);
+  assert(vis.call == "string");
+}
+
+void test_lambda()
+{
+  std::string call;
+  test var1, var2;
+
+  var1 = var2 = true;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "x");
+
+  var1 = var2 = 13;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xx");
+
+  var1 = var2 = 21.12;
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xxx");
+
+  var1 = var2 = std::string{"Hello!"};
+  visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2);
+  assert(call == "xxxx");
+}
+
+void test_complex()
+{
+  using type = variant<monostate,
+                      std::nullptr_t,
+                      double,
+                      std::string,
+                      bool,
+                      std::chrono::system_clock::time_point,
+                      long,
+                      long long
+  >;
+
+  const auto value = type{};
+
+  visit([](const auto& arg){return "pöö";}, value);
+}
+
+int main()
+{
+  test_functor();
+  test_lambda();
+  test_complex();
+}

test/std/experimental/variant/variant/variant.variant/variant.assign/assignment.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <vector>
+
+using std::experimental::variant;
+using std::experimental::get;
+using std::experimental::holds_alternative;
+
+void test_copy_assign()
+{
+  variant<int,bool,std::string,double> v1, v2;
+
+  v1 = 21.12;
+  assert(get<double>(v1) == 21.12);
+  assert(get<3>(v1)   == 21.12);
+
+  v2 = v1;
+  assert(get<double>(v2) == 21.12);
+  assert(get<3>(v2)   == 21.12);
+}
+
+void test_move_assign()
+{
+  variant<int,bool,std::string,double> v;
+  v = variant<int,bool,std::string,double>{std::string{"rush"}};
+  assert(get<std::string>(v) == "rush");
+  assert(get<2>(v)           == "rush");
+}
+
+void test_alternative_assign()
+{
+  variant<int,bool,std::string,double> v;
+
+  v = 13;
+  assert(get<int>(v) == 13);
+  assert(get<0>(v)   == 13);
+
+  v = false;
+  assert(get<bool>(v) == false);
+  assert(get<1>(v)    == false);
+
+  v = std::string{"abc"};
+  assert(get<std::string>(v) == "abc");
+  assert(get<2>(v)           == "abc");
+
+  v = 21.12;
+  assert(get<double>(v) == 21.12);
+  assert(get<3>(v)      == 21.12);
+
+  v = short{2};
+  assert(get<int>(v) == 2);
+  assert(get<0>(v)   == 2);
+}
+
+void test_string_assign()
+{
+  auto v1 = variant<std::vector<int>,std::string>{};
+  v1 = "Test 123 456?";
+  assert(get<std::string>(v1) == "Test 123 456?");
+  assert(get<1>(v1)           == "Test 123 456?");
+
+  auto v2 = variant<std::vector<std::string>,std::string>{};
+  v2 = "Test 123 456?";
+  assert(get<std::string>(v2) == "Test 123 456?");
+  assert(get<1>(v2)           == "Test 123 456?");
+}
+
+void test_pointer_assignent()
+{
+  auto v = variant<int*,bool*,std::string*,double*>{};
+  auto i = 13;
+  auto b = false;
+  auto str = std::string{"TEST123"};
+  auto d = 21.12;
+
+  v = &i;
+  assert(v.index() == 0);
+  assert(holds_alternative<int*>(v));
+  assert(*get<int*>(v) == i);
+  assert(*get<0>(v)    == i);
+
+  v = &b;
+  assert(v.index() == 1);
+  assert(holds_alternative<bool*>(v));
+  assert(*get<bool*>(v) == b);
+  assert(*get<1>(v)     == b);
+
+  v = &str;
+  assert(v.index() == 2);
+  assert(holds_alternative<std::string*>(v));
+  assert(*get<std::string*>(v) == str);
+  assert(*get<2>(v)            == str);
+
+  v = &d;
+  assert(v.index() == 3);
+  assert(holds_alternative<double*>(v));
+  assert(*get<double*>(v) == d);
+  assert(*get<3>(v)      == d);
+}
+
+int main()
+{
+  test_copy_assign();
+  test_move_assign();
+  test_alternative_assign();
+  test_string_assign();
+  test_pointer_assignent();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo& operator = (const foo&) = default;
+};
+
+struct bar
+{
+  bar& operator = (const bar&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_copy_assignable_v<variant<foo>>);
+  static_assert(std::is_copy_assignable_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_copy_assignable_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_copy_assignable_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_copy_assignable_v<variant<bar>>);
+  static_assert(!std::is_copy_assignable_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_copy_assignable_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_copy_assignable_v<variant<int,bool,bar,double>>);
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo& operator = (foo&&) = default;
+};
+
+struct bar
+{
+  bar& operator = (bar&&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_move_assignable_v<variant<foo>>);
+  static_assert(std::is_move_assignable_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_move_assignable_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_move_assignable_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_move_assignable_v<variant<bar>>);
+  static_assert(!std::is_move_assignable_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_move_assignable_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_move_assignable_v<variant<int,bool,bar,double>>);
+}

test/std/experimental/variant/variant/variant.variant/variant.ctor/allocators.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <vector>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+struct foo
+{
+  foo(const foo&) = default;
+  foo(foo&&) = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  bar(const bar&) = delete;
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  // Default
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, foo>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, std::allocator<char>, bar>);
+
+  // Copy
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, variant<int,foo>&>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, std::allocator<char>, variant<int,bar>&>);
+
+  // Move
+  static_assert(std::is_constructible_v<variant<int,foo>,  std::allocator_arg_t, std::allocator<char>, variant<int,foo>&&>);
+  static_assert(!std::is_constructible_v<variant<int,bar>, std::allocator_arg_t, const std::allocator<char>&, variant<int,bar>&&>);
+}
+
+void test_constructors_1()
+{
+  using variant = variant<bool,long,double,std::vector<int>,std::string>;
+  std::allocator<char> a;
+
+  variant v1{std::allocator_arg_t{}, a};
+  assert(v1.index() == 0);
+  assert(get<0>(v1) == false);
+
+  variant v2{std::allocator_arg_t{}, a, 1l};
+  assert(v2.index() == 1);
+  assert(get<1>(v2) == 1);
+
+  variant v3{std::allocator_arg_t{}, a, 2.2};
+  assert(v3.index() == 2);
+  assert(get<2>(v3) == 2.2);
+
+  variant v4{std::allocator_arg_t{}, a, std::in_place_type<std::vector<int>>, {1,2,3,4,5,6,7}};
+  assert(v4.index() == 3);
+  assert(get<3>(v4).size() == 7);
+  assert(get<3>(v4)[3] == 4);
+
+  variant v5{std::allocator_arg_t{}, a, std::in_place_index<3>, {1,2,3,4,5,6,7,8}};
+  assert(v5.index() == 3);
+  assert(get<3>(v5).size() == 8);
+
+  variant v6{std::allocator_arg_t{}, a, std::in_place_type<std::string>, "foo"};
+  assert(v6.index() == 4);
+  assert(get<4>(v6) == "foo");
+
+  variant v7{std::allocator_arg_t{}, a, std::in_place_index<4>, "bar"};
+  assert(v7.index() == 4);
+  assert(get<4>(v7) == "bar");
+
+  variant v8{std::allocator_arg_t{}, a, std::in_place_type<std::string>, {'a','b','c','d'}};
+  assert(v8.index() == 4);
+  assert(get<4>(v8) == "abcd");
+
+  variant v9{std::allocator_arg_t{}, a, std::in_place_index<4>, std::size_t{10}, 'a'};
+  assert(v9.index() == 4);
+  assert(get<4>(v9) == "aaaaaaaaaa");
+
+  variant v22{std::allocator_arg_t{}, a, v2};
+  assert(v22.index() == 1);
+  assert(get<1>(v22) == 1);
+
+  variant v23{std::allocator_arg_t{}, a, std::move(v3)};
+  assert(v23.index() == 2);
+  assert(get<2>(v23) == 2.2);
+
+  variant v30{std::allocator_arg_t{}, a, std::string{"test"}};
+  assert(v30.index() == 4);
+  assert(get<4>(v30) == "test");
+}
+
+void test_constructors_2()
+{
+  using variant = variant<long long,std::vector<int>,std::string>;
+  std::allocator<char> a;
+
+  variant v31{std::allocator_arg_t{}, a, short{31}};
+  assert(v31.index() == 0);
+  assert(get<0>(v31) == 31);
+
+  variant v32{std::allocator_arg_t{}, a, int{32}};
+  assert(v32.index() == 0);
+  assert(get<0>(v32) == 32);
+
+  variant v33{std::allocator_arg_t{}, a, unsigned{33}};
+  assert(v33.index() == 0);
+  assert(get<0>(v33) == 33);
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors_1();
+  test_constructors_2();
+}

test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.fail.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <vector>
+#include <cassert>
+
+using std::experimental::variant;
+
+int main()
+{
+  // constexpr variant<bool,int,double,std::vector<int>> v1{};
+}

test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <vector>
+#include <cassert>
+
+using std::experimental::variant;
+
+int main()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{};
+  static_assert(t1.index() == 0);
+
+  constexpr test t2{true};
+  static_assert(t2.index() == 0);
+
+  constexpr test t3{1};
+  static_assert(t3.index() == 1);
+
+  constexpr test t4{2.2};
+  static_assert(t4.index() == 2);
+}

test/std/experimental/variant/variant/variant.variant/variant.ctor/conversions.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+struct foo
+{
+  foo() noexcept = default;
+  foo(const foo&) noexcept = default;
+  foo(foo&&) noexcept = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  bar(const bar&) = delete;
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  // Well formed
+  static_assert(std::is_nothrow_constructible_v<variant<foo>,foo>);
+  static_assert(std::is_nothrow_constructible_v<variant<int,bool,double,foo>,int>);
+  static_assert(std::is_nothrow_constructible_v<variant<foo,int,bool,double>,bool>);
+
+  static_assert(!std::is_nothrow_constructible_v<variant<bar>,bar>);
+  static_assert(std::is_nothrow_constructible_v<variant<int,bool,double,bar>,double>);
+  static_assert(!std::is_nothrow_constructible_v<variant<bar,int,bool,double>,bar>);
+
+  static_assert(std::is_constructible_v<variant<std::string,foo>,std::string>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,const std::string&>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,std::string&&>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,char*>);
+  static_assert(std::is_constructible_v<variant<std::string,foo>,const char*>);
+
+  // Ill formed
+  static_assert(!std::is_nothrow_constructible_v<variant<bool,bool>,bool>);
+  static_assert(!std::is_nothrow_constructible_v<variant<std::string,std::string>,const char*>);
+}
+
+void test_odds()
+{
+  auto i = 13;
+  variant<bool*,int&,double*,std::string&> odd1{std::in_place_type<int&>, i};
+  assert(odd1.index() == 1);
+  assert(get<1>(odd1) == i);
+
+  const auto str = std::string{"Jee!"};
+  variant<bool*,int&,double*,const std::string&> odd2{std::in_place_type<const std::string&>, str};
+  assert(odd2.index() == 3);
+  assert(get<3>(odd2) == str);
+
+  auto b = false;
+  variant<bool*,int&,double*,const std::string&> odd3{std::in_place_type<bool*>, &b};
+  assert(odd3.index() == 0);
+  assert(*get<0>(odd3) == b);
+}
+
+int main()
+{
+  test_type_traits();
+  test_odds();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+
+struct foo
+{
+  foo(const foo&) = default;
+};
+
+struct bar
+{
+  bar(const bar&) = delete;
+};
+
+int main()
+{
+  static_assert(std::is_copy_constructible_v<variant<foo>>);
+  static_assert(std::is_copy_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_copy_constructible_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_copy_constructible_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_copy_constructible_v<variant<bar>>);
+  static_assert(!std::is_copy_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_copy_constructible_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_copy_constructible_v<variant<int,bool,bar,double>>);
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::monostate;
+using std::experimental::holds_alternative;
+using std::experimental::get;
+
+struct foo
+{
+  foo() noexcept = default;
+};
+
+struct bar
+{
+  bar() = delete;
+  ~bar() = default;
+};
+
+void test_type_traits()
+{
+  static_assert(std::is_default_constructible_v<variant<foo>>);
+  static_assert(std::is_default_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_default_constructible_v<variant<foo,int,bool,double>>);
+
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo,int,bool,double>>);
+
+  static_assert(!std::is_default_constructible_v<variant<bar>>);
+  static_assert(std::is_default_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_default_constructible_v<variant<bar,int,bool,double>>);
+
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar>>);
+  static_assert(std::is_nothrow_default_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar,int,bool,double>>);
+
+  static_assert(std::is_nothrow_default_constructible_v<variant<foo,bar>>);
+  static_assert(!std::is_nothrow_default_constructible_v<variant<bar,foo>>);
+}
+
+void test_constructors()
+{
+  constexpr variant<foo,int,bool,double> v1;
+  static_assert(v1.index() == 0);
+  static_assert(holds_alternative<foo>(v1));
+
+  constexpr variant<int,foo,bar,bool,double> v2;
+  static_assert(v2.index() == 0);
+  static_assert(holds_alternative<int>(v2));
+}
+
+void test_odds()
+{
+  auto i = 13;
+  variant<bool*,int&,double*,std::string&> odd1{i};
+  assert(holds_alternative<int&>(odd1));
+  assert(!holds_alternative<const std::string&>(odd1));
+  assert(!holds_alternative<const std::string>(odd1));
+  assert(!holds_alternative<std::string>(odd1));
+  assert(!holds_alternative<std::string&>(odd1));
+  assert(!holds_alternative<std::nullptr_t>(odd1));
+  assert(odd1.index() == 1);
+  assert(get<1>(odd1) == i);
+
+  const auto str = std::string{"Jee!"};
+  variant<bool*,int&,double*,const std::string&> odd2{str};
+  assert(holds_alternative<const std::string&>(odd2));
+  assert(!holds_alternative<const std::string>(odd2));
+  assert(!holds_alternative<std::string>(odd2));
+  assert(!holds_alternative<std::string&>(odd2));
+  assert(!holds_alternative<int&>(odd2));
+  assert(odd2.index() == 3);
+  assert(get<3>(odd2) == str);
+
+  auto b = false;
+  variant<bool*,int&,double*,const std::string&> odd3{&b};
+  assert(holds_alternative<bool*>(odd3));
+  assert(!holds_alternative<int&>(odd3));
+  assert(!holds_alternative<unsigned>(odd3));
+  assert(odd3.index() == 0);
+  assert(*get<0>(odd3) == b);
+
+  variant<const volatile int> vola{33};
+  assert(holds_alternative<const volatile int>(vola));
+  assert(!holds_alternative<volatile int>(vola));
+  assert(!holds_alternative<int>(vola));
+  assert(!holds_alternative<const int>(vola));
+  assert(!holds_alternative<bool>(vola));
+  assert(vola.index() == 0);
+  assert(get<0>(vola) == 33);
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors();
+  test_odds();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::holds_alternative;
+using std::experimental::variant_npos;
+
+struct foo
+{
+  foo(foo&&) = default;
+};
+
+struct bar
+{
+  bar(bar&&) = delete;
+};
+
+void test_type_traits()
+{
+  static_assert(std::is_move_constructible_v<variant<foo>>);
+  static_assert(std::is_move_constructible_v<variant<int,bool,double,foo>>);
+  static_assert(std::is_move_constructible_v<variant<foo,int,bool,double>>);
+  static_assert(std::is_move_constructible_v<variant<int,foo,bool,double>>);
+
+  static_assert(!std::is_move_constructible_v<variant<bar>>);
+  static_assert(!std::is_move_constructible_v<variant<int,bool,double,bar>>);
+  static_assert(!std::is_move_constructible_v<variant<bar,int,bool,double>>);
+  static_assert(!std::is_move_constructible_v<variant<int,bool,bar,double>>);
+}
+
+void test_constructors()
+{
+  auto v1 = variant<int,bool,double,std::string>{2.2};
+  assert(v1.index() == 2);
+  assert(holds_alternative<double>(v1));
+
+  auto v2 = variant<int,bool,double,std::string>{std::move(v1)};
+  assert(v2.index() == 2);
+  assert(holds_alternative<double>(v2));
+
+  assert(v1.index() == variant_npos);
+
+  auto vola = variant<bool,bool,volatile int>{33};
+  assert(vola.index() == 2);
+  assert(holds_alternative<volatile int>(vola));
+}
+
+int main()
+{
+  test_type_traits();
+  test_constructors();
+}

test/std/experimental/variant/variant/variant.variant/variant.dtor/dtor.pss.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+
+using std::experimental::variant;
+
+static int count = 0;
+
+struct foo
+{
+  ~foo() = default;
+};
+
+struct bar
+{
+  bar() {++count;} // count == 1
+  ~bar(){++count;} // count == 2
+};
+
+int main()
+{
+  static_assert(std::is_trivially_destructible_v<variant<int,foo>> == true);
+
+  static_assert(std::is_trivially_destructible_v<variant<int,bar>> == false);
+
+  assert(count == 0);
+  {
+    variant<bar> v{std::in_place_type<bar>};
+    assert(count == 1);
+  }
+  assert(count == 2);
+}

test/std/experimental/variant/variant/variant.variant/variant.mod/emplace.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <string>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+static int count = 0;
+
+struct foo
+{
+  foo(int) {++count;} // count == 1
+  ~foo(){++count;} // count == 2
+};
+
+void test_basics()
+{
+  variant<bool,foo> v{};
+  assert(count == 0);
+  v.emplace<foo>(13);
+  assert(count == 1);
+  v.emplace<bool>(true);
+  assert(count == 2);
+  v.emplace<foo>(13);
+  assert(count == 3);
+  v.emplace<bool>(true);
+  assert(count == 4);
+}
+
+void test_odds()
+{
+  auto b = false;
+  variant<bool*,int&,double*,const std::string&> odd3{};
+  odd3.emplace<0>(&b);
+  assert(odd3.index() == 0);
+  assert(*get<0>(odd3) == b);
+}
+
+int main()
+{
+  test_basics();
+  test_odds();
+}

test/std/experimental/variant/variant/variant.variant/variant.status/index.pass.cpp

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::bad_variant_access;
+using std::experimental::variant_npos;
+
+void test_ctor()
+{
+  using test = variant<bool,int,double>;
+  constexpr test t1{};
+  static_assert(t1.index() == 0);
+  constexpr test t2{true};
+  static_assert(t2.index() == 0);
+  constexpr test t3{1};
+  static_assert(t3.index() == 1);
+  constexpr test t4{2.2};
+  static_assert(t4.index() == 2);
+}
+
+void test_assign()
+{
+  using test = variant<bool,int,double>;
+  test t1{};
+  assert(t1.index() == 0);
+  t1 = true;
+  assert(t1.index() == 0);
+  t1 = 1;
+  assert(t1.index() == 1);
+  t1 = 2.2;
+  assert(t1.index() == 2);
+}
+
+void test_valueless_by_exception()
+{
+  struct S { operator int() { throw 42; }};
+  variant<float, int> v{12.f};
+  assert(v.index() == 0);
+  assert(!v.valueless_by_exception());
+  try
+  {
+    v.emplace<1>(S());
+  }
+  catch(...)
+  {}
+  assert(v.index() == variant_npos);
+  assert(v.valueless_by_exception());
+}
+
+int main()
+{
+  test_ctor();
+  test_assign();
+  test_valueless_by_exception();
+}

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

+// -*- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <experimental/variant>
+#include <cassert>
+
+using std::experimental::variant;
+using std::experimental::get;
+
+struct foo{};
+
+int main()
+{
+  variant<float,unsigned,foo,char> v1, v2;
+  v1 = 123456u;
+  v2 = 'A';
+  assert(get<1>(v1) == 123456u);
+  assert(get<3>(v2) == 'A');
+  v1.swap(v2);
+  assert(get<1>(v2) == 123456u);
+  assert(get<3>(v1) == 'A');
+}