re2 1.24.0 → 1.25.0

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

@@ -53,6 +53,7 @@
 
 #include <cassert>
 #include <cstdint>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -67,6 +68,8 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/source_location.h"
+#include "absl/types/span.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -305,6 +308,8 @@ enum class StatusToStringMode : int {
   kWithNoExtraData = 0,
   // ToString will contain the payloads.
   kWithPayload = 1 << 0,
+  // ToString will contain the source locations.
+  kWithSourceLocation = 1 << 1,
   // ToString will include all the extra data this Status has.
   kWithEverything = ~kWithNoExtraData,
   // Default mode used by ToString. Its exact value might change in the future.
@@ -443,12 +448,28 @@ class ABSL_ATTRIBUTE_TRIVIAL_ABI Status final {
   Status();
 
   // Creates a status in the canonical error space with the specified
-  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,  // NOLINT
+  // `absl::StatusCode` and error message.  If `code == absl::StatusCode::kOk`,
   // `msg` is ignored and an object identical to an OK status is constructed.
   //
-  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,  // NOLINT
+  // The `msg` string must be in UTF-8. The implementation may complain (e.g.,
   // by printing a warning) if it is not.
-  Status(absl::StatusCode code, absl::string_view msg);
+  //
+  // The `loc` is the SourceLocation of the callsite. It will be stored in the
+  // Status iff `code != absl::StatusCode::kOk` and `!msg.empty()`.
+  Status(absl::StatusCode code, absl::string_view msg,
+         absl::SourceLocation loc = SourceLocation::current());
+
+  // Create a status from a `base_status` and a `loc`. The `loc` will be
+  // appended to the location chain of the new status, iff the `base_status` is
+  // not ok and has non-empty msg.
+  Status(const Status& base_status, absl::SourceLocation loc)
+      : Status(base_status) {
+    AddSourceLocation(loc);
+  }
+  Status(Status&& base_status, absl::SourceLocation loc)
+      : Status(std::move(base_status)) {
+    AddSourceLocation(loc);
+  }
 
   Status(const Status&);
   Status& operator=(const Status& x);
@@ -583,7 +604,7 @@ class ABSL_ATTRIBUTE_TRIVIAL_ABI Status final {
   // Status::GetPayload()
   //
   // Gets the payload of a status given its unique `type_url` key, if present.
-  absl::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
+  std::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
 
   // Status::SetPayload()
   //
@@ -613,16 +634,89 @@ class ABSL_ATTRIBUTE_TRIVIAL_ABI Status final {
       absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor)
       const;
 
+  absl::Span<const absl::SourceLocation> GetSourceLocations() const {
+    if (IsInlined(rep_)) return {};
+    return RepToPointer(rep_)->GetSourceLocations();
+  }
+  // Appends the `loc` to the current location chain inside the status, iff the
+  // status is non-ok and contains a non-empty message.
+  void AddSourceLocation(
+      absl::SourceLocation loc = absl::SourceLocation::current()) {
+    if (ok()) return;
+    rep_ = AddSourceLocationImpl(rep_, loc);
+    ABSL_ATTRIBUTE_UNUSED bool okay = ok();
+    // This hint tells the optimizer that the status is still not ok after the
+    // AddSourceLocation() call. This is useful when passing a known !ok status
+    // to StatusOr. StatusOr checks for ok() on its constructor and this assume
+    // helps the optimizer remove that check.
+    ABSL_ASSUME(!okay);
+  }
+
+  // Status::WithSourceLocation()
+  //
+  // Returns a copy of the current status, with `loc` appended to its location
+  // chain iff the status is non-ok and contains a non-empty message.
+  //
+  // Example:
+  //
+  //   if (Status status = Foo(); !status.ok()) {
+  //     return status.WithSourceLocation();
+  //   }
+  Status WithSourceLocation(
+      absl::SourceLocation loc = absl::SourceLocation::current()) const& {
+    return Status(*this, loc);
+  }
+
+  // Status::WithSourceLocation()
+  //
+  // Appends the `loc` to the current location chain inside the status iff the
+  // status is non-ok and contains a non-empty message, and returns an rvalue
+  // reference to `*this`.
+  //
+  // Example:
+  //
+  //   Status Finalize(...);
+  //
+  //   Status DoSomething(...) {
+  //     ...
+  //     return Finalize().WithSourceLocation();
+  //   }
+  ABSL_MUST_USE_RESULT Status&& WithSourceLocation(
+      absl::SourceLocation loc = absl::SourceLocation::current()) && {
+    AddSourceLocation(loc);
+    return std::move(*this);
+  }
+
  private:
   friend Status CancelledError();
 
+#ifndef SWIG
+  // Returns a `Status` object which is not `ok()` but
+  // `code() == absl::StatusCode::kOk`. This is necessary to be compatible with
+  // `Status` objects created with an error code in a custom `ErrorSpace` that
+  // is mapped to the canonical code `absl::StatusCode::kOk`.
+  static Status MakeNonOkStatusWithOkCode(absl::string_view message);
+
+  friend class absl::status_internal::StatusPrivateAccessor;
+  friend class absl::status_internal::StatusPrivateAccessorForStatusBuilder;
+#endif  // !SWIG
+
   // Creates a status in the canonical error space with the specified
   // code, and an empty error message.
   explicit Status(absl::StatusCode code);
 
+  // Delegate factory in header that ensures CodeToInlinedRep is inlined
+  // where possible.
+  static uintptr_t MakeRep(uintptr_t inlined_rep, absl::string_view msg,
+                           absl::SourceLocation loc);
+
   // Underlying constructor for status from a rep_.
   explicit Status(uintptr_t rep) : rep_(rep) {}
 
+  // An out-of-line AddSourceLocation that mutates rep directly.
+  static uintptr_t AddSourceLocationImpl(uintptr_t rep,
+                                         absl::SourceLocation loc);
+
   static void Ref(uintptr_t rep);
   static void Unref(uintptr_t rep);
 
@@ -740,22 +834,44 @@ ABSL_MUST_USE_RESULT bool IsUnknown(const Status& status);
 // These convenience functions create an `absl::Status` object with an error
 // code as indicated by the associated function name, using the error message
 // passed in `message`.
-Status AbortedError(absl::string_view message);
-Status AlreadyExistsError(absl::string_view message);
-Status CancelledError(absl::string_view message);
-Status DataLossError(absl::string_view message);
-Status DeadlineExceededError(absl::string_view message);
-Status FailedPreconditionError(absl::string_view message);
-Status InternalError(absl::string_view message);
-Status InvalidArgumentError(absl::string_view message);
-Status NotFoundError(absl::string_view message);
-Status OutOfRangeError(absl::string_view message);
-Status PermissionDeniedError(absl::string_view message);
-Status ResourceExhaustedError(absl::string_view message);
-Status UnauthenticatedError(absl::string_view message);
-Status UnavailableError(absl::string_view message);
-Status UnimplementedError(absl::string_view message);
-Status UnknownError(absl::string_view message);
+Status AbortedError(absl::string_view message,
+                    absl::SourceLocation loc = SourceLocation::current());
+Status AlreadyExistsError(absl::string_view message,
+                          absl::SourceLocation loc = SourceLocation::current());
+Status CancelledError(absl::string_view message,
+                      absl::SourceLocation loc = SourceLocation::current());
+Status DataLossError(absl::string_view message,
+                     absl::SourceLocation loc = SourceLocation::current());
+Status DeadlineExceededError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status FailedPreconditionError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status InternalError(absl::string_view message,
+                     absl::SourceLocation loc = SourceLocation::current());
+Status InvalidArgumentError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status NotFoundError(absl::string_view message,
+                     absl::SourceLocation loc = SourceLocation::current());
+Status OutOfRangeError(absl::string_view message,
+                       absl::SourceLocation loc = SourceLocation::current());
+Status PermissionDeniedError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status ResourceExhaustedError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status UnauthenticatedError(
+    absl::string_view message,
+    absl::SourceLocation loc = SourceLocation::current());
+Status UnavailableError(absl::string_view message,
+                        absl::SourceLocation loc = SourceLocation::current());
+Status UnimplementedError(absl::string_view message,
+                          absl::SourceLocation loc = SourceLocation::current());
+Status UnknownError(absl::string_view message,
+                    absl::SourceLocation loc = SourceLocation::current());
 
 // ErrnoToStatusCode()
 //
@@ -768,7 +884,8 @@ absl::StatusCode ErrnoToStatusCode(int error_number);
 //
 // Convenience function that creates a `absl::Status` using an `error_number`,
 // which should be an `errno` value.
-Status ErrnoToStatus(int error_number, absl::string_view message);
+Status ErrnoToStatus(int error_number, absl::string_view message,
+                     absl::SourceLocation loc = SourceLocation::current());
 
 //------------------------------------------------------------------------------
 // Implementation details follow
@@ -778,6 +895,10 @@ inline Status::Status() : Status(absl::StatusCode::kOk) {}
 
 inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
 
+inline Status::Status(absl::StatusCode code, absl::string_view msg,
+                      absl::SourceLocation loc)
+    : Status(MakeRep(CodeToInlinedRep(code), msg, loc)) {}
+
 inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }
 
 inline Status& Status::operator=(const Status& x) {
@@ -862,9 +983,9 @@ inline void swap(absl::Status& a, absl::Status& b) noexcept {
   swap(a.rep_, b.rep_);
 }
 
-inline absl::optional<absl::Cord> Status::GetPayload(
+inline std::optional<absl::Cord> Status::GetPayload(
     absl::string_view type_url) const {
-  if (IsInlined(rep_)) return absl::nullopt;
+  if (IsInlined(rep_)) return std::nullopt;
   return RepToPointer(rep_)->GetPayload(type_url);
 }
 
@@ -942,6 +1063,111 @@ inline Status CancelledError() { return Status(absl::StatusCode::kCancelled); }
 const char* absl_nonnull StatusMessageAsCStr(
     const Status& status ABSL_ATTRIBUTE_LIFETIME_BOUND);
 
+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);
+// Make the instantiations extern to reduce bloat on callers.
+extern template Status MakeErrorImpl<0>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<1>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<2>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<3>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<4>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<5>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<6>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<7>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<8>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<9>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<10>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<11>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<12>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<13>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<14>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<15>(string_view, SourceLocation);
+extern template Status MakeErrorImpl<16>(string_view, SourceLocation);
+
+template <StatusCode error_code>
+Status MakeError(string_view message, SourceLocation loc) {
+  Status out = MakeErrorImpl<static_cast<int>(error_code)>(message, loc);
+  // -Wassume warning complains about potential side effects of `ok()`, so use a
+  // local to avoid that.
+  ABSL_ATTRIBUTE_UNUSED bool ok = out.ok();
+  ABSL_ASSUME(!ok);
+  return out;
+}
+}  // namespace status_internal
+
+// Inline implementations to give the compiler static knowledge about the
+// objects.
+inline Status AbortedError(absl::string_view message,
+                           absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kAborted>(message, loc);
+}
+inline Status AlreadyExistsError(absl::string_view message,
+                                 absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kAlreadyExists>(message, loc);
+}
+inline Status CancelledError(absl::string_view message,
+                             absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kCancelled>(message, loc);
+}
+inline Status DataLossError(absl::string_view message,
+                            absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kDataLoss>(message, loc);
+}
+inline Status DeadlineExceededError(absl::string_view message,
+                                    absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kDeadlineExceeded>(message,
+                                                                   loc);
+}
+inline Status FailedPreconditionError(absl::string_view message,
+                                      absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kFailedPrecondition>(message,
+                                                                     loc);
+}
+inline Status InternalError(absl::string_view message,
+                            absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kInternal>(message, loc);
+}
+inline Status InvalidArgumentError(absl::string_view message,
+                                   absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kInvalidArgument>(message, loc);
+}
+inline Status NotFoundError(absl::string_view message,
+                            absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kNotFound>(message, loc);
+}
+inline Status OutOfRangeError(absl::string_view message,
+                              absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kOutOfRange>(message, loc);
+}
+inline Status PermissionDeniedError(absl::string_view message,
+                                    absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kPermissionDenied>(message,
+                                                                   loc);
+}
+inline Status ResourceExhaustedError(absl::string_view message,
+                                     absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kResourceExhausted>(message,
+                                                                    loc);
+}
+inline Status UnauthenticatedError(absl::string_view message,
+                                   absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kUnauthenticated>(message, loc);
+}
+inline Status UnavailableError(absl::string_view message,
+                               absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kUnavailable>(message, loc);
+}
+inline Status UnimplementedError(absl::string_view message,
+                                 absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kUnimplemented>(message, loc);
+}
+inline Status UnknownError(absl::string_view message,
+                           absl::SourceLocation loc) {
+  return status_internal::MakeError<StatusCode::kUnknown>(message, loc);
+}
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 

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

@@ -13,7 +13,9 @@
 // limitations under the License.
 
 #include <utility>
+
 #include "absl/status/status.h"
+#include "absl/types/source_location.h"
 #include "benchmark/benchmark.h"
 
 namespace {
@@ -34,4 +36,14 @@ void BM_CreateBad(benchmark::State& state) {
 }
 BENCHMARK(BM_CreateBad);
 
+void BM_AppendSourceLocation(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::Status s(absl::StatusCode::kInvalidArgument, "message");
+    benchmark::DoNotOptimize(s);
+    absl::Status s2(std::move(s), absl::SourceLocation::current());
+    benchmark::DoNotOptimize(s2);
+  }
+}
+BENCHMARK(BM_AppendSourceLocation);
+
 }  // namespace

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

