[libc++][P1115][C++20] Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if.

[curdeius]

Summary

This patch adds return type to std::erase and std::erase_if functions.

Also:

• Update __cpp_lib_erase_if to 202002L.
• Fix synopsis in unordered_map.
• Fix generate_feature_test_macro_components.py script.

[curdeius]

libcxx/include/deque

3028–3032

For deque, string and vector, it might be nice to refactor this repetitive code (e.g. to a __libcpp_erase_container function, analogue to __libcpp_erase_if_container).
However, I don't know in which header it should be put as these 3 headers have no good candidate being a common include.
Note that __libcpp_erase_if_container is in <functional> and that doesn't pose any problems for maps/sets as they already include it.
Vector and string already include <__functional_base> but deque doesn't, so I'm not sure what should be the best solution. Creating a new helper header? Leaving it unrefactored?

Possible implementation of the helper:

template <class _Container>
inline typename _Container::size_type
__libcpp_erase_container(_Container& __c,
                         typename _Container::iterator __new_end) {
  typename _Container::size_type __erased_count =
      std::distance(__new_end, __c.end());
  __c.erase(__new_end, __c.end());
  return __erased_count;
}

[curdeius]

Fixed forgotten return type tests.

[curdeius]

Fix string.

[curdeius]

Fix tests with custom allocators. Fix assert in map test.

[curdeius]

Fix __cpp_lib_erase_if value.

[curdeius]

The pre-merge build results show this build as failed because of failing clang-format linter tests (https://reviews.llvm.org/harbormaster/build/52549/, https://results.llvm-merge-guard.org/amd64_debian_testing_clang8-4604/summary.html).
However, these "failures" are all misindentations of preprocessor directives in generated files in libcxx/test/std/language.support/support.limits/support.limits.general/.
That's out of scope of this patch, but isn't the real fix modifying .clang-format config file to indent PP directives (or having a local copy of .clang-format in tests)?

[EricWF]

I think there is a bug in the paper, but I think the return type should be difference_type not size_type.
The paper says the return value is equivalent to:

auto r = distance(a, b);
return r;

And std::distance returns difference_type.

What do you think?

libcxx/include/functional

3087

We need to avoid calling an overloaded comma operator here.

[zoecarver]

It would be nice if we could remove the calls to std::difference and replace them with a count variable so that we only have to iterate once. It may require adding a __libcpp_ erase function, though.

[curdeius]

Avoid using overloaded comma operator.

[curdeius]

Fix typo.

[curdeius]

In D75905#1918677, @zoecarver wrote:

It would be nice if we could remove the calls to std::difference and replace them with a count variable so that we only have to iterate once. It may require adding a __libcpp_ erase function, though.

Where do you see that the iteration takes place twice? std::distance on LegacyRandomAccessIterators is an O(1) operation. And all of basic_string, deque and vector iterators belong to this category.
What do you mean by adding a count variable? remove and remove_if functions do not provide us with a count.

In D75905#1918626, @EricWF wrote:

I think there is a bug in the paper, but I think the return type should be difference_type not size_type.

I'm not sure if it's a bug. I think that a coherence with other APIs was intended. Apart the additions in P0646, there is already pre-C++11 size_type map::erase(key_type) as well as size_type set::erase(key_type).

Otherwise, to be coherent with __libcpp_erase_if_container and avoid casting difference_type to size_type, I'd suggest returning old_size - size() instead of using distance.

libcxx/include/functional

3087

Done.

[curdeius]

Avoid using std::distance.

[curdeius]

Ping.

[zoecarver]

Sorry, this slipped through my inbox somehow.

Where do you see that the iteration takes place twice? std::distance on LegacyRandomAccessIterators is an O(1) operation. And all of basic_string, deque and vector iterators belong to this category. What do you mean by adding a count variable? remove and remove_if functions do not provide us with a count.

Here's the patch I made to implement the first paper [1]. @mclow.lists gave me some great review comments, which apply to this patch as well. Essentially, we never want to traverse the whole range twice (i.e. remove_if and distance). It looks like that's not a problem anymore, though.

That being said, you make a good point. In all those cases, x.distance isn't a traversal of the container. Make sure that you're using the method, not the std::distance function, though.

[1]: https://reviews.llvm.org/D58332

libcxx/include/functional

3084

This seems like a weird place to have this function. Is there another header that would work better?

I know you didn't make this change but, I figured I'd ask anyway.

3085

Instead of calling size, maybe make this a count that is incremented throughout the loop? I don't think it matters much but, it might make it a bit more general.

libcxx/include/string

4399

Why not use __libcpp_erase_if_container?

libcxx/include/vector

3407

Also could use __libcpp_erase_if_container, no?

[curdeius]

Hopefully I answered your questions, @zoecarver.

libcxx/include/functional

3084

Well, this function is used in map, set, unordered_map and unordered_set headers. The common includes of these are: __config, __node_handle, functional and version. IMO, __config and version are really not the place for this. functional seems okayish. I'm unsure about __node_handle.
I'd rather leave it as is.

I'd rather be reluctant as to creating another __header for this particular function, but I don't know what is the policy of using additional headers in libc++.

3085

I have no opinion on this. Both seem ok.

libcxx/include/string

4399

I think that __libcpp_erase_if_container would be inefficient for vector-like containers, as you would call erase n times (n = count of removed elements), hence moving left all elements after the erased one n times.

libcxx/include/vector

3407

Ditto.

[curdeius]

Ping.

[ldionne]

Thanks for your patience. Regarding the code duplication, I think the only way to go is to split up libc++ into tinier headers. Trying to find a "clever" place to put common code is just a waste of time.

[curdeius]

Does anyone of you know why libcxx ARM buildbots fail after changing include headers?

All of them fail (http://lab.llvm.org:8011/console) with something similar to (http://lab.llvm.org:8011/builders/libcxx-libcxxabi-libunwind-armv7-linux/builds/1314/steps/test.libcxx/logs/FAIL%3A libc%2B%2B%3A%3Astds_include.sh.cpp):

/home/tcwg-buildslave/worker/libcxx-libcxxabi-libunwind-armv7-linux/llvm/libcxx/test/libcxx/modules/stds_include.sh.cpp:37:2: fatal error: file '/home/tcwg-buildslave/worker/libcxx-libcxxabi-libunwind-armv7-linux/llvm/libcxx/include/version' has been modified since the module file '/tmp/org.llvm.clang.11827/ModuleCache/8KDYU3/std-1WP0A9P.pcm' was built
#include <vector>
 ^
/home/tcwg-buildslave/worker/libcxx-libcxxabi-libunwind-armv7-linux/llvm/libcxx/test/libcxx/modules/stds_include.sh.cpp:37:2: note: please rebuild precompiled header '/tmp/org.llvm.clang.11827/ModuleCache/8KDYU3/std-1WP0A9P.pcm'
1 error generated.

It happens whenever an include is modified and it seems that the precompiled headers are not updated accordingly. Do you know if there's a fix? Do you know who's the maintainer of these bots?

[zoecarver]

@curdeius It's an issue with the bots, they need to be fixed. @ldionne let the maintainers know so, I don't think there's anything else to do.

[ldionne]

In D75905#2019190, @zoecarver wrote:

@curdeius It's an issue with the bots, they need to be fixed. @ldionne let the maintainers know so, I don't think there's anything else to do.

I actually think it's a module cache invalidation bug. I think @EricWF has more context?

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_constexpr_misc``                      *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_destroying_delete``                   ``201806L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_endian``                              ``201907L``      
     ------------------------------------------------- -----------------
-    ``__cpp_lib_erase_if``                            ``201811L``      
+    ``__cpp_lib_erase_if``                            ``202002L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_generic_unordered_lookup``            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_interpolate``                         ``201902L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_constant_evaluated``               ``201811L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``             *unimplemented*  

libcxx/include/deque

template <class T, class Allocator>
     bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
 
 // specialized algorithms:
 template <class T, class Allocator>
     void swap(deque<T,Allocator>& x, deque<T,Allocator>& y)
          noexcept(noexcept(x.swap(y)));
 
 template <class T, class Allocator, class U>
-    void erase(deque<T, Allocator>& c, const U& value);       // C++20
+    typename deque<T, Allocator>::size_type
+    erase(deque<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
+    typename deque<T, Allocator>::size_type
+    erase_if(deque<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__split_buffer>
 #include <type_traits>

 swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase(deque<_Tp, _Allocator>& __c, const _Up& __v)
-{ __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); }
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
+erase(deque<_Tp, _Allocator>& __c, const _Up& __v) {
+  auto __new_end = _VSTD::remove(__c.begin(), __c.end(), __v);
+  typename deque<_Tp, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __c.end());
+  __c.erase(__new_end, __c.end());
+  return __erased_count;
+}
 
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred)
-{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+inline _LIBCPP_INLINE_VISIBILITY typename deque<_Tp, _Allocator>::size_type
+erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) {
+  auto __new_end = _VSTD::remove_if(__c.begin(), __c.end(), __pred);
+  typename deque<_Tp, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __c.end());
+  __c.erase(__new_end, __c.end());
+  return __erased_count;
+}
 #endif
 
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_DEQUE

