re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/strings/internal/stl_type_traits.h

@@ -48,25 +48,25 @@ struct IsSpecializationImpl : std::false_type {};
 template <template <typename...> class T, typename... Args>
 struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
 template <typename C, template <typename...> class T>
-using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
+using IsSpecialization = IsSpecializationImpl<std::decay_t<C>, T>;
 
 template <typename C>
 struct IsArrayImpl : std::false_type {};
 template <template <typename, size_t> class A, typename T, size_t N>
 struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
 template <typename C>
-using IsArray = IsArrayImpl<absl::decay_t<C>>;
+using IsArray = IsArrayImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsBitsetImpl : std::false_type {};
 template <template <size_t> class B, size_t N>
 struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
 template <typename C>
-using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
+using IsBitset = IsBitsetImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsSTLContainer
-    : absl::disjunction<
+    : std::disjunction<
           IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
           IsSpecialization<C, std::forward_list>,
           IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
@@ -85,14 +85,14 @@ struct IsBaseOfSpecializationImpl : std::false_type {};
 // template.
 template <typename C, template <typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    C, T, std::void_t<typename C::value_type, typename C::allocator_type>>
     : std::is_base_of<C,
                       T<typename C::value_type, typename C::allocator_type>> {};
 template <typename C, template <typename, typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
     C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
+    std::void_t<typename C::key_type, typename C::key_compare,
+                typename C::allocator_type>>
     : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
                            typename C::allocator_type>> {};
 template <typename C, template <typename, typename, typename, typename> class T>
@@ -116,14 +116,14 @@ template <typename C,
           template <typename, typename, typename, typename, typename> class T>
 struct IsBaseOfSpecializationImpl<
     C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
+    std::void_t<typename C::key_type, typename C::mapped_type,
+                typename C::hasher, typename C::key_equal,
+                typename C::allocator_type>>
     : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
                            typename C::hasher, typename C::key_equal,
                            typename C::allocator_type>> {};
 template <typename C, template <typename...> class T>
-using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
+using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<std::decay_t<C>, T>;
 
 template <typename C>
 struct IsBaseOfArrayImpl : std::false_type {};
@@ -131,30 +131,30 @@ template <template <typename, size_t> class A, typename T, size_t N>
 struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
 };
 template <typename C>
-using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
+using IsBaseOfArray = IsBaseOfArrayImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsBaseOfBitsetImpl : std::false_type {};
 template <template <size_t> class B, size_t N>
 struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
 template <typename C>
-using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
+using IsBaseOfBitset = IsBaseOfBitsetImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsBaseOfSTLContainer
-    : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
-                        IsBaseOfSpecialization<C, std::deque>,
-                        IsBaseOfSpecialization<C, std::forward_list>,
-                        IsBaseOfSpecialization<C, std::list>,
-                        IsBaseOfSpecialization<C, std::map>,
-                        IsBaseOfSpecialization<C, std::multimap>,
-                        IsBaseOfSpecialization<C, std::set>,
-                        IsBaseOfSpecialization<C, std::multiset>,
-                        IsBaseOfSpecialization<C, std::unordered_map>,
-                        IsBaseOfSpecialization<C, std::unordered_multimap>,
-                        IsBaseOfSpecialization<C, std::unordered_set>,
-                        IsBaseOfSpecialization<C, std::unordered_multiset>,
-                        IsBaseOfSpecialization<C, std::vector>> {};
+    : std::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
+                       IsBaseOfSpecialization<C, std::deque>,
+                       IsBaseOfSpecialization<C, std::forward_list>,
+                       IsBaseOfSpecialization<C, std::list>,
+                       IsBaseOfSpecialization<C, std::map>,
+                       IsBaseOfSpecialization<C, std::multimap>,
+                       IsBaseOfSpecialization<C, std::set>,
+                       IsBaseOfSpecialization<C, std::multiset>,
+                       IsBaseOfSpecialization<C, std::unordered_map>,
+                       IsBaseOfSpecialization<C, std::unordered_multimap>,
+                       IsBaseOfSpecialization<C, std::unordered_set>,
+                       IsBaseOfSpecialization<C, std::unordered_multiset>,
+                       IsBaseOfSpecialization<C, std::vector>> {};
 
 template <typename C, template <typename...> class T, typename = void>
 struct IsConvertibleToSpecializationImpl : std::false_type {};
@@ -163,14 +163,14 @@ struct IsConvertibleToSpecializationImpl : std::false_type {};
 // STL template.
 template <typename C, template <typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
