[libc++] Stop using strict availability markup on Apple

[ldionne]

Summary

We've been increasingly running into issues with availability markup
in the library lately. In particular, the fact that strict availability
markup causes functions to act as-if they were deleted breaks the library
in various ways, making it impossible AFAICT to enable availability markup
for PMR. It also causes a lot of spurious diagnostics in e.g. <format>,
as can be seen by the multiple TODO comments removed in this patch.

This patch uses non-strict availability markup instead, which is used
much more widely on Apple platforms. The difference is that using an
unavailable API will trigger a warning instead of an error, and that
using an unavailable API will cause a weak-definition to be emitted
(so it is possible to check at runtime whether the API is available).

This should resolve several difficulties we've been having with availability
markup, which I believe to have tracked down to fundamental implementation
constraints with the strict version of availability. In other words,
strict has some properties which are fundamentally undesirable for us,
and it was always possible to work around them but it isn't anymore.

This will also make it possible for users to branch on whether an API
is available at runtime, which has been requested by users.

As a follow-up to this patch, I should be able to clean up even more
availability workarounds in the library.

rdar://100138498

[ldionne]

Note that this is still experimental. I want to run this through CI and I still want to have a few discussions before my mind is set that this is the right solution.

[Mordante]

I'm not familiar enough with the Apple's availability markup to give a proper review. However I really like that this patch fixes the availability issues for format. Thanks for working on this.

libcxx/test/libcxx/diagnostics/format.nodiscard_extensions.compile.pass.cpp

13

I like this change :-)

[ldionne]

[Github PR transition cleanup]

I'm going to abandon this here and reopen on Github when I'm ready to push for this again.

libcxx/include/__availability

#elif defined(__APPLE__)
     // shared_mutex and shared_timed_mutex
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX
 #   endif
 #   define _LIBCPP_AVAILABILITY_SHARED_MUTEX                                    \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
+        __attribute__((availability(macos,introduced=10.12)))                   \
+        __attribute__((availability(ios,introduced=10.0)))                      \
+        __attribute__((availability(tvos,introduced=10.0)))                     \
+        __attribute__((availability(watchos,introduced=3.0)))
 
         // bad_optional_access, bad_variant_access and bad_any_cast
         // Note: bad_optional_access & friends were not introduced in the matching
         // macOS and iOS versions, so the version mismatch between macOS and others
         // is intended.
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101300) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 120000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_OPTIONAL_ACCESS
 #       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_VARIANT_ACCESS
 #       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_ANY_CAST
 #   endif
 #   define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS                             \
-        __attribute__((availability(macos,strict,introduced=10.13)))            \
-        __attribute__((availability(ios,strict,introduced=12.0)))               \
-        __attribute__((availability(tvos,strict,introduced=12.0)))              \
-        __attribute__((availability(watchos,strict,introduced=5.0)))
+        __attribute__((availability(macos,introduced=10.13)))                   \
+        __attribute__((availability(ios,introduced=12.0)))                      \
+        __attribute__((availability(tvos,introduced=12.0)))                     \
+        __attribute__((availability(watchos,introduced=5.0)))
 #   define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS                              \
         _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 #   define _LIBCPP_AVAILABILITY_BAD_ANY_CAST                                    \
         _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 
     // uncaught_exceptions
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_UNCAUGHT_EXCEPTIONS
 #   endif
 #   define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS                             \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
+        __attribute__((availability(macos,introduced=10.12)))                   \
+        __attribute__((availability(ios,introduced=10.0)))                      \
+        __attribute__((availability(tvos,introduced=10.0)))                     \
+        __attribute__((availability(watchos,introduced=3.0)))
 
     // sized operator new and sized operator delete
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_SIZED_NEW_DELETE
 #   endif
 #   define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE                                \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
+        __attribute__((availability(macos,introduced=10.12)))                   \
+        __attribute__((availability(ios,introduced=10.0)))                      \
+        __attribute__((availability(tvos,introduced=10.0)))                     \
+        __attribute__((availability(watchos,introduced=3.0)))
 
     // future_error
 #   if (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 60000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_FUTURE_ERROR
 #   endif
 #   define _LIBCPP_AVAILABILITY_FUTURE_ERROR                                    \
-        __attribute__((availability(ios,strict,introduced=6.0)))
+        __attribute__((availability(ios,introduced=6.0)))
 
     // type_info's vtable
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_TYPEINFO_VTABLE
 #   endif
 #   define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE                                 \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