libcxx/include/forward_list

template <class T, class Allocator>
     bool operator<=(const forward_list<T, Allocator>& x,
                     const forward_list<T, Allocator>& y);
 
 template <class T, class Allocator>
     void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
          noexcept(noexcept(x.swap(y)));
 
 template <class T, class Allocator, class U>
-    void erase(forward_list<T, Allocator>& c, const U& value);       // C++20
+    typename forward_list<T, Allocator>::size_type
+    erase(forward_list<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
+    typename forward_list<T, Allocator>::size_type
+    erase_if(forward_list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <initializer_list>
 #include <memory>
swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred)
-{ __c.remove_if(__pred); }
+    typename forward_list<_Tp, _Allocator>::size_type
+    erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) {
+  return __c.remove_if(__pred);
+}
 
 template <class _Tp, class _Allocator, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v)
-{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+    typename forward_list<_Tp, _Allocator>::size_type
+    erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
+  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_FORWARD_LIST

libcxx/include/functional

 template <class _Tp>
 using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
 
 template <class _Tp>
 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
 #endif // > C++17
 
 template <class _Container, class _Predicate>
-inline void __libcpp_erase_if_container( _Container& __c, _Predicate __pred)
-{
-  for (typename _Container::iterator __iter = __c.begin(), __last = __c.end(); __iter != __last;)
-  {
-    if (__pred(*__iter))
-      __iter = __c.erase(__iter);
-    else
-      ++__iter;
-  }
+inline typename _Container::size_type
+__libcpp_erase_if_container(_Container& __c, _Predicate __pred) {
+  typename _Container::size_type __old_size = __c.size();
+
+  for (typename _Container::iterator __iter = __c.begin(), __last = __c.end();
+       __iter != __last;) {
+    if (__pred(*__iter))
+      __iter = __c.erase(__iter);
+    else
+      ++__iter;
+  }
+
+  return __old_size - __c.size();
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_FUNCTIONAL

libcxx/include/list

 template <class T, class Alloc>
     bool operator<=(const list<T,Alloc>& x, const list<T,Alloc>& y);
 
 template <class T, class Alloc>
     void swap(list<T,Alloc>& x, list<T,Alloc>& y)
          noexcept(noexcept(x.swap(y)));
 
 template <class T, class Allocator, class U>
-    void erase(list<T, Allocator>& c, const U& value);       // C++20
+    typename list<T, Allocator>::size_type
+    erase(list<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
+    typename list<T, Allocator>::size_type
+    erase_if(list<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 
 #include <memory>

 swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred)
-{ __c.remove_if(__pred); }
+inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
+erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) {
+  return __c.remove_if(__pred);
+}
 
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase(list<_Tp, _Allocator>& __c, const _Up& __v)
-{ _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); }
+inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
+erase(list<_Tp, _Allocator>& __c, const _Up& __v) {
+  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_LIST

libcxx/include/map

 
 // specialized algorithms:
 template <class Key, class T, class Compare, class Allocator>
 void
 swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class Key, class T, class Compare, class Allocator, class Predicate>
-  void erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+typename map<Key, T, Compare, Allocator>::size_type
+erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 
 
 template <class Key, class T, class Compare = less<Key>,
           class Allocator = allocator<pair<const Key, T>>>
 class multimap
 {
 public:
     // types:

 // specialized algorithms:
 template <class Key, class T, class Compare, class Allocator>
 void
 swap(multimap<Key, T, Compare, Allocator>& x,
      multimap<Key, T, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class Key, class T, class Compare, class Allocator, class Predicate>
-  void erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
+typename multimap<Key, T, Compare, Allocator>::size_type
+erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__tree>
 #include <__node_handle>

 swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
      map<_Key, _Tp, _Compare, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+template <class _Key, class _Tp, class _Compare, class _Allocator,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename map<_Key, _Tp, _Compare, _Allocator>::size_type
+    erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 
 template <class _Key, class _Tp, class _Compare = less<_Key>,
           class _Allocator = allocator<pair<const _Key, _Tp> > >
 class _LIBCPP_TEMPLATE_VIS multimap
 {
 public:

 swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
      multimap<_Key, _Tp, _Compare, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+template <class _Key, class _Tp, class _Compare, class _Allocator,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
+    erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_MAP

libcxx/include/set

 
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
 swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class Key, class Compare, class Allocator, class Predicate>
-  void erase_if(set<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+typename set<Key, Compare, Allocator>::size_type
+erase_if(set<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 
 template <class Key, class Compare = less<Key>,
           class Allocator = allocator<Key>>
 class multiset
 {
 public:
     // types:
     typedef Key                                      key_type;

 
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
 swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class Key, class Compare, class Allocator, class Predicate>
-  void erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
+typename multiset<Key, Compare, Allocator>::size_type
+erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <__tree>
 #include <__node_handle>
swap(set<_Key, _Compare, _Allocator>& __x,
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename set<_Key, _Compare, _Allocator>::size_type
+    erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 template <class _Key, class _Compare = less<_Key>,
           class _Allocator = allocator<_Key> >
 class _LIBCPP_TEMPLATE_VIS multiset
 {
 public:
     // types:
swap(multiset<_Key, _Compare, _Allocator>& __x,
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename multiset<_Key, _Compare, _Allocator>::size_type
+    erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SET

libcxx/include/string

 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
         charT delim);
 
 template<class charT, class traits, class Allocator>
 basic_istream<charT, traits>&
 getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);
 
 template<class charT, class traits, class Allocator, class U>
-void erase(basic_string<charT, traits, Allocator>& c, const U& value); // C++20
+typename basic_string<charT, traits, Allocator>::size_type
+erase(basic_string<charT, traits, Allocator>& c, const U& value);    // C++20
 template<class charT, class traits, class Allocator, class Predicate>
-void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
+typename basic_string<charT, traits, Allocator>::size_type
+erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred); // C++20
 
 typedef basic_string<char>    string;
 typedef basic_string<wchar_t> wstring;
 typedef basic_string<char16_t> u16string;
 typedef basic_string<char32_t> u32string;
 
 int                stoi  (const string& str, size_t* idx = 0, int base = 10);
 long               stol  (const string& str, size_t* idx = 0, int base = 10);

 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str);
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 17
-template<class _CharT, class _Traits, class _Allocator, class _Up>
+template <class _CharT, class _Traits, class _Allocator, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v)
-{ __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end()); }
+    typename basic_string<_CharT, _Traits, _Allocator>::size_type
+    erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
+  auto __new_end = _VSTD::remove(__str.begin(), __str.end(), __v);
+  typename basic_string<_CharT, _Traits, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __str.end());
+  __str.erase(__new_end, __str.end());
+  return __erased_count;
+}
 
-template<class _CharT, class _Traits, class _Allocator, class _Predicate>
+template <class _CharT, class _Traits, class _Allocator, class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred)
-{ __str.erase(_VSTD::remove_if(__str.begin(), __str.end(), __pred), __str.end()); }
+    typename basic_string<_CharT, _Traits, _Allocator>::size_type
+    erase_if(basic_string<_CharT, _Traits, _Allocator>& __str,
+             _Predicate __pred) {
+  auto __new_end = _VSTD::remove_if(__str.begin(), __str.end(), __pred);
+  typename basic_string<_CharT, _Traits, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __str.end());
+  __str.erase(__new_end, __str.end());
+  return __erased_count;
+}
 #endif
 
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
 template<class _CharT, class _Traits, class _Allocator>
 bool
 basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
 {

libcxx/include/unordered_map

 };
 
 template <class Key, class T, class Hash, class Pred, class Alloc>
     void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
               unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
               noexcept(noexcept(x.swap(y)));
 
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+    typename unordered_map<K, T, H, P, A>::size_type
+    erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);       // C++20
 
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+    typename unordered_multimap<K, T, H, P, A>::size_type
+    erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);  // C++20
 
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool

 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
      unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     if (__x.size() != __y.size())

 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
      unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     if (__x.size() != __y.size())

libcxx/include/unordered_set

 };
 
 template <class Value, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
               unordered_multiset<Value, Hash, Pred, Alloc>& y)
               noexcept(noexcept(x.swap(y)));
 
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
+    typename unordered_set<K, T, H, P, A>::size_type
+    erase_if(unordered_set<K, T, H, P, A>& c, Predicate pred);       // C++20
 
 template <class K, class T, class H, class P, class A, class Predicate>
-    void erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
+    typename unordered_multiset<K, T, H, P, A>::size_type
+    erase_if(unordered_multiset<K, T, H, P, A>& c, Predicate pred);  // C++20
 
 
 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
                const unordered_multiset<Value, Hash, Pred, Alloc>& y);
 
 template <class Value, class Hash, class Pred, class Alloc>

 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     if (__x.size() != __y.size())

 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
      unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
