re2 1.24.1 → 1.25.0

package/vendor/abseil-cpp/absl/status/internal/statusor_internal.h

@@ -60,7 +60,7 @@ struct IsEqualityComparable<
 // Detects whether `T` is constructible or convertible from `StatusOr<U>`.
 template <typename T, typename U>
 using IsConstructibleOrConvertibleFromStatusOr =
-    absl::disjunction<std::is_constructible<T, StatusOr<U>&>,
+    std::disjunction<std::is_constructible<T, StatusOr<U>&>,
                       std::is_constructible<T, const StatusOr<U>&>,
                       std::is_constructible<T, StatusOr<U>&&>,
                       std::is_constructible<T, const StatusOr<U>&&>,
@@ -73,7 +73,7 @@ using IsConstructibleOrConvertibleFromStatusOr =
 // `StatusOr<U>`.
 template <typename T, typename U>
 using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
-    absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
+    std::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>,
                       std::is_assignable<T&, StatusOr<U>&>,
                       std::is_assignable<T&, const StatusOr<U>&>,
                       std::is_assignable<T&, StatusOr<U>&&>,
@@ -83,7 +83,7 @@ using IsConstructibleOrConvertibleOrAssignableFromStatusOr =
 // when `U` is `StatusOr<V>` and `T` is constructible or convertible from `V`.
 template <typename T, typename U>
 struct IsDirectInitializationAmbiguous
-    : public absl::conditional_t<
+    : public std::conditional_t<
           std::is_same<absl::remove_cvref_t<U>, U>::value, std::false_type,
           IsDirectInitializationAmbiguous<T, absl::remove_cvref_t<U>>> {};
 
@@ -95,7 +95,7 @@ struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>>
 // temporaries.
 // REQUIRES: T and U are references.
 template <typename T, typename U>
-using IsReferenceConversionValid = absl::conjunction<  //
+using IsReferenceConversionValid = std::conjunction<  //
     std::is_reference<T>, std::is_reference<U>,
     // The references are convertible. This checks for
     // lvalue/rvalue compatibility.
@@ -108,16 +108,16 @@ using IsReferenceConversionValid = absl::conjunction<  //
 // Checks against the constraints of the direction initialization, i.e. when
 // `StatusOr<T>::StatusOr(U&&)` should participate in overload resolution.
 template <typename T, typename U>
-using IsDirectInitializationValid = absl::disjunction<
+using IsDirectInitializationValid = std::disjunction<
     // Short circuits if T is basically U.
     std::is_same<T, absl::remove_cvref_t<U>>,  //
     std::conditional_t<
         std::is_reference_v<T>,  //
         IsReferenceConversionValid<T, U>,
-        absl::negation<absl::disjunction<
+        std::negation<std::disjunction<
             std::is_same<absl::StatusOr<T>, absl::remove_cvref_t<U>>,
             std::is_same<absl::Status, absl::remove_cvref_t<U>>,
-            std::is_same<absl::in_place_t, absl::remove_cvref_t<U>>,
+            std::is_same<std::in_place_t, absl::remove_cvref_t<U>>,
             IsDirectInitializationAmbiguous<T, U>>>>>;
 
 // This trait detects whether `StatusOr<T>::operator=(U&&)` is ambiguous, which
@@ -132,7 +132,7 @@ using IsDirectInitializationValid = absl::disjunction<
 //   s1 = s2;  // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`?
 template <typename T, typename U>
 struct IsForwardingAssignmentAmbiguous
-    : public absl::conditional_t<
+    : public std::conditional_t<
           std::is_same<absl::remove_cvref_t<U>, U>::value, std::false_type,
           IsForwardingAssignmentAmbiguous<T, absl::remove_cvref_t<U>>> {};
 
@@ -143,91 +143,91 @@ struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>>
 // Checks against the constraints of the forwarding assignment, i.e. whether
 // `StatusOr<T>::operator(U&&)` should participate in overload resolution.
 template <typename T, typename U>
-using IsForwardingAssignmentValid = absl::disjunction<
+using IsForwardingAssignmentValid = std::disjunction<
     // Short circuits if T is basically U.
     std::is_same<T, absl::remove_cvref_t<U>>,
-    absl::negation<absl::disjunction<
+    std::negation<std::disjunction<
         std::is_same<absl::StatusOr<T>, absl::remove_cvref_t<U>>,
         std::is_same<absl::Status, absl::remove_cvref_t<U>>,