+        __attribute__((availability(macos,introduced=10.9)))                    \
+        __attribute__((availability(ios,introduced=7.0)))
 
     // locale::category
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_LOCALE_CATEGORY
 #   endif
 #   define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY                                 \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
+        __attribute__((availability(macos,introduced=10.9)))                    \
+        __attribute__((availability(ios,introduced=7.0)))
 
     // atomic operations on shared_ptr
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_ATOMIC_SHARED_PTR
 #   endif
 #   define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR                               \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
+        __attribute__((availability(macos,introduced=10.9)))                    \
+        __attribute__((availability(ios,introduced=7.0)))
 
     // <filesystem>
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM_LIBRARY
 #   endif
 #   define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY                              \
-        __attribute__((availability(macos,strict,introduced=10.15)))            \
-        __attribute__((availability(ios,strict,introduced=13.0)))               \
-        __attribute__((availability(tvos,strict,introduced=13.0)))              \
-        __attribute__((availability(watchos,strict,introduced=6.0)))
+        __attribute__((availability(macos,introduced=10.15)))                   \
+        __attribute__((availability(ios,introduced=13.0)))                      \
+        __attribute__((availability(tvos,introduced=13.0)))                     \
+        __attribute__((availability(watchos,introduced=6.0)))
 #   define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH                                 \
-        _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
-        _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
-        _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
-        _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
+        _Pragma("clang attribute push(__attribute__((availability(macos,introduced=10.15))), apply_to=any(function,record))") \
+        _Pragma("clang attribute push(__attribute__((availability(ios,introduced=13.0))), apply_to=any(function,record))")    \
+        _Pragma("clang attribute push(__attribute__((availability(tvos,introduced=13.0))), apply_to=any(function,record))")   \
+        _Pragma("clang attribute push(__attribute__((availability(watchos,introduced=6.0))), apply_to=any(function,record))")
 #   define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP                                  \
-        _Pragma("clang attribute pop")                                          \
-        _Pragma("clang attribute pop")                                          \
-        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")                                                  \
+        _Pragma("clang attribute pop")                                                  \
+        _Pragma("clang attribute pop")                                                  \
         _Pragma("clang attribute pop")
 
     // std::to_chars(floating-point)
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 130300) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 160300) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 160300) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 90300)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_TO_CHARS_FLOATING_POINT
 #   endif
 #   define _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT                         \
-        __attribute__((availability(macos,strict,introduced=13.3)))             \
-        __attribute__((availability(ios,strict,introduced=16.3)))               \
-        __attribute__((availability(tvos,strict,introduced=16.3)))              \
-        __attribute__((availability(watchos,strict,introduced=9.3)))
+        __attribute__((availability(macos,introduced=13.3)))                    \
+        __attribute__((availability(ios,introduced=16.3)))                      \
+        __attribute__((availability(tvos,introduced=16.3)))                     \
+        __attribute__((availability(watchos,introduced=9.3)))
 
     // c++20 synchronization library
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_SYNC
 #   endif
 #   define _LIBCPP_AVAILABILITY_SYNC                                            \
-        __attribute__((availability(macos,strict,introduced=11.0)))             \
-        __attribute__((availability(ios,strict,introduced=14.0)))               \
-        __attribute__((availability(tvos,strict,introduced=14.0)))              \
-        __attribute__((availability(watchos,strict,introduced=7.0)))
+        __attribute__((availability(macos,introduced=11.0)))                    \
+        __attribute__((availability(ios,introduced=14.0)))                      \
+        __attribute__((availability(tvos,introduced=14.0)))                     \
+        __attribute__((availability(watchos,introduced=7.0)))
 
     // __libcpp_verbose_abort
 #   if 1 // TODO: Update once this is released
 #       define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
 #   endif
 #   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT                                   \
         __attribute__((unavailable))
 
     // std::pmr
 #   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 140000) ||    \
         (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 170000) || \
         (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 170000) ||         \
         (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 100000)
 #       define _LIBCPP_AVAILABILITY_HAS_NO_PMR
 #   endif
 // TODO: Enable std::pmr markup once https://github.com/llvm/llvm-project/issues/40340 has been fixed
 //       Until then, it is possible for folks to try to use `std::pmr` when back-deploying to targets that don't support
 //       it and it'll be a load-time error, but we don't have a good alternative because the library won't compile if we
 //       use availability annotations until that bug has been fixed.
 #  if 0
 #    define _LIBCPP_AVAILABILITY_PMR                                                                                   \
-      __attribute__((availability(macos, strict, introduced = 14.0)))                                                  \
-      __attribute__((availability(ios, strict, introduced = 17.0)))                                                    \
-      __attribute__((availability(tvos, strict, introduced = 17.0)))                                                   \
-      __attribute__((availability(watchos, strict, introduced = 10.0)))
+      __attribute__((availability(macos, introduced = 14.0)))                                                          \
+      __attribute__((availability(ios, introduced = 17.0)))                                                            \
+      __attribute__((availability(tvos, introduced = 17.0)))                                                           \
+      __attribute__((availability(watchos, introduced = 10.0)))
 #  else
 #    define _LIBCPP_AVAILABILITY_PMR
 #  endif
 
 #else
 
 // ...New vendors can add availability markup here...
 

libcxx/test/libcxx/diagnostics/format.nodiscard_extensions.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // Check that format functions aren't marked [[nodiscard]] when
 // _LIBCPP_DISBALE_NODISCARD_EXT is defined
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // UNSUPPORTED: c++03, c++11, c++14 ,c++17
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_NODISCARD_EXT
 
 #include <format>
 
 #include "test_macros.h"
 

libcxx/test/libcxx/diagnostics/format.nodiscard_extensions.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // Check that format functions are marked [[nodiscard]] as a conforming extension
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // UNSUPPORTED: c++03, c++11, c++14 ,c++17
 
 #include <format>
 
 #include "test_macros.h"
 
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <locale>

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_posix.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: has-unix-headers
 
 // <print>
 
 // Tests the implementation of
 //   void __print::__vprint_unicode_posix(FILE* __stream, string_view __fmt,
 //                                        format_args __args, bool __write_nl,
 //                                        bool __is_terminal);

libcxx/test/libcxx/input.output/iostream.format/print.fun/vprint_unicode_windows.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: no-wide-characters
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // Clang modules do not work with the definiton of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
 // XFAIL: modules-build
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // Tests the implementation of
 //   void __print::__vprint_unicode_windows(FILE* __stream, string_view __fmt,
 //                                          format_args __args, bool __write_nl,
 //                                          bool __is_terminal);
 //
 // In the library when the stdout is redirected to a file it is no

