[libc++][format] Make public functions nodiscard.

[Mordante]

Summary

This is an extension and only adds the functions that are a considered a
but when called and ignoring the result.

Drive-by sort all nodiscard extensions in the documentation.

[Mordante]

CI fixes.

[philnik]

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

3

You seem to be missing a positive test.

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

27–28

Why not simply cast to void?

[Mordante]

Thanks for the review!

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

3

Nice catch, I'll commit my local file this time ;-)

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

27–28

I prefer name instead of a magic invocation, @BillyONeal spend the effort to change them in D40065.

[Mordante]

Addresses review comments.

[philnik]

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

27–28

IMO it's kind-of pointless to have a macro that just casts to void, since its people know what casting to void means, but not what a given macro actually does. It looks to me like the macro does something magical to check that it's actually ignoring nodiscard.

[Mordante]

Thanks for the review!

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

27–28

I like he macro since it explains why it's needed.

libcxx/docs/UsingLibcxx.rst

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 This section lists all extended applications of ``[[nodiscard]]`` to entities
 which no dialect declares as such (See the second form described above).
 
 * ``adjacent_find``
 * ``all_of``
 * ``any_of``
+* ``as_const``
 * ``binary_search``
+* ``bit_cast``
+* ``cbrt``
+* ``ceil``
 * ``clamp``
+* ``copysign``
 * ``count_if``
 * ``count``
 * ``equal_range``
 * ``equal``
+* ``fabs``
 * ``find_end``
 * ``find_first_of``
 * ``find_if_not``
 * ``find_if``
 * ``find``
+* ``floor``
+* ``fmax``
+* ``fmin``
+* ``forward``
+* ``fpclassify``
 * ``get_temporary_buffer``
+* ``identity::operator()``
 * ``includes``
 * ``is_heap_until``
 * ``is_heap``
 * ``is_partitioned``
 * ``is_permutation``
 * ``is_sorted_until``
 * ``is_sorted``
+* ``isfinite``
+* ``isgreater``
+* ``isgreaterequal``
+* ``isinf``
+* ``isless``
+* ``islessequal``
+* ``islessgreater``
+* ``isnan``
+* ``isnormal``
+* ``isunordered``
 * ``lexicographical_compare``
+* ``lock_guard``'s constructors
 * ``lower_bound``
+* ``make_format_args``
+* ``make_wformat_args``
 * ``max_element``
 * ``max``
 * ``min_element``
 * ``min``
 * ``minmax_element``
 * ``minmax``
 * ``mismatch``
+* ``move_if_noexcept``
+* ``move``
+* ``nearbyint``
 * ``none_of``
-* ``remove_if``
-* ``remove``
-* ``search_n``
-* ``search``
-* ``unique``
-* ``upper_bound``
 * ``ranges::adjacent_find``
 * ``ranges::all_of``
 * ``ranges::any_of``
 * ``ranges::binary_search``
 * ``ranges::clamp``
 * ``ranges::count_if``
 * ``ranges::count``
 * ``ranges::equal_range``

 * ``ranges::mismatch``
 * ``ranges::none_of``
 * ``ranges::remove_if``
 * ``ranges::remove``
 * ``ranges::search_n``
 * ``ranges::search``
 * ``ranges::unique``
 * ``ranges::upper_bound``
-* ``lock_guard``'s constructors
-* ``as_const``
-* ``bit_cast``
-* ``forward``
-* ``move``
-* ``move_if_noexcept``
-* ``identity::operator()``
-* ``to_integer``
-* ``to_underlying``
-* ``signbit``
-* ``fpclassify``
-* ``isfinite``
-* ``isinf``
-* ``isnan``
-* ``isnormal``
-* ``isgreater``
-* ``isgreaterequal``
-* ``isless``
-* ``islessequal``
-* ``islessgreater``
-* ``isunordered``
-* ``ceil``
-* ``fabs``
-* ``floor``
-* ``cbrt``
-* ``copysign``
-* ``fmax``
-* ``fmin``
-* ``nearbyint``
+* ``remove_if``
+* ``remove``
 * ``rint``
 * ``round``
