Improve internal lossless_cast to work on pointers (facebook#13648)

Summary:
I was going to use this in some code I was working on but ended up not needing it. But it's useful nonetheless and I'm using it in a few places to replace reinterpret_cast.

Pull Request resolved: facebook#13648

Test Plan: existing tests, manually see compilation fail when pointed-to types are not same size integral types

Reviewed By: cbi42

Differential Revision: D75576195

Pulled By: pdillinger

fbshipit-source-id: e10c7a4959340f6f2b536de8088072a90e871fcf

Author: pdillinger

util/cast_util.h

@@ -39,19 +39,30 @@ inline std::shared_ptr<DestClass> static_cast_with_check(
 }
 
 // A wrapper around static_cast for lossless conversion between integral
-// types, including enum types. For example, this can be used for converting
-// between signed/unsigned or enum type and underlying type without fear of
-// stripping away data, now or in the future.
+// types, including enum types, and pointers to such types. For example, this
+// can be used for converting between signed/unsigned or enum type and
+// underlying type without fear of stripping away data, now or in the future.
 template <typename To, typename From>
 inline To lossless_cast(From x) {
-  using FromValue = typename std::remove_reference<From>::type;
-  static_assert(
-      std::is_integral<FromValue>::value || std::is_enum<FromValue>::value,
-      "Only works on integral types");
-  static_assert(std::is_integral<To>::value || std::is_enum<To>::value,
-                "Only works on integral types");
-  static_assert(sizeof(To) >= sizeof(FromValue), "Must be lossless");
-  return static_cast<To>(x);
+  using FromValue = typename std::remove_reference_t<From>;
+  if constexpr (std::is_pointer_v<FromValue>) {
+    static_assert(std::is_pointer_v<To>);
+    using FromDeref = typename std::remove_pointer_t<FromValue>;
+    using ToDeref = typename std::remove_pointer_t<To>;
+    static_assert(std::is_integral_v<FromDeref> || std::is_enum_v<FromDeref>,
+                  "Only works on integral types");
+    static_assert(std::is_integral_v<ToDeref> || std::is_enum_v<To>,
+                  "Only works on integral types");
+    static_assert(sizeof(ToDeref) == sizeof(FromDeref), "Must be lossless");
+    return reinterpret_cast<To>(x);
+  } else {
+    static_assert(std::is_integral_v<FromValue> || std::is_enum_v<FromValue>,
+                  "Only works on integral types");
+    static_assert(std::is_integral_v<To> || std::is_enum_v<To>,
+                  "Only works on integral types");
+    static_assert(sizeof(To) >= sizeof(FromValue), "Must be lossless");
+    return static_cast<To>(x);
+  }
 }
 
 // For disambiguating a potentially heterogeneous aggregate as a homogeneous

util/coding.h

@@ -21,6 +21,7 @@
 
 #include "port/port.h"
 #include "rocksdb/slice.h"
+#include "util/cast_util.h"
 #include "util/coding_lean.h"
 
 // Some processors does not allow unaligned access to memory
@@ -105,7 +106,7 @@ const char* GetVarint32PtrFallback(const char* p, const char* limit,
 inline const char* GetVarint32Ptr(const char* p, const char* limit,
                                   uint32_t* value) {
   if (p < limit) {
-    uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
+    uint32_t result = *(lossless_cast<const unsigned char*>(p));
     if ((result & 128) == 0) {
       *value = result;
       return p + 1;
@@ -172,13 +173,13 @@ inline void PutVarint32Varint32Varint32(std::string* dst, uint32_t v1,
 
 inline char* EncodeVarint64(char* dst, uint64_t v) {
   static const unsigned int B = 128;
-  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
+  unsigned char* ptr = lossless_cast<unsigned char*>(dst);
   while (v >= B) {
     *(ptr++) = (v & (B - 1)) | B;
     v >>= 7;
   }
   *(ptr++) = static_cast<unsigned char>(v);
-  return reinterpret_cast<char*>(ptr);
+  return lossless_cast<char*>(ptr);
 }
 
 inline void PutVarint64(std::string* dst, uint64_t v) {