libcxx/test/libcxx/thread/atomic.availability.verify.cpp

 
 #include <atomic>
 
 void f() {
     {
         std::atomic<int> i(3);
         std::memory_order m = std::memory_order_relaxed;
 
-        i.wait(4); // expected-error {{is unavailable}}
-        i.wait(4, m); // expected-error {{is unavailable}}
-        i.notify_one(); // expected-error {{is unavailable}}
-        i.notify_all(); // expected-error {{is unavailable}}
-
-        std::atomic_wait(&i, 4); // expected-error {{is unavailable}}
-        std::atomic_wait_explicit(&i, 4, m); // expected-error {{is unavailable}}
-        std::atomic_notify_one(&i); // expected-error {{is unavailable}}
-        std::atomic_notify_all(&i); // expected-error {{is unavailable}}
+        i.wait(4); // expected-warning {{'wait' is only available on}}
+        i.wait(4, m); // expected-warning {{'wait' is only available on}}
+        i.notify_one(); // expected-warning {{'notify_one' is only available on}}
+        i.notify_all(); // expected-warning {{'notify_all' is only available on}}
+
+        std::atomic_wait(&i, 4); // expected-warning {{'atomic_wait' is only available on}}
+        std::atomic_wait_explicit(&i, 4, m); // expected-warning {{'atomic_wait_explicit' is only available on}}
+        std::atomic_notify_one(&i); // expected-warning {{'atomic_notify_one' is only available on}}
+        std::atomic_notify_all(&i); // expected-warning {{'atomic_notify_all' is only available on}}
     }
 
     {
         std::atomic<int> volatile i(3);
         std::memory_order m = std::memory_order_relaxed;
 
-        i.wait(4); // expected-error {{is unavailable}}
-        i.wait(4, m); // expected-error {{is unavailable}}
-        i.notify_one(); // expected-error {{is unavailable}}
-        i.notify_all(); // expected-error {{is unavailable}}
-
-        std::atomic_wait(&i, 4); // expected-error {{is unavailable}}
-        std::atomic_wait_explicit(&i, 4, m); // expected-error {{is unavailable}}
-        std::atomic_notify_one(&i); // expected-error {{is unavailable}}
-        std::atomic_notify_all(&i); // expected-error {{is unavailable}}
+        i.wait(4); // expected-warning {{'wait' is only available on}}
+        i.wait(4, m); // expected-warning {{'wait' is only available on}}
+        i.notify_one(); // expected-warning {{'notify_one' is only available on}}
+        i.notify_all(); // expected-warning {{'notify_all' is only available on}}
+
+        std::atomic_wait(&i, 4); // expected-warning {{'atomic_wait' is only available on}}
+        std::atomic_wait_explicit(&i, 4, m); // expected-warning {{'atomic_wait_explicit' is only available on}}
+        std::atomic_notify_one(&i); // expected-warning {{'atomic_notify_one' is only available on}}
+        std::atomic_notify_all(&i); // expected-warning {{'atomic_notify_all' is only available on}}
     }
 
     {
         std::atomic_flag flag;
         bool b = false;
         std::memory_order m = std::memory_order_relaxed;
-        flag.wait(b); // expected-error {{is unavailable}}
-        flag.wait(b, m); // expected-error {{is unavailable}}
-        flag.notify_one(); // expected-error {{is unavailable}}
-        flag.notify_all(); // expected-error {{is unavailable}}
-
-        std::atomic_flag_wait(&flag, b); // expected-error {{is unavailable}}
-        std::atomic_flag_wait_explicit(&flag, b, m); // expected-error {{is unavailable}}
-        std::atomic_flag_notify_one(&flag); // expected-error {{is unavailable}}
-        std::atomic_flag_notify_all(&flag); // expected-error {{is unavailable}}
+        flag.wait(b); // expected-warning {{'wait' is only available on}}
+        flag.wait(b, m); // expected-warning {{'wait' is only available on}}
+        flag.notify_one(); // expected-warning {{'notify_one' is only available on}}
+        flag.notify_all(); // expected-warning {{'notify_all' is only available on}}
+
+        std::atomic_flag_wait(&flag, b); // expected-warning {{'atomic_flag_wait' is only available on}}
+        std::atomic_flag_wait_explicit(&flag, b, m); // expected-warning {{'atomic_flag_wait_explicit' is only available on}}
+        std::atomic_flag_notify_one(&flag); // expected-warning {{'atomic_flag_notify_one' is only available on}}
+        std::atomic_flag_notify_all(&flag); // expected-warning {{'atomic_flag_notify_all' is only available on}}
     }
 
     {
         std::atomic_flag volatile flag;
         bool b = false;
         std::memory_order m = std::memory_order_relaxed;
-        flag.wait(b); // expected-error {{is unavailable}}
-        flag.wait(b, m); // expected-error {{is unavailable}}
-        flag.notify_one(); // expected-error {{is unavailable}}
-        flag.notify_all(); // expected-error {{is unavailable}}
-
-        std::atomic_flag_wait(&flag, b); // expected-error {{is unavailable}}
-        std::atomic_flag_wait_explicit(&flag, b, m); // expected-error {{is unavailable}}
-        std::atomic_flag_notify_one(&flag); // expected-error {{is unavailable}}
-        std::atomic_flag_notify_all(&flag); // expected-error {{is unavailable}}
+        flag.wait(b); // expected-warning {{'wait' is only available on}}
+        flag.wait(b, m); // expected-warning {{'wait' is only available on}}
+        flag.notify_one(); // expected-warning {{'notify_one' is only available on}}
+        flag.notify_all(); // expected-warning {{'notify_all' is only available on}}
+
+        std::atomic_flag_wait(&flag, b); // expected-warning {{'atomic_flag_wait' is only available on}}
+        std::atomic_flag_wait_explicit(&flag, b, m); // expected-warning {{'atomic_flag_wait_explicit' is only available on}}
+        std::atomic_flag_notify_one(&flag); // expected-warning {{'atomic_flag_notify_one' is only available on}}
+        std::atomic_flag_notify_all(&flag); // expected-warning {{'atomic_flag_notify_all' is only available on}}
     }
 }

