ADT: Add hash_value overload for Optional

[dexonsmith]

Summary

Add a hash_value for Optional so that other data structures with
optional fields can easily hash them. I have a use for this in an
upcoming patch.

[dblaikie]

Looks good, thanks!

llvm/include/llvm/ADT/Optional.h

 //  OCaml's 'opt' variant.  The idea is to strongly type whether or not
 //  a value can be optional.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_OPTIONAL_H
 #define LLVM_ADT_OPTIONAL_H
 
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <memory>
 #include <new>
 #include <utility>
 
#if LLVM_HAS_RVALUE_REFERENCE_THIS
   auto map(const Function &F) &&
       -> Optional<decltype(F(std::move(*this).getValue()))> {
     if (*this) return F(std::move(*this).getValue());
     return None;
   }
 #endif
 };
 
+template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
+  return O ? hash_combine(true, *O) : hash_value(false);
+}
+
 template <typename T, typename U>
 constexpr bool operator==(const Optional<T> &X, const Optional<U> &Y) {
   if (X && Y)
     return *X == *Y;
   return X.hasValue() == Y.hasValue();
 }
 
 template <typename T, typename U>

llvm/unittests/ADT/OptionalTest.cpp

EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, ComparableAndStreamable::get()),
                           "To be equal to: ComparableAndStreamable::get()\n"
                           "      Which is: ComparableAndStreamable");
 
   // Test that it is still possible to compare objects which do not have a
   // custom streaming operator.
   EXPECT_NONFATAL_FAILURE(EXPECT_EQ(llvm::None, Comparable::get()), "object");
 }
 
+TEST(OptionalTest, HashValue) {
+  // Check that None, false, and true all hash differently.
+  Optional<bool> B, B0 = false, B1 = true;
+  EXPECT_NE(hash_value(B0), hash_value(B));
+  EXPECT_NE(hash_value(B1), hash_value(B));
+  EXPECT_NE(hash_value(B1), hash_value(B0));
+
+  // Check that None, 0, and 1 all hash differently.
+  Optional<int> I, I0 = 0, I1 = 1;
+  EXPECT_NE(hash_value(I0), hash_value(I));
+  EXPECT_NE(hash_value(I1), hash_value(I));
+  EXPECT_NE(hash_value(I1), hash_value(I0));
+
+  // Check None hash the same way regardless of type.
+  EXPECT_EQ(hash_value(B), hash_value(I));
+}
+
 } // end anonymous namespace