grpc 1.71.0 → 1.74.0

data/third_party/abseil-cpp/absl/types/variant.h

@@ -16,39 +16,18 @@
 // variant.h
 // -----------------------------------------------------------------------------
 //
-// This header file defines an `absl::variant` type for holding a type-safe
-// value of some prescribed set of types (noted as alternative types), and
-// associated functions for managing variants.
-//
-// The `absl::variant` type is a form of type-safe union. An `absl::variant`
-// should always hold a value of one of its alternative types (except in the
-// "valueless by exception state" -- see below). A default-constructed
-// `absl::variant` will hold the value of its first alternative type, provided
-// it is default-constructible.
-//
-// In exceptional cases due to error, an `absl::variant` can hold no
-// value (known as a "valueless by exception" state), though this is not the
-// norm.
-//
-// As with `absl::optional`, an `absl::variant` -- when it holds a value --
-// allocates a value of that type directly within the `variant` itself; it
-// cannot hold a reference, array, or the type `void`; it can, however, hold a
-// pointer to externally managed memory.
-//
-// `absl::variant` is a C++11 compatible version of the C++17 `std::variant`
-// abstraction and is designed to be a drop-in replacement for code compliant
-// with C++17.
+// Historical note: Abseil once provided an implementation of `absl::variant`
+// as a polyfill for `std::variant` prior to C++17. Now that C++17 is required,
+// `absl::variant` is an alias for `std::variant`.
 
 #ifndef ABSL_TYPES_VARIANT_H_
 #define ABSL_TYPES_VARIANT_H_
 
+#include <variant>
+
 #include "absl/base/config.h"
 #include "absl/utility/utility.h"
 
