[NFC][libc++][test] Enables variant test.

[Mordante]

Summary

Noticed this while working on D133326. Let's see whehter all compilers
now support this feature.

[philnik]

LGTM assuming CI passes.

[Mordante]

CI test

[Mordante]

Undo last change, was to the wrong diff.

libcxx/include/__format/buffer.h

 #define _LIBCPP___FORMAT_BUFFER_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/transform.h>
 #include <__algorithm/unwrap_iter.h>
+#include <__availability>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/enable_insertable.h>
 #include <__format/format_to_n_result.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>

 namespace __format {
 
 /// A "buffer" that handles writing to the proper iterator.
 ///
 /// This helper is used together with the @ref back_insert_iterator to offer
 /// type-erasure for the formatting functions. This reduces the number to
 /// template instantiations.
 template <__fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __output_buffer {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __output_buffer {
 public:
   using value_type = _CharT;
 
   template <class _Tp>
   _LIBCPP_HIDE_FROM_ABI explicit __output_buffer(_CharT* __ptr, size_t __capacity, _Tp* __obj)
       : __ptr_(__ptr),
         __capacity_(__capacity),
         __flush_([](_CharT* __p, size_t __n, void* __o) { static_cast<_Tp*>(__o)->__flush(__p, __n); }),
private:
   }
 };
 
 /// A storage using an internal buffer.
 ///
 /// This storage is used when writing a single element to the output iterator
 /// is expensive.
 template <__fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __internal_storage {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __internal_storage {
 public:
   _LIBCPP_HIDE_FROM_ABI _CharT* __begin() { return __buffer_; }
 
   static constexpr size_t __buffer_size = 256 / sizeof(_CharT);
 
 private:
   _CharT __buffer_[__buffer_size];
 };
 
 /// A storage writing directly to the storage.
 ///
 /// This requires the storage to be a contiguous buffer of \a _CharT.
 /// Since the output is directly written to the underlying storage this class
 /// is just an empty class.
 template <__fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __direct_storage {};
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __direct_storage {};
 
 template <class _OutIt, class _CharT>
 concept __enable_direct_output = __fmt_char_type<_CharT> &&
     (same_as<_OutIt, _CharT*>
 #ifndef _LIBCPP_ENABLE_DEBUG_MODE
      || same_as<_OutIt, __wrap_iter<_CharT*>>
 #endif
     );
 
 /// Write policy for directly writing to the underlying output.
 template <class _OutIt, __fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __writer_direct {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __writer_direct {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
       : __out_it_(__out_it) {}
 
   _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
 
   _LIBCPP_HIDE_FROM_ABI void __flush(_CharT*, size_t __n) {
     // _OutIt can be a __wrap_iter<CharT*>. Therefore the original iterator
     // is adjusted.
     __out_it_ += __n;
   }
 
 private:
   _OutIt __out_it_;
 };
 
 /// Write policy for copying the buffer to the output.
 template <class _OutIt, __fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __writer_iterator {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __writer_iterator {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
       : __out_it_{_VSTD::move(__out_it)} {}
 
   _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
 
   _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
     __out_it_ = _VSTD::copy_n(__ptr, __n, _VSTD::move(__out_it_));

 template <class _Container>
 concept __insertable =
     __enable_insertable<_Container> && __fmt_char_type<typename _Container::value_type> &&
     requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first,
              add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); };
 
 /// Extract the container type of a \ref back_insert_iterator.
 template <class _It>
-struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container {
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __back_insert_iterator_container {
   using type = void;
 };
 
 template <__insertable _Container>
-struct _LIBCPP_TEMPLATE_VIS __back_insert_iterator_container<back_insert_iterator<_Container>> {
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __back_insert_iterator_container<back_insert_iterator<_Container>> {
   using type = _Container;
 };
 
 /// Write policy for inserting the buffer in a container.
 template <class _Container>
-class _LIBCPP_TEMPLATE_VIS __writer_container {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __writer_container {
 public:
   using _CharT = typename _Container::value_type;
 
   _LIBCPP_HIDE_FROM_ABI explicit __writer_container(back_insert_iterator<_Container> __out_it)
       : __container_{__out_it.__get_container()} {}
 
   _LIBCPP_HIDE_FROM_ABI auto __out_it() { return std::back_inserter(*__container_); }
 
   _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
     __container_->insert(__container_->end(), __ptr, __ptr + __n);
   }
 
 private:
   _Container* __container_;
 };
 
 /// Selects the type of the writer used for the output iterator.
 template <class _OutIt, class _CharT>
-class _LIBCPP_TEMPLATE_VIS __writer_selector {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __writer_selector {
   using _Container = typename __back_insert_iterator_container<_OutIt>::type;
 
 public:
   using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>,
                              conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>,
                                            __writer_iterator<_OutIt, _CharT>>>;
 };
 
 /// The generic formatting buffer.
 template <class _OutIt, __fmt_char_type _CharT>
-requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
+requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT
     __format_buffer {
   using _Storage =
       conditional_t<__enable_direct_output<_OutIt, _CharT>,
                     __direct_storage<_CharT>, __internal_storage<_CharT>>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
     requires(same_as<_Storage, __internal_storage<_CharT>>)
private:
   typename __writer_selector<_OutIt, _CharT>::type __writer_;
 };
 
 /// A buffer that counts the number of insertions.
 ///
 /// Since \ref formatted_size only needs to know the size, the output itself is
 /// discarded.
 template <__fmt_char_type _CharT>
-class _LIBCPP_TEMPLATE_VIS __formatted_size_buffer {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatted_size_buffer {
 public:
   _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); }
 
   _LIBCPP_HIDE_FROM_ABI void __flush(const _CharT*, size_t __n) { __size_ += __n; }
 
   _LIBCPP_HIDE_FROM_ABI size_t __result() && {
     __output_.__flush();
     return __size_;
   }
 
 private:
   __internal_storage<_CharT> __storage_;
   __output_buffer<_CharT> __output_{__storage_.__begin(), __storage_.__buffer_size, this};
   size_t __size_{0};
 };
 
 /// The base of a buffer that counts and limits the number of insertions.
 template <class _OutIt, __fmt_char_type _CharT, bool>
   requires(output_iterator<_OutIt, const _CharT&>)
-struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base {
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __format_to_n_buffer_base {
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
       : __writer_(_VSTD::move(__out_it)), __max_size_(_VSTD::max(_Size(0), __max_size)) {}
 
   _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
     if (_Size(__size_) <= __max_size_)

 /// The base of a buffer that counts and limits the number of insertions.
 ///
 /// This version is used when \c __enable_direct_output<_OutIt, _CharT> == true.
 ///
 /// This class limits the size available to the direct writer so it will not
 /// exceed the maximum number of code units.
 template <class _OutIt, __fmt_char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
-class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __format_to_n_buffer_base<_OutIt, _CharT, true> {
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
       : __output_(_VSTD::__unwrap_iter(__out_it), __max_size, this),
         __writer_(_VSTD::move(__out_it)),
         __max_size_(__max_size) {
     if (__max_size <= 0) [[unlikely]]
protected:
 
   _Size __max_size_;
   _Size __size_{0};
 };
 
 /// The buffer that counts and limits the number of insertions.
 template <class _OutIt, __fmt_char_type _CharT>
   requires(output_iterator<_OutIt, const _CharT&>)
-struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __format_to_n_buffer final
     : public __format_to_n_buffer_base< _OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>> {
   using _Base = __format_to_n_buffer_base<_OutIt, _CharT, __enable_direct_output<_OutIt, _CharT>>;
   using _Size = iter_difference_t<_OutIt>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __max_size)
       : _Base(_VSTD::move(__out_it), __max_size) {}
   _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return this->__output_.__make_output_iterator(); }
 
   _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __result() && {
     this->__output_.__flush();
     return {_VSTD::move(this->__writer_).__out_it(), this->__size_};
   }
 };
+
 } // namespace __format
 
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FORMAT_BUFFER_H

libcxx/include/__format/format_arg.h

#  endif
   __libcpp_unreachable();
 }
 
 /// Contains the values used in basic_format_arg.
 ///
 /// This is a separate type so it's possible to store the values and types in
 /// separate arrays.
 template <class _Context>
-class __basic_format_arg_value {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __basic_format_arg_value {
   using _CharT = typename _Context::char_type;
 
 public:
   /// Contains the implementation for basic_format_arg::handle.
   struct __handle {
     template <class _Tp>
     _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp&& __v) noexcept
         : __ptr_(_VSTD::addressof(__v)),
public:
   __format::__arg_t __type_;
 
   _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(__format::__arg_t __type,
                                                   __basic_format_arg_value<_Context> __value) noexcept
       : __value_(__value), __type_(__type) {}
 };
 
 template <class _Context>
-class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg<_Context>::handle {
 public:
   _LIBCPP_HIDE_FROM_ABI
   void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
     __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
   }
 
   _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept
       : __handle_(__handle) {}

libcxx/include/__format/formatter_floating_point.h

 #define _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/find.h>
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
+#include <__availability>
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
struct __traits<double> {
   static constexpr int __hex_precision_digits = 4;
 };
 
 /// Helper class to store the conversion buffer.
 ///
 /// Depending on the maxium size required for a value, the buffer is allocated
 /// on the stack or the heap.
 template <floating_point _Fp>
-class _LIBCPP_TEMPLATE_VIS __float_buffer {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __float_buffer {
   using _Traits = __traits<_Fp>;
 
 public:
   // TODO FMT Improve this constructor to do a better estimate.
   // When using a scientific formatting with a precision of 6 a stack buffer
   // will always suffice. At the moment that isn't important since floats and
   // doubles use a stack buffer, unless the precision used in the format string
   // is large.

libcxx/include/__format/parser_std_format_spec.h

 ///
 /// Note this class is a member of std::formatter specializations. It's
 /// expected developers will create their own formatter specializations that
 /// inherit from the std::formatter specializations. This means this class
 /// must be ABI stable. To aid the stability the unused bits in the class are
 /// set to zero. That way they can be repurposed if a future revision of the
 /// Standards adds new fields to std-format-spec.
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __parser {
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __parser {
 public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields)
       -> decltype(__parse_ctx.begin()) {
 
     const _CharT* __begin = __parse_ctx.begin();
     const _CharT* __end = __parse_ctx.end();
     if (__begin == __end)
       return __begin;

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

#endif // TEST_WORKAROUND_MSVC_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
 }
 
 int main(int, char**) {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
   test_constexpr_copy_ctor();
-#if 0
-// disable this for the moment; it fails on older compilers.
-//  Need to figure out which compilers will support it.
   { // This is the motivating example from P0739R0
     std::variant<int, double> v1(3);
     std::variant v2 = v1;
-  (void) v2;
+    (void)v2;
   }
-#endif
 
   return 0;
 }