libcxx/test/libcxx/thread/barrier.availability.verify.cpp

 
 struct CompletionF {
     void operator()() { }
 };
 
 void f() {
     // Availability markup on std::barrier<>
     {
-        std::barrier<> b(10); // expected-error {{is unavailable}}
-        auto token = b.arrive(); // expected-error {{is unavailable}}
-        (void)b.arrive(10); // expected-error {{is unavailable}}
-        b.wait(std::move(token)); // expected-error {{is unavailable}}
-        b.arrive_and_wait(); // expected-error {{is unavailable}}
-        b.arrive_and_drop(); // expected-error {{is unavailable}}
+        std::barrier<> b(10);
+        auto token = b.arrive(); // expected-warning {{'arrive' is only available on}}
+        (void)b.arrive(10); // expected-warning {{'arrive' is only available on}}
+        b.wait(std::move(token)); // expected-warning {{'wait' is only available on}}
+        b.arrive_and_wait(); // expected-warning {{'arrive_and_wait' is only available on}}
+        b.arrive_and_drop(); // expected-warning {{'arrive_and_drop' is only available on}}
     }
 
     // Availability markup on std::barrier<CompletionF> with non-default CompletionF
     {
-        std::barrier<CompletionF> b(10); // expected-error {{is unavailable}}
-        auto token = b.arrive(); // expected-error {{is unavailable}}
-        (void)b.arrive(10); // expected-error {{is unavailable}}
-        b.wait(std::move(token)); // expected-error {{is unavailable}}
-        b.arrive_and_wait(); // expected-error {{is unavailable}}
-        b.arrive_and_drop(); // expected-error {{is unavailable}}
+        std::barrier<CompletionF> b(10);
+        auto token = b.arrive(); // expected-warning {{'arrive' is only available on}}
+        (void)b.arrive(10); // expected-warning {{'arrive' is only available on}}
+        b.wait(std::move(token)); // expected-warning {{'wait' is only available on}}
+        b.arrive_and_wait(); // expected-warning {{'arrive_and_wait' is only available on}}
+        b.arrive_and_drop(); // expected-warning {{'arrive_and_drop' is only available on}}
     }
 }

libcxx/test/libcxx/thread/latch.availability.verify.cpp

 // REQUIRES: availability-synchronization_library-missing
 
 // Test the availability markup on std::latch.
 
 #include <latch>
 
 void f() {
     std::latch latch(10);
-    latch.count_down(); // expected-error {{is unavailable}}
-    latch.count_down(3); // expected-error {{is unavailable}}
-    latch.wait(); // expected-error {{is unavailable}}
-    latch.arrive_and_wait(); // expected-error {{is unavailable}}
-    latch.arrive_and_wait(3); // expected-error {{is unavailable}}
+    latch.count_down(); // expected-warning {{'count_down' is only available on}}
+    latch.count_down(3); // expected-warning {{'count_down' is only available on}}
+    latch.wait(); // expected-warning {{'wait' is only available on}}
+    latch.arrive_and_wait(); // expected-warning {{'arrive_and_wait' is only available on}}
+    latch.arrive_and_wait(3); // expected-warning {{'arrive_and_wait' is only available on}}
 }

libcxx/test/libcxx/thread/semaphore.availability.verify.cpp

 
 #include <chrono>
 #include <semaphore>
 
 void f() {
     {
         // Tests for std::counting_semaphore with non-default template argument
         std::counting_semaphore<20> sem(10);
-        sem.release(); // expected-error {{is unavailable}}
-        sem.release(5); // expected-error {{is unavailable}}
-        sem.acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-error 1-2 {{is unavailable}}
-        sem.try_acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-error 1-2 {{is unavailable}}
+        sem.release(); // expected-warning {{'release' is only available on}}
+        sem.release(5); // expected-warning {{'release' is only available on}}
+        sem.acquire(); // expected-warning {{'acquire' is only available on}}
+        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-warning {{'try_acquire_for' is only available on}}
+        sem.try_acquire(); // expected-warning {{'try_acquire' is only available on}}
+        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-warning {{'try_acquire_until' is only available on}}
     }
     {
         // Tests for std::counting_semaphore with default template argument
         std::counting_semaphore<> sem(10);
-        sem.release(); // expected-error {{is unavailable}}
-        sem.release(5); // expected-error {{is unavailable}}
-        sem.acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-error 1-2 {{is unavailable}}
-        sem.try_acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-error 1-2 {{is unavailable}}
+        sem.release(); // expected-warning {{'release' is only available on}}
+        sem.release(5); // expected-warning {{'release' is only available on}}
+        sem.acquire(); // expected-warning {{'acquire' is only available on}}
+        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-warning {{'try_acquire_for' is only available on}}
+        sem.try_acquire(); // expected-warning {{'try_acquire' is only available on}}
+        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-warning {{'try_acquire_until' is only available on}}
     }
     {
         // Tests for std::binary_semaphore
         std::binary_semaphore sem(10);
-        sem.release(); // expected-error {{is unavailable}}
-        sem.release(5); // expected-error {{is unavailable}}
-        sem.acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-error 1-2 {{is unavailable}}
-        sem.try_acquire(); // expected-error {{is unavailable}}
-        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-error 1-2 {{is unavailable}}
+        sem.release(); // expected-warning {{'release' is only available on}}
+        sem.release(5); // expected-warning {{'release' is only available on}}
+        sem.acquire(); // expected-warning {{'acquire' is only available on}}
+        sem.try_acquire_for(std::chrono::milliseconds{3}); // expected-warning {{'try_acquire_for' is only available on}}
+        sem.try_acquire(); // expected-warning {{'try_acquire' is only available on}}
+        sem.try_acquire_until(std::chrono::steady_clock::now()); // expected-warning {{'try_acquire_until' is only available on}}
     }
 }

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/format.functions.format.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, c++20
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <vector>
 
 // template<class T, class charT>
 //   requires is-vector-bool-reference<T>
 // struct formatter<T, charT>
 
 // template<class... Args>
 //   string format(format_string<Args...> fmt, Args&&... args);

