[libc++] Refactor allocator_mismatch.compile.fail.cpp -> .verify.cpp

[ldionne]

Summary

compile.fail.cpp tests are an anti-feature since they are too easy to
break when evolving code. This patch moves various allocator_mismatch
tests to .verify.cpp and normalizes the error messages from various
containers.

[philnik]

LGTM % comment.

libcxx/test/std/containers/associative/map/allocator_mismatch.verify.cpp

15

Let's not use the header name. That will just result in unnecessary refactorings later and doesn't really have any value compared to a generic match. It's not like we actually care from what header the error message is.

[ldionne]

Address comment and fix diagnostic matcher on older Clang

libcxx/include/forward_list

protected:
     typedef __rebind_alloc<allocator_traits<allocator_type>, __node> __node_allocator;
     typedef allocator_traits<__node_allocator>        __node_traits;
     typedef typename __node_traits::pointer           __node_pointer;
 
     typedef __rebind_alloc<allocator_traits<allocator_type>, __begin_node> __begin_node_allocator;
     typedef typename allocator_traits<__begin_node_allocator>::pointer
                                                       __begin_node_pointer;
 
-    static_assert((!is_same<allocator_type, __node_allocator>::value),
-                  "internal allocator type must differ from user-specified "
-                  "type; otherwise overload resolution breaks");
-
-    static_assert(is_same<allocator_type, __rebind_alloc<__node_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
-
     __compressed_pair<__begin_node, __node_allocator> __before_begin_;
 
     _LIBCPP_INLINE_VISIBILITY
     __begin_node_pointer        __before_begin() _NOEXCEPT
         {return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());}
     _LIBCPP_INLINE_VISIBILITY
     __begin_node_pointer __before_begin() const _NOEXCEPT
         {return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));}
class _LIBCPP_TEMPLATE_VIS forward_list
     typedef typename base::__node_traits        __node_traits;
     typedef typename base::__node_pointer       __node_pointer;
     typedef typename base::__begin_node_pointer __begin_node_pointer;
 
 public:
     typedef _Tp    value_type;
     typedef _Alloc allocator_type;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
+    static_assert(is_same<value_type, typename allocator_type::value_type>::value,
                   "Allocator::value_type must be same type as value_type");
 
+    static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
+                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
+                  "original allocator");
+
+    static_assert((!is_same<allocator_type, __node_allocator>::value),
+                  "internal allocator type must differ from user-specified "
+                  "type; otherwise overload resolution breaks");
+
     typedef value_type&                                                 reference;
     typedef const value_type&                                           const_reference;
     typedef typename allocator_traits<allocator_type>::pointer          pointer;
     typedef typename allocator_traits<allocator_type>::const_pointer    const_pointer;
     typedef typename allocator_traits<allocator_type>::size_type        size_type;
     typedef typename allocator_traits<allocator_type>::difference_type  difference_type;
 
     typedef typename base::iterator       iterator;

libcxx/include/list

class _LIBCPP_TEMPLATE_VIS list
     typedef typename base::__node_base         __node_base;
     typedef typename base::__node_base_pointer __node_base_pointer;
     typedef typename base::__link_pointer __link_pointer;
 
 public:
     typedef _Tp                                            value_type;
     typedef _Alloc                                         allocator_type;
     static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Invalid allocator::value_type");
+                  "Allocator::value_type must be same type as value_type");
     typedef value_type&                                    reference;
     typedef const value_type&                              const_reference;
     typedef typename base::pointer                         pointer;
     typedef typename base::const_pointer                   const_pointer;
     typedef typename base::size_type                       size_type;
     typedef typename base::difference_type                 difference_type;
     typedef typename base::iterator                        iterator;
     typedef typename base::const_iterator                  const_iterator;

libcxx/include/unordered_map

public:
     typedef _Tp                                            mapped_type;
     typedef __type_identity_t<_Hash>                       hasher;
     typedef __type_identity_t<_Pred>                       key_equal;
     typedef __type_identity_t<_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");
+                  "Allocator::value_type must be same type as value_type");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                          __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher>  __key_equal;
     typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type>    __allocator_type;
 
     typedef __hash_table<__value_type, __hasher,
public:
     typedef _Tp                                            mapped_type;
     typedef __type_identity_t<_Hash>                       hasher;
     typedef __type_identity_t<_Pred>                       key_equal;
     typedef __type_identity_t<_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");
+                  "Allocator::value_type must be same type as value_type");
 
 private:
     typedef __hash_value_type<key_type, mapped_type>                          __value_type;
     typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
     typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher>  __key_equal;
     typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type>    __allocator_type;
 
     typedef __hash_table<__value_type, __hasher,

libcxx/include/unordered_set

public:
     typedef _Value                                                     key_type;
     typedef key_type                                                   value_type;
     typedef __type_identity_t<_Hash>                                   hasher;
     typedef __type_identity_t<_Pred>                                   key_equal;
     typedef __type_identity_t<_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");
+                  "Allocator::value_type must be same type as value_type");
 
     static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
                   "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
                   "original allocator");
 
   private:
     typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
 
public:
     typedef _Value                                                     key_type;
     typedef key_type                                                   value_type;
     typedef __type_identity_t<_Hash>                                   hasher;
     typedef __type_identity_t<_Pred>                                   key_equal;
     typedef __type_identity_t<_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");
+                  "Allocator::value_type must be same type as value_type");
 
 private:
     typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
 
     __table __table_;
 
 public:
     typedef typename __table::pointer         pointer;

libcxx/test/std/containers/associative/map/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <map>
 //   The container's value type must be the same as the allocator's value type
 
 #include <map>
 
-int main(int, char**)
-{
-    std::map<int, int, std::less<int>, std::allocator<long> > m;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/associative/multimap/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <map>
 //   The container's value type must be the same as the allocator's value type
 
 #include <map>
 
-int main(int, char**)
-{
-    std::multimap<int, int, std::less<int>, std::allocator<long> > m;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/associative/multiset/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <set>
 //   The container's value type must be the same as the allocator's value type
 
 #include <set>
 
-int main(int, char**)
-{
-    std::set<int, std::less<int>, std::allocator<long> > s;
-
-  return 0;
-}
+std::multiset<int, std::less<int>, std::allocator<long> > m;
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/associative/set/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <set>
 //   The container's value type must be the same as the allocator's value type
 
 #include <set>
 
-int main(int, char**)
-{
-    std::multiset<int, std::less<int>, std::allocator<long> > ms;
-
-  return 0;
-}
+std::set<int, std::less<int>, std::allocator<long> > m;
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/associative/set/range_concept_conformance.compile.pass.cpp

 static_assert(std::ranges::sized_range<range>);
 static_assert(!std::ranges::borrowed_range<range>);
 static_assert(std::ranges::viewable_range<range>);
 
 static_assert(std::same_as<std::ranges::iterator_t<range const>, range::const_iterator>);
 static_assert(std::ranges::bidirectional_range<range const>);
 static_assert(!std::ranges::random_access_range<range const>);
 static_assert(std::ranges::common_range<range const>);
-static_assert(std::ranges::input_range<range>);
+static_assert(std::ranges::input_range<range const>);
 static_assert(!std::ranges::view<range const>);
 static_assert(std::ranges::sized_range<range const>);
 static_assert(!std::ranges::borrowed_range<range const>);
 static_assert(!std::ranges::viewable_range<range const>);

libcxx/test/std/containers/sequences/deque/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 //   The container's value type must be the same as the allocator's value type
 
 #include <deque>
 
-int main(int, char**)
-{
-    std::deque<int, std::allocator<long> > d;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/sequences/forwardlist/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <forward_list>
 //   The container's value type must be the same as the allocator's value type
 
 #include <forward_list>
 
-int main(int, char**)
-{
-    std::forward_list<int, std::allocator<long> > fl;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/sequences/list/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 //   The container's value type must be the same as the allocator's value type
 
 #include <list>
 
-int main(int, char**)
-{
-    std::list<int, std::allocator<long> > l;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/sequences/vector/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 //   The container's value type must be the same as the allocator's value type
 
 #include <vector>
 
-int main(int, char**)
-{
-    std::vector<int, std::allocator<long> > v;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/unord/unord.map/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 //   The container's value type must be the same as the allocator's value type
 
 #include <unordered_map>
 
-int main(int, char**)
-{
-    std::unordered_map<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/unord/unord.multimap/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 //   The container's value type must be the same as the allocator's value type
 
 #include <unordered_map>
 
-int main(int, char**)
-{
-    std::unordered_multimap<int, int, std::hash<int>, std::less<int>, std::allocator<long> > m;
-
-  return 0;
-}
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/unord/unord.multiset/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 //   The container's value type must be the same as the allocator's value type
 
 #include <unordered_set>
 
-int main(int, char**)
-{
-    std::unordered_set<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
-
-  return 0;
-}
+std::unordered_multiset<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}

libcxx/test/std/containers/unord/unord.set/allocator_mismatch.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 //   The container's value type must be the same as the allocator's value type
 
 #include <unordered_set>
 
-int main(int, char**)
-{
-    std::unordered_multiset<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
-
-  return 0;
-}
+std::unordered_set<int, std::hash<int>, std::less<int>, std::allocator<long> > v;
+  // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{.*}}Allocator::value_type must be same type as value_type}}