[DenseMapInfo] Move hash_code implementation to Hashing.h

[nikic]

Summary

This moves the DenseMapInfo implementation for hash_code into Hashing.h, removing the need to include Hashing.h (and thus <string>) in DenseMapInfo.h. This follows the general convention of declaring DenseMapInfo for types that we own in the respective header. The remaining implementations in DenseMapInfo.h are all for types we do not own.

[lattner]

nice, makes sense. I'm surprised more #include <string> instances weren't needed in other downstream headers and .cpp files.

[nikic]

In D111451#3052300, @lattner wrote:

nice, makes sense. I'm surprised more #include <string> instances weren't needed in other downstream headers and .cpp files.

I landed the necessary (at least for my build) include fixups ahead of time in https://github.com/llvm/llvm-project/commit/cfb53d8e6d6383c9622331224acf0abb03cb1713. Interestingly no <string> includes in particular were needed.

[RKSimon]

Thanks for looking at this @nikic - are you using https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html to identify candidate includes or have you been able to get another tool like iwyu to help?

llvm/include/llvm/ADT/DenseMapInfo.h

 //===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- 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 defines DenseMapInfo traits for DenseMap.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_DENSEMAPINFO_H
 #define LLVM_ADT_DENSEMAPINFO_H
 
-#include "llvm/ADT/Hashing.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
 
template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
   }
 
   static bool isEqual(const Tuple &lhs, const Tuple &rhs) {
     std::integral_constant<bool, 0 == sizeof...(Ts)> atEnd;
     return isEqualImpl<0>(lhs, rhs, atEnd);
   }
 };
 
-template <> struct DenseMapInfo<hash_code> {
-  static inline hash_code getEmptyKey() { return hash_code(-1); }
-  static inline hash_code getTombstoneKey() { return hash_code(-2); }
-  static unsigned getHashValue(hash_code val) { return val; }
-  static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
-};
-
 } // end namespace llvm
 
 #endif // LLVM_ADT_DENSEMAPINFO_H

llvm/include/llvm/ADT/Hashing.h

 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <string>
 #include <tuple>
 #include <utility>
 
 namespace llvm {
+template <typename T> struct DenseMapInfo;
 
 /// An opaque object representing a hash code.
 ///
 /// This object represents the result of hashing some entity. It is intended to
 /// be used to implement hashtables or other hashing-based data structures.
 /// While it wraps and exposes a numeric value, this value should not be
 /// trusted to be stable or predictable across processes or executions.
 ///

 
 // Declared and documented above, but defined here so that any of the hashing
 // infrastructure is available.
 template <typename T>
 hash_code hash_value(const std::basic_string<T> &arg) {
   return hash_combine_range(arg.begin(), arg.end());
 }
 
+template <> struct DenseMapInfo<hash_code> {
+  static inline hash_code getEmptyKey() { return hash_code(-1); }
+  static inline hash_code getTombstoneKey() { return hash_code(-2); }
+  static unsigned getHashValue(hash_code val) { return val; }
+  static bool isEqual(hash_code LHS, hash_code RHS) { return LHS == RHS; }
+};
+
 } // namespace llvm
 
 #endif