libcxx/test/std/containers/sequences/vector.bool/vector.bool.fmt/format.functions.vformat.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, c++20
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <vector>
 
 // template<class T, class charT>
 //   requires is-vector-bool-reference<T>
 // struct formatter<T, charT>
 
 // string vformat(string_view fmt, format_args args);
 // wstring vformat(wstring_view fmt, wformat_args args);

libcxx/test/std/input.output/iostream.format/print.fun/no_file_description.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // XFAIL: msvc, target={{.+}}-windows-gnu
-// XFAIL: availability-fp_to_chars-missing
 
 // <print>
 
 // The FILE returned by fmemopen does not have file descriptor.
 // This means the test could fail when the implementation uses a
 // function that requires a file descriptor, for example write.
 //
 // This tests all print functions which takes a FILE* as argument.

libcxx/test/std/input.output/iostream.format/print.fun/print.file.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // template<class... Args>
 //   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
 
 // In the library when the stdout is redirected to a file it is no
 // longer considered a terminal and the special terminal handling is no
 // longer executed. There are tests in

libcxx/test/std/input.output/iostream.format/print.fun/print.sh.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: executor-has-no-bash
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // template<class... Args>
 //   void print(format_string<Args...> fmt, Args&&... args);
 
 // Testing this properly is quite hard; the function unconditionally
 // writes to stdout. When stdout is redirected to a file it is no longer
 // considered a terminal. The function is a small wrapper around

libcxx/test/std/input.output/iostream.format/print.fun/println.file.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // template<class... Args>
 //   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
 
 // In the library when the stdout is redirected to a file it is no
 // longer considered a terminal and the special terminal handling is no
 // longer executed. There are tests in

libcxx/test/std/input.output/iostream.format/print.fun/println.sh.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: executor-has-no-bash
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // FIXME PRINT How to test println on Windows?
 // XFAIL: msvc, target={{.+}}-windows-gnu
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // template<class... Args>
 //   void println(format_string<Args...> fmt, Args&&... args);
 
 // Testing this properly is quite hard; the function unconditionally
 // writes to stdout. When stdout is redirected to a file it is no longer
 // considered a terminal. The function is a small wrapper around

libcxx/test/std/input.output/iostream.format/print.fun/vprint_nonunicode.file.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // TODO PRINT Enable again
 // https://reviews.llvm.org/D150044
 // https://lab.llvm.org/buildbot/#/builders/237/builds/3578
 // UNSUPPORTED: asan, hwasan, msan
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <cstddef>

libcxx/test/std/input.output/iostream.format/print.fun/vprint_nonunicode.sh.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: executor-has-no-bash
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 //  void vprint_nonunicode(string_view fmt, format_args args);
 
 // Testing this properly is quite hard; the function unconditionally
 // writes to stdout. When stdout is redirected to a file it is no longer
 // considered a terminal. The function is a small wrapper around
 //

libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.file.pass.cpp

 // UNSUPPORTED: libcpp-has-no-unicode
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // TODO PRINT Enable again
 // https://reviews.llvm.org/D150044
 // https://lab.llvm.org/buildbot/#/builders/237/builds/3578
 // UNSUPPORTED: asan, hwasan, msan
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 // void vprint_unicode(FILE* stream, string_view fmt, format_args args);
 
 // In the library when the stdout is redirected to a file it is no
 // longer considered a terminal and the special terminal handling is no
 // longer executed. There are tests in
 //   libcxx/test/libcxx/input.output/iostream.format/print.fun/

