grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/base/options.h

@@ -73,31 +73,33 @@
 // Type Compatibility Options
 // -----------------------------------------------------------------------------
 
-// ABSL_OPTION_USE_STD_STRING_VIEW
+// ABSL_OPTION_USE_STD_SOURCE_LOCATION
 //
-// This option controls whether absl::string_view is implemented as an alias to
-// std::string_view, or as an independent implementation.
+// This option controls whether absl::SourceLocation is implemented as an alias
+// to the std::source_location type, or as an independent implementation.
 //
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
+// A value of 0 means to use Abseil's implementation.  This requires only C++17
+// support, and is expected to run on every toolchain we support, and to
+// properly capture source location information on every toolchain that supports
+// the necessary built-ins (such as `__builtin_LINE`).
 //
-// A value of 1 means to use an alias to std::string_view.  This requires that
-// all code using Abseil is built in C++17 mode or later.
+// A value of 1 means to use aliases.  This requires that all code using Abseil
+// is built in C++20 mode or later.
 //
 // A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::string_view is available.  This
-// option is useful when you are building your program from source.  It should
-// not be used otherwise -- for example, if you are distributing Abseil in a
-// binary package manager -- since in mode 2, absl::string_view will name a
-// different type, with a different mangled name and binary layout, depending on
-// the compiler flags passed by the end user.  For more info, see
+// and use an alias only if working std::source_location types are available.
+// This option is useful when you are building your program from source.  It
+// should not be used otherwise -- for example, if you are distributing Abseil
+// in a binary package manager -- since in mode 2, they will name different
+// types, with different mangled names and binary layout, depending on the
+// compiler flags passed by the end user.  For more info, see
 // https://abseil.io/about/design/dropin-types.
 //
 // User code should not inspect this macro.  To check in the preprocessor if
-// absl::string_view is a typedef of std::string_view, use the feature macro
-// ABSL_USES_STD_STRING_VIEW.
-
-#define ABSL_OPTION_USE_STD_STRING_VIEW 2
+// the source location type is an alias of std::source_location type, use the
+// feature macro ABSL_USES_STD_SOURCE_LOCATION.
+//
+#define ABSL_OPTION_USE_STD_SOURCE_LOCATION 2
 
 // ABSL_OPTION_USE_STD_ORDERING
 //
@@ -149,7 +151,7 @@
 // allowed.
 
 #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20250512
+#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20260526
 
 // ABSL_OPTION_HARDENED
 //
@@ -181,4 +183,30 @@
 
 #define ABSL_OPTION_HARDENED 0
 
+// ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY
+//
+// This option controls whether Abseil is allowed to use non-portable
+// hardware-accelerated implementations in headers (where they are typically
+// inlined into the caller's translation unit).
+//
+// Using such optimizations in headers can lead to One Definition Rule (ODR)
+// violations if different translation units are built with different CPU
+// architecture flags (e.g., -march=native vs -march=generic) and linked
+// together.
+//
+// A value of 0 means to use the portable software implementation in headers.
+// This provides the best ODR guarantees when linking code built with
+// inconsistent flags, but may be slower.
+//
+// A value of 1 means that the implementation requires the use of a
+// hardware-accelerated implementation. This requires the compiler environment
+// to support these instructions; otherwise, the build will fail.
+//
+// A value of 2 means to select the best available implementation based on
+// the compiler flags, but can't guarantee ODR safety if translation units are
+// built with inconsistent flags.
+//
+// User code should not inspect this macro.
+#define ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY 0
+
 #endif  // ABSL_BASE_OPTIONS_H_

data/third_party/abseil-cpp/absl/base/policy_checks.h

@@ -46,17 +46,17 @@
 // Toolchain Check
 // -----------------------------------------------------------------------------
 
-// We support Visual Studio 2019 (MSVC++ 16.0) and later.
+// We support Visual Studio 2022 (MSVC++ 17.0) and later.
 // This minimum will go up.
-#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__)
-#error "This package requires Visual Studio 2019 (MSVC++ 16.0) or higher."
+#if defined(_MSC_VER) && _MSC_VER < 1930 && !defined(__clang__)
+#error "This package requires Visual Studio 2022 (MSVC++ 17.0) or higher."
 #endif
 
 // We support GCC 7 and later.
 // This minimum will go up.
 #if defined(__GNUC__) && !defined(__clang__)
-#if __GNUC__ < 7
-#error "This package requires GCC 7 or higher."
+#if __GNUC__ < 10
+#error "This package requires GCC 10 or higher."
 #endif
 #endif
 

data/third_party/abseil-cpp/absl/base/{internal/throw_delegate.cc → throw_delegate.cc}

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/throw_delegate.h"
 
 #include <cstdlib>
 #include <functional>
@@ -24,11 +24,6 @@
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-
-// NOTE: The exception types, like `std::logic_error`, do not exist on all
-// platforms. (For example, the Android NDK does not have them.)
-// Therefore, their use must be guarded by `#ifdef` or equivalent.
 
 void ThrowStdLogicError(const std::string& what_arg) {
 #ifdef ABSL_HAVE_EXCEPTIONS
@@ -198,6 +193,13 @@ void ThrowStdBadAlloc() {
 #endif
 }
 
-}  // namespace base_internal
+void ThrowStdBadArrayNewLength() {
+#ifdef ABSL_HAVE_EXCEPTIONS
+  throw std::bad_array_new_length();
+#else
+  std::abort();
+#endif
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/abseil-cpp/absl/base/{internal/throw_delegate.h → throw_delegate.h}

@@ -1,4 +1,3 @@
-//
 // Copyright 2017 The Abseil Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,10 +11,9 @@
 // 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_BASE_INTERNAL_THROW_DELEGATE_H_
-#define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#ifndef ABSL_BASE_THROW_DELEGATE_H_
+#define ABSL_BASE_THROW_DELEGATE_H_
 
 #include <string>
 
@@ -23,7 +21,6 @@
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-namespace base_internal {
 
 // Helper functions that allow throwing exceptions consistently from anywhere.
 // The main use case is for header-based libraries (eg templates), as they will
@@ -60,16 +57,9 @@ namespace base_internal {
 
 [[noreturn]] void ThrowStdBadFunctionCall();
 [[noreturn]] void ThrowStdBadAlloc();
+[[noreturn]] void ThrowStdBadArrayNewLength();
 
-// ThrowStdBadArrayNewLength() cannot be consistently supported because
-// std::bad_array_new_length is missing in libstdc++ until 4.9.0.
-// https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
-// https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
-// libcxx (as of 3.2) and msvc (as of 2015) both have it.
-// [[noreturn]] void ThrowStdBadArrayNewLength();
-
-}  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
-#endif  // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#endif  // ABSL_BASE_THROW_DELEGATE_H_

data/third_party/abseil-cpp/absl/cleanup/cleanup.h

@@ -19,6 +19,10 @@
 // `absl::Cleanup` implements the scope guard idiom, invoking the contained
 // callback's `operator()() &&` on scope exit.
 //
+// This class doesn't allocate or take any locks, and is safe to use in a signal
+// handler. Of course the callback with which it is constructed also must be
+// signal safe in order for this to be useful.
+//
 // Example:
 //
 // ```
@@ -71,6 +75,7 @@
 #include <utility>
 
 #include "absl/base/config.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/cleanup/internal/cleanup.h"
 
@@ -91,12 +96,12 @@ class [[nodiscard]] Cleanup final {
   Cleanup(Cleanup&& other) = default;
 
   void Cancel() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    absl::base_internal::HardeningAssert(storage_.IsCallbackEngaged());
     storage_.DestroyCallback();
   }
 
   void Invoke() && {
-    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    absl::base_internal::HardeningAssert(storage_.IsCallbackEngaged());
     storage_.InvokeCallback();
     storage_.DestroyCallback();
   }

data/third_party/abseil-cpp/absl/cleanup/internal/cleanup.h

@@ -19,6 +19,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/utility/utility.h"
@@ -49,13 +50,13 @@ class Storage {
   explicit Storage(Callback callback) {
     // Placement-new into a character buffer is used for eager destruction when
     // the cleanup is invoked or cancelled. To ensure this optimizes well, the
-    // behavior is implemented locally instead of using an absl::optional.
+    // behavior is implemented locally instead of using a std::optional.
     ::new (GetCallbackBuffer()) Callback(std::move(callback));
     is_callback_engaged_ = true;
   }
 
   Storage(Storage&& other) {
-    ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
+    absl::base_internal::HardeningAssert(other.IsCallbackEngaged());
 
     ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
     is_callback_engaged_ = true;

data/third_party/abseil-cpp/absl/container/btree_map.h

@@ -57,18 +57,44 @@
 #ifndef ABSL_CONTAINER_BTREE_MAP_H_
 #define ABSL_CONTAINER_BTREE_MAP_H_
 
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
 #include "absl/base/attributes.h"
 #include "absl/container/internal/btree.h"  // IWYU pragma: export
 #include "absl/container/internal/btree_container.h"  // IWYU pragma: export
+#include "absl/container/internal/common.h"
+#include "absl/container/internal/container_memory.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
 namespace container_internal {
 
+template <typename Key, typename Data, typename... Params>
+struct map_params_impl;
+
+template <typename Key, typename Data>
+struct btree_map_defaults {
+  using Compare = std::less<Key>;
+  using Alloc = std::allocator<std::pair<const Key, Data>>;
+  using TargetNodeSize = std::integral_constant<int, 256>;
+  using IsMulti = std::false_type;
+};
+
 template <typename Key, typename Data, typename Compare, typename Alloc,
           int TargetNodeSize, bool IsMulti>
-struct map_params;
+using map_params = typename ApplyWithoutDefaultSuffix<
+    map_params_impl,
+    TypeList<void, void, typename btree_map_defaults<Key, Data>::Compare,
+             typename btree_map_defaults<Key, Data>::Alloc,
+             typename btree_map_defaults<Key, Data>::TargetNodeSize,
+             typename btree_map_defaults<Key, Data>::IsMulti>,
+    TypeList<Key, Data, Compare, Alloc,
+             std::integral_constant<int, TargetNodeSize>,
+             std::integral_constant<bool, IsMulti>>>::type;
 
 }  // namespace container_internal
 
@@ -117,8 +143,8 @@ class ABSL_ATTRIBUTE_OWNER btree_map
   //
   // * Copy assignment operator
   //
-  //  absl::btree_map<int, std::string> map4;
-  //  map4 = map3;
+  //   absl::btree_map<int, std::string> map4;
+  //   map4 = map3;
   //
   // * Move constructor
   //
@@ -555,8 +581,8 @@ class ABSL_ATTRIBUTE_OWNER btree_multimap
   //
   // * Copy assignment operator
   //
-  //  absl::btree_multimap<int, std::string> map4;
-  //  map4 = map3;
+  //   absl::btree_multimap<int, std::string> map4;
+  //   map4 = map3;
   //
   // * Move constructor
   //
@@ -855,11 +881,20 @@ namespace container_internal {
 
 // A parameters structure for holding the type parameters for a btree_map.
 // Compare and Alloc should be nothrow copy-constructible.
-template <typename Key, typename Data, typename Compare, typename Alloc,
-          int TargetNodeSize, bool IsMulti>
-struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
-                                  /*IsMap=*/true, map_slot_policy<Key, Data>> {
-  using super_type = typename map_params::common_params;
+template <typename Key, typename Data, typename... Params>
+struct map_params_impl
+    : common_params<
+          Key,
+          GetFromListOr<typename btree_map_defaults<Key, Data>::Compare, 0,
+                        Params...>,
+          GetFromListOr<typename btree_map_defaults<Key, Data>::Alloc, 1,
+                        Params...>,
+          GetFromListOr<typename btree_map_defaults<Key, Data>::TargetNodeSize,
+                        2, Params...>::value,
+          GetFromListOr<typename btree_map_defaults<Key, Data>::IsMulti, 3,
+                        Params...>::value,
+          /*IsMap=*/true, map_slot_policy<Key, Data>> {
+  using super_type = typename map_params_impl::common_params;
   using mapped_type = Data;
   // This type allows us to move keys when it is safe to do so. It is safe
   // for maps in which value_type and mutable_value_type are layout compatible.
@@ -868,6 +903,21 @@ struct map_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
   using value_type = typename super_type::value_type;
   using init_type = typename super_type::init_type;
 
+  static_assert(
+      std::is_same_v<
+          map_params<
+              Key, Data,
+              GetFromListOr<typename btree_map_defaults<Key, Data>::Compare, 0,
+                            Params...>,
+              GetFromListOr<typename btree_map_defaults<Key, Data>::Alloc, 1,
+                            Params...>,
+              GetFromListOr<
+                  typename btree_map_defaults<Key, Data>::TargetNodeSize, 2,
+                  Params...>::value,
+              GetFromListOr<typename btree_map_defaults<Key, Data>::IsMulti, 3,
+                            Params...>::value>,
+          map_params_impl>);
+
   template <typename V>
   static auto key(const V &value ABSL_ATTRIBUTE_LIFETIME_BOUND)
       -> decltype((value.first)) {

data/third_party/abseil-cpp/absl/container/btree_set.h

@@ -56,9 +56,15 @@
 #ifndef ABSL_CONTAINER_BTREE_SET_H_
 #define ABSL_CONTAINER_BTREE_SET_H_
 
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
 #include "absl/base/attributes.h"
 #include "absl/container/internal/btree.h"  // IWYU pragma: export
 #include "absl/container/internal/btree_container.h"  // IWYU pragma: export
+#include "absl/container/internal/common.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -68,9 +74,27 @@ namespace container_internal {
 template <typename Key>
 struct set_slot_policy;
 
+template <typename Key, typename...Params>
+struct set_params_impl;
+
+template <typename Key>
+struct btree_set_defaults {
+  using Compare = std::less<Key>;
+  using Alloc = std::allocator<Key>;
+  using TargetNodeSize = std::integral_constant<int, 256>;
+  using IsMulti = std::false_type;
+};
+
 template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
           bool IsMulti>
-struct set_params;
+using set_params = typename ApplyWithoutDefaultSuffix<
+    set_params_impl,
+    TypeList<void, typename btree_set_defaults<Key>::Compare,
+             typename btree_set_defaults<Key>::Alloc,
+             typename btree_set_defaults<Key>::TargetNodeSize,
+             typename btree_set_defaults<Key>::IsMulti>,
+    TypeList<Key, Compare, Alloc, std::integral_constant<int, TargetNodeSize>,
+             std::integral_constant<bool, IsMulti>>>::type;
 
 }  // namespace container_internal
 
@@ -119,8 +143,8 @@ class ABSL_ATTRIBUTE_OWNER btree_set
   //
   // * Copy assignment operator
   //
-  //  absl::btree_set<std::string> set4;
-  //  set4 = set3;
+  //   absl::btree_set<std::string> set4;
+  //   set4 = set3;
   //
   // * Move constructor
   //
@@ -475,8 +499,8 @@ class ABSL_ATTRIBUTE_OWNER btree_multiset
   //
   // * Copy assignment operator
   //
-  //  absl::btree_multiset<std::string> set4;
-  //  set4 = set3;
+  //   absl::btree_multiset<std::string> set4;
+  //   set4 = set3;
   //
   // * Move constructor
   //
@@ -781,34 +805,56 @@ struct set_slot_policy {
 
   template <typename Alloc, class... Args>
   static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot,
-                                             std::forward<Args>(args)...);
+    std::allocator_traits<Alloc>::construct(*alloc, slot,
+                                            std::forward<Args>(args)...);
   }
 
   template <typename Alloc>
   static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
+    std::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
   }
 
   template <typename Alloc>
   static void construct(Alloc *alloc, slot_type *slot, const slot_type *other) {
-    absl::allocator_traits<Alloc>::construct(*alloc, slot, *other);
+    std::allocator_traits<Alloc>::construct(*alloc, slot, *other);
   }
 
   template <typename Alloc>
   static void destroy(Alloc *alloc, slot_type *slot) {
-    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
+    std::allocator_traits<Alloc>::destroy(*alloc, slot);
   }
 };
 
 // A parameters structure for holding the type parameters for a btree_set.
 // Compare and Alloc should be nothrow copy-constructible.
-template <typename Key, typename Compare, typename Alloc, int TargetNodeSize,
-          bool IsMulti>
-struct set_params : common_params<Key, Compare, Alloc, TargetNodeSize, IsMulti,
-                                  /*IsMap=*/false, set_slot_policy<Key>> {
+template <typename Key, typename... Params>
+struct set_params_impl
+    : common_params<
+          Key,
+          GetFromListOr<typename btree_set_defaults<Key>::Compare, 0,
+                        Params...>,
+          GetFromListOr<typename btree_set_defaults<Key>::Alloc, 1, Params...>,
+          GetFromListOr<typename btree_set_defaults<Key>::TargetNodeSize, 2,
+                        Params...>::value,
+          GetFromListOr<typename btree_set_defaults<Key>::IsMulti, 3,
+                        Params...>::value,
+          /*IsMap=*/false, set_slot_policy<Key>> {
   using value_type = Key;
-  using slot_type = typename set_params::common_params::slot_type;
+  using slot_type = typename set_params_impl::common_params::slot_type;
+
+  static_assert(
+      std::is_same_v<
+          set_params<
+              Key,
+              GetFromListOr<typename btree_set_defaults<Key>::Compare, 0,
+                            Params...>,
+              GetFromListOr<typename btree_set_defaults<Key>::Alloc, 1,
+                            Params...>,
+              GetFromListOr<typename btree_set_defaults<Key>::TargetNodeSize, 2,
+                            Params...>::value,
+              GetFromListOr<typename btree_set_defaults<Key>::IsMulti, 3,
+                            Params...>::value>,
+          set_params_impl>);
 
   template <typename V>
   static const V &key(const V &value) {

data/third_party/abseil-cpp/absl/container/fixed_array.h

@@ -44,11 +44,12 @@
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
 #include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/internal/iterator_traits.h"
-#include "absl/base/internal/throw_delegate.h"
 #include "absl/base/macros.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"
+#include "absl/base/throw_delegate.h"
 #include "absl/container/internal/compressed_tuple.h"
 #include "absl/hash/internal/weakly_mixed_integer.h"
 #include "absl/memory/memory.h"
@@ -84,11 +85,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;
@@ -98,7 +97,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
            absl::allocator_is_nothrow<allocator_type>::value;
   }
   static constexpr bool DefaultConstructorIsNonTrivial() {
-    return !absl::is_trivially_default_constructible<StorageElement>::value;
+    return !std::is_trivially_default_constructible<StorageElement>::value;
   }
 
  public:
@@ -161,8 +160,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) {
@@ -224,7 +223,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   // Returns a reference the ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   reference operator[](size_type i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(i < size());
+    absl::base_internal::HardeningAssertLT(i, size());
     return data()[i];
   }
 
@@ -232,7 +231,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   // ith element of the fixed array.
   // REQUIRES: 0 <= i < size()
   const_reference operator[](size_type i) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(i < size());
+    absl::base_internal::HardeningAssertLT(i, size());
     return data()[i];
   }
 
@@ -242,7 +241,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   // array, or throws std::out_of_range
   reference at(size_type i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
     if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+      ThrowStdOutOfRange("FixedArray::at failed bounds check");
     }
     return data()[i];
   }
@@ -251,7 +250,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   // of the fixed array.
   const_reference at(size_type i) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
     if (ABSL_PREDICT_FALSE(i >= size())) {
-      base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+      ThrowStdOutOfRange("FixedArray::at failed bounds check");
     }
     return data()[i];
   }
@@ -260,14 +259,14 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   //
   // Returns a reference to the first element of the fixed array.
   reference front() ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(!empty());
+    absl::base_internal::HardeningAssertNonEmpty(*this);
     return data()[0];
   }
 
   // Overload of FixedArray::front() to return a reference to the first element
   // of a fixed array of const values.
   const_reference front() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(!empty());
+    absl::base_internal::HardeningAssertNonEmpty(*this);
     return data()[0];
   }
 
@@ -275,14 +274,14 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   //
   // Returns a reference to the last element of the fixed array.
   reference back() ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(!empty());
+    absl::base_internal::HardeningAssertNonEmpty(*this);
     return data()[size() - 1];
   }
 
   // Overload of FixedArray::back() to return a reference to the last element
   // of a fixed array of const values.
   const_reference back() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    ABSL_HARDENING_ASSERT(!empty());
+    absl::base_internal::HardeningAssertNonEmpty(*this);
     return data()[size() - 1];
   }
 
@@ -392,8 +391,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
 
   template <typename H>
   friend H AbslHashValue(H h, const FixedArray& v) {
-    return H::combine(H::combine_contiguous(std::move(h), v.data(), v.size()),
-                      hash_internal::WeaklyMixedInteger{v.size()});
+    return H::combine_contiguous(std::move(h), v.data(), v.size());
   }
 
  private:
@@ -417,14 +415,14 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   //     error: call to int __builtin___sprintf_chk(etc...)
   //     will always overflow destination buffer [-Werror]
   //
-  template <typename OuterT, typename InnerT = absl::remove_extent_t<OuterT>,
+  template <typename OuterT, typename InnerT = std::remove_extent_t<OuterT>,
             size_t InnerN = std::extent<OuterT>::value>
   struct StorageElementWrapper {
     InnerT array[InnerN];
   };
 
   using StorageElement =
-      absl::conditional_t<std::is_array<value_type>::value,
+      std::conditional_t<std::is_array<value_type>::value,
                           StorageElementWrapper<value_type>, value_type>;
 
   static pointer AsValueType(pointer ptr) { return ptr; }
@@ -461,7 +459,7 @@ class ABSL_ATTRIBUTE_WARN_UNUSED FixedArray {
   };
 
   using InlinedStorage =
-      absl::conditional_t<inline_elements == 0, EmptyInlinedStorage,
+      std::conditional_t<inline_elements == 0, EmptyInlinedStorage,
                           NonEmptyInlinedStorage>;
 
   // Storage