-    C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+    C, T, std::void_t<typename C::value_type, typename C::allocator_type>>
     : std::is_convertible<
           C, T<typename C::value_type, typename C::allocator_type>> {};
 template <typename C, template <typename, typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
     C, T,
-    absl::void_t<typename C::key_type, typename C::key_compare,
-                 typename C::allocator_type>>
+    std::void_t<typename C::key_type, typename C::key_compare,
+                typename C::allocator_type>>
     : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
                                typename C::allocator_type>> {};
 template <typename C, template <typename, typename, typename, typename> class T>
@@ -193,15 +193,15 @@ template <typename C,
           template <typename, typename, typename, typename, typename> class T>
 struct IsConvertibleToSpecializationImpl<
     C, T,
-    absl::void_t<typename C::key_type, typename C::mapped_type,
-                 typename C::hasher, typename C::key_equal,
-                 typename C::allocator_type>>
+    std::void_t<typename C::key_type, typename C::mapped_type,
+                typename C::hasher, typename C::key_equal,
+                typename C::allocator_type>>
     : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
                                typename C::hasher, typename C::key_equal,
                                typename C::allocator_type>> {};
 template <typename C, template <typename...> class T>
 using IsConvertibleToSpecialization =
-    IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
+    IsConvertibleToSpecializationImpl<std::decay_t<C>, T>;
 
 template <typename C>
 struct IsConvertibleToArrayImpl : std::false_type {};
@@ -209,7 +209,7 @@ template <template <typename, size_t> class A, typename T, size_t N>
 struct IsConvertibleToArrayImpl<A<T, N>>
     : std::is_convertible<A<T, N>, std::array<T, N>> {};
 template <typename C>
-using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
+using IsConvertibleToArray = IsConvertibleToArrayImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsConvertibleToBitsetImpl : std::false_type {};
@@ -217,11 +217,11 @@ template <template <size_t> class B, size_t N>
 struct IsConvertibleToBitsetImpl<B<N>>
     : std::is_convertible<B<N>, std::bitset<N>> {};
 template <typename C>
-using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
+using IsConvertibleToBitset = IsConvertibleToBitsetImpl<std::decay_t<C>>;
 
 template <typename C>
 struct IsConvertibleToSTLContainer
-    : absl::disjunction<
+    : std::disjunction<
           IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
           IsConvertibleToSpecialization<C, std::deque>,
           IsConvertibleToSpecialization<C, std::forward_list>,
@@ -238,9 +238,9 @@ struct IsConvertibleToSTLContainer
 
 template <typename C>
 struct IsStrictlyBaseOfAndConvertibleToSTLContainer
-    : absl::conjunction<absl::negation<IsSTLContainer<C>>,
-                        IsBaseOfSTLContainer<C>,
-                        IsConvertibleToSTLContainer<C>> {};
+    : std::conjunction<std::negation<IsSTLContainer<C>>,
+                       IsBaseOfSTLContainer<C>,
+                       IsConvertibleToSTLContainer<C>> {};
 
 }  // namespace strings_internal
 ABSL_NAMESPACE_END

package/vendor/abseil-cpp/absl/strings/internal/str_format/arg.h

@@ -73,7 +73,7 @@ template <typename T, typename = void>
 struct HasUserDefinedConvert : std::false_type {};
 
 template <typename T>
