[libc++][format] Add basic_format_parse_context.

[Mordante]

Summary

Implements parts of:

• P0645 Text Formatting

Depends on D92214

[Mordante]

Fixes a GCC shadow warning.

[curdeius]

You should mark tests that use format_error with // XFAIL: with_system_cxx_lib=macosx10.9|...|15.

libcxx/include/format

322

Couldn't we add at least a debug check to verify "Preconditions: end() is reachable from it."?
http://eel.is/c++draft/format#parse.ctx-5

342

Why is_constant_evaluated? Does it correspond to the phrase "Remarks: Call expressions where id >= num_args_ are not core constant expressions ([expr.const])."?
http://eel.is/c++draft/format#parse.ctx-11
Could you explain how it should be understood?

349

Why not enum class?

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

33

Please add a test for the ctor being explicit (using test_convertible for instance).

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

47

I think you should guard it on __cpp_char8_t.

[Mordante]

Thanks for the review!

I'll add the XFAILs to the next version of the patch.

libcxx/include/format

322

I had a look at the debug iterators and adding this test seems not trivial. So I think it's not worth the effort to add it here.

342

Since http://eel.is/c++draft/format#parse.ctx-10 doesn't specify this exception to be thrown I read this that the test only should be done when std::is_constant_evaluated is true. In that case the function should no longer be a constexpr function. So I use the throw to achieve this. I'm not sure why the exception just shouldn't be thrown unconditionally, I hope to figure that out when I'm a bit further with the implementation.

I'll add some comment in the next revision of the patch.

349

I didn't add it since the enum is only used internally in the class so I feel the class doesn't add to much benefits and http://eel.is/c++draft/format.parse.ctx doesn't require it.

If you feel strongly about it I don't mind changing it.

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

47

I thought it wouldn't be required, but I'll add _LIBCPP_NO_HAS_CHAR8_T and _LIBCPP_HAS_NO_UNICODE_CHARS guards.

[Mordante]

Addresses review comments.

[curdeius]

I haven't finished reviewing. Will do soon.

libcxx/include/format

349

Don't bother. No strong feelings about this :).

[curdeius]

libcxx/include/format

332

I see that it isn't checked that __next_arg_id_ < __num_args.
fmtlib has the following comment (https://github.com/fmtlib/fmt/blob/5a493560f59369e9fa664e8945b8e8a8ec4391b2/include/fmt/core.h#L599):

// Don't check if the argument id is valid to avoid overhead and because it
// will be checked during formatting anyway.

I don't know what's the libc++'s policy to use assertions, but for me it's a good place to put a _LIBCPP_ASSERT.

350

Same as above, I'd expect at least an assertion in debug mode (in non-constexpr context).

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

65

I don't see why you can't test the first part of test_exception in constexpr context. Changing return type to bool and returning false/true where appropriate should be enough to make it work.
Obviously, the part with test_arg can't be tested there.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.pass.cpp

55

As above, but here you can test everything in constexpr context.

[curdeius]

libcxx/include/format

349

FYI, your implementation seems to be exactly what the author meant (std branch is missing in the main fmt repo):
https://github.com/agmt/fmt/blob/std/include/format#L181-L199

[Mordante]

libcxx/include/format

332

I didn't add a _LIBCPP_ASSERT since it indeed can be tested during formatting. If the index is out of bounds basic_format_args::get will return a default created basic_format_arg (http://eel.is/c++draft/format#args-4) This means the object has a std::monostate as value. In my WIP code I have a formatter for a std::monostate which will throw an exception.

I think it's better to throw an exception to inform the user about errors and I think it's not good to change that behaviour with debug macros. Note for other parts in my WIP code I use _LIBCPP_ASSERT to validate the expected state, but if they trigger it means the library code isn't robust enough.

@ldionne What do you think about the usage of _LIBCPP_ASSERT ?

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

65

I'm not entirely sure what you mean. The line context.next_arg_id(); will call __format::__throw_error which is not a constexpr function, turning it into one will fail with the following diagnostic error: constexpr function never produces a constant expression [-Winvalid-constexpr]. Can you explain what change you think should work.

I made the separate function test_exception for the parts which can't be tested as constexpr.

[curdeius]

Apart from the question whether adding assertion fits here, this LGTM.

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

65

You're completely right. I must have been confused when writing this:).

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.pass.cpp

55

Please ignore the above too.

[Mordante]

Replace a std:: with _VSTD::

[Mordante]

Update the synopsis after the changes in D92214.
Ran clang-format.
Rebased.

[Mordante]

Fix build breakage due to clang-format. In C++03 mode it breaks string prefixes like u8"foo".

[ldionne]

This LGTM, but I would prefer if we stuck to the current convention and used std::__throw_format_error instead. Not a blocking comment.

[Mordante]

In D93166#2528368, @ldionne wrote:

This LGTM, but I would prefer if we stuck to the current convention and used std::__throw_format_error instead. Not a blocking comment.

Thanks for the review! My diversion of the convention was up for discussion ;-) So I'll switch back to the convention and use std::__throw_format_error. I'll commit after it passes CI.

