[ADT] Adopt the new casting infrastructure for PointerUnion

[bzcheeseman]

llvm/include/llvm/ADT/PointerUnion.h

219

CastIsPossible inheritance is not necessary since you define isPossible below.

222

Out of curiosity, does it make sense to implement PointerUnion::is<T> in terms of isa<T> rather than the other way around? And same for doCast below?

230

You can inherit from the NullableValueCastFailed cast trait to get this

232

You can inherit from the DefaultDoCastIfPossible cast trait to get this

[0x59616e]

Given that I'm still young to C++ and llvm, every suggestion, even the
one you feel it's trivial, are very welcomed ;)

This diff comes with the following updates:

• Define PointerUnion::is and PointerUnion::get in terms of isa<T> and cast<T>.
• Add FIXME comment for PointerUnion::is(), PointerUnion::get() and PointerUnion::dyn_cast().

[0x59616e]

llvm/include/llvm/ADT/PointerUnion.h

222

I'm feeling the same, too.

[0x59616e]

In D125609#3513978, @0x59616e wrote:

Given that I'm still young to C++ and llvm, every suggestion, even the
one you feel it's trivial, are very welcomed ;)

This diff comes with the following updates:

• Define PointerUnion::is and ::get in terms of isa<T> and cast<T>.
• Add FIXME comment for is(), get() and dyn_cast().

Also, CastInfoPointerUnionImpl is defined and declared as a friend of PointerUnion to support isa<T> and cast<T> directly rather than calling into PointerUnion::is and PointerUnion::get.

[0x59616e]

Didn't notice the build failure. Remove the CastInfoPointerUnionImpl and revert
back to the original implementation.

Is there any way for CastInfo to directly access PointerUnion::Val, which is
a protected member ?

[0x59616e]

I can only come up with this :

Define CastInfoPointerUnionImpl as below :

template <typename... PTs> struct CastInfoPointerUnionImpl {
  using From = PointerUnion<PTs...>;

  template <typename To> static inline bool isPossible(From &F) {
   return  F.Val.getInt() == FirstIndexOfType<To, PTs...>::value;
  }

  template <typename To> static To doCast(From &F) {
    assert(isPossible<To>(F) && "cast to an incompatible type !");
    return PointerLikeTypeTraits<To>::getFromVoidPointer(F.Val.getPointer());
  }
};

and declared it as a friend of PointerUnion.

And then CastInfo:

template <typename To, typename... PTs>
struct CastInfo<To, PointerUnion<PTs...>>
    : NullableValueCastFailed<To>,
      DefaultDoCastIfPossible<To, PointerUnion<PTs...>,
                              CastInfo<To, PointerUnion<PTs...>>> {
  using From = PointerUnion<PTs...>;
  using Impl = CastInfoPointerUnionImpl<PTs...>;

  static inline bool isPossible(From &f) {
    return Impl::template isPossible<To>(f);
  }

  static To doCast(From &f) {
    return Impl::template doCast<To>(f);
  }
};

By doing this we can implement PointerUnion::is and PointerUnion::get in this way:

/// Test if the Union currently holds the type matching T.
 template <typename T> bool is() const { return isa<T>(*this); }

 /// Returns the value of the specified pointer type.
 ///
 /// If the specified pointer type is incorrect, assert.
 template <typename T> T get() const {
   assert(isa<T>(*this) && "Invalid accessor called");
   return cast<T>(*this);
 }

Does this make sense ?

[bzcheeseman]

In D125609#3514009, @0x59616e wrote:

Define CastInfoPointerUnionImpl as below :

template <typename... PTs> struct CastInfoPointerUnionImpl {
  using From = PointerUnion<PTs...>;

  template <typename To> static inline bool isPossible(From &F) {
   return  F.Val.getInt() == FirstIndexOfType<To, PTs...>::value;
  }

  template <typename To> static To doCast(From &F) {
    assert(isPossible<To>(F) && "cast to an incompatible type !");
    return PointerLikeTypeTraits<To>::getFromVoidPointer(F.Val.getPointer());
  }
};

and declared it as a friend of PointerUnion.

Could you declare the CastInfo struct itself as a friend? something like template<typename To, typename...PTs> friend struct CastInfo<To, PointerUnion<PTs...>>? That way you don't need the impl struct so it cuts down on overall code. Truly asking here - I think it's doable but I may be wrong.

And then CastInfo:

template <typename To, typename... PTs>
struct CastInfo<To, PointerUnion<PTs...>>
    : NullableValueCastFailed<To>,
      DefaultDoCastIfPossible<To, PointerUnion<PTs...>,
                              CastInfo<To, PointerUnion<PTs...>>> {
  using From = PointerUnion<PTs...>;
  using Impl = CastInfoPointerUnionImpl<PTs...>;

  static inline bool isPossible(From &f) {
    return Impl::template isPossible<To>(f);
  }

  static To doCast(From &f) {
    return Impl::template doCast<To>(f);
  }
};

This looks really nice - I think it still will even with the Impl::* methods inlined :)

By doing this we can implement PointerUnion::is and PointerUnion::get in this way:

/// Test if the Union currently holds the type matching T.
 template <typename T> bool is() const { return isa<T>(*this); }

 /// Returns the value of the specified pointer type.
 ///
 /// If the specified pointer type is incorrect, assert.
 template <typename T> T get() const {
   assert(isa<T>(*this) && "Invalid accessor called");
   return cast<T>(*this);
 }

Does this make sense ?

Comments inline :) Overall makes good sense to me though!

[bzcheeseman]

llvm/include/llvm/ADT/PointerUnion.h

219

I think you'll need public inheritance here and below? Otherwise I'd expect that you get compiler errors saying this partial specialization doesn't define the functions you need.

[0x59616e]

Implement CastInfoPointerUnionImpl

[0x59616e]

Thanks for feedback ;)

In D125609#3514018, @bzcheeseman wrote:

In D125609#3514009, @0x59616e wrote:

Define CastInfoPointerUnionImpl as below :

template <typename... PTs> struct CastInfoPointerUnionImpl {
  using From = PointerUnion<PTs...>;

  template <typename To> static inline bool isPossible(From &F) {
   return  F.Val.getInt() == FirstIndexOfType<To, PTs...>::value;
  }

  template <typename To> static To doCast(From &F) {
    assert(isPossible<To>(F) && "cast to an incompatible type !");
    return PointerLikeTypeTraits<To>::getFromVoidPointer(F.Val.getPointer());
  }
};

and declared it as a friend of PointerUnion.

Could you declare the CastInfo struct itself as a friend? something like template<typename To, typename...PTs> friend struct CastInfo<To, PointerUnion<PTs...>>? That way you don't need the impl struct so it cuts down on overall code. Truly asking here - I think it's doable but I may be wrong.

It seems that partial specialization struct can't be declared as a friend ?

[0x59616e]

I used arc incorrectly. Re-update the diff.

[bzcheeseman]

In D125609#3514030, @0x59616e wrote:

Thanks for feedback ;)
<snip>
It seems that partial specialization struct can't be declared as a friend.