-        std::is_same<absl::in_place_t, absl::remove_cvref_t<U>>,
+        std::is_same<std::in_place_t, absl::remove_cvref_t<U>>,
         IsForwardingAssignmentAmbiguous<T, U>>>>;
 
 template <bool Value, typename T>
-using Equality = std::conditional_t<Value, T, absl::negation<T>>;
+using Equality = std::conditional_t<Value, T, std::negation<T>>;
 
 template <bool Explicit, typename T, typename U, bool Lifetimebound>
-using IsConstructionValid = absl::conjunction<
+using IsConstructionValid = std::conjunction<
     Equality<Lifetimebound,
-             absl::disjunction<
+             std::disjunction<
                  std::is_reference<T>,
                  type_traits_internal::IsLifetimeBoundAssignment<T, U>>>,
     IsDirectInitializationValid<T, U&&>, std::is_constructible<T, U&&>,
     Equality<!Explicit, std::is_convertible<U&&, T>>,
-    absl::disjunction<
+    std::disjunction<
         std::is_same<T, absl::remove_cvref_t<U>>,
-        absl::conjunction<
+        std::conjunction<
             std::conditional_t<
                 Explicit,
-                absl::negation<std::is_constructible<absl::Status, U&&>>,
-                absl::negation<std::is_convertible<U&&, absl::Status>>>,
-            absl::negation<
+                std::negation<std::is_constructible<absl::Status, U&&>>,
+                std::negation<std::is_convertible<U&&, absl::Status>>>,
+            std::negation<
                 internal_statusor::HasConversionOperatorToStatusOr<T, U&&>>>>>;
 
 template <typename T, typename U, bool Lifetimebound>
-using IsAssignmentValid = absl::conjunction<
+using IsAssignmentValid = std::conjunction<
     Equality<Lifetimebound,
-             absl::disjunction<
+             std::disjunction<
                  std::is_reference<T>,
                  type_traits_internal::IsLifetimeBoundAssignment<T, U>>>,
     std::conditional_t<std::is_reference_v<T>,
                        IsReferenceConversionValid<T, U&&>,
-                       absl::conjunction<std::is_constructible<T, U&&>,
+                       std::conjunction<std::is_constructible<T, U&&>,
                                          std::is_assignable<T&, U&&>>>,
-    absl::disjunction<
+    std::disjunction<
         std::is_same<T, absl::remove_cvref_t<U>>,
-        absl::conjunction<
-            absl::negation<std::is_convertible<U&&, absl::Status>>,
-            absl::negation<HasConversionOperatorToStatusOr<T, U&&>>>>,
+        std::conjunction<
+            std::negation<std::is_convertible<U&&, absl::Status>>,
+            std::negation<HasConversionOperatorToStatusOr<T, U&&>>>>,
     IsForwardingAssignmentValid<T, U&&>>;
 
 template <bool Explicit, typename T, typename U>
-using IsConstructionFromStatusValid = absl::conjunction<
-    absl::negation<std::is_same<absl::StatusOr<T>, absl::remove_cvref_t<U>>>,
-    absl::negation<std::is_same<T, absl::remove_cvref_t<U>>>,
-    absl::negation<std::is_same<absl::in_place_t, absl::remove_cvref_t<U>>>,
+using IsConstructionFromStatusValid = std::conjunction<
+    std::negation<std::is_same<absl::StatusOr<T>, absl::remove_cvref_t<U>>>,
+    std::negation<std::is_same<T, absl::remove_cvref_t<U>>>,
+    std::negation<std::is_same<std::in_place_t, absl::remove_cvref_t<U>>>,
     Equality<!Explicit, std::is_convertible<U, absl::Status>>,
     std::is_constructible<absl::Status, U>,
-    absl::negation<HasConversionOperatorToStatusOr<T, U>>>;
+    std::negation<HasConversionOperatorToStatusOr<T, U>>>;
 
 template <bool Explicit, typename T, typename U, bool Lifetimebound,
           typename UQ>
-using IsConstructionFromStatusOrValid = absl::conjunction<
-    absl::negation<std::is_same<T, U>>,
+using IsConstructionFromStatusOrValid = std::conjunction<
+    std::negation<std::is_same<T, U>>,
     // If `T` is a reference, then U must be a compatible one.
-    absl::disjunction<absl::negation<std::is_reference<T>>,
+    std::disjunction<std::negation<std::is_reference<T>>,
                       IsReferenceConversionValid<T, U>>,
     Equality<Lifetimebound,
              type_traits_internal::IsLifetimeBoundAssignment<T, U>>,
     std::is_constructible<T, UQ>,
     Equality<!Explicit, std::is_convertible<UQ, T>>,
