[libc++][chrono] Implements formatter day.

[Mordante]

Summary

This implements the enabled specializaton
template<class charT> struct formatter<chrono::day, charT>;

and
template<class charT, class traits>

basic_ostream<charT, traits>&
  operator<<(basic_ostream<charT, traits>& os, const day& d);

Implements:

• LWG 3241 chrono-spec grammar ambiguity in §[time.format]

Partially implements:

• P1361 Integration of chrono with text formatting

[Mordante]

Fixes some CI issue.
Note temporary disable quite some CI runs, since I expect several non-Linux systems to still fail.

[Mordante]

Attempt to fix buildkite

[Mordante]

More CI fixes.

[Mordante]

More CI fixes.

[Mordante]

More CI fixes and disables more green CIs

[Mordante]

With the CI green, reenable all CI jobs.

[Mordante]

libcxx/docs/Status/Cxx20Issues.csv

170

@ldionne, @vitaut this is the first chrono formatter. A rough draft with more formatters is available in D126592.

This patch adds the basic framework and one formatter specialization to keep the review manageable. I will chop the large patch in smaller reviewable patches.

Note there's an issue with Windows somehow the values for invalid days are odd and the CI doesn't provide good feedback. I'll test to see whether I can run the Windows test locally otherwise I'll ask assistance of people with access to Windows.

libcxx/include/__chrono/formatter.h

105

Note the number of "special cases" will grow in future patches. For example '%S' needs to show subsecond resolution. '%Y' requires 4 digits, which C doesn't do.

141

Basically the mentioned paper gives direct access to the buffer's data with a view. That avoids the need for the temporary string to create a view.

libcxx/include/__chrono/parser_std_format_spec.h

51

Note most of these __flags aren't used and the functions below also not yet, except for the unit tests. There have been used in the large patch.

[ldionne]

libcxx/include/__chrono/formatter.h

16

I think it's fine to guard the header here, but I would remove the comment, which seems a bit redundant.

The usual tradition in libc++ is to guard the header itself (as done here) so that the header can always be included (although it might be empty). Note that this isn't really done consistently everywhere, for example _LIBCPP_HAS_NO_LOCALIZATION is usually checked before including the header, since the header will #error out if included.

So yeah, bottom line: you can keep as-is, and I guess we don't have a ton of consistency here in the library.

28–32

Instead, I think our validation for #pragma GCC system_header should be less strict.

44

49

54

This seems like a leftover.

61–62

Suggestion:

  .tm_sec = 0
, .tm_min = 0
, .tm_hour = 0
...
#ifdef __GLIBC__
, .tm_gmtoff = 0
, .tm_zone = "UTC"
#endif

IDK if clang-format will handle that gracefully.

87

ADL

libcxx/include/__chrono/statically_widen.h

34

This should be called _LIBCPP_STATICALLY_WIDEN. We don't define macros that are not prefix with _LIBCPP (except _NOEXCEPT and _NOEXCEPT_, and IMO those were mistakes if only for consistency).

Also, we shouldn't be using _CharT in this macro without taking it as an argument. This creates a really weird dependency that the macro can only be used within a template with a suitably named template parameter.

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp

86

Why are we checking 255 if it's not a valid input? (and hence has these various weird results on AIX and other platforms)

[Mordante]

libcxx/include/__chrono/formatter.h

16

I think moving has another advantage. All other preprocessor are no longer in a global one, thus decreasing their indention level.
(This avoid reformatting when the guard is removed.)

28–32

Agreed I'll look at that in a separate commit.

61–62

I haven't found a clang-format option to do this. Only for the constructor. But I agree it would be great when clang-format would have an option to do this.

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp

86

As discussed in our private conversation. 255 is the minimum of the maximum supported value for a day. I'm not happy with how this works in practice and want to look at alternative solutions. (I will most likely file an LWG issue or write a paper.)

For now I leave it as is since I want to look closer are when exactly happens on Windows; however I want to have a better solution before landing this.

[Mordante]

Addresses most review comments.

[philnik]

libcxx/include/__chrono/formatter.h

61–62

What's wrong with just using a trailing comma?

[Mordante]

libcxx/include/__chrono/formatter.h

61–62

In general nothing, but line 62 now has a single comma. It would be really nice of clang-format could detect these cases an used leading commas instead. IMO that would be nice to have, but I've no objection against the single comma.

[philnik]

libcxx/include/__chrono/formatter.h

61–62

I meant "Why not put the comma at the end of line 60?"
Another thought: Why do you explicitly initialize all the struct members? They get value-initialized anyways if you omit them. That would leave you with just

tm __result {
#ifdef __GLIBC__
  .tm_zone = "UTC",
#endif
};

[Mordante]

Attempt to fix CI and determine Windows status.

[Mordante]

Fix modular build.

[Mordante]

Only build Windows to validate the output.

[Mordante]

Some win32 fixes.

[Mordante]

More fixes.

[Mordante]

Needs additional work to get a good result for invalid values.

[Mordante]

Use alternative approach for formatting invalid day values.

[vitaut]

libcxx/include/__chrono/formatter.h

37

module -> modulo

41–42

Submit an LWG issue to clarify this?

52

You could make this more robust and shorter:

tm __result = tm();
#ifdef __GLIBC__
__result.tm_zone = "UTC";
#endif

80

Is this expensive? Maybe extract a facet lazily since it's often unused.

117–131

Not necessarily in the current diff but you might want to refactor this to only use iostreams for localized formatting. Nonlocalized can be implemented much more efficiently.

libcxx/include/__chrono/ostream.h

36–40

Could you give an example of a format call illustrating the problem on AIX and Windows?

libcxx/include/__chrono/parser_std_format_spec.h

86

a -> an

[Mordante]

Thanks for the review! I'll have a look at your other review comments after I have the results of the CI run.

libcxx/include/__chrono/formatter.h

41–42

At the moment I'm collecting the issues I've found. When the number is low I'll file LWG issues, but otherwise I probably write a paper with all issues.

80

I haven't benchmarked it.

Interesting, I expected it to be used often since most of the formatting can be done by __facet.put. That saves me implementing all locale specific behaviour.

One optimization I've seen in {fmt} is that you handle the C locale as a special case and have written your own output routines for that case. I have that on my todo list.

117–131

Agreed. For now I've been mainly looking at getting things to work. But optimizing it most definitely on my todo list.

libcxx/include/__chrono/ostream.h

36–40

These are examples of the previous iteration of this patch.
Windows check.template operator()<"{:*^23}">(SV("*** is not a valid day*"), 0d); (the same for other invalid days.)
AIX check.template operator()<fmt>(SV("%d='55'\t%Od='55'\t%e='55'\t%Oe='55'\n"), 255d);

[Mordante]

Attempts to fix the CI.

[Mordante]

libcxx/include/__chrono/formatter.h

61–62

@vitaut suggested something similar. I like this approach better, modulo the trailing comma.

[Mordante]

Addresses review comments and attempts to fix the CI.

[Mordante]

Attempt to fix CI.

[ldionne]

libcxx/include/__chrono/formatter.h

52

I think it might be important to use = tm() to get proper zero initialization, otherwise some members might be left uninitialized.

[ldionne]

libcxx/docs/Status/Cxx20Issues.csv

178

libcxx/include/__chrono/formatter.h

51

I don't think this should be in formatter.h or in the __formatter namespace. This seems generally useful, don't you think? I might suggest something like __chrono/convert_to_tm.h to mirror convert_to_timespec.h.

libcxx/include/__chrono/statically_widen.h

14

36

Equivalent since _LIBCPP_STATICALLY_WIDEN should only be used in our namespace, but still more idiomatic since this is a macro.

46

Ditto.

libcxx/include/module.modulemap.in

497

This shouldn't be here.

511

Not needed.

515

Not needed.

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp

144

I would prefer instead:

// The chrono formatters require localization support because {XXXXXXXX}
#ifndef TEST_HAS_NO_LOCALIZATION
  assert_is_formattable<std::chrono::day, CharT>();
#endif

We don't need to test that it's not formattable when localization is disabled.

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp

35–37

Leftover?

90–91

Leftover?

libcxx/test/std/time/time.syn/formatter_tests.h

8

Missing header guard.

