re2 1.24.1 → 1.25.0

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

@@ -46,7 +46,6 @@
 #include "absl/base/internal/iterator_traits.h"
 #include "absl/base/internal/raw_logging.h"
 #include "absl/strings/internal/ostringstream.h"
-#include "absl/strings/internal/resize_uninitialized.h"
 #include "absl/strings/resize_and_overwrite.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"

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

@@ -172,28 +172,27 @@ class SplitIterator {
 template <typename T, typename = void>
 struct HasMappedType : std::false_type {};
 template <typename T>
-struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
-    : std::true_type {};
+struct HasMappedType<T, std::void_t<typename T::mapped_type>> : std::true_type {
+};
 
 // HasValueType<T>::value is true iff there exists a type T::value_type.
 template <typename T, typename = void>
 struct HasValueType : std::false_type {};
 template <typename T>
-struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
-};
+struct HasValueType<T, std::void_t<typename T::value_type>> : std::true_type {};
 
 // HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
 template <typename T, typename = void>
 struct HasConstIterator : std::false_type {};
 template <typename T>
-struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
+struct HasConstIterator<T, std::void_t<typename T::const_iterator>>
     : std::true_type {};
 
 // HasEmplace<T>::value is true iff there exists a method T::emplace().
 template <typename T, typename = void>
 struct HasEmplace : std::false_type {};
 template <typename T>
-struct HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>
+struct HasEmplace<T, std::void_t<decltype(std::declval<T>().emplace())>>
     : std::true_type {};
 
 // IsInitializerList<T>::value is true iff T is an std::initializer_list. More
@@ -203,7 +202,7 @@ template <typename T>
 std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
 template <typename T>
 struct IsInitializerList
-    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
+    : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))){};
 
 // A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
 // is true for type 'C'.
@@ -224,7 +223,7 @@ struct SplitterIsConvertibleToImpl<C, true, false>
 
 template <typename C>
 struct SplitterIsConvertibleToImpl<C, true, true>
-    : absl::conjunction<
+    : std::conjunction<
           std::is_constructible<typename C::key_type, absl::string_view>,
           std::is_constructible<typename C::mapped_type, absl::string_view>> {};
 
@@ -494,7 +493,7 @@ class Splitter {
     // Inserts the key and an empty value into the map, returning an iterator to
     // the inserted item. We use emplace() if available, otherwise insert().
     template <typename M>
-    static absl::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
+    static std::enable_if_t<HasEmplace<M>::value, iterator> InsertOrEmplace(
         M* m, absl::string_view key) {
       // Use piecewise_construct to support old versions of gcc in which pair
       // constructor can't otherwise construct string from string_view.
@@ -502,7 +501,7 @@ class Splitter {
                                std::tuple<>()));
     }
     template <typename M>
-    static absl::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
+    static std::enable_if_t<!HasEmplace<M>::value, iterator> InsertOrEmplace(
         M* m, absl::string_view key) {
       return ToIter(m->insert(std::make_pair(First(key), Second(""))));
     }

package/vendor/abseil-cpp/absl/strings/internal/string_constant_test.cc

@@ -14,7 +14,8 @@
 
 #include "absl/strings/internal/string_constant.h"
 
-#include "absl/meta/type_traits.h"
+#include <type_traits>
+
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -34,10 +35,10 @@ TEST(StringConstant, Traits) {
 
   EXPECT_TRUE(std::is_empty<T>::value);
   EXPECT_TRUE(std::is_trivial<T>::value);
-  EXPECT_TRUE(absl::is_trivially_default_constructible<T>::value);
-  EXPECT_TRUE(absl::is_trivially_copy_constructible<T>::value);
-  EXPECT_TRUE(absl::is_trivially_move_constructible<T>::value);
-  EXPECT_TRUE(absl::is_trivially_destructible<T>::value);
+  EXPECT_TRUE(std::is_trivially_default_constructible<T>::value);
+  EXPECT_TRUE(std::is_trivially_copy_constructible<T>::value);
+  EXPECT_TRUE(std::is_trivially_move_constructible<T>::value);
+  EXPECT_TRUE(std::is_trivially_destructible<T>::value);
 }
 
 TEST(StringConstant, MakeFromCallable) {

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

@@ -15,11 +15,14 @@
 #ifndef ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
 #define ABSL_STRINGS_INTERNAL_STRINGIFY_SINK_H_
 
+#include <array>
 #include <string>
 #include <type_traits>
 #include <utility>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/source_location.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -51,6 +54,15 @@ string_view ExtractStringification(StringifySink& sink, const T& v) {
 
 }  // namespace strings_internal
 
