diff --git a/llvm/include/llvm/ADT/IntrusiveVariant.h b/llvm/include/llvm/ADT/IntrusiveVariant.h
new file mode 100644
--- /dev/null
+++ b/llvm/include/llvm/ADT/IntrusiveVariant.h
@@ -0,0 +1,453 @@
+//===- IntrusiveVariant.h - Compact type safe union -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides IntrusiveVariant, a class template modeled in the spirit
+// of std::variant, but leveraging the "common initial sequence" rule for union
+// members to store the runtime tag at the beginning of the IntrusiveVariant's
+// alternative types, allowing for it to be packed more efficiently into bits
+// that would otherwise be used for padding.
+//
+// However, this requires several restrictions be placed on valid alternative
+// types. All alternative types of an IntrusiveVariant must:
+//
+//  * Be standard-layout. This implies (among other things):
+//    * All non-static data members must have the same access control.
+//    * All non-static data members must be declared in only one class in the
+//      inheritence hierarchy.
+//    * No virtual methods.
+//  * Begin their class definition by invoking the
+//    DECLARE_INTRUSIVE_ALTERNATIVE macro. This declares a member named
+//    `IntrusiveVariantTagMember` which must not be referenced outside of the
+//    implementation of IntrusiveVariant, and declares some `friend` types to
+//    make the tag accessible to the implementation.
+//
+// Additionally, some features were omitted that are present in the C++17
+// std::variant to keep the code simpler:
+//
+//  * All alternative types must be trivially-destructible.
+//  * All copy/move constructors and assignment operators for the variant are
+//    disabled if any type is not trivially-constructible and/or
+//    trivially-copyable, respectively.
+//  * All alternative types must be unique, and cannot be referred to by index.
+//  * No equivalent to std::monostate. An instantiation must have at least
+//    IntrusiveVariant::MinNumberOfAlternatives alternatives.
+//
+// If a use case for the above materializes these can always be added
+// retroactively.
+//
+// Example:
+//
+//  class AltInt {
+//    DECLARE_INTRUSIVE_ALTERNATIVE
+//    int Int;
+//
+//  public:
+//    AltInt() : Int(0) {}
+//    AltInt(int Int) : Int(Int) {}
+//    int getInt() const { return Int; }
+//    void setInt(int Int) { this->Int = Int; }
+//  };
+//
+//  class AltDouble {
+//    DECLARE_INTRUSIVE_ALTERNATIVE
+//    double Double;
+//
+//  public:
+//    AltDouble(double Double) : Double(Double) {}
+//    double getDouble() const { return Double; }
+//    void setDouble(double Double) { this->Double = Double; }
+//  };
+//
+//  class AltComplexInt {
+//    DECLARE_INTRUSIVE_ALTERNATIVE
+//    int Real;
+//    int Imag;
+//
+//  public:
+//    AltComplexInt(int Real, int Imag) : Real(Real), Imag(Imag) {}
+//    int getReal() const { return Real; }
+//    void setReal(int Real) { this->Real = Real; }
+//    int getImag() const { return Imag; }
+//    void setImag(int Imag) { this->Imag = Imag; }
+//  };
+//
+//  TEST(VariantTest, HeaderExample) {
+//    using MyVariant = IntrusiveVariant<AltInt, AltDouble, AltComplexInt>;
+//
+//    MyVariant DefaultConstructedVariant;
+//    ASSERT_TRUE(DefaultConstructedVariant.holdsAlternative<AltInt>());
+//    ASSERT_EQ(DefaultConstructedVariant.get<AltInt>().getInt(), 0);
+//    MyVariant Variant{in_place_type<AltComplexInt>, 4, 2};
+//    ASSERT_TRUE(Variant.holdsAlternative<AltComplexInt>());
+//    int NonSense = visit(
+//        makeVisitor(
+//            [](AltInt &AI) { return AI.getInt(); },
+//            [](AltDouble &AD) { return static_cast<int>(AD.getDouble()); },
+//            [](AltComplexInt &ACI) { return ACI.getReal() + ACI.getImag(); }),
+//        Variant);
+//    ASSERT_EQ(NonSense, 6);
+//    Variant.emplace<AltDouble>(2.0);
+//    ASSERT_TRUE(Variant.holdsAlternative<AltDouble>());
+//    Variant.get<AltDouble>().setDouble(3.0);
+//    AltDouble AD = Variant.get<AltDouble>();
+//    double D = AD.getDouble();
+//    ASSERT_EQ(D, 3.0);
+//    Variant.emplace<AltComplexInt>(4, 5);
+//    ASSERT_EQ(Variant.get<AltComplexInt>().getReal(), 4);
+//    ASSERT_EQ(Variant.get<AltComplexInt>().getImag(), 5);
+//  }
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_INTRUSIVEVARIANT_H
+#define LLVM_ADT_INTRUSIVEVARIANT_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/VariantTraits.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+namespace llvm {
+
+template <typename... Ts> class IntrusiveVariant;
+
+/// Helper to get the number of alternative types of a (possibly cv-qualified)
+/// IntrusiveVariant type as a constexpr. See std::variant_size.
+template <typename T>
+struct IntrusiveVariantSize : IntrusiveVariantSize<std::remove_cv_t<T>> {};
+template <typename... Ts>
+struct IntrusiveVariantSize<IntrusiveVariant<Ts...>>
+    : std::integral_constant<size_t, sizeof...(Ts)> {};
+
+/// Simple value type which must be the first member of all alternative types
+/// of an IntrusiveVariant. See DECLARE_INTRUSIVE_ALTERNATIVE.
+///
+/// The internal implementation assumes this is layout-compatible with the
+/// "common initial sequence" of all alternative types contained in the private
+/// union of the IntrusiveVariant.
+struct IntrusiveVariantTag {
+  uint8_t Index = std::numeric_limits<uint8_t>::max();
+  IntrusiveVariantTag() {}
+  IntrusiveVariantTag(uint8_t Index) : Index(Index) {}
+};
+
+/// A helper macro to add the declarations needed to use a type as an
+/// alternative for IntrusiveVariant. Must be the first declaration of the
+/// class.
+#define DECLARE_INTRUSIVE_ALTERNATIVE                                          \
+  ::llvm::IntrusiveVariantTag IntrusiveVariantTagMember;                       \
+  template <typename...> friend class ::llvm::IntrusiveVariant;                \
+  template <size_t, typename, typename...>                                     \
+  friend union ::llvm::detail::UnionImpl;
+
+namespace detail {
+// This struct is used to access the intrusive tag of the alternative types.
+//
+// All such types must be have an initial sequence which is layout-compatible
+// with this struct or the access causes undefined behavior.
+struct CommonInitialSequenceT {
+  IntrusiveVariantTag Tag;
+};
+
+// The inner implementation of the "type safe union". Members are only
+// accessible directly via an Index, so IntrusiveVariant must use indexOf to
+// convert a pair of T and Ts... into an index.
+//
+// Effectively implemented as a "linked list" of recursively defined union
+// templates. This is the recursive portion of the definition.
+//
+// We use in_place_index_t here both to disambiguate the constructor and to make
+// defining the overload set for getMember more natural.
+template <size_t Index, typename HeadT, typename... TailTs> union UnionImpl {
+  using TailT = UnionImpl<Index + 1, TailTs...>;
+  HeadT Head;
+  TailT Tail;
+  HeadT &getMember(in_place_index_t<Index>) { return Head; }
+  const HeadT &getMember(in_place_index_t<Index>) const { return Head; }
+  template <size_t I> decltype(auto) getMember(in_place_index_t<I>) {
+    return Tail.getMember(in_place_index<I>);
+  }
+  template <size_t I> decltype(auto) getMember(in_place_index_t<I>) const {
+    return Tail.getMember(in_place_index<I>);
+  }
+  template <typename... ArgTs>
+  UnionImpl(in_place_index_t<Index>, ArgTs &&...Args) {
+    new (&Head) HeadT(std::forward<ArgTs>(Args)...);
+    Head.IntrusiveVariantTagMember.Index = Index;
+  }
+  template <size_t I, typename... ArgTs>
+  UnionImpl(in_place_index_t<I>, ArgTs &&...Args) {
+    new (&Tail) TailT(in_place_index_t<I>{}, std::forward<ArgTs>(Args)...);
+  }
+  UnionImpl(const UnionImpl &) = default;
+  UnionImpl(UnionImpl &&) = default;
+  UnionImpl &operator=(const UnionImpl &) = default;
+  UnionImpl &operator=(UnionImpl &&) = default;
+  // This is safe, assuming the member types are all trivially destructible.
+  ~UnionImpl() = default;
+};
+// The base case for the above, i.e. when the tail pack is empty. This is the
+// "(cons head nil)" of the linked list.
+template <size_t Index, typename HeadT> union UnionImpl<Index, HeadT> {
+  HeadT Head;
+  HeadT &getMember(in_place_index_t<Index>) { return Head; }
+  const HeadT &getMember(in_place_index_t<Index>) const { return Head; }
+  template <typename... ArgTs>
+  UnionImpl(in_place_index_t<Index>, ArgTs &&...Args) {
+    new (&Head) HeadT(std::forward<ArgTs>(Args)...);
+    Head.IntrusiveVariantTagMember.Index = Index;
+  }
+  UnionImpl(const UnionImpl &) = default;
+  UnionImpl(UnionImpl &&) = default;
+  UnionImpl &operator=(const UnionImpl &) = default;
+  UnionImpl &operator=(UnionImpl &&) = default;
+  // This is safe, assuming the member types are all trivially destructible.
+  ~UnionImpl() = default;
+};
+} // end namespace detail
+
+template <typename... Ts> struct VariantTraits<IntrusiveVariant<Ts...>> {
+  static constexpr size_t size() { return sizeof...(Ts); }
+  static constexpr size_t index(const IntrusiveVariant<Ts...> &Variant) {
+    return Variant.index();
+  }
+  template <size_t Index, typename VariantT = IntrusiveVariant<Ts...>>
+  static constexpr decltype(auto) get(VariantT &&Variant) {
+    return std::forward<VariantT>(Variant)
+        .template get<TypeAtIndex<Index, Ts...>>();
+  }
+};
+
+/// A class template modeled in the spirit of std::variant, but leveraging the
+/// "common initial sequence" rule for union members to store the runtime tag
+/// at the beginning of each variant alternative itself, allowing for it to be
+/// packed more efficiently into bits that would otherwise be used for padding.
+template <typename... Ts> class IntrusiveVariant {
+public:
+  /// The static minimum number of alternative types supported for an
+  /// instantiation of IntrusiveVariant.
+  static constexpr size_t MinNumberOfAlternatives = 1;
+
+private:
+  static_assert(llvm::conjunction<std::is_standard_layout<Ts>...>::value,
+                "IntrusiveVariant alternatives must be standard-layout.");
+  static_assert(
+      llvm::conjunction<std::is_trivially_destructible<Ts>...>::value,
+      "IntrusiveVariant alternatives must be trivially-destructible.");
+  template <typename... Us> static constexpr bool tagIsFirstMember() {
+    constexpr bool IsFirstMember[] = {
+        !offsetof(Us, IntrusiveVariantTagMember)...};
+    for (size_t I = 0; I < sizeof...(Us); ++I)
+      if (!IsFirstMember[I])
+        return false;
+    return true;
+  }
+  static_assert(
+      tagIsFirstMember<Ts...>() &&
+          llvm::conjunction<
+              std::is_same<IntrusiveVariantTag Ts::*,
+                           decltype(&Ts::IntrusiveVariantTagMember)>...>::value,
+      "IntrusiveVariant alternatives' class definition must begin with "
+      "DECLARE_INTRUSIVE_ALTERNATIVE");
+  static_assert(
+      TypesAreDistinct<Ts...>{},
+      "Repeated alternative types in IntrusiveVariant are not allowed.");
+
+  // Alias for the UnionImpl of this IntrusiveVariant.
+  using UnionT = detail::UnionImpl<0, Ts...>;
+  // Helper to get the in_place_index_t for T in Ts...
+  template <typename T>
+  using InPlaceIndexT = in_place_index_t<FirstIndexOfType<T, Ts...>{}>;
+  // Helper to check if a type is in the set Ts...
+  template <typename T> using IsAlternativeType = llvm::is_one_of<T, Ts...>;
+
+  // The only data member of IntrusiveVariant, meaning the variant is the same
+  // size and has the same alignment requirements as the union of all of its
+  // alternative types.
+  union {
+    detail::CommonInitialSequenceT CommonInitialSequence;
+    UnionT Union;
+  };
+
+  // Convenience methods to get the union member for an alternative type T.
+  template <typename T> T &getAlt() {
+    return Union.getMember(InPlaceIndexT<T>{});
+  }
+  template <typename T> const T &getAlt() const {
+    return Union.getMember(InPlaceIndexT<T>{});
+  }
+
+public:
+  /// A default constructed IntrusiveVariant holds a default constructed value
+  /// of its first alternative. Only enabled if the first alternative has a
+  /// default constructor.
+  template <int B = std::is_default_constructible<TypeAtIndex<0, Ts...>>{},
+            typename std::enable_if_t<B, int> = 0>
+  constexpr IntrusiveVariant() : Union(in_place_index_t<0>{}) {}
+  /// The forwarding constructor requires a disambiguation tag
+  /// in_place_type_t<T>, and creates an IntrusiveVariant holding the
+  /// alternative T constructed with the constructor arguments Args...
+  template <typename T, std::enable_if_t<IsAlternativeType<T>{}, int> = 0,
+            typename... ArgTs>
+  explicit constexpr IntrusiveVariant(in_place_type_t<T>, ArgTs &&...Args)
+      : Union(InPlaceIndexT<T>{}, std::forward<ArgTs>(Args)...) {}
+  /// Converting constructor from alternative types.
+  template <typename T, std::enable_if_t<IsAlternativeType<T>{}, int> = 0>
+  constexpr IntrusiveVariant(T &&Alt)
+      : Union(InPlaceIndexT<T>{}, std::forward<T>(Alt)) {}
+  IntrusiveVariant(const IntrusiveVariant &) = default;
+  IntrusiveVariant(IntrusiveVariant &&) = default;
+  ~IntrusiveVariant() = default;
+  IntrusiveVariant &operator=(const IntrusiveVariant &) = default;
+  IntrusiveVariant &operator=(IntrusiveVariant &&) = default;
+  /// Replaces the held value with a new value of alternative type T in-place,
+  /// constructing the new value with constructor arguments Args...
+  ///
+  /// Returns the newly constructed alternative type value.
+  template <typename T, typename... ArgTs> T &emplace(ArgTs &&...Args) {
+    new (&Union) UnionT(InPlaceIndexT<T>{}, std::forward<ArgTs>(Args)...);
+    return Union.getMember(InPlaceIndexT<T>{});
+  }
+  /// Returns the index of the alternative type held by this variant.
+  size_t index() const { return CommonInitialSequence.Tag.Index; }
+  /// Check if this variant holds a value of the given alternative type T.
+  template <class T> constexpr bool holdsAlternative() const {
+    return index() == FirstIndexOfType<T, Ts...>();
+  }
+  /// Reads the value of alternative type T.
+  ///
+  /// Behavior undefined if this does not hold a value of alternative type T.
+  template <class T> constexpr T &get() {
+    assert(holdsAlternative<T>());
+    return getAlt<T>();
+  }
+  /// Reads the value of alternative type T.
+  ///
+  /// Behavior undefined if this does not hold a value of alternative type T.
+  template <class T> constexpr const T &get() const {
+    assert(holdsAlternative<T>());
+    return getAlt<T>();
+  }
+  /// Obtains a pointer to the value of alternative type T if this holds a
+  /// value of alternative type T. Otherwise, returns nullptr.
+  template <class T> constexpr T *getIf() {
+    if (holdsAlternative<T>())
+      return &getAlt<T>();
+    return nullptr;
+  }
+  /// Obtains a pointer to the value of alternative type T if this holds a
+  /// value of alternative type T. Otherwise, returns nullptr.
+  template <class T> constexpr const T *getIf() const {
+    if (holdsAlternative<T>())
+      return &getAlt<T>();
+    return nullptr;
+  }
+
+  /// Equality operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T != U, returns false.
+  /// Otherwise, returns LHS.get<T>() == RHS.get<U>().
+  friend constexpr bool operator==(const IntrusiveVariant<Ts...> &LHS,
+                                   const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() != RHS.index())
+      return false;
+    return visitSameAlternative(std::equal_to<>{}, LHS, RHS);
+  }
+
+  /// Inequality operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T != U, returns true.
+  /// Otherwise, returns LHS.get<T>() != RHS.get<U>().
+  friend constexpr bool operator!=(const IntrusiveVariant<Ts...> &LHS,
+                                   const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() != RHS.index())
+      return true;
+    return visitSameAlternative(std::not_equal_to<>{}, LHS, RHS);
+  }
+
+  /// Less-than operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T precedes U in Ts..., returns true.
+  /// If U precedes T in Ts..., returns false.
+  /// Otherwise, returns LHS.get<T>() < RHS.get<U>().
+  friend constexpr bool operator<(const IntrusiveVariant<Ts...> &LHS,
+                                  const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() < RHS.index())
+      return true;
+    if (LHS.index() > RHS.index())
+      return false;
+    return visitSameAlternative(std::less<>{}, LHS, RHS);
+  }
+
+  /// Greater-than operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T precedes U in Ts..., returns false.
+  /// If U precedes T in Ts..., returns true.
+  /// Otherwise, returns LHS.get<T>() > RHS.get<U>().
+  friend constexpr bool operator>(const IntrusiveVariant<Ts...> &LHS,
+                                  const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() < RHS.index())
+      return false;
+    if (LHS.index() > RHS.index())
+      return true;
+    return visitSameAlternative(std::greater<>{}, LHS, RHS);
+  }
+
+  /// Less-equal operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T precedes U in Ts..., returns true.
+  /// If U precedes T in Ts..., returns false.
+  /// Otherwise, returns LHS.get<T>() <= RHS.get<U>().
+  friend constexpr bool operator<=(const IntrusiveVariant<Ts...> &LHS,
+                                   const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() < RHS.index())
+      return true;
+    if (LHS.index() > RHS.index())
+      return false;
+    return visitSameAlternative(std::less_equal<>{}, LHS, RHS);
+  }
+
+  /// Greater-equal operator.
+  ///
+  /// The alternative types held by LHS and RHS are T and U, respectively; then:
+  ///
+  /// If T precedes U in Ts..., returns false.
+  /// If U precedes T in Ts..., returns true.
+  /// Otherwise, returns LHS.get<T>() >= RHS.get<U>().
+  friend constexpr bool operator>=(const IntrusiveVariant<Ts...> &LHS,
+                                   const IntrusiveVariant<Ts...> &RHS) {
+    if (LHS.index() < RHS.index())
+      return false;
+    if (LHS.index() > RHS.index())
+      return true;
+    return visitSameAlternative(std::greater_equal<>{}, LHS, RHS);
+  }
+
+  /// Enabled if all alternative types overload hash_value.
+  friend hash_code hash_value(const IntrusiveVariant &IV) {
+    return visit(
+        [&](auto &&Alt) { return hash_combine(IV.index(), hash_value(Alt)); },
+        IV);
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_INTRUSIVEVARIANT_H
diff --git a/llvm/include/llvm/ADT/STLForwardCompat.h b/llvm/include/llvm/ADT/STLForwardCompat.h
--- a/llvm/include/llvm/ADT/STLForwardCompat.h
+++ b/llvm/include/llvm/ADT/STLForwardCompat.h
@@ -16,10 +16,31 @@
 #ifndef LLVM_ADT_STLFORWARDCOMPAT_H
 #define LLVM_ADT_STLFORWARDCOMPAT_H
 
+#include <array>
 #include <type_traits>
 
 namespace llvm {
 
+//===----------------------------------------------------------------------===//
+//     Features from C++20
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct remove_cvref // NOLINT(readability-identifier-naming)
+{
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+template <typename T>
+using remove_cvref_t // NOLINT(readability-identifier-naming)
+    = typename llvm::remove_cvref<T>::type;
+
+template <typename T>
+struct type_identity // NOLINT(readability-identifier-naming)
+{
+  using type = T;
+};
+
 //===----------------------------------------------------------------------===//
 //     Features from C++17
 //===----------------------------------------------------------------------===//
@@ -56,26 +77,32 @@
 {
   explicit in_place_type_t() = default;
 };
+/// \warning This must not be odr-used, as it cannot be made \c inline in C++14.
+template <typename T>
+constexpr in_place_type_t<T>
+    in_place_type; // NOLINT(readability-identifier-naming)
 
 template <std::size_t I>
 struct in_place_index_t // NOLINT(readability-identifier-naming)
 {
   explicit in_place_index_t() = default;
 };
+/// \warning This must not be odr-used, as it cannot be made \c inline in C++14.
+template <std::size_t I>
+constexpr in_place_index_t<I>
+    in_place_index; // NOLINT(readability-identifier-naming)
 
-//===----------------------------------------------------------------------===//
-//     Features from C++20
-//===----------------------------------------------------------------------===//
-
-template <typename T>
-struct remove_cvref // NOLINT(readability-identifier-naming)
-{
-  using type = std::remove_cv_t<std::remove_reference_t<T>>;
-};
-
-template <typename T>
-using remove_cvref_t // NOLINT(readability-identifier-naming)
-    = typename llvm::remove_cvref<T>::type;
+/// Implementation of std::experimental::make_array. Should be deleted in favor
+/// of the C++17 deduction guide for std::array.
+template <typename ExplicitT = void, typename... ArgTs>
+static constexpr auto
+make_array(ArgTs &&...Args) // NOLINT(readability-identifier-naming)
+    -> std::array<typename std::conditional_t<std::is_same<ExplicitT, void>{},
+                                              std::common_type<ArgTs...>,
+                                              type_identity<ExplicitT>>::type,
+                  sizeof...(ArgTs)> {
+  return {std::forward<ArgTs>(Args)...};
+}
 
 } // namespace llvm
 
diff --git a/llvm/include/llvm/ADT/VariantTraits.h b/llvm/include/llvm/ADT/VariantTraits.h
new file mode 100644
--- /dev/null
+++ b/llvm/include/llvm/ADT/VariantTraits.h
@@ -0,0 +1,204 @@
+//===- VariantTraits.h - Common interfaces for variant-like types --C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains common interfaces for variant-like types.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+
+#ifndef LLVM_ADT_VARIANTTRAITS_H
+#define LLVM_ADT_VARIANTTRAITS_H
+
+namespace llvm {
+
+/// Trait type which can be specialized over std::variant-like types to provide
+/// the minimum interface needed to share the implementation of llvm::visit and
+/// llvm::visitSameAlternative.
+template <typename VariantT> struct VariantTraits {
+  // // Returns the number of alternative types of VariantT.
+  // static constexpr size_t size();
+  //
+  // // Returns the index of the current alternative type of Variant.
+  // static constexpr size_t index(const VariantT &Variant);
+  //
+  // // Gets the alternative type at Index.
+  // template <size_t Index, typename VariantT = VariantT>
+  // static constexpr decltype(auto) get(VariantT &&Variant);
+};
+
+namespace variant_traits_detail {
+
+template <typename T> using Traits = struct VariantTraits<remove_cvref_t<T>>;
+
+template <typename T> struct HasTraits {
+  using Absent = char;
+  using Present = long;
+  template <typename U> static Absent size(...);
+  template <typename U> static Present size(SameType<size_t (*)(), &U::size> *);
+  template <typename U> static Absent index(...);
+  template <typename U>
+  static Present
+  index(SameType<size_t (*)(const remove_cvref_t<T> &), &U::index> *);
+  template <typename U> static Absent get(...);
+  template <typename U, typename R>
+  static Present get(SameType<R (*)(remove_cvref_t<T> &&), &U::get> *);
+
+  static bool const value = // NOLINT(readability-identifier-naming)
+      sizeof(size<Traits<T>>(nullptr)) == sizeof(Present) &&
+      sizeof(index<Traits<T>>(nullptr)) == sizeof(Present) &&
+      sizeof(get<Traits<T>>(nullptr) == sizeof(Present));
+};
+
+template <size_t Index, typename VisitorT, typename... VariantTs>
+static constexpr decltype(auto)
+thunkForSameAlternative(VisitorT &&Visitor, VariantTs &&...Variants) {
+  return std::forward<VisitorT>(Visitor)(Traits<VariantTs>::template get<Index>(
+      std::forward<VariantTs>(Variants))...);
+}
+
+template <size_t Index, typename VisitorT, typename... VariantTs>
+static constexpr auto makeThunkForSameAlternative() {
+  return thunkForSameAlternative<Index, VisitorT, VariantTs...>;
+}
+
+template <typename VisitorT, typename HeadVariantT, typename... TailVariantTs,
+          size_t... Indexes>
+static constexpr auto
+visitSameAlternativeImpl(size_t Index, std::index_sequence<Indexes...>,
+                         VisitorT &&Visitor, HeadVariantT &&HeadVariant,
+                         TailVariantTs &&...TailVariants) {
+  constexpr auto Thunks =
+      make_array(makeThunkForSameAlternative<Indexes, VisitorT, HeadVariantT,
+                                             TailVariantTs...>()...);
+  return Thunks[Index](std::forward<VisitorT>(Visitor),
+                       std::forward<HeadVariantT>(HeadVariant),
+                       std::forward<TailVariantTs>(TailVariants)...);
+}
+
+template <size_t... Indexes> struct Thunk {
+  template <typename VisitorT, typename... VariantTs>
+  inline static constexpr decltype(auto) thunk(VisitorT &&Visitor,
+                                               VariantTs &&...Variants) {
+    return std::forward<VisitorT>(Visitor)(
+        Traits<VariantTs>::template get<Indexes>(
+            std::forward<VariantTs>(Variants))...);
+  }
+};
+
+template <typename VisitorT, typename... VariantTs, size_t... Indexes>
+static constexpr auto makeThunkForSequence(std::index_sequence<Indexes...>) {
+  return Thunk<Indexes...>::template thunk<VisitorT, VariantTs...>;
+}
+
+template <typename VisitorT, typename... VariantTs,
+          size_t... AccumulatedIndexes>
+static constexpr auto
+accumulateCartesianProductThunks(std::index_sequence<AccumulatedIndexes...>) {
+  return makeThunkForSequence<VisitorT, VariantTs...>(
+      std::index_sequence<AccumulatedIndexes...>{});
+}
+
+template <typename VisitorT, typename... VariantTs,
+          size_t... AccumulatedIndexes, size_t... HeadIndexes,
+          typename... TailSequenceTs>
+static constexpr auto
+accumulateCartesianProductThunks(std::index_sequence<AccumulatedIndexes...>,
+                                 std::index_sequence<HeadIndexes...>,
+                                 TailSequenceTs... Tail) {
+  return make_array(accumulateCartesianProductThunks<VisitorT, VariantTs...>(
+      std::index_sequence<AccumulatedIndexes..., HeadIndexes>{}, Tail...)...);
+}
+
+template <typename VisitorT, typename... VariantTs>
+static constexpr auto makeThunkMatrix() {
+  return accumulateCartesianProductThunks<VisitorT, VariantTs...>(
+      std::index_sequence<>{},
+      std::make_index_sequence<Traits<VariantTs>::size()>{}...);
+}
+
+template <typename ThunkT>
+static constexpr const ThunkT &indexThunkMatrix(const ThunkT &Thunk) {
+  return Thunk;
+}
+
+template <typename ThunkMatrixT, typename... TailIndexTs>
+static constexpr auto &&indexThunkMatrix(const ThunkMatrixT &ThunkMatrix,
+                                         size_t HeadIndex,
+                                         TailIndexTs... TailIndexes) {
+  return indexThunkMatrix(ThunkMatrix[HeadIndex], TailIndexes...);
+}
+
+} // namespace variant_traits_detail
+
+/// Invokes the provided Visitor using overload resolution based on the
+/// dynamic alternative type held in each Variant. See std::variant.
+///
+/// The return type is effectively
+/// decltype(Visitor(Variants.get<HeldAlternatives>()...)). This must be a
+/// valid expression of the same type and value category for every combination
+/// of alternative types of the variant types.
+template <
+    typename VisitorT, typename... VariantTs,
+    typename std::enable_if_t<
+        conjunction<variant_traits_detail::HasTraits<VariantTs>...>::value,
+        int> = 0>
+constexpr decltype(auto) visit(VisitorT &&Visitor, VariantTs &&...Variants) {
+  constexpr auto ThunkMatrix =
+      variant_traits_detail::makeThunkMatrix<VisitorT, VariantTs...>();
+  const auto &Thunk = variant_traits_detail::indexThunkMatrix(
+      ThunkMatrix, variant_traits_detail::Traits<VariantTs>::index(
+                       std::forward<VariantTs>(Variants))...);
+  return Thunk(std::forward<VisitorT>(Visitor),
+               std::forward<VariantTs>(Variants)...);
+}
+
+/// Invokes the provided Visitor using overload resolution based on the dynamic
+/// alternative type held in each Variant, assuming the variants are all of the
+/// same type and hold the same dynamic alternative type.
+///
+/// \warning llvm::visit must be used instead when there is no guarantee that
+/// all variants currently hold the same alternative type. However, when such a
+/// guarantee can be made llvm::visitSameAlternative may reduce code bloat,
+/// especially for debug builds.
+///
+/// The return type is effectively
+/// decltype(Visitor(Variants.get<HeldAlternative>()...)). This must be a valid
+/// expression of the same type and value category for every alternative type
+/// of the variant type.
+template <
+    typename VisitorT, typename HeadVariantT, typename... TailVariantTs,
+    typename std::enable_if_t<
+        conjunction<variant_traits_detail::HasTraits<HeadVariantT>,
+                    variant_traits_detail::HasTraits<TailVariantTs>...>::value,
+        int> = 0>
+static constexpr decltype(auto)
+visitSameAlternative(VisitorT &&Visitor, HeadVariantT &&HeadVariant,
+                     TailVariantTs &&...TailVariants) {
+  static_assert(conjunction<std::is_same<remove_cvref_t<HeadVariantT>,
+                                         remove_cvref_t<TailVariantTs>>...>{},
+                "all variant arguments to visitSameAlternative must "
+                "be of the same type");
+  using Traits = variant_traits_detail::Traits<HeadVariantT>;
+#ifdef EXPENSIVE_CHECKS
+  size_t Index = Traits::index(std::forward<HeadVariantT>(HeadVariant));
+  for (auto &&V : {std::forward<TailVariantTs>(TailVariants)...})
+    assert(Traits::index(V) == Index &&
+           "all variant arguments to visitSameAlternative must have "
+           "the same index");
+#endif
+  return variant_traits_detail::visitSameAlternativeImpl(
+      Traits::index(std::forward<HeadVariantT>(HeadVariant)),
+      std::make_index_sequence<Traits::size()>{},
+      std::forward<VisitorT>(Visitor), std::forward<HeadVariantT>(HeadVariant),
+      std::forward<TailVariantTs>(TailVariants)...);
+}
+
+} // namespace llvm
+
+#endif // LLVM_ADT_VARIANTTRAITS_H
diff --git a/llvm/unittests/ADT/CMakeLists.txt b/llvm/unittests/ADT/CMakeLists.txt
--- a/llvm/unittests/ADT/CMakeLists.txt
+++ b/llvm/unittests/ADT/CMakeLists.txt
@@ -42,6 +42,7 @@
   IntEqClassesTest.cpp
   IntervalMapTest.cpp
   IntrusiveRefCntPtrTest.cpp
+  IntrusiveVariantTest.cpp
   IteratorTest.cpp
   MappedIteratorTest.cpp
   MapVectorTest.cpp
diff --git a/llvm/unittests/ADT/IntrusiveVariantTest.cpp b/llvm/unittests/ADT/IntrusiveVariantTest.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/unittests/ADT/IntrusiveVariantTest.cpp
@@ -0,0 +1,259 @@
+//===- llvm/unittest/Support/AnyTest.cpp - Any tests ---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/IntrusiveVariant.h"
+#include "gtest/gtest.h"
+#include <cstdlib>
+
+using namespace llvm;
+
+namespace {
+
+class A {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+};
+
+class B {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+};
+
+TEST(IntrusiveVariantTest, SingleAlternative) { IntrusiveVariant<A> V; }
+
+TEST(IntrusiveVariantTest, ZeroArgConstructionAndAssignment) {
+  IntrusiveVariant<A, B> V;
+  ASSERT_TRUE(V.holdsAlternative<A>());
+  visit(makeVisitor([](A) {}, [](B) { FAIL(); }), V);
+  visit(makeVisitor([](B) { FAIL(); }, [](A) {}), V);
+  visit(makeVisitor([](A &) {}, [](B &) { FAIL(); }), V);
+  visit(makeVisitor([](A) {}, [](B &) { FAIL(); }), V);
+  visit(makeVisitor([](A &) {}, [](B) { FAIL(); }), V);
+  visit(makeVisitor([](auto &&) {}), V);
+
+  V.emplace<B>();
+  ASSERT_TRUE(V.holdsAlternative<B>());
+
+  IntrusiveVariant<A, B> W{V};
+  ASSERT_TRUE(W.holdsAlternative<B>());
+
+  const IntrusiveVariant<A, B> X{V};
+  ASSERT_TRUE(X.holdsAlternative<B>());
+}
+
+template <typename T> class Alt {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  T Val;
+
+public:
+  Alt(T Val) : Val(Val) {}
+  T getVal() const { return Val; }
+  friend bool operator==(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() == RHS.getVal();
+  }
+  friend bool operator!=(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() != RHS.getVal();
+  }
+  friend bool operator<(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() < RHS.getVal();
+  }
+  friend bool operator>(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() > RHS.getVal();
+  }
+  friend bool operator<=(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() <= RHS.getVal();
+  }
+  friend bool operator>=(const Alt &LHS, const Alt &RHS) {
+    return LHS.getVal() >= RHS.getVal();
+  }
+};
+using I = Alt<int>;
+using F = Alt<float>;
+using D = Alt<double>;
+
+TEST(IntrusiveVariantTest, ConstructionAndAssignment) {
+  IntrusiveVariant<I, F, D> V{in_place_type<F>, 2.0f};
+  visit(makeVisitor([](I) { FAIL(); }, [](F X) { EXPECT_EQ(X.getVal(), 2.0f); },
+                    [](D) { FAIL(); }),
+        V);
+  IntrusiveVariant<I, F, D> W{V};
+  visit(makeVisitor([](I) { FAIL(); }, [](F X) { EXPECT_EQ(X.getVal(), 2.0f); },
+                    [](D) { FAIL(); }),
+        W);
+  W.emplace<I>(42);
+  visit(makeVisitor([](I X) { EXPECT_EQ(X.getVal(), 42); }, [](F) { FAIL(); },
+                    [](D) { FAIL(); }),
+        W);
+  W = V;
+  visit(makeVisitor([](I) { FAIL(); }, [](F X) { EXPECT_EQ(X.getVal(), 2.0f); },
+                    [](D) { FAIL(); }),
+        W);
+}
+
+TEST(IntrusiveVariantTest, Comparison) {
+  IntrusiveVariant<I, F, D> V{in_place_type<I>, 1};
+  IntrusiveVariant<I, F, D> W{in_place_type<F>, 2.0f};
+  IntrusiveVariant<I, F, D> X{in_place_type<F>, 2.0f};
+  IntrusiveVariant<I, F, D> Y{in_place_type<F>, 3.0f};
+  IntrusiveVariant<I, F, D> Z{in_place_type<D>, 3.0};
+  EXPECT_NE(V, W);
+  EXPECT_LT(V, W);
+  EXPECT_LE(V, W);
+  EXPECT_GT(W, V);
+  EXPECT_GE(W, V);
+  EXPECT_EQ(W, X);
+  EXPECT_LE(W, X);
+  EXPECT_GE(W, X);
+  EXPECT_NE(W, Y);
+  EXPECT_NE(X, Y);
+  EXPECT_LT(X, Y);
+  EXPECT_LE(X, Y);
+  EXPECT_GT(Y, X);
+  EXPECT_GE(Y, X);
+  EXPECT_NE(Y, Z);
+  std::swap(X, Y);
+  EXPECT_EQ(W, Y);
+  EXPECT_NE(W, X);
+}
+
+TEST(IntrusiveVariantTest, IntrusiveVariantSize) {
+  constexpr auto One = IntrusiveVariantSize<IntrusiveVariant<I>>{};
+  EXPECT_EQ(One, 1u);
+  constexpr auto Two = IntrusiveVariantSize<IntrusiveVariant<I, F>>{};
+  EXPECT_EQ(Two, 2u);
+  constexpr auto Three = IntrusiveVariantSize<IntrusiveVariant<I, F, D>>{};
+  EXPECT_EQ(Three, 3u);
+}
+
+TEST(IntrusiveVariantTest, HoldsAlternative) {
+  IntrusiveVariant<I, F, D> V{in_place_type<D>, 2.0};
+  EXPECT_FALSE(V.holdsAlternative<I>());
+  EXPECT_FALSE(V.holdsAlternative<F>());
+  EXPECT_TRUE(V.holdsAlternative<D>());
+  V.emplace<I>(1);
+  EXPECT_TRUE(V.holdsAlternative<I>());
+  EXPECT_FALSE(V.holdsAlternative<F>());
+  EXPECT_FALSE(V.holdsAlternative<D>());
+  const IntrusiveVariant<I, F, D> C{in_place_type<F>, 2.0f};
+  EXPECT_FALSE(C.holdsAlternative<I>());
+  EXPECT_TRUE(C.holdsAlternative<F>());
+  EXPECT_FALSE(C.holdsAlternative<D>());
+}
+
+TEST(IntrusiveVariantTest, Get) {
+  IntrusiveVariant<I, F, D> V{in_place_type<D>, 2.0};
+  EXPECT_EQ(V.get<D>(), D{2.0});
+  EXPECT_EQ(V.get<D>(), *V.getIf<D>());
+  EXPECT_EQ(&V.get<D>(), V.getIf<D>());
+  V.emplace<I>(1);
+  EXPECT_EQ(V.get<I>(), I{1});
+  EXPECT_EQ(V.get<I>(), *V.getIf<I>());
+  EXPECT_EQ(&V.get<I>(), V.getIf<I>());
+  const IntrusiveVariant<I, F, D> C{in_place_type<D>, 2.0};
+  EXPECT_EQ(C.get<D>(), D{2.0});
+  EXPECT_EQ(C.get<D>(), *C.getIf<D>());
+  EXPECT_EQ(&C.get<D>(), C.getIf<D>());
+}
+
+TEST(IntrusiveVariantTest, GetIf) {
+  IntrusiveVariant<I, F, D> V{in_place_type<D>, 2.0};
+  EXPECT_EQ(V.getIf<I>(), nullptr);
+  EXPECT_EQ(V.getIf<F>(), nullptr);
+  EXPECT_NE(V.getIf<D>(), nullptr);
+  V.emplace<I>(1);
+  EXPECT_NE(V.getIf<I>(), nullptr);
+  EXPECT_EQ(V.getIf<F>(), nullptr);
+  EXPECT_EQ(V.getIf<D>(), nullptr);
+  const IntrusiveVariant<I, F, D> C{in_place_type<F>, 2.0f};
+  EXPECT_EQ(C.getIf<I>(), nullptr);
+  EXPECT_NE(C.getIf<F>(), nullptr);
+  EXPECT_EQ(C.getIf<D>(), nullptr);
+}
+
+struct IntA {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  int Val;
+  IntA(int Val) : Val(Val) {}
+  friend hash_code hash_value(const IntA &IA) { return hash_value(IA.Val); }
+};
+
+struct IntB {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  int Val;
+  IntB(int Val) : Val(Val) {}
+  friend hash_code hash_value(const IntB &IB) { return hash_value(IB.Val); }
+};
+
+TEST(IntrusiveVariantTest, HashValue) {
+  IntrusiveVariant<IntA, IntB> ATwo{in_place_type<IntA>, 2};
+  IntrusiveVariant<IntA, IntB> AThree{in_place_type<IntA>, 3};
+  IntrusiveVariant<IntA, IntB> BTwo{in_place_type<IntB>, 2};
+  EXPECT_EQ(hash_value(ATwo), hash_value(ATwo));
+  EXPECT_NE(hash_value(ATwo), hash_value(AThree));
+  EXPECT_NE(hash_value(ATwo), hash_value(BTwo));
+}
+
+class AltInt {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  int Int;
+
+public:
+  AltInt() : Int(0) {}
+  AltInt(int Int) : Int(Int) {}
+  int getInt() const { return Int; }
+  void setInt(int Int) { this->Int = Int; }
+};
+
+class AltDouble {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  double Double;
+
+public:
+  AltDouble(double Double) : Double(Double) {}
+  double getDouble() const { return Double; }
+  void setDouble(double Double) { this->Double = Double; }
+};
+
+class AltComplexInt {
+  DECLARE_INTRUSIVE_ALTERNATIVE
+  int Real;
+  int Imag;
+
+public:
+  AltComplexInt(int Real, int Imag) : Real(Real), Imag(Imag) {}
+  int getReal() const { return Real; }
+  void setReal(int Real) { this->Real = Real; }
+  int getImag() const { return Imag; }
+  void setImag(int Imag) { this->Imag = Imag; }
+};
+
+TEST(IntrusiveVariantTest, HeaderExample) {
+  using MyVariant = IntrusiveVariant<AltInt, AltDouble, AltComplexInt>;
+
+  MyVariant DefaultConstructedVariant;
+  ASSERT_TRUE(DefaultConstructedVariant.holdsAlternative<AltInt>());
+  ASSERT_EQ(DefaultConstructedVariant.get<AltInt>().getInt(), 0);
+  MyVariant Variant{in_place_type<AltComplexInt>, 4, 2};
+  ASSERT_TRUE(Variant.holdsAlternative<AltComplexInt>());
+  int NonSense = visit(
+      makeVisitor(
+          [](AltInt &AI) { return AI.getInt(); },
+          [](AltDouble &AD) { return static_cast<int>(AD.getDouble()); },
+          [](AltComplexInt &ACI) { return ACI.getReal() + ACI.getImag(); }),
+      Variant);
+  ASSERT_EQ(NonSense, 6);
+  Variant.emplace<AltDouble>(2.0);
+  ASSERT_TRUE(Variant.holdsAlternative<AltDouble>());
+  Variant.get<AltDouble>().setDouble(3.0);
+  AltDouble AD = Variant.get<AltDouble>();
+  double D = AD.getDouble();
+  ASSERT_EQ(D, 3.0);
+  Variant.emplace<AltComplexInt>(4, 5);
+  ASSERT_EQ(Variant.get<AltComplexInt>().getReal(), 4);
+  ASSERT_EQ(Variant.get<AltComplexInt>().getImag(), 5);
+}
+
+} // anonymous namespace
diff --git a/llvm/unittests/ADT/STLForwardCompatTest.cpp b/llvm/unittests/ADT/STLForwardCompatTest.cpp
--- a/llvm/unittests/ADT/STLForwardCompatTest.cpp
+++ b/llvm/unittests/ADT/STLForwardCompatTest.cpp
@@ -42,6 +42,17 @@
                                  std::true_type>::value));
 }
 
+TEST(STLForwardCompatTest, MakeArrayTest) {
+  ASSERT_EQ((llvm::make_array<int>()), (std::array<int, 0u>{}));
+  ASSERT_EQ((llvm::make_array<size_t>()), (std::array<size_t, 0u>{}));
+  ASSERT_EQ((llvm::make_array<size_t>(1u, 2u, 3u)),
+            (std::array<size_t, 3u>{1, 2, 3}));
+  ASSERT_EQ((llvm::make_array<size_t>(1u, 2u, 3u)),
+            (llvm::make_array(size_t(1), size_t(2u), size_t(3u))));
+  ASSERT_EQ((llvm::make_array(true, false, false, true)),
+            (std::array<bool, 4u>{true, false, false, true}));
+}
+
 template <typename T>
 class STLForwardCompatRemoveCVRefTest : public ::testing::Test {};