diff --git a/llvm/include/llvm/ADT/Hashing.h b/llvm/include/llvm/ADT/Hashing.h
--- a/llvm/include/llvm/ADT/Hashing.h
+++ b/llvm/include/llvm/ADT/Hashing.h
@@ -113,13 +113,14 @@
 template <typename T, typename U>
 hash_code hash_value(const std::pair<T, U> &arg);
 
+/// Compute a hash_code for a tuple.
+template <typename... Ts>
+hash_code hash_value(const std::tuple<Ts...> &arg);
+
 /// Compute a hash_code for a standard string.
 template <typename T>
 hash_code hash_value(const std::basic_string<T> &arg);
 
-/// Compute a hash_code for a tuple.
-template <typename... Ts> hash_code hash_value(const std::tuple<Ts...> &arg);
-
 /// Override the execution seed with a fixed value.
 ///
 /// This hashing library uses a per-execution seed designed to change on each
@@ -648,40 +649,13 @@
   return hash_combine(arg.first, arg.second);
 }
 
-// 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());
-}
-
 // Implementation details for the hash_value overload for std::tuple<...>(...).
 namespace hashing {
 namespace detail {
 
-// The indices of a tuple (0..n-1) are collected as the Indices template
-// parameter of the TupleIndexSet template.
-template <unsigned... Indices> struct TupleIndexSet {};
-
-// Collecting the indices uses recursive template metaprogramming via the
-// MakeTupleIndexSet struct. The I template parameter recursively
-// counts up to N-1. The values are collected in the Indices template parameter
-// and then returned in the second template specialization when I reaches N.
-template <unsigned I, unsigned N, unsigned... Indices>
-struct MakeTupleIndexSet {
-  typedef typename MakeTupleIndexSet<I + 1, N, Indices..., I>::Type Type;
-};
-
-template <unsigned N, unsigned... Indices>
-struct MakeTupleIndexSet<N, N, Indices...> {
-  typedef TupleIndexSet<Indices...> Type;
-};
-
-// The indices are then expanded in the hash_value_tuple_helper function into
-// std::get<...>(...) calls.
-template <typename... Ts, unsigned... Indices>
+template <typename... Ts, std::size_t... Indices>
 hash_code hash_value_tuple_helper(const std::tuple<Ts...> &arg,
-                                  TupleIndexSet<Indices...> indices) {
+                                  std::index_sequence<Indices...> indices) {
   return hash_combine(std::get<Indices>(arg)...);
 }
 
@@ -689,9 +663,16 @@
 } // namespace hashing
 
 template <typename... Ts> hash_code hash_value(const std::tuple<Ts...> &arg) {
-  typename ::llvm::hashing::detail::MakeTupleIndexSet<0, sizeof...(Ts)>::Type
-      indices;
-  return hash_value_tuple_helper(arg, indices);
+  // TODO: Use std::apply when LLVM starts using C++17.
+  return ::llvm::hashing::detail::hash_value_tuple_helper(
+      arg, typename std::index_sequence_for<Ts...>());
+}
+
+// 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());
 }
 
 } // namespace llvm
diff --git a/llvm/unittests/ADT/HashingTest.cpp b/llvm/unittests/ADT/HashingTest.cpp
--- a/llvm/unittests/ADT/HashingTest.cpp
+++ b/llvm/unittests/ADT/HashingTest.cpp
@@ -105,6 +105,11 @@
   EXPECT_EQ(hash_combine(), hash_value(std::make_tuple()));
   EXPECT_EQ(hash_combine(42), hash_value(std::make_tuple(42)));
   EXPECT_EQ(hash_combine(42, 'c'), hash_value(std::make_tuple(42, 'c')));
+
+  EXPECT_NE(hash_combine(43, 42), hash_value(std::make_tuple(42, 43)));
+  EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42ull, 43ull)));
+  EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42, 43ull)));
+  EXPECT_NE(hash_combine(42, 43), hash_value(std::make_tuple(42ull, 43)));
 }
 
 TEST(HashingTest, HashValueStdString) {