Add compile-time checks to color formatting

include/fmt/color.h

@@ -492,12 +492,10 @@ inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
                "Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args,
+template <typename... T>
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, format_string<T...> fmt,
-void print(std::FILE* f, const text_style& ts, const S& format_str,
+           T&&... args) {
-           const Args&... args) {
+  vprint(f, ts, fmt, fmt::make_format_args(args...));
-  vprint(f, ts, format_str,
-         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }
 
 /**
@@ -511,19 +509,15 @@ void print(std::FILE* f, const text_style& ts, const S& format_str,
                "Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-template <typename S, typename... Args,
+template <typename... T>
-          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, format_string<T...> fmt, T&&... args) {
-void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, fmt, std::forward<T>(args)...);
-  return print(stdout, ts, format_str, args...);
 }
 
-template <typename S, typename Char = char_t<S>>
+inline auto vformat(const text_style& ts, string_view fmt, format_args args)
-inline auto vformat(
+    -> std::string {
-    const text_style& ts, const S& format_str,
+  auto buf = memory_buffer();
-    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+  detail::vformat_to(buf, ts, fmt, args);
-    -> std::basic_string<Char> {
-  basic_memory_buffer<Char> buf;
-  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
   return fmt::to_string(buf);
 }
 
@@ -539,24 +533,21 @@ inline auto vformat(
                                       "The answer is {}", 42);
   \endrst
 */
-template <typename S, typename... Args, typename Char = char_t<S>>
+template <typename... T>
-inline auto format(const text_style& ts, const S& format_str,
+inline auto format(const text_style& ts, format_string<T...> fmt, T&&... args)
-                   const Args&... args) -> std::basic_string<Char> {
+    -> std::string {
-  return fmt::vformat(ts, detail::to_string_view(format_str),
+  return fmt::vformat(ts, fmt, fmt::make_format_args(args...));
-                      fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
 /**
   Formats a string with the given text_style and writes the output to ``out``.
  */
-template <typename OutputIt, typename Char,
+template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, const text_style& ts,
+auto vformat_to(OutputIt out, const text_style& ts, string_view fmt,
-                basic_string_view<Char> format_str,
+                format_args args) -> OutputIt {
-                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+  auto&& buf = detail::get_buffer<char>(out);
-    -> OutputIt {
+  detail::vformat_to(buf, ts, fmt, args);
-  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, ts, format_str, args);
   return detail::get_iterator(buf, out);
 }
 
@@ -572,15 +563,11 @@ auto vformat_to(OutputIt out, const text_style& ts,
                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
   \endrst
 */
-template <
+template <typename OutputIt, typename... T,
-    typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
+inline auto format_to(OutputIt out, const text_style& ts,
-                  detail::is_string<S>::value>
+                      format_string<T...> fmt, T&&... args) -> OutputIt {
-inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+  return vformat_to(out, ts, fmt, fmt::make_format_args(args...));
-                      Args&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, ts, detail::to_string_view(format_str),
-                    fmt::make_format_args<buffer_context<char_t<S>>>(args...));
 }
 
 template <typename T, typename Char>

include/fmt/core.h

@@ -570,12 +570,9 @@ template <> struct is_char<char> : std::true_type {};
 
 namespace detail {
 
-// A base class for compile-time strings.
+// Constructs fmt::basic_string_view<Char> from types **implicitly** convertible
-struct compile_string {};
+// to it, deducing Char. Explicitly convertible types such as compile-time
-
+// strings are intentionally excluded.
-template <typename S>
-struct is_compile_string : std::is_base_of<compile_string, S> {};
-
 template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
 FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
   return s;
@@ -583,25 +580,20 @@ FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
 template <typename S, FMT_ENABLE_IF(is_string_like<S>::value)>
 inline auto to_string_view(const S& s)
     -> basic_string_view<typename S::value_type> {
-  return s;  // std::basic_string[_view]
+  return s;
 }
 template <typename Char>
 constexpr auto to_string_view(basic_string_view<Char> s)
     -> basic_string_view<Char> {
   return s;
 }
-template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
-constexpr auto to_string_view(const S& s)
-    -> basic_string_view<typename S::char_type> {
-  return basic_string_view<typename S::char_type>(s);
-}
 void to_string_view(...);
 
 // Specifies whether S is a string type convertible to fmt::basic_string_view.
 // It should be a constexpr function but MSVC 2017 fails to compile it in
 // enable_if and MSVC 2015 fails to compile it as an alias template.
 // ADL is intentionally disabled as to_string_view is not an extension point.
-template <typename S>
+template <typename S, typename = void>
 struct is_string
     : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {};
 
@@ -2673,6 +2665,12 @@ template <typename Char, typename... Args> class format_string_checker {
   }
 };
 
+// A base class for compile-time strings.
+struct compile_string {};
+
+template <typename S>
+using is_compile_string = std::is_base_of<compile_string, S>;
+
 // Reports a compile-time error if S is not a valid format string.
 template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
 FMT_INLINE void check_format_string(const S&) {
@@ -2754,9 +2752,12 @@ template <typename Char, typename... Args> class basic_format_string {
   basic_string_view<Char> str_;
 
  public:
-  template <typename S,
+  template <
-            FMT_ENABLE_IF(
+      typename S,
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
+      FMT_ENABLE_IF(
+          std::is_convertible<const S&, basic_string_view<Char>>::value ||
+          (detail::is_compile_string<S>::value &&
+           std::is_constructible<basic_string_view<Char>, const S&>::value))>
   FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) {
     static_assert(
         detail::count<

include/fmt/xchar.h

@@ -10,6 +10,7 @@
 
 #include <cwchar>
 
+#include "color.h"
 #include "format.h"
 #include "ranges.h"
 
@@ -29,6 +30,17 @@ enum char8_type : unsigned char {};
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
 
+template <typename S, typename = void>
+struct format_string_char : char_t_impl<S> {};
+
+template <typename S>
+struct format_string_char<S, enable_if_t<is_compile_string<S>::value>> {
+  using type = typename S::char_type;
+};
+
+template <typename S>
+using format_string_char_t = typename format_string_char<S>::type;
+
 inline auto write_loc(back_insert_iterator<detail::buffer<wchar_t>> out,
                       loc_value value, const format_specs<wchar_t>& specs,
                       locale_ref loc) -> bool {
@@ -125,7 +137,8 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
 
 // Pass char_t as a default template parameter instead of using
 // std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... T, typename Char = char_t<S>,
+template <typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
                         !std::is_same<Char, wchar_t>::value)>
 auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
@@ -133,7 +146,8 @@ auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
                  fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename Locale, typename S, typename Char = char_t<S>,
+template <typename Locale, typename S,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto vformat(
@@ -143,7 +157,8 @@ inline auto vformat(
   return detail::vformat(loc, detail::to_string_view(format_str), args);
 }
 
-template <typename Locale, typename S, typename... T, typename Char = char_t<S>,
+template <typename Locale, typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto format(const Locale& loc, const S& format_str, T&&... args)
@@ -152,7 +167,8 @@ inline auto format(const Locale& loc, const S& format_str, T&&... args)
                          fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename OutputIt, typename S, typename Char = char_t<S>,
+template <typename OutputIt, typename S,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
 auto vformat_to(OutputIt out, const S& format_str,
@@ -164,7 +180,7 @@ auto vformat_to(OutputIt out, const S& format_str,
 }
 
 template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
@@ -173,7 +189,7 @@ inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
 }
 
 template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_locale<Locale>::value&&
                                 detail::is_exotic_char<Char>::value)>
@@ -187,7 +203,7 @@ inline auto vformat_to(
 }
 
 template <typename OutputIt, typename Locale, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
                         detail::is_locale<Locale>::value &&
                         detail::is_exotic_char<Char>::value>
@@ -212,16 +228,17 @@ inline auto vformat_to_n(
 }
 
 template <typename OutputIt, typename S, typename... T,
-          typename Char = char_t<S>,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
                             detail::is_exotic_char<Char>::value)>
 inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
     -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, detail::to_string_view(fmt),
+  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
                       fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
-template <typename S, typename... T, typename Char = char_t<S>,
+template <typename S, typename... T,
+          typename Char = detail::format_string_char_t<S>,
           FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
 inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
   auto buf = detail::counting_buffer<Char>();
@@ -260,6 +277,30 @@ template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
   return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
 }
 
+inline auto vformat(const text_style& ts, wstring_view fmt, wformat_args args)
+    -> std::wstring {
+  auto buf = wmemory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  return fmt::to_string(buf);
+}
+
+template <typename... T>
+inline auto format(const text_style& ts, wformat_string<T...> fmt, T&&... args)
+    -> std::wstring {
+  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
+}
+
+template <typename... T>
+void print(std::FILE* f, const text_style& ts, wformat_string<T...> fmt,
+           const T&... args) {
+  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
+}
+
+template <typename... T>
+void print(const text_style& ts, wformat_string<T...> fmt, const T&... args) {
+  return print(stdout, ts, fmt, args...);
+}
+
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */