[Support] Automatically support `hash_value` ...

[arames]

Summary

... when HashBuilder support is available.

[arames]

This was the result of a bad arc command.

llvm/include/llvm/Support/HashBuilder.h

 // about hashed data types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_HASHBUILDER_H
 #define LLVM_SUPPORT_HASHBUILDER_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/type_traits.h"
 
 #include <iterator>
 #include <utility>
 
 namespace llvm {
 
+namespace hashbuilder_detail {
+/// Trait to indicate whether a type's bits can be hashed directly (after
+/// endianness correction).
+template <typename U>
+struct IsHashableData
+    : std::integral_constant<bool, is_integral_or_enum<U>::value> {};
+
+} // namespace hashbuilder_detail
+
 /// Declares the hasher member, and functions forwarding directly to the hasher.
 template <typename HasherT> class HashBuilderBase {
 public:
   HasherT &getHasher() { return Hasher; }
 
   /// Forward to `HasherT::update(ArrayRef<uint8_t>)`.
   ///
   /// This may not take the size of `Data` into account.

 
 /// Implementation of the `HashBuilder` interface.
 ///
 /// `support::endianness::native` is not supported. `HashBuilder` is
 /// expected to canonicalize `support::endianness::native` to one of
 /// `support::endianness::big` or `support::endianness::little`.
 template <typename HasherT, support::endianness Endianness>
 class HashBuilderImpl : public HashBuilderBase<HasherT> {
+public:
   static_assert(Endianness != support::endianness::native,
                 "HashBuilder should canonicalize endianness");
-  /// Trait to indicate whether a type's bits can be hashed directly (after
-  /// endianness correction).
-  template <typename U>
-  struct IsHashableData
-      : std::integral_constant<bool, is_integral_or_enum<U>::value> {};
 
-public:
   explicit HashBuilderImpl(HasherT &Hasher)
       : HashBuilderBase<HasherT>(Hasher) {}
   template <typename... ArgTypes>
   explicit HashBuilderImpl(ArgTypes &&...Args)
       : HashBuilderBase<HasherT>(Args...) {}
 
   /// Implement hashing for hashable data types, e.g. integral or enum values.
   template <typename T>
-  std::enable_if_t<IsHashableData<T>::value, HashBuilderImpl &> add(T Value) {
+  std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value,
+                   HashBuilderImpl &>
+  add(T Value) {
     return adjustForEndiannessAndAdd(Value);
   }
 
   /// Support hashing `ArrayRef`.
   ///
   /// `Value.size()` is taken into account to ensure cases like
   /// ```
   /// builder.add({1});
   /// builder.add({2, 3});
   /// ```
   /// and
   /// ```
   /// builder.add({1, 2});
   /// builder.add({3});
   /// ```
   /// do not collide.
   template <typename T> HashBuilderImpl &add(ArrayRef<T> Value) {
     // As of implementation time, simply calling `addRange(Value)` would also go
     // through the `update` fast path. But that would rely on the implementation
     // details of `ArrayRef::begin()` and `ArrayRef::end()`. Explicitly call
     // `update` to guarantee the fast path.
     add(Value.size());
-    if (IsHashableData<T>::value &&
+    if (hashbuilder_detail::IsHashableData<T>::value &&
         Endianness == support::endian::system_endianness()) {
       this->update(
           makeArrayRef(reinterpret_cast<const uint8_t *>(Value.begin()),
                        Value.size() * sizeof(T)));
     } else {
       for (auto &V : Value)
         add(V);
     }
public:
   ///       HBuilder.addRange(&Value.Elements[0], &Value.Elements[0] +
   ///       Value.Size);
   ///     }
   ///   }
   /// };
   /// ```
   template <typename T>
   std::enable_if_t<is_detected<HasAddHashT, T>::value &&
-                       !IsHashableData<T>::value,
+                       !hashbuilder_detail::IsHashableData<T>::value,
                    HashBuilderImpl &>
   add(const T &Value) {
     addHash(*this, Value);
     return *this;
   }
 
   template <typename T1, typename T2>
   HashBuilderImpl &add(const std::pair<T1, T2> &Value) {
HashBuilderImpl &addRangeElementsImpl(ForwardIteratorT First,
                                         ForwardIteratorT Last,
                                         std::forward_iterator_tag) {
     for (auto It = First; It != Last; ++It)
       add(*It);
     return *this;
   }
 
   template <typename T>
-  std::enable_if_t<IsHashableData<T>::value &&
+  std::enable_if_t<hashbuilder_detail::IsHashableData<T>::value &&
                        Endianness == support::endian::system_endianness(),
                    HashBuilderImpl &>
   addRangeElementsImpl(T *First, T *Last, std::forward_iterator_tag) {
     this->update(makeArrayRef(reinterpret_cast<const uint8_t *>(First),
                               (Last - First) * sizeof(T)));
     return *this;
   }
 };

 /// computation (for example when computing `add((int)123)`).
 /// Specifiying a non-`native` `Endianness` template parameter allows to compute
 /// stable hash across platforms with different endianness.
 template <class HasherT, support::endianness Endianness>
 using HashBuilder =
     HashBuilderImpl<HasherT, (Endianness == support::endianness::native
                                   ? support::endian::system_endianness()
                                   : Endianness)>;
+
+class HashCodeHasher {
+public:
+  HashCodeHasher() : Code(0) {}
+  void update(ArrayRef<uint8_t> Data) {
+    hash_code DataCode = hash_value(Data);
+    Code = hash_combine(Code, DataCode);
+  }
+  hash_code Code;
+};
+
+namespace hashbuilder_detail {
+/// Provide a default implementation of `hash_value` when `addHash(const T &)`
+/// is supported.
+using HashCodeHashBuilder =
+    HashBuilder<HashCodeHasher, support::endianness::native>;
+} // namespace hashbuilder_detail
+
+template <typename T>
+std::enable_if_t<
+    is_detected<hashbuilder_detail::HashCodeHashBuilder::HasAddHashT, T>::value,
+    hash_code>
+hash_value(const T &Value) {
+  hashbuilder_detail::HashCodeHashBuilder HBuilder;
+  HBuilder.add(Value);
+  return HBuilder.getHasher().Code;
+}
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_HASHBUILDER_H

llvm/unittests/ADT/HashingTest.cpp

 //===- llvm/unittest/ADT/HashingTest.cpp ----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Hashing.h unit tests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Hashing.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/HashBuilder.h"
 #include "gtest/gtest.h"
 #include <deque>
 #include <list>
 #include <map>
 #include <vector>
 
 namespace llvm {
 
#define CHECK_SAME(...)                                                        \
   CHECK_SAME(1, 2, 3, 4, 5);
   CHECK_SAME(1, 2, 3, 4);
   CHECK_SAME(1, 2, 3);
   CHECK_SAME(1, 2);
   CHECK_SAME(1);
 #undef CHECK_SAME
 }
 
+struct StructWithHashBuilderSupport {
+  char C;
+  int I;
+  template <typename HasherT, llvm::support::endianness Endianness>
+  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+                      const StructWithHashBuilderSupport &Value) {
+    HBuilder.add(Value.C, Value.I);
   }
+};
+
+TEST(HashingTest, HashWithHashBuilder) {
+  StructWithHashBuilderSupport S{'c', 1};
+  EXPECT_NE(static_cast<size_t>(llvm::hash_value(S)), static_cast<size_t>(0));
+}
+
+struct StructWithHashBuilderAndHashValueSupport {
+  char C;
+  int I;
+  template <typename HasherT, llvm::support::endianness Endianness>
+  friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder,
+                      const StructWithHashBuilderAndHashValueSupport &Value) {}
+  friend hash_code
+  hash_value(const StructWithHashBuilderAndHashValueSupport &Value) {
+    return 0xbeef;
+  }
+};
+
+TEST(HashingTest, HashBuilderAndHashValue) {
+  StructWithHashBuilderAndHashValueSupport S{'c', 1};
+  EXPECT_EQ(static_cast<size_t>(hash_value(S)), static_cast<size_t>(0xbeef));
+}
+
+} // namespace