[libc++] Improve diagnostics for non-const comparators and hashers in associative containers

[ldionne]

Summary

When providing a non-const-callable comparator in a map or set, the
warning diagnostic does not include the point of instantiation of
the container that triggered the warning, which makes it difficult
to track down the problem. This commit improves the diagnostic by
placing it directly in the body of the associative container.

The same change is applied to unordered associative containers, which
had a similar problem.

Finally, this commit cleans up the forward declarations of several
map and unordered_map helpers, which are not needed anymore.

rdar://problem/41370747

[ldionne]

Before the patch, the backtrace refers to the instantiation of the set's destructor instead of referring to the set's instantiation itself:

BEFORE (ordered associative containers)

In file included from /Users/ldionne/work/llvm/libcxx/test/libcxx/containers/associative/non_const_comparator.fail.cpp:16:
In file included from /Users/ldionne/work/llvm/libcxx/include/set:389:
/Users/ldionne/work/llvm/libcxx/include/__tree:1812:22: warning: the specified comparator type does not provide a const call operator [-Wuser-defined-warnings]
                     __trigger_diagnostics()), "");
                     ^
/Users/ldionne/work/llvm/libcxx/include/set:400:28: note: in instantiation of member function 'std::__1::__tree<int, BadCompare, std::__1::allocator<int> >::~__tree' requested here
class _LIBCPP_TEMPLATE_VIS set
                           ^
/Users/ldionne/work/llvm/libcxx/include/__tree:963:7: note: from 'diagnose_if' attribute on '__trigger_diagnostics':
      _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
      ^                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/ldionne/work/llvm/libcxx/include/__config:1165:21: note: expanded from macro '_LIBCPP_DIAGNOSE_WARNING'
     __attribute__((diagnose_if(__VA_ARGS__, "warning")))
                    ^           ~~~~~~~~~~~

AFTER (ordered associative containers)

In file included from /Users/ldionne/work/llvm/libcxx/test/libcxx/containers/associative/non_const_comparator.fail.cpp:16:
/Users/ldionne/work/llvm/libcxx/include/set:412:26: warning: the specified comparator type does not provide a const call operator [-Wuser-defined-warnings]
    static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
                         ^
/Users/ldionne/work/llvm/libcxx/test/libcxx/containers/associative/non_const_comparator.fail.cpp:34:7: note: in instantiation of template class 'std::__1::set<int, BadCompare, std::__1::allocator<int> >' requested here
    C s;
      ^
