#include <cstddef>
#include <cstdint>
#include <tuple>
+#include <type_traits>
#include <utility>
+#include <variant>
namespace llvm {
}
};
+// Provide DenseMapInfo for variants whose all alternatives have DenseMapInfo.
+template <typename... Ts> struct DenseMapInfo<std::variant<Ts...>> {
+ using Variant = std::variant<Ts...>;
+ using FirstT = std::variant_alternative_t<0, Variant>;
+
+ static inline Variant getEmptyKey() {
+ return Variant(std::in_place_index<0>, DenseMapInfo<FirstT>::getEmptyKey());
+ }
+
+ static inline Variant getTombstoneKey() {
+ return Variant(std::in_place_index<0>,
+ DenseMapInfo<FirstT>::getTombstoneKey());
+ }
+
+ static unsigned getHashValue(const Variant &Val) {
+ return std::visit(
+ [&Val](auto &&Alternative) {
+ using T = std::decay_t<decltype(Alternative)>;
+ // Include index in hash to make sure same value as different
+ // alternatives don't collide.
+ return detail::combineHashValue(
+ DenseMapInfo<size_t>::getHashValue(Val.index()),
+ DenseMapInfo<T>::getHashValue(Alternative));
+ },
+ Val);
+ }
+
+ static bool isEqual(const Variant &LHS, const Variant &RHS) {
+ return LHS == RHS;
+ }
+};
} // end namespace llvm
#endif // LLVM_ADT_DENSEMAPINFO_H
//===----------------------------------------------------------------------===//
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <map>
#include <set>
+#include <utility>
+#include <variant>
using namespace llvm;
EXPECT_EQ(Map.find(Keys[1]), Map.end());
EXPECT_EQ(Map.find(Keys[2]), Map.end());
}
+
+TEST(DenseMapCustomTest, VariantSupport) {
+ using variant = std::variant<int, int>;
+ DenseMap<variant, int> Map;
+ variant Keys[] = {
+ variant(std::in_place_index<0>, 1),
+ variant(std::in_place_index<1>, 1),
+ };
+ Map.try_emplace(Keys[0], 0);
+ Map.try_emplace(Keys[1], 1);
+ EXPECT_THAT(Map, testing::SizeIs(2));
+ EXPECT_NE(DenseMapInfo<variant>::getHashValue(Keys[0]),
+ DenseMapInfo<variant>::getHashValue(Keys[1]));
+}
} // namespace