:( I know you can have a templated friend declaration but I guess this doesn't work.

In that case this approach seems fine, thanks for working on it! Just a few more cleanups but overall I think it's looking really solid :)

llvm/include/llvm/ADT/PointerUnion.h

91

nit: Full sentences, please.

129

A quick comment to explain what's going on would be great, maybe /// This is needed to give the CastInfo implementation below access to protected members. or something like that? Just a quick one-liner so it's not confusing in the future.

216

Please explain why this struct is needed with a /// comment.

249

Public inheritance here too. Do you have checks that const is handled correctly?

[0x59616e]

Thanks for feedback !

• Add test case for const
• Add some comments.

[0x59616e]

llvm/include/llvm/ADT/PointerUnion.h

249

I've added some test for const case, but I'm not sure whether it's comprehensive enough or not.

[0x59616e]

• public inheritance for ConstStrippingForwardingCast

[bzcheeseman]

llvm/include/llvm/ADT/PointerUnion.h

249

If you see the tests for the cast infra there are some spots where we have auto result = cast<T>(something); followed by a static_assert that decltype(result) must be a specific type. That was the kind of thing I meant here - i.e. if I have a const pointer union and I do cast<float *> (for example), should it return const float *? Or not? I guess what I was going for was to explicitly test "what happens when I have a const input to a cast? How explicit do I have to be?

At the bottom there you're really close - it looks like you're on the right track but it would be great to get a static_assert for what the output type of a cast on PU4 is, just to make it explicit.

[bzcheeseman]

This comment was removed by bzcheeseman.

[0x59616e]

llvm/include/llvm/ADT/PointerUnion.h

249

What's your opinion about whether it should return a const or non-const pointer when casting from a const PointerUnion ?

[0x59616e]

It seems that people are not always using a plain pointer in PointerUnion. Sometimes they seem to use a custom smart pointer ?

[0x59616e]

update diff

• define our own castFailed in the hope of fixing the build failure of clang.
• add static_assert for type check

[0x59616e]

update diff trying to fix buildbot failure

[0x59616e]

apply clang-format

[bzcheeseman]

Thank you for working on this!

llvm/include/llvm/ADT/PointerUnion.h

249

Honestly I'm not sure! I think it comes down to the semantics of PointerUnion, sort of like const void const* where each const means slightly different things. I think the way that seems simplest is to say "yes, const comes out of a const union". The way that I think matches C++'s const rules is "no, const applies to the union, not the things inside".

I think in this patch you're using the second way, which is totally fair (and you added tests to make it explicit, so thank you!)

llvm/unittests/ADT/PointerUnionTest.cpp

283

misspelling here, "misamatch" -> "mismatch"

[lattner]

I'm excited to see this, thank you or working on it. +1 with the changes aman suggested.

[0x59616e]

fix typo

[0x59616e]

Thanks @lattner @bzcheeseman ! I'll land this patch as soon as possible after making sure everything runs smoothly.

llvm/include/llvm/ADT/PointerUnion.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_POINTERUNION_H
 #define LLVM_ADT_POINTERUNION_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 
 namespace llvm {
 
Derived &operator=(Type V) {
       this->Val = ValTy(
           const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
           I);
       return static_cast<Derived &>(*this);
     };
   };
 }
 
+// This is a forward declaration of CastInfoPointerUnionImpl
+// Refer to its definition below for further details
+template <typename... PTs> struct CastInfoPointerUnionImpl;
 /// A discriminated union of two or more pointer types, with the discriminator
 /// in the low bit of the pointer.
 ///
 /// This implementation is extremely efficient in space due to leveraging the
 /// low bits of the pointer, while exposing a natural and type-safe API.
 ///
 /// Common use patterns would be something like this:
 ///    PointerUnion<int*, float*> P;
class PointerUnion
   // The first type is special because we want to directly cast a pointer to a
   // default-initialized union to a pointer to the first type. But we don't
   // want PointerUnion to be a 'template <typename First, typename ...Rest>'
   // because it's much more convenient to have a name for the whole pack. So
   // split off the first type here.
   using First = TypeAtIndex<0, PTs...>;
   using Base = typename PointerUnion::PointerUnionMembers;
 
+  /// This is needed to give the CastInfo implementation below access
+  /// to protected members.
+  /// Refer to its definition for further details.
+  friend struct CastInfoPointerUnionImpl<PTs...>;
+
 public:
   PointerUnion() = default;
 
   PointerUnion(std::nullptr_t) : PointerUnion() {}
   using Base::Base;
 
   /// Test if the pointer held in the union is null, regardless of
   /// which type it is.
   bool isNull() const { return !this->Val.getPointer(); }
 
   explicit operator bool() const { return !isNull(); }
 
+  // FIXME: Replace the uses of is(), get() and dyn_cast() with
+  //        isa<T>, cast<T> and the llvm::dyn_cast<T>
+
   /// Test if the Union currently holds the type matching T.
-  template <typename T> bool is() const {
-    return this->Val.getInt() == FirstIndexOfType<T, PTs...>::value;
-  }
+  template <typename T> inline bool is() const { return isa<T>(*this); }
 
   /// Returns the value of the specified pointer type.
   ///
   /// If the specified pointer type is incorrect, assert.
