Add unique_dyn_cast

[zturner]

Summary

This addresses the issue pointed out in D31890 regarding a potentially confusing api for using unique_ptr in conjunction with dyn_cast. It does so by implementing this not as a specialization / overload of dyn_cast, but as an entirely new function unique_dyn_cast. Adding unique to the name makes clear through the API that the function will conditionally destroy the input if the cast succeeds, and leave the input alone if the cast fails. A matching unique_dyn_cast_or_null is added as well.

[dblaikie]

Can the pieces of the test case be grouped together (currently it's classes, then some other things, then traits, then some other things, then the tests that use them)?

Also - having bits of one part of the test feed into another otherwise independent part of the test seems a bit sub-optimal. (I realize you're using ASSERT_* so if the first fails tehre won't be spurious failures in the latter tests - but it means you only get the first result from the test and nothing else) - I'd suggest splitting it up to at least be independent, and possibly to be in separate test functions so they can report independent results, etc.

llvm/include/llvm/Support/Casting.h

363

I'd probably phrase this as "From is null on exit". (nullptr is a specific null literal, the concept of nullness is independent of nullptr (or NULL, or 0, etc) and "refers to null" seems a bit awkward/inaccurate because it doesn't refer to anything)

llvm/unittests/Support/Casting.cpp

47

you can drop the "public" in "public base" here, since it's a struct and has default public visibility

52

'inline' isn't needed here

59

'inline' isn't needed here

llvm/include/llvm/Support/Casting.h

 }
 
 template <class X, class Y>
 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
 dyn_cast_or_null(Y *Val) {
   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
 }
 
+// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
+// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
+// cast is successful, From refers to nullptr on exit and the casted value
+// is returned.  If the cast is unsuccessful, the function returns nullptr
+// and From is unchanged.
+template <class X, class Y>
+LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
+    -> decltype(cast<X>(Val)) {
+  if (!isa<X>(Val))
+    return nullptr;
+  return cast<X>(std::move(Val));
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)
+    -> decltype(cast<X>(Val)) {
+  return unique_dyn_cast<X, Y>(Val);
+}
+
+// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
+// a null value is accepted.
+template <class X, class Y>
+LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
+    -> decltype(cast<X>(Val)) {
+  if (!Val)
+    return nullptr;
+  return unique_dyn_cast(Val);
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)
+    -> decltype(cast<X>(Val)) {
+  return unique_dyn_cast_or_null<X, Y>(Val);
+}
+
 } // End llvm namespace
 
 #endif

llvm/unittests/Support/Casting.cpp

 struct foo {
   void ext() const;
   /*  static bool classof(const bar *X) {
     cerr << "Classof: " << X << "\n";
     return true;
     }*/
 };
 
+struct base {
+  virtual ~base() {}
+};
+
+struct derived : public base {
+  static bool classof(const base *B) { return true; }
+};
+
 template <> struct isa_impl<foo, bar> {
   static inline bool doit(const bar &Val) {
     dbgs() << "Classof: " << &Val << "\n";
     return true;
   }
 };
 
+template <typename T> struct isa_impl<foo, T> {
+  static inline bool doit(const T &Val) { return false; }
+};
+
 foo *bar::baz() {
     return cast<foo>(this);
 }
 
 foo *bar::caz() {
     return cast_or_null<foo>(this);
 }
 
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);
 }
 
+std::unique_ptr<derived> newd() { return llvm::make_unique<derived>(); }
+std::unique_ptr<base> newb() { return llvm::make_unique<derived>(); }
+
+TEST(CastingTest, unique_dyn_cast) {
+  derived *OrigD = nullptr;
+  auto D = llvm::make_unique<derived>();
+  OrigD = D.get();
+
+  // Converting from D to itself is valid, it should return a new unique_ptr
+  // and the old one should become nullptr.
+  auto NewD = unique_dyn_cast<derived>(D);
+  ASSERT_EQ(OrigD, NewD.get());
+  ASSERT_EQ(nullptr, D);
+
+  // Converting from D to B is valid, B should have a value and D should be
+  // nullptr.
+  auto B = unique_dyn_cast<base>(NewD);
+  ASSERT_EQ(OrigD, B.get());
+  ASSERT_EQ(nullptr, NewD);
+
+  // Converting from B to itself is valid, it should return a new unique_ptr
+  // and the old one should become nullptr.
+  auto NewB = unique_dyn_cast<base>(B);
+  ASSERT_EQ(OrigD, NewB.get());
+  ASSERT_EQ(nullptr, B);
+
+  // Converting from B to D is valid, D should have a value and B should be
+  // nullptr;
+  D = unique_dyn_cast<derived>(NewB);
+  ASSERT_EQ(OrigD, D.get());
+  ASSERT_EQ(nullptr, NewB);
+
+  // Converting between unrelated types should fail.  The original value should
+  // remain unchanged and it should return nullptr.
+  auto F = unique_dyn_cast<foo>(D);
+  ASSERT_EQ(nullptr, F);
+  ASSERT_EQ(OrigD, D.get());
+
+  // All of the above should also hold for temporaries.
+  auto D2 = unique_dyn_cast<derived>(newd());
+  EXPECT_NE(nullptr, D2);
+
+  auto B2 = unique_dyn_cast<derived>(newb());
+  EXPECT_NE(nullptr, B2);
+
+  auto B3 = unique_dyn_cast<base>(newb());
+  EXPECT_NE(nullptr, B3);
+
+  auto F2 = unique_dyn_cast<foo>(newb());
+  EXPECT_EQ(nullptr, F2);
+}
+
 // 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;