@@ -0,0 +1,196 @@
+// 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/status/status_builder.h"
+
+#include <cstdint>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/status/status.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/source_location.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+void StatusBuilder::Destroy(std::unique_ptr<Rep>) {
+  // nothing to do. The unique_ptr will do the cleanup.
+}
+
+// These constructors are not-inlined and defined in the .cc file to reduce
+// binary size. See cl/354351433 for a quantification.
+StatusBuilder::StatusBuilder() {}
+
+StatusBuilder::StatusBuilder(const absl::Status& original_status,
+                             absl::SourceLocation location)
+    : loc_(location), rep_(InitRep(original_status)) {}
+
+StatusBuilder::operator absl::Status() const& {
+  if (rep_ == nullptr) return absl::Status();
+  return CreateStatusAndConditionallyLog(loc_, std::make_unique<Rep>(*rep_));
+}
+
+StatusBuilder::Rep::Rep(const absl::Status& s) : status(s) {}
+StatusBuilder::Rep::Rep(absl::Status&& s) : status(std::move(s)) {}
+StatusBuilder::Rep::~Rep() {}
+
+StatusBuilder::Rep* StatusBuilder::InitRepImpl(absl::Status s) {
+  if (s.ok()) {
+    return nullptr;
+  } else {
+    return new Rep(std::move(s));
+  }
+}
+
+StatusBuilder::Rep::Rep(const Rep& r)
+    : status(r.status),
+      logging_mode(r.logging_mode),
+      log_severity(r.log_severity),
+      verbose_level(r.verbose_level),
+      n(r.n),
+      period(r.period),
+      stream_message(r.stream_message),
+      sink(r.sink),
+      message_join_style(r.message_join_style),
+      should_log_stack_trace(r.should_log_stack_trace),
+      also_send_to_log(r.also_send_to_log) {
+  if (r.stream.has_value()) {
+    InitStream();
+  }
+}
+
+void StatusBuilder::Rep::InitStream() { stream.emplace(stream_message); }
+
+bool StatusBuilder::HasPayload() const {
+  static constexpr absl::string_view kMessageSetUrl =
+      "type.googleapis.com/util.MessageSetPayload";
+  return rep_ != nullptr && rep_->status.GetPayload(kMessageSetUrl).has_value();
+}
+
+ABSL_ATTRIBUTE_WEAK StatusBuilder& StatusBuilder::SetCode(
+    absl::StatusCode code) & {
+  if (rep_ == nullptr) {
+    rep_ = std::make_unique<StatusBuilder::Rep>(
+        absl::Status(code, absl::string_view(), absl::SourceLocation()));
+  } else {
+    absl::Status status(code, absl::string_view(), absl::SourceLocation());
+    rep_->status.ForEachPayload(
+        [&status](absl::string_view type_url, const absl::Cord& payload) {
+          status.SetPayload(type_url, payload);
+        });
+    rep_->status = std::move(status);
+  }
+  return *this;
+}
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSetErrorCode(StatusBuilder& builder,
+                                                  absl::StatusCode code) {
+  builder.SetCode(code);
+}
+
+class status_internal::StatusPrivateAccessorForStatusBuilder {
+ public:
+  static absl::Status SetMessage(const absl::Status& status,
+                                 absl::string_view message) {
+    ABSL_ASSERT(!status.ok());
+
+    if (message.empty()) {
+      return absl::Status(status.code(), message, absl::SourceLocation());
+    }
+
+    using StatusRep =
+        std::remove_cv_t<std::remove_pointer_t<decltype(Status::RepToPointer(
+            std::declval<uintptr_t>()))>>;
+    StatusRep* rep;
+    if (Status::IsInlined(status.rep_)) {
+      rep = new StatusRep(Status::InlinedRepToCode(status.rep_), message,
+                          nullptr);
+    } else {
+      rep = Status::RepToPointer(status.rep_)->Clone(message, true, true);
+    }
+    return absl::Status(Status::PointerToRep(rep));
+  }
+
+  static absl::Status JoinMessageToStatus(absl::Status s, absl::string_view msg,
+                                          MessageJoinStyle style) {
+    if (s.ok() || msg.empty()) return s;
+    const absl::string_view original_message = s.message();
+    switch (style) {
+      case MessageJoinStyle::kAnnotate: {
+        std::string annotated;
+        if (!original_message.empty()) {
+          absl::StrAppend(&annotated, original_message, "; ", msg);
+          msg = annotated;
+        }
+        return SetMessage(s, msg);
+      }
+      case MessageJoinStyle::kPrepend:
+        return SetMessage(s, absl::StrCat(msg, original_message));
+      case MessageJoinStyle::kAppend:
+        return SetMessage(s, absl::StrCat(original_message, msg));
+      default:
+        return absl::InternalError("Unknown MessageJoinStyle");
+    }
+  }
+};
+
+ABSL_ATTRIBUTE_WEAK std::string StatusBuilder::CurrentStackTrace() {
+  return std::string();
+}
+
+ABSL_ATTRIBUTE_WEAK absl::Status StatusBuilder::CreateStatusAndConditionallyLog(
+    absl::SourceLocation loc, std::unique_ptr<Rep> rep) {
+  if (rep == nullptr) return absl::OkStatus();
+  absl::Status result = status_internal::StatusPrivateAccessorForStatusBuilder::
+      JoinMessageToStatus(std::move(rep->status), rep->stream_message,
+                          rep->message_join_style);
+  // Passing in the `loc` last to ensure the sequence of the source locations.
+  result.AddSourceLocation(loc);
+  return result;
+}
+
+ABSL_ATTRIBUTE_WEAK std::string StatusBuilder::ToString() const {
+  if (rep_ == nullptr) {
+    return absl::OkStatus().ToString();
+  }
+
+  return status_internal::StatusPrivateAccessorForStatusBuilder::
+      JoinMessageToStatus(rep_->status, rep_->stream_message,
+                          rep_->message_join_style)
+          .WithSourceLocation(loc_)
+          .ToString();
+}
+
+ABSL_ATTRIBUTE_WEAK std::ostream& operator<<(std::ostream& os,
+                                             const StatusBuilder& builder) {
+  return os << static_cast<absl::Status>(builder);
+}
+
+ABSL_ATTRIBUTE_WEAK std::ostream& operator<<(std::ostream& os,
+                                             StatusBuilder&& builder) {
+  return os << static_cast<absl::Status>(std::move(builder));
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl