Add support for unique_ptr<T> to dyn_cast<>

[zturner]

Summary

Currently it's possible to take a T* and cast it to a U* using llvm's casting mechanics, but it's not possible to take a std::unique_ptr<T> and cast it to a std::unique_ptr<U> even if they are compatible. This patch adds this functionality.

I tried to modify the cast macros as well as the dyn_cast macros, but honestly the template mechanics started getting a little hairy and I wasn't able to get it working. Upon further reflection, I decided that maybe we don't even want that behavior anyway, since if T is not a U, then no good can possibly come of casting it to one in the face of unique_ptr's RAII semantics. So hopefully I can get this in without adding cast<>() functionality, and then if/when someone actually needs cast functionality in the future, they can revisit this.

[zturner]

Discussed this with rsmith@ some, and we came to the conclusion that it's actually the other way around. We should support this only for cast, and not for dyn_cast. The reason being that you would need to declare the function as dyn_cast(unique_ptr<T> &&Value), and so to invoke it you would need to write dyn_cast<To>(std::move(From)). So even though you're writing this as an unconditional move, it's actually a conditional move, because if it's not actually convertible to To then you would want to return nullptr and leave the source unchanged. The code would still work, but it would just be confusing because std::move(From) sometimes doesn't actually move anything.

This patch removes the implementation of dyn_cast<> and adds a version of cast<> which has expected semantics. It moves unconditionally, and just asserts if it's the wrong type.

[chandlerc]

LGTM from me, and thanks for the update around dyn_cast. Maybe wait for Mehdi or some second pair of eyes just to be sure I'm not missing anything.

[zturner]

Updated this so that isa<B>(const unique_ptr<A>&) works. Will commit tomorrow afternoon if nobody has objections.

llvm/include/llvm/Support/Casting.h

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
+#include <memory>
 
 namespace llvm {
 

   }
 };
 
+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");

   typedef const To* ret_type;   // Constant pointer arg case, return const Ty*
 };
 
+template <class To, class From>
+struct cast_retty_impl<To, std::unique_ptr<From>> {
+private:
+  typedef typename cast_retty_impl<To, From *>::ret_type PointerType;
+  typedef typename std::remove_pointer<PointerType>::type ResultType;
+
+public:
+  typedef std::unique_ptr<ResultType> ret_type;
+};
 
 template<class To, class From, class SimpleFrom>
 struct cast_retty_wrap {

                           typename simplify_type<Y*>::SimpleType>::doit(Val);
 }
 
+template <class X, class Y>
+inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
+cast(std::unique_ptr<Y> &&Val) {
+  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");
+  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
+  return ret_type(
+      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
+          Val.release()));
+}
+
 // cast_or_null<X> - Functionally identical to cast, except that a null value is
 // accepted.
 //

   return cast<X>(Val);
 }
 
+template <class X, class Y>
+inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
+cast_or_null(std::unique_ptr<Y> &&Val) {
+  if (!Val)
+    return nullptr;
+  return cast<X>(std::move(Val));
+}
 
 // dyn_cast<X> - Return the argument parameter cast to the specified type.  This
 // casting operator returns null if the argument is of the wrong type, so it can

llvm/unittests/Support/Casting.cpp

   // EXPECT_EQ(F7, null_foo);
   foo *F8 = B1.baz();
   EXPECT_NE(F8, null_foo);
+
+  std::unique_ptr<const bar> BP(B2);
+  auto FP = cast<foo>(std::move(BP));
+  static_assert(std::is_same<std::unique_ptr<const foo>, decltype(FP)>::value,
+                "Incorrect deduced return type!");
+  EXPECT_NE(FP.get(), null_foo);
+  FP.release();
 }
 
 TEST(CastingTest, cast_or_null) {

   EXPECT_EQ(F14, null_foo);
   foo *F15 = B1.caz();
   EXPECT_NE(F15, null_foo);
+
+  std::unique_ptr<const bar> BP(fub());
+  auto FP = cast_or_null<foo>(std::move(BP));
+  EXPECT_EQ(FP.get(), null_foo);
 }
 
 TEST(CastingTest, dyn_cast) {