re2 1.23.0 → 1.23.2

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

@@ -34,6 +34,57 @@ package(
 
 licenses(["notice"])
 
+cc_library(
+    name = "constexpr_testing",
+    testonly = 1,
+    hdrs = ["internal/constexpr_testing.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        "//absl/base:config",
+    ],
+)
+
+cc_test(
+    name = "constexpr_testing_test",
+    srcs = ["internal/constexpr_testing_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":constexpr_testing",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "requires",
+    hdrs = ["internal/requires.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        "//absl/base:config",
+    ],
+)
+
+cc_test(
+    name = "requires_test",
+    srcs = ["internal/requires_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":requires",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "type_traits",
     hdrs = ["type_traits.h"],

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

@@ -14,6 +14,52 @@
 # limitations under the License.
 #
 
+absl_cc_library(
+  NAME
+    constexpr_testing_internal
+  HDRS
+    "internal/constexpr_testing.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+)
+
+absl_cc_test(
+  NAME
+    constexpr_testing_test
+  SRCS
+    "internal/constexpr_testing_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::constexpr_testing_internal
+    GTest::gmock_main
+)
+
+absl_cc_library(
+  NAME
+    requires_internal
+  HDRS
+    "internal/requires.h"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+)
+
+absl_cc_test(
+  NAME
+    requires_test
+  SRCS
+    "internal/requires_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::requires_internal
+    GTest::gmock_main
+)
+
 absl_cc_library(
   NAME
     type_traits

package/vendor/abseil-cpp/absl/meta/internal/constexpr_testing.h

@@ -0,0 +1,73 @@
+// 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_META_INTERNAL_CONSTEXPR_TESTING_H_
+#define ABSL_META_INTERNAL_CONSTEXPR_TESTING_H_
+
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace meta_internal {
+
+// HasConstexprEvaluation([] { ... }) will evaluate to `true` if the
+// lambda can be evaluated in a constant expression and `false`
+// otherwise.
+// The return type of the lambda is not relevant, as long as the whole
+// evaluation works in a constant expression.
+template <typename F>
+constexpr bool HasConstexprEvaluation(F f);
+
+/// Implementation details below ///
+
+namespace internal_constexpr_evaluation {
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wuninitialized"
+#endif
+// This will give a constexpr instance of `F`.
+// This works for captureless lambdas because they have no state and the copy
+// constructor does not look at the input reference.
+template <typename F>
+constexpr F default_instance = default_instance<F>;
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+template <typename F>
+constexpr std::integral_constant<bool, (default_instance<F>(), true)> Tester(
+    int) {
+  return {};
+}
+
+template <typename S>
+constexpr std::false_type Tester(char) {
+  return {};
+}
+
+}  // namespace internal_constexpr_evaluation
+
+template <typename F>
+constexpr bool HasConstexprEvaluation(F) {
+  return internal_constexpr_evaluation::Tester<F>(0);
+}
+
+}  // namespace meta_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_META_INTERNAL_CONSTEXPR_TESTING_H_

package/vendor/abseil-cpp/absl/meta/internal/constexpr_testing_test.cc

@@ -0,0 +1,40 @@
+// 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.
+
+#include "absl/meta/internal/constexpr_testing.h"
+
+#include <map>
+#include <string_view>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(ConstexprTesting, Basic) {
+  using absl::meta_internal::HasConstexprEvaluation;
+
+  EXPECT_TRUE(HasConstexprEvaluation([] {}));
+  static constexpr int const_global = 7;
+  EXPECT_TRUE(HasConstexprEvaluation([] { return const_global; }));
+  EXPECT_TRUE(HasConstexprEvaluation([] { return 0; }));
+  EXPECT_TRUE(HasConstexprEvaluation([] { return std::string_view{}; }));
+
+  static int nonconst_global;
+  EXPECT_FALSE(HasConstexprEvaluation([] { return nonconst_global; }));
+  EXPECT_FALSE(HasConstexprEvaluation([] { std::abort(); }));
+  EXPECT_FALSE(HasConstexprEvaluation([] { return std::map<int, int>(); }));
+}
+
+}  // namespace

package/vendor/abseil-cpp/absl/meta/internal/requires.h

@@ -0,0 +1,67 @@
+// Copyright 2017 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_META_INTERNAL_REQUIRES_H_
+#define ABSL_META_INTERNAL_REQUIRES_H_
+
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace meta_internal {
+
+// C++17 port of the C++20 `requires` expressions.
+// It allows easy inline test of properties of types in template code.
+// https://en.cppreference.com/w/cpp/language/constraints#Requires_expressions
+//
+// Example usage:
+//
+// if constexpr (Requires<T>([](auto&& x) -> decltype(x.foo()) {})) {
+//   // T has foo()
+//   return t.foo();
+// } else if constexpr (Requires<T>([](auto&& x) -> decltype(Bar(x)) {})) {
+//   // Can call Bar with T
+//   return Bar(t);
+// } else if constexpr (Requires<T, U>(
+//     // Can test expression with multiple inputs
+//     [](auto&& x, auto&& y) -> decltype(x + y) {})) {
+//   return t + t2;
+// }
+//
+// The `Requires` function takes a list of types and a generic lambda where all
+// arguments are of type `auto&&`. The lambda is never actually invoked and the
+// body must be empty.
+// When used this way, `Requires` returns whether the expression inside
+// `decltype` is well-formed, when the lambda parameters have the types that
+// are specified by the corresponding template arguments.
+//
+// NOTE: C++17 does not allow lambdas in template parameters, which means that
+// code like the following is _not_ valid in C++17:
+//
+//  template <typename T,
+//            typename = std::enable_if_t<gtl::Requires<T>(
+//              [] (auto&& v) -> decltype(<expr>) {})>>
+//
+template <typename... T, typename F>
+constexpr bool Requires(F) {
+  return std::is_invocable_v<F, T...>;
+}
+
+}  // namespace meta_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_META_INTERNAL_REQUIRES_H_

package/vendor/abseil-cpp/absl/meta/internal/requires_test.cc

@@ -0,0 +1,66 @@
+// Copyright 2017 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.
+
+#include "absl/meta/internal/requires.h"
+
+#include <string>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(RequiresTest, SimpleLambdasWork) {
+  static_assert(absl::meta_internal::Requires([] {}));
+  static_assert(absl::meta_internal::Requires<int>([](auto&&) {}));
+  static_assert(
+      absl::meta_internal::Requires<int, char>([](auto&&, auto&&) {}));
+}
+
+template <typename T>
+inline constexpr bool has_cstr =
+    absl::meta_internal::Requires<T>([](auto&& x) -> decltype(x.c_str()) {});
+
+template <typename T, typename U>
+inline constexpr bool have_plus = absl::meta_internal::Requires<T, U>(
+    [](auto&& x, auto&& y) -> decltype(x + y) {});
+
+TEST(RequiresTest, CanTestProperties) {
+  static_assert(has_cstr<std::string>);
+  static_assert(!has_cstr<std::vector<int>>);
+
+  static_assert(have_plus<int, double>);
+  static_assert(have_plus<std::string, std::string>);
+  static_assert(!have_plus<std::string, double>);
+}
+
+TEST(RequiresTest, WorksWithUnmovableTypes) {
+  struct S {
+    S(const S&) = delete;
+    int foo() { return 0; }
+  };
+  static_assert(
+      absl::meta_internal::Requires<S>([](auto&& x) -> decltype(x.foo()) {}));
+  static_assert(
+      !absl::meta_internal::Requires<S>([](auto&& x) -> decltype(x.bar()) {}));
+}
+
+TEST(RequiresTest, WorksWithArrays) {
+  static_assert(
+      absl::meta_internal::Requires<int[2]>([](auto&& x) -> decltype(x[1]) {}));
+  static_assert(
+      !absl::meta_internal::Requires<int[2]>([](auto&& x) -> decltype(-x) {}));
+}
+
+}  // namespace

package/vendor/abseil-cpp/absl/meta/type_traits.h

@@ -40,6 +40,7 @@
 #include <string>
 #include <string_view>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include "absl/base/attributes.h"
@@ -168,6 +169,28 @@ template <typename T>
 using remove_cvref_t = typename remove_cvref<T>::type;
 #endif
 
+#if defined(__cpp_lib_type_identity) && __cpp_lib_type_identity >= 201806L
+template <typename T>
+using type_identity = std::type_identity<T>;
+
+template <typename T>
+using type_identity_t = std::type_identity_t<T>;
+#else
+// type_identity
+//
+// Back-fill of C++20's `std::type_identity`.
+template <typename T>
+struct type_identity {
+  typedef T type;
+};
+
+// type_identity_t
+//
+// Back-fill of C++20's `std::type_identity_t`.
+template <typename T>
+using type_identity_t = typename type_identity<T>::type;
+#endif
+
 namespace type_traits_internal {
 
 #if (defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703L) || \
@@ -451,7 +474,7 @@ namespace type_traits_internal {
 
 // Detects if a class's definition has declared itself to be an owner by
 // declaring
-//   using absl_internal_is_view = std::true_type;
+//   using absl_internal_is_view = std::false_type;
 // as a member.
 // Types that don't want either must either omit this declaration entirely, or
 // (if e.g. inheriting from a base class) define the member to something that
@@ -479,6 +502,17 @@ struct IsOwnerImpl<
 template <typename T>
 struct IsOwner : IsOwnerImpl<T> {};
 
+// This allows incomplete types to be used for associative containers, and also
+// expands the set of types we can handle to include std::pair.
+template <typename T1, typename T2>
+struct IsOwner<std::pair<T1, T2>>
+    : std::integral_constant<
+          bool, std::conditional_t<std::is_reference_v<T1>, std::false_type,
+                                   IsOwner<std::remove_cv_t<T1>>>::value &&
+                    std::conditional_t<std::is_reference_v<T2>, std::false_type,
+                                       IsOwner<std::remove_cv_t<T2>>>::value> {
+};
+
 template <typename T, typename Traits, typename Alloc>
 struct IsOwner<std::basic_string<T, Traits, Alloc>> : std::true_type {};
 
@@ -513,6 +547,13 @@ template <typename T>
 struct IsView : std::integral_constant<bool, std::is_pointer<T>::value ||
                                                  IsViewImpl<T>::value> {};
 
+// This allows incomplete types to be used for associative containers, and also
+// expands the set of types we can handle to include std::pair.
+template <typename T1, typename T2>
+struct IsView<std::pair<T1, T2>>
+    : std::integral_constant<bool, IsView<std::remove_cv_t<T1>>::value &&
+                                       IsView<std::remove_cv_t<T2>>::value> {};
+
 template <typename Char, typename Traits>
 struct IsView<std::basic_string_view<Char, Traits>> : std::true_type {};
 

package/vendor/abseil-cpp/absl/meta/type_traits_test.cc

@@ -36,6 +36,9 @@ using IsOwnerAndNotView =
     absl::conjunction<absl::type_traits_internal::IsOwner<T>,
                       absl::negation<absl::type_traits_internal::IsView<T>>>;
 
+static_assert(
+    IsOwnerAndNotView<std::pair<std::vector<int>, std::string>>::value,
+    "pair of owners is an owner, not a view");
 static_assert(IsOwnerAndNotView<std::vector<int>>::value,
               "vector is an owner, not a view");
 static_assert(IsOwnerAndNotView<std::string>::value,
@@ -134,6 +137,17 @@ TEST(TypeTraitsTest, TestRemoveCVRef) {
                             int[2]>::value));
 }
 
+TEST(TypeTraitsTest, TestTypeIdentity) {
+  EXPECT_TRUE((std::is_same_v<typename absl::type_identity<int>::type, int>));
+  EXPECT_TRUE((std::is_same_v<absl::type_identity_t<int>, int>));
+  EXPECT_TRUE((std::is_same_v<typename absl::type_identity<int&>::type, int&>));
+  EXPECT_TRUE((std::is_same_v<absl::type_identity_t<int&>, int&>));
+
+  EXPECT_FALSE(
+      (std::is_same_v<typename absl::type_identity<int64_t>::type, int32_t>));
+  EXPECT_FALSE((std::is_same_v<absl::type_identity_t<int64_t>, int32_t>));
+}
+
 struct TypeA {};
 struct TypeB {};
 struct TypeC {};

package/vendor/abseil-cpp/absl/numeric/int128.h

@@ -164,9 +164,9 @@ class
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
+  constexpr explicit operator float() const;
+  constexpr explicit operator double() const;
+  constexpr explicit operator long double() const;
 
   // Trivial copy constructor, assignment operator and destructor.
 
@@ -357,14 +357,18 @@ class int128 {
   constexpr int128(unsigned long v);       // NOLINT(runtime/int)
   constexpr int128(long long v);           // NOLINT(runtime/int)
   constexpr int128(unsigned long long v);  // NOLINT(runtime/int)
+  constexpr explicit int128(uint128 v);
 #ifdef ABSL_HAVE_INTRINSIC_INT128
   constexpr int128(__int128 v);  // NOLINT(runtime/explicit)
   constexpr explicit int128(unsigned __int128 v);
-#endif  // ABSL_HAVE_INTRINSIC_INT128
-  constexpr explicit int128(uint128 v);
+  constexpr explicit int128(float v);
+  constexpr explicit int128(double v);
+  constexpr explicit int128(long double v);
+#else
   explicit int128(float v);
   explicit int128(double v);
   explicit int128(long double v);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
   // Assignment operators from arithmetic types
   int128& operator=(int v);
@@ -401,9 +405,9 @@ class int128 {
   constexpr explicit operator __int128() const;
   constexpr explicit operator unsigned __int128() const;
 #endif  // ABSL_HAVE_INTRINSIC_INT128
-  explicit operator float() const;
-  explicit operator double() const;
-  explicit operator long double() const;
+  constexpr explicit operator float() const;
+  constexpr explicit operator double() const;
+  constexpr explicit operator long double() const;
 
   // Trivial copy constructor, assignment operator and destructor.
 
@@ -609,9 +613,15 @@ constexpr uint128 operator<<(uint128 lhs, int amount);
 constexpr uint128 operator>>(uint128 lhs, int amount);
 constexpr uint128 operator+(uint128 lhs, uint128 rhs);
 constexpr uint128 operator-(uint128 lhs, uint128 rhs);
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr uint128 operator*(uint128 lhs, uint128 rhs);
+constexpr uint128 operator/(uint128 lhs, uint128 rhs);
+constexpr uint128 operator%(uint128 lhs, uint128 rhs);
+#else   // ABSL_HAVE_INTRINSIC_INT128
 uint128 operator*(uint128 lhs, uint128 rhs);
 uint128 operator/(uint128 lhs, uint128 rhs);
 uint128 operator%(uint128 lhs, uint128 rhs);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 inline uint128& uint128::operator<<=(int amount) {
   *this = *this << amount;
@@ -788,18 +798,18 @@ constexpr uint128::operator unsigned __int128() const {
 
 // Conversion operators to floating point types.
 
-inline uint128::operator float() const {
+constexpr uint128::operator float() const {
   // Note: This method might return Inf.
   constexpr float pow_2_64 = 18446744073709551616.0f;
   return static_cast<float>(lo_) + static_cast<float>(hi_) * pow_2_64;
 }
 
-inline uint128::operator double() const {
+constexpr uint128::operator double() const {
   constexpr double pow_2_64 = 18446744073709551616.0;
   return static_cast<double>(lo_) + static_cast<double>(hi_) * pow_2_64;
 }
 
-inline uint128::operator long double() const {
+constexpr uint128::operator long double() const {
   constexpr long double pow_2_64 = 18446744073709551616.0L;
   return static_cast<long double>(lo_) +
          static_cast<long double>(hi_) * pow_2_64;
@@ -1021,19 +1031,15 @@ constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 #endif
 }
 
+#if !defined(ABSL_HAVE_INTRINSIC_INT128)
 inline uint128 operator*(uint128 lhs, uint128 rhs) {
-#if defined(ABSL_HAVE_INTRINSIC_INT128)
-  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
-  // can be used for uint128 storage.
-  return static_cast<unsigned __int128>(lhs) *
-         static_cast<unsigned __int128>(rhs);
-#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
+#if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
   uint64_t carry;
   uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
   return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
                          Uint128High64(lhs) * Uint128Low64(rhs) + carry,
                      low);
-#else   // ABSL_HAVE_INTRINSIC128
+#else   // _MSC_VER
   uint64_t a32 = Uint128Low64(lhs) >> 32;
   uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
   uint64_t b32 = Uint128Low64(rhs) >> 32;
@@ -1045,16 +1051,24 @@ inline uint128 operator*(uint128 lhs, uint128 rhs) {
   result += uint128(a32 * b00) << 32;
   result += uint128(a00 * b32) << 32;
   return result;
-#endif  // ABSL_HAVE_INTRINSIC128
+#endif  // _MSC_VER
 }
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 
 #if defined(ABSL_HAVE_INTRINSIC_INT128)
-inline uint128 operator/(uint128 lhs, uint128 rhs) {
+constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
+  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+  // can be used for uint128 storage.
+  return static_cast<unsigned __int128>(lhs) *
+         static_cast<unsigned __int128>(rhs);
+}
+
+constexpr uint128 operator/(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) /
          static_cast<unsigned __int128>(rhs);
 }
 
-inline uint128 operator%(uint128 lhs, uint128 rhs) {
+constexpr uint128 operator%(uint128 lhs, uint128 rhs) {
   return static_cast<unsigned __int128>(lhs) %
          static_cast<unsigned __int128>(rhs);
 }
@@ -1112,9 +1126,15 @@ inline int128& int128::operator=(unsigned long long v) {
 constexpr int128 operator-(int128 v);
 constexpr int128 operator+(int128 lhs, int128 rhs);
 constexpr int128 operator-(int128 lhs, int128 rhs);
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+constexpr int128 operator*(int128 lhs, int128 rhs);
+constexpr int128 operator/(int128 lhs, int128 rhs);
+constexpr int128 operator%(int128 lhs, int128 rhs);
+#else
 int128 operator*(int128 lhs, int128 rhs);
 int128 operator/(int128 lhs, int128 rhs);
 int128 operator%(int128 lhs, int128 rhs);
+#endif  // ABSL_HAVE_INTRINSIC_INT128
 constexpr int128 operator|(int128 lhs, int128 rhs);
 constexpr int128 operator&(int128 lhs, int128 rhs);
 constexpr int128 operator^(int128 lhs, int128 rhs);