[libc++][spaceship] Implement std::variant::operator<=>

[mumbleskates]

Summary

Implements [variant.relops] and [variant.monostate.relops] for P1614R2

[avogelsgesang]

Please also update SpaceshipProjects.csv

libcxx/include/variant

1655–1656

indentation here seems off
Also, it might help readability if we use an additional using type alias:

using _ResultType = common_comparison_category_t<compare_three_way_result_t<_Types>...>;
auto __three_way = []<class _Type>(const _Type& __v, const _Type& __w) -> ResultType {
      return __v <=> __w;
};

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

56

seems to be unused?

[mumbleskates]

• delete dead test function
• use a result type alias
• also implement std::monostate::operator<=>
• update spaceship projects

[mumbleskates]

Updated SpaceshipProjects and added the missing monostate operator as well

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

56

thanks! i discovered test_comparisons.h halfway through making this.

[mumbleskates]

• add missing include for monostate

[avogelsgesang]

libcxx/docs/Status/SpaceshipProjects.csv

27–28

please also update monostate and variant to link to this review

libcxx/include/__variant/monostate.h

34

I usually try to keep the order between the synopsis and the implementation in sync.
In this case, the synopsis has operator<=> after the removed comparisons. I think we should also use that order here in the implementation, i.e. switch the #if branches

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

25

afaik <variant> has a standard-mandated include to <compare. Hence, this include shouldn't be necessary

[avogelsgesang]

libcxx/docs/Status/SpaceshipProjects.csv

27–28

I updated the SpaceshipProjects.csv upstream to link a couple of in-flight reviews, also including this one. Please rebase on current main.

libcxx/include/__variant/monostate.h

34

Let's continue this discussion in https://reviews.llvm.org/D131363#inline-1263505

[Mordante]

Thanks for working on this!

libcxx/include/__variant/monostate.h

33

consexpr already implies inline.

libcxx/include/variant

184–189

we typically use remove in instead of until (like cppreference).

1646

inline isn't needed here, both a template and constexpr imply that.

1650

please use clang-format on this new code.

1656

Why a separate lambda instead of a lambda in the visitor?

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

25

As a side note, you can just include headers unconditionally, they will be installed even when their contents in unavailable in a language version. (There are some exceptions, which apply when language features are disabled, like no localization available.)

28

Can you improve this test and the next by using the comparison macros and using our current constexpr test pattern

int main(int, const char**) {
  test();
  static_assert(test());

  return 0;
}

[mumbleskates]

• add comment in test for tested operator
• don't conditionally include <compare>
• use runtime-and-static assert pattern for monostate test
• use test macros for monostate relops

libcxx/include/variant

1646

Should inline therefore be removed from all of these operators?

1650

just for this function? i can't seem to get my editor to run clang-format only on selected code, so it's quite painful. i'm also not sure if the result really helps readability here, it just shuffles some linebreaks around.

are there specific formatting rules you'd like to be honored?

1656

To keep line length and readability under control, mostly, same reason we added using for the return type.

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

28

done

[mumbleskates]

libcxx/include/variant

1646

this whole file is only C++17 onward; i am less familiar with the progression of the associated keyword rules. should we have a separate differential to fix this if it's widespread within this file?

[avogelsgesang]

libcxx/include/__variant/monostate.h

33

as I learned today in a different review, _LIBCPP_INLINE_VISIBILITY was superseded by _LIBCPP_HIDE_FROM_ABI (see https://libcxx.llvm.org/DesignDocs/VisibilityMacros.html#visibility-macros)

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

28

please also update variant.relops/three_way.pass.cpp to follow this constexpr testing pattern and use the comparison test macros

[mumbleskates]

• modernize variant three_way test
• _LIBCPP_INLINE_VISIBILITY --> _LIBCPP_HIDE_FROM_ABI, remove unnecessary inlines

libcxx/include/__variant/monostate.h

33

i've replaced all cases of _LIBCPP_INLINE_VISIBILITY with _LIBCPP_HIDE_FROM_ABI and removed inline in every case where the function itself was either constexpr or a template function.

this establishes consistency and modern practice at the expense of ~90 lines of noise. let me know if we ought to fork that to a new differential.

libcxx/include/variant

184–189

i see 35 instances of "// until c++" and 41 instances of "// removed in c++" in v1/include. cppreference uses the two interchangeably, typically putting "until" next to the full signature (as we are writing here) and "removed in" next to the short name. (see: pair/operator_cmp, variant/operator_cmp, monostate).

[mumbleskates]

• also use _LIBCPP_HIDE_FROM_ABI in monostate

[Mordante]

This is getting close to be ready, some minor issue remain.

libcxx/include/__variant/monostate.h

33

Thanks! FYI I normally prefer those cleanups in a separate commit, but since they are simple changes I'm fine keeping them this time.

33

as I learned today in a different review, _LIBCPP_INLINE_VISIBILITY was superseded by _LIBCPP_HIDE_FROM_ABI

Historically we haven't always resolved our tech-debt, but we're better at it nowadays :-)

34

