[ADT][WIP] Proof of concept impl of generic visit for PointerUnion

[scott.linder]

Summary

If the parent patch (or something similar) is accepted, then this is equivalent to https://reviews.llvm.org/D99561 and could supercede it, possibly with the addition of the match convenience method.

[dblaikie]

llvm/include/llvm/ADT/PointerUnion.h

282

Is this the only reason the variant traits needs to be befriended by the PointerUnion? If so, perhaps this API could be exposed in PointerUnion's public API rather than using friendship?

[scott.linder]

llvm/include/llvm/ADT/PointerUnion.h

282

From a pure perspective I think it is an implementation detail, which is the same reason I didn't expose the index in IntrusiveVariant either. It seems reasonable to expose, as std::variant does expose an ::index method, but I can't think of many uses of it that don't have a better, type-safe alternative.

[dblaikie]

llvm/include/llvm/ADT/PointerUnion.h

282

Eh, I don't feel too strongly about it - but figure if it's an important feature for VariantTraits, that seems like as good a reason as any for it to be public (since you can access the property via variant traits anyway - so why not access it directly at that point?).

Up to you.

[scott.linder]

Rebase

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/VariantTraits.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 
 namespace llvm {
 
 template <typename T> struct PointerUnionTypeSelectorReturn {
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;
 
+  friend struct variant_traits_detail::VariantTraits<PointerUnion>;
+
 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.
static unsigned getHashValue(const Union &UnionVal) {
     return DenseMapInfo<intptr_t>::getHashValue(key);
   }
 
   static bool isEqual(const Union &LHS, const Union &RHS) {
     return LHS == RHS;
   }
 };
 
+template <typename... PTs>
+struct variant_traits_detail::VariantTraits<PointerUnion<PTs...>> {
+  static constexpr size_t numAlts() { return sizeof...(PTs); }
+  static constexpr size_t getIndex(const PointerUnion<PTs...> &Variant) {
+    return Variant.Val.getInt();
+  }
+  template <size_t Index, typename VariantT>
+  static constexpr decltype(auto) getAlt(VariantT &&Variant) {
+    return std::forward<VariantT>(Variant)
+        .template get<TypeAtIndex<Index, PTs...>>();
+  }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_POINTERUNION_H

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, Visitor) {
+  void *ptr;
+
+  visit(makeVisitor([&](int *intPtr) { ptr = intPtr; },
+                    [&](float *floatPtr) { ptr = floatPtr; }),
+        a);
+  EXPECT_EQ(&f, ptr);
+
+  visit(makeVisitor([&](int *intPtr) { ptr = intPtr; },
+                    [&](float *floatPtr) { ptr = floatPtr; },
+                    [&](long long *longPtr) { ptr = longPtr; }),
+        i3);
+  EXPECT_EQ(&i, ptr);
+
+  visit(makeVisitor([&](int *intPtr) { ptr = intPtr; },
+                    [&](float *floatPtr) { ptr = floatPtr; },
+                    [&](long long *longPtr) { ptr = longPtr; },
+                    [&](double *doublePtr) { ptr = doublePtr; }),
+        d4);
+  EXPECT_EQ(&d, ptr);
+}
+
 } // end anonymous namespace