[LLVM][Casting.h] Add trivial self-cast

[bzcheeseman]

Summary

Casting from a type to itself should always be possible. Make this simple for all users, and add tests to ensure we keep being able to do this. Ref: https://reviews.llvm.org/D125543

[rriddle]

The test failures look real here, can you take a look? Looks like this doesn't properly handle the non-const case.

[bzcheeseman]

In D125590#3513022, @rriddle wrote:

The test failures look real here, can you take a look? Looks like this doesn't properly handle the non-const case.

Yeah agreed - I'll take a look when I get a chance.

[bzcheeseman]

Found a better way to do it (I think) that avoids yet another partial specialization of CastInfo to avoid future ambiguous partial specialization shenanigans.

llvm/include/llvm/Support/Casting.h

template <class To, class FromTy> struct cast_retty_wrap<To, FromTy, FromTy> {
   using ret_type = typename cast_retty_impl<To, FromTy>::ret_type;
 };
 
 template <class To, class From> struct cast_retty {
   using ret_type = typename cast_retty_wrap<
       To, From, typename simplify_type<From>::SimpleType>::ret_type;
 };
 
+template <class T> struct cast_retty<T, T> {
+  // Casting T to itself, but have to use a ref if so we don't get a copy if
+  // it's not a pointer.
+  using ret_type = std::conditional_t<std::is_pointer<T>::value, T, T &>;
+};
+
 //===----------------------------------------------------------------------===//
 // cast_convert_val
 //===----------------------------------------------------------------------===//
 
 // Ensure the non-simple values are converted using the simplify_type template
 // that may be specialized by smart pointers...
 //
 template <class To, class From, class SimpleFrom> struct cast_convert_val {
return isa_impl_wrap<
         typename simplify_type<const From>::SimpleType>::doit(*f);
   }
 };
 
 /// Upcasting (from derived to base) and casting from a type to itself should
 /// always be possible.
 template <typename To, typename From>
 struct CastIsPossible<To, From,
-                      std::enable_if_t<std::is_base_of<To, From>::value>> {
+                      std::enable_if_t<std::is_same<To, From>::value ||
+                                       std::is_base_of<To, From>::value>> {
   static inline bool isPossible(const From &f) { return true; }
 };
 
 //===----------------------------------------------------------------------===//
 // Cast traits
 //===----------------------------------------------------------------------===//
 
 /// All of these cast traits are meant to be implementations for useful casts

llvm/unittests/Support/Casting.cpp

 
 bar B;
 extern bar &B1;
 bar &B1 = B;
 extern const bar *B2;
 // test various configurations of const
 const bar &B3 = B1;
 const bar *const B4 = B2;
+bar *B5 = &B;
 
 TEST(CastingTest, isa) {
   EXPECT_TRUE(isa<foo>(B1));
   EXPECT_TRUE(isa<foo>(B2));
   EXPECT_TRUE(isa<foo>(B3));
   EXPECT_TRUE(isa<foo>(B4));
 }
 
TEST(CastingTest, cast) {
   const foo *F6 = cast<foo>(B4);
   EXPECT_NE(F6, null_foo);
   // Can't pass null pointer to cast<>.
   // foo *F7 = cast<foo>(fub());
   // EXPECT_EQ(F7, null_foo);
   foo *F8 = B1.baz();
   EXPECT_NE(F8, null_foo);
 
+  // Ensure cast-to-self works (with the type in the template verbatim
+  // equivalent to the type in the input).
+  auto B9 = cast<bar *>(B5);
+  static_assert(std::is_same<bar *, decltype(B9)>::value,
+                "Inccorrect return type!");
+  EXPECT_EQ(B9, B5);
+  auto B10 = cast<const bar *>(B2);
+  static_assert(std::is_same<const bar *, decltype(B10)>::value,
+                "Inccorrect return type!");
+  EXPECT_EQ(B10, B2);
+
   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, dyn_cast) {
   EXPECT_NE(F2, null_foo);
   const foo *F3 = dyn_cast<foo>(B4);
   EXPECT_NE(F3, null_foo);
   // Can't pass null pointer to dyn_cast<>.
   // foo *F4 = dyn_cast<foo>(fub());
   // EXPECT_EQ(F4, null_foo);
   foo *F5 = B1.daz();
   EXPECT_NE(F5, null_foo);
+
+  // Ensure cast-to-self works (with the type in the template verbatim
+  // equivalent to the type in the input).
+  auto B9 = dyn_cast<bar *>(B5);
+  static_assert(std::is_same<bar *, decltype(B9)>::value,
+                "Inccorrect return type!");
+  EXPECT_EQ(B9, B5);
+  auto B10 = dyn_cast<const bar *>(B2);
+  static_assert(std::is_same<const bar *, decltype(B10)>::value,
+                "Inccorrect return type!");
+  EXPECT_EQ(B10, B2);
 }
 
 // All these tests forward to dyn_cast_if_present, so they also provde an
 // effective test for its use cases.
 TEST(CastingTest, dyn_cast_or_null) {
   const foo *F1 = dyn_cast_or_null<foo>(B2);
   EXPECT_NE(F1, null_foo);
   const foo *F2 = dyn_cast_or_null<foo>(B2);