This isn't something we really do in libc++, I don't object against it but I don't see it as mandatory.
(I agree there's a benefit to do it.)

libcxx/include/variant

184–189

I see, the code I looked at thus-far uses removed in. But feel free to keep this as is.

748

please fix the formatting, can you also fix line 742?

1652

The return is normally on its own line.

FYI git clang-format HEAD^ can be used to format the changes in the last commit and then you can amend the wanted changes. This is basically what I do to format only relevant changes.

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

19

Can you move this to line 8?

74

Why switch the order of V1 and V2?

107

Can you add a test for std::partial_ordering::unordered?

[avogelsgesang]

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

31–44

testComparisons returns a bool indicating if it was succesful or not. The way you wrote this test case, it does not provide the intended test coverage.
The correct way to write this is

assert(testComparisons(m1, m2, /*isEqual*/ true, /*isLess*/ false));

Here and below in line 34

Also see https://reviews.llvm.org/D131364 and consider giving me a review on that

[mumbleskates]

• correctly wrap testOrder and testComparisons in asserts
• fix nits
• run git clang-format on all changes
• manually clang-format the added function
• manually fix spacing of multiline macros
• add partial_ordering::unordered test cases & utils support
• refactor testComparisons and clean up includes
• add nodiscard vis a vis D131364
• order things sensibly because this is C++

libcxx/include/variant

1652

git clang-format HEAD^ does not seem to actually change anything in <variant> even when i squash all the changes in this differential into a single commit. it does clean up a couple things in some of the other files, though. likewise git clang-format main does nothing once those changes are applied; it never decides to act on <variant>.

i let it format that function manually (even though i'm not really on board with un-braced controlled statements on a different line) and normalized all the indentation to the trailing backslashes in multiline macros to the old 80 column limit. but, i still don't know why it chose not to touch this file.

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

31–44

dang you're right, i saw that differential and didn't remember it here. it's a good change

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

19

sure!

74

great question, not sure how that happened

107

yes! doing so revealed a core deficiency in the test_comparisons.h helper header as well, so i expanded upon that file to support testing unordered values.

[avogelsgesang]

libcxx/test/support/test_comparisons.h

98

copying @philnik's comment from https://reviews.llvm.org/D131364:

You shouldn't use libc++-specific macros in the tests. Instead, add a new macro to test_macros.h and use it here. Otherwise the tests that use test_comparisons.h would break for other implementations.

[mumbleskates]

• assert return value types and simplify order value expressions
• add TEST_NODISCARD macro
• use TEST_NODISCARD
• formatting

[mumbleskates]

libcxx/test/support/test_comparisons.h

98

done. feel free to borrow the macro definition i made here, this should cover just about every case we care about, and i think it's right.

[philnik]

libcxx/test/support/test_macros.h

238–246 ↗

(On Diff #451963)

I think this should just be

#if __has_cpp_attribute(nodiscard)
#  define TEST_NODISCARD [[nodiscard]]
#else
#  define TEST_NODISCARD
#endif

I don't really see a reason to use warn_unused_result, since both clang and GCC have [[nodiscard]] as an extension since C++11 and Microsoft only tests with C++14 and later anyways AFAICT. Also, our __config header says:

// We can't use GCC's [[gnu::warn_unused_result]] and
// __attribute__((warn_unused_result)), because GCC does not silence them via
// (void) cast.

[avogelsgesang]

LGTM, after addressing @philnik's comment regarding the TEST_NODISCARD macro.
Thank you! :)

[mumbleskates]

• simplify TEST_NODISCARD definition per feedback

libcxx/test/support/test_macros.h

238–246 ↗

(On Diff #451963)

thanks! done

[mumbleskates]

libcxx/test/support/test_comparisons.h

156

Likewise here, I feel that this function should also be asserting the same type is returned when the operands are swapped. Unless there's something I'm forgetting and that can't possibly happen due to how operators are resolved in c++20...

161–164

Here's a question for you all: Should these instead be spelled as comparisons against zero? It seems possibly better not to assume the ordering type has normally named members, right? This seems like it would enable testing against user-typed orderings while assuming nothing about them except the basis of their usage in expressions.

I also have been wondering if this function should assert the returned type of t1 <=> t2 (and probably t2 <=> t1); other than a recently created test in D130295 this already holds true in the entire test suite, and it seems like an unexpected gotcha that it actually doesn't assert anything about the type. This would especially hold true after the above change, when you could otherwise simply use int for the Order type (as long as we are not also checking (t2 <=> t1 == (0 <=> order)), which would not work with int).

165

Furthermore, should this not also check that (t2 <=> t1 == (0 <=> order))? (and, depending on consensus above, check the type of t2 <=> t1)

[mumbleskates]

• re-add possibly less confusing assert to testComparisons that does not reference a parameter it doesn't have
• Merge branch 'main' into variant
• add sfinae tests for variant::operator<=>
• variant::operator<=> does NOT require three_way_comparable for its types in the standard

[mumbleskates]

i suspect we can ship this differential as-is without fiddling with test_comparisons.h any further, and any further changes we want to make to that file should be done in another differential.

libcxx/include/variant

1646–1665

it turns out this three_way_comparable concept requirement is far too strict and does not exist in the standard. all this operator needs to do is visit its children's operator<=>s, which is already performed by the return type.

[Mordante]

Thanks for your comments.

libcxx/test/support/test_comparisons.h

156

Good point, feel free to add it.

161–164

The types themselves are normally tested in the static_assert for the return type. So I don't think we need to do it here too. But it seems we didn't do it properly in D130295 so maybe it's useful.

I had a look at the Standard, but is it allowed to return something else as one of the ordering categories?

165

How do you feel about making a separate patch with the proposed improvements?

[mumbleskates]

libcxx/test/support/test_comparisons.h

161–164

i think it makes sense to put it in here, since it seems like a gotcha that the returned order was actually different than the one you provided in the test. it seems trivially true that you should always provide the exact type that you expect to see whenever you call testOrder, and even if we assert the type there we still don't obsolete AssertOrderReturn since we aren't asserting anything about the basic operators returning bool.

as for non-standard ordering types:

it's an allowable thing to do because the usages of ordering-typed values are written in terms of order @ 0, as are the synthesized operations (for example, when a type only defines <=> and maybe ==). i know that in most places in the standard library, a lot of the things that are doing <=> need to return a common comparison category; user ordering types will never mesh with those so they are eliminated by SFINAE, but user orderings *do* work for synthesis of basic comparison operators, and indeed synth-three-way.

if there is a standard function that returns a templated type's operator<=> result without gatekeeping on three_way_comparable_with, we might return a user ordering there (compare_three_way_result_t will resolve user ordering types). i have no idea whether any such cases exist. in the case of basic_string_view as one example the standard seems to explicitly state that non-standard ordering types are ill-formed.

whatever the case for the code under test, it still seems like we can broaden the use-cases for this function by spelling things differently. just because we might not have a use for it in testing the behavior of actual standard functions doesn't mean we can't use it, like sanity checking the behavior of a type that returns custom orderings for testing purposes.

165

yeah at this point i'm planning on doing this :) i can perhaps also try to tackle improving support/make_string.h to use char_traits correctly in the basic_string_view tests if you don't get there first.

[mumbleskates]

okay, every comment is either resolved or involves work that should go into another differential.

libcxx/include/variant

748

i got these a couple updates ago :)

[Mordante]

LGTM, some comments but as discussed these should be done in separate patches.

libcxx/include/variant

748

When I wrote the comment it wasn't done, I guess it wasn't marked as done before ;-)

libcxx/test/support/test_comparisons.h

161–164

Then let's add it as you suggested. However in that patch it would be good to refer to the Standard wording where this is allowed. This seems quite odd and confusing. (Just like equal and equivalent being the same and path having an equal and equivalent which isn't the same.)

165

That would be great! I happily leave it to you; I have enough other things I want to work one ;-)

libcxx/docs/Status/SpaceshipProjects.csv

 | `[syserr.compare] <https://wg21.link/syserr.compare>`_,"| `error_code <https://reviews.llvm.org/D131371>`_
 | `error_condition <https://reviews.llvm.org/D131371>`_",None,Adrian Vogelsgesang,|In Progress|
 | `[tuple.rel] <https://wg21.link/tuple.rel>`_,| `tuple <https://reviews.llvm.org/D108250>`_,[expos.only.func],Kent Ross,|Complete|
 "| `[optional.relops] <https://wg21.link/optional.relops>`_
 | `[optional.nullops] <https://wg21.link/optional.nullops>`_
 | `[optional.comp.with.t] <https://wg21.link/optional.comp.with.t>`_","| optional
 | nullopt",None,Kent Ross,|In Progress|
 "| `[variant.relops] <https://wg21.link/variant.relops>`_
 | `[variant.monostate.relops] <https://wg21.link/variant.monostate.relops>`_","| `monostate <https://reviews.llvm.org/D131372>`_
