[libc++][format] Addresses LWG3720.

[Mordante]

Summary

LWG3720 Restrict the valid types of arg-id for width and precision in
std-format-spec

Depends on D144325

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

libcxx/test/std/utilities/format/format.string/format.string.std/lwg3720_arg_id_width_precision_allowed_types.verify.cpp

32

Do we get some sort of note that explains the reason for the format failing to parse?

[Mordante]

libcxx/test/std/utilities/format/format.string/format.string.std/lwg3720_arg_id_width_precision_allowed_types.verify.cpp

32

Unfortunately no. I know it can be done with template magic, but that seems non-trivial to do. I have considered adding a way to get better compile time errors in Clang. There is a recent paper by Barry (P2758) which proposes something like that, but even more powerful than I originally considered.

[ldionne]

libcxx/include/__format/parser_std_format_spec.h

94–96

[ldionne]

libcxx/test/std/utilities/format/format.string/format.string.std/lwg3720_arg_id_width_precision_allowed_types.pass.cpp

12–14

I think you want to remove these annotations, and if the back-deployment CI fails, then you must be using floating-point to_chars, so you can add:

// XFAIL: availability-fp_to_chars-missing

[Mordante]

Rebased, addresses review comments, and test the CI.

libcxx/docs/Status/Cxx2bIssues.csv

 "`3824 <https://wg21.link/LWG3824>`__","Number of ``bind`` placeholders is underspecified", "November 2022","|Nothing to do|","",""
 "`3826 <https://wg21.link/LWG3826>`__","Redundant specification [for overload of yield_value]", "November 2022","","",""
 "","","","","",""
 "`2195 <https://wg21.link/LWG2195>`__","Missing constructors for ``match_results``","February 2023","","",""
 "`2295 <https://wg21.link/LWG2295>`__","Locale name when the provided ``Facet`` is a ``nullptr``","February 2023","","",""
 "`3032 <https://wg21.link/LWG3032>`__","``ValueSwappable`` requirement missing for ``push_heap`` and ``make_heap``","February 2023","","",""
 "`3085 <https://wg21.link/LWG3085>`__","``char_traits::copy`` precondition too weak","February 2023","","",""
 "`3664 <https://wg21.link/LWG3664>`__","`LWG 3392 <https://wg21.link/LWG3392>`__ ``broke std::ranges::distance(a, a+3)``","February 2023","","","|ranges|"
-"`3720 <https://wg21.link/LWG3720>`__","Restrict the valid types of ``arg-id`` for width and precision in ``std-format-spec``","February 2023","","","|format|"
+"`3720 <https://wg21.link/LWG3720>`__","Restrict the valid types of ``arg-id`` for width and precision in ``std-format-spec``","February 2023","|Complete|","17.0","|format|"
 "`3756 <https://wg21.link/LWG3756>`__","Is the ``std::atomic_flag`` class signal-safe?","February 2023","","",""
 "`3769 <https://wg21.link/LWG3769>`__","``basic_const_iterator::operator==`` causes infinite constraint recursion","February 2023","","","|spaceship|"
 "`3807 <https://wg21.link/LWG3807>`__","The feature test macro for ``ranges::find_last`` should be renamed","February 2023","","","|ranges|"
 "`3811 <https://wg21.link/LWG3811>`__","``views::as_const`` on ``ref_view<T>`` should return ``ref_view<const T>``","February 2023","","","|ranges|"
 "`3820 <https://wg21.link/LWG3820>`__","``cartesian_product_view::iterator::prev`` is not quite right","February 2023","","","|ranges|"
 "`3825 <https://wg21.link/LWG3825>`__","Missing compile-time argument ``id`` check in ``basic_format_parse_context::next_arg_id``","February 2023","|Complete|","17.0","|format|"
 "`3204 <https://wg21.link/LWG3204>`__","``sub_match::swap`` only swaps the base class","February 2023","|Complete|","17.0",""
 "`3733 <https://wg21.link/LWG3733>`__","``ranges::to`` misuses ``cpp17-input-iterator``","February 2023","","","|ranges|"

libcxx/include/__format/format_functions.h

