Move std::byte formatter to std.h

include/fmt/format-inl.h

@@ -9,6 +9,8 @@
 #define FMT_FORMAT_INL_H_
 
 #ifndef FMT_MODULE
+#  include <stddef.h>  // ptrdiff_t
+
 #  include <algorithm>
 #  include <cerrno>  // errno
 #  include <climits>

include/fmt/format.h

@@ -51,9 +51,8 @@
 #  include <stdlib.h>  // malloc, free
 #  include <string.h>  // memcpy
 
-#  include <cmath>    // std::signbit
-#  include <cstddef>  // std::byte
-#  include <limits>   // std::numeric_limits
+#  include <cmath>   // std::signbit
+#  include <limits>  // std::numeric_limits
 #  if defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI)
 // Workaround for pre gcc 5 libstdc++.
 #    include <memory>  // std::allocator_traits
@@ -4069,19 +4068,6 @@ constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> {
 }
 }  // namespace enums
 
-#ifdef __cpp_lib_byte
-template <typename Char>
-struct formatter<std::byte, Char> : formatter<unsigned, Char> {
-  static auto format_as(std::byte b) -> unsigned char {
-    return static_cast<unsigned char>(b);
-  }
-  template <typename Context>
-  auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) {
-    return formatter<unsigned, Char>::format(format_as(b), ctx);
-  }
-};
-#endif
-
 struct bytes {
   string_view data;
 

include/fmt/std.h

@@ -15,7 +15,8 @@
 #  include <atomic>
 #  include <bitset>
 #  include <complex>
-#  include <exception>
+#  include <cstddef>     // std::byte
+#  include <exception>   // std::exception
 #  include <functional>  // std::reference_wrapper
 #  include <memory>
 #  include <thread>
@@ -666,6 +667,19 @@ struct formatter<BitRef, Char,
   }
 };
 
+#ifdef __cpp_lib_byte
+template <typename Char>
+struct formatter<std::byte, Char> : formatter<unsigned, Char> {
+  static auto format_as(std::byte b) -> unsigned char {
+    return static_cast<unsigned char>(b);
+  }
+  template <typename Context>
+  auto format(std::byte b, Context& ctx) const -> decltype(ctx.out()) {
+    return formatter<unsigned, Char>::format(format_as(b), ctx);
+  }
+};
+#endif
+
 template <typename T, typename Char>
 struct formatter<std::atomic<T>, Char,
                  enable_if_t<is_formattable<T, Char>::value>>

test/compile-test.cc

@@ -75,9 +75,6 @@ TEST(compile_test, format_default) {
   EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
   auto t = std::chrono::system_clock::now();
   EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
-#  ifdef __cpp_lib_byte
-  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
-#  endif
 }
 
 TEST(compile_test, format_escape) {

test/format-test.cc

@@ -2611,14 +2611,6 @@ TEST(format_test, invalid_glibc_buffer) {
 }
 #endif  // FMT_USE_FCNTL
 
-#ifdef __cpp_lib_byte
-TEST(base_test, format_byte) {
-  auto s = std::string();
-  fmt::format_to(std::back_inserter(s), "{}", std::byte(42));
-  EXPECT_EQ(s, "42");
-}
-#endif
-
 // Only defined after the test case.
 struct incomplete_type;
 extern const incomplete_type& external_instance;

test/ranges-test.cc

@@ -395,13 +395,6 @@ TEST(ranges_test, join) {
   EXPECT_EQ(fmt::format("{}", join(v4, " ")), "0 1 0");
 }
 
-#ifdef __cpp_lib_byte
-TEST(ranges_test, join_bytes) {
-  auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)};
-  EXPECT_EQ(fmt::format("{}", fmt::join(v, ", ")), "1, 2, 3");
-}
-#endif
-
 TEST(ranges_test, join_tuple) {
   // Value tuple args.
   auto t1 = std::tuple<char, int, float>('a', 1, 2.0f);

test/std-test.cc

@@ -460,6 +460,14 @@ TEST(std_test, format_bitset) {
   EXPECT_EQ(fmt::format("{:-^12}", bs), "---101010---");
 }
 
+#ifdef __cpp_lib_byte
+TEST(base_test, format_byte) {
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), "{}", std::byte(42));
+  EXPECT_EQ(s, "42");
+}
+#endif
+
 TEST(std_test, format_atomic) {
   std::atomic<bool> b(false);
   EXPECT_EQ(fmt::format("{}", b), "false");