-  template <typename T> T get() const {
-    assert(is<T>() && "Invalid accessor called");
-    return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
+  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> T dyn_cast() const {
-    if (is<T>())
-      return get<T>();
-    return T();
+  template <typename T> inline T dyn_cast() const {
+    return llvm::dyn_cast<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();
   }
 
bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
   return lhs.getOpaqueValue() != rhs.getOpaqueValue();
 }
 
 template <typename ...PTs>
 bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
   return lhs.getOpaqueValue() < rhs.getOpaqueValue();
 }
 
+/// We can't (at least, at this moment with C++14) declare CastInfo
+/// as a friend of PointerUnion like this:
+/// ```
+///   template<typename To>
+///   friend struct CastInfo<To, PointerUnion<PTs...>>;
+/// ```
+/// The compiler complains 'Partial specialization cannot be declared as a
+/// friend'.
+/// So we define this struct to be a bridge between CastInfo and
+/// PointerUnion.
+template <typename... PTs> struct CastInfoPointerUnionImpl {
+  using From = PointerUnion<PTs...>;
+
+  template <typename To> static inline bool isPossible(From &F) {
+    return F.Val.getInt() == FirstIndexOfType<To, PTs...>::value;
+  }
+
+  template <typename To> static To doCast(From &F) {
+    assert(isPossible<To>(F) && "cast to an incompatible type !");
+    return PointerLikeTypeTraits<To>::getFromVoidPointer(F.Val.getPointer());
+  }
+};
+
+// Specialization of CastInfo for PointerUnion
+template <typename To, typename... PTs>
+struct CastInfo<To, PointerUnion<PTs...>>
+    : public DefaultDoCastIfPossible<To, PointerUnion<PTs...>,
+                                     CastInfo<To, PointerUnion<PTs...>>> {
+  using From = PointerUnion<PTs...>;
+  using Impl = CastInfoPointerUnionImpl<PTs...>;
+
+  static inline bool isPossible(From &f) {
+    return Impl::template isPossible<To>(f);
+  }
+
+  static To doCast(From &f) { return Impl::template doCast<To>(f); }
+
+  static inline To castFailed() { return To(); }
+};
+
+template <typename To, typename... PTs>
+struct CastInfo<To, const PointerUnion<PTs...>>
+    : public ConstStrippingForwardingCast<To, const PointerUnion<PTs...>,
+                                          CastInfo<To, PointerUnion<PTs...>>> {
+};
+
 // Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
 // # low bits available = min(PT1bits,PT2bits)-1.
 template <typename ...PTs>
 struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
   static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
     return P.getOpaqueValue();
   }
 

llvm/unittests/ADT/PointerUnionTest.cpp

TEST_F(PointerUnionTest, ManyElements) {
   EXPECT_TRUE(a != PU8(&a0));
 }
 
 TEST_F(PointerUnionTest, GetAddrOfPtr1) {
   EXPECT_TRUE((void *)b.getAddrOfPtr1() == (void *)&b);
   EXPECT_TRUE((void *)n.getAddrOfPtr1() == (void *)&n);
 }
 