+template <typename Sink>
+void AbslStringify(Sink& sink, SourceLocation l) {
+  sink.Append(l.file_name());
+  sink.Append(":");
+  std::array<char, numbers_internal::kFastToBufferSize> buffer;
+  numbers_internal::FastIntToBuffer(l.line(), buffer.data());
+  sink.Append(buffer.data());
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

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

@@ -0,0 +1,119 @@
+// Copyright 2026 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.
+//
+// -----------------------------------------------------------------------------
+// File: stringify_stream.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_STRINGS_INTERNAL_STRINGIFY_STREAM_H_
+#define ABSL_STRINGS_INTERNAL_STRINGIFY_STREAM_H_
+
+// StringifyStream is an adaptor for any std::ostream, that provides a
+// stream insertion (<<) operator with the following behavior when inserting
+// some value of type T:
+//
+//   - If there is a suitable overload of operator<< already defined for T, it
+//     will be used.
+//
+//   - If there is no operator<< overload, but there is an AbslStringify defined
+//     for T, it will be used as a fallback.
+//
+//   - Otherwise it is a compilation error.
+//
+// For reference, AbslStringify typically has the form:
+//
+//   struct Foo {
+//     template <typename Sink>
+//     friend void AbslStringify(Sink& sink, const Foo& foo) { ... }
+//   };
+//
+// This permits the following usage, for example:
+//
+//   StringifyStream(std::cout) << Foo();
+//
+
+#include <cstddef>
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace strings_internal {
+
+class StringifyStream {
+ public:
+  // Constructor: adapts (but does not take ownership of) some underlying
+  // std::ostream instance.
+  explicit StringifyStream(std::ostream& os) : sink_{os} {}
+
+  // Stream insertion: delegate to an overload of operator<< if defined for type
+  // T, otherwise fall back to AbslStringify for T.
+  template <typename T>
+  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
+    if constexpr (HasStreamInsertion<T>::value) {
+      stream.sink_.os << t;
+    } else {
+      AbslStringify(stream.sink_, t);
+    }
+    return stream;
+  }
+
+  // Rvalue-ref overload, required when the StringifyStream parameter hasn't
+  // been bound to a variable.
+  template <typename T>
+  friend StringifyStream& operator<<(StringifyStream&& stream, const T& t) {
+    return stream << t;
+  }
+
+  // Overload for things like << std::endl which need an explicit type in order
+  // to resolve to the appropriate overload or template instantiation.
+  StringifyStream& operator<<(std::ostream& (*func)(std::ostream&)) {
+    sink_.os << func;
+    return *this;
+  }
+
+ private:
+  // Abseil "stringify sink" concept (stringify_sink.h)
+  struct Sink {
+    std::ostream& os;
+    void Append(size_t count, char ch) { os << std::string(count, ch); }
+    void Append(absl::string_view v) { os << v; }
+    friend void AbslFormatFlush(Sink* sink, absl::string_view v) {
+      sink->Append(v);
+    }
+  } sink_;
+
+  // SFINAE helper to identify types with a defined operator<< overload.
+  template <typename T, typename = void>
+  struct HasStreamInsertion : std::false_type {};
+
+  template <typename T>
+  struct HasStreamInsertion<T,
+                            std::void_t<decltype(std::declval<std::ostream&>()
+                                                 << std::declval<const T&>())>>
+      : std::true_type {};
+};
+
+}  // namespace strings_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_STRINGS_INTERNAL_STRINGIFY_STREAM_H_

package/vendor/abseil-cpp/absl/strings/internal/stringify_stream_test.cc

@@ -0,0 +1,111 @@
+// Copyright 2026 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/strings/internal/stringify_stream.h"
+
+#include <cstddef>
+#include <iomanip>
+#include <ostream>
+#include <sstream>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace strings_internal {
+namespace {
+
+// Exercises the Append(size_t, char) overload
+struct AppendNCharsTest {
+  size_t count;
+  char ch;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const AppendNCharsTest& t) {
+    sink.Append(t.count, t.ch);
+  }
+};
+TEST(StringifyStreamTest, AppendNChars) {
+  std::ostringstream os;
+  StringifyStream(os) << AppendNCharsTest{5, 'a'};
+  EXPECT_EQ(os.str(), "aaaaa");
+}
+
+// Exercises the Append(absl::string_view) overload
+struct AppendStringViewTest {
+  absl::string_view v;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const AppendStringViewTest& t) {
+    sink.Append(t.v);
+  }
+};
+TEST(StringifyStreamTest, AppendStringView) {
+  std::ostringstream os;
+  StringifyStream(os) << AppendStringViewTest{"abc"};
+  EXPECT_EQ(os.str(), "abc");
+}
+
+// Exercises AbslFormatFlush(OStringStreamSink*, absl::string_view v)
+struct AbslFormatFlushTest {
+  absl::string_view a, b, c;
+
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const AbslFormatFlushTest& t) {
+    absl::Format(&sink, "%s, %s, %s", t.a, t.b, t.c);
+  }
+};
+TEST(StringifyStreamTest, AbslFormatFlush) {
+  std::ostringstream os;
+  StringifyStream(os) << AbslFormatFlushTest{"a", "b", "c"};
+  EXPECT_EQ(os.str(), "a, b, c");
+}
+
+// If overloads of both AbslStringify and operator<< are defined for the type,
+// the operator<< overload should take precedence.
+struct PreferStreamInsertionOverAbslStringifyTest {
+  friend std::ostream& operator<<(  // NOLINT(clang-diagnostic-unused-function)
+      std::ostream& os, const PreferStreamInsertionOverAbslStringifyTest&) {
+    return os << "good";
+  }
+
+  template <typename Sink>
+  friend void AbslStringify  // NOLINT(clang-diagnostic-unused-function)
+      (Sink& sink, const PreferStreamInsertionOverAbslStringifyTest&) {
+    sink.Append("bad");
+  }
+};
+TEST(StringifyStreamTest, PreferStreamInsertionOverAbslStringify) {
+  std::ostringstream os;
+  StringifyStream(os) << PreferStreamInsertionOverAbslStringifyTest{};
+  EXPECT_EQ(os.str(), "good");
+}
+TEST(StringifyStreamTest, SupportEndl) {
+  std::ostringstream os;
+  StringifyStream(os) << std::endl;
+  EXPECT_EQ(os.str(), "\n");
+}
+TEST(StringifyStreamTest, SupportSetbase) {
+  std::ostringstream os;
+  StringifyStream(os) << std::setbase(16) << 255;
+  EXPECT_EQ(os.str(), "ff");
+}
+
+}  // namespace
+}  // namespace strings_internal
+ABSL_NAMESPACE_END
+}  // namespace absl