public:
   _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(iterator) {}
 
 private:
   const __arg_t* __args_;
   const __compile_time_handle<_CharT>* __handles_;
   size_t __size_;
 };
 
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __compile_time_validate_integral(__arg_t __type) {
+// [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.
+//
+// _HasPrecision does the formatter have a precision?
+template <class _CharT, class _Tp, bool _HasPrecision = false>
+_LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_validate_argument(
+    basic_format_parse_context<_CharT>& __parse_ctx, __compile_time_basic_format_context<_CharT>& __ctx) {
+  auto __validate_type = [](__arg_t __type) {
+    // LWG3720 originally allowed "signed or unsigned integer types", however
+    // the final version explicitly changed it to "*standard* signed or unsigned
+    // integer types". It's trivial to use 128-bit integrals in libc++'s
+    // implementation, but other implementations may not implement it.
+    // (Using a width or precision, that does not fit in 64-bits, sounds very
+    // unlikely in real world code.)
     switch (__type) {
     case __arg_t::__int:
     case __arg_t::__long_long:
-  case __arg_t::__i128:
     case __arg_t::__unsigned:
     case __arg_t::__unsigned_long_long:
-  case __arg_t::__u128:
       return;
 
     default:
-    std::__throw_format_error("Argument isn't an integral type");
-  }
+      std::__throw_format_error("Replacement argument isn't a standard signed or unsigned integer type");
     }
+  };
 
-// _HasPrecision does the formatter have a precision?
-template <class _CharT, class _Tp, bool _HasPrecision = false>
-_LIBCPP_HIDE_FROM_ABI constexpr void
-__compile_time_validate_argument(basic_format_parse_context<_CharT>& __parse_ctx,
-                                 __compile_time_basic_format_context<_CharT>& __ctx) {
   formatter<_Tp, _CharT> __formatter;
   __parse_ctx.advance_to(__formatter.parse(__parse_ctx));
-  // [format.string.std]/7
-  // ... If the corresponding formatting argument is not of integral type, or
-  // its value is negative for precision or non-positive for width, an
-  // exception of type format_error is thrown.
-  //
-  // Validate whether the arguments are integrals.
   if (__formatter.__parser_.__width_as_arg_)
-    __format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__width_));
+    __validate_type(__ctx.arg(__formatter.__parser_.__width_));
 
   if constexpr (_HasPrecision)
     if (__formatter.__parser_.__precision_as_arg_)
-      __format::__compile_time_validate_integral(__ctx.arg(__formatter.__parser_.__precision_));
+      __validate_type(__ctx.arg(__formatter.__parser_.__precision_));
 }
 
 // This function is not user facing, so it can directly use the non-standard types of the "variant".
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_format_parse_context<_CharT>& __parse_ctx,
                                                                      __compile_time_basic_format_context<_CharT>& __ctx,
                                                                      __arg_t __type) {
   switch (__type) {

libcxx/include/__format/parser_std_format_spec.h

__substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   //    If the corresponding formatting argument is not of standard signed or
   //    unsigned integer type,
   // This means the 128-bit will not be valid anymore.
   // TODO FMT Verify this resolution is accepted and add a test to verify
   //          128-bit integrals fail and switch to visit_format_arg.
   return _VSTD::__visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
-        if constexpr (integral<_Type>) {
+        if constexpr (same_as<_Type, monostate>)
+          std::__throw_format_error("Argument index out of bounds");
+
+        // [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.
+        //
+        // When an integral is used in a format function, it is stored as one of
+        // the types checked below. Other integral types are promoted. For example,
+        // a signed char is stored as an int.
+        if constexpr (same_as<_Type, int> || same_as<_Type, unsigned int> || //
+                      same_as<_Type, long long> || same_as<_Type, unsigned long long>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
               std::__throw_format_error("A format-spec arg-id replacement shouldn't have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
-          if (static_cast<_CT>(__arg) >
-              static_cast<_CT>(__format::__number_max))
+          if (static_cast<_CT>(__arg) > static_cast<_CT>(__format::__number_max))
             std::__throw_format_error("A format-spec arg-id replacement exceeds the maximum supported value");
 
           return __arg;
-        } else if constexpr (same_as<_Type, monostate>)
-          std::__throw_format_error("Argument index out of bounds");
-        else
-          std::__throw_format_error("A format-spec arg-id replacement argument isn't an integral type");
+        } else
+          std::__throw_format_error("Replacement argument isn't a standard signed or unsigned integer type");
       },
       __format_arg);
 }
 
 /// These fields are a filter for which elements to parse.
 ///
 /// They default to false so when a new field is added it needs to be opted in
 /// explicitly.