-| `variant <https://reviews.llvm.org/D131372>`_",None,Kent Ross,|In Progress|
+| `variant <https://reviews.llvm.org/D131372>`_",None,Kent Ross,|Complete|
 | `[unique.ptr.special] <https://wg21.link/unique.ptr.special>`_,| `unique_ptr <https://reviews.llvm.org/D130838>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[util.smartptr.shared.cmp] <https://wg21.link/util.smartptr.shared.cmp>`_,| `shared_ptr <https://reviews.llvm.org/D130852>`_,[comparisons.three.way],Adrian Vogelsgesang,|Complete|
 | `[type.index.members] <https://wg21.link/type.index.members>`_,| `type_index <https://reviews.llvm.org/D131357>`_,None,Adrian Vogelsgesang,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| to_chars_result,None,Mark de Wever,|Complete|
 | `[charconv.syn] <https://wg21.link/charconv.syn>`_,| from_chars_result,None,Mark de Wever,|Complete|
 | `[stacktrace.entry.cmp] <https://wg21.link/stacktrace.entry.cmp>`_,| stacktrace_entry,None,Unassigned,|Not Started|
 | `[stacktrace.basic.cmp] <https://wg21.link/stacktrace.basic.cmp>`_,| basic_stacktrace,[alg.three.way],Unassigned,|Not Started|
 | `[string.cmp] <https://wg21.link/string.cmp>`_,| `basic_string <https://reviews.llvm.org/D131421>`,None,Mark de Wever,|Complete|

libcxx/include/__variant/monostate.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___VARIANT_MONOSTATE_H
 #define _LIBCPP___VARIANT_MONOSTATE_H
 
+#include <__compare/ordering.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 
 struct _LIBCPP_TEMPLATE_VIS monostate {};
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator<(monostate, monostate) noexcept { return false; }
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator>(monostate, monostate) noexcept { return false; }
+#  if _LIBCPP_STD_VER > 17
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
+  return strong_ordering::equal;
+}
+
+#  else // _LIBCPP_STD_VER > 17
+
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; }
+
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator==(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+#  endif // _LIBCPP_STD_VER > 17
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
   using argument_type = monostate;
   using result_type = size_t;
 
-  inline _LIBCPP_INLINE_VISIBILITY
-  result_type operator()(const argument_type&) const _NOEXCEPT {
+  inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT {
     return 66740831; // return a fundamentally attractive random value.
   }
 };
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___VARIANT_MONOSTATE_H

libcxx/include/variant

namespace std {
   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 common_comparison_category_t<compare_three_way_result_t<Types>...>
+    operator<=>(const variant<Types...>&, const variant<Types...>&);           // since C++20
+
   // 20.7.6, visitation
   template <class Visitor, class... Variants>
   constexpr see below visit(Visitor&&, Variants&&...);
 
   template <class R, class Visitor, class... Variants>
   constexpr R visit(Visitor&&, Variants&&...); // since C++20
 
   // 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;
+  constexpr bool operator!=(monostate, monostate) noexcept;             // until C++20
+  constexpr bool operator<(monostate, monostate) noexcept;              // until C++20
+  constexpr bool operator>(monostate, monostate) noexcept;              // until C++20
+  constexpr bool operator<=(monostate, monostate) noexcept;             // until C++20
+  constexpr bool operator>=(monostate, monostate) noexcept;             // until C++20
+  constexpr strong_ordering operator<=>(monostate, monostate) noexcept; // since C++20
 
   // 20.7.9, specialized algorithms
   template <class... Types>
   void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
 
   // 20.7.10, class bad_variant_access
   class bad_variant_access;
 
   // 20.7.11, hash support
   template <class T> struct hash;
   template <class... Types> struct hash<variant<Types...>>;
   template <> struct hash<monostate>;
 
 } // namespace std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
+#include <__compare/common_comparison_category.h>
+#include <__compare/compare_three_way_result.h>
+#include <__compare/three_way_comparable.h>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
 #include <__tuple>
 #include <__type_traits/dependent_type.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
struct __farray {
 
   _LIBCPP_INLINE_VISIBILITY constexpr
   const _Tp &operator[](size_t __n) const noexcept {
       return __buf_[__n];
   }
 };
 
 _LIBCPP_NORETURN
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 void __throw_bad_variant_access() {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw bad_variant_access();
 #else
         _VSTD::abort();
 #endif
 }

 _LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>&&
 __as_variant(const variant<_Types...>&& __vs) noexcept {
   return _VSTD::move(__vs);
 }
 
 namespace __find_detail {
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr size_t __find_index() {
   constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
   size_t __result = __not_found;
   for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
     if (__matches[__i]) {
       if (__result != __not_found) {
         return __ambiguous;
       }

 template <typename _Tp,
           template <typename> class _IsTriviallyAvailable,
           template <typename> class _IsAvailable>
 constexpr _Trait __trait =
     _IsTriviallyAvailable<_Tp>::value
         ? _Trait::_TriviallyAvailable
         : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;
 
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
   _Trait __result = _Trait::_TriviallyAvailable;
   for (_Trait __t : __traits) {
     if (static_cast<int>(__t) > static_cast<int>(__result)) {
       __result = __t;
     }
   }
   return __result;
struct __traits {
   static constexpr _Trait __destructible_trait = __common_trait(
       {__trait<_Types, is_trivially_destructible, is_destructible>...});
 };
 
 namespace __access {
 
 struct __union {
   template <class _Vp>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
     return _VSTD::forward<_Vp>(__v).__head;
   }
 
   template <class _Vp, size_t _Ip>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
     return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
   }
 };
 
 struct __base {
   template <size_t _Ip, class _Vp>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto&& __get_alt(_Vp&& __v) {
     return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
                               in_place_index<_Ip>);
   }
 };
 
 struct __variant {
   template <size_t _Ip, class _Vp>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto&& __get_alt(_Vp&& __v) {
     return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
   }
 };
 
 } // namespace __access
 
 namespace __visitation {
 
 struct __base {
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto)
   __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
     constexpr auto __fdiagonal =
         __make_fdiagonal<_Visitor&&,
                          decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
     return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
                                 _VSTD::forward<_Vs>(__vs).__as_base()...);
   }
 
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
                                               _Vs&&... __vs) {
     constexpr auto __fmatrix =
         __make_fmatrix<_Visitor&&,
                        decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
     return __at(__fmatrix, __vs.index()...)(
         _VSTD::forward<_Visitor>(__visitor),
         _VSTD::forward<_Vs>(__vs).__as_base()...);
   }
 
 private:
   template <class _Tp>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }
 
   template <class _Tp, size_t _Np, typename... _Indices>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto&& __at(const __farray<_Tp, _Np>& __elems,
                                size_t __index, _Indices... __indices) {
     return __at(__elems[__index], __indices...);
   }
 
   template <class _Fp, class... _Fs>
   static constexpr void __std_visit_visitor_return_type_check() {
     static_assert(
         __all<is_same_v<_Fp, _Fs>...>::value,
         "`std::visit` requires the visitor to have a single return type.");
   }
 
   template <class... _Fs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_farray(_Fs&&... __fs) {
     __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>();
     using __result = __farray<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>;
     return __result{{_VSTD::forward<_Fs>(__fs)...}};
   }
 
   template <size_t... _Is>
   struct __dispatcher {
     template <class _Fp, class... _Vs>
-    inline _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_HIDE_FROM_ABI
     static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
         return _VSTD::__invoke(
             static_cast<_Fp>(__f),
             __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
     }
   };
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_dispatch(index_sequence<_Is...>) {
     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
   }
 
   template <size_t _Ip, class _Fp, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fdiagonal_impl() {
     return __make_dispatch<_Fp, _Vs...>(
         index_sequence<((void)__type_identity<_Vs>{}, _Ip)...>{});
   }
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
     return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
   }
 
   template <class _Fp, class _Vp, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fdiagonal() {
     constexpr size_t _Np = __uncvref_t<_Vp>::__size();
     static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value);
     return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
   }
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
     return __make_dispatch<_Fp, _Vs...>(__is);
   }
 
   template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
                                             index_sequence<_Js...>,
                                             _Ls... __ls) {
     return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
         index_sequence<_Is..., _Js>{}, __ls...)...);
   }
 
   template <class _Fp, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_fmatrix() {
     return __make_fmatrix_impl<_Fp, _Vs...>(
         index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...);
   }
 };
 
 struct __variant {
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto)
   __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
     return __base::__visit_alt_at(__index,
                                   _VSTD::forward<_Visitor>(__visitor),
                                   _VSTD::forward<_Vs>(__vs).__impl...);
   }
 
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
                                               _Vs&&... __vs) {
     return __base::__visit_alt(
         _VSTD::forward<_Visitor>(__visitor),
         _VSTD::__as_variant(_VSTD::forward<_Vs>(__vs)).__impl...);
   }
 
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto)
   __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
     return __visit_alt_at(
         __index,
         __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
         _VSTD::forward<_Vs>(__vs)...);
   }
 
   template <class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
                                                 _Vs&&... __vs) {
     return __visit_alt(
         __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
         _VSTD::forward<_Vs>(__vs)...);
   }
 
 #if _LIBCPP_STD_VER > 17
   template <class _Rp, class _Visitor, class... _Vs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr _Rp __visit_value(_Visitor&& __visitor,
                                      _Vs&&... __vs) {
     return __visit_alt(
         __make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)),
         _VSTD::forward<_Vs>(__vs)...);
   }
 #endif
 
 private:
   template <class _Visitor, class... _Values>
   static constexpr void __std_visit_exhaustive_visitor_check() {
     static_assert(is_invocable_v<_Visitor, _Values...>,
                   "`std::visit` requires the visitor to be exhaustive.");
   }
 
   template <class _Visitor>
   struct __value_visitor {
     template <class... _Alts>
-    inline _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_HIDE_FROM_ABI
     constexpr decltype(auto) operator()(_Alts&&... __alts) const {
       __std_visit_exhaustive_visitor_check<
           _Visitor,
           decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
       return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
                              _VSTD::forward<_Alts>(__alts).__value...);
     }
     _Visitor&& __visitor;
   };
 
 #if _LIBCPP_STD_VER > 17
   template <class _Rp, class _Visitor>
   struct __value_visitor_return_type {
     template <class... _Alts>
-    inline _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_HIDE_FROM_ABI
     constexpr _Rp operator()(_Alts&&... __alts) const {
       __std_visit_exhaustive_visitor_check<
           _Visitor,
           decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
       if constexpr (is_void_v<_Rp>) {
         _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
                         _VSTD::forward<_Alts>(__alts).__value...);
       }
       else {
         return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
                                _VSTD::forward<_Alts>(__alts).__value...);
       }
     }
 
     _Visitor&& __visitor;
   };
 #endif
 
   template <class _Visitor>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
     return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
   }
 
 #if _LIBCPP_STD_VER > 17
   template <class _Rp, class _Visitor>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
     return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)};
   }
 #endif
 };
 
 } // namespace __visitation
 
 template <size_t _Index, class _Tp>
 struct _LIBCPP_TEMPLATE_VIS __alt {
   using __value_type = _Tp;
 
   template <class... _Args>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr __alt(in_place_t, _Args&&... __args)
       : __value(_VSTD::forward<_Args>(__args)...) {}
 
   __value_type __value;
 };
 
 template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
 union _LIBCPP_TEMPLATE_VIS __union;
 
 template <_Trait _DestructibleTrait, size_t _Index>
 union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
 
 #define _LIBCPP_VARIANT_UNION(destructible_trait, destructor)                  \
   template <size_t _Index, class _Tp, class... _Types>                         \