61–67

89–93

I would suggest putting that above so it doesn't clutter the body of the function so much. You could use something like using Context = ..... The same comment applies above too.

104–105

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

119

Same comment as above for TEST_HAS_NO_LOCALIZATION.

[Mordante]

• Rebased
• Addresses most review comments
• Qualify several calls
• Comment out some transitive includes that caused include cycles

[Mordante]

Adds work-around to test CI.

[Mordante]

Attempts to fix Windows build.
Adds convert_to_tm private header.

[Mordante]

Fixes CI.

[Mordante]

Attempts to fix CI.

[Mordante]

Tests failing CI.

[Mordante]

Attempt to fix the CI.

[Mordante]

Remove more parts of the experimental library.

[Mordante]

Another attempt to fix the CI.

[Mordante]

CI test

[Mordante]

CI test

[ldionne]

Notes from live review:

1. Let's move transitive includes to the end of each file to break cycles
2. Let's guard transitive includes on standard versions

Also, please update this to its final form and we can take a look at the Windows DLL errors.

[Mordante]

CI

[Mordante]

CI

[Mordante]

Restore CI and try to fix circular dependencies.

[Mordante]

Disable a test and test CI

[Mordante]

libcxx/include/chrono

700

As tested in D132284.

704

The header can be unconditional again.

[Mordante]

Rebased and integrated all upstream changes.

[Mordante]

Attempts to fix CI.

[Mordante]

Rebased and some final polishing.

[ldionne]

libcxx/include/chrono

699

Is this comment still required? I think it is no longer needed since we inlined the destructor of format_error to workaround Windows DLL issues.

[Mordante]

libcxx/include/chrono

699

No it's not, removed it.

libcxx/docs/Status/Cxx20Issues.csv

 "`3209 <https://wg21.link/LWG3209>`__","Expression in ``year::ok()``\  returns clause is ill-formed","Cologne","|Complete|",""
 "","","","",""
 "`3231 <https://wg21.link/LWG3231>`__","``year_month_day_last::day``\  specification does not cover ``!ok()``\  values","Belfast","|Nothing To Do|",""
 "`3225 <https://wg21.link/LWG3225>`__","``zoned_time``\  converting constructor shall not be ``noexcept``\ ","Belfast","","","|chrono|"
 "`3190 <https://wg21.link/LWG3190>`__","``std::allocator::allocate``\  sometimes returns too little storage","Belfast","|Complete|","14.0"
 "`3218 <https://wg21.link/LWG3218>`__","Modifier for ``%d``\  parse flag does not match POSIX and ``format``\  specification","Belfast","","","|chrono| |format|"
 "`3224 <https://wg21.link/LWG3224>`__","``zoned_time``\  constructor from ``TimeZonePtr``\  does not specify initialization of ``tp_``\ ","Belfast","","","|chrono|"
 "`3230 <https://wg21.link/LWG3230>`__","Format specifier ``%y/%Y``\  is missing locale alternative versions","Belfast","","","|chrono| |format|"
 "`3232 <https://wg21.link/LWG3232>`__","Inconsistency in ``zoned_time``\  deduction guides","Belfast","","","|chrono|"
 "`3222 <https://wg21.link/LWG3222>`__","P0574R1 introduced preconditions on non-existent parameters","Belfast","",""
 "`3221 <https://wg21.link/LWG3221>`__","Result of ``year_month``\  arithmetic with ``months``\  is ambiguous","Belfast","|Complete|","8.0"
 "`3235 <https://wg21.link/LWG3235>`__","``parse``\  manipulator without abbreviation is not callable","Belfast","",""
 "`3246 <https://wg21.link/LWG3246>`__","What are the constraints on the template parameter of ``basic_format_arg``\ ?","Belfast","","","|format|"
 "`3253 <https://wg21.link/LWG3253>`__","``basic_syncbuf::basic_syncbuf()``\  should not be explicit","Belfast","",""
 "`3245 <https://wg21.link/LWG3245>`__","Unnecessary restriction on ``'%p'``\  parse specifier","Belfast","","","|chrono|"
 "`3244 <https://wg21.link/LWG3244>`__","Constraints for ``Source``\  in |sect|\ [fs.path.req] insufficiently constrainty","Belfast","",""
-"`3241 <https://wg21.link/LWG3241>`__","``chrono-spec``\  grammar ambiguity in |sect|\ [time.format]","Belfast","","","|chrono| |format|"
+"`3241 <https://wg21.link/LWG3241>`__","``chrono-spec``\  grammar ambiguity in |sect|\ [time.format]","Belfast","|Complete|","16.0","|chrono| |format|"
 "`3257 <https://wg21.link/LWG3257>`__","Missing feature testing macro update from P0858","Belfast","",""
 "`3256 <https://wg21.link/LWG3256>`__","Feature testing macro for ``constexpr``\  algorithms","Belfast","|Complete|","13.0"
 "`3273 <https://wg21.link/LWG3273>`__","Specify ``weekday_indexed``\  to range of ``[0, 7]``\ ","Belfast","","","|chrono|"
 "`3070 <https://wg21.link/LWG3070>`__","``path::lexically_relative``\  causes surprising results if a filename can also be a  *root-name*","Belfast","",""
 "`3266 <https://wg21.link/LWG3266>`__","``to_chars(bool)``\  should be deleted","Belfast","|Complete|","14.0"
 "`3272 <https://wg21.link/LWG3272>`__","``%I%p``\  should parse/format ``duration``\  since midnight","Belfast","","","|chrono| |format|"
 "`3259 <https://wg21.link/LWG3259>`__","The definition of *constexpr iterators* should be adjusted","Belfast","|Nothing To Do|","","|ranges|"
 "`3103 <https://wg21.link/LWG3103>`__","Errors in taking subview of ``span``\  should be ill-formed where possible","Belfast","",""

libcxx/docs/Status/Cxx20Papers.csv

 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
-"`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","",""
+"`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","|In Progress|",""
 "`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|Complete|","15.0"
 "`P1424R1 <https://wg21.link/P1424R1>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""
 "`P1466R3 <https://wg21.link/P1466R3>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""
 "`P1474R1 <https://wg21.link/P1474R1>`__","LWG","Helpful pointers for ContiguousIterator","Cologne","|Complete|","15.0"
 "`P1502R1 <https://wg21.link/P1502R1>`__","LWG","Standard library header units for C++20","Cologne","",""
 "`P1522R1 <https://wg21.link/P1522R1>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","|Complete|","15.0"
 "`P1523R1 <https://wg21.link/P1523R1>`__","LWG","Views and Size Types","Cologne","|Complete|","15.0"
 "`P1612R1 <https://wg21.link/P1612R1>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"

libcxx/include/CMakeLists.txt

set(files
   __charconv/tables.h
   __charconv/to_chars_base_10.h
   __charconv/to_chars_result.h
   __chrono/calendar.h
   __chrono/convert_to_timespec.h
   __chrono/day.h
   __chrono/duration.h
   __chrono/file_clock.h
+  __chrono/formatter.h
   __chrono/hh_mm_ss.h
   __chrono/high_resolution_clock.h
   __chrono/literals.h
   __chrono/month.h
   __chrono/month_weekday.h
   __chrono/monthday.h
+  __chrono/ostream.h
+  __chrono/parser_std_format_spec.h
+  __chrono/statically_widen.h
   __chrono/steady_clock.h
   __chrono/system_clock.h
   __chrono/time_point.h
   __chrono/weekday.h
   __chrono/year.h
   __chrono/year_month.h
   __chrono/year_month_day.h
   __chrono/year_month_weekday.h

libcxx/include/__chrono/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___CHRONO_FORMATTER_H
+#define _LIBCPP___CHRONO_FORMATTER_H
+
+#include <__chrono/day.h>
+#include <__chrono/parser_std_format_spec.h>
+#include <__config>
+#include <ctime>
+#include <format>
+#include <iterator>
+#include <sstream>
+#include <string>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+namespace __formatter {
+
+/// Formats a time based on a tm struct.
+///
+/// This formatter passes the formatting to time_put which uses strftime. When
+/// the value is outside the valid range it's unspecified what strftime will
+/// output. For example weekday 8 can print 1 when the day is processed modulo
+/// 7 since that handles the Sunday for 0-based weekday. It can also print 8 if
+/// 7 is handled as a special case.)
+///
+/// The Standard doesn't specify what to do in this case so the result depends
+/// on the result of the underlying code.
+///
+/// \pre When the (abbreviated) weekday on month name are used the caller
+///      validates the value is valid. So the caller handles that requirement
+///      of Table 97: Meaning of conversion specifiers [tab:time.format.spec].
+///
+/// When no chrono-specs are provided it uses the stream formatter.
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI tm __make_tm(const _Tp& __value) {
+  tm __result = {};
+#  ifdef __GLIBC__
+  __result.tm_zone = "UTC";
+#  endif
+
+  if constexpr (same_as<_Tp, chrono::day>)
+    __result.tm_mday = static_cast<unsigned>(__value);
+  else
+    static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
+
+  return __result;
+}
+
+template <class _CharT, class _Tp>
+_LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
+    const _Tp& __value, basic_stringstream<_CharT>& __sstr, basic_string_view<_CharT> __chrono_specs) {
+  tm __t              = __formatter::__make_tm(__value);
+  const auto& __facet = std::use_facet<time_put<_CharT>>(__sstr.getloc());
+  for (auto __it = __chrono_specs.begin(); __it != __chrono_specs.end(); ++__it) {
+    if (*__it == _CharT('%')) {
+      auto __s = __it;
+      ++__it;
+      // We only handle the types that can't be directly handled by time_put.
+      // (as an optimization n, t, and % are also handled directly.)
+      switch (*__it) {
+      case _CharT('n'):
+        __sstr << _CharT('\n');
+        break;
+      case _CharT('t'):
+        __sstr << _CharT('\t');
+        break;
+      case _CharT('%'):
+        __sstr << *__it;
+        break;
+
+      case _CharT('O'):
+        ++__it;
+        [[fallthrough]];
+      default:
+        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), __s, __it + 1);
+        break;
+      }
+    } else {
+      __sstr << *__it;
+    }
+  }
+}
+
+template <class _CharT, class _Tp>
+_LIBCPP_HIDE_FROM_ABI auto
+__format_chrono(const _Tp& __value,
+                auto& __ctx,
+                __format_spec::__parsed_specifications<_CharT> __specs,
+                basic_string_view<_CharT> __chrono_specs) -> decltype(__ctx.out()) {
+  basic_stringstream<_CharT> __sstr;
+  // [time.format]/2
+  // 2.1 - the "C" locale if the L option is not present in chrono-format-spec, otherwise
+  // 2.2 - the locale passed to the formatting function if any, otherwise
+  // 2.3 - the global locale.
+  // Note that the __ctx's locale() call does 2.2 and 2.3.
+  if (__specs.__chrono_.__locale_specific_form_)
+    __sstr.imbue(__ctx.locale());
+  else
+    __sstr.imbue(locale::classic());
+
+  if (__chrono_specs.empty())
+    __sstr << __value;
+  else
+    __formatter::__format_chrono_using_chrono_specs(__value, __sstr, __chrono_specs);
+
+  // TODO FMT Use the stringstream's view after P0408R7 has been implemented.
+  basic_string<_CharT> __str = __sstr.str();
+  return __formatter::__write_string(basic_string_view<_CharT>{__str}, __ctx.out(), __specs);
+}
+
+} // namespace __formatter
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_chrono {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(
+      basic_format_parse_context<_CharT>& __parse_ctx, __format_spec::__fields __fields, __format_spec::__flags __flags)
+      -> decltype(__parse_ctx.begin()) {
+    return __parser_.__parse(__parse_ctx, __fields, __flags);
+  }
+
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI auto format(const _Tp& __value, auto& __ctx) const -> decltype(__ctx.out()) const {
+    return __formatter::__format_chrono(
+        __value, __ctx, __parser_.__parser_.__get_parsed_chrono_specifications(__ctx), __parser_.__chrono_specs_);
+  }
+
+  __format_spec::__parser_chrono<_CharT> __parser_;
+};
+
+template <__formatter::__char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<chrono::day, _CharT>
+    : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
+      -> decltype(__parse_ctx.begin()) {
+    return _Base::parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__day);
+  }
+};
+
+#endif //if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif //  _LIBCPP___CHRONO_FORMATTER_H

libcxx/include/__chrono/ostream.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___CHRONO_OSTREAM_H
+#define _LIBCPP___CHRONO_OSTREAM_H
+
+#include <__chrono/day.h>
+#include <__chrono/statically_widen.h>
+#include <__config>
+#include <format>
+#include <ostream>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+namespace chrono {
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d) {
+  return __os
+      << (__d.ok()
+              ? std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:%d}"), __d)
+              // Note this error differs from the wording of the Standard. The
+              // Standard wording doesn't work well on AIX or Windows. There
+              // the formatted day seems to be either modulo 100 or completely
+              // omitted. Judging by the wording this is valid.
+              // TODO FMT Write a paper of file an LWG issue.
+              : std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02} is not a valid day"), static_cast<unsigned>(__d)));
+}
+
+} // namespace chrono
+
+#endif //if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CHRONO_OSTREAM_H

libcxx/include/__chrono/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___CHRONO_PARSER_STD_FORMAT_SPEC_H
+#define _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H
+
+#include <__config>
+#include <__format/format_error.h>
+#include <__format/format_fwd.h> // for __char_type TODO FMT Move the concept?
+#include <__format/format_parse_context.h>
+#include <__format/formatter_string.h>
+#include <__format/parser_std_format_spec.h>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+namespace __format_spec {
+
+// By not placing this constant in the formatter class it's not duplicated for char and wchar_t
+inline constexpr __fields __fields_chrono{.__locale_specific_form_ = true, .__type_ = false};
+
+/// Flags available or required in a chrono type.
+///
+/// The caller of the chrono formatter lists the types it has available and the
+/// validation tests whether the requested type spec (e.g. %M) is available in
+/// the formatter.
+/// When the type in the chrono-format-spec isn't present in the data a
+/// \ref format_error is thrown.
+enum class __flags {
+  __second = 0x1,
+  __minute = 0x2,
+  __hour   = 0x4,
+  __time   = __hour | __minute | __second,
+
+  __day   = 0x8,
+  __month = 0x10,
+  __year  = 0x20,
+
+  __weekday = 0x40,
+
+  __month_day     = __day | __month,
+  __month_weekday = __weekday | __month,
+  __year_month    = __month | __year,
+  __date          = __day | __month | __year | __weekday,
+
+  __date_time = __date | __time,
+
+  __duration = 0x80 | __time,
+
+  __time_zone = 0x100,
+
+  __clock = __date_time | __time_zone
+};
+
+_LIBCPP_HIDE_FROM_ABI constexpr __flags operator&(__flags __lhs, __flags __rhs) {
+  return static_cast<__flags>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_second(__flags __flags) {
+  if ((__flags & __flags::__second) != __flags::__second)
+    std::__throw_format_error("The supplied date time doesn't contain a second");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_minute(__flags __flags) {
+  if ((__flags & __flags::__minute) != __flags::__minute)
+    std::__throw_format_error("The supplied date time doesn't contain a minute");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_hour(__flags __flags) {
+  if ((__flags & __flags::__hour) != __flags::__hour)
+    std::__throw_format_error("The supplied date time doesn't contain an hour");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_time(__flags __flags) {
+  if ((__flags & __flags::__time) != __flags::__time)
+    std::__throw_format_error("The supplied date time doesn't contain a time");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_day(__flags __flags) {
+  if ((__flags & __flags::__day) != __flags::__day)
+    std::__throw_format_error("The supplied date time doesn't contain a day");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_month(__flags __flags) {
+  if ((__flags & __flags::__month) != __flags::__month)
+    std::__throw_format_error("The supplied date time doesn't contain a month");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_year(__flags __flags) {
+  if ((__flags & __flags::__year) != __flags::__year)
+    std::__throw_format_error("The supplied date time doesn't contain a year");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date(__flags __flags) {
+  if ((__flags & __flags::__date) != __flags::__date)
+    std::__throw_format_error("The supplied date time doesn't contain a date");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date_or_duration(__flags __flags) {
+  if (((__flags & __flags::__date) != __flags::__date) && ((__flags & __flags::__duration) != __flags::__duration))
+    std::__throw_format_error("The supplied date time doesn't contain a date or duration");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_date_time(__flags __flags) {
+  if ((__flags & __flags::__date_time) != __flags::__date_time)
+    std::__throw_format_error("The supplied date time doesn't contain a date and time");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_weekday(__flags __flags) {
+  if ((__flags & __flags::__weekday) != __flags::__weekday)
+    std::__throw_format_error("The supplied date time doesn't contain a weekday");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_duration(__flags __flags) {
+  if ((__flags & __flags::__duration) != __flags::__duration)
+    std::__throw_format_error("The supplied date time doesn't contain a duration");
+}
+
+_LIBCPP_HIDE_FROM_ABI constexpr void __validate_time_zone(__flags __flags) {
+  if ((__flags & __flags::__time_zone) != __flags::__time_zone)
+    std::__throw_format_error("The supplied date time doesn't contain a time zone");
+}
+
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS __parser_chrono {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr auto
+  __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields, __flags __flags)
+      -> decltype(__parse_ctx.begin()) {
+    const _CharT* __begin = __parser_.__parse(__parse_ctx, __fields);
+    const _CharT* __end   = __parse_ctx.end();
+    if (__begin == __end)
+      return __begin;
+
+    const _CharT* __last = __parse_chrono_specs(__begin, __end, __flags);
+    __chrono_specs_      = basic_string_view<_CharT>{__begin, __last};
+
+    return __last;
+  }
+
+  __parser<_CharT> __parser_;
+  basic_string_view<_CharT> __chrono_specs_;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI constexpr const _CharT*
+  __parse_chrono_specs(const _CharT* __begin, const _CharT* __end, __flags __flags) {
+    _LIBCPP_ASSERT(__begin != __end,
+                   "When called with an empty input the function will cause "
+                   "undefined behavior by evaluating data not in the input");
+
+    if (*__begin != _CharT('%') && *__begin != _CharT('}'))
+      std::__throw_format_error("Expected '%' or '}' in the chrono format-string");
+
+    do {
+      switch (*__begin) {
+      case _CharT('{'):
+        std::__throw_format_error("The chrono-specs contains a '{'");
+
+      case _CharT('}'):
+        return __begin;
+
+      case _CharT('%'):
+        __parse_conversion_spec(__begin, __end, __flags);
+        [[fallthrough]];
+
+      default:
+        // All other literals
+        ++__begin;
+      }
+
+    } while (__begin != __end && *__begin != _CharT('}'));
+
+    return __begin;
+  }
+
+  /// \pre *__begin == '%'
+  /// \post __begin points at the end parsed conversion-spec
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __parse_conversion_spec(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+    ++__begin;
+    if (__begin == __end)
+      std::__throw_format_error("End of input while parsing the modifier chrono conversion-spec");
+
+    switch (*__begin) {
+    case _CharT('n'):
+    case _CharT('t'):
+    case _CharT('%'):
+      break;
+
+    case _CharT('S'):
+      __format_spec::__validate_second(__flags);
+      break;
+
+    case _CharT('M'):
+      __format_spec::__validate_minute(__flags);
+      break;
+
+    case _CharT('p'): // TODO FMT does the formater require an hour or a time?
+    case _CharT('H'):
+    case _CharT('I'):
+      __validate_hour(__flags);
+      break;
+
+    case _CharT('r'):
+    case _CharT('R'):
+    case _CharT('T'):
+    case _CharT('X'):
+      __format_spec::__validate_time(__flags);
+      break;
+
+    case _CharT('d'):
+    case _CharT('e'):
+      __format_spec::__validate_day(__flags);
+      break;
+
+    case _CharT('b'):
+    case _CharT('h'):
+    case _CharT('B'):
+      __parser_.__month_name_ = true;
+      [[fallthrough]];
+    case _CharT('m'):
+      __format_spec::__validate_month(__flags);
+      break;
+
+    case _CharT('y'):
+    case _CharT('C'):
+    case _CharT('Y'):
+      __format_spec::__validate_year(__flags);
+      break;
+
+    case _CharT('j'):
+      __format_spec::__validate_date_or_duration(__flags);
+      break;
+
+    case _CharT('g'):
+    case _CharT('x'):
+    case _CharT('D'):
+    case _CharT('F'):
+    case _CharT('G'):
+    case _CharT('U'):
+    case _CharT('V'):
+    case _CharT('W'):
+      __format_spec::__validate_date(__flags);
+      break;
+
+    case _CharT('c'):
+      __format_spec::__validate_date_time(__flags);
+      break;
+
+    case _CharT('a'):
+    case _CharT('A'):
+      __parser_.__weekday_name_ = true;
+      [[fallthrough]];
+    case _CharT('u'):
+    case _CharT('w'):
+      __format_spec::__validate_weekday(__flags);
+      break;
+
+    case _CharT('q'):
+    case _CharT('Q'):
+      __format_spec::__validate_duration(__flags);
+      break;
+
+    case _CharT('E'):
+      __parse_modifier_E(__begin, __end, __flags);
+      break;
+
+    case _CharT('O'):
+      __parse_modifier_O(__begin, __end, __flags);
+      break;
+
+    case _CharT('z'):
+    case _CharT('Z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __format_spec::__validate_time_zone(__flags);
+      break;
+
+    default: // unknown type;
+      std::__throw_format_error("The date time type specifier is invalid");
+    }
+  }
+
+  /// \pre *__begin == 'E'
+  /// \post __begin is incremented by one.
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __parse_modifier_E(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+    ++__begin;
+    if (__begin == __end)
+      std::__throw_format_error("End of input while parsing the modifier E");
+
+    switch (*__begin) {
+    case _CharT('X'):
+      __format_spec::__validate_time(__flags);
+      break;
+
+    case _CharT('y'):
+    case _CharT('C'):
+    case _CharT('Y'):
+      __format_spec::__validate_year(__flags);
+      break;
+
+    case _CharT('x'):
+      __format_spec::__validate_date(__flags);
+      break;
+
+    case _CharT('c'):
+      __format_spec::__validate_date_time(__flags);
+      break;
+
+    case _CharT('z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __format_spec::__validate_time_zone(__flags);
+      break;
+
+    default:
+      std::__throw_format_error("The date time type specifier for modifier E is invalid");
+    }
+  }
+
+  /// \pre *__begin == 'O'
+  /// \post __begin is incremented by one.
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __parse_modifier_O(const _CharT*& __begin, const _CharT* __end, __flags __flags) {
+    ++__begin;
+    if (__begin == __end)
+      std::__throw_format_error("End of input while parsing the modifier O");
+
+    switch (*__begin) {
+    case _CharT('S'):
+      __format_spec::__validate_second(__flags);
+      break;
+
+    case _CharT('M'):
+      __format_spec::__validate_minute(__flags);
+      break;
+
+    case _CharT('I'):
+    case _CharT('H'):
+      __format_spec::__validate_hour(__flags);
+      break;
+
+    case _CharT('d'):
+    case _CharT('e'):
+      __format_spec::__validate_day(__flags);
+      break;
+
+    case _CharT('m'):
+      __format_spec::__validate_month(__flags);
+      break;
+
+    case _CharT('y'):
+      __format_spec::__validate_year(__flags);
+      break;
+
+    case _CharT('U'):
+    case _CharT('V'):
+    case _CharT('W'):
+      __format_spec::__validate_date(__flags);
+      break;
+
+    case _CharT('u'):
+    case _CharT('w'):
+      __format_spec::__validate_weekday(__flags);
+      break;
+
+    case _CharT('z'):
+      // Currently there's no time zone information. However some clocks have a
+      // hard-coded "time zone", for these clocks the information can be used.
+      // TODO FMT implement time zones.
+      __format_spec::__validate_time_zone(__flags);
+      break;
+
+    default:
+      std::__throw_format_error("The date time type specifier for modifier O is invalid");
+    }
+  }
+};
+
+} // namespace __format_spec
+
+#endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H

libcxx/include/__chrono/statically_widen.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___CHRONO_STATICALLY_WIDEN_H
+#define _LIBCPP___CHRONO_STATICALLY_WIDEN_H
+
+// Implements the STATICALLY-WIDEN exposition-only function. ([time.general]/2)
+
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__format/formatter.h> // for __char_type TODO FMT Move the concept?
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <__formatter::__char_type _CharT>
+consteval const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) {
+  if constexpr (same_as<_CharT, char>)
+    return __str;
+  else
+    return __wstr;
+}
+#    define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str, L##__str)
+#  else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// Without this indirection the unit test test/libcxx/modules_include.sh.cpp
+// fails for the CI build "No wide characters". This seems like a bug.
+// TODO FMT investigate why this is needed.
+template <__formatter::__char_type _CharT>
+consteval const _CharT* __statically_widen(const char* __str) {
+  return __str;
+}
+#    define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str)
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#endif //if _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___CHRONO_STATICALLY_WIDEN_H

libcxx/include/__format/parser_std_format_spec.h

struct __std {
   __sign __sign_ : 2;
   bool __alternate_form_ : 1;
   bool __locale_specific_form_ : 1;
   __type __type_;
 };
 
 struct __chrono {
   __alignment __alignment_ : 3;
+  bool __locale_specific_form_ : 1;
   bool __weekday_name_ : 1;
   bool __month_name_ : 1;
 };
 
 /// Contains the parsed formatting specifications.
 ///
 /// This contains information for both the std-format-spec and the
 /// chrono-format-spec. This results in some unused members for both
_LIBCPP_HIDE_FROM_ABI constexpr auto __parse(basic_format_parse_context<_CharT>& __parse_ctx, __fields __fields)
 
     return __begin;
   }
 
   /// \returns the `__parsed_specifications` with the resolved dynamic sizes..
   _LIBCPP_HIDE_FROM_ABI
   __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
     return __parsed_specifications<_CharT>{
-        .__std_ =
-            __std{.__alignment_            = __alignment_,
+        .__std_ = __std{.__alignment_            = __alignment_,
                         .__sign_                 = __sign_,
                         .__alternate_form_       = __alternate_form_,
                         .__locale_specific_form_ = __locale_specific_form_,
                         .__type_                 = __type_},
         .__width_{__get_width(__ctx)},
         .__precision_{__get_precision(__ctx)},
         .__fill_{__fill_}};
   }
 
+  _LIBCPP_HIDE_FROM_ABI __parsed_specifications<_CharT> __get_parsed_chrono_specifications(auto& __ctx) const {
+    return __parsed_specifications<_CharT>{
+        .__chrono_ = __chrono{.__alignment_            = __alignment_,
+                              .__locale_specific_form_ = __locale_specific_form_,
+                              .__weekday_name_         = __weekday_name_,
+                              .__month_name_           = __month_name_},
+        .__width_{__get_width(__ctx)},
+        .__precision_{__get_precision(__ctx)},
+        .__fill_{__fill_}};
+  }
+
   __alignment __alignment_ : 3 {__alignment::__default};
   __sign __sign_ : 2 {__sign::__default};
   bool __alternate_form_ : 1 {false};
   bool __locale_specific_form_ : 1 {false};
   bool __reserved_0_ : 1 {false};
   __type __type_{__type::__default};
 
   // These two flags are used for formatting chrono. Since the struct has

libcxx/include/algorithm

 #include <__algorithm/swap_ranges.h>
 #include <__algorithm/transform.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__algorithm/upper_bound.h>
 
 #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+// This creates a circular dependency tree...
+//#  include <chrono>
 #  include <iterator>
 #  include <utility>
 #endif
 
 // standard-mandated includes
 #include <initializer_list>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_algorithm>
 #endif
 
 #endif // _LIBCPP_ALGORITHM

libcxx/include/atomic

 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 # include <__threading_support>
 #endif
 
 #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
-#  include <chrono>
+// This creates a circular dependency tree...
+//#  include <chrono>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_ATOMIC_HEADER
 # error <atomic> is not implemented

libcxx/include/chrono

 
 class day;
 constexpr bool operator==(const day& x, const day& y) noexcept;
 constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
 constexpr day  operator+(const day&  x, const days& y) noexcept;
 constexpr day  operator+(const days& x, const day&  y) noexcept;
 constexpr day  operator-(const day&  x, const days& y) noexcept;
 constexpr days operator-(const day&  x, const day&  y) noexcept;
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const day& d);
 
 // 25.8.4, class month    // C++20
 class month;
 constexpr bool operator==(const month& x, const month& y) noexcept;
 constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
 
 constexpr month  operator+(const month&  x, const months& y) noexcept;
 constexpr month  operator+(const months& x,  const month& y) noexcept;

 enum class choose {earliest, latest};
 class time_zone;
 bool operator==(const time_zone& x, const time_zone& y) noexcept;
 bool operator!=(const time_zone& x, const time_zone& y) noexcept;
 bool operator<(const time_zone& x, const time_zone& y) noexcept;
 bool operator>(const time_zone& x, const time_zone& y) noexcept;
 bool operator<=(const time_zone& x, const time_zone& y) noexcept;
 bool operator>=(const time_zone& x, const time_zone& y) noexcept;
+}  // chrono
+
+namespace std {
+  template<class charT> struct formatter<chrono::day, charT>;                     // C++20
+} // namespace std
 
+namespace chrono {
 // calendrical constants
 inline constexpr last_spec                              last{};       // C++20
 inline constexpr chrono::weekday                        Sunday{0};    // C++20
 inline constexpr chrono::weekday                        Monday{1};    // C++20
 inline constexpr chrono::weekday                        Tuesday{2};   // C++20
 inline constexpr chrono::weekday                        Wednesday{3}; // C++20
 inline constexpr chrono::weekday                        Thursday{4};  // C++20
 inline constexpr chrono::weekday                        Friday{5};    // C++20

 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/hh_mm_ss.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__chrono/literals.h>
 #include <__chrono/month.h>
 #include <__chrono/month_weekday.h>
 #include <__chrono/monthday.h>
+#include <__chrono/statically_widen.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/weekday.h>
 #include <__chrono/year.h>
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>
 #include <__config>
 #include <version>
 
 // standard-mandated includes
 #include <compare>
 
+// The time format and ostream functions use ostream which requires locale support.
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
+#  include <__chrono/formatter.h>
+#  include <__chrono/ostream.h>
+#  include <__chrono/parser_std_format_spec.h>
+#endif
+
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_CHRONO

libcxx/include/module.modulemap.in

module charconv {
     }
 
   }
   module chrono {
     header "chrono"
     export *
 
     module __chrono {
-      module calendar              { private header "__chrono/calendar.h" }
-      module convert_to_timespec   { private header "__chrono/convert_to_timespec.h" }
-      module day                   { private header "__chrono/day.h" }
-      module duration              { private header "__chrono/duration.h" }
-      module file_clock            { private header "__chrono/file_clock.h" }
-      module hh_mm_ss              { private header "__chrono/hh_mm_ss.h" }
-      module high_resolution_clock {
+      module calendar               { private header "__chrono/calendar.h" }
+      module convert_to_timespec    { private header "__chrono/convert_to_timespec.h" }
+      module day                    { private header "__chrono/day.h" }
+      module duration               { private header "__chrono/duration.h" }
+      module file_clock             { private header "__chrono/file_clock.h" }
+      module formatter              {
+        @requires_LIBCXX_ENABLE_LOCALIZATION@
+        private header "__chrono/formatter.h"
+      }
+      module hh_mm_ss               { private header "__chrono/hh_mm_ss.h" }
+      module high_resolution_clock  {
         private header "__chrono/high_resolution_clock.h"
         export steady_clock
         export system_clock
       }
-      module literals              { private header "__chrono/literals.h" }
-      module month                 { private header "__chrono/month.h" }
-      module month_weekday         { private header "__chrono/month_weekday.h" }
-      module monthday              { private header "__chrono/monthday.h" }
-      module steady_clock          { private header "__chrono/steady_clock.h" }
-      module system_clock          { private header "__chrono/system_clock.h" }
-      module time_point            { private header "__chrono/time_point.h" }
-      module weekday               { private header "__chrono/weekday.h" }
-      module year                  { private header "__chrono/year.h" }
-      module year_month            { private header "__chrono/year_month.h" }
-      module year_month_day        { private header "__chrono/year_month_day.h" }
-      module year_month_weekday    { private header "__chrono/year_month_weekday.h" }
+      module literals               { private header "__chrono/literals.h" }
+      module month                  { private header "__chrono/month.h" }
+      module month_weekday          { private header "__chrono/month_weekday.h" }
+      module monthday               { private header "__chrono/monthday.h" }
+      module ostream                {
+        @requires_LIBCXX_ENABLE_LOCALIZATION@
+        private header "__chrono/ostream.h"
+      }
+      module parser_std_format_spec { private header "__chrono/parser_std_format_spec.h" }
+      module statically_widen       { private header "__chrono/statically_widen.h" }
+      module steady_clock           { private header "__chrono/steady_clock.h" }
+      module system_clock           { private header "__chrono/system_clock.h" }
+      module time_point             { private header "__chrono/time_point.h" }
+      module weekday                { private header "__chrono/weekday.h" }
+      module year                   { private header "__chrono/year.h" }
+      module year_month             { private header "__chrono/year_month.h" }
+      module year_month_day         { private header "__chrono/year_month_day.h" }
+      module year_month_weekday     { private header "__chrono/year_month_weekday.h" }
     }
   }
   module codecvt {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "codecvt"
     export *
   }
   module compare {

libcxx/include/optional

 #include <initializer_list>
 #include <new>
 #include <stdexcept>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
 #  include <atomic>
-#  include <chrono>
+// This creates a circular dependency tree...
+//#  include <chrono>
 #  include <climits>
 #  include <concepts>
 #  include <ctime>
 #  include <iterator>
 #  include <memory>
 #  include <ratio>
 #  include <tuple>
 #  include <typeinfo>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__charconv/tables.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/tables.h'}}
 #include <__charconv/to_chars_base_10.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/to_chars_base_10.h'}}
 #include <__charconv/to_chars_result.h> // expected-error@*:* {{use of private header from outside its module: '__charconv/to_chars_result.h'}}
 #include <__chrono/calendar.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/calendar.h'}}
 #include <__chrono/convert_to_timespec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/convert_to_timespec.h'}}
 #include <__chrono/day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/day.h'}}
 #include <__chrono/duration.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/duration.h'}}
 #include <__chrono/file_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/file_clock.h'}}
+#include <__chrono/formatter.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/formatter.h'}}
 #include <__chrono/hh_mm_ss.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/hh_mm_ss.h'}}
 #include <__chrono/high_resolution_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/high_resolution_clock.h'}}
 #include <__chrono/literals.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/literals.h'}}
 #include <__chrono/month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month.h'}}
 #include <__chrono/month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/month_weekday.h'}}
 #include <__chrono/monthday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/monthday.h'}}
+#include <__chrono/ostream.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/ostream.h'}}
+#include <__chrono/parser_std_format_spec.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/parser_std_format_spec.h'}}
+#include <__chrono/statically_widen.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/statically_widen.h'}}
 #include <__chrono/steady_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/steady_clock.h'}}
 #include <__chrono/system_clock.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/system_clock.h'}}
 #include <__chrono/time_point.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/time_point.h'}}
 #include <__chrono/weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/weekday.h'}}
 #include <__chrono/year.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year.h'}}
 #include <__chrono/year_month.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month.h'}}
 #include <__chrono/year_month_day.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_day.h'}}
 #include <__chrono/year_month_weekday.h> // expected-error@*:* {{use of private header from outside its module: '__chrono/year_month_weekday.h'}}

libcxx/test/libcxx/transitive_includes.sh.cpp

 
 // This test doesn't support being run when some headers are not available, since we
 // would need to add significant complexity to make that work.
 // UNSUPPORTED: no-localization, no-threads, no-wide-characters, no-filesystem, libcpp-has-no-incomplete-format, libcpp-has-no-incomplete-ranges
 
 // This test only supports being run with the latest Standard, otherwise we'd
 // have to support various versions of the test.
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+//
+//
+// TEMPORARY HACK
+// UNSUPPORTED: c++2b
 
 // When built with modules, this test doesn't work because --trace-includes doesn't
 // report the stack of includes correctly.
 // UNSUPPORTED: modules-build
 
 // This test uses --trace-includes, which is not supported by GCC.
 // UNSUPPORTED: gcc
 

libcxx/test/libcxx/utilities/format/format.formatter/format.formatter.spec/formattable.compile.pass.cpp

 
 // Tests for P1361 Integration of chrono with text formatting
 //
 // Some tests are commented out since these types haven't been implemented in
 // chrono yet. After P1361 has been implemented these formatters should be all
 // enabled.
 template <class CharT>
 void test_P1361() {
+// The chrono formatters require localization support.
+// [time.format]/7
+//   If the chrono-specs is omitted, the chrono object is formatted as if by
+//   streaming it to std::ostringstream os with the formatting
+//   locale imbued and copying os.str() through the output iterator of the
+//   context with additional padding and adjustments as specified by the format
+//   specifiers.
+// In libc++ std:::ostringstream requires localization support.
+#ifndef TEST_HAS_NO_LOCALIZATION
+
   assert_is_not_formattable<std::chrono::microseconds, CharT>();
 
   assert_is_not_formattable<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::utc_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::tai_time<std::chrono::microseconds>, CharT>();
   //assert_is_formattable<std::chrono::gps_time<std::chrono::microseconds>, CharT>();
   assert_is_not_formattable<std::chrono::file_time<std::chrono::microseconds>, CharT>();
   assert_is_not_formattable<std::chrono::local_time<std::chrono::microseconds>, CharT>();
 
-  assert_is_not_formattable<std::chrono::day, CharT>();
+  assert_is_formattable<std::chrono::day, CharT>();
   assert_is_not_formattable<std::chrono::month, CharT>();
   assert_is_not_formattable<std::chrono::year, CharT>();
 
   assert_is_not_formattable<std::chrono::weekday, CharT>();
   assert_is_not_formattable<std::chrono::weekday_indexed, CharT>();
   assert_is_not_formattable<std::chrono::weekday_last, CharT>();
 
   assert_is_not_formattable<std::chrono::month_day, CharT>();
   assert_is_not_formattable<std::chrono::month_day_last, CharT>();
   assert_is_not_formattable<std::chrono::month_weekday, CharT>();
   assert_is_not_formattable<std::chrono::month_weekday_last, CharT>();
 
   assert_is_not_formattable<std::chrono::year_month, CharT>();
   assert_is_not_formattable<std::chrono::year_month_day, CharT>();
   assert_is_not_formattable<std::chrono::year_month_day_last, CharT>();
   assert_is_not_formattable<std::chrono::year_month_weekday, CharT>();
   assert_is_not_formattable<std::chrono::year_month_weekday_last, CharT>();
 
   assert_is_not_formattable<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
 
   //assert_is_formattable<std::chrono::sys_info, CharT>();
   //assert_is_formattable<std::chrono::local_info, CharT>();
 
   //assert_is_formattable<std::chrono::zoned_time, CharT>();
+
+#endif // TEST_HAS_NO_LOCALIZATION
 }
 
 // Tests for P1636 Formatters for library types
 //
 // The paper hasn't been voted in so currently all formatters are disabled.
 // TODO validate whether the test is correct after the paper has been accepted.
 template <class CharT>
 void test_P1636() {

libcxx/test/std/time/time.cal/time.cal.day/time.cal.day.nonmembers/ostream.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// TODO FMT Investigate Windows issues.
+// UNSUPPORTED msvc, target={{.+}}-windows-gnu
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+// class day;
+
+// template<class charT, class traits>
+//   basic_ostream<charT, traits>&
+//     operator<<(basic_ostream<charT, traits>& os, const day& d);
+
+#include <chrono>
+#include <cassert>
+#include <sstream>
+
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+template <class CharT>
+static std::basic_string<CharT> stream_c_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_fr_FR_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_fr_FR_UTF_8);
+  sstr.imbue(locale);
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static std::basic_string<CharT> stream_ja_JP_locale(std::chrono::day day) {
+  std::basic_stringstream<CharT> sstr;
+  const std::locale locale(LOCALE_ja_JP_UTF_8);
+  sstr.imbue(locale);
+  sstr << day;
+  return sstr.str();
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  assert(stream_c_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_c_locale<CharT>(1d) == SV("01"));
+  assert(stream_c_locale<CharT>(31d) == SV("31"));
+  assert(stream_c_locale<CharT>(255d) == SV("255 is not a valid day"));
+
+  assert(stream_fr_FR_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_fr_FR_locale<CharT>(1d) == SV("01"));
+  assert(stream_fr_FR_locale<CharT>(31d) == SV("31"));
+  assert(stream_fr_FR_locale<CharT>(255d) == SV("255 is not a valid day"));
+
+  assert(stream_ja_JP_locale<CharT>(0d) == SV("00 is not a valid day"));
+  assert(stream_ja_JP_locale<CharT>(1d) == SV("01"));
+  assert(stream_ja_JP_locale<CharT>(31d) == SV("31"));
+  assert(stream_ja_JP_locale<CharT>(255d) == SV("255 is not a valid day"));
+}
+
+int main(int, char**) {
+  using namespace std::literals::chrono_literals;
+
+  test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.syn/formatter.day.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-localization
+// UNSUPPORTED: libcpp-has-no-incomplete-format
+
+// TODO FMT Investigate Windows issues.
+// UNSUPPORTED: msvc, target={{.+}}-windows-gnu
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+// <chrono>
+
+// template<class charT> struct formatter<chrono::day, charT>;
+
+#include <chrono>
+#include <format>
+
+#include <cassert>
+#include <concepts>
+#include <locale>
+#include <iostream>
+#include <type_traits>
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "string_literal.h"
+#include "test_macros.h"
+
+template <class CharT>
+static void test_no_chrono_specs() {
+  using namespace std::literals::chrono_literals;
+
+  // Valid day
+  check.template operator()<"{}">(SV("01"), 1d);
+  check.template operator()<"{:*^4}">(SV("*01*"), 1d);
+  check.template operator()<"{:*>3}">(SV("*01"), 1d);
+
+  // Invalid day
+  check.template operator()<"{}">(SV("00 is not a valid day"), 0d);
+  check.template operator()<"{:*^23}">(SV("*00 is not a valid day*"), 0d);
+}
+
+template <class CharT>
+static void test_valid_values() {
+  using namespace std::literals::chrono_literals;
+
+  constexpr string_literal fmt{"{:%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%n}"};
+  constexpr string_literal lfmt{"{:L%%d='%d'%t%%Od='%Od'%t%%e='%e'%t%%Oe='%Oe'%n}"};
+
+  const std::locale loc(LOCALE_ja_JP_UTF_8);
+  std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+  // Non localized output using C-locale
+  check.template operator()<fmt>(SV("%d='00'\t%Od='00'\t%e=' 0'\t%Oe=' 0'\n"), 0d);
+  check.template operator()<fmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"), 1d);
+  check.template operator()<fmt>(SV("%d='31'\t%Od='31'\t%e='31'\t%Oe='31'\n"), 31d);
+#if defined(_AIX)
+  check.template operator()<fmt>(SV("%d='55'\t%Od='55'\t%e='55'\t%Oe='55'\n"), 255d);
+#else
+  check.template operator()<fmt>(SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+#endif
+
+  // Use the global locale (fr_FR)
+  check.template operator()<lfmt>(SV("%d='00'\t%Od='00'\t%e=' 0'\t%Oe=' 0'\n"), 0d);
+  check.template operator()<lfmt>(SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"), 1d);
+  check.template operator()<lfmt>(SV("%d='31'\t%Od='31'\t%e='31'\t%Oe='31'\n"), 31d);
+#if defined(_AIX)
+  check.template operator()<lfmt>(SV("%d='55'\t%Od='55'\t%e='55'\t%Oe='55'\n"), 255d);
+#else
+  check.template operator()<lfmt>(SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+#endif
+
+  // Use supplied locale (ja_JP). This locale has a different alternate on some platforms.
+#if defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%d='00'\t%Od='00'\t%e=' 0'\t%Oe=' 0'\n"), 0d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='01'\t%Od='01'\t%e=' 1'\t%Oe=' 1'\n"), 1d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='31'\t%Od='31'\t%e='31'\t%Oe='31'\n"), 31d);
+#  if defined(_AIX)
+  check.template operator()<fmt>(SV("%d='55'\t%Od='55'\t%e='55'\t%Oe='55'\n"), 255d);
+#  else
+  check.template operator()<fmt>(SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+#  endif
+#else  // defined(__APPLE__) || defined(_AIX)
+  lcheck.template operator()<lfmt>(loc, SV("%d='00'\t%Od='〇'\t%e=' 0'\t%Oe='〇'\n"), 0d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='01'\t%Od='一'\t%e=' 1'\t%Oe='一'\n"), 1d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='31'\t%Od='三十一'\t%e='31'\t%Oe='三十一'\n"), 31d);
+  lcheck.template operator()<lfmt>(loc, SV("%d='255'\t%Od='255'\t%e='255'\t%Oe='255'\n"), 255d);
+#endif // defined(__APPLE__) || defined(_AIX)
+
+  std::locale::global(std::locale::classic());
+}
+
+template <class CharT>
+static void test() {
+  using namespace std::literals::chrono_literals;
+
+  test_no_chrono_specs<CharT>();
+  test_valid_values<CharT>();
+  check_invalid_types<CharT>({SV("d"), SV("e"), SV("Od"), SV("Oe")}, 0d);
+
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:A"), 0d);
+  check_exception("The chrono-specs contains a '{'", SV("{:%%{"), 0d);
+  check_exception("End of input while parsing the modifier chrono conversion-spec", SV("{:%"), 0d);
+  check_exception("End of input while parsing the modifier E", SV("{:%E"), 0d);
+  check_exception("End of input while parsing the modifier O", SV("{:%O"), 0d);
+
+  // Precision not allowed
+  check_exception("Expected '%' or '}' in the chrono format-string", SV("{:.3}"), 0d);
+}
+
+int main(int, char**) {
+  test<char>();
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  test<wchar_t>();
+#endif
+
+  return 0;
+}

libcxx/test/std/time/time.syn/formatter_tests.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 TEST_STD_TIME_TIME_SYN_FORMATTER_TESTS_H
+#define TEST_STD_TIME_TIME_SYN_FORMATTER_TESTS_H
+
+#include "make_string.h"
+#include "string_literal.h"
+
+#include <algorithm>
+#include <cassert>
+#include <set>
+#include <string>
+#include <string_view>
+
+#define STR(S) MAKE_STRING(CharT, S)
+#define SV(S) MAKE_STRING_VIEW(CharT, S)
+
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+template <class CharT>
+using format_context = std::conditional_t<std::same_as<CharT, char>, std::format_context, std::wformat_context>;
+#else
+template <class CharT>
+using format_context = std::format_context;
+#endif
+
+inline constexpr auto check = []<string_literal fmt, class CharT, class... Args>(
+    std::basic_string_view<CharT> expected, const Args&... args) constexpr {
+  std::basic_string<CharT> out = std::format(fmt.template sv<CharT>(), args...);
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt.template sv<CharT>() << "\nExpected output " << expected
+                << "\nActual output   " << out << '\n';
+  assert(out == expected);
+};
+
+inline constexpr auto lcheck = []<string_literal fmt, class CharT, class... Args>(
+    const std::locale& loc, std::basic_string_view<CharT> expected, const Args&... args) constexpr {
+  std::basic_string<CharT> out = std::format(loc, fmt.template sv<CharT>(), args...);
+  if constexpr (std::same_as<CharT, char>)
+    if (out != expected)
+      std::cerr << "\nFormat string   " << fmt.template sv<CharT>() << "\nExpected output " << expected
+                << "\nActual output   " << out << '\n';
+  assert(out == expected);
+};
+
+inline constexpr auto check_exception =
+    []<class CharT, class... Args>(
+        [[maybe_unused]] std::string_view what,
+        [[maybe_unused]] std::basic_string_view<CharT> fmt,
+        [[maybe_unused]] const Args&... args) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+      try {
+        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<format_context<CharT>>(args...));
+        if constexpr (std::same_as<CharT, char>)
+          std::cerr << "\nFormat string   " << fmt << "\nDidn't throw an exception.\n";
+        assert(false);
+      } catch (const std::format_error& e) {
+#  if defined(_LIBCPP_VERSION)
+        if constexpr (std::same_as<CharT, char>)
+          if (e.what() != what)
+            std::cerr << "\nFormat string   " << fmt << "\nExpected exception " << what << "\nActual exception   "
+                      << e.what() << '\n';
+        assert(e.what() == what);
+#  endif
+        return;
+      }
+      assert(false);
+#endif
+    };
+
+template <class CharT, class T>
+void check_invalid_type(const std::set<std::basic_string_view<CharT>>& valid_types,
+                        std::string_view what,
+                        std::basic_string<CharT> type,
+                        const T& arg) {
+  std::basic_string<CharT> fmt{STR("{:%") + type + STR("}")};
+
+  if (valid_types.contains(std::basic_string_view<CharT>{type})) {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try {
+#endif
+      TEST_IGNORE_NODISCARD std::vformat(
+          std::basic_string_view<CharT>{fmt}, std::make_format_args<format_context<CharT>>(arg));
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    } catch (const std::format_error& e) {
+#  if defined(_LIBCPP_VERSION)
+      if constexpr (std::same_as<CharT, char>)
+        std::cerr << "\nFormat string        " << fmt << "\nUnexpected exception " << e.what() << '\n';
+#  endif
+      assert(false);
+    }
+#endif
+  } else {
+    check_exception(what, std::basic_string_view<CharT>{fmt}, arg);
+  }
+}
+
+template <class CharT, class T>
+void check_invalid_types(const std::set<std::basic_string_view<CharT>>& valid_types, const T& arg) {
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("a"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("A"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("b"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("B"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date and time", STR("c"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("C"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("d"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("D"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("e"), arg);
+  // E - the modifier is checked separately
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("f"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("F"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("g"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("G"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("h"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain an hour", STR("H"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("i"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain an hour", STR("I"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date or duration", STR("j"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("J"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("k"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("K"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("l"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("L"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("m"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a minute", STR("M"), arg);
+  // n - valid
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("N"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("o"), arg);
+  // O - the modifier is checked separately
+  check_invalid_type(valid_types, "The supplied date time doesn't contain an hour", STR("p"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("P"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a duration", STR("q"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a duration", STR("Q"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("r"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("R"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("s"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a second", STR("S"), arg);
+  // t - valid
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("T"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("u"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("U"), arg);
+  check_invalid_type(valid_types, "The date time type specifier is invalid", STR("v"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("V"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("w"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("W"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("x"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("X"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("y"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("y"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("z"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Z"), arg);
+
+  // *** E modifier
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ea"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EA"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eb"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EB"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date and time", STR("Ec"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("EC"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ed"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ED"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ee"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EE"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ef"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EF"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eg"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EG"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eh"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EH"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ei"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EI"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ej"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EJ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ek"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EK"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("El"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EL"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Em"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EM"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("En"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EN"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eo"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EO"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ep"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EP"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eq"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EQ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Er"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ER"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Es"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ES"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Et"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("ET"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Eu"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EU"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ev"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EV"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("Ew"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EW"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("Ex"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time", STR("EX"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("Ey"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("EY"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Ez"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("EZ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier E is invalid", STR("E%"), arg);
+
+  // *** O modifier
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oa"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OA"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ob"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OB"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oc"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OC"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("Od"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OD"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a day", STR("Oe"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OE"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Of"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OF"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Og"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OG"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oh"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain an hour", STR("OH"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oi"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain an hour", STR("OI"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oj"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OJ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ok"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OK"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ol"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OL"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a month", STR("Om"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a minute", STR("OM"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("On"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("ON"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oo"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OO"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Op"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OP"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Oq"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OQ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Or"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OR"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Os"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a second", STR("OS"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ot"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OT"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("Ou"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OU"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ov"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OV"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a weekday", STR("Ow"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a date", STR("OW"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("Ox"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OX"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a year", STR("Oy"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OY"), arg);
+  check_invalid_type(valid_types, "The supplied date time doesn't contain a time zone", STR("Oz"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("OZ"), arg);
+  check_invalid_type(valid_types, "The date time type specifier for modifier O is invalid", STR("O%"), arg);
+}
+
+#endif // TEST_STD_TIME_TIME_SYN_FORMATTER_TESTS_H

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/types.compile.pass.cpp

#endif
   else
     assert_formatter_is_disabled<T, CharT>();
 }
 
 // Tests for P0645 Text Formatting
 template <class CharT>
 void test_P0645() {
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   // Tests the special formatter that converts a char to a wchar_t.
   assert_formatter_is_enabled<char, wchar_t>();
 #endif
   assert_formatter_is_enabled<CharT, CharT>();
 
   assert_formatter_is_enabled<CharT*, CharT>();
   assert_formatter_is_enabled<const CharT*, CharT>();
   assert_formatter_is_enabled<CharT[42], CharT>();
   assert_formatter_is_enabled<const CharT[42], CharT>();

 
 // Tests for P1361 Integration of chrono with text formatting
 //
 // Some tests are commented out since these types haven't been implemented in
 // chrono yet. After P1361 has been implemented these formatters should be all
 // enabled.
 template <class CharT>
 void test_P1361() {
+// The chrono formatters require localization support.
+// [time.format]/7
+//   If the chrono-specs is omitted, the chrono object is formatted as if by
+//   streaming it to std::ostringstream os with the formatting
+//   locale imbued and copying os.str() through the output iterator of the
+//   context with additional padding and adjustments as specified by the format
+//   specifiers.
+// In libc++ std:::ostringstream requires localization support.
+#ifndef TEST_HAS_NO_LOCALIZATION
+
   assert_formatter_is_disabled<std::chrono::microseconds, CharT>();
 
   assert_formatter_is_disabled<std::chrono::sys_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::utc_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::tai_time<std::chrono::microseconds>, CharT>();
   //assert_formatter_is_enabled<std::chrono::gps_time<std::chrono::microseconds>, CharT>();
   assert_formatter_is_disabled<std::chrono::file_time<std::chrono::microseconds>, CharT>();
   assert_formatter_is_disabled<std::chrono::local_time<std::chrono::microseconds>, CharT>();
 
-  assert_formatter_is_disabled<std::chrono::day, CharT>();
+  assert_formatter_is_enabled<std::chrono::day, CharT>();
   assert_formatter_is_disabled<std::chrono::month, CharT>();
   assert_formatter_is_disabled<std::chrono::year, CharT>();
 
   assert_formatter_is_disabled<std::chrono::weekday, CharT>();
   assert_formatter_is_disabled<std::chrono::weekday_indexed, CharT>();
   assert_formatter_is_disabled<std::chrono::weekday_last, CharT>();
 
   assert_formatter_is_disabled<std::chrono::month_day, CharT>();
   assert_formatter_is_disabled<std::chrono::month_day_last, CharT>();
   assert_formatter_is_disabled<std::chrono::month_weekday, CharT>();
   assert_formatter_is_disabled<std::chrono::month_weekday_last, CharT>();
 
   assert_formatter_is_disabled<std::chrono::year_month, CharT>();
   assert_formatter_is_disabled<std::chrono::year_month_day, CharT>();
   assert_formatter_is_disabled<std::chrono::year_month_day_last, CharT>();
   assert_formatter_is_disabled<std::chrono::year_month_weekday, CharT>();
   assert_formatter_is_disabled<std::chrono::year_month_weekday_last, CharT>();
 
   assert_formatter_is_disabled<std::chrono::hh_mm_ss<std::chrono::microseconds>, CharT>();
 
   //assert_formatter_is_enabled<std::chrono::sys_info, CharT>();
   //assert_formatter_is_enabled<std::chrono::local_info, CharT>();
 
   //assert_formatter_is_enabled<std::chrono::zoned_time, CharT>();
+
+#endif // TEST_HAS_NO_LOCALIZATION
 }
 
 // Tests for P1636 Formatters for library types
 //
 // The paper hasn't been voted in so currently all formatters are disabled.
 // TODO validate whether the test is correct after the paper has been accepted.
 template <class CharT>
 void test_P1636() {