[libc++][format] Adds parser std-format-spec.

[Mordante]

Summary

This implements the generic std.format.spec framework for all types.

The Unicode support will be added in a separate patch.

Implements parts of:

• P0645 Text Formatting

Completes:

• LWG-3242 std::format: missing rules for arg-id in width and precision
• P1892 Extended locale-specific presentation specifiers for std::format

[Mordante]

Reupload, forgot to set the dependencies so CI failed.

[Mordante]

Updates the paper status.
Fixes no-except and no-localization unit tests.

[Mordante]

Rebase.
Mark unit test requiring concepts.
Minor cleanup.

[Mordante]

Tabs -> spaces.

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

133

This should really be a grapheme cluster but {fmt} uses a code point at the moment (grapheme clusterization will be added later). In any case this should be a range (e.g. string_view) and not a single code unit.

139

This will have to change for the same reason.

185–186

This is incorrect because format specs can consist of a single sign specifier. Same for other "End of input" errors.

197–202

I don't think you need to have this check because it will be caught elsewhere anyway. Format specifiers are type-specific and it generally makes more sense to say what is supported rather than what is not. Same for other __parser_no_* cases.

278–280

This is redundant and only adds an overhead without substantially improving diagnostics. The error message is not particularly correct either.

308–309

It might be better to just return a large value and let the error be reported elsewhere (when the ID is actually used). It's both more efficient and gives better diagnostic without referring to internal magic limits.

322

with -> width

374

Note that any nonnegative int32_t value is a valid precision so I'm not sure __number_max is OK here.

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

422

Looks like a stray "without".

472

This is a wrong place to do such validation because format specs may not have }.

552

Did you mean std-format-spec?

557–559

It does now.

583

This isn't correct. std-format-spec doesn't have to be terminated by anything. formatter::parse can be used to parse standalone format specs. } is part of replacement-field and should be handled there.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

133

My interpretation of http://eel.is/c++draft/format#string.std-2

The fill character can be any character other than { or }.

is that this is intended to be a single character and not a Unicode grapheme cluster. I can't find a paper or defect report that intends to change the current behaviour. Was it intended to be part of P1868R2 "🦄 width: clarifying units of width and precision in std::format" ?

Is there a paper or defect report, or should I file a defect report?

I don't mind changing it, but for now there are some unclarities how to implement this feature:
Are 2 column Unicode characters allowed?

• if yes, how to do odd even formatting?
• if no, then is it a precondition or should the implementation do an width estimate?

For now I'll leave it as is, there's a TODO FMT to address this issue later.

139

Likewise will be done later.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

197–202

I personally like to report errors as early as possible. So for types where the sign makes no sense, for example strings, I like to report them as soon as they're found. For the other types I indeed still need post processing based on the type.

278–280

Removed. The if (__r.first == __end) validation in this function has also been removed.

308–309

I think that can lead to errors. When _Type is uint64_t containing UINT32_MAX + 1 it will return 1 without this test.

374

This was on "the 999.999.999 maximum"-will-never-be-used-in-practice assumption. I've adjusted the code to handle every non-negative int32_t.

557–559

true :-)

583

Yes that is now handled in the replacement field of the previous patch.

[Mordante]

Addresses review comments:

• Replacement field shouldn't require a terminating '}'
• Change error strings
• Allow precision and width to use the whole positive range of int32_t
• Update module map
• Several minor improvements

[Mordante]

Only test the exact exception messages when testing libc++, as noted in D96664.

[Mordante]

Rebase.
Use new monostate header.
Use LIBCPP_ASSERT.

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

101

Fixed should have lower and uppercase variants too (f and F).

133

should I file a defect report?

Please do open a LWG issue. The "character" term is ambiguous but if interpreted in the C++ sense the current wording is clearly wrong because you cannot even use box drawing characters (in the Unicode sense). We can discuss the details in the LWG issue.

197–202

In addition to being conceptually wrong having these checks penalizes many common cases. I strongly suggest making all __parser_no_* cases noops. The only reason the standard wording uses a single grammar for built-in and string types is simplicity but in reality these are separate per-type grammars and should be treated as such. Moreover, those unnecessary checks won't apply to chrono and UDTs potentially adding more confusion.

361–363

I suggest moving this check into __substitute_arg_id which will allow having one check instead of two for the common case of signed width.

389

So if the user passes a precision of INT32_MAX it will be treated as "no precision" (and asserted on in debug mode) which is somewhat arbitrary and may lead to the same problems I mentioned earlier. To avoid this you could use two values above INT32_MAX (e.g. INT32_MAX + 1 and INT32_MAX + 2 to denote "no precision" and __precision_as_arg respectively.

[Mordante]

Thanks for the review!

libcxx/include/__format/parser_std_format_spec.h

101

The upper and lower case are formatted the same. So the the type function maps both f and F to fixed.

389

I guess I need more comment for this code ;-)
When the format-spec has a value __precision_as_arg == 0.
When the format-spec has an arg-id all arg-id's except for INT32_MAX are a valid arg-id. If the arg-id gets resolved to INT32_MAX this value is considered a limit.

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

101

Not quite, NaN and infinity are formatted differently.

389

In other words INT32_MAX is already handled correctly with the current approach or have I misunderstood your comment?

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

101

I forgot about these cases.

197–202

Thanks for the additional explanation. I now see what you meant before. For now I'll make them noops. I'll also add a TODO because with this new insight I might want to look at a cleaner solution later.

361–363

__substitute_arg_id is also used to substitute the precision. A precision of 0 is valid. I'll give it some thought, but at the moment I don't see a good alternative.

389

Yes INT32_MAX is currently handled correctly.

[Mordante]

Rebased
Made module headers private
Addresses review comments
Removed unit tests no longer required due change to the parser_no changes
Marked other unit tests as libc++ specific

[vitaut]

Looks great, thanks for addressing the comments!

[vitaut]

libcxx/include/__format/parser_std_format_spec.h

133

So have you or do you plan to open an LWG issue? Otherwise I can do it.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

133

I plan to file an LWG issue. But I first want to address all other review comments. It's on my TODO list.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

118

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/ here and all other occurrences in this patch.

[Mordante]

• Rebased and updated to work against main.
• Remove [[nodiscard]]s.
• s/_LIBCPP_TYPE_VIS/_LIBCPP_HIDE_FROM_ABI/
• Refactor the std-format-spec parser. Since the parser_no_ classes are a kind of useless dummy they can be removed. Due to this change several tests no longer that useful, they are removed.
• Test with designated initializers to improve readability of the tests. When this passes the CI I want to improve more of the tests.

[Mordante]

When the build passes I want to polish the unit tests a bit more.

[DavidSpickett]

Apologies for the AArch64 test timeout. There are some issues on our end that I'm currently working on.

[Mordante]

In D103368#2915965, @DavidSpickett wrote:

Apologies for the AArch64 test timeout. There are some issues on our end that I'm currently working on.

Thanks for the update.

[Mordante]

Retarget for llvm 14.
Improve unit tests by using designated initializers.

[DavidSpickett]

Apologies for the AArch64 test timeout. There are some issues on our end that I'm currently working on.

(as you can see from the build) This has now been resolved.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

133

I filed https://cplusplus.github.io/LWG/issue3576

[Mordante]

Rebased against main.
Adds missing includes
s/_LIBCPP_NO_EXCEPTIONS/TEST_HAS_NO_EXCEPTIONS/

[ldionne]

Nothing major, I'm leaving the correctness of the implementation to @vitaut, who already reviewed it.

libcxx/include/__format/parser_std_format_spec.h

27–28

You don't need this (nor the _LIBCPP_POP_MACROS at the end) if you don't use min() or max() in this file.

141

This assertion message is not very helpful, we should explain *why* it's unexpected that begin == end instead.

616

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

24