-template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+template <class _Value, class _Hash, class _Pred, class _Alloc,
+          class _Predicate>
 inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred)
-{ __libcpp_erase_if_container(__c, __pred); }
+    typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
+    erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c,
+             _Predicate __pred) {
+  return __libcpp_erase_if_container(__c, __pred);
+}
 #endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 bool
 operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     if (__x.size() != __y.size())

libcxx/include/vector

 template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
 template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
 
 template <class T, class Allocator>
 void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
     noexcept(noexcept(x.swap(y)));
 
 template <class T, class Allocator, class U>
-    void erase(vector<T, Allocator>& c, const U& value);       // C++20
+typename vector<T, Allocator>::size_type
+erase(vector<T, Allocator>& c, const U& value);       // C++20
 template <class T, class Allocator, class Predicate>
-    void erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
+typename vector<T, Allocator>::size_type
+erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <iosfwd> // for forward declaration of vector
 #include <__bit_reference>

 swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
     __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase(vector<_Tp, _Allocator>& __c, const _Up& __v)
-{ __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); }
+inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
+erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
+  auto __new_end = _VSTD::remove(__c.begin(), __c.end(), __v);
+  typename vector<_Tp, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __c.end());
+  __c.erase(__new_end, __c.end());
+  return __erased_count;
+}
 
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-void erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred)
-{ __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); }
+inline _LIBCPP_INLINE_VISIBILITY typename vector<_Tp, _Allocator>::size_type
+erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
+  auto __new_end = _VSTD::remove_if(__c.begin(), __c.end(), __pred);
+  typename vector<_Tp, _Allocator>::size_type __erased_count =
+      std::distance(__new_end, __c.end());
+  __c.erase(__new_end, __c.end());
+  return __erased_count;
+}
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_VECTOR

libcxx/test/std/containers/associative/map/map.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <map>
 
 // template <class Key, class T, class Compare, class Allocator, class Predicate>
-//   void erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
+//   typename map<Key, T, Compare, Allocator>::size_type
+//   erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
 
 #include <map>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret[static_cast<typename M::key_type>(v)] = static_cast<typename M::mapped_type>(v + 10);
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == make<M>(expected));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p);
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v.first == 1;};
     auto is2 = [](auto v) { return v.first == 2;};
     auto is3 = [](auto v) { return v.first == 3;};
     auto is4 = [](auto v) { return v.first == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::map<int, int>>();
     test<std::map<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
     test<std::map<int, int, std::less<int>, test_allocator<std::pair<const int, int>>>> ();
 
     test<std::map<long, short>>();
     test<std::map<short, double>>();
 
   return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <map>
 
-//   template <class Key, class T, class Compare, class Allocator, class Predicate>
-//     void erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
+// template <class Key, class T, class Compare, class Allocator, class Predicate>
+//   typename multimap<Key, T, Compare, Allocator>::size_type
+//   erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
 
 #include <map>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret.emplace(static_cast<typename M::key_type>(v), static_cast<typename M::mapped_type>(v + 10));
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == make<M>(expected));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v.first == 1;};
     auto is2 = [](auto v) { return v.first == 2;};
     auto is3 = [](auto v) { return v.first == 3;};
     auto is4 = [](auto v) { return v.first == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-    test0<S>({1,1}, is1, {});
-    test0<S>({1,1}, is3, {1,1});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
-
-    test0<S>({1,1,1}, is1, {});
-    test0<S>({1,1,1}, is2, {1,1,1});
-    test0<S>({1,1,2}, is1, {2});
-    test0<S>({1,1,2}, is2, {1,1});
-    test0<S>({1,1,2}, is3, {1,1,2});
-    test0<S>({1,2,2}, is1, {2,2});
-    test0<S>({1,2,2}, is2, {1});
-    test0<S>({1,2,2}, is3, {1,2,2});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+    test0<S>({1, 1}, is1, {}, 2);
+    test0<S>({1, 1}, is3, {1, 1}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
+
+    test0<S>({1, 1, 1}, is1, {}, 3);
+    test0<S>({1, 1, 1}, is2, {1, 1, 1}, 0);
+    test0<S>({1, 1, 2}, is1, {2}, 2);
+    test0<S>({1, 1, 2}, is2, {1, 1}, 1);
+    test0<S>({1, 1, 2}, is3, {1, 1, 2}, 0);
+    test0<S>({1, 2, 2}, is1, {2, 2}, 1);
+    test0<S>({1, 2, 2}, is2, {1}, 2);
+    test0<S>({1, 2, 2}, is3, {1, 2, 2}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::multimap<int, int>>();
     test<std::multimap<int, int, std::less<int>, min_allocator<std::pair<const int, int>>>> ();
     test<std::multimap<int, int, std::less<int>, test_allocator<std::pair<const int, int>>>> ();
 
     test<std::multimap<long, short>>();
     test<std::multimap<short, double>>();
 
   return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <set>
 
 // template <class T, class Compare, class Allocator, class Predicate>
-//   void erase_if(multiset<T, Compare, Allocator>& c, Predicate pred);
+//   typename multiset<T, Compare, Allocator>::size_type
+//   erase_if(multiset<T, Compare, Allocator>& c, Predicate pred);
 
 #include <set>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-    test0(S({1,1}), is1, S());
-    test0(S({1,1}), is3, S({1,1}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
-
-    test0(S({1,1,1}), is1, S());
-    test0(S({1,1,1}), is2, S({1,1,1}));
-    test0(S({1,1,2}), is1, S({2}));
-    test0(S({1,1,2}), is2, S({1,1}));
-    test0(S({1,1,2}), is3, S({1,1,2}));
-    test0(S({1,2,2}), is1, S({2,2}));
-    test0(S({1,2,2}), is2, S({1}));
-    test0(S({1,2,2}), is3, S({1,2,2}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+    test0(S({1, 1}), is1, S(), 2);
+    test0(S({1, 1}), is3, S({1, 1}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    test0(S({1, 1, 1}), is1, S(), 3);
+    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    test0(S({1, 1, 2}), is1, S({2}), 2);
+    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
+    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    test0(S({1, 2, 2}), is1, S({2, 2}), 1);
+    test0(S({1, 2, 2}), is2, S({1}), 2);
+    test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::multiset<int>>();
     test<std::multiset<int, std::less<int>, min_allocator<int>>> ();
     test<std::multiset<int, std::less<int>, test_allocator<int>>> ();
 
     test<std::multiset<long>>();
     test<std::multiset<double>>();
 
   return 0;
 }

libcxx/test/std/containers/associative/set/set.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <set>
 
 // template <class T, class Compare, class Allocator, class Predicate>
-//   void erase_if(set<T, Compare, Allocator>& c, Predicate pred);
+//   typename set<T, Compare, Allocator>::size_type
+//   erase_if(set<T, Compare, Allocator>& c, Predicate pred);
 
 #include <set>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::set<int>>();
     test<std::set<int, std::less<int>, min_allocator<int>>> ();
     test<std::set<int, std::less<int>, test_allocator<int>>> ();
 
     test<std::set<long>>();
     test<std::set<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.erasure/erase.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <deque>
 
 // template <class T, class Allocator, class U>
-//   void erase(deque<T, Allocator>& c, const U& value);
-
+//   typename deque<T, Allocator>::size_type
+//   erase(deque<T, Allocator>& c, const U& value);
 
 #include <deque>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void
-test0(S s,  U val, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
-    std::erase(s, val);
-    assert(s == expected);
+void test0(S s, U val, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase(s, val)));
+  assert(expected_erased_count == std::erase(s, val));
 }
 
 template <class S>
 void test()
 {
+  test0(S(), 1, S(), 0);
 
-    test0(S(), 1, S());
-
-    test0(S({1}), 1, S());
-    test0(S({1}), 2, S({1}));
+  test0(S({1}), 1, S(), 1);
+  test0(S({1}), 2, S({1}), 0);
 
-    test0(S({1,2}), 1, S({2}));
-    test0(S({1,2}), 2, S({1}));
-    test0(S({1,2}), 3, S({1,2}));
-    test0(S({1,1}), 1, S());
-    test0(S({1,1}), 3, S({1,1}));
-
-    test0(S({1,2,3}), 1, S({2,3}));
-    test0(S({1,2,3}), 2, S({1,3}));
-    test0(S({1,2,3}), 3, S({1,2}));
-    test0(S({1,2,3}), 4, S({1,2,3}));
-
-    test0(S({1,1,1}), 1, S());
-    test0(S({1,1,1}), 2, S({1,1,1}));
-    test0(S({1,1,2}), 1, S({2}));
-    test0(S({1,1,2}), 2, S({1,1}));
-    test0(S({1,1,2}), 3, S({1,1,2}));
-    test0(S({1,2,2}), 1, S({2,2}));
-    test0(S({1,2,2}), 2, S({1}));
-    test0(S({1,2,2}), 3, S({1,2,2}));
+  test0(S({1, 2}), 1, S({2}), 1);
+  test0(S({1, 2}), 2, S({1}), 1);
+  test0(S({1, 2}), 3, S({1, 2}), 0);
+  test0(S({1, 1}), 1, S(), 2);
+  test0(S({1, 1}), 3, S({1, 1}), 0);
+
+  test0(S({1, 2, 3}), 1, S({2, 3}), 1);
+  test0(S({1, 2, 3}), 2, S({1, 3}), 1);
+  test0(S({1, 2, 3}), 3, S({1, 2}), 1);
+  test0(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
+
+  test0(S({1, 1, 1}), 1, S(), 3);
+  test0(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
+  test0(S({1, 1, 2}), 1, S({2}), 2);
+  test0(S({1, 1, 2}), 2, S({1, 1}), 1);
+  test0(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
+  test0(S({1, 2, 2}), 1, S({2, 2}), 1);
+  test0(S({1, 2, 2}), 2, S({1}), 2);
+  test0(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
 
   //  Test cross-type erasure
-    using opt = std::optional<typename S::value_type>;
-    test0(S({1,2,1}), opt(),  S({1,2,1}));
-    test0(S({1,2,1}), opt(1), S({2}));
-    test0(S({1,2,1}), opt(2), S({1,1}));
-    test0(S({1,2,1}), opt(3), S({1,2,1}));
+  test0(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
+  test0(S({1, 2, 1}), opt(1), S({2}), 2);
+  test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
+  test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
 int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
     test<std::deque<int, test_allocator<int>>> ();
 
     test<std::deque<long>>();
     test<std::deque<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/deque.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <deque>
 
 // template <class T, class Allocator, class Predicate>
-//   void erase_if(deque<T, Allocator>& c, Predicate pred);
+//   typename deque<T, Allocator>::size_type
+//   erase_if(deque<T, Allocator>& c, Predicate pred);
 
 #include <deque>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-    test0(S({1,1}), is1, S());
-    test0(S({1,1}), is3, S({1,1}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
-
-    test0(S({1,1,1}), is1, S());
-    test0(S({1,1,1}), is2, S({1,1,1}));
-    test0(S({1,1,2}), is1, S({2}));
-    test0(S({1,1,2}), is2, S({1,1}));
-    test0(S({1,1,2}), is3, S({1,1,2}));
-    test0(S({1,2,2}), is1, S({2,2}));
-    test0(S({1,2,2}), is2, S({1}));
-    test0(S({1,2,2}), is3, S({1,2,2}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+    test0(S({1, 1}), is1, S(), 2);
+    test0(S({1, 1}), is3, S({1, 1}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    test0(S({1, 1, 1}), is1, S(), 3);
+    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    test0(S({1, 1, 2}), is1, S({2}), 2);
+    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
+    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    test0(S({1, 2, 2}), is1, S({2, 2}), 1);
+    test0(S({1, 2, 2}), is2, S({1}), 2);
+    test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::deque<int>>();
     test<std::deque<int, min_allocator<int>>> ();
     test<std::deque<int, test_allocator<int>>> ();
 
     test<std::deque<long>>();
     test<std::deque<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <forward_list>
 
 // template <class T, class Allocator, class U>
-//   void erase(forward_list<T, Allocator>& c, const U& value);
-
+//   typename forward_list<T, Allocator>::size_type
+//   erase(forward_list<T, Allocator>& c, const U& value);
 
 #include <forward_list>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void
-test0(S s,  U val, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
-    std::erase(s, val);
-    assert(s == expected);
+void test0(S s, U val, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase(s, val)));
+  assert(expected_erased_count == std::erase(s, val));
 }
 
 template <class S>
 void test()
 {
+  test0(S(), 1, S(), 0);
 
-    test0(S(), 1, S());
-
-    test0(S({1}), 1, S());
-    test0(S({1}), 2, S({1}));
+  test0(S({1}), 1, S(), 1);
+  test0(S({1}), 2, S({1}), 0);
 
-    test0(S({1,2}), 1, S({2}));
-    test0(S({1,2}), 2, S({1}));
-    test0(S({1,2}), 3, S({1,2}));
-    test0(S({1,1}), 1, S());
-    test0(S({1,1}), 3, S({1,1}));
-
-    test0(S({1,2,3}), 1, S({2,3}));
-    test0(S({1,2,3}), 2, S({1,3}));
-    test0(S({1,2,3}), 3, S({1,2}));
-    test0(S({1,2,3}), 4, S({1,2,3}));
-
-    test0(S({1,1,1}), 1, S());
-    test0(S({1,1,1}), 2, S({1,1,1}));
-    test0(S({1,1,2}), 1, S({2}));
-    test0(S({1,1,2}), 2, S({1,1}));
-    test0(S({1,1,2}), 3, S({1,1,2}));
-    test0(S({1,2,2}), 1, S({2,2}));
-    test0(S({1,2,2}), 2, S({1}));
-    test0(S({1,2,2}), 3, S({1,2,2}));
+  test0(S({1, 2}), 1, S({2}), 1);
+  test0(S({1, 2}), 2, S({1}), 1);
+  test0(S({1, 2}), 3, S({1, 2}), 0);
+  test0(S({1, 1}), 1, S(), 2);
+  test0(S({1, 1}), 3, S({1, 1}), 0);
+
+  test0(S({1, 2, 3}), 1, S({2, 3}), 1);
+  test0(S({1, 2, 3}), 2, S({1, 3}), 1);
+  test0(S({1, 2, 3}), 3, S({1, 2}), 1);
+  test0(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
+
+  test0(S({1, 1, 1}), 1, S(), 3);
+  test0(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
+  test0(S({1, 1, 2}), 1, S({2}), 2);
+  test0(S({1, 1, 2}), 2, S({1, 1}), 1);
+  test0(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
+  test0(S({1, 2, 2}), 1, S({2, 2}), 1);
+  test0(S({1, 2, 2}), 2, S({1}), 2);
+  test0(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
 
   //  Test cross-type erasure
-    using opt = std::optional<typename S::value_type>;
-    test0(S({1,2,1}), opt(),  S({1,2,1}));
-    test0(S({1,2,1}), opt(1), S({2}));
-    test0(S({1,2,1}), opt(2), S({1,1}));
-    test0(S({1,2,1}), opt(3), S({1,2,1}));
+  test0(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
+  test0(S({1, 2, 1}), opt(1), S({2}), 2);
+  test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
+  test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
 int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
     test<std::forward_list<int, test_allocator<int>>> ();
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/forwardlist/forwardlist.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <forward_list>
 
 // template <class T, class Allocator, class Predicate>
-//   void erase_if(forward_list<T, Allocator>& c, Predicate pred);
+//   typename forward_list<T, Allocator>::size_type
+//   erase_if(forward_list<T, Allocator>& c, Predicate pred);
 
 #include <forward_list>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-    test0(S({1,1}), is1, S());
-    test0(S({1,1}), is3, S({1,1}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
-
-    test0(S({1,1,1}), is1, S());
-    test0(S({1,1,1}), is2, S({1,1,1}));
-    test0(S({1,1,2}), is1, S({2}));
-    test0(S({1,1,2}), is2, S({1,1}));
-    test0(S({1,1,2}), is3, S({1,1,2}));
-    test0(S({1,2,2}), is1, S({2,2}));
-    test0(S({1,2,2}), is2, S({1}));
-    test0(S({1,2,2}), is3, S({1,2,2}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+    test0(S({1, 1}), is1, S(), 2);
+    test0(S({1, 1}), is3, S({1, 1}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    test0(S({1, 1, 1}), is1, S(), 3);
+    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    test0(S({1, 1, 2}), is1, S({2}), 2);
+    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
+    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    test0(S({1, 2, 2}), is1, S({2, 2}), 1);
+    test0(S({1, 2, 2}), is2, S({1}), 2);
+    test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::forward_list<int>>();
     test<std::forward_list<int, min_allocator<int>>> ();
     test<std::forward_list<int, test_allocator<int>>> ();
 
     test<std::forward_list<long>>();
     test<std::forward_list<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.erasure/erase.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <list>
 
 // template <class T, class Allocator, class U>
-//   void erase(list<T, Allocator>& c, const U& value);
-
+//   typename list<T, Allocator>::size_type
+//   erase(list<T, Allocator>& c, const U& value);
 
 #include <list>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void
-test0(S s,  U val, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
-    std::erase(s, val);
-    assert(s == expected);
+void test0(S s, U val, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase(s, val)));
+  assert(expected_erased_count == std::erase(s, val));
 }
 
 template <class S>
 void test()
 {
+  test0(S(), 1, S(), 0);
 
-    test0(S(), 1, S());
-
-    test0(S({1}), 1, S());
-    test0(S({1}), 2, S({1}));
+  test0(S({1}), 1, S(), 1);
+  test0(S({1}), 2, S({1}), 0);
 
-    test0(S({1,2}), 1, S({2}));
-    test0(S({1,2}), 2, S({1}));
-    test0(S({1,2}), 3, S({1,2}));
-    test0(S({1,1}), 1, S());
-    test0(S({1,1}), 3, S({1,1}));
-
-    test0(S({1,2,3}), 1, S({2,3}));
-    test0(S({1,2,3}), 2, S({1,3}));
-    test0(S({1,2,3}), 3, S({1,2}));
-    test0(S({1,2,3}), 4, S({1,2,3}));
-
-    test0(S({1,1,1}), 1, S());
-    test0(S({1,1,1}), 2, S({1,1,1}));
-    test0(S({1,1,2}), 1, S({2}));
-    test0(S({1,1,2}), 2, S({1,1}));
-    test0(S({1,1,2}), 3, S({1,1,2}));
-    test0(S({1,2,2}), 1, S({2,2}));
-    test0(S({1,2,2}), 2, S({1}));
-    test0(S({1,2,2}), 3, S({1,2,2}));
+  test0(S({1, 2}), 1, S({2}), 1);
+  test0(S({1, 2}), 2, S({1}), 1);
+  test0(S({1, 2}), 3, S({1, 2}), 0);
+  test0(S({1, 1}), 1, S(), 2);
+  test0(S({1, 1}), 3, S({1, 1}), 0);
+
+  test0(S({1, 2, 3}), 1, S({2, 3}), 1);
+  test0(S({1, 2, 3}), 2, S({1, 3}), 1);
+  test0(S({1, 2, 3}), 3, S({1, 2}), 1);
+  test0(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
+
+  test0(S({1, 1, 1}), 1, S(), 3);
+  test0(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
+  test0(S({1, 1, 2}), 1, S({2}), 2);
+  test0(S({1, 1, 2}), 2, S({1, 1}), 1);
+  test0(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
+  test0(S({1, 2, 2}), 1, S({2, 2}), 1);
+  test0(S({1, 2, 2}), 2, S({1}), 2);
+  test0(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
 
   //  Test cross-type erasure
-    using opt = std::optional<typename S::value_type>;
-    test0(S({1,2,1}), opt(),  S({1,2,1}));
-    test0(S({1,2,1}), opt(1), S({2}));
-    test0(S({1,2,1}), opt(2), S({1,1}));
-    test0(S({1,2,1}), opt(3), S({1,2,1}));
+  test0(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
+  test0(S({1, 2, 1}), opt(1), S({2}), 2);
+  test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
+  test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
 int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
     test<std::list<int, test_allocator<int>>> ();
 
     test<std::list<long>>();
     test<std::list<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/list/list.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <list>
 
 // template <class T, class Allocator, class Predicate>
-//   void erase_if(list<T, Allocator>& c, Predicate pred);
+//   typename list<T, Allocator>::size_type
+//   erase_if(list<T, Allocator>& c, Predicate pred);
 
 #include <list>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-    test0(S({1,1}), is1, S());
-    test0(S({1,1}), is3, S({1,1}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
-
-    test0(S({1,1,1}), is1, S());
-    test0(S({1,1,1}), is2, S({1,1,1}));
-    test0(S({1,1,2}), is1, S({2}));
-    test0(S({1,1,2}), is2, S({1,1}));
-    test0(S({1,1,2}), is3, S({1,1,2}));
-    test0(S({1,2,2}), is1, S({2,2}));
-    test0(S({1,2,2}), is2, S({1}));
-    test0(S({1,2,2}), is3, S({1,2,2}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+    test0(S({1, 1}), is1, S(), 2);
+    test0(S({1, 1}), is3, S({1, 1}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    test0(S({1, 1, 1}), is1, S(), 3);
+    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    test0(S({1, 1, 2}), is1, S({2}), 2);
+    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
+    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    test0(S({1, 2, 2}), is1, S({2, 2}), 1);
+    test0(S({1, 2, 2}), is2, S({1}), 2);
+    test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::list<int>>();
     test<std::list<int, min_allocator<int>>> ();
     test<std::list<int, test_allocator<int>>> ();
 
     test<std::list<long>>();
     test<std::list<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.erasure/erase.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <vector>
 
 // template <class T, class Allocator, class U>
-//   void erase(vector<T, Allocator>& c, const U& value);
-
+//   typename vector<T, Allocator>::size_type
+//   erase(vector<T, Allocator>& c, const U& value);
 
 #include <vector>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void
-test0(S s,  U val, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
-    std::erase(s, val);
-    assert(s == expected);
+void test0(S s, U val, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase(s, val)));
+  assert(expected_erased_count == std::erase(s, val));
 }
 
 template <class S>
 void test()
 {
 
-    test0(S(), 1, S());
+  test0(S(), 1, S(), 0);
 
-    test0(S({1}), 1, S());
-    test0(S({1}), 2, S({1}));
+  test0(S({1}), 1, S(), 1);
+  test0(S({1}), 2, S({1}), 0);
 
-    test0(S({1,2}), 1, S({2}));
-    test0(S({1,2}), 2, S({1}));
-    test0(S({1,2}), 3, S({1,2}));
-    test0(S({1,1}), 1, S());
-    test0(S({1,1}), 3, S({1,1}));
-
-    test0(S({1,2,3}), 1, S({2,3}));
-    test0(S({1,2,3}), 2, S({1,3}));
-    test0(S({1,2,3}), 3, S({1,2}));
-    test0(S({1,2,3}), 4, S({1,2,3}));
-
-    test0(S({1,1,1}), 1, S());
-    test0(S({1,1,1}), 2, S({1,1,1}));
-    test0(S({1,1,2}), 1, S({2}));
-    test0(S({1,1,2}), 2, S({1,1}));
-    test0(S({1,1,2}), 3, S({1,1,2}));
-    test0(S({1,2,2}), 1, S({2,2}));
-    test0(S({1,2,2}), 2, S({1}));
-    test0(S({1,2,2}), 3, S({1,2,2}));
+  test0(S({1, 2}), 1, S({2}), 1);
+  test0(S({1, 2}), 2, S({1}), 1);
+  test0(S({1, 2}), 3, S({1, 2}), 0);
+  test0(S({1, 1}), 1, S(), 2);
+  test0(S({1, 1}), 3, S({1, 1}), 0);
+
+  test0(S({1, 2, 3}), 1, S({2, 3}), 1);
+  test0(S({1, 2, 3}), 2, S({1, 3}), 1);
+  test0(S({1, 2, 3}), 3, S({1, 2}), 1);
+  test0(S({1, 2, 3}), 4, S({1, 2, 3}), 0);
+
+  test0(S({1, 1, 1}), 1, S(), 3);
+  test0(S({1, 1, 1}), 2, S({1, 1, 1}), 0);
+  test0(S({1, 1, 2}), 1, S({2}), 2);
+  test0(S({1, 1, 2}), 2, S({1, 1}), 1);
+  test0(S({1, 1, 2}), 3, S({1, 1, 2}), 0);
+  test0(S({1, 2, 2}), 1, S({2, 2}), 1);
+  test0(S({1, 2, 2}), 2, S({1}), 2);
+  test0(S({1, 2, 2}), 3, S({1, 2, 2}), 0);
 
   //  Test cross-type erasure
-    using opt = std::optional<typename S::value_type>;
-    test0(S({1,2,1}), opt(),  S({1,2,1}));
-    test0(S({1,2,1}), opt(1), S({2}));
-    test0(S({1,2,1}), opt(2), S({1,1}));
-    test0(S({1,2,1}), opt(3), S({1,2,1}));
+  test0(S({1, 2, 1}), opt(), S({1, 2, 1}), 0);
+  test0(S({1, 2, 1}), opt(1), S({2}), 2);
+  test0(S({1, 2, 1}), opt(2), S({1, 1}), 1);
+  test0(S({1, 2, 1}), opt(3), S({1, 2, 1}), 0);
 }
 
 int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
     test<std::vector<int, test_allocator<int>>> ();
 
     test<std::vector<long>>();
     test<std::vector<double>>();
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <vector>
 
 // template <class T, class Allocator, class Predicate>
-//   void erase_if(vector<T, Allocator>& c, Predicate pred);
+//   typename vector<T, Allocator>::size_type
+//   erase_if(vector<T, Allocator>& c, Predicate pred);
 
 #include <vector>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(), is1, S());
+    test0(S(), is1, S(), 0);
 
-    test0(S({1}), is1, S());
-    test0(S({1}), is2, S({1}));
+    test0(S({1}), is1, S(), 1);
+    test0(S({1}), is2, S({1}), 0);
 
-    test0(S({1,2}), is1, S({2}));
-    test0(S({1,2}), is2, S({1}));
-    test0(S({1,2}), is3, S({1,2}));
-    test0(S({1,1}), is1, S());
-    test0(S({1,1}), is3, S({1,1}));
-
-    test0(S({1,2,3}), is1, S({2,3}));
-    test0(S({1,2,3}), is2, S({1,3}));
-    test0(S({1,2,3}), is3, S({1,2}));
-    test0(S({1,2,3}), is4, S({1,2,3}));
-
-    test0(S({1,1,1}), is1, S());
-    test0(S({1,1,1}), is2, S({1,1,1}));
-    test0(S({1,1,2}), is1, S({2}));
-    test0(S({1,1,2}), is2, S({1,1}));
-    test0(S({1,1,2}), is3, S({1,1,2}));
-    test0(S({1,2,2}), is1, S({2,2}));
-    test0(S({1,2,2}), is2, S({1}));
-    test0(S({1,2,2}), is3, S({1,2,2}));
+    test0(S({1, 2}), is1, S({2}), 1);
+    test0(S({1, 2}), is2, S({1}), 1);
+    test0(S({1, 2}), is3, S({1, 2}), 0);
+    test0(S({1, 1}), is1, S(), 2);
+    test0(S({1, 1}), is3, S({1, 1}), 0);
+
+    test0(S({1, 2, 3}), is1, S({2, 3}), 1);
+    test0(S({1, 2, 3}), is2, S({1, 3}), 1);
+    test0(S({1, 2, 3}), is3, S({1, 2}), 1);
+    test0(S({1, 2, 3}), is4, S({1, 2, 3}), 0);
+
+    test0(S({1, 1, 1}), is1, S(), 3);
+    test0(S({1, 1, 1}), is2, S({1, 1, 1}), 0);
+    test0(S({1, 1, 2}), is1, S({2}), 2);
+    test0(S({1, 1, 2}), is2, S({1, 1}), 1);
+    test0(S({1, 1, 2}), is3, S({1, 1, 2}), 0);
+    test0(S({1, 2, 2}), is1, S({2, 2}), 1);
+    test0(S({1, 2, 2}), is2, S({1}), 2);
+    test0(S({1, 2, 2}), is3, S({1, 2, 2}), 0);
 
-    test0(S({1,2,3}), True,  S());
-    test0(S({1,2,3}), False, S({1,2,3}));
+    test0(S({1, 2, 3}), True, S(), 3);
+    test0(S({1, 2, 3}), False, S({1, 2, 3}), 0);
 }
 
 int main(int, char**)
 {
     test<std::vector<int>>();
     test<std::vector<int, min_allocator<int>>> ();
     test<std::vector<int, test_allocator<int>>> ();
 
     test<std::vector<long>>();
     test<std::vector<double>>();
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.map/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <unordered_map>
 
 // template <class Key, class T, class Hash, class Pred, class Allocator, class Predicate>
-//   void erase_if(unordered_map<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
+//   typename unordered_map<Key, T, Hash, Pred, Allocator>::size_type
+//   erase_if(unordered_map<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
 
 #include <unordered_map>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret[static_cast<typename M::key_type>(v)] = static_cast<typename M::mapped_type>(v + 10);
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    M e = make<M>(expected);
-    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v.first == 1;};
     auto is2 = [](auto v) { return v.first == 2;};
     auto is3 = [](auto v) { return v.first == 3;};
     auto is4 = [](auto v) { return v.first == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::unordered_map<int, int>>();
     test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
     test<std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int, int>>>> ();
 
     test<std::unordered_map<long, short>>();
     test<std::unordered_map<short, double>>();
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <unordered_map>
 
 // template <class Key, class T, class Hash, class Pred, class Allocator, class Predicate>
-//   void erase_if(unordered_multimap<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
+//   typename unordered_multimap<Key, T, Hash, Pred, Allocator>::size_type
+//   erase_if(unordered_multimap<Key, T, Hash, Pred, Allocator>& c, Predicate pred);
 
 #include <unordered_map>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret.emplace(static_cast<typename M::key_type>(v), static_cast<typename M::mapped_type>(v + 10));
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    M e = make<M>(expected);
-    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v.first == 1;};
     auto is2 = [](auto v) { return v.first == 2;};
     auto is3 = [](auto v) { return v.first == 3;};
     auto is4 = [](auto v) { return v.first == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-    test0<S>({1,1}, is1, {});
-    test0<S>({1,1}, is3, {1,1});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
-
-    test0<S>({1,1,1}, is1, {});
-    test0<S>({1,1,1}, is2, {1,1,1});
-    test0<S>({1,1,2}, is1, {2});
-    test0<S>({1,1,2}, is2, {1,1});
-    test0<S>({1,1,2}, is3, {1,1,2});
-    test0<S>({1,2,2}, is1, {2,2});
-    test0<S>({1,2,2}, is2, {1});
-    test0<S>({1,2,2}, is3, {1,2,2});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+    test0<S>({1, 1}, is1, {}, 2);
+    test0<S>({1, 1}, is3, {1, 1}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
+
+    test0<S>({1, 1, 1}, is1, {}, 3);
+    test0<S>({1, 1, 1}, is2, {1, 1, 1}, 0);
+    test0<S>({1, 1, 2}, is1, {2}, 2);
+    test0<S>({1, 1, 2}, is2, {1, 1}, 1);
+    test0<S>({1, 1, 2}, is3, {1, 1, 2}, 0);
+    test0<S>({1, 2, 2}, is1, {2, 2}, 1);
+    test0<S>({1, 2, 2}, is2, {1}, 2);
+    test0<S>({1, 2, 2}, is3, {1, 2, 2}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::unordered_multimap<int, int>>();
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, int>>>> ();
     test<std::unordered_multimap<int, int, std::hash<int>, std::equal_to<int>, test_allocator<std::pair<const int, int>>>> ();
 
     test<std::unordered_multimap<long, short>>();
     test<std::unordered_multimap<short, double>>();
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <set>
 
 // template <class T, class Hash, class Compare, class Allocator, class Predicate>
-//   void erase_if(unordered_multiset<T, Hash, Compare, Allocator>& c, Predicate pred);
+//   typename unordered_multiset<T, Hash, Compare, Allocator>::size_type
+//   erase_if(unordered_multiset<T, Hash, Compare, Allocator>& c, Predicate pred);
 
 #include <unordered_set>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret.insert(v);
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    M e = make<M>(expected);
-    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-    test0<S>({1,1}, is1, {});
-    test0<S>({1,1}, is3, {1,1});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
-
-    test0<S>({1,1,1}, is1, {});
-    test0<S>({1,1,1}, is2, {1,1,1});
-    test0<S>({1,1,2}, is1, {2});
-    test0<S>({1,1,2}, is2, {1,1});
-    test0<S>({1,1,2}, is3, {1,1,2});
-    test0<S>({1,2,2}, is1, {2,2});
-    test0<S>({1,2,2}, is2, {1});
-    test0<S>({1,2,2}, is3, {1,2,2});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+    test0<S>({1, 1}, is1, {}, 2);
+    test0<S>({1, 1}, is3, {1, 1}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
+
+    test0<S>({1, 1, 1}, is1, {}, 3);
+    test0<S>({1, 1, 1}, is2, {1, 1, 1}, 0);
+    test0<S>({1, 1, 2}, is1, {2}, 2);
+    test0<S>({1, 1, 2}, is2, {1, 1}, 1);
+    test0<S>({1, 1, 2}, is3, {1, 1, 2}, 0);
+    test0<S>({1, 2, 2}, is1, {2, 2}, 1);
+    test0<S>({1, 2, 2}, is2, {1}, 2);
+    test0<S>({1, 2, 2}, is3, {1, 2, 2}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::unordered_multiset<int>>();
     test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
     test<std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>> ();
 
     test<std::unordered_multiset<long>>();
     test<std::unordered_multiset<double>>();
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.set/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <unordered_set>
 
 // template <class T, class Hash, class Compare, class Allocator, class Predicate>
-//   void erase_if(unorderd_set<T, Hash, Compare, Allocator>& c, Predicate pred);
+//   typename unordered_set<T, Hash, Compare, Allocator>::size_type
+//   erase_if(unordered_set<T, Hash, Compare, Allocator>& c, Predicate pred);
 
 #include <unordered_set>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 using Init = std::initializer_list<int>;
 
 template <typename M>
 M make (Init vals)
 {
     M ret;
     for (int v : vals)
         ret.insert(v);
     return ret;
 }
 
 template <typename M, typename Pred>
-void
-test0(Init vals, Pred p, Init expected)
-{
-    M s = make<M> (vals);
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    M e = make<M>(expected);
-    assert((std::is_permutation(s.begin(), s.end(), e.begin(), e.end())));
+void test0(Init vals, Pred p, Init expected, size_t expected_erased_count) {
+  M s = make<M>(vals);
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
-
 template <typename S>
 void test()
 {
     auto is1 = [](auto v) { return v == 1;};
     auto is2 = [](auto v) { return v == 2;};
     auto is3 = [](auto v) { return v == 3;};
     auto is4 = [](auto v) { return v == 4;};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0<S>({}, is1, {});
+    test0<S>({}, is1, {}, 0);
 
-    test0<S>({1}, is1, {});
-    test0<S>({1}, is2, {1});
+    test0<S>({1}, is1, {}, 1);
+    test0<S>({1}, is2, {1}, 0);
 
-    test0<S>({1,2}, is1, {2});
-    test0<S>({1,2}, is2, {1});
-    test0<S>({1,2}, is3, {1,2});
-
-    test0<S>({1,2,3}, is1, {2,3});
-    test0<S>({1,2,3}, is2, {1,3});
-    test0<S>({1,2,3}, is3, {1,2});
-    test0<S>({1,2,3}, is4, {1,2,3});
+    test0<S>({1, 2}, is1, {2}, 1);
+    test0<S>({1, 2}, is2, {1}, 1);
+    test0<S>({1, 2}, is3, {1, 2}, 0);
+
+    test0<S>({1, 2, 3}, is1, {2, 3}, 1);
+    test0<S>({1, 2, 3}, is2, {1, 3}, 1);
+    test0<S>({1, 2, 3}, is3, {1, 2}, 1);
+    test0<S>({1, 2, 3}, is4, {1, 2, 3}, 0);
 
-    test0<S>({1,2,3}, True,  {});
-    test0<S>({1,2,3}, False, {1,2,3});
+    test0<S>({1, 2, 3}, True, {}, 3);
+    test0<S>({1, 2, 3}, False, {1, 2, 3}, 0);
 }
 
 int main(int, char**)
 {
     test<std::unordered_set<int>>();
     test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>>> ();
     test<std::unordered_set<int, std::hash<int>, std::equal_to<int>, test_allocator<int>>> ();
 
     test<std::unordered_set<long>>();
     test<std::unordered_set<double>>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/support.limits.general/deque.version.pass.cpp

 // and should not be edited manually.
 
 // <deque>
 
 // Test the feature test macros defined by <deque>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <deque>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
 # endif
 
 #endif // TEST_STD_VER > 17
 
 int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/forward_list.version.pass.cpp

 // and should not be edited manually.
 
 // <forward_list>
 
 // Test the feature test macros defined by <forward_list>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_incomplete_container_elements       201505L [C++17]
     __cpp_lib_list_remove_return_type             201806L [C++2a]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <forward_list>
 #include "test_macros.h"
 

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
 # endif
 # if __cpp_lib_incomplete_container_elements != 201505L
 #   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/list.version.pass.cpp

 // and should not be edited manually.
 
 // <list>
 
 // Test the feature test macros defined by <list>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_incomplete_container_elements       201505L [C++17]
     __cpp_lib_list_remove_return_type             201806L [C++2a]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <list>
 #include "test_macros.h"
 

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
 # endif
 # if __cpp_lib_incomplete_container_elements != 201505L
 #   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/map.version.pass.cpp

 // and should not be edited manually.
 
 // <map>
 
 // Test the feature test macros defined by <map>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_generic_associative_lookup          201304L [C++14]
     __cpp_lib_map_try_emplace                     201411L [C++17]
     __cpp_lib_node_extract                        201606L [C++17]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <map>
 #include "test_macros.h"

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_generic_associative_lookup
 #   error "__cpp_lib_generic_associative_lookup should be defined in c++2a"
 # endif
 # if __cpp_lib_generic_associative_lookup != 201304L
 #   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/set.version.pass.cpp

 // and should not be edited manually.
 
 // <set>
 
 // Test the feature test macros defined by <set>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_generic_associative_lookup          201304L [C++14]
     __cpp_lib_node_extract                        201606L [C++17]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <set>
 #include "test_macros.h"
 

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_generic_associative_lookup
 #   error "__cpp_lib_generic_associative_lookup should be defined in c++2a"
 # endif
 # if __cpp_lib_generic_associative_lookup != 201304L
 #   error "__cpp_lib_generic_associative_lookup should have the value 201304L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp

 
 // <string>
 
 // Test the feature test macros defined by <string>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
     __cpp_lib_char8_t                             201811L [C++2a]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_nonmember_container_access          201411L [C++17]
     __cpp_lib_string_udls                         201304L [C++14]
     __cpp_lib_string_view                         201606L [C++17]
 */
 
 #include <string>
 #include "test_macros.h"
 

 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_nonmember_container_access
 #   error "__cpp_lib_nonmember_container_access should be defined in c++2a"
 # endif
 # if __cpp_lib_nonmember_container_access != 201411L
 #   error "__cpp_lib_nonmember_container_access should have the value 201411L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/unordered_map.version.pass.cpp

 // and should not be edited manually.
 
 // <unordered_map>
 
 // Test the feature test macros defined by <unordered_map>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_generic_unordered_lookup            201811L [C++2a]
     __cpp_lib_node_extract                        201606L [C++17]
     __cpp_lib_nonmember_container_access          201411L [C++17]
     __cpp_lib_unordered_map_try_emplace           201411L [C++17]
 */
 
 #include <unordered_map>
 #include "test_macros.h"

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_generic_unordered_lookup
 #     error "__cpp_lib_generic_unordered_lookup should be defined in c++2a"
 #   endif
 #   if __cpp_lib_generic_unordered_lookup != 201811L
 #     error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2a"

libcxx/test/std/language.support/support.limits/support.limits.general/unordered_set.version.pass.cpp

 // and should not be edited manually.
 
 // <unordered_set>
 
 // Test the feature test macros defined by <unordered_set>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_generic_unordered_lookup            201811L [C++2a]
     __cpp_lib_node_extract                        201606L [C++17]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <unordered_set>
 #include "test_macros.h"
 

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_generic_unordered_lookup
 #     error "__cpp_lib_generic_unordered_lookup should be defined in c++2a"
 #   endif
 #   if __cpp_lib_generic_unordered_lookup != 201811L
 #     error "__cpp_lib_generic_unordered_lookup should have the value 201811L in c++2a"

libcxx/test/std/language.support/support.limits/support.limits.general/vector.version.pass.cpp

 // and should not be edited manually.
 
 // <vector>
 
 // Test the feature test macros defined by <vector>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_erase_if                            201811L [C++2a]
+    __cpp_lib_erase_if                            202002L [C++2a]
     __cpp_lib_incomplete_container_elements       201505L [C++17]
     __cpp_lib_nonmember_container_access          201411L [C++17]
 */
 
 #include <vector>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14

 # endif
 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_incomplete_container_elements
 #   error "__cpp_lib_incomplete_container_elements should be defined in c++2a"
 # endif
 # if __cpp_lib_incomplete_container_elements != 201505L
 #   error "__cpp_lib_incomplete_container_elements should have the value 201505L in c++2a"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             201806L [C++2a]
     __cpp_lib_constexpr_misc                       201811L [C++2a]
     __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
     __cpp_lib_destroying_delete                    201806L [C++2a]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++2a]
-    __cpp_lib_erase_if                             201811L [C++2a]
+    __cpp_lib_erase_if                             202002L [C++2a]
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]
     __cpp_lib_filesystem                           201703L [C++17]
     __cpp_lib_gcd_lcm                              201606L [C++17]
     __cpp_lib_generic_associative_lookup           201304L [C++14]
     __cpp_lib_generic_unordered_lookup             201811L [C++2a]
     __cpp_lib_hardware_interference_size           201703L [C++17]
     __cpp_lib_has_unique_object_representations    201606L [C++17]

 # endif
 # if __cpp_lib_endian != 201907L
 #   error "__cpp_lib_endian should have the value 201907L in c++2a"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2a"
 # endif
-# if __cpp_lib_erase_if != 201811L
-#   error "__cpp_lib_erase_if should have the value 201811L in c++2a"
+# if __cpp_lib_erase_if != 202002L
+#   error "__cpp_lib_erase_if should have the value 202002L in c++2a"
 # endif
 
 # ifndef __cpp_lib_exchange_function
 #   error "__cpp_lib_exchange_function should be defined in c++2a"
 # endif
 # if __cpp_lib_exchange_function != 201304L
 #   error "__cpp_lib_exchange_function should have the value 201304L in c++2a"
 # endif

libcxx/test/std/strings/strings.erasure/erase.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <string>
 
 // template <class charT, class traits, class Allocator, class U>
-//   void erase(basic_string<charT, traits, Allocator>& c, const U& value);
-
+//   typename basic_string<charT, traits, Allocator>::size_type
+//   erase(basic_string<charT, traits, Allocator>& c, const U& value);
 
 #include <string>
 #include <optional>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class U>
-void
-test0(S s,  U val, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase(s, val)));
-    std::erase(s, val);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+void test0(S s, U val, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase(s, val)));
+  assert(expected_erased_count == std::erase(s, val));
 }
 
 template <class S>
 void test()
 {
 
-    test0(S(""), 'a', S(""));
+  test0(S(""), 'a', S(""), 0);
 
-    test0(S("a"), 'a', S(""));
-    test0(S("a"), 'b', S("a"));
+  test0(S("a"), 'a', S(""), 1);
+  test0(S("a"), 'b', S("a"), 0);
 
-    test0(S("ab"), 'a', S("b"));
-    test0(S("ab"), 'b', S("a"));
-    test0(S("ab"), 'c', S("ab"));
-    test0(S("aa"), 'a', S(""));
-    test0(S("aa"), 'c', S("aa"));
-
-    test0(S("abc"), 'a', S("bc"));
-    test0(S("abc"), 'b', S("ac"));
-    test0(S("abc"), 'c', S("ab"));
-    test0(S("abc"), 'd', S("abc"));
-
-    test0(S("aab"), 'a', S("b"));
-    test0(S("aab"), 'b', S("aa"));
-    test0(S("aab"), 'c', S("aab"));
-    test0(S("abb"), 'a', S("bb"));
-    test0(S("abb"), 'b', S("a"));
-    test0(S("abb"), 'c', S("abb"));
-    test0(S("aaa"), 'a', S(""));
-    test0(S("aaa"), 'b', S("aaa"));
+  test0(S("ab"), 'a', S("b"), 1);
+  test0(S("ab"), 'b', S("a"), 1);
+  test0(S("ab"), 'c', S("ab"), 0);
+  test0(S("aa"), 'a', S(""), 2);
+  test0(S("aa"), 'c', S("aa"), 0);
+
+  test0(S("abc"), 'a', S("bc"), 1);
+  test0(S("abc"), 'b', S("ac"), 1);
+  test0(S("abc"), 'c', S("ab"), 1);
+  test0(S("abc"), 'd', S("abc"), 0);
+
+  test0(S("aab"), 'a', S("b"), 2);
+  test0(S("aab"), 'b', S("aa"), 1);
+  test0(S("aab"), 'c', S("aab"), 0);
+  test0(S("abb"), 'a', S("bb"), 1);
+  test0(S("abb"), 'b', S("a"), 2);
+  test0(S("abb"), 'c', S("abb"), 0);
+  test0(S("aaa"), 'a', S(""), 3);
+  test0(S("aaa"), 'b', S("aaa"), 0);
 
   //  Test cross-type erasure
-    using opt = std::optional<typename S::value_type>;
-    test0(S("aba"), opt(),    S("aba"));
-    test0(S("aba"), opt('a'), S("b"));
-    test0(S("aba"), opt('b'), S("aa"));
-    test0(S("aba"), opt('c'), S("aba"));
+  test0(S("aba"), opt(), S("aba"), 0);
+  test0(S("aba"), opt('a'), S("b"), 2);
+  test0(S("aba"), opt('b'), S("aa"), 1);
+  test0(S("aba"), opt('c'), S("aba"), 0);
 }
 
 int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
 
   return 0;
 }

libcxx/test/std/strings/strings.erasure/erase_if.pass.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
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
 
 // <string>
 
 // template <class charT, class traits, class Allocator, class Predicate>
-//   void erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
+//   typename basic_string<charT, traits, Allocator>::size_type
+//   erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);
 
 #include <string>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 
 template <class S, class Pred>
-void
-test0(S s, Pred p, S expected)
-{
-    ASSERT_SAME_TYPE(void, decltype(std::erase_if(s, p)));
-    std::erase_if(s, p);
-    LIBCPP_ASSERT(s.__invariants());
-    assert(s == expected);
+void test0(S s, Pred p, S expected, size_t expected_erased_count) {
+  ASSERT_SAME_TYPE(size_t, decltype(std::erase_if(s, p)));
+  assert(expected_erased_count == std::erase_if(s, p));
 }
 
 template <typename S>
 void test()
 {
     auto isA = [](auto ch) { return ch == 'a';};
     auto isB = [](auto ch) { return ch == 'b';};
     auto isC = [](auto ch) { return ch == 'c';};
     auto isD = [](auto ch) { return ch == 'd';};
     auto True  = [](auto) { return true; };
     auto False = [](auto) { return false; };
 
-    test0(S(""), isA, S(""));
+    test0(S(""), isA, S(""), 0);
 
-    test0(S("a"), isA, S(""));
-    test0(S("a"), isB, S("a"));
+    test0(S("a"), isA, S(""), 1);
+    test0(S("a"), isB, S("a"), 0);
 
-    test0(S("ab"), isA, S("b"));
-    test0(S("ab"), isB, S("a"));
-    test0(S("ab"), isC, S("ab"));
-    test0(S("aa"), isA, S(""));
-    test0(S("aa"), isC, S("aa"));
-
-    test0(S("abc"), isA, S("bc"));
-    test0(S("abc"), isB, S("ac"));
-    test0(S("abc"), isC, S("ab"));
-    test0(S("abc"), isD, S("abc"));
-
-    test0(S("aab"), isA, S("b"));
-    test0(S("aab"), isB, S("aa"));
-    test0(S("aab"), isC, S("aab"));
-    test0(S("abb"), isA, S("bb"));
-    test0(S("abb"), isB, S("a"));
-    test0(S("abb"), isC, S("abb"));
-    test0(S("aaa"), isA, S(""));
-    test0(S("aaa"), isB, S("aaa"));
+    test0(S("ab"), isA, S("b"), 1);
+    test0(S("ab"), isB, S("a"), 1);
+    test0(S("ab"), isC, S("ab"), 0);
+    test0(S("aa"), isA, S(""), 2);
+    test0(S("aa"), isC, S("aa"), 0);
+
+    test0(S("abc"), isA, S("bc"), 1);
+    test0(S("abc"), isB, S("ac"), 1);
+    test0(S("abc"), isC, S("ab"), 1);
+    test0(S("abc"), isD, S("abc"), 0);
+
+    test0(S("aab"), isA, S("b"), 2);
+    test0(S("aab"), isB, S("aa"), 1);
+    test0(S("aab"), isC, S("aab"), 0);
+    test0(S("abb"), isA, S("bb"), 1);
+    test0(S("abb"), isB, S("a"), 2);
+    test0(S("abb"), isC, S("abb"), 0);
+    test0(S("aaa"), isA, S(""), 3);
+    test0(S("aaa"), isB, S("aaa"), 0);
 
-    test0(S("aba"), False,  S("aba"));
-    test0(S("aba"), True,   S(""));
+    test0(S("aba"), False, S("aba"), 0);
+    test0(S("aba"), True, S(""), 3);
 }
 
 int main(int, char**)
 {
     test<std::string>();
     test<std::basic_string<char, std::char_traits<char>, min_allocator<char>>> ();
     test<std::basic_string<char, std::char_traits<char>, test_allocator<char>>> ();
 
   return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
    },
    "headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream",
                "string", "string_view"],
    "depends": "defined(__cpp_char8_t)",
    "internal_depends": "!defined(_LIBCPP_NO_HAS_CHAR8_T)",
    },
   {"name": "__cpp_lib_erase_if",
    "values": {
-     "c++2a": int(201811),
+     "c++2a": int(202002),
    },
    "headers": ["string", "deque", "forward_list", "list", "vector", "map",
                "set", "unordered_map", "unordered_set"]
   },
   {"name": "__cpp_lib_destroying_delete",
    "values": {
      "c++2a": int(201806),
    },
feature_test_macros = sorted([ add_version_header(x) for x in [
   {"name": "__cpp_lib_endian",
    "values": {
      "c++2a": int(201907),
    },
    "headers": ["bit"],
    },
   {"name": "__cpp_lib_to_array",
    "values": {
-     "c++2a": 201907L,
+     "c++2a": int(201907),
    },
    "headers": ["array"],
    },
 ]], key=lambda tc: tc["name"])
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++2a']
   return list(std_dialects)

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1959">P1959</a></td><td>LWG</td><td>Remove std::weak_equality and std::strong_equality</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1960">P1960</a></td><td>LWG</td><td>NB Comment Changes Reviewed by SG1</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1961">P1961</a></td><td>LWG</td><td>Harmonizing the definitions of total order for pointers</td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1965">P1965</a></td><td>LWG</td><td>Blanket Wording for Specifying “Hidden Friends”</td><td>Belfast</td><td><i> </i></td><td></td></tr>
 
     <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0586">P0586</a></td><td>LWG</td><td>Safe integral comparisons</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0593">P0593</a></td><td>CWG</td><td>Implicit creation of objects for low-level object manipulation</td><td>Prague</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1115">P1115</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if</td><td>Prague</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P1115">P1115</a></td><td>LWG</td><td>Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if</td><td>Prague</td><td>Complete</td><td>11.0</td></tr>
   <tr><td><a href="https://wg21.link/P1243">P1243</a></td><td>LWG</td><td>Rangify New Algorithms</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1460">P1460</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 20 - Utilities library</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1739">P1739</a></td><td>LWG</td><td>Avoid template bloat for safe_ranges in combination with "subrange-y" view adaptors</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1831">P1831</a></td><td>LWG</td><td>Deprecating volatile: library</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1868">P1868</a></td><td>LWG</td><td>width: clarifying units of width and precision in std::format</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1908">P1908</a></td><td>CWG</td><td>Reserving Attribute Namespaces for Future Use</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1937">P1937</a></td><td>CWG</td><td>Fixing inconsistencies between constexpr and consteval functions</td><td>Prague</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1956">P1956</a></td><td>LWG</td><td>On the names of low-level bit manipulation functions</td><td>Prague</td><td><i> </i></td><td></td></tr>