Export of internal Abseil changes

--
e2a571b818faaec4185426a8cf71fd2970674423 by Matt Kulukundis <kfm@google.com>:

Fix missed use of old RTTI macro

PiperOrigin-RevId: 413239579

--
e3c15a3fe0a4e44d6e08d69ad912b2245a403bd6 by Derek Mauro <dmauro@google.com>:

Makes erase_if return the number of erased elements for compatibility
with C++20

https://en.cppreference.com/w/cpp/container/unordered_map/erase_if

This may technically be an API break, but no actual breaks were found
in Google code. Fixes to open source code should be trivial.

Closes #1065

PiperOrigin-RevId: 413204392

--
c1fb1ddbc2def3f3d177e5b80b9934bdbb7b16fc by Matt Kulukundis <kfm@google.com>:

Consolidate to a single HAS_RTTI macro

PiperOrigin-RevId: 413169336
GitOrigin-RevId: e2a571b818faaec4185426a8cf71fd2970674423
Change-Id: I74b78ebd5fc172e3f5fcbd13a58cf53f7b250ae9

12 files changed, 79 insertions, 41 deletions

diff --git a/absl/container/btree_map.h b/absl/container/btree_map.h
index 4eafe062..797b949f 100644
--- a/absl/container/btree_map.h
+++ b/absl/container/btree_map.h
@@ -478,8 +478,11 @@ void swap(btree_map<K, V, C, A> &x, btree_map<K, V, C, A> &y) {
 // absl::erase_if(absl::btree_map<>, Pred)
 //
 // Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
 template <typename K, typename V, typename C, typename A, typename Pred>
-void erase_if(btree_map<K, V, C, A> &map, Pred pred) {
+typename btree_map<K, V, C, A>::size_type erase_if(
+    btree_map<K, V, C, A> &map, Pred pred) {
+  const auto initial_size = map.size();
   for (auto it = map.begin(); it != map.end();) {
     if (pred(*it)) {
       it = map.erase(it);
@@ -487,6 +490,7 @@ void erase_if(btree_map<K, V, C, A> &map, Pred pred) {
       ++it;
     }
   }
+  return initial_size - map.size();
 }
 
 // absl::btree_multimap
@@ -809,8 +813,11 @@ void swap(btree_multimap<K, V, C, A> &x, btree_multimap<K, V, C, A> &y) {
 // absl::erase_if(absl::btree_multimap<>, Pred)
 //
 // Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
 template <typename K, typename V, typename C, typename A, typename Pred>
-void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
+typename btree_multimap<K, V, C, A>::size_type erase_if(
+    btree_multimap<K, V, C, A> &map, Pred pred) {
+  const auto initial_size = map.size();
   for (auto it = map.begin(); it != map.end();) {
     if (pred(*it)) {
       it = map.erase(it);
@@ -818,6 +825,7 @@ void erase_if(btree_multimap<K, V, C, A> &map, Pred pred) {
       ++it;
     }
   }
+  return initial_size - map.size();
 }
 
 namespace container_internal {
diff --git a/absl/container/btree_set.h b/absl/container/btree_set.h
index 8c96e0ed..2c217d8f 100644
--- a/absl/container/btree_set.h
+++ b/absl/container/btree_set.h
@@ -398,8 +398,11 @@ void swap(btree_set<K, C, A> &x, btree_set<K, C, A> &y) {
 // absl::erase_if(absl::btree_set<>, Pred)
 //
 // Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
 template <typename K, typename C, typename A, typename Pred>
-void erase_if(btree_set<K, C, A> &set, Pred pred) {
+typename btree_set<K, C, A>::size_type erase_if(btree_set<K, C, A> &set,
+                                                Pred pred) {
+  const auto initial_size = set.size();
   for (auto it = set.begin(); it != set.end();) {
     if (pred(*it)) {
       it = set.erase(it);
@@ -407,6 +410,7 @@ void erase_if(btree_set<K, C, A> &set, Pred pred) {
       ++it;
     }
   }
+  return initial_size - set.size();
 }
 
 // absl::btree_multiset<>
@@ -724,8 +728,11 @@ void swap(btree_multiset<K, C, A> &x, btree_multiset<K, C, A> &y) {
 // absl::erase_if(absl::btree_multiset<>, Pred)
 //
 // Erases all elements that satisfy the predicate pred from the container.
+// Returns the number of erased elements.
 template <typename K, typename C, typename A, typename Pred>
-void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
+typename btree_multiset<K, C, A>::size_type erase_if(
+   btree_multiset<K, C, A> & set, Pred pred) {
+  const auto initial_size = set.size();
   for (auto it = set.begin(); it != set.end();) {
     if (pred(*it)) {
       it = set.erase(it);
@@ -733,6 +740,7 @@ void erase_if(btree_multiset<K, C, A> &set, Pred pred) {
       ++it;
     }
   }
+  return initial_size - set.size();
 }
 
 namespace container_internal {
diff --git a/absl/container/btree_test.cc b/absl/container/btree_test.cc
index d27cf271..650c51db 100644
--- a/absl/container/btree_test.cc
+++ b/absl/container/btree_test.cc
@@ -2452,23 +2452,28 @@ TEST(Btree, EraseIf) {
   // Test that erase_if works with all the container types and supports lambdas.
   {
     absl::btree_set<int> s = {1, 3, 5, 6, 100};
-    erase_if(s, [](int k) { return k > 3; });
+    EXPECT_EQ(erase_if(s, [](int k) { return k > 3; }), 3);
     EXPECT_THAT(s, ElementsAre(1, 3));
   }
   {
     absl::btree_multiset<int> s = {1, 3, 3, 5, 6, 6, 100};
-    erase_if(s, [](int k) { return k <= 3; });
+    EXPECT_EQ(erase_if(s, [](int k) { return k <= 3; }), 3);
     EXPECT_THAT(s, ElementsAre(5, 6, 6, 100));
   }
   {
     absl::btree_map<int, int> m = {{1, 1}, {3, 3}, {6, 6}, {100, 100}};
-    erase_if(m, [](std::pair<const int, int> kv) { return kv.first > 3; });
+    EXPECT_EQ(
+        erase_if(m, [](std::pair<const int, int> kv) { return kv.first > 3; }),
+        2);
     EXPECT_THAT(m, ElementsAre(Pair(1, 1), Pair(3, 3)));
   }
   {
     absl::btree_multimap<int, int> m = {{1, 1}, {3, 3}, {3, 6},
                                         {6, 6}, {6, 7}, {100, 6}};
-    erase_if(m, [](std::pair<const int, int> kv) { return kv.second == 6; });
+    EXPECT_EQ(
+        erase_if(m,
+                 [](std::pair<const int, int> kv) { return kv.second == 6; }),
+        3);
     EXPECT_THAT(m, ElementsAre(Pair(1, 1), Pair(3, 3), Pair(6, 7)));
   }
   // Test that erasing all elements from a large set works and test support for
@@ -2476,13 +2481,13 @@ TEST(Btree, EraseIf) {
   {
     absl::btree_set<int> s;
     for (int i = 0; i < 1000; ++i) s.insert(2 * i);
-    erase_if(s, IsEven);
+    EXPECT_EQ(erase_if(s, IsEven), 1000);
     EXPECT_THAT(s, IsEmpty());
   }
   // Test that erase_if supports other format of function pointers.
   {
     absl::btree_set<int> s = {1, 3, 5, 6, 100};
-    erase_if(s, &IsEven);
+    EXPECT_EQ(erase_if(s, &IsEven), 2);
     EXPECT_THAT(s, ElementsAre(1, 3, 5));
   }
 }
diff --git a/absl/container/flat_hash_map.h b/absl/container/flat_hash_map.h
index 74def0df..69fbf239 100644
--- a/absl/container/flat_hash_map.h
+++ b/absl/container/flat_hash_map.h
@@ -541,10 +541,12 @@ class flat_hash_map : public absl::container_internal::raw_hash_map<
 // erase_if(flat_hash_map<>, Pred)
 //
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
 template <typename K, typename V, typename H, typename E, typename A,
           typename Predicate>
-void erase_if(flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
-  container_internal::EraseIf(pred, &c);
+typename flat_hash_map<K, V, H, E, A>::size_type erase_if(
+    flat_hash_map<K, V, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
 }
 
 namespace container_internal {
diff --git a/absl/container/flat_hash_map_test.cc b/absl/container/flat_hash_map_test.cc
index 8dda1d35..263951f1 100644
--- a/absl/container/flat_hash_map_test.cc
+++ b/absl/container/flat_hash_map_test.cc
@@ -236,33 +236,36 @@ TEST(FlatHashMap, EraseIf) {
   // Erase all elements.
   {
     flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, [](std::pair<const int, int>) { return true; });
+    EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return true; }), 5);
     EXPECT_THAT(s, IsEmpty());
   }
   // Erase no elements.
   {
     flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, [](std::pair<const int, int>) { return false; });
+    EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return false; }), 0);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3),
                                         Pair(4, 4), Pair(5, 5)));
   }
   // Erase specific elements.
   {
     flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s,
-             [](std::pair<const int, int> kvp) { return kvp.first % 2 == 1; });
+    EXPECT_EQ(erase_if(s,
+                       [](std::pair<const int, int> kvp) {
+                         return kvp.first % 2 == 1;
+                       }),
+              3);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(2, 2), Pair(4, 4)));
   }
   // Predicate is function reference.
   {
     flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, FirstIsEven);
+    EXPECT_EQ(erase_if(s, FirstIsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
   }
   // Predicate is function pointer.
   {
     flat_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, &FirstIsEven);
+    EXPECT_EQ(erase_if(s, &FirstIsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
   }
 }
diff --git a/absl/container/flat_hash_set.h b/absl/container/flat_hash_set.h
index 6b89da65..f1c650cc 100644
--- a/absl/container/flat_hash_set.h
+++ b/absl/container/flat_hash_set.h
@@ -443,9 +443,11 @@ class flat_hash_set
 // erase_if(flat_hash_set<>, Pred)
 //
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
 template <typename T, typename H, typename E, typename A, typename Predicate>
-void erase_if(flat_hash_set<T, H, E, A>& c, Predicate pred) {
-  container_internal::EraseIf(pred, &c);
+typename flat_hash_set<T, H, E, A>::size_type erase_if(
+    flat_hash_set<T, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
 }
 
 namespace container_internal {
diff --git a/absl/container/flat_hash_set_test.cc b/absl/container/flat_hash_set_test.cc
index 8f6f9944..b6a72a20 100644
--- a/absl/container/flat_hash_set_test.cc
+++ b/absl/container/flat_hash_set_test.cc
@@ -143,31 +143,31 @@ TEST(FlatHashSet, EraseIf) {
   // Erase all elements.
   {
     flat_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int) { return true; });
+    EXPECT_EQ(erase_if(s, [](int) { return true; }), 5);
     EXPECT_THAT(s, IsEmpty());
   }
   // Erase no elements.
   {
     flat_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int) { return false; });
+    EXPECT_EQ(erase_if(s, [](int) { return false; }), 0);
     EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
   }
   // Erase specific elements.
   {
     flat_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int k) { return k % 2 == 1; });
+    EXPECT_EQ(erase_if(s, [](int k) { return k % 2 == 1; }), 3);
     EXPECT_THAT(s, UnorderedElementsAre(2, 4));
   }
   // Predicate is function reference.
   {
     flat_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, IsEven);
