Make isa, cast, dyn_cast, etc. work with std::unique_ptr and std::shared_ptr.

[jlebar]

Summary

This lets us use these functions without calling 'get()' everywhere.

[tra]

@dblakie Dave, can you take a look?

[echristo]

That was totally who I was going to add :)

include/llvm/Support/Casting.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CASTING_H
 #define LLVM_SUPPORT_CASTING_H
 
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
+#include <memory>
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 //                          isa<x> Support Templates
 //===----------------------------------------------------------------------===//
 
 // Define a template that can be specialized by smart pointers to reflect the
typedef typename add_const_past_pointer<NonConstSimpleType>::type
     SimpleType;
   typedef typename add_lvalue_reference_if_not_pointer<SimpleType>::type
     RetType;
   static RetType getSimplifiedValue(const From& Val) {
     return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
   }
 };
 
+template<class T> struct simplify_type<std::unique_ptr<T>> {
+  typedef T* SimpleType;
+  static SimpleType getSimplifiedValue(std::unique_ptr<T> &Val) { return Val.get(); }
+};
+
+template<class T> struct simplify_type<const std::unique_ptr<T>> {
+  typedef /*const*/ T* SimpleType;
+  static SimpleType getSimplifiedValue(const std::unique_ptr<T> &Val) {
+    return Val.get();
+  }
+};
+
+template<class T> struct simplify_type<std::shared_ptr<T>> {
+  typedef T* SimpleType;
+  static SimpleType getSimplifiedValue(std::shared_ptr<T> &Val) { return Val.get(); }
+};
+
+template<class T> struct simplify_type<const std::shared_ptr<T>> {
+  typedef /*const*/ T* SimpleType;
+  static SimpleType getSimplifiedValue(const std::shared_ptr<T> &Val) {
+    return Val.get();
+  }
+};
+
 // The core of the implementation of isa<X> is here; To and From should be
 // the names of classes.  This template can be specialized to customize the
 // implementation of isa<> without rewriting it from scratch.
 template <typename To, typename From, typename Enabler = void>
 struct isa_impl {
   static inline bool doit(const From &Val) {
     return To::classof(&Val);
   }

unittests/Support/Casting.cpp

TEST(CastingTest, dyn_cast_or_null) {
   const foo *F3 = dyn_cast_or_null<foo>(B4);
   EXPECT_NE(F3, null_foo);
   foo *F4 = dyn_cast_or_null<foo>(fub());
   EXPECT_EQ(F4, null_foo);
   foo *F5 = B1.naz();
   EXPECT_NE(F5, null_foo);
 }
 
+// We should be able to treat unique_ptr<T> just like T* for the purposes of
+// isa, dyn_cast, cast, etc.
+TEST(CastingTest, unique_ptr) {
+  std::unique_ptr<foo> a(new foo());
+  EXPECT_TRUE(isa<foo>(a));
+
+  std::unique_ptr<bar> b(new bar());
+  EXPECT_NE(dyn_cast_or_null<foo>(b), null_foo);
+}
+
+// We should be able to treat shared_ptr<T> just like T* for the purposes of
+// isa, dyn_cast, cast, etc.
+TEST(CastingTest, shared_ptr) {
+  auto a = std::make_shared<foo>();
+  EXPECT_TRUE(isa<foo>(a));
+
+  auto b = std::make_shared<bar>();
+  EXPECT_NE(dyn_cast_or_null<foo>(b), null_foo);
+}
+
 // These lines are errors...
 //foo *F20 = cast<foo>(B2);  // Yields const foo*
 //foo &F21 = cast<foo>(B3);  // Yields const foo&
 //foo *F22 = cast<foo>(B4);  // Yields const foo*
 //foo &F23 = cast_or_null<foo>(B1);
 //const foo &F24 = cast_or_null<foo>(B3);
 
 const bar *B2 = &B;