grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/random/internal/randen_engine.h

@@ -63,7 +63,7 @@ class alignas(8) randen_engine {
   explicit randen_engine(result_type seed_value) { seed(seed_value); }
 
   template <class SeedSequence,
-            typename = typename absl::enable_if_t<
+            typename = typename std::enable_if_t<
                 !std::is_same<SeedSequence, randen_engine>::value>>
   explicit randen_engine(SeedSequence&& seq) {
     seed(seq);
@@ -93,7 +93,7 @@ class alignas(8) randen_engine {
   }
 
   template <class SeedSequence>
-  typename absl::enable_if_t<
+  typename std::enable_if_t<
       !std::is_convertible<SeedSequence, result_type>::value>
   seed(SeedSequence&& seq) {
     // Zeroes the state.

data/third_party/abseil-cpp/absl/random/internal/salted_seed_seq.h

@@ -20,6 +20,7 @@
 #include <initializer_list>
 #include <iterator>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -48,11 +49,11 @@ class SaltedSeedSeq {
   using inner_sequence_type = SSeq;
   using result_type = typename SSeq::result_type;
 
-  SaltedSeedSeq() : seq_(absl::make_unique<SSeq>()) {}
+  SaltedSeedSeq() : seq_(std::make_unique<SSeq>()) {}
 
   template <typename Iterator>
   SaltedSeedSeq(Iterator begin, Iterator end)
-      : seq_(absl::make_unique<SSeq>(begin, end)) {}
+      : seq_(std::make_unique<SSeq>(begin, end)) {}
 
   template <typename T>
   SaltedSeedSeq(std::initializer_list<T> il)
@@ -71,7 +72,7 @@ class SaltedSeedSeq {
     // The common case is that generate is called with ContiguousIterators
     // to uint arrays. Such contiguous memory regions may be optimized,
     // which we detect here.
-    using TagType = absl::conditional_t<
+    using TagType = std::conditional_t<
         (std::is_same<U, uint32_t>::value &&
          (std::is_pointer<RandomAccessIterator>::value ||
           std::is_same<RandomAccessIterator,
@@ -141,14 +142,14 @@ struct is_salted_seed_seq<
 // non-salted seed parameters.
 template <
     typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<is_salted_seed_seq<SSeq>::value>>
+    typename EnableIf = std::enable_if_t<is_salted_seed_seq<SSeq>::value>>
 SSeq MakeSaltedSeedSeq(SSeq&& seq) {
   return SSeq(std::forward<SSeq>(seq));
 }
 
 template <
     typename SSeq,  //
-    typename EnableIf = absl::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
+    typename EnableIf = std::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
 SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq) {
   using sseq_type = typename std::decay<SSeq>::type;
   using result_type = typename sseq_type::result_type;

data/third_party/abseil-cpp/absl/random/internal/seed_material.cc

@@ -28,6 +28,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -38,15 +39,9 @@
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-#if defined(__native_client__)
-
-#include <nacl/nacl_random.h>
-#define ABSL_RANDOM_USE_NACL_SECURE_RANDOM 1
-
-#elif defined(_WIN32)
+#if defined(_WIN32)
 
 #include <windows.h>
 #define ABSL_RANDOM_USE_BCRYPT 1
@@ -109,27 +104,6 @@ bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
   return BCRYPT_SUCCESS(ret);
 }
 
-#elif defined(ABSL_RANDOM_USE_NACL_SECURE_RANDOM)
-
-// On NaCL use nacl_secure_random to acquire bytes.
-bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
-  auto buffer = reinterpret_cast<uint8_t*>(values.data());
-  size_t buffer_size = sizeof(uint32_t) * values.size();
-
-  uint8_t* output_ptr = buffer;
-  while (buffer_size > 0) {
-    size_t nread = 0;
-    const int error = nacl_secure_random(output_ptr, buffer_size, &nread);
-    if (error != 0 || nread > buffer_size) {
-      ABSL_RAW_LOG(ERROR, "Failed to read secure_random seed data: %d", error);
-      return false;
-    }
-    output_ptr += nread;
-    buffer_size -= nread;
-  }
-  return true;
-}
-
 #elif defined(__Fuchsia__)
 
 bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
@@ -254,17 +228,17 @@ void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
   }
 }
 
-absl::optional<uint32_t> GetSaltMaterial() {
+std::optional<uint32_t> GetSaltMaterial() {
   // Salt must be common for all generators within the same process so read it
   // only once and store in static variable.
-  static const auto salt_material = []() -> absl::optional<uint32_t> {
+  static const auto salt_material = []() -> std::optional<uint32_t> {
     uint32_t salt_value = 0;
 
     if (ReadSeedMaterialFromOSEntropy(absl::MakeSpan(&salt_value, 1))) {
       return salt_value;
     }
 
-    return absl::nullopt;
+    return std::nullopt;
   }();
 
   return salt_material;

data/third_party/abseil-cpp/absl/random/internal/seed_material.h

@@ -18,6 +18,7 @@
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -95,7 +96,7 @@ void MixIntoSeedMaterial(absl::Span<const uint32_t> sequence,
 // Salt is obtained only once and stored in static variable.
 //
 // May return empty value if obtaining the salt was not possible.
-absl::optional<uint32_t> GetSaltMaterial();
+std::optional<uint32_t> GetSaltMaterial();
 
 }  // namespace random_internal
 ABSL_NAMESPACE_END

data/third_party/abseil-cpp/absl/random/internal/traits.h

@@ -20,6 +20,7 @@
 #include <type_traits>
 
 #include "absl/base/config.h"
+#include "absl/meta/type_traits.h"
 #include "absl/numeric/bits.h"
 #include "absl/numeric/int128.h"
 
@@ -27,6 +28,26 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace random_internal {
 
+// is_urbg<URBG>
+//
+// Indicates whether a type URBG is a Uniform Random Bit Generator.
+template <typename URBG, typename = void, typename = void, typename = void>
+struct is_urbg : std::false_type {};
+
+template <typename URBG>
+struct is_urbg<
+    URBG,
+    std::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype((URBG::min)())>::type>::value>,
+    std::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype((URBG::max)())>::type>::value>,
+    std::enable_if_t<std::is_same<
+        typename URBG::result_type,
+        typename std::decay<decltype(std::declval<URBG>()())>::type>::value>>
+    : std::true_type {};
+
 // random_internal::is_widening_convertible<A, B>
 //
 // Returns whether a type A is widening-convertible to a type B.

data/third_party/abseil-cpp/absl/random/internal/uniform_helper.h

@@ -76,7 +76,7 @@ namespace random_internal {
 // Return-type for absl::Uniform() when the return-type is inferred.
 template <typename A, typename B>
 using uniform_inferred_return_t =
-    absl::enable_if_t<absl::disjunction<is_widening_convertible<A, B>,
+    std::enable_if_t<std::disjunction<is_widening_convertible<A, B>,
                                         is_widening_convertible<B, A>>::value,
                       typename std::conditional<
                           is_widening_convertible<A, B>::value, B, A>::type>;
@@ -98,10 +98,10 @@ using uniform_inferred_return_t =
 //               uniform_upper_bound(IntervalOpenClosed, a, b)]
 //
 template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
+        std::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     IntType>
 uniform_lower_bound(Tag, IntType a, IntType) {
@@ -109,10 +109,10 @@ uniform_lower_bound(Tag, IntType a, IntType) {
 }
 
 template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
+        std::disjunction<std::is_same<Tag, IntervalOpenClosedTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     FloatType>
 uniform_lower_bound(Tag, FloatType a, FloatType b) {
@@ -120,8 +120,8 @@ uniform_lower_bound(Tag, FloatType a, FloatType b) {
 }
 
 template <typename NumType, typename Tag>
-typename absl::enable_if_t<
-    absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+typename std::enable_if_t<
+    std::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
                       std::is_same<Tag, IntervalClosedOpenTag>>::value,
     NumType>
 uniform_lower_bound(Tag, NumType a, NumType) {
@@ -129,10 +129,10 @@ uniform_lower_bound(Tag, NumType a, NumType) {
 }
 
 template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
+        std::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     IntType>
 uniform_upper_bound(Tag, IntType, IntType b) {
@@ -140,10 +140,10 @@ uniform_upper_bound(Tag, IntType, IntType b) {
 }
 
 template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
+        std::disjunction<std::is_same<Tag, IntervalClosedOpenTag>,
                           std::is_same<Tag, IntervalOpenOpenTag>>>::value,
     FloatType>
 uniform_upper_bound(Tag, FloatType, FloatType b) {
@@ -151,10 +151,10 @@ uniform_upper_bound(Tag, FloatType, FloatType b) {
 }
 
 template <typename IntType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         IsIntegral<IntType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+        std::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
                           std::is_same<Tag, IntervalOpenClosedTag>>>::value,
     IntType>
 uniform_upper_bound(Tag, IntType, IntType b) {
@@ -162,10 +162,10 @@ uniform_upper_bound(Tag, IntType, IntType b) {
 }
 
 template <typename FloatType, typename Tag>
-typename absl::enable_if_t<
-    absl::conjunction<
+typename std::enable_if_t<
+    std::conjunction<
         std::is_floating_point<FloatType>,
-        absl::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
+        std::disjunction<std::is_same<Tag, IntervalClosedClosedTag>,
                           std::is_same<Tag, IntervalOpenClosedTag>>>::value,
     FloatType>
 uniform_upper_bound(Tag, FloatType, FloatType b) {
@@ -195,13 +195,13 @@ uniform_upper_bound(Tag, FloatType, FloatType b) {
 // (0, 0] is not legal, but (0, 0+epsilon] is.
 //
 template <typename FloatType>
-absl::enable_if_t<std::is_floating_point<FloatType>::value, bool>
+std::enable_if_t<std::is_floating_point<FloatType>::value, bool>
 is_uniform_range_valid(FloatType a, FloatType b) {
   return a <= b && std::isfinite(b - a);
 }
 
 template <typename IntType>
-absl::enable_if_t<IsIntegral<IntType>::value, bool> is_uniform_range_valid(
+std::enable_if_t<IsIntegral<IntType>::value, bool> is_uniform_range_valid(
     IntType a, IntType b) {
   return a <= b;
 }

data/third_party/abseil-cpp/absl/random/mocking_access.h

@@ -0,0 +1,74 @@
+// Copyright 2019 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.
+
+#ifndef ABSL_RANDOM_MOCKING_ACCESS_H_
+#define ABSL_RANDOM_MOCKING_ACCESS_H_
+
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/fast_type_id.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// RandomMockingAccess must be a friend of any class which exposes an InvokeMock
+// method. All calls to InvokeMock should be made through RandomMockingAccess.
+//
+// Any URBG type which wants to participate in mocking should declare
+// RandomMockingAccess as a friend and have a protected or private method with
+// the signature:
+//
+// bool InvokeMock(absl::FastTypeIdType key_id, void* args_tuple, void* result)
+//
+// This method returns false when mocking is not enabled, otherwise it will
+// apply the mock.  Typically this will involve forwarding to an underlying
+// URBG such as absl::MockingBitGen by calling RandomMockingAccess::InvokeMock
+// after checking that RandomMockingAccess::HasInvokeMock<URBG> is true for the
+// underlying URBG type.
+class RandomMockingAccess {
+  template <template <class...> class Trait, class AlwaysVoid, class... Args>
+  struct detector : std::false_type {};
+  template <template <class...> class Trait, class... Args>
+  struct detector<Trait, std::void_t<Trait<Args...>>, Args...>
+      : std::true_type {};
+
+  using IdType = ::absl::FastTypeIdType;
+
+  // Detector for `bool InvokeMock(key_id, args_tuple*, result*)`
+  // Lives inside RandomMockingAccess so that it has friend access to private
+  // members of URBG types.
+  template <class T>
+  using invoke_mock_t = decltype(std::declval<T*>()->InvokeMock(
+      std::declval<IdType>(), std::declval<void*>(), std::declval<void*>()));
+
+ public:
+  // Returns true if the URBG type has an InvokeMock method.
+  template <typename T>
+  using HasInvokeMock = typename detector<invoke_mock_t, void, T>::type;
+
+  // InvokeMock is private; calls to InvokeMock are proxied by MockingAccess.
+  template <typename URBG>
+  static inline bool InvokeMock(URBG* urbg, IdType key_id, void* args_tuple,
+                                void* result) {
+    return urbg->InvokeMock(key_id, args_tuple, result);
+  }
+};
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_RANDOM_MOCKING_ACCESS_H_

data/third_party/abseil-cpp/absl/random/uniform_real_distribution.h

@@ -159,7 +159,7 @@ uniform_real_distribution<RealType>::operator()(
   using random_internal::GeneratePositiveTag;
   using random_internal::GenerateRealFromBits;
   using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
+      std::conditional_t<std::is_same<RealType, float>::value, float, double>;
 
   while (true) {
     const result_type sample =

data/third_party/abseil-cpp/absl/status/internal/status_internal.cc

@@ -21,6 +21,7 @@
 #include <cstdio>
 #include <cstring>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -31,6 +32,7 @@
 #include "absl/debugging/leak_check.h"
 #include "absl/debugging/stacktrace.h"
 #include "absl/debugging/symbolize.h"
+#include "absl/hash/hash.h"
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/status_payload_printer.h"
@@ -40,7 +42,9 @@
 #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/optional_ref.h"
+#include "absl/types/source_location.h"
+#include "absl/types/span.h"
 
 namespace absl {
 ABSL_NAMESPACE_BEGIN
@@ -56,32 +60,32 @@ void StatusRep::Unref() const {
   }
 }
 
-static absl::optional<size_t> FindPayloadIndexByUrl(
-    const Payloads* payloads, absl::string_view type_url) {
-  if (payloads == nullptr) return absl::nullopt;
+static std::optional<size_t> FindPayloadIndexByUrl(const Payloads* payloads,
+                                                   absl::string_view type_url) {
+  if (payloads == nullptr) return std::nullopt;
 
   for (size_t i = 0; i < payloads->size(); ++i) {
     if ((*payloads)[i].type_url == type_url) return i;
   }
 
-  return absl::nullopt;
+  return std::nullopt;
 }
 
-absl::optional<absl::Cord> StatusRep::GetPayload(
+std::optional<absl::Cord> StatusRep::GetPayload(
     absl::string_view type_url) const {
-  absl::optional<size_t> index =
+  std::optional<size_t> index =
       status_internal::FindPayloadIndexByUrl(payloads_.get(), type_url);
   if (index.has_value()) return (*payloads_)[index.value()].payload;
 
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 void StatusRep::SetPayload(absl::string_view type_url, absl::Cord payload) {
   if (payloads_ == nullptr) {
-    payloads_ = absl::make_unique<status_internal::Payloads>();
+    payloads_ = std::make_unique<status_internal::Payloads>();
   }
 
-  absl::optional<size_t> index =
+  std::optional<size_t> index =
       status_internal::FindPayloadIndexByUrl(payloads_.get(), type_url);
   if (index.has_value()) {
     (*payloads_)[index.value()].payload = std::move(payload);
@@ -92,7 +96,7 @@ void StatusRep::SetPayload(absl::string_view type_url, absl::Cord payload) {
 }
 
 StatusRep::EraseResult StatusRep::ErasePayload(absl::string_view type_url) {
-  absl::optional<size_t> index =
+  std::optional<size_t> index =
       status_internal::FindPayloadIndexByUrl(payloads_.get(), type_url);
   if (!index.has_value()) return {false, Status::PointerToRep(this)};
   payloads_->erase(payloads_->begin() + index.value());
@@ -130,6 +134,14 @@ void StatusRep::ForEachPayload(
   }
 }
 
+absl::Span<const SourceLocation> StatusRep::GetSourceLocations() const {
+  return absl::MakeSpan(source_locations_);
+}
+
+void StatusRep::AddSourceLocation(absl::SourceLocation loc) {
+  source_locations_.push_back(loc);
+}
+
 std::string StatusRep::ToString(StatusToStringMode mode) const {
   std::string text;
   absl::StrAppend(&text, absl::StatusCodeToString(code()), ": ", message());
@@ -142,7 +154,7 @@ std::string StatusRep::ToString(StatusToStringMode mode) const {
         status_internal::GetStatusPayloadPrinter();
     this->ForEachPayload([&](absl::string_view type_url,
                              const absl::Cord& payload) {
-      absl::optional<std::string> result;
+      std::optional<std::string> result;
       if (printer) result = printer(type_url, payload);
       absl::StrAppend(
           &text, " [", type_url, "='",
@@ -150,6 +162,17 @@ std::string StatusRep::ToString(StatusToStringMode mode) const {
           "']");
     });
   }
+  const bool with_source_location =
+      (mode & StatusToStringMode::kWithSourceLocation) ==
+      StatusToStringMode::kWithSourceLocation;
+  if (with_source_location && !source_locations_.empty()) {
+    absl::string_view whitespace = (absl::Hash<int>{}(42) % 2 == 0) ? "" : " ";
+    absl::StrAppend(&text, "\n=== Source Location Trace: ===", whitespace,
+                    "\n");
+    for (const absl::SourceLocation loc : GetSourceLocations()) {
+      absl::StrAppend(&text, loc.file_name(), ":", loc.line(), "\n");
+    }
+  }
 
   return text;
 }
@@ -189,9 +212,12 @@ bool StatusRep::operator==(const StatusRep& other) const {
   return true;
 }
 
-StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
+StatusRep* absl_nonnull StatusRep::Clone(
+    absl::optional_ref<absl::string_view> new_message, bool include_payloads,
+    bool include_source_locations) const {
   // Optimization: no need to create a clone if we already have a refcount of 1.
-  if (ref_.load(std::memory_order_acquire) == 1) {
+  if (ref_.load(std::memory_order_acquire) == 1 && !new_message.has_value() &&
+      include_payloads && include_source_locations) {
     // All StatusRep instances are heap allocated and mutable, therefore this
     // const_cast will never cast away const from a stack instance.
     //
@@ -200,11 +226,30 @@ StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
     return const_cast<StatusRep*>(this);
   }
   std::unique_ptr<status_internal::Payloads> payloads;
-  if (payloads_) {
-    payloads = absl::make_unique<status_internal::Payloads>(*payloads_);
+  if (include_payloads && payloads_) {
+    payloads = std::make_unique<status_internal::Payloads>(*payloads_);
+  }
+  auto* new_rep =
+      new StatusRep(code_, new_message.value_or(message_), std::move(payloads));
+  if (include_source_locations) {
+    new_rep->source_locations_ = source_locations_;
+  }
+  return new_rep;
+}
+
+StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
+  return CloneAndUnref(std::nullopt, true, true);
+}
+
+StatusRep* absl_nonnull StatusRep::CloneAndUnref(
+    absl::optional_ref<absl::string_view> new_message, bool include_payloads,
+    bool include_source_locations) const {
+  StatusRep* new_rep =
+      Clone(new_message, /*include_payloads=*/include_payloads,
+            /*include_source_locations=*/include_source_locations);
+  if (new_rep != this) {
+    Unref();
   }
-  auto* new_rep = new StatusRep(code_, message_, std::move(payloads));
-  Unref();
   return new_rep;
 }
 

data/third_party/abseil-cpp/absl/status/internal/status_internal.h

@@ -17,8 +17,10 @@
 #include <atomic>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
@@ -27,6 +29,9 @@
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/optional_ref.h"
+#include "absl/types/source_location.h"
+#include "absl/types/span.h"
 
 #ifndef SWIG
 // Disabled for SWIG as it doesn't parse attributes correctly.
@@ -38,10 +43,13 @@ ABSL_NAMESPACE_BEGIN
 // TODO(b/176172494): ABSL_MUST_USE_RESULT should expand to the more strict
 // [[nodiscard]]. For now, just use [[nodiscard]] directly when it is available.
 #if ABSL_HAVE_CPP_ATTRIBUTE(nodiscard)
-class [[nodiscard]] ABSL_ATTRIBUTE_TRIVIAL_ABI Status;
+class [[nodiscard]] ABSL_ATTRIBUTE_TRIVIAL_ABI
+    Status;
 #else
-class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI Status;
+class ABSL_MUST_USE_RESULT ABSL_ATTRIBUTE_TRIVIAL_ABI
+    Status;
 #endif
+
 ABSL_NAMESPACE_END
 }  // namespace absl
 #endif  // !SWIG
@@ -53,6 +61,10 @@ enum class StatusCode : int;
 enum class StatusToStringMode : int;
 
 namespace status_internal {
+#ifndef SWIG
+class StatusPrivateAccessor;
+class StatusPrivateAccessorForStatusBuilder;
+#endif  // !SWIG
 
 // Container for status payloads.
 struct Payload {
@@ -81,7 +93,7 @@ class StatusRep {
   void Unref() const;
 
   // Payload methods correspond to the same methods in absl::Status.
-  absl::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
+  std::optional<absl::Cord> GetPayload(absl::string_view type_url) const;
   void SetPayload(absl::string_view type_url, absl::Cord payload);
   struct EraseResult {
     bool erased;
@@ -92,6 +104,9 @@ class StatusRep {
       absl::FunctionRef<void(absl::string_view, const absl::Cord&)> visitor)
       const;
 
+  absl::Span<const SourceLocation> GetSourceLocations() const;
+  void AddSourceLocation(absl::SourceLocation loc);
+
   std::string ToString(StatusToStringMode mode) const;
 
   bool operator==(const StatusRep& other) const;
@@ -99,7 +114,17 @@ class StatusRep {
 
   // Returns an equivalent heap allocated StatusRep with refcount 1.
   //
-  // `this` is not safe to be used after calling as it may have been deleted.
+  // If `new_message` is provided, the message will be replaced with the new
+  // message.
+  StatusRep* absl_nonnull Clone(
+      absl::optional_ref<absl::string_view> new_message, bool include_payloads,
+      bool include_source_locations) const;
+
+  // Same as Clone(), but also removes a reference to `this`. `this` is not safe
+  // to be used after calling as it may have been deleted.
+  StatusRep* absl_nonnull CloneAndUnref(
+      absl::optional_ref<absl::string_view> new_message, bool include_payloads,
+      bool include_source_locations) const;
   StatusRep* absl_nonnull CloneAndUnref() const;
 
  private:
@@ -110,6 +135,7 @@ class StatusRep {
   // is non-empty, then the resulting string_view is null terminated.
   // This is required to implement 'StatusMessageAsCStr(...)'
   std::string message_;
+  absl::InlinedVector<absl::SourceLocation, 1> source_locations_;
   std::unique_ptr<status_internal::Payloads> payloads_;
 };