libcxx/test/std/utilities/format/format.functions/format_tests.h

#ifdef _LIBCPP_VERSION
   check_exception("The numeric value of the format-spec is too large", SV("{:5000000000}"), world);
   check_exception("The numeric value of the format-spec is too large", SV("{:10000000000}"), world);
 #endif
 
   check_exception("A format-spec arg-id replacement shouldn't have a negative value", SV("hello {:{}}"), world, -1);
   check_exception("A format-spec arg-id replacement exceeds the maximum supported value", SV("hello {:{}}"), world,
                   unsigned(-1));
   check_exception("Argument index out of bounds", SV("hello {:{}}"), world);
-  check_exception("A format-spec arg-id replacement argument isn't an integral type", SV("hello {:{}}"), world,
-                  universe);
+  check_exception(
+      "Replacement argument isn't a standard signed or unsigned integer type", SV("hello {:{}}"), world, universe);
   check_exception("Using manual argument numbering in automatic argument numbering mode", SV("hello {:{0}}"), world, 1);
   check_exception("Using automatic argument numbering in manual argument numbering mode", SV("hello {0:{}}"), world, 1);
   // Arg-id may not have leading zeros.
   check_exception("Invalid arg-id", SV("hello {0:{01}}"), world, 1);
 
   // *** precision ***
 #ifdef _LIBCPP_VERSION
   // This limit isn't specified in the Standard.
   static_assert(std::__format::__number_max == 2'147'483'647, "Update the assert and the test.");
   check_exception("The numeric value of the format-spec is too large", SV("{:.2147483648}"), world);
   check_exception("The numeric value of the format-spec is too large", SV("{:.5000000000}"), world);
   check_exception("The numeric value of the format-spec is too large", SV("{:.10000000000}"), world);
 #endif
 
   // Precision 0 allowed, but not useful for string arguments.
   check(SV("hello "), SV("hello {:.{}}"), world, 0);
   // Precision may have leading zeros. Secondly tests the value is still base 10.
   check(SV("hello 0123456789"), SV("hello {:.000010}"), STR("0123456789abcdef"));
   check_exception("A format-spec arg-id replacement shouldn't have a negative value", SV("hello {:.{}}"), world, -1);
   check_exception("A format-spec arg-id replacement exceeds the maximum supported value", SV("hello {:.{}}"), world,
                   ~0u);
   check_exception("Argument index out of bounds", SV("hello {:.{}}"), world);
-  check_exception("A format-spec arg-id replacement argument isn't an integral type", SV("hello {:.{}}"), world,
-                  universe);
+  check_exception(
+      "Replacement argument isn't a standard signed or unsigned integer type", SV("hello {:.{}}"), world, universe);
   check_exception("Using manual argument numbering in automatic argument numbering mode", SV("hello {:.{0}}"), world,
                   1);
   check_exception("Using automatic argument numbering in manual argument numbering mode", SV("hello {0:.{}}"), world,
                   1);
   // Arg-id may not have leading zeros.
   check_exception("Invalid arg-id", SV("hello {0:.{01}}"), world, 1);
 
   // *** locale-specific form ***
void format_test_signed_integer(TestFunction check, ExceptionTest check_exception) {
   format_test_integer<signed char, CharT>(check, check_exception);
   format_test_integer<short, CharT>(check, check_exception);
   format_test_integer<int, CharT>(check, check_exception);
   format_test_integer<long, CharT>(check, check_exception);
   format_test_integer<long long, CharT>(check, check_exception);
 #ifndef TEST_HAS_NO_INT128
   format_test_integer<__int128_t, CharT>(check, check_exception);
 #endif
-  // *** check the minma and maxima ***
+  // *** check the minima and maxima ***
   check(SV("-0b10000000"), SV("{:#b}"), std::numeric_limits<std::int8_t>::min());
   check(SV("-0200"), SV("{:#o}"), std::numeric_limits<std::int8_t>::min());
   check(SV("-128"), SV("{:#}"), std::numeric_limits<std::int8_t>::min());
   check(SV("-0x80"), SV("{:#x}"), std::numeric_limits<std::int8_t>::min());
 
   check(SV("-0b1000000000000000"), SV("{:#b}"), std::numeric_limits<std::int16_t>::min());
   check(SV("-0100000"), SV("{:#o}"), std::numeric_limits<std::int16_t>::min());
   check(SV("-32768"), SV("{:#}"), std::numeric_limits<std::int16_t>::min());

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: libcpp-has-no-incomplete-format
+
+// 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.
+//
+// This test does the run-time validation
+
+#include <cassert>
+#include <format>
+
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "format.functions.common.h"
+#include "make_string.h"
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT, class... Args>
+void test_exception([[maybe_unused]] std::basic_string_view<CharT> fmt, [[maybe_unused]] Args&&... args) {
+  [[maybe_unused]] std::string_view what = "Replacement argument isn't a standard signed or unsigned integer type";
+  TEST_VALIDATE_EXCEPTION(
+      std::format_error,
+      [&]([[maybe_unused]] const std::format_error& e) {
+        TEST_LIBCPP_REQUIRE(
+            e.what() == what,
+            TEST_WRITE_CONCATENATED(
+                "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
+      },
+      TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
+}
+
+template <class CharT>
+void test() {
+  // *** Width ***
+  test_exception(SV("{:{}}"), 42, true);
+  test_exception(SV("{:{}}"), 42, '0');
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  if constexpr (std::same_as<CharT, wchar_t>)
+    test_exception(SV("{:{}}"), 42, L'0');
+#endif
+#ifndef TEST_HAS_NO_INT128
+  test_exception(SV("{:{}}"), 42, __int128_t(0));
+  test_exception(SV("{:{}}"), 42, __uint128_t(0));
+#endif
+  test_exception(SV("{:{}}"), 42, 42.0f);
+  test_exception(SV("{:{}}"), 42, 42.0);
+  test_exception(SV("{:{}}"), 42, 42.0l);
+
+  // *** Precision ***
+  test_exception(SV("{:0.{}}"), 42.0, true);
+  test_exception(SV("{:0.{}}"), 42.0, '0');
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  if constexpr (std::same_as<CharT, wchar_t>)
+    test_exception(SV("{:0.{}}"), 42.0, L'0');
+#endif
+#ifndef TEST_HAS_NO_INT128
+  test_exception(SV("{:0.{}}"), 42.0, __int128_t(0));
+  test_exception(SV("{:0.{}}"), 42.0, __uint128_t(0));
+#endif
+  test_exception(SV("{:0.{}}"), 42.0, 42.0f);
+  test_exception(SV("{:0.{}}"), 42.0, 42.0);
+  test_exception(SV("{:0.{}}"), 42.0, 42.0l);
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

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
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// 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.
+//
+// This test does the compile-time validation
+
+#include <format>
+
+#include "test_macros.h"
+
+void test_char_width() {
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, true);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, '0');
+#ifndef TEST_HAS_NO_INT128
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, __int128_t(0));
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, __uint128_t(0));
+#endif
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, 42.0f);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, 42.0);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:{}}", 42, 42.0l);
+}
+
+void test_char_precision() {
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, true);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, '0');
+#ifndef TEST_HAS_NO_INT128
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, __int128_t(0));
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, __uint128_t(0));
+#endif
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, 42.0f);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, 42.0);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format("{:0.{}}", 42.0, 42.0l);
+}
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+void test_wchar_t_width() {
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, true);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, '0');
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, L'0');
+#  ifndef TEST_HAS_NO_INT128
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, __int128_t(0));
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, __uint128_t(0));
+#  endif
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, 42.0f);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, 42.0);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:{}}", 42, 42.0l);
+}
+
+void test_wchar_t_precision() {
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, true);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, '0');
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, L'0');
+#  ifndef TEST_HAS_NO_INT128
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, __int128_t(0));
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, __uint128_t(0));
+#  endif
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, 42.0f);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, 42.0);
+  // expected-error-re@*:* {{call to consteval function {{.*}} is not a constant expression}}
+  TEST_IGNORE_NODISCARD std::format(L"{:0.{}}", 42.0, 42.0l);
+}
+
+#endif // TEST_HAS_NO_WIDE_CHARACTERS