re2 1.24.0 → 1.25.0

package/vendor/abseil-cpp/absl/types/source_location.h

@@ -0,0 +1,172 @@
+// 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.
+//
+// -----------------------------------------------------------------------------
+// File: source_location.h
+// -----------------------------------------------------------------------------
+//
+// absl::SourceLocation provides source-code location info for C++17 and later.
+//
+// Critically, it is a **view type** (like std::string_view). Unlike
+// std::source_location, it is not permanently valid and must not outlive its
+// source. Using an invalid location is an error and may result in warnings
+// or crashes.
+//
+// Additionally, it does not guarantee the retention of all caller information
+// (e.g. column or function name) and may e.g. return unspecified values for
+// performance reasons.
+//
+// To define a function that has access to the source location of the
+// callsite, define it with a parameter of type `absl::SourceLocation`. The
+// caller can then invoke the function, passing
+// `absl::SourceLocation::current()` as the argument.
+//
+// If at all possible, make the `absl::SourceLocation` parameter be the
+// function's last parameter. That way, when `std::source_location` is
+// available, you will be able to switch to it, and give the parameter a default
+// argument of `std::source_location::current()`. Users will then be able to
+// omit that argument, and the default will automatically capture the location
+// of the callsite.
+
+#ifndef ABSL_TYPES_SOURCE_LOCATION_H_
+#define ABSL_TYPES_SOURCE_LOCATION_H_
+
+#include <cstdint>
+#include <type_traits>
+
+#include "absl/base/config.h"
+#include "absl/base/nullability.h"
+
+// This needs to come after absl/base/config.h, which is responsible for
+// defining ABSL_HAVE_STD_SOURCE_LOCATION
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+#include <source_location>  // NOLINT(build/c++20)
+#endif
+
+// For OSS release, whether to alias to std::source_location is configurable via
+// config.h/options.h, similar to std::string_view/variant/etc.
+#if defined(ABSL_USES_STD_SOURCE_LOCATION) && \
+    defined(ABSL_HAVE_STD_SOURCE_LOCATION)
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+using SourceLocation = std::source_location;
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#else  // ABSL_HAVE_STD_SOURCE_LOCATION
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// C++17-compatible class representing a specific location in the source code of
+// a program. Similar to std::source_location, but with a few key differences
+// explained above.
+class SourceLocation {
+  struct PrivateTag {
+   private:
+    explicit PrivateTag() = default;
+    friend class SourceLocation;
+  };
+
+ public:
+  // Avoid this constructor; it populates the object with dummy values.
+  SourceLocation() = default;
+
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+  constexpr SourceLocation(  // NOLINT(google-explicit-constructor)
+      std::source_location loc)
+      : SourceLocation(loc.line(), loc.file_name()) {}
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_BUILTIN_LINE_FILE
+  // SourceLocation::current
+  //
+  // Creates a `SourceLocation` based on the current source location. Currently,
+  // it only captures file and line information for efficiency purposes, but
+  // that is subject to change. APIs that accept a `SourceLocation` as a default
+  // parameter can use this to capture their caller's locations.
+  //
+  // Example:
+  //
+  //   void TracedAdd(int i, SourceLocation loc = SourceLocation::current()) {
+  //     std::cout << loc.file_name() << ":" << loc.line() << " added " << i;
+  //     ...
+  //   }
+  //
+  //   void UserCode() {
+  //     TracedAdd(1);
+  //     TracedAdd(2);
+  //   }
+  static constexpr SourceLocation current(
+      PrivateTag = PrivateTag{}, std::uint_least32_t line = __builtin_LINE(),
+      const char* absl_nonnull file_name = __builtin_FILE()) {
+    return SourceLocation(line, file_name);
+  }
+#else
+  // Creates a dummy `SourceLocation` of "<source_location>" at line number 1,
+  // if no `SourceLocation::current()` implementation is available.
+  static constexpr SourceLocation current() {
+    return SourceLocation(1, "<source_location>");
+  }
+#endif
+  // The line number of the captured source location, or an unspecified value
+  // if this information is not available.
+  constexpr std::uint_least32_t line() const noexcept { return line_; }
+
+  // The column number of the captured source location, or an unspecified value
+  // if this information is not available.
+  constexpr std::uint_least32_t column() const noexcept { return 0; }
+
+  // The file name of the captured source location, or an unspecified string
+  // if this information is not available. Guaranteed to never be NULL.
+  constexpr const char* absl_nonnull file_name() const noexcept {
+    return file_name_;
+  }
+
+  // The function name of the captured source location, or an unspecified string
+  // if this information is not available. Guaranteed to never be NULL.
+  //
+  // NOTE: Currently, we deliberately avoid providing the function name, as it
+  // can bloat binary sizes and is non-critical. This may change in the future.
+  constexpr const char* absl_nonnull function_name() const noexcept {
+    return "";
+  }
+
+ private:
+  // `file_name` must outlive all copies of the `absl::SourceLocation` object,
+  // so in practice it should be a string literal.
+  constexpr SourceLocation(std::uint_least32_t line,
+                           const char* absl_nonnull file_name)
+      : line_(line), file_name_(file_name) {}
+
+  // We would use [[maybe_unused]] here, but it doesn't work on all supported
+  // toolchains at the moment.
+  friend constexpr int UseUnused() {
+    static_assert(SourceLocation(0, nullptr).unused_column_ == 0,
+                  "Use the otherwise-unused member.");
+    return 0;
+  }
+
+  // "unused" members are present to minimize future changes in the size of this
+  // type.
+  std::uint_least32_t line_ = 0;
+  std::uint_least32_t unused_column_ = 0;
+  const char* absl_nonnull file_name_ = "";
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+#endif  // ABSL_HAVE_STD_SOURCE_LOCATION
+
+#endif  // ABSL_TYPES_SOURCE_LOCATION_H_

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

@@ -0,0 +1,139 @@
+// 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/types/source_location.h"
+
+#include "absl/base/config.h"
+
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+#include <source_location>  // NOLINT(build/c++20)
+#endif
+#include <type_traits>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/strings/string_view.h"
+
+namespace {
+
+using ::absl::SourceLocation;
+using ::testing::EndsWith;
+
+TEST(SourceLocationTest, DefaultConstructionWorks) {
+  static_assert(!std::is_trivially_default_constructible_v<SourceLocation>);
+  static_assert(std::is_nothrow_default_constructible_v<SourceLocation>);
+  constexpr SourceLocation loc1 [[maybe_unused]];
+  SourceLocation loc2 [[maybe_unused]]{};
+  EXPECT_EQ(loc1.line(), loc2.line());
+}
+
+#ifdef ABSL_INTERNAL_HAVE_BUILTIN_LINE_FILE
+
+TEST(SourceLocationTest, ConstexprMembers) {
+  constexpr SourceLocation loc1 = absl::SourceLocation::current();
+  const SourceLocation loc2 = absl::SourceLocation::current();
+  EXPECT_EQ(loc1.line(), loc2.line() - 1);
+  EXPECT_EQ(absl::string_view(loc1.file_name()), loc2.file_name());
+}
+
+TEST(SourceLocationTest, ConversionFromStdSourceLocationWorks) {
+#ifndef ABSL_HAVE_STD_SOURCE_LOCATION
+  GTEST_SKIP() << "std::source_location is not available";
+#else
+  constexpr SourceLocation loc1 = std::source_location::current();
+  const std::source_location loc2 = std::source_location::current();
+  EXPECT_EQ(loc1.line(), loc2.line() - 1);
+  EXPECT_EQ(absl::string_view(loc1.file_name()), loc2.file_name());
+#endif
+}
+
+TEST(SourceLocationTest, CopyConstructionWorks) {
+  constexpr SourceLocation location = absl::SourceLocation::current();
+  constexpr int line = __LINE__ - 1;
+
+  EXPECT_EQ(location.line(), line);
+  EXPECT_THAT(location.file_name(), EndsWith("source_location_test.cc"));
+}
+
+TEST(SourceLocationTest, CopyAssignmentWorks) {
+  SourceLocation location;
+  location = absl::SourceLocation::current();
+  constexpr int line = __LINE__ - 1;
+
+  EXPECT_EQ(location.line(), line);
+  EXPECT_THAT(location.file_name(), EndsWith("source_location_test.cc"));
+}
+
+SourceLocation Echo(const SourceLocation& location) { return location; }
+
+TEST(SourceLocationTest, ExpectedUsageWorks) {
+  SourceLocation location = Echo(absl::SourceLocation::current());
+  constexpr int line = __LINE__ - 1;
+
+  EXPECT_EQ(location.line(), line);
+  EXPECT_THAT(location.file_name(), EndsWith("source_location_test.cc"));
+}
+
+TEST(SourceLocationTest, CurrentWorks) {
+  constexpr SourceLocation location = SourceLocation::current();
+  constexpr int line = __LINE__ - 1;
+
+  EXPECT_EQ(location.line(), line);
+  EXPECT_THAT(location.file_name(), EndsWith("source_location_test.cc"));
+}
+
+SourceLocation FuncWithDefaultParam(
+    SourceLocation loc = SourceLocation::current()) {
+  return loc;
+}
+
+TEST(SourceLocationTest, CurrentWorksAsDefaultParam) {
+  SourceLocation location = FuncWithDefaultParam();
+  constexpr int line = __LINE__ - 1;
+
+  EXPECT_EQ(location.line(), line);
+  EXPECT_THAT(location.file_name(), EndsWith("source_location_test.cc"));
+}
+
+#endif
+
+template <typename T>
+bool TryPassLineAndFile(decltype(T::current(0, ""))*) {
+  return true;
+}
+template <typename T>
+bool TryPassLineAndFile(decltype(T::current({}, 0, ""))*) {
+  return true;
+}
+template <typename T>
+bool TryPassLineAndFile(decltype(T::current(typename T::Tag{}, 0, ""))*) {
+  return true;
+}
+template <typename T>
+bool TryPassLineAndFile(...) {
+  return false;
+}
+
+TEST(SourceLocationTest, CantPassLineAndFile) {
+#ifdef ABSL_HAVE_STD_SOURCE_LOCATION
+  using StdSourceLocation = std::source_location;
+#else
+  using StdSourceLocation = void;
+#endif
+  if constexpr (!std::is_same_v<absl::SourceLocation, StdSourceLocation>) {
+    EXPECT_FALSE(TryPassLineAndFile<absl::SourceLocation>(nullptr));
+  }
+}
+
+}  // namespace

package/vendor/abseil-cpp/absl/types/span.h

@@ -30,18 +30,17 @@
 // `Span<const T>` when such types may be difficult to identify due to issues
 // with implicit conversion.
 //
-// The C++20 draft standard includes a `std::span` type. As of June 2020, the
+// The C++20 standard includes a `std::span` type. As of January 2026, the
 // differences between `absl::Span` and `std::span` are:
 //    * `absl::Span` has `operator==` (which is likely a design bug,
 //       per https://abseil.io/blog/20180531-regular-types)
 //    * `absl::Span` has the factory functions `MakeSpan()` and
 //      `MakeConstSpan()`
 //    * bounds-checked access to `absl::Span` is accomplished with `at()`
+//      however `std::span` now supports the same as of the draft C++26 standard
 //    * `absl::Span` has compiler-provided move and copy constructors and
 //      assignment. This is due to them being specified as `constexpr`, but that
 //      implies const in C++11.
-//    * A read-only `absl::Span<const T>` can be implicitly constructed from an
-//      initializer list.
 //    * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
 //      `as_writable_bytes()` methods
 //    * `absl::Span` has no static extent template parameter, nor constructors
@@ -65,11 +64,12 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
-#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/internal/hardening.h"
 #include "absl/base/macros.h"
 #include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 #include "absl/base/port.h"  // TODO(strel): remove this include
+#include "absl/base/throw_delegate.h"
 #include "absl/hash/internal/weakly_mixed_integer.h"
 #include "absl/meta/type_traits.h"
 #include "absl/types/internal/span.h"
@@ -205,7 +205,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
 
  public:
   using element_type = T;
-  using value_type = absl::remove_cv_t<T>;
+  using value_type = std::remove_cv_t<T>;
   // TODO(b/316099902) - pointer should be absl_nullable, but this makes it hard
   // to recognize foreach loops as safe. absl_nullability_unknown is currently
   // used to suppress -Wnullability-completeness warnings.
@@ -336,7 +336,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Returns a reference to the i'th element of this span.
   constexpr reference operator[](size_type i) const noexcept {
-    ABSL_HARDENING_ASSERT(i < size());
+    absl::base_internal::HardeningAssertLT(i, size());
     return ptr_[i];
   }
 
@@ -346,8 +346,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   constexpr reference at(size_type i) const {
     return ABSL_PREDICT_TRUE(i < size())  //
                ? *(data() + i)
-               : (base_internal::ThrowStdOutOfRange(
-                      "Span::at failed bounds check"),
+               : (ThrowStdOutOfRange("Span::at failed bounds check"),
                   *(data() + i));
   }
 
@@ -356,7 +355,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // Returns a reference to the first element of this span. The span must not
   // be empty.
   constexpr reference front() const noexcept {
-    ABSL_HARDENING_ASSERT(size() > 0);
+    absl::base_internal::HardeningAssertGT(size(), static_cast<size_t>(0));
     return *data();
   }
 
@@ -365,7 +364,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   // Returns a reference to the last element of this span. The span must not
   // be empty.
   constexpr reference back() const noexcept {
-    ABSL_HARDENING_ASSERT(size() > 0);
+    absl::base_internal::HardeningAssertGT(size(), static_cast<size_t>(0));
     return *(data() + size() - 1);
   }
 
@@ -431,7 +430,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Removes the first `n` elements from the span.
   void remove_prefix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    absl::base_internal::HardeningAssertGE(size(), n);
     ptr_ += n;
     len_ -= n;
   }
@@ -440,7 +439,7 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //
   // Removes the last `n` elements from the span.
   void remove_suffix(size_type n) noexcept {
-    ABSL_HARDENING_ASSERT(size() >= n);
+    absl::base_internal::HardeningAssertGE(size(), n);
     len_ -= n;
   }
 
@@ -466,9 +465,8 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).subspan(4);     // {}
   //   absl::MakeSpan(vec).subspan(5);     // throws std::out_of_range
   constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