libcxx/test/libcxx/utilities/format/format.string/format.string.std/test_exception.h

12

What do you mean by "freestanding" here?

Also, this header should include what it uses.

22–24

We don't want to print error messages like that in the tests, specifically because that doesn't work on some platforms where stderr & friends are not supported. I'd rather just remove this if constexpr. Same goes for below.

[Mordante]

libcxx/include/__format/parser_std_format_spec.h

616

Good catch, this indeed looks weird.

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

24

I'm not too happy with this change, it's what clang-format did. I created D109835 containing an updated clang-format settings so this won't be undone when I rerun clang-format.

libcxx/test/libcxx/utilities/format/format.string/format.string.std/test_exception.h

12

Freestanding means the header depends on the state of the translation unit before the header itself. Hence it requires no includes.
It depends on the parser type in the test using it. I changed the unit tests to supply that argument as template argument, so the header can be a normal header.

22–24

I expect stderr to be valid on all platforms what do not define _LIBCPP_HAS_NO_LOCALIZATION. AFAIK this macro should be the proper guard.
I don't mind removing them too much, so I'll remove them.

[Mordante]

Addresses review comments.
Ran clang-format with the settings added in D109835.
Adds a small comment.

libcxx/docs/Status/Cxx20Issues.csv

 "`3175 <https://wg21.link/LWG3175>`__","The ``CommonReference``\  requirement of concept ``SwappableWith``\  is not satisfied in the example","Prague","|Complete|","13.0"
 "`3194 <https://wg21.link/LWG3194>`__","``ConvertibleTo``\  prose does not match code","Prague","|Complete|","13.0"
 "`3200 <https://wg21.link/LWG3200>`__","``midpoint``\  should not constrain ``T``\  is complete","Prague","|Nothing To Do|",""
 "`3201 <https://wg21.link/LWG3201>`__","``lerp``\  should be marked as ``noexcept``\ ","Prague","|Complete|",""
 "`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\  constructor from ``string_view``\  should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague","",""
 "`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\  converting constructors","Prague","",""
 "`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","",""
 "`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\  deduction guides","Prague","",""
-"`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague","",""
+"`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague","|Complete|","Clang 14"
 "`3243 <https://wg21.link/LWG3243>`__","``std::format``\  and negative zeroes","Prague","",""
 "`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague","",""
 "`3248 <https://wg21.link/LWG3248>`__","``std::format``\  ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\   presentation types misformat negative numbers","Prague","",""
 "`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\  (alternate form) for NaN and inf","Prague","",""
 "`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\  alignment specifiers applied to string arguments?","Prague","",""
 "`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","",""
 "`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","",""
 "`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\  constructor is too strict","Prague","|Complete|",""

libcxx/docs/Status/Cxx20Papers.csv

 "`P1855 <https://wg21.link/P1855>`__","LWG","Make ``<compare>``\  freestanding","Belfast","* *",""
 "`P1862 <https://wg21.link/P1862>`__","LWG","Ranges adaptors for non-copyable iterators","Belfast","* *",""
 "`P1865 <https://wg21.link/P1865>`__","LWG","Add max() to latch and barrier","Belfast","|Complete|","11.0"
 "`P1869 <https://wg21.link/P1869>`__","LWG","Rename 'condition_variable_any' interruptible wait methods","Belfast","* *",""
 "`P1870 <https://wg21.link/P1870>`__","LWG","forwarding-range is too subtle","Belfast","|In Progress|",""
 "`P1871 <https://wg21.link/P1871>`__","LWG","Should concepts be enabled or disabled?","Belfast","* *",""
 "`P1872 <https://wg21.link/P1872>`__","LWG","span should have size_type, not index_type","Belfast","|Complete|","10.0"
 "`P1878 <https://wg21.link/P1878>`__","LWG","Constraining Readable Types","Belfast","* *",""
-"`P1892 <https://wg21.link/P1892>`__","LWG","Extended locale-specific presentation specifiers for std::format","Belfast","* *",""
+"`P1892 <https://wg21.link/P1892>`__","LWG","Extended locale-specific presentation specifiers for std::format","Belfast","|Complete|","14.0"
 "`P1902 <https://wg21.link/P1902>`__","LWG","Missing feature-test macros 2018-2019","Belfast","* *",""
 "`P1959 <https://wg21.link/P1959>`__","LWG","Remove std::weak_equality and std::strong_equality","Belfast","* *",""
 "`P1960 <https://wg21.link/P1960>`__","LWG","NB Comment Changes Reviewed by SG1","Belfast","* *",""
 "`P1961 <https://wg21.link/P1961>`__","LWG","Harmonizing the definitions of total order for pointers","Belfast","* *",""
 "`P1965 <https://wg21.link/P1965>`__","LWG","Blanket Wording for Specifying ""Hidden Friends""","Belfast","* *",""
 "","","","","",""
 "`P0586 <https://wg21.link/P0586>`__","LWG","Safe integral comparisons","Prague","|Complete|","13.0"
 "`P0593 <https://wg21.link/P0593>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *",""

 "`P2106 <https://wg21.link/P2106>`__","LWG","Alternative wording for GB315 and GB316","Prague","* *",""
 "`P2116 <https://wg21.link/P2116>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "`P2231 <https://wg21.link/P2231>`__","LWG","Missing constexpr in std::optional and std::variant","February 2021","|In progress|","13.0"
 "`P2325 <https://wg21.link/P2325>`__","LWG","Views should not be required to be default constructible","June 2021","|In progress|",""
 "`P2210R2 <https://wg21.link/P2210R2>`__","LWG",Superior String Splitting,"June 2021","",""
 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG",std::format improvements,"June 2021","",""
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG",Clarifying range adaptor objects,"June 2021","",""
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG",join_view should join all views of ranges,"June 2021","",""
-"`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
+"`P2367R0 <https://wg21.link/P2367R0>`__","LWG",Remove misuses of list-initialization from Clause 24,"June 2021","",""
 

libcxx/include/CMakeLists.txt