libcxx/test/std/input.output/iostream.format/print.fun/vprint_unicode.sh.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, c++20
 // UNSUPPORTED: no-filesystem
 // UNSUPPORTED: executor-has-no-bash
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <print>
 
 //  void vprint_unicode(string_view fmt, format_args args);
 
 // Testing this properly is quite hard; the function unconditionally
 // writes to stdout. When stdout is redirected to a file it is no longer
 // considered a terminal. The function is a small wrapper around
 //

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/format.functions.format.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, c++20
 // UNSUPPORTED: no-threads
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <thread>
 
 // template<class charT>
 // struct formatter<thread::id, charT>;
 
 // template<class... Args>
 //   string format(format_string<Args...> fmt, Args&&... args);
 // template<class... Args>

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/format.functions.vformat.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, c++20
 // UNSUPPORTED: no-threads
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <thread>
 
 // template<class charT>
 // struct formatter<thread::id, charT>;
 
 // string vformat(string_view fmt, format_args args);
 // wstring vformat(wstring_view fmt, wformat_args args);
 

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.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: no-threads
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // REQUIRES: locale.fr_FR.UTF-8
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <thread>
 
 // class thread::id
 
 // template<class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& out, thread::id id);
 

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class day;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.md/time.cal.md.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class month_day;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.mdlast/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class month_day_last;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class month;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class month_weekday;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class month_weekday_last;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class weekday_indexed;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class weekday_last;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class weekday;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 // class year;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&

libcxx/test/std/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class year_month;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class year_month_day_last;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class year_month_weekday;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // class year_month_weekday_last;
 
 // template<class charT, class traits>

libcxx/test/std/time/time.duration/time.duration.nonmember/ostream.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class Rep, class Period = ratio<1>> class duration;
 
 // template<class charT, class traits, class Rep, class Period>

libcxx/test/std/time/time.syn/formatter.hh_mm_ss.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class Rep, class Period, class charT>
 //   struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;
 

libcxx/test/std/time/time.syn/formatter.day.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.file_time.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 //
 // template<class charT> struct formatter<chrono::file_time, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.local_time.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 //
 // template<class charT> struct formatter<chrono::day, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.month.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::month, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.month_day.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.month_day_last.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::month_day_last, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.month_weekday.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::month_weekday, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.sys_time.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 //
 // template<class charT> struct formatter<chrono::day, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.weekday.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.weekday_index.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.weekday_last.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.year.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::year, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.year_month.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::year_month, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.year_month_day.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // TODO FMT Investigate Windows issues.
 // XFAIL: msvc
 
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 

libcxx/test/std/time/time.syn/formatter.year_month_day_last.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::year_month_day_last, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.year_month_weekday.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::year_month_weekday, charT>;
 
 #include <chrono>

libcxx/test/std/time/time.syn/formatter.year_month_weekday_last.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
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // REQUIRES: locale.fr_FR.UTF-8
 // REQUIRES: locale.ja_JP.UTF-8
 
 // <chrono>
 
 // template<class charT> struct formatter<chrono::year_month_weekday_last, charT>;
 
 #include <chrono>

libcxx/test/std/utilities/format/format.functions/P2418.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
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Tests whether a move only type can be formatted. This is required by
 // P2418R2 "Add support for std::generator-like types to std::format"
 
 // <format>
 
 #include <format>
 #include <cassert>
 

libcxx/test/std/utilities/format/format.functions/ascii.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
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // Force unicode to be disabled.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_HAS_NO_UNICODE
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // Tests Unicode is ignored and handled as ASCII.
 
 #include <format>
 #include <cassert>
 #include <vector>
 

libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.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, c++20
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Force unicode to be disabled.
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_HAS_NO_UNICODE
 
 // <format>
 
 // This test the debug string type for the formatter specializations for char
 // and string types. This tests ASCII strings, the tests assume every char32_t value is valid ASCII.
 

libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.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, c++20
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // This version runs the test when the platform has Unicode support.
 // UNSUPPORTED: libcpp-has-no-unicode
 
 // TODO FMT Investigate Windows and 32-bit AIX issues.
 // UNSUPPORTED: msvc, target={{.+}}-windows-gnu, target=powerpc-ibm-aix{{.*}}
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // This test the debug string type for the formatter specializations for char
 // and string types. This tests Unicode strings.
 
 #include <format>
 
 #include <cassert>

libcxx/test/std/utilities/format/format.functions/fill.unicode.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
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // This version runs the test when the platform has Unicode support.
 // UNSUPPORTED: libcpp-has-no-unicode
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // The paper
 //   P2572R1 std::format fill character allowances
 // adds support for Unicode Scalar Values as fill character.
 
 #include <format>
 

libcxx/test/std/utilities/format/format.functions/format.locale.verify.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
 // UNSUPPORTED: no-localization
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class... Args>
 //   string format(const locale& loc, format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(const locale& loc, wformat-string<Args...> fmt, const Args&... args);

