RTC_[D]CHECK_op: Remove superfluous casts

webrtc/base/safe_compare.h

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 127 matching lines @@
     }                                      \
   };
 RTC_SAFECMP_MAKE_OP(EqOp, ==)
 RTC_SAFECMP_MAKE_OP(NeOp, !=)
 RTC_SAFECMP_MAKE_OP(LtOp, <)
 RTC_SAFECMP_MAKE_OP(LeOp, <=)
 RTC_SAFECMP_MAKE_OP(GtOp, >)
 RTC_SAFECMP_MAKE_OP(GeOp, >=)
 #undef RTC_SAFECMP_MAKE_OP
 
+// Determines if the given type is an enum that converts implicitly to
+// an integral type.
+template <typename T>
+struct IsIntEnum {
+ private:
+  // This overload is used if the type is an enum, and unary plus
+  // compiles and turns it into an integral type.
+  template <typename X,
+            typename std::enable_if<
+                std::is_enum<X>::value &&
+                std::is_integral<decltype(+std::declval<X>())>::value>::type* =
+                nullptr>
+  static int Test(int);
+
+  // Otherwise, this overload is used.
+  template <typename>
+  static char Test(...);

[ossu, 2016/11/28 14:14:34]

I tried to find an answer to this, and clearly this isn't the case on any of our
current platforms, but could char and int be the same type? I guess they could
be the same size on some machine that only reads words, but would that also mean
they're the same type? If so, the check below would break down.

[kwiberg-webrtc, 2016/11/28 23:20:37]

Yes, they can be the same size, but I think they'd still be separate types. You
can run into problems on real systems today because long long and long, although
they're both 64 bits, aren't the same type. Example where the compiler is able
to tell them apart, even though they're both 64 bits:
https://godbolt.org/g/rVMNcI

[ossu, 2016/11/29 10:28:23]

Cool beans! Then I'm satisfied. :)

+
+ public:
+  static constexpr bool value =
+      std::is_same<decltype(Test<typename std::remove_reference<T>::type>(0)),
+                   int>::value;
+};
+
+// Determines if the given type is integral, or an enum that
+// converts implicitly to an integral type.
+template <typename T>
+struct IsIntlike {
+ private:
+  using X = typename std::remove_reference<T>::type;
+
+ public:
+  static constexpr bool value =
+      std::is_integral<X>::value || IsIntEnum<X>::value;
+};
+
+namespace test_enum_intlike {
+
+enum E1 { e1 };
+enum { e2 };
+enum class E3 { e3 };
+struct S {};
+
+static_assert(IsIntEnum<E1>::value, "");
+static_assert(IsIntEnum<decltype(e2)>::value, "");
+static_assert(!IsIntEnum<E3>::value, "");
+static_assert(!IsIntEnum<int>::value, "");
+static_assert(!IsIntEnum<float>::value, "");
+static_assert(!IsIntEnum<S>::value, "");
+
+static_assert(IsIntlike<E1>::value, "");
+static_assert(IsIntlike<decltype(e2)>::value, "");
+static_assert(!IsIntlike<E3>::value, "");
+static_assert(IsIntlike<int>::value, "");
+static_assert(!IsIntlike<float>::value, "");
+static_assert(!IsIntlike<S>::value, "");
+
+}  // test_enum_intlike
 }  // namespace safe_cmp_impl
 
-#define RTC_SAFECMP_MAKE_FUN(name)                                             \
-  template <                                                                   \
-      typename T1, typename T2,                                                \
-      typename std::enable_if<                                                 \
-          std::is_integral<typename std::remove_reference<T1>::type>::value && \
-          std::is_integral<typename std::remove_reference<T2>::type>::value>:: \
-          type* = nullptr>                                                     \
-  inline bool name(T1 a, T2 b) {                                               \
-    return safe_cmp_impl::Cmp<safe_cmp_impl::name##Op>(a, b);                  \
-  }                                                                            \
-  template <typename T1, typename T2,                                          \
-            typename std::enable_if<                                           \
-                !std::is_integral<                                             \
-                    typename std::remove_reference<T1>::type>::value ||        \
-                !std::is_integral<typename std::remove_reference<T2>::type>::  \
-                    value>::type* = nullptr>                                   \
-  inline bool name(T1&& a, T2&& b) {                                           \
-    return safe_cmp_impl::name##Op::Op(a, b);                                  \
+#define RTC_SAFECMP_MAKE_FUN(name)                                      \
+  template <typename T1, typename T2,                                   \
+            typename std::enable_if<                                    \
+                safe_cmp_impl::IsIntlike<T1>::value &&                  \
+                safe_cmp_impl::IsIntlike<T2>::value>::type* = nullptr>  \
+  inline bool name(T1 a, T2 b) {                                        \
+    /* Unary plus here turns enums into real integral types. */         \
+    return safe_cmp_impl::Cmp<safe_cmp_impl::name##Op>(+a, +b);         \
+  }                                                                     \
+  template <typename T1, typename T2,                                   \
+            typename std::enable_if<                                    \
+                !safe_cmp_impl::IsIntlike<T1>::value ||                 \
+                !safe_cmp_impl::IsIntlike<T2>::value>::type* = nullptr> \
+  inline bool name(T1&& a, T2&& b) {                                    \
+    return safe_cmp_impl::name##Op::Op(a, b);                           \
   }
 RTC_SAFECMP_MAKE_FUN(Eq)
 RTC_SAFECMP_MAKE_FUN(Ne)
 RTC_SAFECMP_MAKE_FUN(Lt)
 RTC_SAFECMP_MAKE_FUN(Le)
 RTC_SAFECMP_MAKE_FUN(Gt)
 RTC_SAFECMP_MAKE_FUN(Ge)
 #undef RTC_SAFECMP_MAKE_FUN
 
 }  // namespace safe_cmp
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_SAFE_COMPARE_H_