[Mordante]

Use __throw_format_error instead of __format::__throw__error.

[Mordante]

Rebase to trigger CI.

[mehdi_amini]

Reverted in 68f66f37d7d7 because of the build break mentioned inline, let me know if you need help to reproduce!

libcxx/include/format

347

We have a build breakage on bootstrapping clang here:

In file included from /var/lib/buildkite-agent/builds/buildkite-69fdf6c495-wt2bd-1/mlir/mlir-core/libcxx/src/format.cpp:9:
/tmp/ci-nGNyLRM9V3/include/c++/v1/format:153:16: error: no member named 'is_constant_evaluated' in namespace 'std::__1'
    if (_VSTD::is_constant_evaluated() && __id >= __num_args_)
        ~~~~~~~^
1 error generated.

See https://buildkite.com/mlir/mlir-core/builds/11261#3cc923a2-b03c-4f8b-a0f1-83d638fff493

[antiagainst]

Some additional information that might help: looks like std:: is_constant_evaluated is supported since Clang 9: https://clang.llvm.org/cxx_status.html

[Mordante]

In D93166#2534776, @antiagainst wrote:

Some additional information that might help: looks like std:: is_constant_evaluated is supported since Clang 9: https://clang.llvm.org/cxx_status.html

Thanks there's already a library macro to test whether it's available _LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED. But the we don't test with old compilers in C++20 mode.

[Mordante]

This should fix building with clang-8 which doesn't support
std::is_constant_evaluated().

@mehdi_amini Can you test whether this fixes the MLIR build?

[Mordante]

Rebase to trigger CI.

[Mordante]

Use concept support to disable <format> on older compilers. Note this is intended to be a temporary solution until libc++ requires a modern compiler.
Rebased.

[mehdi_amini]

I still see an error unfortunately:

In file included from /var/lib/buildkite-agent/builds/buildkite-69fdf6c495-8wxf7-1/mlir/mlir-core/libcxx/src/format.cpp:9:
/tmp/ci-6kGTAaqbDL/include/c++/v1/format:159:16: error: no member named 'is_constant_evaluated' in namespace 'std::__1'
    if (_VSTD::is_constant_evaluated() && __id >= __num_args_)
        ~~~~~~~^

[mehdi_amini]

Actually I see that you pushed a follow up fix? Kicked another build here: https://buildkite.com/mlir/mlir-core/builds/11503

[mehdi_amini]

Fails differently with the forward fix:

libcxx/src/format.cpp:15:1: error: use of undeclared identifier 'format_error'; did you mean 'domain_error'?
format_error::~format_error() noexcept = default;
^~~~~~~~~~~~
domain_error
/tmp/ci-yIcukneKik/include/c++/v1/stdexcept:122:29: note: 'domain_error' declared here
class _LIBCPP_EXCEPTION_ABI domain_error
                            ^
/var/lib/buildkite-agent/builds/buildkite-69fdf6c495-8wxf7-1/mlir/mlir-core/libcxx/src/format.cpp:15:16: error: expected the class name after '~' to name a destructor
format_error::~format_error() noexcept = default;
               ^~~~~~~~~~~~
               domain_error

[mehdi_amini]

And one more build with the most recent fix: https://buildkite.com/mlir/mlir-core/builds/11505

[Mordante]

It seems modifying the header and building libc++ doesn't rebuild the library. So it seemed to work for me. After I touched format.cpp I could reproduce the issue. Pushed another fix that works for me locally, but I'll keep an eye on the MLIR build server.

[mehdi_amini]

It passed the host phase :)

[Mordante]

The MLIR build is now green :-)

[mehdi_amini]

Thanks for checking on it! :)

libcxx/include/format

public:
     explicit format_error(const char* what_arg);
   };
 }
 
 */
 
 #include <__config>
 #include <stdexcept>
+#include <string_view>
 #include <version>
 
+#ifdef _LIBCPP_NO_EXCEPTIONS
+#include <cstdlib>
+#endif
+
 #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
 
 class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
 public:
   _LIBCPP_INLINE_VISIBILITY explicit format_error(const string& __s)
       : runtime_error(__s) {}
   _LIBCPP_INLINE_VISIBILITY explicit format_error(const char* __s)
       : runtime_error(__s) {}
   virtual ~format_error() noexcept;
 };
 
+namespace __format {
+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY void
+__throw_error(const char* __s) {
+#ifndef _LIBCPP_NO_EXCEPTIONS
+  throw format_error(__s);
+#else
+  (void)__s;
+  _VSTD::abort();
+#endif
+}
+} // namespace __format
+
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS basic_format_parse_context {
+public:
+  using char_type = _CharT;
+  using const_iterator =
+      typename _VSTD::basic_string_view<_CharT>::const_iterator;
+  using iterator = const_iterator;
+
+public:
+  _LIBCPP_INLINE_VISIBILITY
+  constexpr explicit basic_format_parse_context(
+      _VSTD::basic_string_view<_CharT> __fmt, size_t __num_args = 0) noexcept
+      : __begin_(__fmt.begin()),
+        __end_(__fmt.end()),
+        __indexing_(__unknown),
+        __next_arg_id_(0),
+        __num_args_(__num_args) {}
+
+  basic_format_parse_context(const basic_format_parse_context&) = delete;
+  basic_format_parse_context&
+  operator=(const basic_format_parse_context&) = delete;
+
+  _LIBCPP_INLINE_VISIBILITY constexpr const_iterator begin() const noexcept {
+    return __begin_;
+  }
+  _LIBCPP_INLINE_VISIBILITY constexpr const_iterator end() const noexcept {
+    return __end_;
+  }
+  _LIBCPP_INLINE_VISIBILITY constexpr void advance_to(const_iterator __it) {
+    __begin_ = __it;
+  }
+
+  _LIBCPP_INLINE_VISIBILITY constexpr size_t next_arg_id() {
+    if (__indexing_ == __manual)
+      __format::__throw_error("Using automatic argument numbering in manual "
+                              "argument numbering mode");
+
+    if (__indexing_ == __unknown)
+      __indexing_ = __automatic;
+    return __next_arg_id_++;
+  }
+  _LIBCPP_INLINE_VISIBILITY constexpr void check_arg_id(size_t __id) {
+    if (__indexing_ == __automatic)
+      __format::__throw_error("Using manual argument numbering in automatic "
+                              "argument numbering mode");
+
+    if (__indexing_ == __unknown)
+      __indexing_ = __manual;
+
+    if (std::is_constant_evaluated() && __id >= __num_args_)
+      __format::__throw_error("Argument index outside the valid range");
+  }
+
+private:
+  iterator __begin_;
+  iterator __end_;
+  enum _Indexing { __unknown, __manual, __automatic };
+  _Indexing __indexing_;
+  size_t __next_arg_id_;
+  size_t __num_args_;
+};
+
+using format_parse_context = basic_format_parse_context<char>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+
 #endif //_LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FORMAT

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.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
+
+// <format>
+
+// constexpr void advance_to(const_iterator it);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+constexpr void test(const CharT* fmt) {
+  {
+    std::basic_format_parse_context<CharT> context(fmt);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == &fmt[1]);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == &fmt[2]);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == context.end());
+  }
+  {
+    std::basic_string_view view{fmt};
+    std::basic_format_parse_context context(view);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == view.begin() + 1);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == view.begin() + 2);
+
+    context.advance_to(context.begin() + 1);
+    assert(context.begin() == context.end());
+  }
+}
+
+constexpr bool test() {
+  test("abc");
+  test(L"abc");
+  test(u8"abc");
+  test(u"abc");
+  test(U"abc");
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.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
+
+// <format>
+
+// constexpr begin() const noexcept;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+constexpr void test(const CharT* fmt) {
+  {
+    std::basic_format_parse_context<CharT> context(fmt);
+    assert(context.begin() == &fmt[0]);
+    ASSERT_NOEXCEPT(context.begin());
+  }
+  {
+    std::basic_string_view view{fmt};
+    std::basic_format_parse_context context(view);
+    assert(context.begin() == view.begin());
+    ASSERT_NOEXCEPT(context.begin());
+  }
+}
+
+constexpr bool test() {
+  test("abc");
+  test(L"abc");
+  test(u8"abc");
+  test(u"abc");
+  test(U"abc");
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-exceptions
+
+// constexpr void check_arg_id(size_t id);
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  std::format_parse_context context("", 10);
+  for (size_t i = 0; i < 10; ++i)
+    context.check_arg_id(i);
+
+  return true;
+}
+
+void test_exception() {
+  [] {
+    std::format_parse_context context("", 1);
+    context.next_arg_id();
+    try {
+      context.check_arg_id(0);
+      assert(false);
+    } catch (const std::format_error& e) {
+      assert(strcmp(e.what(), "Using manual argument numbering in automatic "
+                              "argument numbering mode") == 0);
+      return;
+    }
+    assert(false);
+  }();
+
+  auto test_arg = [](size_t num_args) {
+    std::format_parse_context context("", num_args);
+    // Out of bounds access is valid if !std::is_constant_evaluated()
+    for (size_t i = 0; i <= num_args; ++i)
+      context.check_arg_id(i);
+  };
+  for (size_t i = 0; i < 10; ++i)
+    test_arg(i);
+}
+
+int main(int, char**) {
+  test();
+  test_exception();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.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
+
+// <format>
+
+// constexpr explicit
+// basic_format_parse_context(basic_string_view<charT> fmt,
+//                            size_t num_args = 0) noexcept
+
+#include <format>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class CharT>
+constexpr void test(const CharT* fmt) {
+  static_assert(
+      !std::is_copy_constructible_v<std::basic_format_parse_context<CharT> >);
+  static_assert(
+      !std::is_copy_assignable_v<std::basic_format_parse_context<CharT> >);
+  // The move operations are implicitly deleted due to the
+  // deleted copy operations.
+  static_assert(
+      !std::is_move_constructible_v<std::basic_format_parse_context<CharT> >);
+  static_assert(
+      !std::is_move_assignable_v<std::basic_format_parse_context<CharT> >);
+
+  ASSERT_NOEXCEPT(
+      std::basic_format_parse_context{std::basic_string_view<CharT>{}});
+  ASSERT_NOEXCEPT(
+      std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
+
+  {
+    std::basic_format_parse_context<CharT> context(fmt);
+    assert(context.begin() == &fmt[0]);
+    assert(context.end() == &fmt[3]);
+  }
+  {
+    std::basic_string_view view{fmt};
+    std::basic_format_parse_context context(view);
+    assert(context.begin() == view.begin());
+    assert(context.end() == view.end());
+  }
+}
+
+constexpr bool test() {
+  test("abc");
+  test(L"abc");
+  test(u8"abc");
+  test(u"abc");
+  test(U"abc");
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.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
+
+// <format>
+
+// constexpr end() const noexcept;
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class CharT>
+constexpr void test(const CharT* fmt) {
+  {
+    std::basic_format_parse_context<CharT> context(fmt);
+    assert(context.end() == &fmt[3]);
+    ASSERT_NOEXCEPT(context.end());
+  }
+  {
+    std::basic_string_view view{fmt};
+    std::basic_format_parse_context context(view);
+    assert(context.end() == view.end());
+    ASSERT_NOEXCEPT(context.end());
+  }
+}
+
+constexpr bool test() {
+  test("abc");
+  test(L"abc");
+  test(u8"abc");
+  test(u"abc");
+  test(U"abc");
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.pass.cpp

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-exceptions
+
+// constexpr size_t next_arg_id();
+
+#include <format>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  std::format_parse_context context("");
+  for (size_t i = 0; i < 10; ++i)
+    assert(i == context.next_arg_id());
+
+  return true;
+}
+
+void test_exception() {
+  std::format_parse_context context("", 1);
+  context.check_arg_id(0);
+
+  try {
+    context.next_arg_id();
+    assert(false);
+  } catch (const std::format_error& e) {
+    assert(strcmp(e.what(), "Using automatic argument numbering in manual "
+                            "argument numbering mode") == 0);
+    return;
+  }
+  assert(false);
+}
+
+int main(int, char**) {
+  test();
+  test_exception();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <format>
+
+// Class typedefs:
+// template<class charT>
+// class basic_format_parse_context {
+// public:
+//   using char_type = charT;
+//   using const_iterator = typename basic_string_view<charT>::const_iterator;
+//   using iterator = const_iterator;
+// }
+//
+// Namespace std typedefs:
+// using format_parse_context = basic_format_parse_context<char>;
+// using wformat_parse_context = basic_format_parse_context<wchar_t>;
+
+#include <format>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class CharT>
+constexpr void test() {
+  static_assert(
+      std::is_same_v<typename std::basic_format_parse_context<CharT>::char_type,
+                     CharT>);
+  static_assert(std::is_same_v<
+                typename std::basic_format_parse_context<CharT>::const_iterator,
+                typename std::basic_string_view<CharT>::const_iterator>);
+  static_assert(
+      std::is_same_v<
+          typename std::basic_format_parse_context<CharT>::iterator,
+          typename std::basic_format_parse_context<CharT>::const_iterator>);
+}
+
+constexpr void test() {
+  test<char>();
+  test<wchar_t>();
+  test<char8_t>();
+  test<char16_t>();
+  test<char32_t>();
+}
+
+static_assert(std::is_same_v<std::format_parse_context,
+                             std::basic_format_parse_context<char> >);
+static_assert(std::is_same_v<std::wformat_parse_context,
+                             std::basic_format_parse_context<wchar_t> >);
+
+// Required for MSVC internal test runner compatibility.
+int main(int, char**) {
+  return 0;
+}