libcxx/test/std/utilities/format/format.functions/format.verify.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
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class... Args>
 //   string format(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(wformat-string<Args...> fmt, const Args&... args);

libcxx/test/std/utilities/format/format.functions/format_to.locale.verify.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
 // UNSUPPORTED: no-localization
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>

libcxx/test/std/utilities/format/format.functions/format_to.verify.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
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // Basic test to validate ill-formed code is properly detected.
 
 // template<class Out, class... Args>
 //   Out format_to(Out out, format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, wformat-string<Args...> fmt, const Args&... args);

libcxx/test/std/utilities/format/format.functions/format_to_n.locale.verify.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
 // UNSUPPORTED: no-localization
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       const locale& loc, format-string<Args...> fmt,
 //                                       const Args&... args);

libcxx/test/std/utilities/format/format.functions/format_to_n.verify.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
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>

libcxx/test/std/utilities/format/format.functions/formatted_size.locale.verify.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
 // UNSUPPORTED: no-localization
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class... Args>
 //   size_t formatted_size(const locale& loc,
 //                         format-string<Args...> fmt, const Args&... args);
 // template<class... Args>

libcxx/test/std/utilities/format/format.functions/formatted_size.verify.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
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // Basic test to validate ill-formed code is properly detected.
 
 // <format>
 
 // template<class... Args>
 //   size_t formatted_size(format-string<Args...> fmt, const Args&... args);
 // template<class... Args>
 //   size_t formatted_size(wformat-string<Args...> fmt, const Args&... args);

libcxx/test/std/utilities/format/format.functions/unicode.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
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
 // This version runs the test when the platform has Unicode support.
 // UNSUPPORTED: libcpp-has-no-unicode
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // Tests the Unicode width support of the standard format specifiers.
 // It tests [format.string.std]/8 - 11:
 // - Properly determining the estimated with of a unicode string.
 // - Properly truncating to the wanted maximum width.
 
 // More specific extended grapheme cluster boundary rules are tested in

libcxx/test/std/utilities/format/format.range/format.range.fmtstr/format.functions.format.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, c++20
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // template<ranges::input_range R, class charT>
 //   requires (K == range_format::string || K == range_format::debug_string)
 // struct range-default-formatter<K, R, charT>
 //
 // template<class... Args>
 //   string format(format_string<Args...> fmt, Args&&... args);

libcxx/test/std/utilities/format/format.range/format.range.fmtstr/format.functions.vformat.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, c++20
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // template<ranges::input_range R, class charT>
 //   requires (K == range_format::string || K == range_format::debug_string)
 // struct range-default-formatter<K, R, charT>
 //
 // string vformat(string_view fmt, format_args args);
 // wstring vformat(wstring_view fmt, wformat_args args);

libcxx/test/std/utilities/format/format.string/format.string.std/lwg3720_arg_id_width_precision_allowed_types.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
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // [format.string.std]/8
 // If { arg-idopt } is used in a width or precision, the value of the
 // corresponding formatting argument is used in its place. If the
 // corresponding formatting argument is not of standard signed or unsigned
 // integer type, or its value is negative for precision or non-positive for
 // width, an exception of type format_error is thrown.

libcxx/test/std/utilities/format/format.string/format.string.std/lwg3720_arg_id_width_precision_allowed_types.verify.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
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // [format.string.std]/8
 // If { arg-idopt } is used in a width or precision, the value of the
 // corresponding formatting argument is used in its place. If the
 // corresponding formatting argument is not of standard signed or unsigned
 // integer type, or its value is negative for precision or non-positive for
 // width, an exception of type format_error is thrown.

libcxx/test/std/utilities/format/format.tuple/format.functions.format.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, c++20
 
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // template<class charT, formattable<charT>... Ts>
 //   struct formatter<pair-or-tuple<Ts...>, charT>
 //
 // tested in the format functions
 //
 // template<class... Args>

libcxx/test/std/utilities/format/format.tuple/format.functions.format.verify.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, c++20
 
-// TODO FMT This test should not require std::to_chars(floating-point)
-// XFAIL: availability-fp_to_chars-missing
-
 #include <format>
 
 #include <utility>
 #include <tuple>
 
 #include "test_macros.h"
 
 // clang-format off

libcxx/test/std/utilities/format/format.tuple/format.functions.vformat.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, c++20
 // UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
 
-// XFAIL: availability-fp_to_chars-missing
-
 // <format>
 
 // template<class charT, formattable<charT>... Ts>
 //   struct formatter<pair-or-tuple<Ts...>, charT>
 //
 // tested in the format functions
 //
 // string vformat(string_view fmt, format_args args);