+    EXPECT_EQ(erase_if(s, IsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
   }
   // Predicate is function pointer.
   {
     flat_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, &IsEven);
+    EXPECT_EQ(erase_if(s, &IsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
   }
 }
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h
index 12682b35..d4b72ab1 100644
--- a/absl/container/internal/raw_hash_set.h
+++ b/absl/container/internal/raw_hash_set.h
@@ -1958,7 +1958,9 @@ class raw_hash_set {
 
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
 template <typename P, typename H, typename E, typename A, typename Predicate>
-void EraseIf(Predicate& pred, raw_hash_set<P, H, E, A>* c) {
+typename raw_hash_set<P, H, E, A>::size_type EraseIf(
+    Predicate& pred, raw_hash_set<P, H, E, A>* c) {
+  const auto initial_size = c->size();
   for (auto it = c->begin(), last = c->end(); it != last;) {
     if (pred(*it)) {
       c->erase(it++);
@@ -1966,6 +1968,7 @@ void EraseIf(Predicate& pred, raw_hash_set<P, H, E, A>* c) {
       ++it;
     }
   }
+  return initial_size - c->size();
 }
 
 namespace hashtable_debug_internal {
diff --git a/absl/container/node_hash_map.h b/absl/container/node_hash_map.h
index 302dafa2..0d4ebeda 100644
--- a/absl/container/node_hash_map.h
+++ b/absl/container/node_hash_map.h
@@ -525,10 +525,12 @@ class node_hash_map
 // erase_if(node_hash_map<>, Pred)
 //
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
 template <typename K, typename V, typename H, typename E, typename A,
           typename Predicate>
-void erase_if(node_hash_map<K, V, H, E, A>& c, Predicate pred) {
-  container_internal::EraseIf(pred, &c);
+typename node_hash_map<K, V, H, E, A>::size_type erase_if(
+    node_hash_map<K, V, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
 }
 
 namespace container_internal {
diff --git a/absl/container/node_hash_map_test.cc b/absl/container/node_hash_map_test.cc
index 8f59a1e4..e941a836 100644
--- a/absl/container/node_hash_map_test.cc
+++ b/absl/container/node_hash_map_test.cc
@@ -223,33 +223,36 @@ TEST(NodeHashMap, EraseIf) {
   // Erase all elements.
   {
     node_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, [](std::pair<const int, int>) { return true; });
+    EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return true; }), 5);
     EXPECT_THAT(s, IsEmpty());
   }
   // Erase no elements.
   {
     node_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, [](std::pair<const int, int>) { return false; });
+    EXPECT_EQ(erase_if(s, [](std::pair<const int, int>) { return false; }), 0);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(2, 2), Pair(3, 3),
                                         Pair(4, 4), Pair(5, 5)));
   }
   // Erase specific elements.
   {
     node_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s,
-             [](std::pair<const int, int> kvp) { return kvp.first % 2 == 1; });
+    EXPECT_EQ(erase_if(s,
+                       [](std::pair<const int, int> kvp) {
+                         return kvp.first % 2 == 1;
+                       }),
+              3);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(2, 2), Pair(4, 4)));
   }
   // Predicate is function reference.
   {
     node_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, FirstIsEven);
+    EXPECT_EQ(erase_if(s, FirstIsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
   }
   // Predicate is function pointer.
   {
     node_hash_map<int, int> s = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    erase_if(s, &FirstIsEven);
+    EXPECT_EQ(erase_if(s, &FirstIsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(Pair(1, 1), Pair(3, 3), Pair(5, 5)));
   }
 }
diff --git a/absl/container/node_hash_set.h b/absl/container/node_hash_set.h
index 4247288d..3bc5fe6b 100644
--- a/absl/container/node_hash_set.h
+++ b/absl/container/node_hash_set.h
@@ -433,9 +433,11 @@ class node_hash_set
 // erase_if(node_hash_set<>, Pred)
 //
 // Erases all elements that satisfy the predicate `pred` from the container `c`.
+// Returns the number of erased elements.
 template <typename T, typename H, typename E, typename A, typename Predicate>
-void erase_if(node_hash_set<T, H, E, A>& c, Predicate pred) {
-  container_internal::EraseIf(pred, &c);
+typename node_hash_set<T, H, E, A>::size_type erase_if(
+    node_hash_set<T, H, E, A>& c, Predicate pred) {
+  return container_internal::EraseIf(pred, &c);
 }
 
 namespace container_internal {
diff --git a/absl/container/node_hash_set_test.cc b/absl/container/node_hash_set_test.cc
index 7ddad202..98a8dbdd 100644
--- a/absl/container/node_hash_set_test.cc
+++ b/absl/container/node_hash_set_test.cc
@@ -108,31 +108,31 @@ TEST(NodeHashSet, EraseIf) {
   // Erase all elements.
   {
     node_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int) { return true; });
+    EXPECT_EQ(erase_if(s, [](int) { return true; }), 5);
     EXPECT_THAT(s, IsEmpty());
   }
   // Erase no elements.
   {
     node_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int) { return false; });
+    EXPECT_EQ(erase_if(s, [](int) { return false; }), 0);
     EXPECT_THAT(s, UnorderedElementsAre(1, 2, 3, 4, 5));
   }
   // Erase specific elements.
   {
     node_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, [](int k) { return k % 2 == 1; });
+    EXPECT_EQ(erase_if(s, [](int k) { return k % 2 == 1; }), 3);
     EXPECT_THAT(s, UnorderedElementsAre(2, 4));
   }
   // Predicate is function reference.
   {
     node_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, IsEven);
+    EXPECT_EQ(erase_if(s, IsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
   }
   // Predicate is function pointer.
   {
     node_hash_set<int> s = {1, 2, 3, 4, 5};
-    erase_if(s, &IsEven);
+    EXPECT_EQ(erase_if(s, &IsEven), 2);
     EXPECT_THAT(s, UnorderedElementsAre(1, 3, 5));
   }
 }