+* ``search_n``
+* ``search``
+* ``signbit``
+* ``to_integer``
+* ``to_underlying``
 * ``trunc``
+* ``unique``
+* ``upper_bound``
+* ``vformat``
 
 Extended integral type support
 ------------------------------
 
 Several platforms support types that are not specified in the Standard, such as
 the 128-bit integral types ``__int128_t`` and ``__uint128_t``. As an extension,
 libc++ does a best-effort attempt to support these types like other integral
 types, by supporting them notably in:

libcxx/include/__format/format_functions.h

 // to do this optimization now.
 
 using format_args = basic_format_args<format_context>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_args = basic_format_args<wformat_context>;
 #endif
 
 template <class _Context = format_context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&&... __args) {
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&&... __args) {
   return _VSTD::__format_arg_store<_Context, _Args...>(__args...);
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> make_wformat_args(_Args&&... __args) {
+_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...>
+make_wformat_args(_Args&&... __args) {
   return _VSTD::__format_arg_store<wformat_context, _Args...>(__args...);
 }
-#endif
+#  endif
 
 namespace __format {
 
 /// Helper class parse and handle argument.
 ///
 /// When parsing a handle which is not enabled the code is ill-formed.
 /// This helper uses the parser of the appropriate formatter for the stored type.
 template <class _CharT>
format_to(_OutIt __out_it, wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.get(),
                            _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
 vformat(string_view __fmt, format_args __args) {
   string __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
   return __res;
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
 vformat(wstring_view __fmt, wformat_args __args) {
   wstring __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
   return __res;
 }
-#endif
+#  endif
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string format(format_string<_Args...> __fmt,
-                                                                                      _Args&&... __args) {
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string
+format(format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(__fmt.get(), _VSTD::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
 format(wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(__fmt.get(), _VSTD::make_wformat_args(__args...));
 }
-#endif
+#  endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));

 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
                                 _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)});
 }
-#endif
+#  endif
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
 template <class _OutIt, class _CharT, class _FormatOutIt>
 requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
     __vformat_to(
         _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
         basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
     return _VSTD::__format::__vformat_to(
format_to(_OutIt __out_it, locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.get(),
                            _VSTD::make_wformat_args(__args...));
 }
 #endif
 
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
 vformat(locale __loc, string_view __fmt, format_args __args) {
   string __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
                     __args);
   return __res;
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
 vformat(locale __loc, wstring_view __fmt, wformat_args __args) {
   wstring __res;
   _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
                     __args);
   return __res;
 }
-#endif
+#    endif
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string format(locale __loc,
-                                                                                      format_string<_Args...> __fmt,
-                                                                                      _Args&&... __args) {
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string
+format(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(_VSTD::move(__loc), __fmt.get(),
                         _VSTD::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
 format(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::vformat(_VSTD::move(__loc), __fmt.get(),
                         _VSTD::make_wformat_args(__args...));
 }
-#endif
+#    endif
 
 template <class _Context, class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
                                                                 locale __loc, basic_string_view<_CharT> __fmt,
                                                                 basic_format_args<_Context> __args) {
   __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
_LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
   _VSTD::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
       _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
   return _VSTD::move(__buffer).__result();
 }
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+_LIBCPP_NODISCARD_EXT _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
   return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)});
 }
-#endif
+#    endif
 
-#endif // _LIBCPP_HAS_NO_LOCALIZATION
+#  endif // _LIBCPP_HAS_NO_LOCALIZATION
 
-
 #endif //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FORMAT_FORMAT_FUNCTIONS

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"
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <locale>
+#endif
+
+void test() {
+  std::format("");
+  std::vformat("", std::make_format_args());
+  std::formatted_size("");
+  std::make_format_args();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(L"");
+  std::vformat(L"", std::make_wformat_args());
+  std::formatted_size(L"");
+  std::make_wformat_args();
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  std::format(std::locale::classic(), "");
+  std::vformat(std::locale::classic(), "", std::make_format_args());
+  std::formatted_size(std::locale::classic(), "");
+#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(std::locale::classic(), L"");
+  std::vformat(std::locale::classic(), L"", std::make_wformat_args());
+  std::formatted_size(std::locale::classic(), L"");
+#  endif // TEST_HAS_NO_WIDE_CHARACTERS
+#endif   // TEST_HAS_NO_LOCALIZATION
+}

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>
+#endif
+
+void test() {
+  // clang-format off
+  std::format(""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::vformat("", std::make_format_args()); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::formatted_size(""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::make_format_args(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(L""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::vformat(L"", std::make_wformat_args()); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::formatted_size(L""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::make_wformat_args(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+  std::format(std::locale::classic(), ""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::vformat(std::locale::classic(), "", std::make_format_args()); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::formatted_size(std::locale::classic(), ""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+#  ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  std::format(std::locale::classic(), L""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::vformat(std::locale::classic(), L"", std::make_wformat_args()); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  std::formatted_size(std::locale::classic(), L""); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+#  endif // TEST_HAS_NO_WIDE_CHARACTERS
+#endif   // TEST_HAS_NO_LOCALIZATION
+  // clang-format on
+}

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.sh.cpp

 
 // [format.arg]/5.2
 // - otherwise, if T is char and char_type is wchar_t, initializes value with static_cast<wchar_t>(v);
 
 #include <format>
 #include <iterator>
 #include <string>
 
+#include "test_macros.h"
+
 void test() {
-  std::make_format_args<std::basic_format_context<
-      std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>('c');
+  TEST_IGNORE_NODISCARD
+  std::make_format_args<std::basic_format_context<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>('c');
 }

libcxx/test/std/utilities/format/format.functions/format.locale.verify.cpp

 #include <format>
 #include <locale>
 
 #include "test_macros.h"
 
 // clang-format off
 
 void f() {
-  std::format(std::locale(), "{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), "{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), "{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::format(std::locale(), L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(std::locale(), L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(std::locale(), L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }

libcxx/test/std/utilities/format/format.functions/format.verify.cpp

 
 #include <format>
 
 #include "test_macros.h"
 
 // clang-format off
 
 void f() {
-  std::format("{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::format(L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }
 
 struct tiny {
   int bit : 1;
 };
 
 void P2418()
 {
   auto t = tiny{};
-  std::format("{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+  TEST_IGNORE_NODISCARD std::format("{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::format(L"{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
+  TEST_IGNORE_NODISCARD std::format(L"{}", t.bit); // expected-error{{non-const reference cannot bind to bit-field 'bit'}}
 #endif
 }

libcxx/test/std/utilities/format/format.functions/formatted_size.locale.verify.cpp

 #include <format>
 #include <locale>
 
 #include "test_macros.h"
 
 // clang-format off
 
 void f() {
-  std::formatted_size(std::locale(), "{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), "{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), "{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::formatted_size(std::locale(), L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(std::locale(), L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(std::locale(), L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }

libcxx/test/std/utilities/format/format.functions/formatted_size.verify.cpp

 
 #include <format>
 
 #include "test_macros.h"
 
 // clang-format off
 
 void f() {
-  std::formatted_size("{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{:-}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{:#}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{:L}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{0:{0}}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{:.42d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size("{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size("{:d}", "Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::formatted_size(L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{0}"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{:-}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{:#}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{:L}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{0:{0}}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{:.42d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::formatted_size(L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::formatted_size(L"{:d}", L"Forty-two"); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }

libcxx/test/std/utilities/format/format.tuple/format.functions.format.verify.cpp

 #include <utility>
 #include <tuple>
 
 #include "test_macros.h"
 
 // clang-format off
 
 void f() {
-  std::format("{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format("{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-  std::format(L"{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{::}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{::^}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:+}", std::make_pair(0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:m}", std::make_tuple(0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 
-  std::format(L"{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:m}", std::make_tuple(0, 0, 0)); // expected-error-re{{call to consteval function '{{.*}}' is not a constant expression}}
   // expected-note@*:* {{non-constexpr function '__throw_format_error' cannot be used in a constant expression}}
 #endif
 }