/Users/ldionne/work/llvm/libcxx/include/__tree:957:5: note: from 'diagnose_if' attribute on '__diagnose_non_const_comparator<int, BadCompare>':
    _LIBCPP_DIAGNOSE_WARNING(!std::__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
    ^                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/ldionne/work/llvm/libcxx/include/__config:1165:21: note: expanded from macro '_LIBCPP_DIAGNOSE_WARNING'
     __attribute__((diagnose_if(__VA_ARGS__, "warning")))
                    ^           ~~~~~~~~~~~

For unordered containers, the difference is that we don't show __hash_table in the backtrace anymore:

BEFORE (unordered associative containers)

In file included from /Users/ldionne/work/llvm/libcxx/test/libcxx/containers/unord/non_const_comparator.fail.cpp:16:
In file included from /Users/ldionne/work/llvm/libcxx/include/unordered_set:323:
/Users/ldionne/work/llvm/libcxx/include/__hash_table:956:77: warning: the specified hash functor does not provide a const call operator [-Wuser-defined-warnings]
    static_assert(__diagnose_hash_table_helper<_Tp, _Hash, _Equal, _Alloc>::__trigger_diagnostics(), "");
                                                                            ^
/Users/ldionne/work/llvm/libcxx/include/unordered_set:353:13: note: in instantiation of template class 'std::__1::__hash_table<int, BadHash, BadEqual, std::__1::allocator<int> >' requested here
    __table __table_;
            ^
/Users/ldionne/work/llvm/libcxx/test/libcxx/containers/unord/non_const_comparator.fail.cpp:42:7: note: in instantiation of template class 'std::__1::unordered_set<int, BadHash, BadEqual, std::__1::allocator<int> >' requested here
    C s;
      ^
/Users/ldionne/work/llvm/libcxx/include/__hash_table:867:5: note: from 'diagnose_if' attribute on '__trigger_diagnostics':
    _LIBCPP_DIAGNOSE_WARNING(__check_hash_requirements<_Key, _Hash>::value
    ^                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/ldionne/work/llvm/libcxx/include/__config:1165:21: note: expanded from macro '_LIBCPP_DIAGNOSE_WARNING'
     __attribute__((diagnose_if(__VA_ARGS__, "warning")))
                    ^           ~~~~~~~~~~~

AFTER (unordered associative containers)

In file included from /Users/ldionne/work/llvm/libcxx/test/libcxx/containers/unord/non_const_comparator.fail.cpp:16:
/Users/ldionne/work/llvm/libcxx/include/unordered_set:349:26: warning: the specified hash functor does not provide a const call operator [-Wuser-defined-warnings]
    static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
                         ^
/Users/ldionne/work/llvm/libcxx/test/libcxx/containers/unord/non_const_comparator.fail.cpp:44:7: note: in instantiation of template class 'std::__1::unordered_set<int, BadHash, BadEqual, std::__1::allocator<int> >' requested here
    C s;
      ^
/Users/ldionne/work/llvm/libcxx/include/__hash_table:868:5: note: from 'diagnose_if' attribute on '__diagnose_unordered_container_requirements<int, BadHash, BadEqual>':
    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Hash const&, _Key const&>::value,
    ^                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Users/ldionne/work/llvm/libcxx/include/__config:1165:21: note: expanded from macro '_LIBCPP_DIAGNOSE_WARNING'
     __attribute__((diagnose_if(__VA_ARGS__, "warning")))
                    ^           ~~~~~~~~~~~

[ldionne]

Rebase on top of ToT.

[mclow.lists]

If you can build this w/GCC in C++03 mode, then I'm fine with it.

[ldionne]

In D48955#1258146, @mclow.lists wrote:

If you can build this w/GCC in C++03 mode, then I'm fine with it.

I can't run the tests with GCC in C++03 mode -- I get thousands of errors unrelated to this patch.

[ldionne]

In D48955#1297140, @ldionne wrote:

In D48955#1258146, @mclow.lists wrote:

If you can build this w/GCC in C++03 mode, then I'm fine with it.

I can't run the tests with GCC in C++03 mode -- I get thousands of errors unrelated to this patch.

But the two tests I modified do pass, since they are unsupported on GCC. Am I good to go?

[ldionne]

I'll push this as I'm fairly sure this won't affect the (already broken) build on GCC. At least not as far as I can tell.

libcxx/docs/UsingLibcxx.rst

auto foo() {
       using Tup = std::tuple<std::string, int, std::error_code>;
       return Tup{"hello world", 42}; // explicit constructor called. OK.
     }
 
 **_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS**:
   This macro disables the additional diagnostics generated by libc++ using the
   `diagnose_if` attribute. These additional diagnostics include checks for:
 
-    * Giving `set`, `map`, `multiset`, `multimap` a comparator which is not
-      const callable.
+    * Giving `set`, `map`, `multiset`, `multimap` and their `unordered_`
+      counterparts a comparator which is not const callable.
+    * Giving an unordered associative container a hasher that is not const
+      callable.
 
 **_LIBCPP_NO_VCRUNTIME**:
   Microsoft's C and C++ headers are fairly entangled, and some of their C++
   headers are fairly hard to avoid. In particular, `vcruntime_new.h` gets pulled
   in from a lot of other headers and provides definitions which clash with
   libc++ headers, such as `nothrow_t` (note that `nothrow_t` is a struct, so
   there's no way for libc++ to provide a compatible definition, since you can't
   have multiple definitions).

libcxx/include/__hash_table

 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Tp>
 struct __hash_value_type;
 
-template <class _Key, class _Cp, class _Hash,
-          bool =  is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
-class __unordered_map_hasher;
-
-template <class _Key, class _Cp, class _Pred,
-          bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value
-         >
-class __unordered_map_equal;
-
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
 struct __is_hash_value_type_imp : false_type {};
 
 template <class _Key, class _Value>
 struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value>> : true_type {};
 
 template <class ..._Args>
void operator()(pointer __p) _NOEXCEPT
             __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 
     template <class> friend class __hash_map_node_destructor;
 };
 
-
+template <class _Key, class _Hash, class _Equal>
+struct __enforce_unordered_container_requirements {
 #ifndef _LIBCPP_CXX03_LANG
-template <class _Key, class _Hash, class _Equal, class _Alloc>
-struct __diagnose_hash_table_helper {
-  static constexpr bool __trigger_diagnostics()
-    _LIBCPP_DIAGNOSE_WARNING(__check_hash_requirements<_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(__check_hash_requirements<_Key, _Hash>::value,
-      "the specified hash does not meet the Hash requirements");
     static_assert(is_copy_constructible<_Equal>::value,
-      "the specified comparator is required to be copy constructible");
-    return true;
-  }
+#endif
+    typedef int type;
 };
 
-template <class _Key, class _Value, class _Hash, class _Equal, class _Alloc>
-struct __diagnose_hash_table_helper<
-  __hash_value_type<_Key, _Value>,
-  __unordered_map_hasher<_Key, __hash_value_type<_Key, _Value>, _Hash>,
-  __unordered_map_equal<_Key, __hash_value_type<_Key, _Value>, _Equal>,
-  _Alloc>
-: __diagnose_hash_table_helper<_Key, _Hash, _Equal, _Alloc>
-{
-};
-#endif // _LIBCPP_CXX03_LANG
+template <class _Key, class _Hash, class _Equal>
+#ifndef _LIBCPP_CXX03_LANG
+    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Equal const&, _Key const&, _Key const&>::value,
+    "the specified comparator type does not provide a const call operator")
+    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Hash const&, _Key const&>::value,
+    "the specified hash functor does not provide a const call operator")
+#endif
+typename __enforce_unordered_container_requirements<_Key, _Hash, _Equal>::type
+__diagnose_unordered_container_requirements(int);
+
+// This dummy overload is used so that the compiler won't emit a spurious
+// "no matching function for call to __diagnose_unordered_xxx" diagnostic
+// when the overload above causes a hard error.
+template <class _Key, class _Hash, class _Equal>
+int __diagnose_unordered_container_requirements(void*);
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 class __hash_table
 {
 public:
     typedef _Tp    value_type;
     typedef _Hash  hasher;
     typedef _Equal key_equal;

 private:
 
     typedef typename __rebind_alloc_helper<__node_traits, __next_pointer>::type __pointer_allocator;
     typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter;
     typedef unique_ptr<__next_pointer[], __bucket_list_deleter> __bucket_list;
     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_;
     __compressed_pair<size_type, hasher>                  __p2_;
     __compressed_pair<float, key_equal>                   __p3_;
     // --- Member data end ---
 
     _LIBCPP_INLINE_VISIBILITY

libcxx/include/__tree

 
 template <class _Pointer> class __tree_end_node;
 template <class _VoidPtr> class __tree_node_base;
 template <class _Tp, class _VoidPtr> class __tree_node;
 
 template <class _Key, class _Value>
 struct __value_type;
 
-template <class _Key, class _CP, class _Compare,
-    bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
-class __map_value_compare;
-
 template <class _Allocator> class __map_node_destructor;
 template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
 template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 
 /*
 
 _NodePtr algorithms
 
private:
     template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
     template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
     template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
     template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
     template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 
 };
 
+template<class _Tp, class _Compare>
 #ifndef _LIBCPP_CXX03_LANG
-template <class _Tp, class _Compare, class _Allocator>
-struct __diagnose_tree_helper {
-  static constexpr bool __trigger_diagnostics()
-      _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
-            "the specified comparator type does not provide a const call operator")
-  { return true; }
-};
-
-template <class _Key, class _Value, class _KeyComp, class _Alloc>
-struct __diagnose_tree_helper<
-    __value_type<_Key, _Value>,
-    __map_value_compare<_Key, __value_type<_Key, _Value>, _KeyComp>,
-    _Alloc
-> : __diagnose_tree_helper<_Key, _KeyComp, _Alloc>
-{
-};
-#endif // !_LIBCPP_CXX03_LANG
+    _LIBCPP_DIAGNOSE_WARNING(!std::__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
+#endif
+int __diagnose_non_const_comparator();
 
 template <class _Tp, class _Compare, class _Allocator>
 class __tree
 {
 public:
     typedef _Tp                                      value_type;
     typedef _Compare                                 value_compare;
     typedef _Allocator                               allocator_type;

 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::~__tree()
 {
     static_assert((is_copy_constructible<value_compare>::value),
                  "Comparator must be copy-constructible.");
-#ifndef _LIBCPP_CXX03_LANG
-    static_assert((__diagnose_tree_helper<_Tp, _Compare, _Allocator>::
-                     __trigger_diagnostics()), "");
-#endif
   destroy(__root());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
 {
     if (__nd != nullptr)

libcxx/include/map

 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Key, class _CP, class _Compare, bool _IsSmall>
+template <class _Key, class _CP, class _Compare,
+          bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
 class __map_value_compare
     : private _Compare
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     __map_value_compare()
         _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
         : _Compare() {}
public:
     typedef _Key                                     key_type;
     typedef _Tp                                      mapped_type;
     typedef pair<const key_type, mapped_type>        value_type;
     typedef _Compare                                 key_compare;
     typedef _Allocator                               allocator_type;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
+    static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
     class _LIBCPP_TEMPLATE_VIS value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class map;
     protected:
public:
     typedef _Key                                     key_type;
     typedef _Tp                                      mapped_type;
     typedef pair<const key_type, mapped_type>        value_type;
     typedef _Compare                                 key_compare;
     typedef _Allocator                               allocator_type;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
+    static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
     class _LIBCPP_TEMPLATE_VIS value_compare
         : public binary_function<value_type, value_type, bool>
     {
         friend class multimap;
     protected:

libcxx/include/set

public:
     typedef _Key                                     key_type;
     typedef key_type                                 value_type;
     typedef _Compare                                 key_compare;
     typedef key_compare                              value_compare;
     typedef _Allocator                               allocator_type;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
+    static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
 private:
     typedef __tree<value_type, value_compare, allocator_type> __base;
     typedef allocator_traits<allocator_type>                  __alloc_traits;
     typedef typename __base::__node_holder                    __node_holder;
 
public:
     typedef _Key                                      key_type;
     typedef key_type                                 value_type;
     typedef _Compare                                  key_compare;
     typedef key_compare                              value_compare;
     typedef _Allocator                                allocator_type;
     typedef value_type&                              reference;
     typedef const value_type&                        const_reference;
 
+    static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
     static_assert((is_same<typename allocator_type::value_type, value_type>::value),
                   "Allocator::value_type must be same type as value_type");
 
 private:
     typedef __tree<value_type, value_compare, allocator_type> __base;
     typedef allocator_traits<allocator_type>                  __alloc_traits;
     typedef typename __base::__node_holder                    __node_holder;
 

libcxx/include/unordered_map

 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Key, class _Cp, class _Hash, bool _IsEmpty>
+template <class _Key, class _Cp, class _Hash,
+          bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
 class __unordered_map_hasher
     : private _Hash
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     __unordered_map_hasher()
         _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
         : _Hash() {}

 void
 swap(__unordered_map_hasher<_Key, _Cp, _Hash, __b>& __x,
      __unordered_map_hasher<_Key, _Cp, _Hash, __b>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
-template <class _Key, class _Cp, class _Pred, bool _IsEmpty>
+template <class _Key, class _Cp, class _Pred,
+          bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value>
 class __unordered_map_equal
     : private _Pred
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     __unordered_map_equal()
         _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
         : _Pred() {}
public:
     typedef _Hash                                          hasher;
     typedef _Pred                                          key_equal;
     typedef _Alloc                                         allocator_type;
     typedef pair<const key_type, mapped_type>              value_type;
     typedef value_type&                                    reference;
     typedef const value_type&                              const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
+    static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                 __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher>   __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
     typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
                                                  __value_type>::type __allocator_type;
 
public:
     typedef _Hash                                          hasher;
     typedef _Pred                                          key_equal;
     typedef _Alloc                                         allocator_type;
     typedef pair<const key_type, mapped_type>              value_type;
     typedef value_type&                                    reference;
     typedef const value_type&                              const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
+    static_assert(sizeof(__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                 __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher>   __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
     typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
                                                  __value_type>::type __allocator_type;
 

libcxx/include/unordered_set

public:
     typedef key_type                                                   value_type;
     typedef _Hash                                                      hasher;
     typedef _Pred                                                      key_equal;
     typedef _Alloc                                                     allocator_type;
     typedef value_type&                                                reference;
     typedef const value_type&                                          const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
+    static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
 
 private:
     typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
 
     __table __table_;
 
 public:
     typedef typename __table::pointer         pointer;
public:
     typedef key_type                                                   value_type;
     typedef _Hash                                                      hasher;
     typedef _Pred                                                      key_equal;
     typedef _Alloc                                                     allocator_type;
     typedef value_type&                                                reference;
     typedef const value_type&                                          const_reference;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
                   "Invalid allocator::value_type");
+    static_assert(sizeof(__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
 
 private:
     typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
 
     __table __table_;
 
 public:
     typedef typename __table::pointer         pointer;

libcxx/test/libcxx/containers/associative/non_const_comparator.fail.cpp

bool operator()(T const& t, U const& u) {
     return t < u;
   }
 };
 
 int main() {
   static_assert(!std::__invokable<BadCompare const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadCompare&, int const&, int const&>::value, "");
 
-  // expected-warning@__tree:* 4 {{the specified comparator type does not provide a const call operator}}
+  // expected-warning@set:* 2 {{the specified comparator type does not provide a const call operator}}
+  // expected-warning@map:* 2 {{the specified comparator type does not provide a const call operator}}
   {
     using C = std::set<int, BadCompare>;
     C s;
   }
   {
     using C = std::multiset<long, BadCompare>;
     C s;
   }

libcxx/test/libcxx/containers/unord/non_const_comparator.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
 // REQUIRES: diagnose-if-support, verify-support
 
 // Test that libc++ generates a warning diagnostic when the container is
-// provided a non-const callable comparator.
+// provided a non-const callable comparator or a non-const hasher.
 
 #include <unordered_set>
 #include <unordered_map>
 
 struct BadHash {
   template <class T>
   size_t operator()(T const& t) {
     return std::hash<T>{}(t);
   }
 };
 
 struct BadEqual {
   template <class T, class U>
   bool operator()(T const& t, U const& u) {
     return t == u;
   }
 };
 
 int main() {
   static_assert(!std::__invokable<BadEqual const&, int const&, int const&>::value, "");
   static_assert(std::__invokable<BadEqual&, int const&, int const&>::value, "");
 
-  // expected-warning@__hash_table:* 4 {{the specified comparator type does not provide a const call operator}}
-  // expected-warning@__hash_table:* 4 {{the specified hash functor does not provide a const call operator}}
+  // expected-warning@unordered_set:* 2 {{the specified comparator type does not provide a const call operator}}
+  // expected-warning@unordered_map:* 2 {{the specified comparator type does not provide a const call operator}}
+  // expected-warning@unordered_set:* 2 {{the specified hash functor does not provide a const call operator}}
+  // expected-warning@unordered_map:* 2 {{the specified hash functor does not provide a const call operator}}
 
   {
     using C = std::unordered_set<int, BadHash, BadEqual>;
     C s;
   }
   {
     using C = std::unordered_multiset<long, BadHash, BadEqual>;
     C s;