grpc 1.70.1 → 1.71.0

data/src/core/tsi/fake_transport_security.cc

@@ -191,6 +191,11 @@ static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
     frame->allocated_size = TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE;
     frame->data =
         static_cast<unsigned char*>(gpr_malloc(frame->allocated_size));
+    // Initialize `data` to some recognizably bad values.
+    // There's some debug code paths where we stringify the entire buffer, and
+    // doing so leads to ubsan failures on those code paths -- which are
+    // commonly hit using fuzzers.
+    memset(frame->data, 0xab, frame->allocated_size);
   }
 
   if (frame->offset < TSI_FAKE_FRAME_HEADER_SIZE) {

data/src/core/util/dump_args.h

@@ -26,20 +26,12 @@
 namespace grpc_core {
 namespace dump_args_detail {
 
-// Helper function... just ignore the initializer list passed into it.
-// Allows doing 'statements' via parameter pack expansion in C++11 - given
-// template <typename... Ts>:
-//  do_these_things({foo<Ts>()...});
-// will execute foo<T>() for each T in Ts.
-template <typename T>
-void do_these_things(std::initializer_list<T>) {}
-
 class DumpArgs {
  public:
   template <typename... Args>
   explicit DumpArgs(const char* arg_string, const Args&... args)
       : arg_string_(arg_string) {
-    do_these_things({AddDumper(&args)...});
+    (AddDumper(&args), ...);
   }
 
   template <typename Sink>

data/src/core/util/env.h

@@ -21,14 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 // Gets the environment variable value with the specified name. */
-absl::optional<std::string> GetEnv(const char* name);
+std::optional<std::string> GetEnv(const char* name);
 
 // Sets the environment with the specified name to the specified value.
 void SetEnv(const char* name, const char* value);
@@ -40,7 +39,7 @@ inline void SetEnv(const char* name, const std::string& value) {
 void UnsetEnv(const char* name);
 
 template <typename T>
-void SetOrUnsetEnv(const char* name, const absl::optional<T>& value) {
+void SetOrUnsetEnv(const char* name, const std::optional<T>& value) {
   if (value.has_value()) {
     SetEnv(name, value.value());
   } else {

data/src/core/util/examine_stack.cc

@@ -33,11 +33,11 @@ void SetCurrentStackTraceProvider(
   g_current_stack_trace_provider = current_stack_trace_provider;
 }
 
-absl::optional<std::string> GetCurrentStackTrace() {
+std::optional<std::string> GetCurrentStackTrace() {
   if (g_current_stack_trace_provider != nullptr) {
     return g_current_stack_trace_provider();
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/util/examine_stack.h

@@ -21,10 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 typedef std::string (*gpr_current_stack_trace_func)();
@@ -37,8 +36,8 @@ void SetCurrentStackTraceProvider(
     gpr_current_stack_trace_func current_stack_trace_provider);
 
 // Returns the current stack trace as a string via current_stack_trace_provider
-// If current_stack_trace_provider is not set, it returns absl::nullopt.
-absl::optional<std::string> GetCurrentStackTrace();
+// If current_stack_trace_provider is not set, it returns std::nullopt.
+std::optional<std::string> GetCurrentStackTrace();
 
 }  // namespace grpc_core
 

data/src/core/util/gpr_time.cc

@@ -18,7 +18,6 @@
 
 // Generic implementation of time calls.
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 #include <limits.h>
@@ -26,7 +25,6 @@
 #include <string.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);

data/src/core/util/http_client/httpcli.cc

@@ -71,7 +71,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Get(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_get_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -97,7 +97,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Post(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_post_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -122,7 +122,7 @@ OrphanablePtr<HttpRequest> HttpRequest::Put(
     grpc_polling_entity* pollent, const grpc_http_request* request,
     Timestamp deadline, grpc_closure* on_done, grpc_http_response* response,
     RefCountedPtr<grpc_channel_credentials> channel_creds) {
-  absl::optional<std::function<bool()>> test_only_generate_response;
+  std::optional<std::function<bool()>> test_only_generate_response;
   if (g_put_override != nullptr) {
     test_only_generate_response = [request, uri, deadline, on_done,
                                    response]() {
@@ -159,7 +159,7 @@ HttpRequest::HttpRequest(
     URI uri, const grpc_slice& request_text, grpc_http_response* response,
     Timestamp deadline, const grpc_channel_args* channel_args,
     grpc_closure* on_done, grpc_polling_entity* pollent, const char* name,
-    absl::optional<std::function<bool()>> test_only_generate_response,
+    std::optional<std::function<bool()>> test_only_generate_response,
     RefCountedPtr<grpc_channel_credentials> channel_creds)
     : uri_(std::move(uri)),
       request_text_(request_text),
@@ -226,7 +226,6 @@ void HttpRequest::Start() {
         ->LookupHostname(
             [this](absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
                        addresses_or) {
-              ApplicationCallbackExecCtx callback_exec_ctx;
               ExecCtx exec_ctx;
               OnResolved(addresses_or);
             },

data/src/core/util/http_client/httpcli.h

@@ -27,13 +27,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -162,7 +162,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
               grpc_http_response* response, Timestamp deadline,
               const grpc_channel_args* channel_args, grpc_closure* on_done,
               grpc_polling_entity* pollent, const char* name,
-              absl::optional<std::function<bool()>> test_only_generate_response,
+              std::optional<std::function<bool()>> test_only_generate_response,
               RefCountedPtr<grpc_channel_credentials> channel_creds);
 
   ~HttpRequest() override;
@@ -250,7 +250,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   ResourceQuotaRefPtr resource_quota_;
   grpc_polling_entity* pollent_;
   grpc_pollset_set* pollset_set_;
-  const absl::optional<std::function<bool()>> test_only_generate_response_;
+  const std::optional<std::function<bool()>> test_only_generate_response_;
   Mutex mu_;
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
@@ -267,7 +267,7 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   // experiment is fully enabled.
   bool use_event_engine_dns_resolver_;
   std::shared_ptr<DNSResolver> resolver_;
-  absl::optional<DNSResolver::TaskHandle> dns_request_handle_
+  std::optional<DNSResolver::TaskHandle> dns_request_handle_
       ABSL_GUARDED_BY(mu_) = DNSResolver::kNullHandle;
   absl::StatusOr<std::unique_ptr<
       grpc_event_engine::experimental::EventEngine::DNSResolver>>

data/src/core/util/http_client/httpcli_security_connector.cc

@@ -25,13 +25,13 @@
 #include <grpc/support/string_util.h>
 #include <string.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/security/security_handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -173,7 +173,7 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
       LOG(ERROR) << "Could not get default pem root certs.";
       return nullptr;
     }
-    absl::optional<std::string> target_string =
+    std::optional<std::string> target_string =
         args->GetOwnedString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)
             .value_or(target);
     return httpcli_ssl_channel_security_connector_create(

data/src/core/util/json/json_channel_args.h

@@ -17,8 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json_args.h"
 

data/src/core/util/json/json_object_loader.cc

@@ -159,11 +159,11 @@ void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
     return;
   }
   const LoaderInterface* element_loader = ElementLoader();
-  for (const auto& pair : json.object()) {
+  for (const auto& [key, value] : json.object()) {
     ValidationErrors::ScopedField field(errors,
-                                        absl::StrCat("[\"", pair.first, "\"]"));
-    void* element = Insert(pair.first, dst);
-    element_loader->LoadInto(pair.second, args, element, errors);
+                                        absl::StrCat("[\"", key, "\"]"));
+    void* element = Insert(key, dst);
+    element_loader->LoadInto(value, args, element, errors);
   }
 }
 

data/src/core/util/json/json_object_loader.h

@@ -21,6 +21,7 @@
 #include <cstring>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -30,7 +31,6 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/no_destruct.h"
@@ -388,15 +388,15 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
   ~AutoLoader() = default;
 };
 
-// Specializations of AutoLoader for absl::optional<>.
+// Specializations of AutoLoader for std::optional<>.
 template <typename T>
-class AutoLoader<absl::optional<T>> final : public LoadWrapped {
+class AutoLoader<std::optional<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
-    return &static_cast<absl::optional<T>*>(dst)->emplace();
+    return &static_cast<std::optional<T>*>(dst)->emplace();
   }
   void Reset(void* dst) const final {
-    static_cast<absl::optional<T>*>(dst)->reset();
+    static_cast<std::optional<T>*>(dst)->reset();
   }
   const LoaderInterface* ElementLoader() const final {
     return LoaderForType<T>();
@@ -623,19 +623,19 @@ T LoadFromJson(const Json& json, const JsonArgs& args,
 }
 
 template <typename T>
-absl::optional<T> LoadJsonObjectField(const Json::Object& json,
-                                      const JsonArgs& args,
-                                      absl::string_view field,
-                                      ValidationErrors* errors,
-                                      bool required = true) {
+std::optional<T> LoadJsonObjectField(const Json::Object& json,
+                                     const JsonArgs& args,
+                                     absl::string_view field,
+                                     ValidationErrors* errors,
+                                     bool required = true) {
   ValidationErrors::ScopedField error_field(errors, absl::StrCat(".", field));
   const Json* field_json =
       json_detail::GetJsonObjectField(json, field, errors, required);
-  if (field_json == nullptr) return absl::nullopt;
+  if (field_json == nullptr) return std::nullopt;
   T result{};
   size_t starting_error_size = errors->size();
   json_detail::LoaderForType<T>()->LoadInto(*field_json, args, &result, errors);
-  if (errors->size() > starting_error_size) return absl::nullopt;
+  if (errors->size() > starting_error_size) return std::nullopt;
   return std::move(result);
 }
 

data/src/core/util/json/json_reader.cc

@@ -23,6 +23,7 @@
 #include <map>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/attributes.h"
@@ -33,7 +34,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/match.h"
 
@@ -94,7 +94,7 @@ class JsonReader {
 
   struct Scope {
     std::string parent_object_key;
-    absl::variant<Json::Object, Json::Array> data;
+    std::variant<Json::Object, Json::Array> data;
 
     Json::Type type() const {
       return Match(
@@ -295,7 +295,7 @@ void JsonReader::EndContainer() {
 void JsonReader::SetKey() {
   key_ = std::move(string_);
   string_.clear();
-  const Json::Object& object = absl::get<Json::Object>(stack_.back().data);
+  const Json::Object& object = std::get<Json::Object>(stack_.back().data);
   if (object.find(key_) != object.end()) {
     if (errors_.size() == GRPC_JSON_MAX_ERRORS) {
       truncated_errors_ = true;
@@ -434,7 +434,7 @@ JsonReader::Status JsonReader::Run() {
             }
             if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
             state_ = State::GRPC_JSON_STATE_VALUE_END;
-            ABSL_FALLTHROUGH_INTENDED;
+            [[fallthrough]];
 
           case State::GRPC_JSON_STATE_VALUE_END:
           case State::GRPC_JSON_STATE_OBJECT_KEY_BEGIN:

data/src/core/util/json/json_writer.cc

@@ -278,9 +278,9 @@ void JsonWriter::ValueString(const std::string& string) {
 
 void JsonWriter::DumpObject(const Json::Object& object) {
   ContainerBegins(Json::Type::kObject);
-  for (const auto& p : object) {
-    ObjectKey(p.first);
-    DumpValue(p.second);
+  for (const auto& [key, value] : object) {
+    ObjectKey(key);
+    DumpValue(value);
   }
   ContainerEnds(Json::Type::kObject);
 }

data/src/core/util/latent_see.cc

@@ -18,12 +18,12 @@
 #include <atomic>
 #include <chrono>
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/util/ring_buffer.h"
 #include "src/core/util/sync.h"
 
@@ -75,7 +75,7 @@ void Log::TryPullEventsAndFlush(
   mu_flushing_.Unlock();
 }
 
-absl::optional<std::string> Log::TryGenerateJson() {
+std::optional<std::string> Log::TryGenerateJson() {
   using Nanos = std::chrono::duration<unsigned long long, std::nano>;
   std::string json = "[\n";
   bool first = true;
@@ -137,7 +137,7 @@ absl::optional<std::string> Log::TryGenerateJson() {
                       ", \"batch\": ", event.batch_id, "}}");
     }
   });
-  if (callbacks == 0) return absl::nullopt;
+  if (callbacks == 0) return std::nullopt;
   absl::StrAppend(&json, "\n]");
   return json;
 }

data/src/core/util/latent_see.h

@@ -26,6 +26,7 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -35,7 +36,6 @@
 #include "absl/functional/function_ref.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/util/per_cpu.h"
 #include "src/core/util/sync.h"
 
@@ -144,7 +144,7 @@ class Log {
 
   void TryPullEventsAndFlush(
       absl::FunctionRef<void(absl::Span<const RecordedEvent>)> callback);
-  absl::optional<std::string> TryGenerateJson();
+  std::optional<std::string> TryGenerateJson();
 
   void OverrideStatsFlusher(
       absl::AnyInvocable<void(absl::string_view)> stats_exporter) {

data/src/core/util/linux/env.cc

@@ -23,10 +23,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
-
 #ifdef GPR_LINUX_ENV
 
 #include <features.h>
@@ -36,14 +35,14 @@
 
 namespace grpc_core {
 
-absl::optional<std::string> GetEnv(const char* name) {
+std::optional<std::string> GetEnv(const char* name) {
   char* result = nullptr;
 #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 17)
   result = secure_getenv(name);
 #else
   result = getenv(name);
 #endif
-  if (result == nullptr) return absl::nullopt;
+  if (result == nullptr) return std::nullopt;
   return result;
 }
 

data/src/core/util/lru_cache.h

@@ -18,13 +18,13 @@
 #define GRPC_SRC_CORE_UTIL_LRU_CACHE_H
 
 #include <list>
+#include <optional>
 #include <tuple>
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 
@@ -39,7 +39,7 @@ class LruCache {
   }
 
   // Returns the value for key, or nullopt if not present.
-  absl::optional<Value> Get(Key key);
+  std::optional<Value> Get(Key key);
 
   // If key is present in the cache, returns the corresponding value.
   // Otherwise, inserts a new entry in the map, calling create() to
@@ -72,9 +72,9 @@ class LruCache {
 //
 
 template <typename Key, typename Value>
-absl::optional<Value> LruCache<Key, Value>::Get(Key key) {
+std::optional<Value> LruCache<Key, Value>::Get(Key key) {
   auto it = cache_.find(key);
-  if (it == cache_.end()) return absl::nullopt;
+  if (it == cache_.end()) return std::nullopt;
   // Found the entry.  Move the entry to the end of the LRU list.
   auto new_lru_it = lru_list_.insert(lru_list_.end(), *it->second.lru_iterator);
   lru_list_.erase(it->second.lru_iterator);

data/src/core/util/match.h

@@ -18,8 +18,8 @@
 #include <grpc/support/port_platform.h>
 
 #include <utility>
+#include <variant>
 
-#include "absl/types/variant.h"
 #include "src/core/util/overload.h"
 
 namespace grpc_core {
@@ -47,9 +47,9 @@ struct MatchPointerExtractor {
 ///         [](int i) { puts("hoorah"); },
 ///         [](string s) { puts("boo"); });
 template <typename... Fs, typename T0, typename... Ts>
-auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
+auto Match(const std::variant<T0, Ts...>& value, Fs... fs)
     -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
-  return absl::visit(Overload(std::move(fs)...), value);
+  return std::visit(Overload(std::move(fs)...), value);
 }
 
 /// A version of Match that takes a mutable pointer to a variant and calls its
@@ -62,11 +62,11 @@ auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
 ///                [](string* s) { *s = "foo"; });
 ///   // v now contains 1.
 template <typename... Fs, typename T0, typename... Ts>
-auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
+auto MatchMutable(std::variant<T0, Ts...>* value, Fs... fs)
     -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
-  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
-                         std::move(fs)...)},
-                     *value);
+  return std::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
+                        std::move(fs)...)},
+                    *value);
 }
 
 }  // namespace grpc_core

data/src/core/util/matchers.cc

@@ -294,8 +294,7 @@ bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
   }
 }
 
-bool HeaderMatcher::Match(
-    const absl::optional<absl::string_view>& value) const {
+bool HeaderMatcher::Match(const std::optional<absl::string_view>& value) const {
   bool match;
   if (type_ == Type::kPresent) {
     match = value.has_value() == present_match_;

data/src/core/util/matchers.h

@@ -19,11 +19,11 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "re2/re2.h"
 
 namespace grpc_core {
@@ -134,7 +134,7 @@ class HeaderMatcher {
   // Valid for kSafeRegex.
   RE2* regex_matcher() const { return matcher_.regex_matcher(); }
 
-  bool Match(const absl::optional<absl::string_view>& value) const;
+  bool Match(const std::optional<absl::string_view>& value) const;
 
   std::string ToString() const;
 

data/src/core/util/posix/env.cc

@@ -26,9 +26,9 @@
 
 namespace grpc_core {
 
-absl::optional<std::string> GetEnv(const char* name) {
+std::optional<std::string> GetEnv(const char* name) {
   char* result = getenv(name);
-  if (result == nullptr) return absl::nullopt;
+  if (result == nullptr) return std::nullopt;
   return result;
 }
 

data/src/core/util/posix/sync.cc

@@ -28,7 +28,6 @@
 #include <time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED

data/src/core/util/posix/time.cc

@@ -32,7 +32,6 @@
 #include <grpc/support/time.h>
 
 #include "absl/log/check.h"
-#include "src/core/util/crash.h"
 
 static struct timespec timespec_from_gpr(gpr_timespec gts) {
   struct timespec rv;

data/src/core/util/ring_buffer.h

@@ -20,8 +20,7 @@
 #include <array>
 #include <cstddef>
 #include <iterator>
-
-#include "absl/types/optional.h"
+#include <optional>
 
 namespace grpc_core {
 
@@ -93,9 +92,9 @@ class RingBuffer {
   }
 
   // Returns the data of the first element in the buffer and removes it from
-  // the buffer. If the buffer is empty, returns absl::nullopt.
-  absl::optional<T> PopIfNotEmpty() {
-    if (!size_) return absl::nullopt;
+  // the buffer. If the buffer is empty, returns std::nullopt.
+  std::optional<T> PopIfNotEmpty() {
+    if (!size_) return std::nullopt;
     T data = std::move(data_[head_]);
     --size_;
     head_ = (head_ + 1) % kCapacity;