[include-cleaner] Make Symbol (and Macro) hashable.

[sammccall]

Summary

For now, we decided not to add operator< or handle other variants.
(If we do so in future we may want to extract a base class).

[kadircet]

thanks, lgtm!

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

146

probably left over?

clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h

struct Symbol {
 
   Kind kind() const { return static_cast<Kind>(Storage.index()); }
   bool operator==(const Symbol &RHS) const { return Storage == RHS.Storage; }
 
   const Decl &declaration() const { return *std::get<Declaration>(Storage); }
   struct Macro macro() const { return std::get<Macro>(Storage); }
 
 private:
-  // FIXME: Add support for macros.
   // Order must match Kind enum!
   std::variant<const Decl *, struct Macro> Storage;
+
+  Symbol(decltype(Storage) Sentinel) : Storage(std::move(Sentinel)) {}
+  friend llvm::DenseMapInfo<Symbol>;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Symbol &);
 
 /// Indicates the relation between the reference and the target.
 enum class RefType {
   /// Target is named by the reference, e.g. function call.
   Explicit,
   /// Target isn't spelled, e.g. default constructor call in `Foo f;`
struct Include {
   SourceLocation HashLocation;         // of hash in #include <vector>
   unsigned Line = 0;                   // 1-based line number for #include
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Include &);
 
 } // namespace include_cleaner
 } // namespace clang
 
+namespace llvm {
+
+template <> struct DenseMapInfo<clang::include_cleaner::Symbol> {
+  using Outer = clang::include_cleaner::Symbol;
+  using Base = DenseMapInfo<decltype(Outer::Storage)>;
+
+  static inline Outer getEmptyKey() { return {Base::getEmptyKey()}; }
+  static inline Outer getTombstoneKey() { return {Base::getTombstoneKey()}; }
+  static unsigned getHashValue(const Outer &Val) {
+    return Base::getHashValue(Val.Storage);
+  }
+  static bool isEqual(const Outer &LHS, const Outer &RHS) {
+    return Base::isEqual(LHS.Storage, RHS.Storage);
+  }
+};
+template <> struct DenseMapInfo<clang::include_cleaner::Macro> {
+  using Outer = clang::include_cleaner::Macro;
+  using Base = DenseMapInfo<decltype(Outer::Definition)>;
+
+  static inline Outer getEmptyKey() { return {nullptr, Base::getEmptyKey()}; }
+  static inline Outer getTombstoneKey() {
+    return {nullptr, Base::getTombstoneKey()};
+  }
+  static unsigned getHashValue(const Outer &Val) {
+    return Base::getHashValue(Val.Definition);
+  }
+  static bool isEqual(const Outer &LHS, const Outer &RHS) {
+    return Base::isEqual(LHS.Definition, RHS.Definition);
+  }
+};
+} // namespace llvm
+
 #endif