re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/types/variant_test.cc

@@ -51,22 +51,22 @@ TEST(VariantTest, TestRvalueConversion) {
   std::variant<Convertible1, Convertible2> v(
       ConvertVariantTo<std::variant<Convertible1, Convertible2>>(
           (std::variant<Convertible2, Convertible1>(Convertible1()))));
-  ASSERT_TRUE(absl::holds_alternative<Convertible1>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible1>(v));
 
   v = ConvertVariantTo<std::variant<Convertible1, Convertible2>>(
       std::variant<Convertible2, Convertible1>(Convertible2()));
-  ASSERT_TRUE(absl::holds_alternative<Convertible2>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible2>(v));
 }
 
 TEST(VariantTest, TestLvalueConversion) {
   std::variant<Convertible2, Convertible1> source((Convertible1()));
   std::variant<Convertible1, Convertible2> v(
       ConvertVariantTo<std::variant<Convertible1, Convertible2>>(source));
-  ASSERT_TRUE(absl::holds_alternative<Convertible1>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible1>(v));
 
   source = Convertible2();
   v = ConvertVariantTo<std::variant<Convertible1, Convertible2>>(source);
-  ASSERT_TRUE(absl::holds_alternative<Convertible2>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible2>(v));
 }
 
 TEST(VariantTest, TestMoveConversion) {
@@ -77,14 +77,14 @@ TEST(VariantTest, TestMoveConversion) {
 
   Variant var(
       ConvertVariantTo<Variant>(OtherVariant{std::make_unique<int>(0)}));
-  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const int>>(var));
-  ASSERT_NE(absl::get<std::unique_ptr<const int>>(var), nullptr);
-  EXPECT_EQ(0, *absl::get<std::unique_ptr<const int>>(var));
+  ASSERT_TRUE(std::holds_alternative<std::unique_ptr<const int>>(var));
+  ASSERT_NE(std::get<std::unique_ptr<const int>>(var), nullptr);
+  EXPECT_EQ(0, *std::get<std::unique_ptr<const int>>(var));
 
   var = ConvertVariantTo<Variant>(
       OtherVariant(std::make_unique<std::string>("foo")));
-  ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const std::string>>(var));
-  EXPECT_EQ("foo", *absl::get<std::unique_ptr<const std::string>>(var));
+  ASSERT_TRUE(std::holds_alternative<std::unique_ptr<const std::string>>(var));
+  EXPECT_EQ("foo", *std::get<std::unique_ptr<const std::string>>(var));
 }
 
 TEST(VariantTest, DoesNotMoveFromLvalues) {
@@ -100,47 +100,47 @@ TEST(VariantTest, DoesNotMoveFromLvalues) {
 
   // Test copy constructor
   Variant v2(v1);
-  EXPECT_EQ(absl::get<std::shared_ptr<const int>>(v1),
-            absl::get<std::shared_ptr<const int>>(v2));
+  EXPECT_EQ(std::get<std::shared_ptr<const int>>(v1),
+            std::get<std::shared_ptr<const int>>(v2));
 
   // Test copy-assignment operator
   v1 = std::make_shared<const std::string>("foo");
   v2 = v1;
-  EXPECT_EQ(absl::get<std::shared_ptr<const std::string>>(v1),
-            absl::get<std::shared_ptr<const std::string>>(v2));
+  EXPECT_EQ(std::get<std::shared_ptr<const std::string>>(v1),
+            std::get<std::shared_ptr<const std::string>>(v2));
 
   // Test converting copy constructor
   OtherVariant other(std::make_shared<int>(0));
   Variant v3(ConvertVariantTo<Variant>(other));
-  EXPECT_EQ(absl::get<std::shared_ptr<int>>(other),
-            absl::get<std::shared_ptr<const int>>(v3));
+  EXPECT_EQ(std::get<std::shared_ptr<int>>(other),
+            std::get<std::shared_ptr<const int>>(v3));
 
   other = std::make_shared<std::string>("foo");
   v3 = ConvertVariantTo<Variant>(other);
-  EXPECT_EQ(absl::get<std::shared_ptr<std::string>>(other),
-            absl::get<std::shared_ptr<const std::string>>(v3));
+  EXPECT_EQ(std::get<std::shared_ptr<std::string>>(other),
+            std::get<std::shared_ptr<const std::string>>(v3));
 }
 
 TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) {
   variant<Convertible1, Convertible2> v(
       ConvertVariantTo<std::variant<Convertible1, Convertible2>>(
           (std::variant<Convertible2, Convertible1>(Convertible1()))));
-  ASSERT_TRUE(absl::holds_alternative<Convertible1>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible1>(v));
 
   v = ConvertVariantTo<std::variant<Convertible1, Convertible2>>(
       std::variant<Convertible2, Convertible1>(Convertible2()));
-  ASSERT_TRUE(absl::holds_alternative<Convertible2>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible2>(v));
 }
 
 TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) {
   variant<Convertible2, Convertible1> source((Convertible1()));
   variant<Convertible1, Convertible2> v(
       ConvertVariantTo<std::variant<Convertible1, Convertible2>>(source));
-  ASSERT_TRUE(absl::holds_alternative<Convertible1>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible1>(v));
 
   source = Convertible2();
   v = ConvertVariantTo<std::variant<Convertible1, Convertible2>>(source);
-  ASSERT_TRUE(absl::holds_alternative<Convertible2>(v));
+  ASSERT_TRUE(std::holds_alternative<Convertible2>(v));
 }
 
 TEST(VariantTest, TestMoveConversionViaConvertVariantTo) {
@@ -151,12 +151,12 @@ TEST(VariantTest, TestMoveConversionViaConvertVariantTo) {
 
   Variant var(
       ConvertVariantTo<Variant>(OtherVariant{std::make_unique<int>(3)}));
-  EXPECT_THAT(absl::get_if<std::unique_ptr<const int>>(&var),
+  EXPECT_THAT(std::get_if<std::unique_ptr<const int>>(&var),
               Pointee(Pointee(3)));
 
   var = ConvertVariantTo<Variant>(
       OtherVariant(std::make_unique<std::string>("foo")));
-  EXPECT_THAT(absl::get_if<std::unique_ptr<const std::string>>(&var),
+  EXPECT_THAT(std::get_if<std::unique_ptr<const std::string>>(&var),
               Pointee(Pointee(std::string("foo"))));
 }
 

package/vendor/abseil-cpp/absl/utility/BUILD.bazel

@@ -41,6 +41,7 @@ cc_library(
     linkopts = ABSL_DEFAULT_LINKOPTS,
     deps = [
         "//absl/base:config",
+        "//absl/base:core_headers",
         "//absl/meta:type_traits",
     ],
 )

package/vendor/abseil-cpp/absl/utility/CMakeLists.txt

@@ -23,6 +23,7 @@ absl_cc_library(
     ${ABSL_DEFAULT_COPTS}
   DEPS
     absl::config
+    absl::core_headers
     absl::type_traits
   PUBLIC
 )

package/vendor/abseil-cpp/absl/utility/utility.h

@@ -18,13 +18,18 @@
 #include <cstddef>
 #include <cstdlib>
 #include <tuple>
+#include <type_traits>
 #include <utility>
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 
 // TODO(b/290784225): Include what you use cleanup required.
 #include "absl/meta/type_traits.h"
 
+// TODO(b/509512528): Deprecate the C++14/C++17 symbols publicly, in all files.
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 
@@ -32,22 +37,100 @@ ABSL_NAMESPACE_BEGIN
 // abstractions for platforms that had not yet provided them. Those
 // platforms are no longer supported. New code should simply use the
 // the ones from std directly.
-using std::apply;
-using std::exchange;
-using std::forward;
-using std::in_place;
-using std::in_place_index;
-using std::in_place_index_t;
-using std::in_place_t;
-using std::in_place_type;
-using std::in_place_type_t;
-using std::index_sequence;
-using std::index_sequence_for;
-using std::integer_sequence;
-using std::make_from_tuple;
-using std::make_index_sequence;
-using std::make_integer_sequence;
-using std::move;
+template <class F, class T>
+ABSL_DEPRECATE_AND_INLINE()
+constexpr decltype(auto)
+    apply(F&& f, T&& t) noexcept(noexcept(std::apply(std::declval<F>(),
+                                                     std::declval<T>()))) {
+  return std::apply(std::forward<F>(f), std::forward<T>(t));
+}
+
+template <class T1, class T2 = T1>
+ABSL_DEPRECATE_AND_INLINE()
+constexpr T1 exchange(T1& obj, T2&& new_value) noexcept(
+    noexcept(std::exchange(std::declval<T1&>(), std::declval<T2>()))) {
+  return std::exchange(obj, std::forward<T2>(new_value));
+}
+
+template <class T>
+[[deprecated("Use std::forward instead.")]] [[nodiscard]] constexpr T&& forward(
+    std::remove_reference_t<T>& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  // NOLINTNEXTLINE: Avoid warnings about T not being the spelled type of arg.
+  return std::forward<T>(arg);
+}
+
+template <class T>
+[[deprecated("Use std::forward instead.")]] [[nodiscard]] constexpr T&& forward(
+    std::remove_reference_t<T>&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  // NOLINTNEXTLINE: Avoid warnings about T not being the spelled type of arg.
+  return std::forward<T>(arg);
+}
+
+inline constexpr const std::in_place_t& in_place ABSL_DEPRECATE_AND_INLINE() =
+    std::in_place;
+
+template <size_t I>
+inline constexpr const std::in_place_index_t<I>& in_place_index
+    [[deprecated("Use std::in_place_index<I> instead.")]] =
+        std::in_place_index<I>;
+
+template <size_t I>
+using in_place_index_t [[deprecated("Use std::in_place_index_t<I> instead.")]] =
+    std::in_place_index_t<I>;
+
+using in_place_t ABSL_DEPRECATE_AND_INLINE() = std::in_place_t;
+
+template <class T>
+inline constexpr const std::in_place_type_t<T>& in_place_type
+ABSL_DEPRECATE_AND_INLINE() = std::in_place_type<T>;
+
+template <class T>
+using in_place_type_t ABSL_DEPRECATE_AND_INLINE() = std::in_place_type_t<T>;
+
+template <size_t... I>
+using index_sequence [[deprecated("Use std::index_sequence instead.")]] =
+    std::index_sequence<I...>;
+
+template <class T, T... I>
+using integer_sequence [[deprecated("Use std::integer_sequence instead.")]] =
+    std::integer_sequence<T, I...>;
+
+template <class... T>
+using index_sequence_for
+    [[deprecated("Use std::index_sequence_for instead.")]] =
+        std::index_sequence_for<T...>;
+
+template <class T, class Tuple>
+ABSL_DEPRECATE_AND_INLINE()
+[[nodiscard]] constexpr decltype(std::make_from_tuple<T>(std::declval<Tuple>()))
+    make_from_tuple(Tuple&& arg) noexcept(
+        noexcept(std::make_from_tuple<T>(std::declval<Tuple>()))) {
+  return std::make_from_tuple<T>(std::forward<Tuple>(arg));
+}
+
+template <size_t N>
+using make_index_sequence
+    [[deprecated("Use std::make_index_sequence instead.")]] =
+        std::make_index_sequence<N>;
+
+template <class T, T N>
+using make_integer_sequence
+    [[deprecated("Use std::make_integer_sequence instead.")]] =
+        std::make_integer_sequence<T, N>;
+
+template <class It, class OutIt>
+[[deprecated("Use std::move instead.")]]
+constexpr OutIt move(It&& begin, It&& end, OutIt&& output) {
+  return std::move(std::forward<It>(begin), std::forward<It>(end),
+                   std::forward<OutIt>(output));
+}
+
+template <class T>
+[[deprecated("Use std::move instead.")]]
+[[nodiscard]] constexpr std::remove_reference_t<T>&&
+move(T&& arg ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept {
+  return std::move(arg);  // NOLINT(bugprone-move-forwarding-reference)
+}
 
 #if ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
 // Backfill for std::nontype_t. An instance of this class can be provided as a

package/vendor/abseil-cpp/ci/absl_alternate_options.h

@@ -20,9 +20,11 @@
 #ifndef ABSL_CI_ABSL_ALTERNATE_OPTIONS_H_
 #define ABSL_CI_ABSL_ALTERNATE_OPTIONS_H_
 
+#define ABSL_OPTION_USE_STD_SOURCE_LOCATION 0
 #define ABSL_OPTION_USE_STD_ORDERING 0
 #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
 #define ABSL_OPTION_INLINE_NAMESPACE_NAME ns
 #define ABSL_OPTION_HARDENED 1
+#define ABSL_OPTION_INLINE_HW_ACCEL_STRATEGY 2
 
 #endif  // ABSL_CI_ABSL_ALTERNATE_OPTIONS_H_

package/vendor/abseil-cpp/ci/linux_arm_clang-latest_libcxx_bazel.sh

@@ -39,6 +39,11 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_ARM_CLANG_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /opt/llvm/bin/clang -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -64,6 +69,11 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/llvm/bin/clang" \
+        --env="BAZEL_CXXOPTS=-std=${std}:-nostdinc++" \
+        --env="BAZEL_LINKOPTS=-L/opt/llvm/lib/aarch64-unknown-linux-gnu:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/lib/aarch64-unknown-linux-gnu" \
+        --env="CPLUS_INCLUDE_PATH=/opt/llvm/include/c++/v1:/opt/llvm/include/aarch64-unknown-linux-gnu/c++/v1/" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp-ro,readonly \
         --tmpfs=/abseil-cpp \
         --workdir=/abseil-cpp \
@@ -77,17 +87,13 @@ for std in ${STD}; do
             cp ${ALTERNATE_OPTIONS:-} absl/base/options.h || exit 1
           fi
           /usr/local/bin/bazel test ... \
-            --action_env=CC=clang-19 \
             --compilation_mode=\"${compilation_mode}\" \
             --copt=\"${exceptions_mode}\" \
             --copt=\"-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1\" \
             --copt=-Werror \
-            --cxxopt=-std=${std} \
-            --cxxopt=-stdlib=libc++ \
             --define=\"absl=1\" \
             --features=external_include_paths \
             --keep_going \
-            --linkopt=-stdlib=libc++ \
             --per_file_copt=external/.*@-w \
             --show_timestamps \
             --test_env=\"GTEST_INSTALL_FAILURE_SIGNAL_HANDLER=1\" \

package/vendor/abseil-cpp/ci/linux_clang-latest_libcxx_asan_bazel.sh

@@ -39,6 +39,11 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_CLANG_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /opt/llvm/bin/clang -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -67,6 +72,11 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/llvm/bin/clang" \
+        --env="BAZEL_CXXOPTS=-std=${std}:-nostdinc++" \
+        --env="BAZEL_LINKOPTS=-L/opt/llvm/lib/x86_64-unknown-linux-gnu:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/lib/x86_64-unknown-linux-gnu" \
+        --env="CPLUS_INCLUDE_PATH=/opt/llvm/include/c++/v1:/opt/llvm/include/x86_64-unknown-linux-gnu/c++/v1/" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp,readonly \
         --workdir=/abseil-cpp \
         --cap-add=SYS_PTRACE \
@@ -75,10 +85,6 @@ for std in ${STD}; do
         ${DOCKER_CONTAINER} \
         /bin/bash --login -c "
         /usr/local/bin/bazel test ... \
-          --action_env=\"CC=/opt/llvm/clang/bin/clang\" \
-          --action_env=\"BAZEL_CXXOPTS=-std=${std}:-nostdinc++\" \
-          --action_env=\"BAZEL_LINKOPTS=-L/opt/llvm/libcxx/lib:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/libcxx/lib\" \
-          --action_env=\"CPLUS_INCLUDE_PATH=/opt/llvm/libcxx/include/c++/v1\" \
           --compilation_mode=\"${compilation_mode}\" \
           --copt=\"${exceptions_mode}\" \
           --copt=\"-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG\" \
@@ -88,6 +94,7 @@ for std in ${STD}; do
           --copt=\"-fno-sanitize-recover=${UBSAN_CHECKS}\" \
           --copt=\"-fno-sanitize-blacklist\" \
           --copt=-Werror \
+          --define=\"absl=1\" \
           --enable_bzlmod=true \
           --features=external_include_paths \
           --keep_going \
@@ -95,10 +102,10 @@ for std in ${STD}; do
           --linkopt=\"-fsanitize-link-c++-runtime\" \
           --per_file_copt=external/.*@-w \
           --show_timestamps \
-          --test_env=\"ASAN_SYMBOLIZER_PATH=/opt/llvm/clang/bin/llvm-symbolizer\" \
+          --test_env=\"ASAN_SYMBOLIZER_PATH=/opt/llvm/bin/llvm-symbolizer\" \
           --test_env=\"TZDIR=/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo\" \
           --test_env=\"UBSAN_OPTIONS=print_stacktrace=1\" \
-          --test_env=\"UBSAN_SYMBOLIZER_PATH=/opt/llvm/clang/bin/llvm-symbolizer\" \
+          --test_env=\"UBSAN_SYMBOLIZER_PATH=/opt/llvm/bin/llvm-symbolizer\" \
           --test_output=errors \
           --test_tag_filters=\"-benchmark,-noasan\" \
           ${BAZEL_EXTRA_ARGS:-}"

package/vendor/abseil-cpp/ci/linux_clang-latest_libcxx_bazel.sh

@@ -39,6 +39,11 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_CLANG_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /opt/llvm/bin/clang -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -64,6 +69,11 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/llvm/bin/clang" \
+        --env="BAZEL_CXXOPTS=-std=${std}:-nostdinc++" \
+        --env="BAZEL_LINKOPTS=-L/opt/llvm/lib/x86_64-unknown-linux-gnu:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/lib/x86_64-unknown-linux-gnu" \
+        --env="CPLUS_INCLUDE_PATH=/opt/llvm/include/c++/v1:/opt/llvm/include/x86_64-unknown-linux-gnu/c++/v1/" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp-ro,readonly \
         --tmpfs=/abseil-cpp \
         --workdir=/abseil-cpp \
@@ -77,10 +87,6 @@ for std in ${STD}; do
             cp ${ALTERNATE_OPTIONS:-} absl/base/options.h || exit 1
           fi
           /usr/local/bin/bazel test ... \
-            --action_env=CC=/opt/llvm/clang/bin/clang \
-            --action_env=BAZEL_CXXOPTS=-std=${std}:-nostdinc++ \
-            --action_env=BAZEL_LINKOPTS=-L/opt/llvm/libcxx/lib:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/libcxx/lib \
-            --action_env=CPLUS_INCLUDE_PATH=/opt/llvm/libcxx/include/c++/v1 \
             --compilation_mode=\"${compilation_mode}\" \
             --copt=\"${exceptions_mode}\" \
             --copt=\"-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1\" \

package/vendor/abseil-cpp/ci/linux_clang-latest_libcxx_tsan_bazel.sh

@@ -39,6 +39,11 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_CLANG_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /opt/llvm/bin/clang -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -64,6 +69,11 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/llvm/bin/clang" \
+        --env="BAZEL_CXXOPTS=-std=${std}:-nostdinc++" \
+        --env="BAZEL_LINKOPTS=-L/opt/llvm-tsan/lib:-lc++:-lc++abi:-lgcc_s:-lm:-Wl,-rpath=/opt/llvm-tsan/lib" \
+        --env="CPLUS_INCLUDE_PATH=/opt/llvm-tsan/include/c++/v1" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp,readonly \
         --workdir=/abseil-cpp \
         --cap-add=SYS_PTRACE \
@@ -72,10 +82,6 @@ for std in ${STD}; do
         ${DOCKER_CONTAINER} \
         /bin/bash --login -c "
         /usr/local/bin/bazel test ... \
-          --action_env=\"CC=/opt/llvm/clang/bin/clang\" \
-          --action_env=\"BAZEL_CXXOPTS=-std=${std}:-nostdinc++\" \
-          --action_env=\"BAZEL_LINKOPTS=-L/opt/llvm/libcxx-tsan/lib:-lc++:-lc++abi:-lm:-Wl,-rpath=/opt/llvm/libcxx-tsan/lib\" \
-          --action_env=\"CPLUS_INCLUDE_PATH=/opt/llvm/libcxx-tsan/include/c++/v1\" \
           --build_tag_filters=\"-notsan\" \
           --compilation_mode=\"${compilation_mode}\" \
           --copt=\"${exceptions_mode}\" \
@@ -83,13 +89,14 @@ for std in ${STD}; do
           --copt=\"-fsanitize=thread\" \
           --copt=\"-fno-sanitize-blacklist\" \
           --copt=-Werror \
+          --define=\"absl=1\" \
           --enable_bzlmod=true \
           --features=external_include_paths \
           --keep_going \
           --linkopt=\"-fsanitize=thread\" \
           --per_file_copt=external/.*@-w \
           --show_timestamps \
-          --test_env=\"TSAN_SYMBOLIZER_PATH=/opt/llvm/clang/bin/llvm-symbolizer\" \
+          --test_env=\"TSAN_SYMBOLIZER_PATH=/opt/llvm/bin/llvm-symbolizer\" \
           --test_env=\"TZDIR=/abseil-cpp/absl/time/internal/cctz/testdata/zoneinfo\" \
           --test_output=errors \
           --test_tag_filters=\"-benchmark,-notsan\" \

package/vendor/abseil-cpp/ci/linux_clang-latest_libstdcxx_bazel.sh

@@ -39,6 +39,12 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_CLANG_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /usr/local/bin/gcc -v
+docker run "${DOCKER_CONTAINER}" /opt/llvm/bin/clang -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -64,6 +70,9 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/llvm/bin/clang" \
+        --env="BAZEL_CXXOPTS=-std=${std}" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp,readonly \
         --workdir=/abseil-cpp \
         --cap-add=SYS_PTRACE \
@@ -72,8 +81,6 @@ for std in ${STD}; do
         ${DOCKER_CONTAINER} \
         /bin/bash --login -c "
         /usr/local/bin/bazel test ... \
-          --action_env=\"CC=/opt/llvm/clang/bin/clang\" \
-          --action_env=\"BAZEL_CXXOPTS=-std=${std}\" \
           --compilation_mode=\"${compilation_mode}\" \
           --copt=\"--gcc-toolchain=/usr/local\" \
           --copt=\"-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1\" \

package/vendor/abseil-cpp/ci/linux_docker_containers.sh

@@ -16,7 +16,7 @@
 # Test scripts should source this file to get the identifiers.
 
 readonly LINUX_ALPINE_CONTAINER="gcr.io/google.com/absl-177019/alpine:20230612"
-readonly LINUX_CLANG_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20250527"
-readonly LINUX_ARM_CLANG_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_arm_hybrid-latest:20250430"
-readonly LINUX_GCC_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20250527"
-readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20250430"
+readonly LINUX_CLANG_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest@sha256:baa99e65a3cc837bab8e5246f1870d25c76d0adf2b1d598ee5a3ec77fd2e19bd"
+readonly LINUX_ARM_CLANG_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_arm_hybrid-latest@sha256:04479ae67993e1a70dc1730bcddfe3233ac3af178ede0b33044dd9c31b889ac8"
+readonly LINUX_GCC_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest@sha256:baa99e65a3cc837bab8e5246f1870d25c76d0adf2b1d598ee5a3ec77fd2e19bd"
+readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest@sha256:baa99e65a3cc837bab8e5246f1870d25c76d0adf2b1d598ee5a3ec77fd2e19bd"

package/vendor/abseil-cpp/ci/linux_gcc-floor_libstdcxx_bazel.sh

@@ -37,7 +37,12 @@ if [[ -z ${EXCEPTIONS_MODE:-} ]]; then
 fi
 
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
-readonly DOCKER_CONTAINER=${LINUX_GCC_FLOOR_CONTAINER}
+readonly DOCKER_CONTAINER="${LINUX_GCC_FLOOR_CONTAINER}"
+
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /opt/gcc-10/bin/gcc -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
 
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
@@ -64,6 +69,10 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/opt/gcc-10/bin/gcc" \
+        --env="BAZEL_CXXOPTS=-std=${std}" \
+        --env="BAZEL_LINKOPTS=-L/opt/gcc-10/lib64:-Wl,-rpath=/opt/gcc-10/lib64" \
         --volume="${ABSEIL_ROOT}:/abseil-cpp:ro" \
         --workdir=/abseil-cpp \
         --cap-add=SYS_PTRACE \
@@ -72,8 +81,6 @@ for std in ${STD}; do
         ${DOCKER_CONTAINER} \
         /bin/bash --login -c "
         /usr/local/bin/bazel test ... \
-          --action_env=\"CC=/usr/local/bin/gcc\" \
-          --action_env=\"BAZEL_CXXOPTS=-std=${std}\" \
           --compilation_mode=\"${compilation_mode}\" \
           --copt=\"${exceptions_mode}\" \
           --copt=\"-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1\" \

package/vendor/abseil-cpp/ci/linux_gcc-latest_libstdcxx_bazel.sh

@@ -39,6 +39,11 @@ fi
 source "${ABSEIL_ROOT}/ci/linux_docker_containers.sh"
 readonly DOCKER_CONTAINER=${LINUX_GCC_LATEST_CONTAINER}
 
+# Print information about the environment.
+docker run "${DOCKER_CONTAINER}" /usr/bin/fastfetch -c ci
+docker run "${DOCKER_CONTAINER}" /usr/local/bin/gcc -v
+docker run "${DOCKER_CONTAINER}" cat /root/cached_bazel_versions
+
 # USE_BAZEL_CACHE=1 only works on Kokoro.
 # Without access to the credentials this won't work.
 if [[ ${USE_BAZEL_CACHE:-0} -ne 0 ]]; then
@@ -64,6 +69,9 @@ for std in ${STD}; do
     for exceptions_mode in ${EXCEPTIONS_MODE}; do
       echo "--------------------------------------------------------------------"
       time docker run \
+        --env="USE_BAZEL_VERSION=9.1.0" \
+        --env="CC=/usr/local/bin/gcc" \
+        --env="BAZEL_CXXOPTS=-std=${std}" \
         --mount type=bind,source="${ABSEIL_ROOT}",target=/abseil-cpp-ro,readonly \
         --tmpfs=/abseil-cpp \
         --workdir=/abseil-cpp \
@@ -77,8 +85,6 @@ for std in ${STD}; do
             cp ${ALTERNATE_OPTIONS:-} absl/base/options.h || exit 1
           fi
           /usr/local/bin/bazel test ... \
-            --action_env=CC=/usr/local/bin/gcc \
-            --action_env=BAZEL_CXXOPTS=-std=${std} \
             --compilation_mode=\"${compilation_mode}\" \
             --copt=\"${exceptions_mode}\" \
             --copt=\"-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1\" \

package/vendor/abseil-cpp/ci/macos_xcode_bazel.sh

@@ -19,15 +19,15 @@
 
 set -euox pipefail
 
-# Use Xcode 16.3
-sudo xcode-select -s /Applications/Xcode_16.3.app/Contents/Developer
+# Use Xcode 26.2
+sudo xcode-select -s /Applications/Xcode_26.2.app/Contents/Developer
 
 if [[ -z ${ABSEIL_ROOT:-} ]]; then
   ABSEIL_ROOT="$(realpath $(dirname ${0})/..)"
 fi
 
 # If we are running on Kokoro, check for a versioned Bazel binary.
-KOKORO_GFILE_BAZEL_BIN="bazel-8.2.1-darwin-x86_64"
+KOKORO_GFILE_BAZEL_BIN="bazel-9.1.0-darwin-x86_64"
 if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then
   BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}"
   chmod +x ${BAZEL_BIN}
@@ -57,6 +57,7 @@ fi
 ${BAZEL_BIN} test ... \
   --copt="-DGTEST_REMOVE_LEGACY_TEST_CASEAPI_=1" \
   --copt="-Werror" \
+  --define="absl=1" \
   --cxxopt="-std=c++17" \
   --enable_bzlmod=true \
   --features=external_include_paths \

package/vendor/abseil-cpp/ci/macos_xcode_cmake.sh

@@ -16,8 +16,8 @@
 
 set -euox pipefail
 
-# Use Xcode 16.3
-sudo xcode-select -s /Applications/Xcode_16.3.app/Contents/Developer
+# Use Xcode 26.2
+sudo xcode-select -s /Applications/Xcode_26.2.app/Contents/Developer
 
 brew install cmake
 

package/vendor/abseil-cpp/ci/windows_clangcl_bazel.bat

@@ -47,7 +47,7 @@ IF NOT "%ALTERNATE_OPTIONS%"=="" copy %ALTERNATE_OPTIONS% absl\base\options.h
 :: /google/data/rw/teams/absl/kokoro/windows.
 ::
 :: TODO(absl-team): Remove -Wno-microsoft-cast
-%KOKORO_GFILE_DIR%\bazel-8.2.1-windows-x86_64.exe ^
+%KOKORO_GFILE_DIR%\bazel-9.1.0-windows-x86_64.exe ^
   test ... ^
   --compilation_mode=%COMPILATION_MODE% ^
   --compiler=clang-cl ^

package/vendor/abseil-cpp/ci/windows_msvc_bazel.bat

@@ -42,7 +42,7 @@ IF NOT "%ALTERNATE_OPTIONS%"=="" copy %ALTERNATE_OPTIONS% absl\base\options.h
 :: To upgrade Bazel, first download a new binary from
 :: https://github.com/bazelbuild/bazel/releases and copy it to
 :: /google/data/rw/teams/absl/kokoro/windows.
-"%KOKORO_GFILE_DIR%\bazel-8.2.1-windows-x86_64.exe" ^
+"%KOKORO_GFILE_DIR%\bazel-9.1.0-windows-x86_64.exe" ^
   test ... ^
   --compilation_mode=%COMPILATION_MODE% ^
   --copt=/WX ^