Make formatter specializations override implicit conversions

include/fmt/core.h

@@ -853,8 +853,8 @@ void make_value(const T*) {
 }
 
 template <typename C, typename T,
-          FMT_ENABLE_IF(convert_to_int<T, typename C::char_type>::value&&
-                            std::is_enum<T>::value)>
+          FMT_ENABLE_IF(std::is_enum<T>::value&&
+                            convert_to_int<T, typename C::char_type>::value)>
 inline init<C, int, int_type> make_value(const T& val) {
   return static_cast<int>(val);
 }
@@ -873,6 +873,14 @@ inline init<C, const T&, custom_type> make_value(const T& val) {
   return val;
 }
 
+template <typename C, typename T,
+          FMT_ENABLE_IF(std::is_class<T>::value&& std::is_convertible<
+                            T, int>::value&& is_formattable<T, C>::value &&
+                        !std::is_same<T, typename C::char_type>::value)>
+inline init<C, const T&, custom_type> make_value(const T& val) {
+  return val;
+}
+
 template <typename C, typename T>
 init<C, const void*, named_arg_type> make_value(
     const named_arg<T, typename C::char_type>& val) {

test/core-test.cc

@@ -442,6 +442,25 @@ TEST(CoreTest, ConvertToInt) {
   EXPECT_TRUE((fmt::convert_to_int<enum_with_underlying_type, char>::value));
 }
 
+struct convertible_to_int {
+  operator int() const { return 42; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<convertible_to_int> {
+  auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_int, format_context& ctx) -> decltype(ctx.out()) {
+    return std::copy_n("foo", 3, ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(CoreTest, FormatterOverridesImplicitConversion) {
+  EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
+}
+
 namespace my_ns {
 template <typename Char> class my_string {
  public: