[libc++][format] Fixes test failures.

[Mordante]

Summary

Using some builds the modular build fails due to missing exports
and includes. This fixes the build.

[ldionne]

Most of the additions seem correct, but I don't understand a few of them. I'd like to understand to make sure we're not just blindly adding includes to fix stuff (and to fix what?).

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

15–16 ↗

(On Diff #494372)

Why is this needed? What is this fixing?

libcxx/test/std/utilities/format/format.functions/ascii.pass.cpp

20 ↗

(On Diff #494372)

We're not using std::string here right? Why is this needed?

[Mordante]

Improves the fixes.

libcxx/include/module.modulemap.in

module __format {
       module format_arg_store                { private header "__format/format_arg_store.h" }
       module format_args                     { private header "__format/format_args.h" }
       module format_context {
         private header "__format/format_context.h"
         export optional
         export locale
       }
       module format_error                    { private header "__format/format_error.h" }
-      module format_functions                { private header "__format/format_functions.h" }
+      module format_functions                {
+        private header "__format/format_functions.h"
+        export string
+      }
       module format_fwd                      { private header "__format/format_fwd.h" }
       module format_parse_context            { private header "__format/format_parse_context.h" }
       module format_string                   { private header "__format/format_string.h" }
       module format_to_n_result {
         private header "__format/format_to_n_result.h"
         export iterator.__iterator.incrementable_traits
       }
       module formatter                       { private header "__format/formatter.h" }

libcxx/test/libcxx/utilities/format/format.formatter/format.context/types.compile.pass.cpp

 //   template<class T> using formatter_type = formatter<T, charT>;
 // }
 //
 // Namespace std typedefs:
 // using format_context = basic_format_context<unspecified, char>;
 // using wformat_context = basic_format_context<unspecified, wchar_t>;
 
 #include <format>
+#include <iterator>
 #include <string_view>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class OutIt, class CharT>
 constexpr void test() {
   static_assert(

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

 // RUN: %{cxx} %{flags} %{compile_flags} -funsigned-char -fsyntax-only %s
 
 // <format>
 
 // [format.arg]/5.2
 // - otherwise, if T is char and char_type is wchar_t, initializes value with static_cast<wchar_t>(v);
 
 #include <format>
+#include <iterator>
 #include <string>
 
 void test() {
   std::make_format_args<std::basic_format_context<
       std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>('c');
 }

libcxx/test/std/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp

 // This test requires the dylib support introduced in D92214.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
 
 // <format>
 
 // template<class Visitor, class Context>
 //   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 
+#include <algorithm>
 #include <format>
 #include <cassert>
 #include <type_traits>
 
 #include "constexpr_char_traits.h"
 #include "test_macros.h"
 #include "make_string.h"
 #include "min_allocator.h"

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/arg.pass.cpp

 //===----------------------------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // <format>
 
 // basic_format_arg<basic_format_context> arg(size_t id) const;
 
 #include <format>
+#include <iterator>
 #include <cassert>
 
 #include "test_basic_format_arg.h"
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 template <class OutIt, class CharT>

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.pass.cpp

 //                      basic_format_args<basic_format_context> args,
 //                      std::optional<std::::locale>&& loc = std::nullopt);
 // If compiled with -D_LIBCPP_HAS_NO_LOCALIZATION
 // basic_format_context(Out out,
 //                      basic_format_args<basic_format_context> args);
 
 #include <format>
 #include <cassert>
+#include <iterator>
 #include <type_traits>
 
 #include "test_basic_format_arg.h"
 #include "test_format_context.h"
 #include "test_iterators.h"
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
 #include "test_macros.h"

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.pass.cpp

 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.fr_FR.UTF-8
 
 // <format>
 
 // std::locale locale();
 
 #include <format>
+#include <iterator>
 #include <cassert>
 
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
 #include "test_basic_format_arg.h"
 #include "test_format_context.h"
 #include "test_macros.h"
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.handle.pass.cpp

 
 #include <format>
 
 #include <array>
 #include <cassert>
 #include <cmath>
 #include <charconv>
 #include <concepts>
+#include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 
 enum class color { black, red, gold };
 const char* color_names[] = {"black", "red", "gold"};

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.bool.pass.cpp

 // other than char, wchar_t, char8_t, char16_t, or char32_t, a specialization
 //    template<> struct formatter<ArithmeticT, charT>
 //
 // This file tests with `ArithmeticT = bool`, for each valid `charT`.
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.c_string.pass.cpp

 // enabled specializations:
 // For each `charT`, the string type specializations
 //   template<> struct formatter<charT*, charT>;
 //   template<> struct formatter<const charT*, charT>;
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char.pass.cpp

 // The specializations
 //   template<> struct formatter<char, char>;
 //   template<> struct formatter<char, wchar_t>;
 //   template<> struct formatter<wchar_t, wchar_t>;
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.char_array.pass.cpp

 // [format.functions]/25
 //   Preconditions: formatter<remove_cvref_t<Ti>, charT> meets the
 //   BasicFormatter requirements ([formatter.requirements]) for each Ti in
 //   Args.
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.const_char_array.pass.cpp

 // Each header that declares the template `formatter` provides the following
 // enabled specializations:
 // For each `charT`, the string type specializations
 //   template<size_t N> struct formatter<const charT[N], charT>;
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

 #include <format>
 
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <cmath>
 #include <charconv>
 #include <concepts>
+#include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp

 
 #include <format>
 
 #include <array>
 #include <cassert>
 #include <cmath>
 #include <charconv>
 #include <concepts>
+#include <iterator>
 #include <string>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

 // - int
 // - long
 // - long long
 // - __int128_t
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.string.pass.cpp

 //   template<class traits, class Allocator>
 //     struct formatter<basic_string<charT, traits, Allocator>, charT>;
 //   template<class traits>
 //     struct formatter<basic_string_view<charT, traits>, charT>;
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "make_string.h"
 #include "test_format_context.h"
 #include "test_macros.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.unsigned_integral.pass.cpp

 // - unsigned
 // - unsigned long
 // - unsigned long long
 // - __uint128_t
 
 #include <format>
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <type_traits>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define STR(S) MAKE_STRING(CharT, S)
 

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

 
 // <format>
 
 // constexpr void check_arg_id(size_t id);
 
 #include <format>
 
 #include <cassert>
+#include <cstring>
 #include <string_view>
 
 #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);
     TEST_IGNORE_NODISCARD context.next_arg_id();
     try {
       context.check_arg_id(0);
       assert(false);
     } catch ([[maybe_unused]] const std::format_error& e) {
-      LIBCPP_ASSERT(strcmp(e.what(), "Using manual argument numbering in automatic "
-                                     "argument numbering mode") == 0);
+      LIBCPP_ASSERT(std::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()

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

 
 // <format>
 
 // constexpr size_t next_arg_id();
 
 #include <format>
 
 #include <cassert>
+#include <cstring>
 #include <string_view>
 
 #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 {
     TEST_IGNORE_NODISCARD context.next_arg_id();
     assert(false);
   } catch ([[maybe_unused]] const std::format_error& e) {
-    LIBCPP_ASSERT(strcmp(e.what(), "Using automatic argument numbering in manual "
-                                   "argument numbering mode") == 0);
+    LIBCPP_ASSERT(std::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.functions/escaped_output.ascii.pass.cpp

 
 // <format>
 
 // This test the debug string type for the formatter specializations for char
 // and string types. This tests ASCII strings, the tests assume every char32_t value is valid ASCII.
 
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
 #include "make_string.h"
 #include "test_format_string.h"
 #include "assert_macros.h"
 

libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp

 
 // This test the debug string type for the formatter specializations for char
 // and string types. This tests Unicode strings.
 
 #include <format>
 
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
 #include "make_string.h"
 #include "test_format_string.h"
 #include "assert_macros.h"
 

libcxx/test/std/utilities/format/format.functions/format_to.locale.pass.cpp

 //                 format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, const locale& loc,
 //                 wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 #include "test_iterators.h"

libcxx/test/std/utilities/format/format.functions/format_to.pass.cpp

 // template<class Out, class... Args>
 //   Out format_to(Out out, format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   Out format_to(Out out, wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 #include "test_iterators.h"

libcxx/test/std/utilities/format/format.functions/format_to_n.pass.cpp

 //                                       format-string<Args...> fmt, const Args&... args);
 // template<class Out, class... Args>
 //   format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
 //                                       wformat-string<Args...> fmt, const Args&... args);
 
 #include <format>
 #include <algorithm>
 #include <cassert>
+#include <iterator>
 #include <list>
 #include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 #include "test_format_string.h"
 

libcxx/test/std/utilities/format/format.range/format.range.fmtmap/format.pass.cpp

 //     format(const T& ref, FormatContext& ctx) const;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format.functions test.
 
 #include <cassert>
 #include <concepts>
 #include <format>
+#include <iterator>
 #include <map>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 

libcxx/test/std/utilities/format/format.range/format.range.fmtset/format.pass.cpp

 //   typename FormatContext::iterator
 //     format(const T& ref, FormatContext& ctx) const;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format.functions test.
 
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <format>
 #include <set>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.range/format.range.formatter/format.functions.tests.h

 #include <array>
 #include <charconv>
 #include <concepts>
 #include <deque>
 #include <format>
 #include <list>
 #include <ranges>
 #include <span>
+#include <tuple>
 #include <vector>
 
 #include "format.functions.common.h"
 #include "make_string.h"
 #include "platform_support.h" // locale name macros
 #include "test_iterators.h"
 #include "test_macros.h"
 

libcxx/test/std/utilities/format/format.range/format.range.formatter/format.pass.cpp

 //   typename FormatContext::iterator
 //     format(const T& ref, FormatContext& ctx) const;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions test.
 
 #include <cassert>
 #include <concepts>
+#include <iterator>
 #include <format>
 #include <vector>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)

libcxx/test/std/utilities/format/format.range/format.range.formatter/set_brackets.pass.cpp

 // constexpr void constexpr void set_brackets(basic_string_view<charT> opening,
 //                                            basic_string_view<charT> closing);
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions test.
 
 #include <format>
 #include <cassert>
+#include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 

libcxx/test/std/utilities/format/format.range/format.range.formatter/set_separator.pass.cpp

 
 // constexpr void set_separator(basic_string_view<charT> sep);
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions test.
 
 #include <format>
 #include <cassert>
+#include <iterator>
 #include <type_traits>
 #include <vector>
 
 #include "make_string.h"
 #include "test_format_context.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)
 

libcxx/test/std/utilities/format/format.syn/format_to_n_result.pass.cpp

 // The class template format_to_n_result has the template parameters, data
 // members, and special members specified above. It has no base classes or
 // members other than those specified.
 
 #include <format>
 
 #include <cassert>
 #include <concepts>
+#include <iterator>
 
 #include "test_macros.h"
 
 template <class CharT>
 constexpr void test() {
   std::format_to_n_result<CharT*> v{nullptr, std::iter_difference_t<CharT*>{42}};
 
   auto [out, size] = v;

libcxx/test/std/utilities/format/format.tuple/format.functions.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_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
 #define TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
 
 #include <concepts>
 #include <format>
+#include <tuple>
 
 #include "format.functions.common.h"
 
 enum class color { black, red, gold };
 
 template <class CharT>
 struct std::formatter<color, CharT> : std::formatter<basic_string_view<CharT>, CharT> {
   static constexpr basic_string_view<CharT> color_names[] = {SV("black"), SV("red"), SV("gold")};

libcxx/test/std/utilities/format/format.tuple/format.pass.cpp

 //     format(see below& elems, FormatContext& ctx) const;
 
 // Note this tests the basics of this function. It's tested in more detail in
 // the format functions tests.
 
 #include <cassert>
 #include <concepts>
 #include <format>
+#include <iterator>
 #include <tuple>
 #include <utility>
 
 #include "test_format_context.h"
 #include "test_macros.h"
 #include "make_string.h"
 
 #define SV(S) MAKE_STRING_VIEW(CharT, S)