-#ifdef ABSL_USES_STD_VARIANT
-
-#include <variant>  // IWYU pragma: export
-
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 using std::bad_variant_access;
@@ -63,765 +42,8 @@ using std::variant_npos;
 using std::variant_size;
 using std::variant_size_v;
 using std::visit;
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#else  // ABSL_USES_STD_VARIANT
-
-#include <functional>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "absl/base/macros.h"
-#include "absl/base/port.h"
-#include "absl/meta/type_traits.h"
-#include "absl/types/internal/variant.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// -----------------------------------------------------------------------------
-// absl::variant
-// -----------------------------------------------------------------------------
-//
-// An `absl::variant` type is a form of type-safe union. An `absl::variant` --
-// except in exceptional cases -- always holds a value of one of its alternative
-// types.
-//
-// Example:
-//
-//   // Construct a variant that holds either an integer or a std::string and
-//   // assign it to a std::string.
-//   absl::variant<int, std::string> v = std::string("abc");
-//
-//   // A default-constructed variant will hold a value-initialized value of
-//   // the first alternative type.
-//   auto a = absl::variant<int, std::string>();   // Holds an int of value '0'.
-//
-//   // variants are assignable.
-//
-//   // copy assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   auto v2 = absl::variant<int, std::string>(10);
-//   v2 = v1;  // copy assign
-//
-//   // move assignment
-//   auto v1 = absl::variant<int, std::string>("abc");
-//   v1 = absl::variant<int, std::string>(10);
-//
-//   // assignment through type conversion
-//   a = 128;         // variant contains int
-//   a = "128";       // variant contains std::string
-//
-// An `absl::variant` holding a value of one of its alternative types `T` holds
-// an allocation of `T` directly within the variant itself. An `absl::variant`
-// is not allowed to allocate additional storage, such as dynamic memory, to
-// allocate the contained value. The contained value shall be allocated in a
-// region of the variant storage suitably aligned for all alternative types.
-template <typename... Ts>
-class variant;
-
-// swap()
-//
-// Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
-// where `v` and `w` are `absl::variant` types.
-//
-// Note that this function requires all alternative types to be both swappable
-// and move-constructible, because any two variants may refer to either the same
-// type (in which case, they will be swapped) or to two different types (in
-// which case the values will need to be moved).
-//
-template <
-    typename... Ts,
-    absl::enable_if_t<
-        absl::conjunction<std::is_move_constructible<Ts>...,
-                          type_traits_internal::IsSwappable<Ts>...>::value,
-        int> = 0>
-void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) {
-  v.swap(w);
-}
-
-// variant_size
-//
-// Returns the number of alternative types available for a given `absl::variant`
-// type as a compile-time constant expression. As this is a class template, it
-// is not generally useful for accessing the number of alternative types of
-// any given `absl::variant` instance.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>();
-//
-//   // You can also use the member constant `value`.
-//   constexpr int num_types =
-//       absl::variant_size<absl::variant<int, std::string>>::value;
-//
-//   // `absl::variant_size` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsVariantMultivalue() {
-//       return absl::variant_size<Variant>() > 1;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_size` are
-// provided to ensure that those specializations compile (especially when passed
-// within template logic).
-template <class T>
-struct variant_size;
-
-template <class... Ts>
-struct variant_size<variant<Ts...>>
-    : std::integral_constant<std::size_t, sizeof...(Ts)> {};
-
-// Specialization of `variant_size` for const qualified variants.
-template <class T>
-struct variant_size<const T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for volatile qualified variants.
-template <class T>
-struct variant_size<volatile T> : variant_size<T>::type {};
-
-// Specialization of `variant_size` for const volatile qualified variants.
-template <class T>
-struct variant_size<const volatile T> : variant_size<T>::type {};
-
-// variant_alternative
-//
-// Returns the alternative type for a given `absl::variant` at the passed
-// index value as a compile-time constant expression. As this is a class
-// template resulting in a type, it is not useful for access of the run-time
-// value of any given `absl::variant` variable.
-//
-// Example:
-//
-//   // The type of the 0th alternative is "int".
-//   using alternative_type_0
-//     = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
-//
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-//
-//   // `absl::variant_alternative` is more valuable for use in generic code:
-//   template <typename Variant>
-//   constexpr bool IsFirstElementTrivial() {
-//       return std::is_trivial_v<variant_alternative<0, Variant>::type>;
-//   }
-//
-// Note that the set of cv-qualified specializations of `variant_alternative`
-// are provided to ensure that those specializations compile (especially when
-// passed within template logic).
-template <std::size_t I, class T>
-struct variant_alternative;
-
-template <std::size_t I, class... Types>
-struct variant_alternative<I, variant<Types...>> {
-  using type =
-      variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
-};
-
-// Specialization of `variant_alternative` for const qualified variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, const T> {
-  using type = const typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for volatile qualified variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, volatile T> {
-  using type = volatile typename variant_alternative<I, T>::type;
-};
-
-// Specialization of `variant_alternative` for const volatile qualified
-// variants.
-template <std::size_t I, class T>
-struct variant_alternative<I, const volatile T> {
-  using type = const volatile typename variant_alternative<I, T>::type;
-};
-
-// Template type alias for variant_alternative<I, T>::type.
-//
-// Example:
-//
-//   using alternative_type_0
-//     = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
-//   static_assert(std::is_same<alternative_type_0, int>::value, "");
-template <std::size_t I, class T>
-using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-// holds_alternative()
-//
-// Checks whether the given variant currently holds a given alternative type,
-// returning `true` if so.
-//
-// Example:
-//
-//   absl::variant<int, std::string> foo = 42;
-//   if (absl::holds_alternative<int>(foo)) {
-//       std::cout << "The variant holds an integer";
-//   }
-template <class T, class... Types>
-constexpr bool holds_alternative(const variant<Types...>& v) noexcept {
-  static_assert(
-      variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
-                                               0>::value != sizeof...(Types),
-      "The type T must occur exactly once in Types...");
-  return v.index() ==
-         variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
-}
-
-// get()
-//
-// Returns a reference to the value currently within a given variant, using
-// either a unique alternative type amongst the variant's set of alternative
-// types, or the variant's index value. Attempting to get a variant's value
-// using a type that is not unique within the variant's set of alternative types
-// is a compile-time error. If the index of the alternative being specified is
-// different from the index of the alternative that is currently stored, throws
-// `absl::bad_variant_access`.
-//
-// Example:
-//
-//   auto a = absl::variant<int, std::string>;
-//
-//   // Get the value by type (if unique).
-//   int i = absl::get<int>(a);
-//
-//   auto b = absl::variant<int, int>;
-//
-//   // Getting the value by a type that is not unique is ill-formed.
-//   int j = absl::get<int>(b);     // Compile Error!
-//
-//   // Getting value by index not ambiguous and allowed.
-//   int k = absl::get<1>(b);
-
-// Overload for getting a variant's lvalue by type.
-template <class T, class... Types>
-constexpr T& get(variant<Types...>& v) {  // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's rvalue by type.
-template <class T, class... Types>
-constexpr T&& get(variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(std::move(v));
-}
-
-// Overload for getting a variant's const lvalue by type.
-template <class T, class... Types>
-constexpr const T& get(const variant<Types...>& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a variant's const rvalue by type.
-template <class T, class... Types>
-constexpr const T&& get(const variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<
-      variant_internal::IndexOf<T, Types...>::value>(std::move(v));
-}
-
-// Overload for getting a variant's lvalue by index.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>>& get(
-    variant<Types...>& v) {  // NOLINT
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's rvalue by index.
-template <std::size_t I, class... Types>
-constexpr variant_alternative_t<I, variant<Types...>>&& get(
-    variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
-}
 
-// Overload for getting a variant's const lvalue by index.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>>& get(
-    const variant<Types...>& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(v);
-}
-
-// Overload for getting a variant's const rvalue by index.
-template <std::size_t I, class... Types>
-constexpr const variant_alternative_t<I, variant<Types...>>&& get(
-    const variant<Types...>&& v) {
-  return variant_internal::VariantCoreAccess::CheckedAccess<I>(std::move(v));
-}
-
-// get_if()
-//
-// Returns a pointer to the value currently stored within a given variant, if
-// present, using either a unique alternative type amongst the variant's set of
-// alternative types, or the variant's index value. If such a value does not
-// exist, returns `nullptr`.
-//
-// As with `get`, attempting to get a variant's value using a type that is not
-// unique within the variant's set of alternative types is a compile-time error.
-
-// Overload for getting a pointer to the value stored in the given variant by
-// index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-get_if(variant<Types...>* v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the const value stored in the given
-// variant by index.
-template <std::size_t I, class... Types>
-constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-get_if(const variant<Types...>* v) noexcept {
-  return (v != nullptr && v->index() == I)
-             ? std::addressof(
-                   variant_internal::VariantCoreAccess::Access<I>(*v))
-             : nullptr;
-}
-
-// Overload for getting a pointer to the value stored in the given variant by
-// type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// Overload for getting a pointer to the const value stored in the given variant
-// by type.
-template <class T, class... Types>
-constexpr absl::add_pointer_t<const T> get_if(
-    const variant<Types...>* v) noexcept {
-  return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
-}
-
-// visit()
-//
-// Calls a provided functor on a given set of variants. `absl::visit()` is
-// commonly used to conditionally inspect the state of a given variant (or set
-// of variants).
-//
-// The functor must return the same type when called with any of the variants'
-// alternatives.
-//
-// Example:
-//
-//   // Define a visitor functor
-//   struct GetVariant {
-//       template<typename T>
-//       void operator()(const T& i) const {
-//         std::cout << "The variant's value is: " << i;
-//       }
-//   };
-//
-//   // Declare our variant, and call `absl::visit()` on it.
-//   // Note that `GetVariant()` returns void in either case.
-//   absl::variant<int, std::string> foo = std::string("foo");
-//   GetVariant visitor;
-//   absl::visit(visitor, foo);  // Prints `The variant's value is: foo'
-template <typename Visitor, typename... Variants>
-variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
-                                                          Variants&&... vars) {
-  return variant_internal::
-      VisitIndices<variant_size<absl::decay_t<Variants> >::value...>::Run(
-          variant_internal::PerformVisitation<Visitor, Variants...>{
-              std::forward_as_tuple(std::forward<Variants>(vars)...),
-              std::forward<Visitor>(vis)},
-          vars.index()...);
-}
-
-// monostate
-//
-// The monostate class serves as a first alternative type for a variant for
-// which the first variant type is otherwise not default-constructible.
-struct monostate {};
-
-// `absl::monostate` Relational Operators
-
-constexpr bool operator<(monostate, monostate) noexcept { return false; }
-constexpr bool operator>(monostate, monostate) noexcept { return false; }
-constexpr bool operator<=(monostate, monostate) noexcept { return true; }
-constexpr bool operator>=(monostate, monostate) noexcept { return true; }
-constexpr bool operator==(monostate, monostate) noexcept { return true; }
-constexpr bool operator!=(monostate, monostate) noexcept { return false; }
-
-
-//------------------------------------------------------------------------------
-// `absl::variant` Template Definition
-//------------------------------------------------------------------------------
-template <typename T0, typename... Tn>
-class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
-  static_assert(absl::conjunction<std::is_object<T0>,
-                                  std::is_object<Tn>...>::value,
-                "Attempted to instantiate a variant containing a non-object "
-                "type.");
-  // Intentionally not qualifying `negation` with `absl::` to work around a bug
-  // in MSVC 2015 with inline namespace and variadic template.
-  static_assert(absl::conjunction<negation<std::is_array<T0> >,
-                                  negation<std::is_array<Tn> >...>::value,
-                "Attempted to instantiate a variant containing an array type.");
-  static_assert(absl::conjunction<std::is_nothrow_destructible<T0>,
-                                  std::is_nothrow_destructible<Tn>...>::value,
-                "Attempted to instantiate a variant containing a non-nothrow "
-                "destructible type.");
-
-  friend struct variant_internal::VariantCoreAccess;
-
- private:
-  using Base = variant_internal::VariantBase<T0, Tn...>;
-
- public:
-  // Constructors
-
-  // Constructs a variant holding a default-initialized value of the first
-  // alternative type.
-  constexpr variant() /*noexcept(see 111above)*/ = default;
-
-  // Copy constructor, standard semantics
-  variant(const variant& other) = default;
-
-  // Move constructor, standard semantics
-  variant(variant&& other) /*noexcept(see above)*/ = default;
-
-  // Constructs a variant of an alternative type specified by overload
-  // resolution of the provided forwarding arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          variant_internal::IsNeitherSelfNorInPlace<variant,
-                                                    absl::decay_t<T> >::value,
-          variant_internal::IndexOfConstructedType<variant, T> >::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      absl::enable_if_t<std::is_constructible<Tj, T>::value>* = nullptr>
-  constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value)
-      : Base(variant_internal::EmplaceTag<I>(), std::forward<T>(t)) {}
-
-  // Constructs a variant of an alternative type from the arguments through
-  // direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
-                Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, Args&&... args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from an initializer list
-  // and other arguments through direct-initialization.
-  //
-  // Note: If the selected constructor is a constexpr constructor, this
-  // constructor shall be a constexpr constructor.
-  template <class T, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::UnambiguousTypeOfT<variant, T>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
-                             Args&&... args)
-      : Base(variant_internal::EmplaceTag<
-                 variant_internal::UnambiguousIndexOf<variant, T>::value>(),
-             il, std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization using the provided forwarded arguments.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
-                Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, Args&&... args)
-      : Base(variant_internal::EmplaceTag<I>(), std::forward<Args>(args)...) {}
-
-  // Constructs a variant of an alternative type from a provided index,
-  // through value-initialization of an initializer list and the provided
-  // forwarded arguments.
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                variant_internal::VariantAlternativeSfinaeT<I, variant>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
-                             Args&&... args)
-      : Base(variant_internal::EmplaceTag<I>(), il,
-             std::forward<Args>(args)...) {}
-
-  // Destructors
-
-  // Destroys the variant's currently contained value, provided that
-  // `absl::valueless_by_exception()` is false.
-  ~variant() = default;
-
-  // Assignment Operators
-
-  // Copy assignment operator
-  variant& operator=(const variant& other) = default;
-
-  // Move assignment operator
-  variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
-
-  // Converting assignment operator
-  //
-  // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
-  // has been voted passed the design phase in the C++ standard meeting in Mar
-  // 2018. It will be implemented and integrated into `absl::variant`.
-  template <
-      class T,
-      std::size_t I = std::enable_if<
-          !std::is_same<absl::decay_t<T>, variant>::value,
-          variant_internal::IndexOfConstructedType<variant, T>>::type::value,
-      class Tj = absl::variant_alternative_t<I, variant>,
-      typename std::enable_if<std::is_assignable<Tj&, T>::value &&
-                              std::is_constructible<Tj, T>::value>::type* =
-          nullptr>
-  variant& operator=(T&& t) noexcept(
-      std::is_nothrow_assignable<Tj&, T>::value&&
-          std::is_nothrow_constructible<Tj, T>::value) {
-    variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
-            this, std::forward<T>(t)),
-        index());
-
-    return *this;
-  }
-
-
-  // emplace() Functions
-
-  // Constructs a value of the given alternative type T within the variant. The
-  // existing value of the variant is destroyed first (provided that
-  // `absl::valueless_by_exception()` is false). Requires that T is unambiguous
-  // in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<int>(99);
-  //   v.emplace<std::string>("abc");
-  template <
-      class T, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          Args...>::value>::type* = nullptr>
-  T& emplace(Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, std::forward<Args>(args)...);
-  }
-
-  // Constructs a value of the given alternative type T within the variant using
-  // an initializer list. The existing value of the variant is destroyed first
-  // (provided that `absl::valueless_by_exception()` is false). Requires that T
-  // is unambiguous in the variant.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, std::string> v;
-  //   v.emplace<std::vector<int>>({0, 1, 2});
-  template <
-      class T, class U, class... Args,
-      typename std::enable_if<std::is_constructible<
-          absl::variant_alternative_t<
-              variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
-          std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  T& emplace(std::initializer_list<U> il, Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<
-        variant_internal::UnambiguousIndexOf<variant, T>::value>(
-        this, il, std::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<1>(99);
-  //   v.emplace<2>(98);
-  //   v.emplace<int>(99);  // Won't compile. 'int' isn't a unique type.
-  template <std::size_t I, class... Args,
-            typename std::enable_if<
-                std::is_constructible<absl::variant_alternative_t<I, variant>,
-                                      Args...>::value>::type* = nullptr>
-  absl::variant_alternative_t<I, variant>& emplace(Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, std::forward<Args>(args)...);
-  }
-
-  // Destroys the current value of the variant (provided that
-  // `absl::valueless_by_exception()` is false) and constructs a new value at
-  // the given index using an initializer list and the provided arguments.
-  //
-  // Example:
-  //
-  //   absl::variant<std::vector<int>, int, int> v;
-  //   v.emplace<0>({0, 1, 2});
-  template <std::size_t I, class U, class... Args,
-            typename std::enable_if<std::is_constructible<
-                absl::variant_alternative_t<I, variant>,
-                std::initializer_list<U>&, Args...>::value>::type* = nullptr>
-  absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il,
-                                                   Args&&... args) {
-    return variant_internal::VariantCoreAccess::Replace<I>(
-        this, il, std::forward<Args>(args)...);
-  }
-
-  // variant::valueless_by_exception()
-  //
-  // Returns false if and only if the variant currently holds a valid value.
-  constexpr bool valueless_by_exception() const noexcept {
-    return this->index_ == absl::variant_npos;
-  }
-
-  // variant::index()
-  //
-  // Returns the index value of the variant's currently selected alternative
-  // type.
-  constexpr std::size_t index() const noexcept { return this->index_; }
-
-  // variant::swap()
-  //
-  // Swaps the values of two variant objects.
-  //
-  void swap(variant& rhs) noexcept(
-      absl::conjunction<
-          std::is_nothrow_move_constructible<T0>,
-          std::is_nothrow_move_constructible<Tn>...,
-          type_traits_internal::IsNothrowSwappable<T0>,
-          type_traits_internal::IsNothrowSwappable<Tn>...>::value) {
-    return variant_internal::VisitIndices<sizeof...(Tn) + 1>::Run(
-        variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
-  }
-};
-
-// We need a valid declaration of variant<> for SFINAE and overload resolution
-// to work properly above, but we don't need a full declaration since this type
-// will never be constructed. This declaration, though incomplete, suffices.
-template <>
-class variant<>;
-
-//------------------------------------------------------------------------------
-// Relational Operators
-//------------------------------------------------------------------------------
-//
-// If neither operand is in the `variant::valueless_by_exception` state:
-//
-//   * If the index of both variants is the same, the relational operator
-//     returns the result of the corresponding relational operator for the
-//     corresponding alternative type.
-//   * If the index of both variants is not the same, the relational operator
-//     returns the result of that operation applied to the value of the left
-//     operand's index and the value of the right operand's index.
-//   * If at least one operand is in the valueless_by_exception state:
-//     - A variant in the valueless_by_exception state is only considered equal
-//       to another variant in the valueless_by_exception state.
-//     - If exactly one operand is in the valueless_by_exception state, the
-//       variant in the valueless_by_exception state is less than the variant
-//       that is not in the valueless_by_exception state.
-//
-// Note: The value 1 is added to each index in the relational comparisons such
-// that the index corresponding to the valueless_by_exception state wraps around
-// to 0 (the lowest value for the index type), and the remaining indices stay in
-// the same relative order.
-
-// Equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() == b.index()) &&
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Not equal operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index()) ||
-         variant_internal::VisitIndices<sizeof...(Types)>::Run(
-             variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
-}
-
-// Less-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
-}
-
-// Greater-than operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Less-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
-    const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) < (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-// Greater-than or equal-to operator
-template <typename... Types>
-constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
-operator>=(const variant<Types...>& a, const variant<Types...>& b) {
-  return (a.index() != b.index())
-             ? (a.index() + 1) > (b.index() + 1)
-             : variant_internal::VisitIndices<sizeof...(Types)>::Run(
-                   variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
-                   a.index());
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-namespace std {
-
-// hash()
-template <>  // NOLINT
-struct hash<absl::monostate> {
-  std::size_t operator()(absl::monostate) const { return 0; }
-};
-
-template <class... T>  // NOLINT
-struct hash<absl::variant<T...>>
-    : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
-                                              absl::remove_const_t<T>...> {};
-
-}  // namespace std
-
-#endif  // ABSL_USES_STD_VARIANT
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
 namespace variant_internal {
-
 // Helper visitor for converting a variant<Ts...>` into another type (mostly
 // variant) that can be constructed from any type.
 template <typename To>
@@ -831,7 +53,6 @@ struct ConversionVisitor {
     return To(std::forward<T>(v));
   }
 };
-
 }  // namespace variant_internal
 
 // ConvertVariantTo()