-struct HasUserDefinedConvert<T, void_t<decltype(AbslFormatConvert(
+struct HasUserDefinedConvert<T, std::void_t<decltype(AbslFormatConvert(
                                     std::declval<const T&>(),
                                     std::declval<const FormatConversionSpec&>(),
                                     std::declval<FormatSink*>()))>>
@@ -133,9 +133,8 @@ auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
                                   std::declval<const FormatConversionSpec&>(),
                                   std::declval<FormatSink*>())) {
   using FormatConversionSpecT =
-      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
-  using FormatSinkT =
-      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
+      std::enable_if_t<sizeof(const T& (*)()) != 0, FormatConversionSpec>;
+  using FormatSinkT = std::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
   auto fcs = conv.Wrap<FormatConversionSpecT>();
   auto fs = sink->Wrap<FormatSinkT>();
   return AbslFormatConvert(v, fcs, &fs);
@@ -150,7 +149,7 @@ auto FormatConvertImpl(const T& v, FormatConversionSpecImpl conv,
                         IntegralConvertResult> {
   if (conv.conversion_char() == FormatConversionCharInternal::v) {
     using FormatSinkT =
-        absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
+        std::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
     auto fs = sink->Wrap<FormatSinkT>();
     AbslStringify(fs, v);
     return {true};
@@ -168,8 +167,7 @@ auto FormatConvertImpl(const T& v, FormatConversionSpecImpl,
                             std::is_void<decltype(AbslStringify(
                                 std::declval<FormatSink&>(), v))>::value,
                         ArgConvertResult<FormatConversionCharSetInternal::v>> {
-  using FormatSinkT =
-      absl::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
+  using FormatSinkT = std::enable_if_t<sizeof(const T& (*)()) != 0, FormatSink>;
   auto fs = sink->Wrap<FormatSinkT>();
   AbslStringify(fs, v);
   return {true};
@@ -214,8 +212,7 @@ ArgConvertResult<FormatConversionCharSetInternal::p> FormatConvertImpl(
 
 // Strings.
 using StringConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s,
-    FormatConversionCharSetInternal::v)>;
+    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::v)>;
 StringConvertResult FormatConvertImpl(const std::string& v,
                                       FormatConversionSpecImpl conv,
                                       FormatSinkImpl* sink);
@@ -237,8 +234,7 @@ inline StringConvertResult FormatConvertImpl(std::string_view v,
 #endif  // !ABSL_USES_STD_STRING_VIEW
 
 using StringPtrConvertResult = ArgConvertResult<FormatConversionCharSetUnion(
-    FormatConversionCharSetInternal::s,
-    FormatConversionCharSetInternal::p)>;
+    FormatConversionCharSetInternal::s, FormatConversionCharSetInternal::p)>;
 StringPtrConvertResult FormatConvertImpl(const char* v,
                                          FormatConversionSpecImpl conv,
                                          FormatSinkImpl* sink);
@@ -303,8 +299,7 @@ FloatingConvertResult FormatConvertImpl(long double v,
 // Chars.
 CharConvertResult FormatConvertImpl(char v, FormatConversionSpecImpl conv,
                                     FormatSinkImpl* sink);
-CharConvertResult FormatConvertImpl(wchar_t v,
-                                    FormatConversionSpecImpl conv,
+CharConvertResult FormatConvertImpl(wchar_t v, FormatConversionSpecImpl conv,
                                     FormatSinkImpl* sink);
 
 // Ints.
@@ -345,7 +340,7 @@ IntegralConvertResult FormatConvertImpl(uint128 v,
 
 // This function needs to be a template due to ambiguity regarding type
 // conversions.
-template <typename T, enable_if_t<std::is_same<T, bool>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_same<T, bool>::value, int> = 0>
 IntegralConvertResult FormatConvertImpl(T v, FormatConversionSpecImpl conv,
                                         FormatSinkImpl* sink) {
   if (conv.conversion_char() == FormatConversionCharInternal::v) {
@@ -381,7 +376,7 @@ struct FormatCountCaptureHelper {
   static ArgConvertResult<FormatConversionCharSetInternal::n> ConvertHelper(
       const FormatCountCapture& v, FormatConversionSpecImpl conv,
       FormatSinkImpl* sink) {
-    const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
+    const std::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
 
     if (conv.conversion_char() !=
         str_format_internal::FormatConversionCharInternal::n) {
@@ -484,8 +479,7 @@ class FormatArgImpl {
             const wchar_t*,
             typename std::conditional<
                 !kHasUserDefined && std::is_convertible<T, VoidPtr>::value,
-                VoidPtr,
-                const T&>::type>::type>::type;
+                VoidPtr, const T&>::type>::type>::type;
   };
   template <typename T>
   struct DecayType<
@@ -598,13 +592,12 @@ class FormatArgImpl {
       return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
                       std::is_enum<T>());
     }
-    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
-                                     spec.conversion_char()))) {
+    if (ABSL_PREDICT_FALSE(
+            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
       return false;
     }
     return str_format_internal::FormatConvertImpl(
-               Manager<T>::Value(arg), spec,
-               static_cast<FormatSinkImpl*>(out))
+               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
         .value;
   }
 
@@ -653,7 +646,6 @@ class FormatArgImpl {
 
 ABSL_INTERNAL_FORMAT_DISPATCH_OVERLOADS_EXPAND_(extern);
 
-
 }  // namespace str_format_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

package/vendor/abseil-cpp/absl/strings/internal/str_format/bind.h

@@ -116,7 +116,7 @@ class FormatSpecTemplate
   }
 
   template <FormatConversionCharSet... C, size_t... I>
-  static bool CheckMatches(absl::index_sequence<I...>) {
+  static bool CheckMatches(std::index_sequence<I...>) {
     bool res[] = {true, CheckMatch<Args, C, I + 1>()...};
     (void)res;
     return true;
@@ -173,7 +173,7 @@ class FormatSpecTemplate
   FormatSpecTemplate(const ExtendedParsedFormat<C...>& pc)  // NOLINT
       : Base(&pc) {
     CheckArity<sizeof...(C), sizeof...(Args)>();
-    CheckMatches<C...>(absl::make_index_sequence<sizeof...(C)>{});
+    CheckMatches<C...>(std::make_index_sequence<sizeof...(C)>{});
   }
 };
 

package/vendor/abseil-cpp/absl/strings/internal/str_format/convert_test.cc

@@ -24,6 +24,7 @@
 #include <cstring>
 #include <cwctype>
 #include <limits>
+#include <optional>
 #include <set>
 #include <sstream>
 #include <string>
@@ -44,7 +45,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 
 namespace absl {
@@ -285,9 +285,6 @@ const NativePrintfTraits &VerifyNativeImplementation() {
 }
 
 bool IsNativeHexFloatConversion(char f) { return f == 'a' || f == 'A'; }
-bool IsNativeFloatConversion(char f) {
-  return f == 'f' || f == 'F' || f == 'e' || f == 'E' || f == 'a' || f == 'A';
-}
 
 class FormatConvertTest : public ::testing::Test { };
 
@@ -593,11 +590,11 @@ TYPED_TEST_P(TypedFormatConvertTest, AllIntsWithFlags) {
 }
 
 template <typename T>
-absl::optional<std::string> StrPrintChar(T c) {
+std::optional<std::string> StrPrintChar(T c) {
   return StrPrint("%c", static_cast<int>(c));
 }
 template <>
-absl::optional<std::string> StrPrintChar(wchar_t c) {
+std::optional<std::string> StrPrintChar(wchar_t c) {
   // musl libc has a bug where ("%lc", 0) writes no characters, and Android
   // doesn't support forcing UTF-8 via setlocale(). Hardcode the expected
   // answers for ASCII inputs to maximize test coverage on these platforms.
@@ -611,7 +608,7 @@ absl::optional<std::string> StrPrintChar(wchar_t c) {
   // call.
   std::string old_locale = setlocale(LC_CTYPE, nullptr);
   if (!setlocale(LC_CTYPE, "en_US.UTF-8")) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   const std::string output = StrPrint("%lc", static_cast<wint_t>(c));
   setlocale(LC_CTYPE, old_locale.c_str());
@@ -666,7 +663,7 @@ TYPED_TEST_P(TypedFormatConvertTest, Char) {
     SCOPED_TRACE(Esc(c));
     const FormatArgImpl args[] = {FormatArgImpl(c)};
     UntypedFormatSpecImpl format("%c");
-    absl::optional<std::string> result = StrPrintChar(c);
+    std::optional<std::string> result = StrPrintChar(c);
     if (result.has_value()) {
       EXPECT_EQ(result.value(), FormatPack(format, absl::MakeSpan(args)));
     }
@@ -804,12 +801,6 @@ void TestWithMultipleFormatsHelper(Floating tested_float) {
                    'e', 'E'}) {
       std::string fmt_str = std::string(fmt) + f;
 
-      if (fmt == absl::string_view("%.5000") && !IsNativeFloatConversion(f)) {
-        // This particular test takes way too long with snprintf.
-        // Disable for the case we are not implementing natively.
-        continue;
-      }
-
       if (IsNativeHexFloatConversion(f) &&
           !native_traits.hex_float_has_glibc_rounding) {
         continue;
@@ -1074,6 +1065,13 @@ TEST_F(FormatConvertTest, DoubleRound) {
 
   // Rounding large negative exponent first digit
   EXPECT_EQ(format("%0.1e", -8.956e-294), "-9.0e-294");
+
+  // FormatGNegativeExpSlow: 2^(-77) has decomposed.exponent < -128.
+  EXPECT_EQ(format("%.10g", std::ldexp(1.0, -77)), "6.6174449e-24");
+
+  // FormatGPositiveExpSlow: 2^130 has total_bits > 128.
+  EXPECT_EQ(format("%.10g", std::ldexp(1.0, 130)),
+            "1.361129468e+39");
 }
 
 TEST_F(FormatConvertTest, DoubleRoundA) {
@@ -1332,12 +1330,6 @@ TEST_F(FormatConvertTest, LongDouble) {
                    'e', 'E'}) {
       std::string fmt_str = std::string(fmt) + 'L' + f;
 
-      if (fmt == absl::string_view("%.5000") && !IsNativeFloatConversion(f)) {
-        // This particular test takes way too long with snprintf.
-        // Disable for the case we are not implementing natively.
-        continue;
-      }
-
       if (IsNativeHexFloatConversion(f)) {
         if (!native_traits.hex_float_has_glibc_rounding ||
             !native_traits.hex_float_optimizes_leading_digit_bit_count) {