-  union _LIBCPP_TEMPLATE_VIS __union<destructible_trait,                      \
+  union _LIBCPP_TEMPLATE_VIS __union<destructible_trait,                       \
                                       _Index,                                  \
                                       _Tp,                                     \
                                       _Types...> {                             \
   public:                                                                      \
-    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    _LIBCPP_HIDE_FROM_ABI                                                      \
     explicit constexpr __union(__valueless_t) noexcept : __dummy{} {}          \
                                                                                \
     template <class... _Args>                                                  \
-    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    _LIBCPP_HIDE_FROM_ABI                                                      \
     explicit constexpr __union(in_place_index_t<0>, _Args&&... __args)         \
         : __head(in_place, _VSTD::forward<_Args>(__args)...) {}                \
                                                                                \
     template <size_t _Ip, class... _Args>                                      \
-    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    _LIBCPP_HIDE_FROM_ABI                                                      \
     explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args)       \
         : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
                                                                                \
     __union(const __union&) = default;                                         \
     __union(__union&&) = default;                                              \
                                                                                \
     destructor                                                                 \
                                                                                \

 
 #undef _LIBCPP_VARIANT_UNION
 
 template <_Trait _DestructibleTrait, class... _Types>
 class _LIBCPP_TEMPLATE_VIS __base {
 public:
   using __index_t = __variant_index_t<sizeof...(_Types)>;
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr __base(__valueless_t __tag) noexcept
       : __data(__tag), __index(__variant_npos<__index_t>) {}
 
   template <size_t _Ip, class... _Args>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
       :
         __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
         __index(_Ip) {}
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr bool valueless_by_exception() const noexcept {
     return index() == variant_npos;
   }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr size_t index() const noexcept {
     return __index == __variant_npos<__index_t> ? variant_npos : __index;
   }
 
 protected:
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto&& __as_base() & { return *this; }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto&& __as_base() && { return _VSTD::move(*this); }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto&& __as_base() const & { return *this; }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr auto&& __as_base() const && { return _VSTD::move(*this); }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static constexpr size_t __size() { return sizeof...(_Types); }
 
   __union<_DestructibleTrait, 0, _Types...> __data;
   __index_t __index;
 
   friend struct __access::__base;
   friend struct __visitation::__base;
 };
using __base_type::operator=;                                              \
                                                                                \
     __dtor(const __dtor&) = default;                                           \
     __dtor(__dtor&&) = default;                                                \
     destructor                                                                 \
     __dtor& operator=(const __dtor&) = default;                                \
     __dtor& operator=(__dtor&&) = default;                                     \
                                                                                \
   protected:                                                                   \