-    absl::negation<IsConstructibleOrConvertibleFromStatusOr<T, U>>>;
+    std::negation<IsConstructibleOrConvertibleFromStatusOr<T, U>>>;
 
 template <typename T, typename U, bool Lifetimebound>
-using IsStatusOrAssignmentValid = absl::conjunction<
-    absl::negation<std::is_same<T, absl::remove_cvref_t<U>>>,
+using IsStatusOrAssignmentValid = std::conjunction<
+    std::negation<std::is_same<T, absl::remove_cvref_t<U>>>,
     Equality<Lifetimebound,
              type_traits_internal::IsLifetimeBoundAssignment<T, U>>,
     std::is_constructible<T, U>, std::is_assignable<T, U>,
-    absl::negation<IsConstructibleOrConvertibleOrAssignableFromStatusOr<
+    std::negation<IsConstructibleOrConvertibleOrAssignableFromStatusOr<
         T, absl::remove_cvref_t<U>>>>;
 
 template <typename T, typename U, bool Lifetimebound>
-using IsValueOrValid = absl::conjunction<
+using IsValueOrValid = std::conjunction<
     // If `T` is a reference, then U must be a compatible one.
-    absl::disjunction<absl::negation<std::is_reference<T>>,
+    std::disjunction<std::negation<std::is_reference<T>>,
                       IsReferenceConversionValid<T, U>>,
     Equality<Lifetimebound,
-             absl::disjunction<
+             std::disjunction<
                  std::is_reference<T>,
                  type_traits_internal::IsLifetimeBoundAssignment<T, U>>>>;
 
@@ -325,13 +325,13 @@ class StatusOrData {
   }
 
   template <typename... Args>
-  explicit StatusOrData(absl::in_place_t, Args&&... args)
+  explicit StatusOrData(std::in_place_t, Args&&... args)
       : data_(std::forward<Args>(args)...) {
     MakeStatus();
   }
 
   template <typename U,
-            absl::enable_if_t<std::is_constructible<absl::Status, U&&>::value,
+            std::enable_if_t<std::is_constructible<absl::Status, U&&>::value,
                               int> = 0>
   explicit StatusOrData(U&& v) : status_(std::forward<U>(v)) {
     EnsureNotOk();

package/vendor/abseil-cpp/absl/status/status.cc

@@ -37,7 +37,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "absl/types/source_location.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -105,11 +105,36 @@ const std::string* absl_nonnull Status::MovedFromString() {
   return kMovedFrom.get();
 }
 
-Status::Status(absl::StatusCode code, absl::string_view msg)
-    : rep_(CodeToInlinedRep(code)) {
-  if (code != absl::StatusCode::kOk && !msg.empty()) {
-    rep_ = PointerToRep(new status_internal::StatusRep(code, msg, nullptr));
+absl::Status absl::Status::MakeNonOkStatusWithOkCode(
+    absl::string_view message) {
+  return absl::Status(
+      absl::Status::PointerToRep(new absl::status_internal::StatusRep(
+          absl::StatusCode::kOk, message, nullptr)));
+}
+
+uintptr_t Status::MakeRep(uintptr_t inlined_rep, absl::string_view msg,
+                          absl::SourceLocation loc) {
+  bool ok = inlined_rep == CodeToInlinedRep(absl::StatusCode::kOk);
+  if (ok) return inlined_rep;
+  if (msg.empty()
+  ) {
+    return inlined_rep;
+  }
+  auto* rep = new status_internal::StatusRep(InlinedRepToCode(inlined_rep), msg,
+                                             nullptr);
+  if (loc.file_name()[0] != '\0') {
+    rep->AddSourceLocation(loc);
   }
+  return PointerToRep(rep);
+}
+
+uintptr_t Status::AddSourceLocationImpl(uintptr_t rep,
+                                        absl::SourceLocation loc) {
+  if (IsInlined(rep)) return rep;
+  if (loc.file_name()[0] == '\0') return rep;
+  status_internal::StatusRep* rep_ptr = PrepareToModify(rep);
+  rep_ptr->AddSourceLocation(loc);
+  return PointerToRep(rep_ptr);
 }
 
 status_internal::StatusRep* absl_nonnull Status::PrepareToModify(
@@ -133,69 +158,35 @@ std::ostream& operator<<(std::ostream& os, const Status& x) {
   return os;
 }
 
-Status AbortedError(absl::string_view message) {
-  return Status(absl::StatusCode::kAborted, message);
-}
-
-Status AlreadyExistsError(absl::string_view message) {
-  return Status(absl::StatusCode::kAlreadyExists, message);
-}
-
-Status CancelledError(absl::string_view message) {
-  return Status(absl::StatusCode::kCancelled, message);
-}
-
-Status DataLossError(absl::string_view message) {
-  return Status(absl::StatusCode::kDataLoss, message);
-}
-
-Status DeadlineExceededError(absl::string_view message) {
-  return Status(absl::StatusCode::kDeadlineExceeded, message);
-}
-
-Status FailedPreconditionError(absl::string_view message) {
-  return Status(absl::StatusCode::kFailedPrecondition, message);
-}
-
-Status InternalError(absl::string_view message) {
-  return Status(absl::StatusCode::kInternal, message);
-}
-
-Status InvalidArgumentError(absl::string_view message) {
-  return Status(absl::StatusCode::kInvalidArgument, message);
-}
-
-Status NotFoundError(absl::string_view message) {
-  return Status(absl::StatusCode::kNotFound, message);
-}
-
-Status OutOfRangeError(absl::string_view message) {
-  return Status(absl::StatusCode::kOutOfRange, message);
-}
-
-Status PermissionDeniedError(absl::string_view message) {
-  return Status(absl::StatusCode::kPermissionDenied, message);
-}
-
-Status ResourceExhaustedError(absl::string_view message) {
-  return Status(absl::StatusCode::kResourceExhausted, message);
-}
-
-Status UnauthenticatedError(absl::string_view message) {
-  return Status(absl::StatusCode::kUnauthenticated, message);
-}
-
-Status UnavailableError(absl::string_view message) {
-  return Status(absl::StatusCode::kUnavailable, message);
-}
-
-Status UnimplementedError(absl::string_view message) {
-  return Status(absl::StatusCode::kUnimplemented, message);
-}
-
-Status UnknownError(absl::string_view message) {
-  return Status(absl::StatusCode::kUnknown, message);
-}
+namespace status_internal {
+// We use an int in the template parameter to shorten mangled names.
+template <int error_code>
+Status MakeErrorImpl(string_view message, SourceLocation loc) {
+  return Status(static_cast<StatusCode>(error_code), message, loc);
+}
+
+// Explicit instantiation for all the error codes.
+// If we add more error code, we need to add their values on this list.
+// Using ints here instead of static_cast<int>(StatusCode::kFoo) makes it easier
+// to see that the list is complete.
+template Status MakeErrorImpl<0>(string_view, SourceLocation);
+template Status MakeErrorImpl<1>(string_view, SourceLocation);
+template Status MakeErrorImpl<2>(string_view, SourceLocation);
+template Status MakeErrorImpl<3>(string_view, SourceLocation);
+template Status MakeErrorImpl<4>(string_view, SourceLocation);
+template Status MakeErrorImpl<5>(string_view, SourceLocation);
+template Status MakeErrorImpl<6>(string_view, SourceLocation);
+template Status MakeErrorImpl<7>(string_view, SourceLocation);
+template Status MakeErrorImpl<8>(string_view, SourceLocation);
+template Status MakeErrorImpl<9>(string_view, SourceLocation);
+template Status MakeErrorImpl<10>(string_view, SourceLocation);
+template Status MakeErrorImpl<11>(string_view, SourceLocation);
+template Status MakeErrorImpl<12>(string_view, SourceLocation);
+template Status MakeErrorImpl<13>(string_view, SourceLocation);
+template Status MakeErrorImpl<14>(string_view, SourceLocation);
+template Status MakeErrorImpl<15>(string_view, SourceLocation);
+template Status MakeErrorImpl<16>(string_view, SourceLocation);
+}  // namespace status_internal
 
 bool IsAborted(const Status& status) {
   return status.code() == absl::StatusCode::kAborted;
@@ -405,9 +396,10 @@ std::string MessageForErrnoToStatus(int error_number,
 }
 }  // namespace
 
-Status ErrnoToStatus(int error_number, absl::string_view message) {
+Status ErrnoToStatus(int error_number, absl::string_view message,
+                     absl::SourceLocation loc) {
   return Status(ErrnoToStatusCode(error_number),
-                MessageForErrnoToStatus(error_number, message));
+                MessageForErrnoToStatus(error_number, message), loc);
 }
 
 const char* absl_nonnull StatusMessageAsCStr(const Status& status) {