[Support][NFC] Improve isa implementation

[dmitry]

Summary

This patch aimed to enhance isa utility by making it more generic and reducing code duplication in its implementation in the same time. It extends isa<T>(value) so that isa works with any dereferenceable and implicitly convertible to bool values (i.e. fancy pointer-like types). It supposed to be a part of the following changes that I propose:

Generalize semantics of isa, cast, dyn_cast to any pointer-like types (i.e. dereferenceable and implicitly convertible to bool) so that:

• for each fancy_pointer<T> t: isa<G>(t) returns true iff current implementation of isa<G>(nonfancy_t) returns true where decltype(nonfancy_t) is T*
• all old cast operations should return a raw pointer of type typename std::pointer_traits<fancy_pointer<T>>::element_type * and do not perform ownership transfer.
• move_[dyn_]cast should do what unique_dyn_cast [ab480f45cd23c08cb9aa3f427aad072df249135f] is currently doing in a more generic manner: it move constructs an object of type typename std::pointer_traits<fancy_pointer<T>>::rebind<G>

N.B. the reference to std::pointer_traits is a conception that was used to explain the behaviour - not necessary the way it would be implemented.

[dmitry]

ping

[dmitry]

Removed dereferenced_type specialization for non-dereferenceable type. Thus we could use detection idiom (e.g. std::experimental:: detected_or) with it in future.

[dblaikie]

unittests/Support/Casting.cpp

288–289

Does this change then mean that one could cast<T> from Optional<Derived> to Optional<Base>? Because that'd be problematic, owing to Optional being a value-type. (it'd slice the object)

[dmitry]

unittests/Support/Casting.cpp

288–289

This change doesn't modify casts behavior - just isa.
As for the plan, cast should return T*, so

Optional<Derived> DOpt;
Base *b = cast<Base>(DOpt); //Just cast pointer to underlying data to Base*, does not handle potential ownership issues.

should work, but it's ok.
Move cast would be indeed problematic for value-types. So I would probably restrict it.

include/llvm/Support/Casting.h

 
 /// \brief Always allow upcasts, and perform no dynamic check for them.
 template <typename To, typename From>
 struct isa_impl<
     To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
   static inline bool doit(const From &) { return true; }
 };
 
-template <typename To, typename From> struct isa_impl_cl {
-  static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
-  }
-};
+template <typename To, typename From, typename = void> struct isa_impl_cl {};
 
-template <typename To, typename From> struct isa_impl_cl<To, const From> {
+template <typename To, typename From>
+struct isa_impl_cl<To, From,
+                   enable_if_t<!is_dereferenceable<From>::value>> {
+  using FromTy = typename std::remove_const<From>::type;
   static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
+    return isa_impl<To, FromTy>::doit(Val);
   }
 };
 
 template <typename To, typename From>
-struct isa_impl_cl<To, const std::unique_ptr<From>> {
-  static inline bool doit(const std::unique_ptr<From> &Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl_cl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, From*> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, From*const> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, const From*> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
-  static inline bool doit(const From *Val) {
+struct isa_impl_cl<To, From, enable_if_t<is_dereferenceable<From>::value>> {
+  using FromTy =
+      typename std::remove_const<dereferenced_type_t<From>>::type;
+  static inline bool doit(const From &Val) {
     assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
+    return isa_impl<To, FromTy>::doit(*Val);
   }
 };
 
 template<typename To, typename From, typename SimpleFrom>
 struct isa_impl_wrap {
   // When From != SimplifiedType, we can simplify the type some more by using
   // the simplify_type template.
   static bool doit(const From &Val) {

include/llvm/Support/type_traits.h

struct const_pointer_or_const_ref {
   using type = const T &;
 };
 template <typename T>
 struct const_pointer_or_const_ref<
     T, typename std::enable_if<std::is_pointer<T>::value>::type> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
+template <typename T, typename = decltype((void)*std::declval<T>(),
+                                          (void)(std::declval<T>() && true))>
+std::true_type is_dereferenceable_test(const T &);
+std::false_type is_dereferenceable_test(...);
+
+template <typename T>
+using is_dereferenceable = decltype(is_dereferenceable_test(std::declval<T>()));
+
+template <bool Cond>
+using enable_if_t = typename std::enable_if<Cond>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <typename F, typename = void> struct dereferenced_type;
+
+template <typename F>
+struct dereferenced_type<F, enable_if_t<is_dereferenceable<F>::value>> {
+  using type = decay_t<decltype(*std::declval<F>())>;
+};
+
+template <typename F>
+using dereferenced_type_t = typename dereferenced_type<F>::type;
+
 } // end namespace llvm
 
 // If the compiler supports detecting whether a class is final, define
 // an LLVM_IS_FINAL macro. If it cannot be defined properly, this
 // macro will be left undefined.
 #if __cplusplus >= 201402L
 #define LLVM_IS_FINAL(Ty) std::is_final<Ty>()
 #elif __has_feature(is_final) || LLVM_GNUC_PREREQ(4, 7, 0)
 #define LLVM_IS_FINAL(Ty) __is_final(Ty)
 #endif
 
 #ifdef LLVM_DEFINED_HAS_FEATURE
 #undef __has_feature
 #endif
 
 #endif // LLVM_SUPPORT_TYPE_TRAITS_H

unittests/Support/Casting.cpp

 //===---------- llvm/unittest/Support/Casting.cpp - Casting tests ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Casting.h"
 #include "llvm/IR/User.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/ADT/Optional.h"
 #include "gtest/gtest.h"
 #include <cstdlib>
 
 namespace llvm {
 // Used to test illegal cast. If a cast doesn't match any of the "real" ones,
 // it will match this one.
 struct IllegalCast;
 template <typename T> IllegalCast *cast(...) { return nullptr; }

 // Derived to its base class.
 TEST(CastingTest, UpcastIsInferred) {
   Derived D;
   EXPECT_TRUE(isa<Base>(D));
   Base *BP = dyn_cast<Base>(&D);
   EXPECT_TRUE(BP != nullptr);
 }
 
+TEST(CastingTest, DereferencableIsA) {
+  std::shared_ptr<Derived> DShared = std::make_shared<Derived>();
+  EXPECT_TRUE(isa<Base>(DShared));
+  llvm::Optional<Derived> DOpt;
+  EXPECT_TRUE(isa<Base>(DOpt));
+}
 
 // This test verifies that the inferred upcast takes precedence over an
 // explicitly written one. This is important because it verifies that the
 // dynamic check gets optimized away.
 class UseInferredUpcast {
 public:
   int Dummy;
   static bool classof(const UseInferredUpcast *) {