set(files
   __format/format_arg.h
   __format/format_args.h
   __format/format_context.h
   __format/format_error.h
   __format/format_fwd.h
   __format/format_parse_context.h
   __format/format_string.h
   __format/formatter.h
+  __format/parser_std_format_spec.h
   __function_like.h
   __functional_base
   __functional/binary_function.h
   __functional/binary_negate.h
   __functional/bind_back.h
   __functional/bind_front.h
   __functional/bind.h
   __functional/binder1st.h

libcxx/include/__format/formatter.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___FORMAT_FORMATTER_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
 #include <__availability>
 #include <__config>
 #include <__format/format_error.h>
+#include <__format/parser_std_format_spec.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 

libcxx/include/__format/parser_std_format_spec.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
+#define _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H
+
+#include <__config>
+#include <__debug>
+#include <__format/format_arg.h>
+#include <__format/format_error.h>
+#include <__format/format_string.h>
+#include <__variant/monostate.h>
+#include <concepts>
+#include <cstdint>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+// TODO FMT Remove this once we require compilers with proper C++20 support.
+// If the compiler has no concepts support, the format header will be disabled.
+// Without concepts support enable_if needs to be used and that too much effort
+// to support compilers with partial C++20 support.
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+namespace __format_spec {
+
+/**
+ * Contains the flags for the std-format-spec.
+ *
+ * Some format-options can only be used for specific C++types and may depend on
+ * the selected format-type.
+ * * The C++type filtering can be done using the proper policies for
+ *   @ref __parser_std.
+ * * The format-type filtering needs to be done post parsing in the parser
+ *   derived from @ref __parser_std.
+ */
+class _LIBCPP_TYPE_VIS _Flags {
+public:
+  enum class _LIBCPP_ENUM_VIS _Alignment : uint8_t {
+    /**
+     * No alignment is set in the format string.
+     *
+     * Zero-padding is ignored when an alignment is selected.
+     * The default alignment depends on the selected format-type.
+     */
+    __default,
+    __left,
+    __center,
+    __right
+  };
+  enum class _LIBCPP_ENUM_VIS _Sign : uint8_t {
+    /**
+     * No sign is set in the format string.
+     *
+     * The sign isn't allowed for certain format-types. By using this value
+     * it's possible to detect whether or not the user explicitly set the sign
+     * flag. For formatting purposes it behaves the same as @ref __minus.
+     */
+    __default,
+    __minus,
+    __plus,
+    __space
+  };
+
+  _Alignment __alignment : 2 {_Alignment::__default};
+  _Sign __sign : 2 {_Sign::__default};
+  uint8_t __alternate_form : 1 {false};
+  uint8_t __zero_padding : 1 {false};
+  uint8_t __locale_specific_form : 1 {false};
+
+  enum class _LIBCPP_ENUM_VIS _Type : uint8_t {
+    __default,
+    __string,
+    __binary_lower_case,
+    __binary_upper_case,
+    __octal,
+    __decimal,
+    __hexadecimal_lower_case,
+    __hexadecimal_upper_case,
+    __pointer,
+    __char,
+    __float_hexadecimal_lower_case,
+    __float_hexadecimal_upper_case,
+    __scientific_lower_case,
+    __scientific_upper_case,
+    __fixed_lower_case,
+    __fixed_upper_case,
+    __general_lower_case,
+    __general_upper_case
+  };
+
+  _Type __type{_Type::__default};
+};
+
+namespace __detail {
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr bool
+__parse_alignment(_CharT __c, _Flags& __flags) noexcept {
+  switch (__c) {
+  case _CharT('<'):
+    __flags.__alignment = _Flags::_Alignment::__left;
+    return true;
+
+  case _CharT('^'):
+    __flags.__alignment = _Flags::_Alignment::__center;
+    return true;
+
+  case _CharT('>'):
+    __flags.__alignment = _Flags::_Alignment::__right;
+    return true;
+  }
+  return false;
+}
+} // namespace __detail
+
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser_fill_align {
+public:
+  // TODO FMT The standard doesn't specify this character is a Unicode
+  // character. Validate what fmt and MSVC have implemented.
+  _CharT __fill{_CharT(' ')};
+
+protected:
+  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+  __parse(const _CharT* __begin, const _CharT* __end, _Flags& __flags) {
+    _LIBCPP_ASSERT(__begin != __end, "Precondition failure");
+    if (__begin + 1 != __end) {
+      if (__detail::__parse_alignment(*(__begin + 1), __flags)) {
+        if (*__begin == _CharT('{') || *__begin == _CharT('}'))
+          __throw_format_error(
+              "The format-spec fill field contains an invalid character");
+        __fill = *__begin;
+        return __begin + 2;
+      }
+    }
+
+    if (__detail::__parse_alignment(*__begin, __flags))
+      return __begin + 1;
+
+    return __begin;
+  }
+};
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+__parse_sign(const _CharT* __begin, _Flags& __flags) noexcept {
+  switch (*__begin) {
+  case _CharT('-'):
+    __flags.__sign = _Flags::_Sign::__minus;
+    break;
+  case _CharT('+'):
+    __flags.__sign = _Flags::_Sign::__plus;
+    break;
+  case _CharT(' '):
+    __flags.__sign = _Flags::_Sign::__space;
+    break;
+  default:
+    return __begin;
+  }
+  return __begin + 1;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+__parse_alternate_form(const _CharT* __begin, _Flags& __flags) noexcept {
+  if (*__begin == _CharT('#')) {
+    __flags.__alternate_form = true;
+    ++__begin;
+  }
+
+  return __begin;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+__parse_zero_padding(const _CharT* __begin, _Flags& __flags) noexcept {
+  if (*__begin == _CharT('0')) {
+    __flags.__zero_padding = true;
+    ++__begin;
+  }
+
+  return __begin;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result< _CharT>
+__parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+  // This function is a wrapper to call the real parser. But it does the
+  // validation for the pre-conditions and post-conditions.
+  if (__begin == __end)
+    __throw_format_error("End of input while parsing format-spec arg-id");
+
+  __format::__parse_number_result __r =
+      __format::__parse_arg_id(__begin, __end, __parse_ctx);
+
+  if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
+    __throw_format_error("A format-spec arg-id should terminate at a '}'");
+
+  ++__r.__ptr;
+  return __r;
+}
+
+template <class _Context>
+_LIBCPP_HIDE_FROM_ABI constexpr uint32_t
+__substitute_arg_id(basic_format_arg<_Context> __arg) {
+  return visit_format_arg(
+      [](auto __arg) -> uint32_t {
+        using _Type = decltype(__arg);
+        if constexpr (integral<_Type>) {
+          if constexpr (signed_integral<_Type>) {
+            if (__arg < 0)
+              __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))
+            __throw_format_error("A format-spec arg-id replacement exceeds "
+                                 "the maximum supported value");
+          return __arg;
+        } else if constexpr (same_as<_Type, monostate>)
+          __throw_format_error("Argument index out of bounds");
+        else
+          __throw_format_error("A format-spec arg-id replacement argument "
+                               "isn't an integral type");
+      },
+      __arg);
+}
+
+class _LIBCPP_TYPE_VIS __parser_width {
+public:
+  /** Contains a width or an arg-id. */
+  uint32_t __width : 31 {0};
+  /** Determines whether the value stored is a width or an arg-id. */
+  uint32_t __width_as_arg : 1 {0};
+
+protected:
+  /**
+   * Does the supplied std-format-spec contain a width field?
+   *
+   * When the field isn't present there's no padding required. This can be used
+   * to optimize the formatting.
+   */
+  constexpr bool __has_width_field() const noexcept {
+    return __width_as_arg || __width;
+  }
+
+  /**
+   * Does the supplied width field contain an arg-id?
+   *
+   * If @c true the formatter needs to call @ref __substitute_width_arg_id.
+   */
+  constexpr bool __width_needs_substitution() const noexcept {
+    return __width_as_arg;
+  }
+
+  template <class _CharT>
+  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+  __parse(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+    if (*__begin == _CharT('0'))
+      __throw_format_error(
+          "A format-spec width field shouldn't have a leading zero");
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __r =
+          __parse_arg_id(++__begin, __end, __parse_ctx);
+      __width = __r.__value;
+      __width_as_arg = 1;
+      return __r.__ptr;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      return __begin;
+
+    __format::__parse_number_result __r =
+        __format::__parse_number(__begin, __end);
+    __width = __r.__value;
+    _LIBCPP_ASSERT(__width != 0,
+                   "A zero value isn't allowed and should be impossible, "
+                   "due to validations in this function");
+    return __r.__ptr;
+  }
+
+  void _LIBCPP_HIDE_FROM_ABI constexpr __substitute_width_arg_id(auto __arg) {
+    _LIBCPP_ASSERT(__width_as_arg == 1,
+                   "Substitute width called when no substitution is required");
+
+    // The clearing of the flag isn't required but looks better when debugging
+    // the code.
+    __width_as_arg = 0;
+    __width = __substitute_arg_id(__arg);
+    if (__width == 0)
+      __throw_format_error(
+          "A format-spec width field replacement should have a positive value");
+  }
+};
+
+class _LIBCPP_TYPE_VIS __parser_precision {
+public:
+  /** Contains a precision or an arg-id. */
+  uint32_t __precision : 31 {__format::__number_max};
+  /**
+   * Determines whether the value stored is a precision or an arg-id.
+   *
+   * @note Since @ref __precision == @ref __format::__number_max is a valid
+   * value, the default value contains an arg-id of INT32_MAX. (This number of
+   * arguments isn't supported by compilers.)  This is used to detect whether
+   * the std-format-spec contains a precision field.
+   */
+  uint32_t __precision_as_arg : 1 {1};
+
+protected:
+  /**
+   * Does the supplied std-format-spec contain a precision field?
+   *
+   * When the field isn't present there's no truncating required. This can be
+   * used to optimize the formatting.
+   */
+  constexpr bool __has_precision_field() const noexcept {
+
+    return __precision_as_arg == 0 ||             // Contains a value?
+           __precision != __format::__number_max; // The arg-id is valid?
+  }
+
+  /**
+   * Does the supplied precision field contain an arg-id?
+   *
+   * If @c true the formatter needs to call @ref __substitute_precision_arg_id.
+   */
+  constexpr bool __precision_needs_substitution() const noexcept {
+    return __precision_as_arg && __precision != __format::__number_max;
+  }
+
+  template <class _CharT>
+  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+  __parse(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
+    if (*__begin != _CharT('.'))
+      return __begin;
+
+    ++__begin;
+    if (__begin == __end)
+      __throw_format_error("End of input while parsing format-spec precision");
+
+    if (*__begin == _CharT('0')) {
+      ++__begin;
+      if (__begin != __end && *__begin >= '0' && *__begin <= '9')
+        __throw_format_error(
+            "A format-spec precision field shouldn't have a leading zero");
+
+      __precision = 0;
+      __precision_as_arg = 0;
+      return __begin;
+    }
+
+    if (*__begin == _CharT('{')) {
+      __format::__parse_number_result __arg_id =
+          __parse_arg_id(++__begin, __end, __parse_ctx);
+      _LIBCPP_ASSERT(__arg_id.__value != __format::__number_max,
+                     "Unsupported number of arguments, since this number of "
+                     "arguments is used a special value");
+      __precision = __arg_id.__value;
+      return __arg_id.__ptr;
+    }
+
+    if (*__begin < _CharT('0') || *__begin > _CharT('9'))
+      __throw_format_error(
+          "The format-spec precision field doesn't contain a value or arg-id");
+
+    __format::__parse_number_result __r =
+        __format::__parse_number(__begin, __end);
+    __precision = __r.__value;
+    __precision_as_arg = 0;
+    return __r.__ptr;
+  }
+
+  void _LIBCPP_HIDE_FROM_ABI constexpr __substitute_precision_arg_id(
+      auto __arg) {
+    _LIBCPP_ASSERT(
+        __precision_as_arg == 1 && __precision != __format::__number_max,
+        "Substitute precision called when no substitution is required");
+
+    // The clearing of the flag isn't required but looks better when debugging
+    // the code.
+    __precision_as_arg = 0;
+    __precision = __substitute_arg_id(__arg);
+  }
+};
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+__parse_locale_specific_form(const _CharT* __begin, _Flags& __flags) noexcept {
+  if (*__begin == _CharT('L')) {
+    __flags.__locale_specific_form = true;
+    ++__begin;
+  }
+
+  return __begin;
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+__parse_type(const _CharT* __begin, _Flags& __flags) {
+
+  // Determines the type. It does not validate whether the selected type is
+  // valid. Most formatters have optional fields that are only allowed for
+  // certain types. These parsers need to do validation after the type has
+  // been parsed. So its easier to implement the validation for all types in
+  // the specific parse function.
+  switch (*__begin) {
+  case 'A':
+    __flags.__type = _Flags::_Type::__float_hexadecimal_upper_case;
+    break;
+  case 'B':
+    __flags.__type = _Flags::_Type::__binary_upper_case;
+    break;
+  case 'E':
+    __flags.__type = _Flags::_Type::__scientific_upper_case;
+    break;
+  case 'F':
+    __flags.__type = _Flags::_Type::__fixed_upper_case;
+    break;
+  case 'G':
+    __flags.__type = _Flags::_Type::__general_upper_case;
+    break;
+  case 'X':
+    __flags.__type = _Flags::_Type::__hexadecimal_upper_case;
+    break;
+  case 'a':
+    __flags.__type = _Flags::_Type::__float_hexadecimal_lower_case;
+    break;
+  case 'b':
+    __flags.__type = _Flags::_Type::__binary_lower_case;
+    break;
+  case 'c':
+    __flags.__type = _Flags::_Type::__char;
+    break;
+  case 'd':
+    __flags.__type = _Flags::_Type::__decimal;
+    break;
+  case 'e':
+    __flags.__type = _Flags::_Type::__scientific_lower_case;
+    break;
+  case 'f':
+    __flags.__type = _Flags::_Type::__fixed_lower_case;
+    break;
+  case 'g':
+    __flags.__type = _Flags::_Type::__general_lower_case;
+    break;
+  case 'o':
+    __flags.__type = _Flags::_Type::__octal;
+    break;
+  case 'p':
+    __flags.__type = _Flags::_Type::__pointer;
+    break;
+  case 's':
+    __flags.__type = _Flags::_Type::__string;
+    break;
+  case 'x':
+    __flags.__type = _Flags::_Type::__hexadecimal_lower_case;
+    break;
+  default:
+    return __begin;
+  }
+  return ++__begin;
+}
+
+/**
+ * The parser for the std-format-spec.
+ *
+ * [format.string.std]/1 specifies the std-format-spec:
+ *   fill-and-align sign # 0 width precision L type
+ *
+ * All these fields are optional. Whether these fields can be used depend on:
+ * - The type supplied to the format string.
+ *   E.g. A string never uses the sign field so the field may not be set.
+ *   This constrain is validated by the parsers in this file.
+ * - The supplied value for the optional type field.
+ *   E.g. A int formatted as decimal uses the sign field.
+ *   When formatted as a char the sign field may no longer be set.
+ *   This constrain isn't validated by the parsers in this file.
+ *
+ * The base classes are ordered to minimize the amount of padding.
+ *
+ * This implements the parser for the string types.
+ */
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser_string
+    : public __parser_width,              // provides __width(|as_arg)
+      public __parser_precision,          // provides __precision(|as_arg)
+      public __parser_fill_align<_CharT>, // provides __fill and uses __flags
+      public _Flags                       // provides __flags
+{
+public:
+  using char_type = _CharT;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __parser_string() {
+    this->__alignment = _Flags::_Alignment::__left;
+  }
+
+  /**
+   * The low-level std-format-spec parse function.
+   *
+   * @pre __begin points at the beginning of the std-format-spec. This means
+   * directly after the ':'.
+   * @pre The std-format-spec parses the entire input, or the first unmatched
+   * character is a '}'.
+   *
+   * @returns The iterator pointing at the last parsed character.
+   */
+  auto _LIBCPP_HIDE_FROM_ABI constexpr parse(auto& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __it = __parse(__parse_ctx);
+    __process_display_type();
+    return __it;
+  }
+
+private:
+  /**
+   * Parses the std-format-spec.
+   *
+   * @throws __throw_format_error When @a __parse_ctx contains an ill-formed
+   *                               std-format-spec.
+   *
+   * @returns An iterator to the end of input or point at the closing '}'.
+   */
+  auto _LIBCPP_HIDE_FROM_ABI constexpr __parse(auto& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+
+    auto __begin = __parse_ctx.begin();
+    auto __end = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end,
+                                                   static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parser_precision::__parse(__begin, __end, __parse_ctx);
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
+
+    if (__begin != __end && *__begin != _CharT('}'))
+      __throw_format_error(
+          "The format-spec should consume the input or end with a '}'");
+
+    return __begin;
+  }
+
+  /** Processes the parsed std-format-spec based on the parsed display type. */
+  void _LIBCPP_HIDE_FROM_ABI constexpr __process_display_type() {
+    switch (this->__type) {
+    case _Flags::_Type::__default:
+    case _Flags::_Type::__string:
+      break;
+
+    default:
+      __throw_format_error("The format-spec type has a type not supported for "
+                           "a string argument");
+    }
+  }
+};
+
+/**
+ * The parser for the std-format-spec.
+ *
+ * This implements the parser for the integral types. This includes the
+ * character type and boolean type.
+ *
+ * See @ref __parser_string.
+ */
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser_integral
+    : public __parser_width,              // provides __width(|as_arg)
+      public __parser_fill_align<_CharT>, // provides __fill and uses __flags
+      public _Flags                       // provides __flags
+{
+public:
+  using char_type = _CharT;
+
+  // TODO FMT This class probably doesn't need public member functions after
+  // format.string.std/std_format_spec_integral.pass.cpp has been retired.
+
+  /**
+   * The low-level std-format-spec parse function.
+   *
+   * @pre __begin points at the beginning of the std-format-spec. This means
+   * directly after the ':'.
+   * @pre The std-format-spec parses the entire input, or the first unmatched
+   * character is a '}'.
+   *
+   * @returns The iterator pointing at the last parsed character.
+   */
+  auto _LIBCPP_HIDE_FROM_ABI constexpr parse(auto& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    auto __begin = __parse_ctx.begin();
+    auto __end = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parser_fill_align<_CharT>::__parse(__begin, __end,
+                                                   static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parse_sign(__begin, static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parse_alternate_form(__begin, static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parse_zero_padding(__begin, static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parser_width::__parse(__begin, __end, __parse_ctx);
+    if (__begin == __end)
+      return __begin;
+
+    __begin =
+        __parse_locale_specific_form(__begin, static_cast<_Flags&>(*this));
+    if (__begin == __end)
+      return __begin;
+
+    __begin = __parse_type(__begin, static_cast<_Flags&>(*this));
+
+    if (__begin != __end && *__begin != _CharT('}'))
+      __throw_format_error(
+          "The format-spec should consume the input or end with a '}'");
+
+    return __begin;
+  }
+
+protected:
+  /**
+   * Handles the post-parsing updates for the integer types.
+   *
+   * Updates the zero-padding and alignment for integer types.
+   *
+   * [format.string.std]/13
+   *   If the 0 character and an align option both appear, the 0 character is
+   *   ignored.
+   *
+   * For the formatter a @ref __default alignment means zero-padding. Update
+   * the alignment based on parsed format string.
+   */
+  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_integer() noexcept {
+    this->__zero_padding &= this->__alignment == _Flags::_Alignment::__default;
+    if (!this->__zero_padding &&
+        this->__alignment == _Flags::_Alignment::__default)
+      this->__alignment = _Flags::_Alignment::__right;
+  }
+
+  /**
+   * Handles the post-parsing updates for the character types.
+   *
+   * Sets the alignment and validates the format flags set for a character type.
+   *
+   * At the moment the validation for a character and a Boolean behave the
+   * same, but this may change in the future.
+   */
+  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_char() { __handle_bool(); }
+
+  /**
+   * Handles the post-parsing updates for the Boolean types.
+   *
+   * Sets the alignment and validates the format flags set for a Boolean type.
+   */
+  _LIBCPP_HIDE_FROM_ABI constexpr void __handle_bool() {
+    if (this->__sign != _Flags::_Sign::__default)
+      __throw_format_error("A sign field isn't allowed in this format-spec");
+
+    if (this->__alternate_form)
+      __throw_format_error(
+          "An alternate form field isn't allowed in this format-spec");
+
+    if (this->__zero_padding)
+      __throw_format_error(
+          "A zero-padding field isn't allowed in this format-spec");
+
+    if (this->__alignment == _Flags::_Alignment::__default)
+      this->__alignment = _Flags::_Alignment::__left;
+  }
+};
+
+// TODO FMT Add a parser for floating-point values.
+// TODO FMT Add a parser for pointer values.
+
+} // namespace __format_spec
+
+#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+#endif //_LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H

libcxx/include/format

 #include <__config>
 #include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/format_string.h>
+#include <__format/parser_std_format_spec.h>
 #include <__format/formatter.h>
 #include <__variant/monostate.h>
 #include <array>
 #include <concepts>
 #include <string>
 #include <string_view>
 #include <type_traits>
 

libcxx/include/module.modulemap

module filesystem {
     header "filesystem"
     export *
   }
   module format {
     header "format"
     export *
 
     module __format {
-      module format_arg           { private header "__format/format_arg.h"           }
-      module format_args          { private header "__format/format_args.h"          }
+      module format_arg             { private header "__format/format_arg.h"           }
+      module format_args            { private header "__format/format_args.h"          }
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
       }
-      module format_error         { private header "__format/format_error.h"         }
-      module format_fwd           { private header "__format/format_fwd.h"           }
-      module format_parse_context { private header "__format/format_parse_context.h" }
-      module format_string        { private header "__format/format_string.h"        }
-      module formatter            { private header "__format/formatter.h"            }
+      module format_error           { private header "__format/format_error.h"           }
+      module format_fwd             { private header "__format/format_fwd.h"             }
+      module format_parse_context   { private header "__format/format_parse_context.h"   }
+      module format_string          { private header "__format/format_string.h"          }
+      module formatter              { private header "__format/formatter.h"              }
+      module parser_std_format_spec { private header "__format/parser_std_format_spec.h" }
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {

libcxx/test/libcxx/diagnostics/detail.headers/format/parser_std_format_spec.module.verify.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__format/parser_std_format_spec.h'}}
+#include <__format/parser_std_format_spec.h>

libcxx/test/libcxx/utilities/format/format.string/format.string.std/concepts_precision.h

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
+#define LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H
+
+template <class T>
+concept has_precision = requires(T parser) {
+  parser.__precision;
+};
+
+template <class T>
+concept has_precision_as_arg = requires(T parser) {
+  parser.__precision_as_arg;
+};
+
+#endif // LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_CONCEPTS_PRECISION_H

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_integral.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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// Tests the parsing of the format string as specified in [format.string.std].
+// It validates whether the std-format-spec is valid for a string type.
+
+// TODO FMT This test should removed once the integer parser is implemented.
+// The integral specific fields are all tested for the integer, making this
+// test redundant.
+
+#include <format>
+#include <cassert>
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <iostream>
+#endif
+
+#include "concepts_precision.h"
+#include "test_macros.h"
+#include "make_string.h"
+
+#define CSTR(S) MAKE_CSTRING(CharT, S)
+
+using namespace std::__format_spec;
+
+template <class CharT>
+using parser = __parser_integral<CharT>;
+
+#include "test_exception.h" // requires parser
+
+template <class CharT>
+struct Expected {
+  CharT fill = CharT(' ');
+  _Flags::_Alignment alignment = _Flags::_Alignment::__default;
+  _Flags::_Sign sign = _Flags::_Sign::__default;
+  bool alternate_form = false;
+  bool zero_padding = false;
+  uint32_t width = 0;
+  bool width_as_arg = false;
+  bool locale_specific_form = false;
+  _Flags::_Type type = _Flags::_Type::__default;
+};
+
+template <class CharT>
+constexpr void test(Expected<CharT> expected, size_t size,
+                    std::basic_string_view<CharT> fmt) {
+  // Initialize parser with sufficient arguments to avoid the parsing to fail
+  // due to insufficient arguments.
+  std::basic_format_parse_context<CharT> parse_ctx(fmt,
+                                                   std::__format::__number_max);
+  auto begin = parse_ctx.begin();
+  auto end = parse_ctx.end();
+  parser<CharT> parser;
+  auto it = parser.parse(parse_ctx);
+
+  assert(begin == parse_ctx.begin());
+  assert(end == parse_ctx.end());
+
+  assert(begin + size == it);
+  assert(parser.__fill == expected.fill);
+  assert(parser.__alignment == expected.alignment);
+  assert(parser.__sign == expected.sign);
+  assert(parser.__alternate_form == expected.alternate_form);
+  assert(parser.__zero_padding == expected.zero_padding);
+  assert(parser.__width == expected.width);
+  assert(parser.__width_as_arg == expected.width_as_arg);
+  assert(parser.__locale_specific_form == expected.locale_specific_form);
+  assert(parser.__type == expected.type);
+}
+
+template <class CharT>
+constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, size, fmt);
+  fmt.remove_suffix(1);
+  test(expected, size, fmt);
+}
+
+template <class CharT>
+constexpr void test() {
+  parser<CharT> parser;
+
+  assert(parser.__fill == CharT(' '));
+  assert(parser.__alignment == _Flags::_Alignment::__default);
+  assert(parser.__sign == _Flags::_Sign::__default);
+  assert(parser.__alternate_form == false);
+  assert(parser.__zero_padding == false);
+  assert(parser.__width == 0);
+  assert(parser.__width_as_arg == false);
+  static_assert(!has_precision<decltype(parser)>);
+  static_assert(!has_precision_as_arg<decltype(parser)>);
+  assert(parser.__locale_specific_form == false);
+  assert(parser.__type == _Flags::_Type::__default);
+
+  test({}, 0, CSTR("}"));
+
+  // *** Align-fill ***
+  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
+  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
+  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
+
+  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
+       CSTR("L<}"));
+  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
+       CSTR("#^}"));
+  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
+       CSTR("0>}"));
+
+  test_exception("The format-spec fill field contains an invalid character",
+                 CSTR("{<"));
+  test_exception("The format-spec fill field contains an invalid character",
+                 CSTR("}<"));
+
+  // *** Sign ***
+  test({.sign = _Flags::_Sign::__minus}, 1, CSTR("-}"));
+  test({.sign = _Flags::_Sign::__plus}, 1, CSTR("+}"));
+  test({.sign = _Flags::_Sign::__space}, 1, CSTR(" }"));
+
+  // *** Alternate form ***
+  test({.alternate_form = true}, 1, CSTR("#}"));
+
+  // *** Zero padding ***
+  // TODO FMT What to do with zero-padding without a width?
+  // [format.string.std]/13
+  //   A zero (0) character preceding the width field pads the field with
+  //   leading zeros (following any indication of sign or base) to the field
+  //   width, except when applied to an infinity or NaN.
+  // Obviously it makes no sense, but should it be allowed or is it a format
+  // errror?
+  test({.zero_padding = true}, 1, CSTR("0}"));
+  test({.alignment = _Flags::_Alignment::__center, .zero_padding = true}, 2,
+       CSTR("^0}"));
+
+  // *** Width ***
+  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
+  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
+  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
+  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
+  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
+
+  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
+  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
+  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
+
+  test_exception("A format-spec width field shouldn't have a leading zero",
+                 CSTR("00"));
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
+       CSTR("2147483647}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("2147483648"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("5000000000"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("10000000000"));
+
+  test_exception("End of input while parsing format-spec arg-id", CSTR("{"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{0"));
+  test_exception(
+      "The arg-id of the format-spec starts with an invalid character",
+      CSTR("{a"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{1"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9:"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9a"));
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  // Note the static_assert tests whether the arg-id is valid.
+  // Therefore the following should be true arg-id < __format::__number_max.
+  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
+       CSTR("{2147483646}}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{2147483648}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{5000000000}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{10000000000}"));
+
+  // *** Precision ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("."));
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR(".1"));
+
+  // *** Locale-specific form ***
+  test({.locale_specific_form = true}, 1, CSTR("L}"));
+  test({.locale_specific_form = true, .type = _Flags::_Type::__decimal}, 2,
+       CSTR("Ld}"));
+  test({.locale_specific_form = true, .type = _Flags::_Type::__char}, 2,
+       CSTR("Lc}"));
+
+  // *** Type ***
+
+  {
+    const char* not_a_type =
+        "The format-spec should consume the input or end with a '}'";
+
+    test({.type = _Flags::_Type::__float_hexadecimal_upper_case}, 1,
+         CSTR("A}"));
+    test({.type = _Flags::_Type::__binary_upper_case}, 1, CSTR("B}"));
+    test_exception(not_a_type, CSTR("C}"));
+    test_exception(not_a_type, CSTR("D}"));
+    test({.type = _Flags::_Type::__scientific_upper_case}, 1, CSTR("E}"));
+    test({.type = _Flags::_Type::__fixed_upper_case}, 1, CSTR("F}"));
+    test({.type = _Flags::_Type::__general_upper_case}, 1, CSTR("G}"));
+    test_exception(not_a_type, CSTR("H}"));
+    test_exception(not_a_type, CSTR("I}"));
+    test_exception(not_a_type, CSTR("J}"));
+    test_exception(not_a_type, CSTR("K}"));
+    test({.locale_specific_form = true}, 1, CSTR("L}"));
+    test_exception(not_a_type, CSTR("M}"));
+    test_exception(not_a_type, CSTR("N}"));
+    test_exception(not_a_type, CSTR("O}"));
+    test_exception(not_a_type, CSTR("P}"));
+    test_exception(not_a_type, CSTR("Q}"));
+    test_exception(not_a_type, CSTR("R}"));
+    test_exception(not_a_type, CSTR("S}"));
+    test_exception(not_a_type, CSTR("T}"));
+    test_exception(not_a_type, CSTR("U}"));
+    test_exception(not_a_type, CSTR("V}"));
+    test_exception(not_a_type, CSTR("W}"));
+    test({.type = _Flags::_Type::__hexadecimal_upper_case}, 1, CSTR("X}"));
+    test_exception(not_a_type, CSTR("Y}"));
+    test_exception(not_a_type, CSTR("Z}"));
+
+    test({.type = _Flags::_Type::__float_hexadecimal_lower_case}, 1,
+         CSTR("a}"));
+    test({.type = _Flags::_Type::__binary_lower_case}, 1, CSTR("b}"));
+    test({.type = _Flags::_Type::__char}, 1, CSTR("c}"));
+    test({.type = _Flags::_Type::__decimal}, 1, CSTR("d}"));
+    test({.type = _Flags::_Type::__scientific_lower_case}, 1, CSTR("e}"));
+    test({.type = _Flags::_Type::__fixed_lower_case}, 1, CSTR("f}"));
+    test({.type = _Flags::_Type::__general_lower_case}, 1, CSTR("g}"));
+    test_exception(not_a_type, CSTR("h}"));
+    test_exception(not_a_type, CSTR("i}"));
+    test_exception(not_a_type, CSTR("j}"));
+    test_exception(not_a_type, CSTR("k}"));
+    test_exception(not_a_type, CSTR("l}"));
+    test_exception(not_a_type, CSTR("m}"));
+    test_exception(not_a_type, CSTR("n}"));
+    test({.type = _Flags::_Type::__octal}, 1, CSTR("o}"));
+    test({.type = _Flags::_Type::__pointer}, 1, CSTR("p}"));
+    test_exception(not_a_type, CSTR("q}"));
+    test_exception(not_a_type, CSTR("r}"));
+    test({.type = _Flags::_Type::__string}, 1, CSTR("s}"));
+    test_exception(not_a_type, CSTR("t}"));
+    test_exception(not_a_type, CSTR("u}"));
+    test_exception(not_a_type, CSTR("v}"));
+    test_exception(not_a_type, CSTR("w}"));
+    test({.type = _Flags::_Type::__hexadecimal_lower_case}, 1, CSTR("x}"));
+    test_exception(not_a_type, CSTR("y}"));
+    test_exception(not_a_type, CSTR("z}"));
+  }
+  // **** General ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("ss"));
+}
+
+constexpr bool test() {
+  test<char>();
+  test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+  test<char8_t>();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<char16_t>();
+  test<char32_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+#ifndef _WIN32
+  // Make sure the parsers match the expectations. The layout of the
+  // subobjects is chosen to minimize the size required.
+  static_assert(sizeof(parser<char>) == 2 * sizeof(uint32_t));
+  static_assert(
+      sizeof(parser<wchar_t>) ==
+      (sizeof(wchar_t) <= 2 ? 2 * sizeof(uint32_t) : 3 * sizeof(uint32_t)));
+#endif
+
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string.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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// <format>
+
+// Tests the parsing of the format string as specified in [format.string.std].
+// It validates whether the std-format-spec is valid for a string type.
+
+#include <format>
+#include <cassert>
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#include <iostream>
+#endif
+
+#include "test_macros.h"
+#include "make_string.h"
+
+#define CSTR(S) MAKE_CSTRING(CharT, S)
+
+using namespace std::__format_spec;
+
+template <class CharT>
+using parser = __parser_string<CharT>;
+
+#include "test_exception.h" // requires parser
+
+template <class CharT>
+struct Expected {
+  CharT fill = CharT(' ');
+  _Flags::_Alignment alignment = _Flags::_Alignment::__left;
+  uint32_t width = 0;
+  bool width_as_arg = false;
+  uint32_t precision = std::__format::__number_max;
+  bool precision_as_arg = true;
+  _Flags::_Type type = _Flags::_Type::__default;
+};
+
+template <class CharT>
+constexpr void test(Expected<CharT> expected, size_t size,
+                    std::basic_string_view<CharT> fmt) {
+  // Initialize parser with sufficient arguments to avoid the parsing to fail
+  // due to insufficient arguments.
+  std::basic_format_parse_context<CharT> parse_ctx(fmt,
+                                                   std::__format::__number_max);
+  auto begin = parse_ctx.begin();
+  auto end = parse_ctx.end();
+  parser<CharT> parser;
+  auto it = parser.parse(parse_ctx);
+
+  assert(begin == parse_ctx.begin());
+  assert(end == parse_ctx.end());
+
+  assert(begin + size == it);
+  assert(parser.__fill == expected.fill);
+  assert(parser.__alignment == expected.alignment);
+  assert(parser.__sign == _Flags::_Sign::__default);
+  assert(parser.__alternate_form == false);
+  assert(parser.__zero_padding == false);
+  assert(parser.__width == expected.width);
+  assert(parser.__width_as_arg == expected.width_as_arg);
+  assert(parser.__precision == expected.precision);
+  assert(parser.__precision_as_arg == expected.precision_as_arg);
+  assert(parser.__locale_specific_form == false);
+  assert(parser.__type == expected.type);
+}
+
+template <class CharT>
+constexpr void test(Expected<CharT> expected, size_t size, const CharT* f) {
+  // The format-spec is valid if completely consumed or terminates at a '}'.
+  // The valid inputs all end with a '}'. The test is executed twice:
+  // - first with the terminating '}',
+  // - second consuming the entire input.
+  std::basic_string_view<CharT> fmt{f};
+  assert(fmt.back() == CharT('}') && "Pre-condition failure");
+
+  test(expected, size, fmt);
+  fmt.remove_suffix(1);
+  test(expected, size, fmt);
+}
+
+template <class CharT>
+constexpr void test() {
+  parser<CharT> parser;
+
+  assert(parser.__fill == CharT(' '));
+  assert(parser.__alignment == _Flags::_Alignment::__left);
+  assert(parser.__sign == _Flags::_Sign::__default);
+  assert(parser.__alternate_form == false);
+  assert(parser.__zero_padding == false);
+  assert(parser.__width == 0);
+  assert(parser.__width_as_arg == false);
+  assert(parser.__precision == std::__format::__number_max);
+  assert(parser.__precision_as_arg == true);
+  assert(parser.__locale_specific_form == false);
+  assert(parser.__type == _Flags::_Type::__default);
+
+  test({}, 0, CSTR("}"));
+
+  // *** Align-fill ***
+  test({.alignment = _Flags::_Alignment::__left}, 1, CSTR("<}"));
+  test({.alignment = _Flags::_Alignment::__center}, 1, "^}");
+  test({.alignment = _Flags::_Alignment::__right}, 1, ">}");
+
+  test({.fill = CharT('L'), .alignment = _Flags::_Alignment::__left}, 2,
+       CSTR("L<}"));
+  test({.fill = CharT('#'), .alignment = _Flags::_Alignment::__center}, 2,
+       CSTR("#^}"));
+  test({.fill = CharT('0'), .alignment = _Flags::_Alignment::__right}, 2,
+       CSTR("0>}"));
+
+  test_exception("The format-spec fill field contains an invalid character",
+                 CSTR("{<"));
+  test_exception("The format-spec fill field contains an invalid character",
+                 CSTR("}<"));
+
+  // *** Sign ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("+"));
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("-"));
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR(" "));
+
+  // *** Alternate form ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("#"));
+
+  // *** Zero padding ***
+  test_exception("A format-spec width field shouldn't have a leading zero",
+                 CSTR("0"));
+
+  // *** Width ***
+  test({.width = 0, .width_as_arg = false}, 0, CSTR("}"));
+  test({.width = 1, .width_as_arg = false}, 1, CSTR("1}"));
+  test({.width = 10, .width_as_arg = false}, 2, CSTR("10}"));
+  test({.width = 1000, .width_as_arg = false}, 4, CSTR("1000}"));
+  test({.width = 1000000, .width_as_arg = false}, 7, CSTR("1000000}"));
+
+  test({.width = 0, .width_as_arg = true}, 2, CSTR("{}}"));
+  test({.width = 0, .width_as_arg = true}, 3, CSTR("{0}}"));
+  test({.width = 1, .width_as_arg = true}, 3, CSTR("{1}}"));
+
+  test_exception("A format-spec width field shouldn't have a leading zero",
+                 CSTR("00"));
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  test({.width = 2'147'483'647, .width_as_arg = false}, 10,
+       CSTR("2147483647}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("2147483648"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("5000000000"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("10000000000"));
+
+  test_exception("End of input while parsing format-spec arg-id", CSTR("{"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{0"));
+  test_exception(
+      "The arg-id of the format-spec starts with an invalid character",
+      CSTR("{a"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{1"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9:"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR("{9a"));
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  // Note the static_assert tests whether the arg-id is valid.
+  // Therefore the following should be true arg-id < __format::__number_max.
+  test({.width = 2'147'483'646, .width_as_arg = true}, 12,
+       CSTR("{2147483646}}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{2147483648}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{5000000000}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR("{10000000000}"));
+
+  // *** Precision ***
+  test({.precision = 0, .precision_as_arg = false}, 2, CSTR(".0}"));
+  test({.precision = 1, .precision_as_arg = false}, 2, CSTR(".1}"));
+  test({.precision = 10, .precision_as_arg = false}, 3, CSTR(".10}"));
+  test({.precision = 1000, .precision_as_arg = false}, 5, CSTR(".1000}"));
+  test({.precision = 1000000, .precision_as_arg = false}, 8, CSTR(".1000000}"));
+
+  test({.precision = 0, .precision_as_arg = true}, 3, CSTR(".{}}"));
+  test({.precision = 0, .precision_as_arg = true}, 4, CSTR(".{0}}"));
+  test({.precision = 1, .precision_as_arg = true}, 4, CSTR(".{1}}"));
+
+  test_exception("A format-spec precision field shouldn't have a leading zero",
+                 CSTR(".00"));
+  test_exception("A format-spec precision field shouldn't have a leading zero",
+                 CSTR(".01"));
+  test_exception(
+      "The format-spec precision field doesn't contain a value or arg-id",
+      CSTR(".a"));
+  test_exception(
+      "The format-spec precision field doesn't contain a value or arg-id",
+      ".:");
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  test({.precision = 2'147'483'647, .precision_as_arg = false}, 11,
+       CSTR(".2147483647}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".2147483648"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".5000000000"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".10000000000"));
+
+  test_exception("End of input while parsing format-spec arg-id", CSTR(".{"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR(".{0"));
+  test_exception(
+      "The arg-id of the format-spec starts with an invalid character",
+      CSTR(".{a"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR(".{1"));
+  test_exception("A format-spec arg-id should terminate at a '}'", CSTR(".{9"));
+  test_exception("A format-spec arg-id should terminate at a '}'",
+                 CSTR(".{9:"));
+  test_exception("A format-spec arg-id should terminate at a '}'",
+                 CSTR(".{9a"));
+
+  static_assert(std::__format::__number_max == 2'147'483'647,
+                "Update the assert and the test.");
+  // Note the static_assert tests whether the arg-id is valid.
+  // Therefore the following should be true arg-id < __format::__number_max.
+  test({.precision = 2'147'483'646, .precision_as_arg = true}, 13,
+       CSTR(".{2147483646}}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".{2147483648}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".{5000000000}"));
+  test_exception("The numeric value of the format-spec is too large",
+                 CSTR(".{10000000000}"));
+
+  // *** Width & Precision ***
+  test({.width = 1,
+        .width_as_arg = false,
+        .precision = 0,
+        .precision_as_arg = false},
+       3, CSTR("1.0}"));
+  test({.width = 0,
+        .width_as_arg = true,
+        .precision = 1,
+        .precision_as_arg = true},
+       5, CSTR("{}.{}}"));
+  test({.width = 10,
+        .width_as_arg = true,
+        .precision = 9,
+        .precision_as_arg = true},
+       8, CSTR("{10}.{9}}"));
+
+  // *** Locale-specific form ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("L"));
+
+  // *** Type ***
+
+  {
+    const char* unsuported_type =
+        "The format-spec type has a type not supported for a string argument";
+    const char* not_a_type =
+        "The format-spec should consume the input or end with a '}'";
+
+    test_exception(unsuported_type, CSTR("A}"));
+    test_exception(unsuported_type, CSTR("B}"));
+    test_exception(not_a_type, CSTR("C}"));
+    test_exception(not_a_type, CSTR("D}"));
+    test_exception(unsuported_type, CSTR("E}"));
+    test_exception(unsuported_type, CSTR("F}"));
+    test_exception(unsuported_type, CSTR("G}"));
+    test_exception(not_a_type, CSTR("H}"));
+    test_exception(not_a_type, CSTR("I}"));
+    test_exception(not_a_type, CSTR("J}"));
+    test_exception(not_a_type, CSTR("K}"));
+    test_exception(not_a_type, CSTR("L}"));
+    test_exception(not_a_type, CSTR("M}"));
+    test_exception(not_a_type, CSTR("N}"));
+    test_exception(not_a_type, CSTR("O}"));
+    test_exception(not_a_type, CSTR("P}"));
+    test_exception(not_a_type, CSTR("Q}"));
+    test_exception(not_a_type, CSTR("R}"));
+    test_exception(not_a_type, CSTR("S}"));
+    test_exception(not_a_type, CSTR("T}"));
+    test_exception(not_a_type, CSTR("U}"));
+    test_exception(not_a_type, CSTR("V}"));
+    test_exception(not_a_type, CSTR("W}"));
+    test_exception(unsuported_type, CSTR("X}"));
+    test_exception(not_a_type, CSTR("Y}"));
+    test_exception(not_a_type, CSTR("Z}"));
+
+    test_exception(unsuported_type, CSTR("a}"));
+    test_exception(unsuported_type, CSTR("b}"));
+    test_exception(unsuported_type, CSTR("c}"));
+    test_exception(unsuported_type, CSTR("d}"));
+    test_exception(unsuported_type, CSTR("e}"));
+    test_exception(unsuported_type, CSTR("f}"));
+    test_exception(unsuported_type, CSTR("g}"));
+    test_exception(not_a_type, CSTR("h}"));
+    test_exception(not_a_type, CSTR("i}"));
+    test_exception(not_a_type, CSTR("j}"));
+    test_exception(not_a_type, CSTR("k}"));
+    test_exception(not_a_type, CSTR("l}"));
+    test_exception(not_a_type, CSTR("m}"));
+    test_exception(not_a_type, CSTR("n}"));
+    test_exception(unsuported_type, CSTR("o}"));
+    test_exception(unsuported_type, CSTR("p}"));
+    test_exception(not_a_type, CSTR("q}"));
+    test_exception(not_a_type, CSTR("r}"));
+    test({.type = _Flags::_Type::__string}, 1, CSTR("s}"));
+    test_exception(not_a_type, CSTR("t}"));
+    test_exception(not_a_type, CSTR("u}"));
+    test_exception(not_a_type, CSTR("v}"));
+    test_exception(not_a_type, CSTR("w}"));
+    test_exception(unsuported_type, CSTR("x}"));
+    test_exception(not_a_type, CSTR("y}"));
+    test_exception(not_a_type, CSTR("z}"));
+  }
+  // **** General ***
+  test_exception("The format-spec should consume the input or end with a '}'",
+                 CSTR("ss"));
+}
+
+constexpr bool test() {
+  test<char>();
+  test<wchar_t>();
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+  test<char8_t>();
+#endif
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+  test<char16_t>();
+  test<char32_t>();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+#ifndef _WIN32
+  // Make sure the parsers match the expectations. The layout of the
+  // subobjects is chosen to minimize the size required.
+  LIBCPP_STATIC_ASSERT(sizeof(parser<char>) == 3 * sizeof(uint32_t));
+  LIBCPP_STATIC_ASSERT(
+      sizeof(parser<wchar_t>) ==
+      (sizeof(wchar_t) <= 2 ? 3 * sizeof(uint32_t) : 4 * sizeof(uint32_t)));
+#endif
+
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/libcxx/utilities/format/format.string/format.string.std/test_exception.h

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_TEST_EXCEPTION_H
+#define _LIBCPP_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_TEST_EXCEPTION_H
+
+// Helper header for the tests in this directory.
+// Note the header isn't freestanding.
+
+namespace detail {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+template <class CharT>
+void test_exception(std::string_view what, const CharT* fmt) {
+  try {
+    std::basic_format_parse_context<CharT> parse_ctx(fmt);
+    (void)parser<CharT>{}.parse(parse_ctx);
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+    if constexpr (std::same_as<CharT, char>)
+      std::cerr << "\nFormat string   " << fmt
+                << "\nDidn't throw an exception.\n";
+#endif
+    assert(false);
+  } catch (std::format_error& e) {
+#if defined(_LIBCPP_VERSION) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+    if constexpr (std::same_as<CharT, char>)
+      if (e.what() != what)
+        std::cerr << "\nFormat string   " << fmt << "\nExpected exception "
+                  << what << "\nActual exception   " << e.what() << '\n';
+#endif
+    LIBCPP_ASSERT(e.what() == what);
+    return;
+  }
+
+  assert(false);
+}
+#endif
+} // namespace detail
+
+/**
+ *  Wrapper for the exception tests.
+ *
+ *  When using the real function directly during in a constexpr test and add
+ *  the `std::is_constant_evaluated()` test there the compilation fails. This
+ *  happens since assert calls the non-constexpr function '__assert_fail'.
+ *  Solve this issue with an layer of indirection.
+ */
+template <class CharT>
+constexpr void test_exception(std::string_view what, const CharT* fmt) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  if (!std::is_constant_evaluated())
+    detail::test_exception(what, fmt);
+#else
+  (void)what;
+  (void)fmt;
+#endif
+}
+
+#endif // _LIBCPP_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_TEST_EXCEPTION_H