diff --git a/llvm/include/llvm/ADT/PointerUnion.h b/llvm/include/llvm/ADT/PointerUnion.h
--- a/llvm/include/llvm/ADT/PointerUnion.h
+++ b/llvm/include/llvm/ADT/PointerUnion.h
@@ -16,6 +16,7 @@
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/Visitor.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
 #include <cstddef>
@@ -64,18 +65,27 @@
     return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
   }
 
-  /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
-  /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
-  /// list.
-  template <typename T, typename ...Us> struct TypeIndex;
-  template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
+  template <std::size_t I, class... T> struct SelectTypeAtIndex {};
+
+  template <std::size_t I, class T0, class... Tn>
+  struct SelectTypeAtIndex<I, T0, Tn...> : SelectTypeAtIndex<I - 1, Tn...> {};
+
+  template <class T0, class... Ts> struct SelectTypeAtIndex<0, T0, Ts...> {
+    using type = T0;
+  };
+
+  /// Find the index of a type in a list of types. FindIndexOfType<T,
+  /// Us...>::Index is the index of T in Us, or sizeof...(Us) if T does not
+  /// appear in the list.
+  template <typename T, typename... Us> struct FindIndexOfType;
+  template <typename T, typename... Us> struct FindIndexOfType<T, T, Us...> {
     static constexpr int Index = 0;
   };
   template <typename T, typename U, typename... Us>
-  struct TypeIndex<T, U, Us...> {
-    static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
+  struct FindIndexOfType<T, U, Us...> {
+    static constexpr int Index = 1 + FindIndexOfType<T, Us...>::Index;
   };
-  template <typename T> struct TypeIndex<T> {
+  template <typename T> struct FindIndexOfType<T> {
     static constexpr int Index = 0;
   };
 
@@ -145,6 +155,9 @@
 ///    P = (float*)0;
 ///    Y = P.get<float*>();   // ok.
 ///    X = P.get<int*>();     // runtime assertion failure.
+///    W = P.visit(
+///        [](int* i) { std::cout << i; },
+///        [](float* f) { std::cout << f; });   // ok.
 template <typename... PTs>
 class PointerUnion
     : public pointer_union_detail::PointerUnionMembers<
@@ -175,7 +188,8 @@
 
   /// Test if the Union currently holds the type matching T.
   template <typename T> bool is() const {
-    constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
+    constexpr int Index =
+        pointer_union_detail::FindIndexOfType<T, PTs...>::Index;
     static_assert(Index < sizeof...(PTs),
                   "PointerUnion::is<T> given type not in the union");
     return this->Val.getInt() == Index;
@@ -230,6 +244,70 @@
     V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
     return V;
   }
+
+  template <std::size_t I>
+  using TypeAtIndex =
+      typename pointer_union_detail::SelectTypeAtIndex<I, PTs...>::type;
+  using ArbitraryType = TypeAtIndex<0>;
+
+  struct UnreachableSwitchCase {
+    [[noreturn]] static ArbitraryType get(PointerUnion<PTs...> p) {
+#if ((defined(__has_builtin) && __has_builtin(__builtin_unreachable)) ||       \
+     (defined(__GNUC__) && !defined(__clang__)))
+      __builtin_unreachable();
+#elif defined(_MSC_VER)
+      __assume(false);
+#else
+      assert(false); // NOLINT
+#endif
+    }
+  };
+
+  template <std::size_t I> struct ReachableSwitchCase {
+    static TypeAtIndex<I> get(PointerUnion<PTs...> p) {
+      return p.get<TypeAtIndex<I>>();
+    }
+  };
+
+  // Default Getter implements a case statement for unreachable branches.
+  template <bool IsReachable> struct GetterImpl {
+    template <std::size_t I> using Body = UnreachableSwitchCase;
+  };
+
+  template <> struct GetterImpl</*IsReachable =*/true> {
+    template <std::size_t I> using Body = ReachableSwitchCase<I>;
+  };
+
+  template <std::size_t I>
+  using Getter = typename GetterImpl<(I < sizeof...(PTs))>::template Body<I>;
+
+  template <typename Visitor> auto visit(Visitor &&visitor) {
+    static_assert(
+        sizeof...(PTs) <= 8,
+        "PointerUnion::visit implemented for at most 8 alternatives.");
+    switch (this->Val.getInt()) {
+    case 0:
+      return visitor(Getter<0>::get(*this));
+    case 1:
+      return visitor(Getter<1>::get(*this));
+    case 2:
+      return visitor(Getter<2>::get(*this));
+    case 3:
+      return visitor(Getter<3>::get(*this));
+    case 4:
+      return visitor(Getter<4>::get(*this));
+    case 5:
+      return visitor(Getter<5>::get(*this));
+    case 6:
+      return visitor(Getter<6>::get(*this));
+    case 7:
+      return visitor(Getter<7>::get(*this));
+    }
+  }
+
+  template <class... LAMBDAS> auto visit(LAMBDAS... lambdas) {
+    return visit(llvm::makeVisitor(lambdas...));
+  }
 };
 
 template <typename ...PTs>