That's kind of a crappy diagnostic, maybe we can ask upstream to make that diagnostic more actionable? (instead of "this is wrong", make it say "this is wrong because of a, b, c")

It's hard to pinpoint where this started because  Issue 697603  had the build red for a while.

I think this is the first where it's showing in the output: https://luci-logdog.appspot.com/v/?s=chromium%2Fbb%2Fchromium.fyi%2FClangToTMac%2F13303%2F%2B%2Frecipes%2Fsteps%2Fcompile%2F0%2Fstdout

But the previous build had other errors, and they occurred in earlier steps so they could be hiding this one.

There's a related recent commit though:

Author: ericwf
Date: Tue Feb 28 20:02:28 2017
New Revision: 296565

URL: http://llvm.org/viewvc/llvm-project?rev=296565&view=rev
Log:
Improve diagnostics when an invalid hash is used in an unordered container.

This patch adds a static assertion that the specified hash meets
the requirements of an enabled hash, and it ensures that the static
assertion is evaluated before __compressed_pair is instantiated.
That way the static assertion diagnostic is emitted first.

Added:
    libcxx/trunk/test/libcxx/containers/unord/unord.set/missing_hash_specialization.fail.cpp
Modified:
    libcxx/trunk/include/__hash_table

Modified: libcxx/trunk/include/__hash_table
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__hash_table?rev=296565&r1=296564&r2=296565&view=diff
==============================================================================
--- libcxx/trunk/include/__hash_table (original)
+++ libcxx/trunk/include/__hash_table Tue Feb 28 20:02:28 2017
@@ -871,11 +871,20 @@ public:
 template <class _Key, class _Hash, class _Equal, class _Alloc>
 struct __diagnose_hash_table_helper {
   static constexpr bool __trigger_diagnostics()
-  _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Hash const&, _Key const&>::value,
-    "the specified hash functor does not provide a const call operator")
-  _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Equal const&, _Key const&, _Key const&>::value,
-    "the specified comparator type does not provide a const call operator")
-  { return true; }
+    _LIBCPP_DIAGNOSE_WARNING(__has_enabled_hash<_Key, _Hash>::value
+                         && !__invokable<_Hash const&, _Key const&>::value,
+      "the specified hash functor does not provide a const call operator")
+    _LIBCPP_DIAGNOSE_WARNING(is_copy_constructible<_Equal>::value
+                          && !__invokable<_Equal const&, _Key const&, _Key const&>::value,
+      "the specified comparator type does not provide a const call operator")
+  {
+    static_assert(__has_enabled_hash<_Key, _Hash>::value,
+      "the specified hash functor does not meet the requirements for an "
+      "enabled hash");
+    static_assert(is_copy_constructible<_Equal>::value,
+      "the specified comparator is required to be copy constructible");
+    return true;
+  }
 };

 template <class _Key, class _Value, class _Hash, class _Equal, class _Alloc>
@@ -951,6 +960,10 @@ private:
     typedef allocator_traits<__pointer_allocator>          __pointer_alloc_traits;
     typedef typename __bucket_list_deleter::pointer       __node_pointer_pointer;

+#ifndef _LIBCPP_CXX03_LANG
+    static_assert(__diagnose_hash_table_helper<_Tp, _Hash, _Equal, _Alloc>::__trigger_diagnostics(), "");
+#endif
+
     // --- Member data begin ---
     __bucket_list                                         __bucket_list_;
     __compressed_pair<__first_node, __node_allocator>     __p1_;
@@ -1482,13 +1495,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
 {
+#if defined(_LIBCPP_CXX03_LANG)
     static_assert((is_copy_constructible<key_equal>::value),
                  "Predicate must be copy-constructible.");
     static_assert((is_copy_constructible<hasher>::value),
                  "Hasher must be copy-constructible.");
-#ifndef _LIBCPP_CXX03_LANG
-    static_assert(__diagnose_hash_table_helper<_Tp, _Hash, _Equal, _Alloc>::__trigger_diagnostics(), "");
 #endif
+
     __deallocate_node(__p1_.first().__next_);
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__erase_c(this);

Maybe just ask ericwf on IRC if this bug here rings any bells?

__has_enabled_hash<_Key, _Hash>::value

Seems to be defined here https://llvm.org/svn/llvm-project/libcxx/trunk/include/utility
like

template <class _Key, class _Hash = std::hash<_Key> >
using __has_enabled_hash = integral_constant<bool,
    is_default_constructible<_Hash>::value &&
    is_copy_constructible<_Hash>::value &&
    is_move_constructible<_Hash>::value &&
    __invokable_r<size_t, _Hash, _Key const&>::value
>;


In V8's case module_to_directory_map is a std::unordered_map<Global<Module>, std::string, ModuleGlobalHash>, so _Hash should be ModuleGlobalHash, which is this one: https://cs.chromium.org/chromium/src/v8/src/d8.cc?rcl=c9b4087f4a00632b7133c491addac7272d45cbef&l=616

  class ModuleGlobalHash {
   public:
    explicit ModuleGlobalHash(Isolate* isolate) : isolate_(isolate) {}
    size_t operator()(const Global<Module>& module) const {
      return module.Get(isolate_)->GetIdentityHash();
    }

   private:
    Isolate* isolate_;
  };

Which does not meet those criteria..

Eric says it should be fixed in r296919.

Tentatively closing this.