-    inline _LIBCPP_INLINE_VISIBILITY                                           \
+    inline _LIBCPP_HIDE_FROM_ABI                                               \
     destroy                                                                    \
   }
 
 _LIBCPP_VARIANT_DESTRUCTOR(
     _Trait::_TriviallyAvailable,
     ~__dtor() = default;,
     void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
 
class _LIBCPP_TEMPLATE_VIS __ctor : public __dtor<_Traits> {
   using __base_type = __dtor<_Traits>;
 
 public:
   using __base_type::__base_type;
   using __base_type::operator=;
 
 protected:
   template <size_t _Ip, class _Tp, class... _Args>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
     ::new ((void*)_VSTD::addressof(__a))
         __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
     return __a.__value;
   }
 
   template <class _Rhs>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
     __lhs.__destroy();
     if (!__rhs.valueless_by_exception()) {
       __visitation::__base::__visit_alt_at(
           __rhs.index(),
           [](auto& __lhs_alt, auto&& __rhs_alt) {
             __construct_alt(
                 __lhs_alt,

 #undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
 
 template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
 class _LIBCPP_TEMPLATE_VIS __copy_constructor;
 
 #define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait,             \
                                          copy_constructor)                     \
   template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>,          \
+  class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>,           \
                                                  copy_constructible_trait>     \
       : public __move_constructor<__traits<_Types...>> {                       \
     using __base_type = __move_constructor<__traits<_Types...>>;               \
                                                                                \
   public:                                                                      \
     using __base_type::__base_type;                                            \
     using __base_type::operator=;                                              \
                                                                                \

 class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
   using __base_type = __copy_constructor<_Traits>;
 
 public:
   using __base_type::__base_type;
   using __base_type::operator=;
 
   template <size_t _Ip, class... _Args>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   auto& __emplace(_Args&&... __args) {
     this->__destroy();
     auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
                           _VSTD::forward<_Args>(__args)...);
     this->__index = _Ip;
     return __res;
   }
 
 protected:
   template <size_t _Ip, class _Tp, class _Arg>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
     if (this->index() == _Ip) {
       __a.__value = _VSTD::forward<_Arg>(__arg);
     } else {
       struct {
         void operator()(true_type) const {
           __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
         }
         void operator()(false_type) const {
           __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
         }
         __assignment* __this;
         _Arg&& __arg;
       } __impl{this, _VSTD::forward<_Arg>(__arg)};
       __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> ||
                            !is_nothrow_move_constructible_v<_Tp>>{});
     }
   }
 
   template <class _That>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   void __generic_assign(_That&& __that) {
     if (this->valueless_by_exception() && __that.valueless_by_exception()) {
       // do nothing.
     } else if (__that.valueless_by_exception()) {
       this->__destroy();
     } else {
       __visitation::__base::__visit_alt_at(
           __that.index(),
           [this](auto& __this_alt, auto&& __that_alt) {
             this->__assign_alt(
                 __this_alt,
                 _VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
           },
           *this, _VSTD::forward<_That>(__that));
     }
   }
 };
 
 template <class _Traits, _Trait = _Traits::__move_assignable_trait>
 class _LIBCPP_TEMPLATE_VIS __move_assignment;
 
 #define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait,                 \
                                         move_assignment)                       \
   template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>,           \
+  class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>,            \
                                                 move_assignable_trait>         \
       : public __assignment<__traits<_Types...>> {                             \
     using __base_type = __assignment<__traits<_Types...>>;                     \
                                                                                \
   public:                                                                      \
     using __base_type::__base_type;                                            \
     using __base_type::operator=;                                              \
                                                                                \

 #undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
 
 template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
 class _LIBCPP_TEMPLATE_VIS __copy_assignment;
 
 #define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait,                 \
                                         copy_assignment)                       \
   template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>,           \
+  class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>,            \
                                                 copy_assignable_trait>         \
       : public __move_assignment<__traits<_Types...>> {                        \
     using __base_type = __move_assignment<__traits<_Types...>>;                \
                                                                                \
   public:                                                                      \
     using __base_type::__base_type;                                            \
     using __base_type::operator=;                                              \
                                                                                \

 public:
   using __base_type::__base_type; // get in_place_index_t constructor & friends
   __impl(__impl const&) = default;
   __impl(__impl&&) = default;
   __impl& operator=(__impl const&) = default;
   __impl& operator=(__impl&&) = default;
 
   template <size_t _Ip, class _Arg>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   void __assign(_Arg&& __arg) {
     this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
                        _VSTD::forward<_Arg>(__arg));
   }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  inline _LIBCPP_HIDE_FROM_ABI
   void __swap(__impl& __that)  {
     if (this->valueless_by_exception() && __that.valueless_by_exception()) {
       // do nothing.
     } else if (this->index() == __that.index()) {
       __visitation::__base::__visit_alt_at(
           this->index(),
           [](auto& __this_alt, auto& __that_alt) {
             using _VSTD::swap;
#else
       // `throw` being ill-formed with exceptions disabled even when discarded.
       this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
 #endif
       this->__generic_construct(*__lhs, _VSTD::move(__tmp));
     }
   }
 
 private:
-  inline _LIBCPP_INLINE_VISIBILITY
+  inline _LIBCPP_HIDE_FROM_ABI
   bool __move_nothrow() const {
     constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
     return this->valueless_by_exception() || __results[this->index()];
   }
 };
 
 struct __no_narrowing_check {
   template <class _Dest, class _Source>
class _LIBCPP_TEMPLATE_VIS variant
 
   using __first_type = variant_alternative_t<0, variant>;
 
 public:
   template <bool _Dummy = true,
             enable_if_t<__dependent_type<is_default_constructible<__first_type>,
                                          _Dummy>::value,
                         int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
       : __impl(in_place_index<0>) {}
 
   variant(const variant&) = default;
   variant(variant&&) = default;
 
   template <
       class _Arg,
       enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
       enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0,
       enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0,
       class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr variant(_Arg&& __arg) noexcept(
       is_nothrow_constructible_v<_Tp, _Arg>)
       : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}
 
   template <size_t _Ip, class... _Args,
             class = enable_if_t<(_Ip < sizeof...(_Types)), int>,
             class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
             enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr variant(
       in_place_index_t<_Ip>,
       _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
       : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
 
   template <
       size_t _Ip,
       class _Up,
       class... _Args,
       enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
       class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
       enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
                   int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr variant(
       in_place_index_t<_Ip>,
       initializer_list<_Up> __il,
       _Args&&... __args) noexcept(
       is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
       : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
 
   template <
       class _Tp,
       class... _Args,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
       is_nothrow_constructible_v<_Tp, _Args...>)
       : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
 
   template <
       class _Tp,
       class _Up,
       class... _Args,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
                   int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   explicit constexpr variant(
       in_place_type_t<_Tp>,
       initializer_list<_Up> __il,
       _Args&&... __args) noexcept(
       is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
       : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
 
   ~variant() = default;
 
   variant& operator=(const variant&) = default;
   variant& operator=(variant&&) = default;
 
   template <
       class _Arg,
       enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
       class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
                   int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   variant& operator=(_Arg&& __arg) noexcept(
       is_nothrow_assignable_v<_Tp&, _Arg> &&
       is_nothrow_constructible_v<_Tp, _Arg>) {
     __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
     return *this;
   }
 
   template <
       size_t _Ip,
       class... _Args,
       enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
       class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
       enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   _Tp& emplace(_Args&&... __args) {
     return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
   }
 
   template <
       size_t _Ip,
       class _Up,
       class... _Args,
       enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
       class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
       enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
                   int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
     return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
   }
 
   template <
       class _Tp,
       class... _Args,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   _Tp& emplace(_Args&&... __args) {
     return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
   }
 
   template <
       class _Tp,
       class _Up,
       class... _Args,
       size_t _Ip =
           __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
       enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
                   int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
     return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
   }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr bool valueless_by_exception() const noexcept {
     return __impl.valueless_by_exception();
   }
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   constexpr size_t index() const noexcept { return __impl.index(); }
 
   template <
       bool _Dummy = true,
       enable_if_t<
           __all<(
               __dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
               __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
           int> = 0>
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   void swap(variant& __that) noexcept(
       __all<(is_nothrow_move_constructible_v<_Types> &&
              is_nothrow_swappable_v<_Types>)...>::value) {
     __impl.__swap(__that.__impl);
   }
 
 private:
   __variant_detail::__impl<_Types...> __impl;
 
   friend struct __variant_detail::__access::__variant;
   friend struct __variant_detail::__visitation::__variant;
 };
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
   return __v.index() == _Ip;
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
   return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <size_t _Ip, class _Vp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr auto&& __generic_get(_Vp&& __v) {
   using __variant_detail::__access::__variant;
   if (!__holds_alternative<_Ip>(__v)) {
     __throw_bad_variant_access();
   }
   return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
     variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
     variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get<_Ip>(_VSTD::move(__v));
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
     const variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
     const variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get<_Ip>(_VSTD::move(__v));
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr _Tp& get(variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr _Tp&& get(variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
       _VSTD::move(__v));
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const _Tp& get(const variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
 constexpr const _Tp&& get(const variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
       _VSTD::move(__v));
 }
 
 template <size_t _Ip, class _Vp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr auto* __generic_get_if(_Vp* __v) noexcept {
   using __variant_detail::__access::__variant;
   return __v && __holds_alternative<_Ip>(*__v)
              ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
              : nullptr;
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get_if<_Ip>(__v);
 }
 
 template <size_t _Ip, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(const variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return __generic_get_if<_Ip>(__v);
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<_Tp>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr add_pointer_t<const _Tp>
 get_if(const variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
   return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Operator>
 struct __convert_to_bool {
   template <class _T1, class _T2>
-  _LIBCPP_INLINE_VISIBILITY constexpr bool operator()(_T1 && __t1, _T2&& __t2) const {
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr bool operator()(_T1 && __t1, _T2&& __t2) const {
     static_assert(is_convertible<decltype(_Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2))), bool>::value,
         "the relational operator does not return a type which is implicitly convertible to bool");
     return _Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
   }
 };
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator==(const variant<_Types...>& __lhs,
                           const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.index() != __rhs.index()) return false;
   if (__lhs.valueless_by_exception()) return true;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
 }
 
+#  if _LIBCPP_STD_VER > 17
+
+template <class... _Types>
+_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
+operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
+  using __variant_detail::__visitation::__variant;
+  using __result_t = common_comparison_category_t<compare_three_way_result_t<_Types>...>;
+  if (__lhs.valueless_by_exception() && __rhs.valueless_by_exception())
+    return strong_ordering::equal;
+  if (__lhs.valueless_by_exception())
+    return strong_ordering::less;
+  if (__rhs.valueless_by_exception())
+    return strong_ordering::greater;
+  if (auto __c = __lhs.index() <=> __rhs.index(); __c != 0)
+    return __c;
+  auto __three_way = []<class _Type>(const _Type& __v, const _Type& __w) -> __result_t { return __v <=> __w; };
+  return __variant::__visit_value_at(__lhs.index(), __three_way, __lhs, __rhs);
+}
+
+#  endif // _LIBCPP_STD_VER > 17
+
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator!=(const variant<_Types...>& __lhs,
                           const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.index() != __rhs.index()) return true;
   if (__lhs.valueless_by_exception()) return false;
   return __variant::__visit_value_at(
       __lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator<(const variant<_Types...>& __lhs,
                          const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__rhs.valueless_by_exception()) return false;
   if (__lhs.valueless_by_exception()) return true;
   if (__lhs.index() < __rhs.index()) return true;
   if (__lhs.index() > __rhs.index()) return false;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<less<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator>(const variant<_Types...>& __lhs,
                          const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.valueless_by_exception()) return false;
   if (__rhs.valueless_by_exception()) return true;
   if (__lhs.index() > __rhs.index()) return true;
   if (__lhs.index() < __rhs.index()) return false;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<greater<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator<=(const variant<_Types...>& __lhs,
                           const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__lhs.valueless_by_exception()) return true;
   if (__rhs.valueless_by_exception()) return false;
   if (__lhs.index() < __rhs.index()) return true;
   if (__lhs.index() > __rhs.index()) return false;
   return __variant::__visit_value_at(
       __lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr bool operator>=(const variant<_Types...>& __lhs,
                           const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
   if (__rhs.valueless_by_exception()) return true;
   if (__lhs.valueless_by_exception()) return false;
   if (__lhs.index() > __rhs.index()) return true;
   if (__lhs.index() < __rhs.index()) return false;
   return __variant::__visit_value_at(
       __lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
 }
 
 template <class... _Vs>
-inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr void
-    __throw_if_valueless(_Vs&&... __vs) {
+_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+constexpr void __throw_if_valueless(_Vs&&... __vs) {
   const bool __valueless =
       (... || _VSTD::__as_variant(__vs).valueless_by_exception());
   if (__valueless) {
     __throw_bad_variant_access();
   }
 }
 
 template <
     class _Visitor, class... _Vs,
     typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> >
-inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr
-    decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
+_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
   _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
                                   _VSTD::forward<_Vs>(__vs)...);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <
     class _Rp, class _Visitor, class... _Vs,
     typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> >
-inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp
-    visit(_Visitor&& __visitor, _Vs&&... __vs) {
+_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+constexpr _Rp visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
   _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
   return __variant::__visit_value<_Rp>(_VSTD::forward<_Visitor>(__visitor),
                                        _VSTD::forward<_Vs>(__vs)...);
 }
 #endif
 
 template <class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
   noexcept(noexcept(__lhs.swap(__rhs)))
   -> decltype(      __lhs.swap(__rhs))
   { return          __lhs.swap(__rhs); }
 
 template <class... _Types>
 struct _LIBCPP_TEMPLATE_VIS hash<
     __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
   using argument_type = variant<_Types...>;
   using result_type = size_t;
 
-  inline _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI
   result_type operator()(const argument_type& __v) const {
     using __variant_detail::__visitation::__variant;
     size_t __res =
         __v.valueless_by_exception()
                ? 299792458 // Random value chosen by the universe upon creation
                : __variant::__visit_alt(
                      [](const auto& __alt) {
                        using __alt_type = __uncvref_t<decltype(__alt)>;
                        using __value_type = remove_const_t<
                          typename __alt_type::__value_type>;
                        return hash<__value_type>{}(__alt.__value);
                      },
                      __v);
     return __hash_combine(__res, hash<size_t>{}(__v.index()));
   }
 };
 
 // __unchecked_get is the same as std::get, except, it is UB to use it with the wrong
 // type whereas std::get will throw or returning nullptr. This makes it faster than
 // std::get.
 template <size_t _Ip, class _Vp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(_Vp&& __v) noexcept {
   using __variant_detail::__access::__variant;
   return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept {
   return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_HIDE_FROM_ABI
 constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept {
   return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_VARIANT

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

 // <variant>
 
 // 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; }
+// constexpr strong_ordering operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; } // since C++20
 
-#include "test_macros.h"
 #include <cassert>
-#include <type_traits>
 #include <variant>
 
-int main(int, char**) {
+#include "test_comparisons.h"
+#include "test_macros.h"
+
+constexpr bool test() {
   using M = std::monostate;
   constexpr M m1{};
   constexpr M m2{};
-  {
-    static_assert((m1 < m2) == false, "");
-    ASSERT_NOEXCEPT(m1 < m2);
-  }
-  {
-    static_assert((m1 > m2) == false, "");
-    ASSERT_NOEXCEPT(m1 > m2);
-  }
-  {
-    static_assert((m1 <= m2) == true, "");
-    ASSERT_NOEXCEPT(m1 <= m2);
-  }
-  {
-    static_assert((m1 >= m2) == true, "");
-    ASSERT_NOEXCEPT(m1 >= m2);
-  }
-  {
-    static_assert((m1 == m2) == true, "");
-    ASSERT_NOEXCEPT(m1 == m2);
-  }
-  {
-    static_assert((m1 != m2) == false, "");
-    ASSERT_NOEXCEPT(m1 != m2);
-  }
+  assert(testComparisons(m1, m2, /*isEqual*/ true, /*isLess*/ false));
+  AssertComparisonsAreNoexcept<M>();
+
+#if TEST_STD_VER > 17
+  assert(testOrder(m1, m2, std::strong_ordering::equal));
+  AssertOrderAreNoexcept<M>();
+#endif // TEST_STD_VER > 17
+
+  return true;
 
+int main(int, char**) {
+  test();
+  static_assert(test());
+
   return 0;
 }

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <variant>
+
+// template <class... Types> class variant;
+
+// template<class... Types>
+//   constexpr std::common_comparison_category_t<
+//     std::compare_three_way_result_t<Types>...>
+//   operator<=>(const variant<Types...>& t, const variant<Types...>& u);
+
+#include <cassert>
+#include <limits>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#include "test_macros.h"
+#include "test_comparisons.h"
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+// MakeEmptyT throws in operator=(&&), so we can move to it to create valueless-by-exception variants.
+struct MakeEmptyT {
+  MakeEmptyT() = default;
+  MakeEmptyT(MakeEmptyT&&) { throw 42; }
+  MakeEmptyT& operator=(MakeEmptyT&&) { throw 42; }
+};
+inline bool operator==(const MakeEmptyT&, const MakeEmptyT&) {
+  assert(false);
+  return false;
+}
+inline std::weak_ordering operator<=>(const MakeEmptyT&, const MakeEmptyT&) {
+  assert(false);
+  return std::weak_ordering::equivalent;
+}
+
+template <class Variant>
+void makeEmpty(Variant& v) {
+  Variant v2(std::in_place_type<MakeEmptyT>);
+  try {
+    v = std::move(v2);
+    assert(false);
+  } catch (...) {
+    assert(v.valueless_by_exception());
+  }
+}
+
+void test_empty() {
+  {
+    using V = std::variant<int, MakeEmptyT>;
+    V v1;
+    V v2;
+    makeEmpty(v2);
+    assert(testOrder(v1, v2, std::weak_ordering::greater));
+  }
+  {
+    using V = std::variant<int, MakeEmptyT>;
+    V v1;
+    makeEmpty(v1);
+    V v2;
+    assert(testOrder(v1, v2, std::weak_ordering::less));
+  }
+  {
+    using V = std::variant<int, MakeEmptyT>;
+    V v1;
+    makeEmpty(v1);
+    V v2;
+    makeEmpty(v2);
+    assert(testOrder(v1, v2, std::weak_ordering::equivalent));
+  }
+}
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+template <class T1, class T2, class Order>
+constexpr bool test_with_types() {
+  using V = std::variant<T1, T2>;
+  AssertOrderReturn<Order, V>();
+  { // same index, same value
+    constexpr V v1(std::in_place_index<0>, T1{1});
+    constexpr V v2(std::in_place_index<0>, T1{1});
+    assert(testOrder(v1, v2, Order::equivalent));
+  }
+  { // same index, value < other_value
+    constexpr V v1(std::in_place_index<0>, T1{0});
+    constexpr V v2(std::in_place_index<0>, T1{1});
+    assert(testOrder(v1, v2, Order::less));
+  }
+  { // same index, value > other_value
+    constexpr V v1(std::in_place_index<0>, T1{1});
+    constexpr V v2(std::in_place_index<0>, T1{0});
+    assert(testOrder(v1, v2, Order::greater));
+  }
+  { // LHS.index() < RHS.index()
+    constexpr V v1(std::in_place_index<0>, T1{0});
+    constexpr V v2(std::in_place_index<1>, T2{0});
+    assert(testOrder(v1, v2, Order::less));
+  }
+  { // LHS.index() > RHS.index()
+    constexpr V v1(std::in_place_index<1>, T2{0});
+    constexpr V v2(std::in_place_index<0>, T1{0});
+    assert(testOrder(v1, v2, Order::greater));
+  }
+
+  return true;
+}
+
+constexpr bool test_three_way() {
+  assert((test_with_types<int, double, std::partial_ordering>()));
+  assert((test_with_types<int, long, std::strong_ordering>()));
+
+  {
+    using V              = std::variant<int, double>;
+    constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+    {
+      constexpr V v1(std::in_place_type<int>, 1);
+      constexpr V v2(std::in_place_type<double>, nan);
+      assert(testOrder(v1, v2, std::partial_ordering::less));
+    }
+    {
+      constexpr V v1(std::in_place_type<double>, nan);
+      constexpr V v2(std::in_place_type<int>, 2);
+      assert(testOrder(v1, v2, std::partial_ordering::greater));
+    }
+    {
+      constexpr V v1(std::in_place_type<double>, nan);
+      constexpr V v2(std::in_place_type<double>, nan);
+      assert(testOrder(v1, v2, std::partial_ordering::unordered));
+    }
+  }
+
+  return true;
+}
+
+// SFINAE tests
+template <class T, class U = T>
+concept has_three_way_op = requires (T& t, U& u) { t <=> u; };
+
+// std::three_way_comparable is a more stringent requirement that demands
+// operator== and a few other things.
+using std::three_way_comparable;
+
+struct HasSimpleOrdering {
+  constexpr bool operator==(const HasSimpleOrdering&) const;
+  constexpr bool operator<(const HasSimpleOrdering&) const;
+};
+
+struct HasOnlySpaceship {
+  constexpr bool operator==(const HasOnlySpaceship&) const = delete;
+  constexpr std::weak_ordering operator<=>(const HasOnlySpaceship&) const;
+};
+
+struct HasFullOrdering {
+  constexpr bool operator==(const HasFullOrdering&) const;
+  constexpr std::weak_ordering operator<=>(const HasFullOrdering&) const;
+};
+
+// operator<=> must resolve the return types of all its union types'
+// operator<=>s to determine its own return type, so it is detectable by SFINAE
+static_assert(!has_three_way_op<HasSimpleOrdering>);
+static_assert(!has_three_way_op<std::variant<int, HasSimpleOrdering>>);
+
+static_assert(!three_way_comparable<HasSimpleOrdering>);
+static_assert(!three_way_comparable<std::variant<int, HasSimpleOrdering>>);
+
+static_assert( has_three_way_op<HasOnlySpaceship>);
+static_assert( has_three_way_op<std::variant<int, HasOnlySpaceship>>);
+
+// variants containing types with unavailable operator== still exist but will
+// generate a compilation error if their operator== is invoked, so the variant
+// type here participates when asked for operator== and operator<=> even though
+// it would actually fail.
+static_assert(!three_way_comparable<HasOnlySpaceship>);
+static_assert( three_way_comparable<std::variant<int, HasOnlySpaceship>>);
+
+static_assert( has_three_way_op<HasFullOrdering>);
+static_assert( has_three_way_op<std::variant<int, HasFullOrdering>>);
+
+static_assert( three_way_comparable<HasFullOrdering>);
+static_assert( three_way_comparable<std::variant<int, HasFullOrdering>>);
+
+int main(int, char**) {
+  test_three_way();
+  static_assert(test_three_way());
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  test_empty();
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  return 0;
+}

libcxx/test/support/test_comparisons.h

 //      AssertXConvertibleToBool     static_asserts that the operations return something convertible to bool.
 //      testXValues                  returns the result of the comparison of all operations.
 //
 //      AssertOrderConvertibleToBool doesn't exist yet. It will be implemented when needed.
 
 #ifndef TEST_COMPARISONS_H
 #define TEST_COMPARISONS_H
 
-#include <type_traits>
 #include <cassert>
 #include <concepts>
+#include <type_traits>
+#include <utility>
+
 #include "test_macros.h"
 
-//  Test all six comparison operations for sanity
+// Test the consistency of the six basic comparison operators for values that are ordered or unordered.
 template <class T, class U = T>
-TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess)
-{
-    assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
-    if (isEqual)
-        {
+TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool
+testComparisonsComplete(const T& t1, const U& t2, bool isEqual, bool isLess, bool isGreater) {
+    assert(((isEqual ? 1 : 0) + (isLess ? 1 : 0) + (isGreater ? 1 : 0) <= 1) &&
+           "at most one of isEqual, isLess, and isGreater can be true");
+    if (isEqual) {
         if (!(t1 == t2)) return false;
         if (!(t2 == t1)) return false;
         if ( (t1 != t2)) return false;
         if ( (t2 != t1)) return false;
         if ( (t1  < t2)) return false;
         if ( (t2  < t1)) return false;
         if (!(t1 <= t2)) return false;
         if (!(t2 <= t1)) return false;
         if ( (t1  > t2)) return false;
         if ( (t2  > t1)) return false;
         if (!(t1 >= t2)) return false;
         if (!(t2 >= t1)) return false;
-        }
-    else if (isLess)
-        {
+    } else if (isLess) {
         if ( (t1 == t2)) return false;
         if ( (t2 == t1)) return false;
         if (!(t1 != t2)) return false;
         if (!(t2 != t1)) return false;
         if (!(t1  < t2)) return false;
         if ( (t2  < t1)) return false;
         if (!(t1 <= t2)) return false;
         if ( (t2 <= t1)) return false;
         if ( (t1  > t2)) return false;
         if (!(t2  > t1)) return false;
         if ( (t1 >= t2)) return false;
         if (!(t2 >= t1)) return false;
-        }
-    else /* greater */
-        {
+    } else if (isGreater) {
         if ( (t1 == t2)) return false;
         if ( (t2 == t1)) return false;
         if (!(t1 != t2)) return false;
         if (!(t2 != t1)) return false;
         if ( (t1  < t2)) return false;
         if (!(t2  < t1)) return false;
         if ( (t1 <= t2)) return false;
         if (!(t2 <= t1)) return false;
         if (!(t1  > t2)) return false;
         if ( (t2  > t1)) return false;
         if (!(t1 >= t2)) return false;
         if ( (t2 >= t1)) return false;
-        }
+    } else { // unordered
+        if ( (t1 == t2)) return false;
+        if ( (t2 == t1)) return false;
+        if (!(t1 != t2)) return false;
+        if (!(t2 != t1)) return false;
+        if ( (t1  < t2)) return false;
+        if ( (t2  < t1)) return false;
+        if ( (t1 <= t2)) return false;
+        if ( (t2 <= t1)) return false;
+        if ( (t1  > t2)) return false;
+        if ( (t2  > t1)) return false;
+        if ( (t1 >= t2)) return false;
+        if ( (t2 >= t1)) return false;
 
     return true;
 }
 
+// Test the six basic comparison operators for ordered values.
+template <class T, class U = T>
+TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess) {
+    assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
+    bool isGreater = !isEqual && !isLess;
+    return testComparisonsComplete(t1, t2, isEqual, isLess, isGreater);
+}
+
 //  Easy call when you can init from something already comparable.
 template <class T, class Param>
 TEST_NODISCARD TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2)
 {
-    const bool isEqual = val1 == val2;
-    const bool isLess  = val1  < val2;
+    const bool isEqual   = val1 == val2;
+    const bool isLess    = val1 <  val2;
+    const bool isGreater = val1  > val2;
 
-    return testComparisons(T(val1), T(val2), isEqual, isLess);
+    return testComparisonsComplete(T(val1), T(val2), isEqual, isLess, isGreater);
 }
 
 template <class T, class U = T>
 TEST_CONSTEXPR_CXX14 void AssertComparisonsAreNoexcept() {
     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());

 constexpr void AssertOrderAreNoexcept() {
     AssertComparisonsAreNoexcept<T, U>();
     ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
 }
 
 template <class Order, class T, class U = T>
 constexpr void AssertOrderReturn() {
     AssertComparisonsReturnBool<T, U>();
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
 }
 
 template <class Order, class T, class U = T>
 TEST_NODISCARD constexpr bool testOrder(const T& t1, const U& t2, Order order) {
-    bool equal = order == Order::equivalent;
-    bool less = order == Order::less;
+    bool equal   = order == Order::equivalent;
+    bool less    = order == Order::less;
+    bool greater = order == Order::greater;
 
-    return (t1 <=> t2 == order) && testComparisons(t1, t2, equal, less);
+    return (t1 <=> t2 == order) && testComparisonsComplete(t1, t2, equal, less, greater);
 }
 
 template <class T, class Param>
 TEST_NODISCARD constexpr bool testOrderValues(Param val1, Param val2) {
   return testOrder(T(val1), T(val2), val1 <=> val2);
 }
 
 #endif