+TEST_F(PointerUnionTest, NewCastInfra) {
+  // test isa<>
+  EXPECT_TRUE(isa<float *>(a));
+  EXPECT_TRUE(isa<int *>(b));
+  EXPECT_TRUE(isa<int *>(c));
+  EXPECT_TRUE(isa<int *>(n));
+  EXPECT_TRUE(isa<int *>(i3));
+  EXPECT_TRUE(isa<float *>(f3));
+  EXPECT_TRUE(isa<long long *>(l3));
+  EXPECT_TRUE(isa<int *>(i4));
+  EXPECT_TRUE(isa<float *>(f4));
+  EXPECT_TRUE(isa<long long *>(l4));
+  EXPECT_TRUE(isa<double *>(d4));
+  EXPECT_TRUE(isa<int *>(i4null));
+  EXPECT_TRUE(isa<float *>(f4null));
+  EXPECT_TRUE(isa<long long *>(l4null));
+  EXPECT_TRUE(isa<double *>(d4null));
+  EXPECT_FALSE(isa<int *>(a));
+  EXPECT_FALSE(isa<float *>(b));
+  EXPECT_FALSE(isa<float *>(c));
+  EXPECT_FALSE(isa<float *>(n));
+  EXPECT_FALSE(isa<float *>(i3));
+  EXPECT_FALSE(isa<long long *>(i3));
+  EXPECT_FALSE(isa<int *>(f3));
+  EXPECT_FALSE(isa<long long *>(f3));
+  EXPECT_FALSE(isa<int *>(l3));
+  EXPECT_FALSE(isa<float *>(l3));
+  EXPECT_FALSE(isa<float *>(i4));
+  EXPECT_FALSE(isa<long long *>(i4));
+  EXPECT_FALSE(isa<double *>(i4));
+  EXPECT_FALSE(isa<int *>(f4));
+  EXPECT_FALSE(isa<long long *>(f4));
+  EXPECT_FALSE(isa<double *>(f4));
+  EXPECT_FALSE(isa<int *>(l4));
+  EXPECT_FALSE(isa<float *>(l4));
+  EXPECT_FALSE(isa<double *>(l4));
+  EXPECT_FALSE(isa<int *>(d4));
+  EXPECT_FALSE(isa<float *>(d4));
+  EXPECT_FALSE(isa<long long *>(d4));
+  EXPECT_FALSE(isa<float *>(i4null));
+  EXPECT_FALSE(isa<long long *>(i4null));
+  EXPECT_FALSE(isa<double *>(i4null));
+  EXPECT_FALSE(isa<int *>(f4null));
+  EXPECT_FALSE(isa<long long *>(f4null));
+  EXPECT_FALSE(isa<double *>(f4null));
+  EXPECT_FALSE(isa<int *>(l4null));
+  EXPECT_FALSE(isa<float *>(l4null));
+  EXPECT_FALSE(isa<double *>(l4null));
+  EXPECT_FALSE(isa<int *>(d4null));
+  EXPECT_FALSE(isa<float *>(d4null));
+  EXPECT_FALSE(isa<long long *>(d4null));
+
+  // test cast<>
+  EXPECT_EQ(cast<float *>(a), &f);
+  EXPECT_EQ(cast<int *>(b), &i);
+  EXPECT_EQ(cast<int *>(c), &i);
+  EXPECT_EQ(cast<int *>(i3), &i);
+  EXPECT_EQ(cast<float *>(f3), &f);
+  EXPECT_EQ(cast<long long *>(l3), &l);
+  EXPECT_EQ(cast<int *>(i4), &i);
+  EXPECT_EQ(cast<float *>(f4), &f);
+  EXPECT_EQ(cast<long long *>(l4), &l);
+  EXPECT_EQ(cast<double *>(d4), &d);
+
+  // 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<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);
+  EXPECT_EQ(dyn_cast<long long *>(l3), &l);
+  EXPECT_EQ(dyn_cast<int *>(i4), &i);
+  EXPECT_EQ(dyn_cast<float *>(i4), nullptr);
+  EXPECT_EQ(dyn_cast<long long *>(i4), nullptr);
+  EXPECT_EQ(dyn_cast<double *>(i4), nullptr);
+  EXPECT_EQ(dyn_cast<int *>(f4), nullptr);
+  EXPECT_EQ(dyn_cast<float *>(f4), &f);
+  EXPECT_EQ(dyn_cast<long long *>(f4), nullptr);
+  EXPECT_EQ(dyn_cast<double *>(f4), nullptr);
+  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);
+
+  // 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);
+
+  auto *result1 = cast<double *>(constd4);
+  static_assert(std::is_same<double *, decltype(result1)>::value,
+                "type mismatch for cast with PointerUnion");
+
+  PointerUnion<int *, const double *> constd2(&d);
+  auto *result2 = cast<const double *>(d);
+  static_assert(std::is_same<const double *, decltype(result2)>::value,
+                "type mismatch for cast with PointerUnion");
+}
+
 } // end anonymous namespace