[LLVM][Support/ADT] Add assert for isPresent to dyn_cast.

[bzcheeseman]

Summary

This change adds an assert to dyn_cast that the value passed-in is present. In the past, this relied on the isa_impl assertion (which still works in many cases) but which we can tighten up for a better QoI.

The PointerUnion change is because it seems like (based on the call sites) the semantics of the member dyn_cast are actually dyn_cast_if_present.

[rriddle]

Nice!

llvm/include/llvm/ADT/PointerUnion.h

public:
   template <typename T> inline T get() const {
     assert(isa<T>(*this) && "Invalid accessor called");
     return cast<T>(*this);
   }
 
   /// Returns the current pointer if it is of the specified pointer type,
   /// otherwise returns null.
   template <typename T> inline T dyn_cast() const {
-    return llvm::dyn_cast<T>(*this);
+    return llvm::dyn_cast_if_present<T>(*this);
   }
 
   /// If the union is set to the first pointer type get an address pointing to
   /// it.
   First const *getAddrOfPtr1() const {
     return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
   }
 

llvm/include/llvm/Support/Casting.h

 }
 
 template <typename To, typename From>
 [[nodiscard]] inline decltype(auto) cast(std::unique_ptr<From> &&Val) {
   assert(isa<To>(Val) && "cast<Ty>() argument of incompatible type!");
   return CastInfo<To, std::unique_ptr<From>>::doCast(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 be used to test for a type as well as cast if successful. The value
-/// passed in must be present, if not, use dyn_cast_if_present. This should be
-/// used in the context of an if statement like this:
-///
-///  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
-
-template <typename To, typename From>
-[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) {
-  return CastInfo<To, const From>::doCastIfPossible(Val);
-}
-
-template <typename To, typename From>
-[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) {
-  return CastInfo<To, From>::doCastIfPossible(Val);
-}
-
-template <typename To, typename From>
-[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
-  return CastInfo<To, From *>::doCastIfPossible(Val);
-}
-
-template <typename To, typename From>
-[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
-  return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(std::move(Val));
-}
-
 //===----------------------------------------------------------------------===//
 // ValueIsPresent
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-constexpr bool IsNullable = std::is_pointer<T>::value ||
-                            std::is_constructible<T, std::nullptr_t>::value;
+constexpr bool IsNullable =
+    std::is_pointer_v<T> || std::is_constructible_v<T, std::nullptr_t>;
 
 /// ValueIsPresent provides a way to check if a value is, well, present. For
-/// pointers, this is the equivalent of checking against nullptr, for
-/// Optionals this is the equivalent of checking hasValue(). It also
-/// provides a method for unwrapping a value (think dereferencing a
-/// pointer).
+/// pointers, this is the equivalent of checking against nullptr, for Optionals
+/// this is the equivalent of checking hasValue(). It also provides a method for
+/// unwrapping a value (think calling .value() on an optional).
 
 // Generic values can't *not* be present.
 template <typename T, typename Enable = void> struct ValueIsPresent {
   using UnwrappedType = T;
   static inline bool isPresent(const T &t) { return true; }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
 };
 
 // Optional provides its own way to check if something is present.
 template <typename T> struct ValueIsPresent<Optional<T>> {
   using UnwrappedType = T;
   static inline bool isPresent(const Optional<T> &t) { return t.has_value(); }
   static inline decltype(auto) unwrapValue(Optional<T> &t) { return t.value(); }
 };
 
 // If something is "nullable" then we just compare it to nullptr to see if it
 // exists.
 template <typename T>
 struct ValueIsPresent<T, std::enable_if_t<IsNullable<T>>> {
   using UnwrappedType = T;
-  static inline bool isPresent(const T &t) { return t != nullptr; }
+  static inline bool isPresent(const T &t) { return t != T(nullptr); }
   static inline decltype(auto) unwrapValue(T &t) { return t; }
 };
 
 namespace detail {
 // Convenience function we can use to check if a value is present. Because of
 // simplify_type, we have to call it on the simplified type for now.
 template <typename T> inline bool isPresent(const T &t) {
   return ValueIsPresent<typename simplify_type<T>::SimpleType>::isPresent(
       simplify_type<T>::getSimplifiedValue(const_cast<T &>(t)));
 }
 
 // Convenience function we can use to unwrap a value.
 template <typename T> inline decltype(auto) unwrapValue(T &t) {
   return ValueIsPresent<T>::unwrapValue(t);
 }
 } // namespace detail
 
+/// 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 be used to test for a type as well as cast if successful. The value
+/// passed in must be present, if not, use dyn_cast_if_present. This should be
+/// used in the context of an if statement like this:
+///
+///  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
+
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(const From &Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, const From>::doCastIfPossible(Val);
+}
+
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(From &Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, From>::doCastIfPossible(Val);
+}
+
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(From *Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, From *>::doCastIfPossible(Val);
+}
+
+template <typename To, typename From>
+[[nodiscard]] inline decltype(auto) dyn_cast(std::unique_ptr<From> &&Val) {
+  assert(detail::isPresent(Val) && "dyn_cast on a non-existent value");
+  return CastInfo<To, std::unique_ptr<From>>::doCastIfPossible(
+      std::forward<std::unique_ptr<From> &&>(Val));
+}
+
 /// isa_and_present<X> - Functionally identical to isa, except that a null value
 /// is accepted.
 template <typename... X, class Y>
 [[nodiscard]] inline bool isa_and_present(const Y &Val) {
   if (!detail::isPresent(Val))
     return false;
   return isa<X...>(Val);
 }

llvm/unittests/ADT/PointerUnionTest.cpp

TEST_F(PointerUnionTest, NewCastInfra) {
 
   // test dyn_cast
   EXPECT_EQ(dyn_cast<int *>(a), nullptr);
   EXPECT_EQ(dyn_cast<float *>(a), &f);
   EXPECT_EQ(dyn_cast<int *>(b), &i);
   EXPECT_EQ(dyn_cast<float *>(b), nullptr);
   EXPECT_EQ(dyn_cast<int *>(c), &i);
   EXPECT_EQ(dyn_cast<float *>(c), nullptr);
-  EXPECT_EQ(dyn_cast<int *>(n), nullptr);
-  EXPECT_EQ(dyn_cast<float *>(n), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<int *>(n), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<float *>(n), nullptr);
   EXPECT_EQ(dyn_cast<int *>(i3), &i);
   EXPECT_EQ(dyn_cast<float *>(i3), nullptr);
   EXPECT_EQ(dyn_cast<long long *>(i3), nullptr);
   EXPECT_EQ(dyn_cast<int *>(f3), nullptr);
   EXPECT_EQ(dyn_cast<float *>(f3), &f);
   EXPECT_EQ(dyn_cast<long long *>(f3), nullptr);
   EXPECT_EQ(dyn_cast<int *>(l3), nullptr);
   EXPECT_EQ(dyn_cast<float *>(l3), nullptr);
TEST_F(PointerUnionTest, NewCastInfra) {
   EXPECT_EQ(dyn_cast<int *>(l4), nullptr);
   EXPECT_EQ(dyn_cast<float *>(l4), nullptr);
   EXPECT_EQ(dyn_cast<long long *>(l4), &l);
   EXPECT_EQ(dyn_cast<double *>(l4), nullptr);
   EXPECT_EQ(dyn_cast<int *>(d4), nullptr);
   EXPECT_EQ(dyn_cast<float *>(d4), nullptr);
   EXPECT_EQ(dyn_cast<long long *>(d4), nullptr);
   EXPECT_EQ(dyn_cast<double *>(d4), &d);
-  EXPECT_EQ(dyn_cast<int *>(i4null), nullptr);
-  EXPECT_EQ(dyn_cast<float *>(i4null), nullptr);
-  EXPECT_EQ(dyn_cast<long long *>(i4null), nullptr);
-  EXPECT_EQ(dyn_cast<double *>(i4null), nullptr);
-  EXPECT_EQ(dyn_cast<int *>(f4null), nullptr);
-  EXPECT_EQ(dyn_cast<float *>(f4null), nullptr);
-  EXPECT_EQ(dyn_cast<long long *>(f4null), nullptr);
-  EXPECT_EQ(dyn_cast<double *>(f4null), nullptr);
-  EXPECT_EQ(dyn_cast<int *>(l4null), nullptr);
-  EXPECT_EQ(dyn_cast<float *>(l4null), nullptr);
-  EXPECT_EQ(dyn_cast<long long *>(l4null), nullptr);
-  EXPECT_EQ(dyn_cast<double *>(l4null), nullptr);
-  EXPECT_EQ(dyn_cast<int *>(d4null), nullptr);
-  EXPECT_EQ(dyn_cast<float *>(d4null), nullptr);
-  EXPECT_EQ(dyn_cast<long long *>(d4null), nullptr);
-  EXPECT_EQ(dyn_cast<double *>(d4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<int *>(i4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<float *>(i4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<long long *>(i4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<double *>(i4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<int *>(f4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<float *>(f4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<long long *>(f4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<double *>(f4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<int *>(l4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<float *>(l4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<long long *>(l4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<double *>(l4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<int *>(d4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<float *>(d4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<long long *>(d4null), nullptr);
+  EXPECT_EQ(dyn_cast_if_present<double *>(d4null), nullptr);
 
   // test for const
   const PU4 constd4(&d);
   EXPECT_TRUE(isa<double *>(constd4));
   EXPECT_FALSE(isa<int *>(constd4));
   EXPECT_EQ(cast<double *>(constd4), &d);
   EXPECT_EQ(dyn_cast<long long *>(constd4), nullptr);