-    return (pos <= size())
-               ? Span(data() + pos, (std::min)(size() - pos, len))
-               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+    return (pos <= size()) ? Span(data() + pos, (std::min)(size() - pos, len))
+                           : (ThrowStdOutOfRange("pos > size()"), Span());
   }
 
   // Span::first()
@@ -483,9 +481,8 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).first(3);  // {10, 11, 12}
   //   absl::MakeSpan(vec).first(5);  // throws std::out_of_range
   constexpr Span first(size_type len) const {
-    return (len <= size())
-               ? Span(data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    return (len <= size()) ? Span(data(), len)
+                           : (ThrowStdOutOfRange("len > size()"), Span());
   }
 
   // Span::last()
@@ -500,9 +497,8 @@ class ABSL_ATTRIBUTE_VIEW Span {
   //   absl::MakeSpan(vec).last(3);  // {11, 12, 13}
   //   absl::MakeSpan(vec).last(5);  // throws std::out_of_range
   constexpr Span last(size_type len) const {
-    return (len <= size())
-               ? Span(size() - len + data(), len)
-               : (base_internal::ThrowStdOutOfRange("len > size()"), Span());
+    return (len <= size()) ? Span(size() - len + data(), len)
+                           : (ThrowStdOutOfRange("len > size()"), Span());
   }
 
   // Support for absl::Hash.
@@ -742,7 +738,7 @@ constexpr Span<T> MakeSpan(T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND,
 template <int&... ExplicitArgumentBarrier, typename T>
 Span<T> MakeSpan(T* absl_nullable begin ABSL_ATTRIBUTE_LIFETIME_BOUND,
                  T* absl_nullable end) noexcept {
-  ABSL_HARDENING_ASSERT(begin <= end);
+  absl::base_internal::HardeningAssertLE(begin, end);
   return Span<T>(begin, static_cast<size_t>(end - begin));
 }
 
@@ -803,7 +799,7 @@ template <int&... ExplicitArgumentBarrier, typename T>
 Span<const T> MakeConstSpan(T* absl_nullable begin
                                 ABSL_ATTRIBUTE_LIFETIME_BOUND,
                             T* absl_nullable end) noexcept {
-  ABSL_HARDENING_ASSERT(begin <= end);
+  absl::base_internal::HardeningAssertLE(begin, end);
   return Span<const T>(begin, end - begin);
 }
 

package/vendor/abseil-cpp/absl/types/variant.h

@@ -23,25 +23,82 @@
 #ifndef ABSL_TYPES_VARIANT_H_
 #define ABSL_TYPES_VARIANT_H_
 
+#include <stddef.h>
+
 #include <variant>
 
 #include "absl/base/config.h"
+#include "absl/base/macros.h"
 #include "absl/utility/utility.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
-using std::bad_variant_access;
-using std::get;
-using std::get_if;
-using std::holds_alternative;
-using std::monostate;
-using std::variant;
-using std::variant_alternative;
-using std::variant_alternative_t;
-using std::variant_npos;
-using std::variant_size;
-using std::variant_size_v;
-using std::visit;
+
+using bad_variant_access ABSL_REFACTOR_INLINE
+    = std::bad_variant_access;
+
+template <size_t I, typename... Args>
+[[deprecated]] constexpr auto get(Args&&... args)
+    -> decltype(std::get<I>(std::forward<Args>(args)...)) {
+  return std::get<I>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::get<T>(std::declval<Args>()...)) get(
+    Args&&... args) {
+  return std::get<T>(std::forward<Args>(args)...);
+}
+
+template <size_t I, typename... Args>
+[[deprecated]] constexpr decltype(std::get_if<I>(std::declval<Args>()...))
+get_if(Args&&... args) {
+  return std::get_if<I>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::get_if<T>(std::declval<Args>()...))
+get_if(Args&&... args) {
+  return std::get_if<T>(std::forward<Args>(args)...);
+}
+
+template <typename T, typename... Args>
+[[deprecated]] constexpr decltype(std::holds_alternative<T>(
+    std::declval<Args>()...))
+holds_alternative(Args&&... args) {
+  return std::holds_alternative<T>(std::forward<Args>(args)...);
+}
+
+using monostate ABSL_REFACTOR_INLINE
+    = std::monostate;
+
+template <typename... Types>
+using variant ABSL_REFACTOR_INLINE
+    = std::variant<Types...>;
+
+template <size_t I, typename T>
+using variant_alternative ABSL_REFACTOR_INLINE
+    = std::variant_alternative<I, T>;
+
+template <size_t I, typename T>
+using variant_alternative_t ABSL_REFACTOR_INLINE
+    = std::variant_alternative_t<I, T>;
+
+inline constexpr size_t variant_npos ABSL_REFACTOR_INLINE
+    = std::variant_npos;
+
+template <typename T>
+using variant_size ABSL_REFACTOR_INLINE
+    = std::variant_size<T>;
+
+template <typename T>
+inline constexpr size_t variant_size_v ABSL_REFACTOR_INLINE
+    = std::variant_size_v<T>;
+
+template <typename... Args>
+[[deprecated]] constexpr decltype(std::visit(std::declval<Args>()...)) visit(
+    Args&&... args) {
+  return std::visit(std::forward<Args>(args)...);
+}
 
 namespace variant_internal {
 // Helper visitor for converting a variant<Ts...>` into another type (mostly
@@ -57,23 +114,23 @@ struct ConversionVisitor {
 
 // ConvertVariantTo()
 //
-// Helper functions to convert an `absl::variant` to a variant of another set of
+// Helper functions to convert an `std::variant` to a variant of another set of
 // types, provided that the alternative type of the new variant type can be
 // converted from any type in the source variant.
 //
 // Example:
 //
-//   absl::variant<name1, name2, float> InternalReq(const Req&);
+//   std::variant<name1, name2, float> InternalReq(const Req&);
 //
 //   // name1 and name2 are convertible to name
-//   absl::variant<name, float> ExternalReq(const Req& req) {
-//     return absl::ConvertVariantTo<absl::variant<name, float>>(
+//   std::variant<name, float> ExternalReq(const Req& req) {
+//     return absl::ConvertVariantTo<std::variant<name, float>>(
 //              InternalReq(req));
 //   }
 template <typename To, typename Variant>
 To ConvertVariantTo(Variant&& variant) {
-  return absl::visit(variant_internal::ConversionVisitor<To>{},
-                     std::forward<Variant>(variant));
+  return std::visit(variant_internal::ConversionVisitor<To>{},
+                    std::forward<Variant>(variant));
 }
 
 ABSL_NAMESPACE_END