[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

284

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

284

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

284

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/STLExtras.h"
+#include "llvm/ADT/VariantTraits.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 
 namespace llvm {
 
 template <typename T> struct PointerUnionTypeSelectorReturn {
public:
   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(); }
 
+  /// Get index of pointer type currently held by Union.
+  size_t index() const { return this->Val.getInt(); }
+
   /// Test if the Union currently holds the type matching T.
   template <typename T> bool is() const {
-    return this->Val.getInt() == FirstIndexOfType<T, PTs...>{};
+    return index() == FirstIndexOfType<T, PTs...>{};
   }
 
   /// 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());
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 VariantTraits<PointerUnion<PTs...>> {
+  static constexpr size_t size() { return sizeof...(PTs); }
+  static constexpr size_t index(const PointerUnion<PTs...> &Variant) {
+    return Variant.index();
+  }
+  template <size_t Index, typename VariantT = PointerUnion<PTs...>>
+  static constexpr decltype(auto) get(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