From a93270fd60567b6dca7666266c6cc5811bf90ad6 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Mon, 22 Jan 2018 18:56:53 -0800
Subject: [PATCH] Replace a bunch of craft with type_traits, take 2

---
 include/fmt/core.h    | 29 ++---------------------------
 include/fmt/ostream.h | 33 +++++++++++++++++++--------------
 test/util-test.cc     |  6 +++---
 3 files changed, 24 insertions(+), 44 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index a73fa829..561c1b86 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -338,36 +338,11 @@ inline void require_wchar() {
       "formatting of wide characters into a narrow output is disallowed");
 }
 
-using yes = char[1];
-using no = char[2];
-
-yes &convert(unsigned long long);
-no &convert(...);
-
-template<typename T, bool ENABLE_CONVERSION>
-struct convert_to_int_impl {
-  enum { value = ENABLE_CONVERSION };
-};
-
-template<typename T, bool ENABLE_CONVERSION>
-struct convert_to_int_impl2 {
-  enum { value = false };
-};
-
-template<typename T>
-struct convert_to_int_impl2<T, true> {
-  enum {
-    // Don't convert arithmetic types.
-    value = convert_to_int_impl<T, !std::is_arithmetic<T>::value>::value
-  };
-};
-
-template<typename T>
+template <typename T, bool ENABLE = true>
 struct convert_to_int {
   enum {
-    enable_conversion = sizeof(convert(std::declval<T>())) == sizeof(yes)
+   value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
   };
-  enum { value = convert_to_int_impl2<T, enable_conversion>::value };
 };
 
 #define FMT_DISABLE_CONVERSION_TO_INT(Type) \
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 09b85608..b24d026d 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -47,23 +47,28 @@ class FormatBuf : public std::basic_streambuf<Char> {
   }
 };
 
-yes &convert(std::ostream &);
-
-struct DummyStream : std::ostream {
-  DummyStream();  // Suppress a bogus warning in MSVC.
-  // Hide all operator<< overloads from std::ostream.
-  void operator<<(null<>);
+struct test_stream : std::ostream {
+ private:
+  struct null;
+  // Hide all operator<< from std::ostream.
+  void operator<<(null);
 };
 
-no &operator<<(std::ostream &, int);
+// Disable conversion to int if T has an overloaded operator<< which is a free
+// function (not a member of std::ostream).
+template <typename T>
+class convert_to_int<T, true> {
+ private:
+  template <typename U>
+  static decltype(
+    std::declval<test_stream&>() << std::declval<U>(), std::true_type())
+      test(int);
 
-template<typename T>
-struct convert_to_int_impl<T, true> {
-  // Convert to int only if T doesn't have an overloaded operator<<.
-  enum {
-    value = sizeof(convert(std::declval<DummyStream&>() << std::declval<T>()))
-            == sizeof(no)
-  };
+  template <typename>
+  static std::false_type test(...);
+
+ public:
+  static const bool value = !decltype(test<T>(0))::value;
 };
 
 // Write the content of buf to os.
diff --git a/test/util-test.cc b/test/util-test.cc
index 65d8e5f8..4f4f04c7 100644
--- a/test/util-test.cc
+++ b/test/util-test.cc
@@ -827,15 +827,15 @@ TEST(UtilTest, ReportWindowsError) {
 enum TestEnum2 {};
 
 TEST(UtilTest, ConvertToInt) {
-  EXPECT_TRUE(fmt::internal::convert_to_int<char>::enable_conversion);
-  EXPECT_FALSE(fmt::internal::convert_to_int<const char *>::enable_conversion);
+  EXPECT_FALSE(fmt::internal::convert_to_int<char>::value);
+  EXPECT_FALSE(fmt::internal::convert_to_int<const char *>::value);
   EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum2>::value);
 }
 
 #if FMT_USE_ENUM_BASE
 enum TestEnum : char {TestValue};
 TEST(UtilTest, IsEnumConvertibleToInt) {
-  EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum>::enable_conversion);
+  EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum>::value);
 }
 #endif