re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/container/fixed_array.h

@@ -84,11 +84,9 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   static constexpr size_t kInlineBytesDefault = 256;
 
   using AllocatorTraits = std::allocator_traits<A>;
-  // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
-  // but this seems to be mostly pedantic.
   template <typename Iterator>
-  using EnableIfForwardIterator = std::enable_if_t<
-      base_internal::IsAtLeastForwardIterator<Iterator>::value>;
+  using EnableIfInputIterator =
+      std::enable_if_t<base_internal::IsAtLeastInputIterator<Iterator>::value>;
   static constexpr bool NoexceptCopyable() {
     return std::is_nothrow_copy_constructible<StorageElement>::value &&
            absl::allocator_is_nothrow<allocator_type>::value;
@@ -161,8 +159,8 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
 
   // Creates an array initialized with the elements from the input
   // range. The array's size will always be `std::distance(first, last)`.
-  // REQUIRES: Iterator must be a forward_iterator or better.
-  template <typename Iterator, EnableIfForwardIterator<Iterator>* = nullptr>
+  // REQUIRES: Iterator must be a input_iterator or better.
+  template <typename Iterator, EnableIfInputIterator<Iterator>* = nullptr>
   FixedArray(Iterator first, Iterator last,
              const allocator_type& a = allocator_type())
       : storage_(std::distance(first, last), a) {

package/vendor/abseil-cpp/absl/container/flat_hash_map.h

@@ -127,13 +127,17 @@ struct FlatHashMapPolicy;
 //   if (result != ducks.end()) {
 //     std::cout << "Result: " << result->second << std::endl;
 //   }
-template <class K, class V, class Hash = DefaultHashContainerHash<K>,
-          class Eq = DefaultHashContainerEq<K>,
-          class Allocator = std::allocator<std::pair<const K, V>>>
+template <
+    class K, class V,
+    class Hash =
+        typename container_internal::FlatHashMapPolicy<K, V>::DefaultHash,
+    class Eq = typename container_internal::FlatHashMapPolicy<K, V>::DefaultEq,
+    class Allocator =
+        typename container_internal::FlatHashMapPolicy<K, V>::DefaultAlloc>
 class ABSL_ATTRIBUTE_OWNER flat_hash_map
-    : public absl::container_internal::raw_hash_map<
+    : public absl::container_internal::InstantiateRawHashMap<
           absl::container_internal::FlatHashMapPolicy<K, V>, Hash, Eq,
-          Allocator> {
+          Allocator>::type {
   using Base = typename flat_hash_map::raw_hash_map;
 
  public:
@@ -462,7 +466,9 @@ class ABSL_ATTRIBUTE_OWNER flat_hash_map
   //
   // Sets the number of slots in the `flat_hash_map` to the number needed to
   // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
+  // maximum load factor, and may rehash the container if needed. After this
+  // returns, it is guaranteed that `count - size()` elements can be inserted
+  // into the `flat_hash_map` without another rehash.
   using Base::reserve;
 
   // flat_hash_map::at()
@@ -635,6 +641,10 @@ struct FlatHashMapPolicy {
   using mapped_type = V;
   using init_type = std::pair</*non const*/ key_type, mapped_type>;
 
+  using DefaultHash = DefaultHashContainerHash<K>;
+  using DefaultEq = DefaultHashContainerEq<K>;
+  using DefaultAlloc = std::allocator<std::pair<const K, V>>;
+
   template <class Allocator, class... Args>
   static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
     slot_policy::construct(alloc, slot, std::forward<Args>(args)...);

package/vendor/abseil-cpp/absl/container/flat_hash_map_test.cc

@@ -39,8 +39,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace {
-using ::absl::container_internal::hash_internal::Enum;
-using ::absl::container_internal::hash_internal::EnumClass;
+
 using ::testing::_;
 using ::testing::IsEmpty;
 using ::testing::Pair;

package/vendor/abseil-cpp/absl/container/flat_hash_set.h

@@ -124,12 +124,16 @@ struct FlatHashSetPolicy;
 //   if (ducks.contains("dewey")) {
 //     std::cout << "We found dewey!" << std::endl;
 //   }
-template <class T, class Hash = DefaultHashContainerHash<T>,
-          class Eq = DefaultHashContainerEq<T>,
-          class Allocator = std::allocator<T>>
+template <
+    class T,
+    class Hash = typename container_internal::FlatHashSetPolicy<T>::DefaultHash,
+    class Eq = typename container_internal::FlatHashSetPolicy<T>::DefaultEq,
+    class Allocator =
+        typename container_internal::FlatHashSetPolicy<T>::DefaultAlloc>
 class ABSL_ATTRIBUTE_OWNER flat_hash_set
-    : public absl::container_internal::raw_hash_set<
-          absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq, Allocator> {
+    : public absl::container_internal::InstantiateRawHashSet<
+          absl::container_internal::FlatHashSetPolicy<T>, Hash, Eq,
+          Allocator>::type {
   using Base = typename flat_hash_set::raw_hash_set;
 
  public:
@@ -396,7 +400,9 @@ class ABSL_ATTRIBUTE_OWNER flat_hash_set
   //
   // Sets the number of slots in the `flat_hash_set` to the number needed to
   // accommodate at least `count` total elements without exceeding the current
-  // maximum load factor, and may rehash the container if needed.
+  // maximum load factor, and may rehash the container if needed. After this
+  // returns, it is guaranteed that `count - size()` elements can be inserted
+  // into the `flat_hash_set` without another rehash.
   using Base::reserve;
 
   // flat_hash_set::contains()
@@ -533,6 +539,10 @@ struct FlatHashSetPolicy {
   using init_type = T;
   using constant_iterators = std::true_type;
 
+  using DefaultHash = DefaultHashContainerHash<T>;
+  using DefaultEq = DefaultHashContainerEq<T>;
+  using DefaultAlloc = std::allocator<T>;
+
   template <class Allocator, class... Args>
   static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
     absl::allocator_traits<Allocator>::construct(*alloc, slot,

package/vendor/abseil-cpp/absl/container/flat_hash_set_test.cc

@@ -43,8 +43,6 @@ ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 namespace {
 
-using ::absl::container_internal::hash_internal::Enum;
-using ::absl::container_internal::hash_internal::EnumClass;
 using ::testing::IsEmpty;
 using ::testing::Pointee;
 using ::testing::UnorderedElementsAre;

package/vendor/abseil-cpp/absl/container/inlined_vector.h

@@ -815,13 +815,11 @@ class ABSL_ATTRIBUTE_WARN_UNUSED InlinedVector {
   // `InlinedVector::clear()`
   //
   // Destroys all elements in the inlined vector, setting the size to `0` and
-  // deallocating any held memory.
+  // preserving capacity.
   void clear() noexcept {
     inlined_vector_internal::DestroyAdapter<A>::DestroyElements(
         storage_.GetAllocator(), data(), size());
-    storage_.DeallocateIfAllocated();
-
-    storage_.SetInlinedSize(0);
+    storage_.SetSize(0);
   }
 
   // `InlinedVector::reserve(...)`
@@ -1011,6 +1009,16 @@ H AbslHashValue(H h, const absl::InlinedVector<T, N, A>& a) {
   return H::combine_contiguous(std::move(h), a.data(), a.size());
 }
 
+template <typename T, size_t N, typename A, typename Predicate>
+constexpr typename InlinedVector<T, N, A>::size_type erase_if(
+    InlinedVector<T, N, A>& v, Predicate pred) {
+  const auto it = std::remove_if(v.begin(), v.end(), std::move(pred));
+  const auto removed = static_cast<typename InlinedVector<T, N, A>::size_type>(
+      std::distance(it, v.end()));
+  v.erase(it, v.end());
+  return removed;
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

package/vendor/abseil-cpp/absl/container/inlined_vector_test.cc

@@ -51,6 +51,7 @@ using testing::AllOf;
 using testing::Each;
 using testing::ElementsAre;
 using testing::ElementsAreArray;
+using testing::IsEmpty;
 using testing::Eq;
 using testing::Gt;
 using testing::Pointee;
@@ -919,7 +920,9 @@ TEST(IntVec, Clear) {
     SCOPED_TRACE(len);
     IntVec v;
     Fill(&v, len);
+    size_t capacity_before_clear = v.capacity();
     v.clear();
+    EXPECT_EQ(v.capacity(), capacity_before_clear);
     EXPECT_EQ(0u, v.size());
     EXPECT_EQ(v.begin(), v.end());
   }
@@ -2254,4 +2257,22 @@ TEST(StorageTest, InlinedCapacityAutoIncrease) {
             sizeof(MySpan<int>) / sizeof(int));
 }
 
+TEST(IntVec, EraseIf) {
+  IntVec v = {3, 1, 2, 0};
+  EXPECT_EQ(absl::erase_if(v, [](int i) { return i > 1; }), 2u);
+  EXPECT_THAT(v, ElementsAre(1, 0));
+}
+
+TEST(IntVec, EraseIfMatchesNone) {
+  IntVec v = {1, 2, 3};
+  EXPECT_EQ(absl::erase_if(v, [](int i) { return i > 10; }), 0u);;
+  EXPECT_THAT(v, ElementsAre(1, 2, 3));
+}
+
+TEST(IntVec, EraseIfMatchesAll) {
+  IntVec v = {1, 2, 3};
+  EXPECT_EQ(absl::erase_if(v, [](int i) { return i > 0; }), 3u);
+  EXPECT_THAT(v, IsEmpty());
+}
+
 }  // anonymous namespace

package/vendor/abseil-cpp/absl/container/internal/btree_container.h

@@ -640,12 +640,12 @@ class btree_map_container : public btree_set_container<Tree> {
   }
   template <class K = key_type, int = EnableIf<LifetimeBoundK<K, false>>()>
   mapped_type &operator[](key_arg<K> &&k) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return try_emplace(std::forward<K>(k)).first->second;
+    return try_emplace(std::forward<key_arg<K>>(k)).first->second;
   }
   template <class K = key_type, int &..., EnableIf<LifetimeBoundK<K, true>> = 0>
   mapped_type &operator[](key_arg<K> &&k ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(
       this)) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return this->template operator[]<K, 0>(std::forward<K>(k));
+    return this->template operator[]<K, 0>(std::forward<key_arg<K>>(k));
   }
 
   template <typename K = key_type>
@@ -672,27 +672,36 @@ class btree_map_container : public btree_set_container<Tree> {
   std::pair<iterator, bool> insert_or_assign_impl(K &&k, M &&obj) {
     const std::pair<iterator, bool> ret =
         this->tree_.insert_unique(k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
+    if (!ret.second) {
+      // NOLINTNEXTLINE(bugprone-use-after-move)
+      ret.first->second = std::forward<M>(obj);
+    }
     return ret;
   }
   template <class K, class M>
   iterator insert_or_assign_hint_impl(const_iterator hint, K &&k, M &&obj) {
     const std::pair<iterator, bool> ret = this->tree_.insert_hint_unique(
         iterator(hint), k, std::forward<K>(k), std::forward<M>(obj));
-    if (!ret.second) ret.first->second = std::forward<M>(obj);
+    if (!ret.second) {
+      // NOLINTNEXTLINE(bugprone-use-after-move)
+      ret.first->second = std::forward<M>(obj);
+    }
     return ret.first;
   }
 
   template <class K, class... Args>
   std::pair<iterator, bool> try_emplace_impl(K &&k, Args &&... args) {
     return this->tree_.insert_unique(
+        // NOLINTNEXTLINE(bugprone-use-after-move)
         k, std::piecewise_construct, std::forward_as_tuple(std::forward<K>(k)),
         std::forward_as_tuple(std::forward<Args>(args)...));
   }
   template <class K, class... Args>
   iterator try_emplace_hint_impl(const_iterator hint, K &&k, Args &&... args) {
     return this->tree_
-        .insert_hint_unique(iterator(hint), k, std::piecewise_construct,
+        .insert_hint_unique(iterator(hint),
+                            // NOLINTNEXTLINE(bugprone-use-after-move)
+                            k, std::piecewise_construct,
                             std::forward_as_tuple(std::forward<K>(k)),
                             std::forward_as_tuple(std::forward<Args>(args)...))
         .first;

package/vendor/abseil-cpp/absl/container/internal/chunked_queue.h

@@ -0,0 +1,173 @@
+// Copyright 2025 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_
+#define ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
+#include <new>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/layout.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace container_internal {
+
+// ChunkedQueueBlock defines a node in a forward list of uninitialized storage
+// of size T's. The user is responsible for constructing and destroying T's in
+// said storage.
+//
+// ChunkedQueueBlock::New(size) returns said node, with at least size_hint T's
+// of uninitialized storage.
+template <typename T, typename Allocator>
+class ChunkedQueueBlock {
+ private:
+  using ChunkedQueueBlockAllocator = typename std::allocator_traits<
+      Allocator>::template rebind_alloc<ChunkedQueueBlock>;
+  using ByteAllocator =
+      typename std::allocator_traits<Allocator>::template rebind_alloc<char>;
+
+ public:
+  // NB, instances of this must not be created or destroyed directly, only via
+  // the New() and Delete() methods.  (This notionally-private constructor is
+  // public only to allow access from allocator types used by New().)
+  explicit ChunkedQueueBlock(size_t size)
+      : next_(nullptr), limit_(start() + size) {}
+
+  // Must be deleted by ChunkedQueueBlock::Delete.
+  static ChunkedQueueBlock* New(size_t size_hint, Allocator* alloc) {  // NOLINT
+    ABSL_ASSERT(size_hint >= size_t{1});
+    size_t allocation_bytes = AllocSize(size_hint);
+    void* mem;
+    std::tie(mem, allocation_bytes) = Allocate(allocation_bytes, alloc);
+    const size_t element_count =
+        (allocation_bytes - start_offset()) / sizeof(T);
+    ChunkedQueueBlock* as_block = static_cast<ChunkedQueueBlock*>(mem);
+    ChunkedQueueBlockAllocator block_alloc(*alloc);
+    std::allocator_traits<ChunkedQueueBlockAllocator>::construct(
+        block_alloc, as_block, element_count);
+    return as_block;
+  }
+
+  static void Delete(ChunkedQueueBlock* ptr, Allocator* alloc) {
+    const size_t allocation_bytes = AllocSize(ptr->size());
+    ChunkedQueueBlockAllocator block_alloc(*alloc);
+    std::allocator_traits<ChunkedQueueBlockAllocator>::destroy(block_alloc,
+                                                               ptr);
+    if constexpr (std::is_same_v<ByteAllocator, std::allocator<char>>) {
+#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
+      if (alignment() > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        ::operator delete(ptr
+#ifdef __cpp_sized_deallocation
+                          ,
+                          allocation_bytes
+#endif
+                          ,
+                          std::align_val_t(alignment()));
+        return;
+      }
+#endif
+      ::operator delete(ptr);
+    } else {
+      void* mem = ptr;
+      ByteAllocator byte_alloc(*alloc);
+      std::allocator_traits<ByteAllocator>::deallocate(
+          byte_alloc, static_cast<char*>(mem), allocation_bytes);
+    }
+  }
+
+  ChunkedQueueBlock* next() const { return next_; }
+  void set_next(ChunkedQueueBlock* next) { next_ = next; }
+  T* start() {
+    return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(this) +
+                                start_offset());
+  }
+  T* limit() { return limit_; }
+  size_t size() { return limit() - start(); }
+
+  static constexpr size_t block_size_from_bytes(size_t bytes) {
+    return bytes <= static_cast<size_t>(start_offset())
+               ? size_t{1}
+               : elements_in_bytes(bytes - start_offset());
+  }
+
+ private:
+  ChunkedQueueBlock(const ChunkedQueueBlock&) = delete;
+  ChunkedQueueBlock& operator=(const ChunkedQueueBlock&) = delete;
+
+  // The byte size to allocate to ensure space for `min_element_count` elements.
+  static constexpr size_t AllocSize(size_t min_element_count) {
+    return absl::container_internal::Layout<ChunkedQueueBlock, T>(
+               1, min_element_count)
+        .AllocSize();
+  }
+
+  static constexpr ptrdiff_t start_offset() {
+    return absl::container_internal::Layout<ChunkedQueueBlock, T>(1, 1)
+        .template Offset<1>();
+  }
+
+  static constexpr size_t alignment() {
+    return absl::container_internal::Layout<ChunkedQueueBlock, T>(1, 1)
+        .Alignment();
+  }
+
+  static constexpr size_t elements_in_bytes(size_t bytes) {
+    return (bytes + sizeof(T) - 1) / sizeof(T);
+  }
+
+  static std::pair<void*, size_t> Allocate(size_t allocation_bytes,
+                                           Allocator* alloc) {
+    // If we're using the default allocator, then we can use new.
+    void* mem;
+    if constexpr (std::is_same_v<ByteAllocator, std::allocator<char>>) {
+      // Older GCC versions have an unused variable warning on `alloc` inside
+      // this constexpr branch.
+      static_cast<void>(alloc);
+#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
+      if (alignment() > __STDCPP_DEFAULT_NEW_ALIGNMENT__) {
+        // Align the allocation to respect alignof(T).
+        mem = ::operator new(allocation_bytes, std::align_val_t(alignment()));
+        return {mem, allocation_bytes};
+      }
+#endif
+      mem = ::operator new(allocation_bytes);
+    } else {
+      ByteAllocator byte_alloc(*alloc);
+      mem = std::allocator_traits<ByteAllocator>::allocate(byte_alloc,
+                                                           allocation_bytes);
+    }
+    return {mem, allocation_bytes};
+  }
+
+  ChunkedQueueBlock* next_;
+  T* limit_;
+};
+
+}  // namespace container_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CONTAINER_INTERNAL_CHUNKED_QUEUE_H_

package/vendor/abseil-cpp/absl/container/internal/common.h

@@ -15,7 +15,10 @@
 #ifndef ABSL_CONTAINER_INTERNAL_COMMON_H_
 #define ABSL_CONTAINER_INTERNAL_COMMON_H_
 
+#include <algorithm>
 #include <cassert>
+#include <cstddef>
+#include <tuple>
 #include <type_traits>
 
 #include "absl/meta/type_traits.h"
@@ -243,6 +246,54 @@ struct InsertReturnType {
   NodeType node;
 };
 
+// Utilities to strip redundant template parameters from the underlying
+// implementation types.
+// We use a variadic pack (ie Params...) to specify required prefix of types for
+// non-default types, and then we use GetFromListOr to select the provided types
+// or the default ones otherwise.
+//
+// These default types do not contribute information for debugging and just
+// bloat the binary.
+// Removing the redundant tail types reduces mangled names and stringified
+// function names like __PRETTY_FUNCTION__.
+//
+// How to use:
+//  1. Define a template with `typename ...Params`
+//  2. Instantiate it via `ApplyWithoutDefaultSuffix<>` to only pass the minimal
+//     set of types.
+//  3. Inside the template use `GetFromListOr` to map back from the existing
+//     `Params` list to the actual types, filling the gaps when types are
+//     missing.
+
+template <typename Or, size_t N, typename... Params>
+using GetFromListOr = std::tuple_element_t<(std::min)(N, sizeof...(Params)),
+                                           std::tuple<Params..., Or>>;
+
+template <typename... T>
+struct TypeList {
+  template <template <typename...> class Template>
+  using Apply = Template<T...>;
+};
+
+// Evaluate to `Template<TPrefix...>` where the last type in the list (if any)
+// is different from the corresponding one in the default list.
+// Eg
+//   ApplyWithoutDefaultSuffix<Template, TypeList<a, b, c>, TypeList<a, X, c>>
+// evaluates to
+//   Template<a, X>
+template <template <typename...> class Template, typename D, typename T,
+          typename L = TypeList<>, typename = void>
+struct ApplyWithoutDefaultSuffix {
+  using type = typename L::template Apply<Template>;
+};
+template <template <typename...> class Template, typename D, typename... Ds,
+          typename T, typename... Ts, typename... L>
+struct ApplyWithoutDefaultSuffix<
+    Template, TypeList<D, Ds...>, TypeList<T, Ts...>, TypeList<L...>,
+    std::enable_if_t<!std::is_same_v<TypeList<D, Ds...>, TypeList<T, Ts...>>>>
+    : ApplyWithoutDefaultSuffix<Template, TypeList<Ds...>, TypeList<Ts...>,
+                       TypeList<L..., T>> {};
+
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/container/internal/container_memory.h

@@ -44,7 +44,12 @@ ABSL_NAMESPACE_BEGIN
 namespace container_internal {
 
 template <size_t Alignment>
-struct alignas(Alignment) AlignedType {};
+struct alignas(Alignment) AlignedType {
+  // When alignment is sufficient for the allocated memory to store pointers,
+  // include a pointer member so that swisstable backing arrays end up in the
+  // pointer-containing partition for heap partitioning.
+  std::conditional_t<(Alignment < alignof(void*)), char, void*> pointer;
+};
 
 // Allocates at least n bytes aligned to the specified alignment.
 // Alignment must be a power of 2. It must be positive.
@@ -130,6 +135,7 @@ decltype(std::declval<F>()(std::declval<T>())) WithConstructedImpl(
 template <class T, size_t... Is>
 auto TupleRefImpl(T&& t, absl::index_sequence<Is...>)
     -> decltype(std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...)) {
+  // NOLINTNEXTLINE(bugprone-use-after-move)
   return std::forward_as_tuple(std::get<Is>(std::forward<T>(t))...);
 }
 

package/vendor/abseil-cpp/absl/container/internal/container_memory_test.cc

@@ -25,6 +25,7 @@
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/base/config.h"
 #include "absl/base/no_destructor.h"
 #include "absl/container/internal/test_instance_tracker.h"
 #include "absl/meta/type_traits.h"
@@ -42,6 +43,16 @@ using ::testing::ElementsAre;
 using ::testing::Gt;
 using ::testing::Pair;
 
+#if ABSL_HAVE_BUILTIN(__builtin_infer_alloc_token)
+TEST(Memory, AlignedTypeAllocToken) {
+#if defined(__wasm__)
+  GTEST_SKIP() << "Fails on wasm due to lack of heap partitioning support.";
+#endif
+  EXPECT_GT(__builtin_infer_alloc_token(sizeof(AlignedType<alignof(void*)>)),
+            __builtin_infer_alloc_token(sizeof(int)));
+}
+#endif
+
 TEST(Memory, AlignmentLargerThanBase) {
   std::allocator<int8_t> alloc;
   void* mem = Allocate<2>(&alloc, 3);

package/vendor/abseil-cpp/absl/container/internal/hash_generator_testing.cc

@@ -26,7 +26,6 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
-namespace hash_internal {
 
 std::string Generator<std::string>::operator()() const {
   absl::InsecureBitGen gen;
@@ -50,7 +49,6 @@ absl::string_view Generator<absl::string_view>::operator()() const {
   return res;
 }
 
-}  // namespace hash_internal
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/container/internal/hash_generator_testing.h

@@ -31,6 +31,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/config.h"
 #include "absl/container/internal/hash_policy_testing.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
@@ -40,7 +41,6 @@
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace container_internal {
-namespace hash_internal {
 namespace generator_internal {
 
 template <class Container, class = void>
@@ -165,7 +165,6 @@ struct UniqueGenerator {
   }
 };
 
-}  // namespace hash_internal
 }  // namespace container_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/container/internal/hash_policy_testing.h

@@ -170,18 +170,4 @@ auto keys(const Set& s)
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-// ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
-// where the unordered containers are missing certain constructors that
-// take allocator arguments. This test is defined ad-hoc for the platforms
-// we care about (notably Crosstool 17) because libstdcxx's useless
-// versioning scheme precludes a more principled solution.
-// From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html)
-// "the unordered associative containers in <unordered_map> and <unordered_set>
-// meet the allocator-aware container requirements;"
-#if defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425
-#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
-#else
-#define ABSL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
-#endif
-
 #endif  // ABSL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_

package/vendor/abseil-cpp/absl/container/internal/hashtable_control_bytes.h

@@ -212,6 +212,9 @@ static_assert(
 static_assert(ctrl_t::kDeleted == static_cast<ctrl_t>(-2),
               "ctrl_t::kDeleted must be -2 to make the implementation of "
               "ConvertSpecialToEmptyAndFullToDeleted efficient");
+static_assert(ctrl_t::kEmpty == static_cast<ctrl_t>(-128),
+              "ctrl_t::kEmpty must be -128 to use saturated subtraction in"
+              " ConvertSpecialToEmptyAndFullToDeleted");
 
 // Helpers for checking the state of a control byte.
 inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
@@ -329,15 +332,15 @@ struct GroupSse2Impl {
   }
 
   void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
+    // Take advantage of the fact that kEmpty is already the smallest signed
+    // char value, and using a saturated subtraction will not affect it.
+    // All special values have the MSB set, so after an AND with MSBS, we
+    // are left with -128 for special values and 0 for full. After applying
+    // subs 2, we arrive at the result of -128(kEmpty) for special and
+    // -2(kDeleted) for full.
     auto msbs = _mm_set1_epi8(static_cast<char>(-128));
-    auto x126 = _mm_set1_epi8(126);
-#ifdef ABSL_INTERNAL_HAVE_SSSE3
-    auto res = _mm_or_si128(_mm_shuffle_epi8(x126, ctrl), msbs);
-#else
-    auto zero = _mm_setzero_si128();
-    auto special_mask = _mm_cmpgt_epi8_fixed(zero, ctrl);
-    auto res = _mm_or_si128(msbs, _mm_andnot_si128(special_mask, x126));
-#endif
+    auto twos = _mm_set1_epi8(static_cast<char>(2));
+    auto res = _mm_subs_epi8(_mm_and_si128(msbs, ctrl), twos);
     _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
   }