[ADT] Remove CachedHash, which is unused.

[timshen]

It's used in lld/ELF/SymbolTable.h .

[jlebar]

It's used in lld/ELF/SymbolTable.h .

Dang, you are right. I was thrown off because the lines above use CachedHashString, which is different.

This actually looks pretty reasonable, too.

I guess that does it for this patch.

[jlebar]

Reopening -- I now have the mechanisms (soon to be added as dependent patches) in place to get rid of this again.

Rafael, I've structured this removal as one clean commit so if you ever want to resurrect this class, it'll be relatively easy.

[jlebar]

Rebase patch.

llvm/include/llvm/ADT/DenseMapInfo.h

 template<typename T>
 struct DenseMapInfo {
   //static inline T getEmptyKey();
   //static inline T getTombstoneKey();
   //static unsigned getHashValue(const T &Val);
   //static bool isEqual(const T &LHS, const T &RHS);
 };
 
-template <typename T> struct CachedHash {
-  CachedHash(T Val) : Val(std::move(Val)) {
-    Hash = DenseMapInfo<T>::getHashValue(Val);
-  }
-  CachedHash(T Val, unsigned Hash) : Val(std::move(Val)), Hash(Hash) {}
-  T Val;
-  unsigned Hash;
-};
-
-// Provide DenseMapInfo for all CachedHash<T>.
-template <typename T> struct DenseMapInfo<CachedHash<T>> {
-  static CachedHash<T> getEmptyKey() {
-    T N = DenseMapInfo<T>::getEmptyKey();
-    return {N, 0};
-  }
-  static CachedHash<T> getTombstoneKey() {
-    T N = DenseMapInfo<T>::getTombstoneKey();
-    return {N, 0};
-  }
-  static unsigned getHashValue(CachedHash<T> Val) {
-    assert(!isEqual(Val, getEmptyKey()) && "Cannot hash the empty key!");
-    assert(!isEqual(Val, getTombstoneKey()) &&
-           "Cannot hash the tombstone key!");
-    return Val.Hash;
-  }
-  static bool isEqual(CachedHash<T> A, CachedHash<T> B) {
-    return DenseMapInfo<T>::isEqual(A.Val, B.Val);
-  }
-};
-
 // Provide DenseMapInfo for all pointers.
 template<typename T>
 struct DenseMapInfo<T*> {
   static inline T* getEmptyKey() {
     uintptr_t Val = static_cast<uintptr_t>(-1);
     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
     return reinterpret_cast<T*>(Val);
   }

llvm/unittests/ADT/DenseMapTest.cpp

TEST(DenseMapCustomTest, StringRefTest) {
   EXPECT_EQ(0, M.lookup(StringRef()));
   EXPECT_EQ(0, M.lookup(StringRef("a", 0)));
   M[""] = 42;
   EXPECT_EQ(42, M.lookup(""));
   EXPECT_EQ(42, M.lookup(StringRef()));
   EXPECT_EQ(42, M.lookup(StringRef("a", 0)));
 }
 
-struct CachedHashTest {
-  unsigned Val;
-  unsigned *Counter = nullptr;
-  CachedHashTest(unsigned Val) : Val(Val) {}
-  CachedHashTest(unsigned Val, unsigned *Counter)
-      : Val(Val), Counter(Counter) {}
-};
-}
-namespace llvm {
-template <> struct DenseMapInfo<CachedHashTest> {
-  static CachedHashTest getEmptyKey() { return ~0; }
-  static CachedHashTest getTombstoneKey() { return ~0U - 1; }
-  static unsigned getHashValue(const CachedHashTest &X) {
-    ++*X.Counter;
-    return X.Val;
-  }
-  static bool isEqual(const CachedHashTest &LHS, const CachedHashTest &RHS) {
-    return LHS.Val == RHS.Val;
-  }
-};
-}
-namespace {
-
-TEST(DenseMapCustomTest, CachedHashTest) {
-  unsigned Counter = 0;
-  CachedHashTest Val(0, &Counter);
-  DenseMap<CachedHashTest, int> Map;
-
-  Map[Val] = 0;
-  ASSERT_EQ(1u, Counter);
-
-  Map.reserve(64);
-  ASSERT_EQ(2u, Counter);
-}
-
-// Like above, but now cache the hash.
-TEST(DenseMapCustomTest, CachedHashTest2) {
-  unsigned Counter = 0;
-  CachedHashTest Val(0, &Counter);
-  typedef CachedHash<CachedHashTest> Cached;
-  DenseMap<Cached, int> Map;
-
-  Map[Val] = 0;
-  ASSERT_EQ(1u, Counter);
-
-  Map.reserve(64);
-  ASSERT_EQ(1u, Counter);
-}
-
 // Key traits that allows lookup with either an unsigned or char* key;
 // In the latter case, "a" == 0, "b" == 1 and so on.
 struct TestDenseMapInfo {
   static inline unsigned getEmptyKey() { return ~0; }
   static inline unsigned getTombstoneKey() { return ~0U - 1; }
   static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
   static unsigned getHashValue(const char* Val) {
     return (unsigned)(Val[0] - 'a') * 37U;