diff --git a/envoy/api/io_error.h b/envoy/api/io_error.h
index ae03b17dad865..ebb4f99b79854 100644
--- a/envoy/api/io_error.h
+++ b/envoy/api/io_error.h
@@ -50,20 +50,21 @@ using IoErrorPtr = std::unique_ptr<IoError, IoErrorDeleterType>;
 /**
  * Basic type for return result which has a return code and error code defined
  * according to different implementations.
- * If the call succeeds, ok() should return true and |rc_| is valid. Otherwise |err_|
+ * If the call succeeds, ok() should return true and |return_value_| is valid. Otherwise |err_|
  * can be passed into IoError::getErrorCode() to extract the error. In this
- * case, |rc_| is invalid.
+ * case, |return_value_| is invalid.
  */
 template <typename ReturnValue> struct IoCallResult {
-  IoCallResult(ReturnValue rc, IoErrorPtr err) : rc_(rc), err_(std::move(err)) {}
+  IoCallResult(ReturnValue return_value, IoErrorPtr err)
+      : return_value_(return_value), err_(std::move(err)) {}
 
   IoCallResult(IoCallResult<ReturnValue>&& result) noexcept
-      : rc_(result.rc_), err_(std::move(result.err_)) {}
+      : return_value_(result.return_value_), err_(std::move(result.err_)) {}
 
   virtual ~IoCallResult() = default;
 
   IoCallResult& operator=(IoCallResult&& result) noexcept {
-    rc_ = result.rc_;
+    return_value_ = result.return_value_;
     err_ = std::move(result.err_);
     return *this;
   }
@@ -79,8 +80,7 @@ template <typename ReturnValue> struct IoCallResult {
    */
   bool wouldBlock() const { return !ok() && err_->getErrorCode() == IoError::IoErrorCode::Again; }
 
-  // TODO(danzh): rename it to be more meaningful, i.e. return_value_.
-  ReturnValue rc_;
+  ReturnValue return_value_;
   IoErrorPtr err_;
 };
 
diff --git a/envoy/api/os_sys_calls_common.h b/envoy/api/os_sys_calls_common.h
index c59469e53e6f4..e26bc125e3109 100644
--- a/envoy/api/os_sys_calls_common.h
+++ b/envoy/api/os_sys_calls_common.h
@@ -15,7 +15,7 @@ template <typename T> struct SysCallResult {
   /**
    * The return code from the system call.
    */
-  T rc_;
+  T return_value_;
 
   /**
    * The errno value as captured after the system call.
diff --git a/source/common/access_log/access_log_manager_impl.cc b/source/common/access_log/access_log_manager_impl.cc
index 9c5f83a189e74..5d50de4d74a5f 100644
--- a/source/common/access_log/access_log_manager_impl.cc
+++ b/source/common/access_log/access_log_manager_impl.cc
@@ -53,7 +53,7 @@ AccessLogFileImpl::AccessLogFileImpl(Filesystem::FilePtr&& file, Event::Dispatch
       thread_factory_(thread_factory), flush_interval_msec_(flush_interval_msec), stats_(stats) {
   flush_timer_->enableTimer(flush_interval_msec_);
   auto open_result = open();
-  if (!open_result.rc_) {
+  if (!open_result.return_value_) {
     throw EnvoyException(fmt::format("unable to open file '{}': {}", file_->path(),
                                      open_result.err_->getErrorDetails()));
   }
@@ -91,8 +91,8 @@ AccessLogFileImpl::~AccessLogFileImpl() {
       doWrite(flush_buffer_);
     }
     const Api::IoCallBoolResult result = file_->close();
-    ASSERT(result.rc_, fmt::format("unable to close file '{}': {}", file_->path(),
-                                   result.err_->getErrorDetails()));
+    ASSERT(result.return_value_, fmt::format("unable to close file '{}': {}", file_->path(),
+                                             result.err_->getErrorDetails()));
   }
 }
 
@@ -112,7 +112,7 @@ void AccessLogFileImpl::doWrite(Buffer::Instance& buffer) {
     for (const Buffer::RawSlice& slice : slices) {
       absl::string_view data(static_cast<char*>(slice.mem_), slice.len_);
       const Api::IoCallSizeResult result = file_->write(data);
-      if (result.ok() && result.rc_ == static_cast<ssize_t>(slice.len_)) {
+      if (result.ok() && result.return_value_ == static_cast<ssize_t>(slice.len_)) {
         stats_.write_completed_.inc();
       } else {
         // Probably disk full.
@@ -154,10 +154,10 @@ void AccessLogFileImpl::flushThreadFunc() {
       if (reopen_file_) {
         reopen_file_ = false;
         const Api::IoCallBoolResult result = file_->close();
-        ASSERT(result.rc_, fmt::format("unable to close file '{}': {}", file_->path(),
-                                       result.err_->getErrorDetails()));
+        ASSERT(result.return_value_, fmt::format("unable to close file '{}': {}", file_->path(),
+                                                 result.err_->getErrorDetails()));
         const Api::IoCallBoolResult open_result = open();
-        if (!open_result.rc_) {
+        if (!open_result.return_value_) {
           stats_.reopen_failed_.inc();
           return;
         }
diff --git a/source/common/api/win32/os_sys_calls_impl.cc b/source/common/api/win32/os_sys_calls_impl.cc
index d534e5e07cd02..3766c54a2100c 100644
--- a/source/common/api/win32/os_sys_calls_impl.cc
+++ b/source/common/api/win32/os_sys_calls_impl.cc
@@ -279,11 +279,11 @@ SysCallIntResult OsSysCallsImpl::socketpair(int domain, int type, int protocol,
   sv[0] = sv[1] = INVALID_SOCKET;
 
   SysCallSocketResult socket_result = socket(domain, type, protocol);
-  if (SOCKET_INVALID(socket_result.rc_)) {
+  if (SOCKET_INVALID(socket_result.return_value_)) {
     return {SOCKET_ERROR, socket_result.errno_};
   }
 
-  os_fd_t listener = socket_result.rc_;
+  os_fd_t listener = socket_result.return_value_;
 
   typedef union {
     struct sockaddr_storage sa;
@@ -313,44 +313,44 @@ SysCallIntResult OsSysCallsImpl::socketpair(int domain, int type, int protocol,
   };
 
   SysCallIntResult int_result = bind(listener, reinterpret_cast<sockaddr*>(&a), sa_size);
-  if (int_result.rc_ == SOCKET_ERROR) {
+  if (int_result.return_value_ == SOCKET_ERROR) {
     onErr();
     return int_result;
   }
 
   int_result = listen(listener, 1);
-  if (int_result.rc_ == SOCKET_ERROR) {
+  if (int_result.return_value_ == SOCKET_ERROR) {
     onErr();
     return int_result;
   }
 
   socket_result = socket(domain, type, protocol);
-  if (SOCKET_INVALID(socket_result.rc_)) {
+  if (SOCKET_INVALID(socket_result.return_value_)) {
     onErr();
     return {SOCKET_ERROR, socket_result.errno_};
   }
-  sv[0] = socket_result.rc_;
+  sv[0] = socket_result.return_value_;
 
   a = {};
   int_result = getsockname(listener, reinterpret_cast<sockaddr*>(&a), &sa_size);
-  if (int_result.rc_ == SOCKET_ERROR) {
+  if (int_result.return_value_ == SOCKET_ERROR) {
     onErr();
     return int_result;
   }
 
   int_result = connect(sv[0], reinterpret_cast<sockaddr*>(&a), sa_size);
-  if (int_result.rc_ == SOCKET_ERROR) {
+  if (int_result.return_value_ == SOCKET_ERROR) {
     onErr();
     return int_result;
   }
 
-  socket_result.rc_ = ::accept(listener, nullptr, nullptr);
-  if (SOCKET_INVALID(socket_result.rc_)) {
+  socket_result.return_value_ = ::accept(listener, nullptr, nullptr);
+  if (SOCKET_INVALID(socket_result.return_value_)) {
     socket_result.errno_ = ::WSAGetLastError();
     onErr();
     return {SOCKET_ERROR, socket_result.errno_};
   }
-  sv[1] = socket_result.rc_;
+  sv[1] = socket_result.return_value_;
 
   ::closesocket(listener);
   return {0, 0};
diff --git a/source/common/event/win32/signal_impl.cc b/source/common/event/win32/signal_impl.cc
index d2a96b0de6fe3..0466ee6b732f0 100644
--- a/source/common/event/win32/signal_impl.cc
+++ b/source/common/event/win32/signal_impl.cc
@@ -21,14 +21,14 @@ SignalEventImpl::SignalEventImpl(DispatcherImpl& dispatcher, signal_t signal_num
   os_fd_t socks[2];
   Api::SysCallIntResult result =
       Api::OsSysCallsSingleton::get().socketpair(AF_INET, SOCK_STREAM, IPPROTO_TCP, socks);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
 
   read_handle_ = std::make_unique<Network::IoSocketHandleImpl>(socks[0], false, AF_INET);
   result = read_handle_->setBlocking(false);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
   auto write_handle = std::make_shared<Network::IoSocketHandleImpl>(socks[1], false, AF_INET);
   result = write_handle->setBlocking(false);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
 
   read_handle_->initializeFileEvent(
       dispatcher,
diff --git a/source/common/filesystem/posix/directory_iterator_impl.cc b/source/common/filesystem/posix/directory_iterator_impl.cc
index 65c1fe2bd7dfe..eb760c76cfdfd 100644
--- a/source/common/filesystem/posix/directory_iterator_impl.cc
+++ b/source/common/filesystem/posix/directory_iterator_impl.cc
@@ -55,7 +55,7 @@ FileType DirectoryIteratorImpl::fileType(const std::string& full_path,
   struct stat stat_buf;
 
   const Api::SysCallIntResult result = os_sys_calls.stat(full_path.c_str(), &stat_buf);
-  if (result.rc_ != 0) {
+  if (result.return_value_ != 0) {
     if (errno == ENOENT) {
       // Special case. This directory entity is likely to be a symlink,
       // but the reference is broken as the target could not be stat()'ed.
diff --git a/source/common/filesystem/posix/filesystem_impl.cc b/source/common/filesystem/posix/filesystem_impl.cc
index c89cacd6dafb4..95e103c7f3c74 100644
--- a/source/common/filesystem/posix/filesystem_impl.cc
+++ b/source/common/filesystem/posix/filesystem_impl.cc
@@ -25,8 +25,9 @@ namespace Filesystem {
 
 FileImplPosix::~FileImplPosix() {
   if (isOpen()) {
+    // NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
     const Api::IoCallBoolResult result = close();
-    ASSERT(result.rc_);
+    ASSERT(result.return_value_);
   }
 }
 
@@ -152,7 +153,7 @@ bool InstanceImplPosix::illegalPath(const std::string& path) {
   }
 
   const Api::SysCallStringResult canonical_path = canonicalPath(path);
-  if (canonical_path.rc_.empty()) {
+  if (canonical_path.return_value_.empty()) {
     ENVOY_LOG_MISC(debug, "Unable to determine canonical path for {}: {}", path,
                    errorDetails(canonical_path.errno_));
     return true;
@@ -163,9 +164,9 @@ bool InstanceImplPosix::illegalPath(const std::string& path) {
   // platform in the future, growing these or relaxing some constraints (e.g.
   // there are valid reasons to go via /proc for file paths).
   // TODO(htuch): Optimize this as a hash lookup if we grow any further.
-  if (absl::StartsWith(canonical_path.rc_, "/dev") ||
-      absl::StartsWith(canonical_path.rc_, "/sys") ||
-      absl::StartsWith(canonical_path.rc_, "/proc")) {
+  if (absl::StartsWith(canonical_path.return_value_, "/dev") ||
+      absl::StartsWith(canonical_path.return_value_, "/sys") ||
+      absl::StartsWith(canonical_path.return_value_, "/proc")) {
     return true;
   }
   return false;
diff --git a/source/common/filesystem/win32/filesystem_impl.cc b/source/common/filesystem/win32/filesystem_impl.cc
index 9ec504375951d..0be9c219ef6b9 100644
--- a/source/common/filesystem/win32/filesystem_impl.cc
+++ b/source/common/filesystem/win32/filesystem_impl.cc
@@ -22,7 +22,7 @@ namespace Filesystem {
 FileImplWin32::~FileImplWin32() {
   if (isOpen()) {
     const Api::IoCallBoolResult result = close();
-    ASSERT(result.rc_);
+    ASSERT(result.return_value_);
   }
 }
 
diff --git a/source/common/filesystem/win32/watcher_impl.cc b/source/common/filesystem/win32/watcher_impl.cc
index e4a3dd7e87f9e..ed89d98ceba95 100644
--- a/source/common/filesystem/win32/watcher_impl.cc
+++ b/source/common/filesystem/win32/watcher_impl.cc
@@ -11,14 +11,14 @@ WatcherImpl::WatcherImpl(Event::Dispatcher& dispatcher, Api::Api& api)
     : api_(api), os_sys_calls_(Api::OsSysCallsSingleton::get()) {
   os_fd_t socks[2];
   Api::SysCallIntResult result = os_sys_calls_.socketpair(AF_INET, SOCK_STREAM, IPPROTO_TCP, socks);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
 
   read_handle_ = std::make_unique<Network::IoSocketHandleImpl>(socks[0], false, AF_INET);
   result = read_handle_->setBlocking(false);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
   write_handle_ = std::make_unique<Network::IoSocketHandleImpl>(socks[1], false, AF_INET);
   result = write_handle_->setBlocking(false);
-  ASSERT(result.rc_ == 0);
+  ASSERT(result.return_value_ == 0);
 
   read_handle_->initializeFileEvent(
       dispatcher,
@@ -154,7 +154,7 @@ void WatcherImpl::endDirectoryWatch(Network::IoHandle& io_handle, HANDLE event_h
   constexpr absl::string_view data{"a"};
   buffer.add(data);
   auto result = io_handle.write(buffer);
-  RELEASE_ASSERT(result.rc_ == 1,
+  RELEASE_ASSERT(result.return_value_ == 1,
                  fmt::format("failed to write 1 byte: {}", result.err_->getErrorDetails()));
 }
 
@@ -207,7 +207,7 @@ void WatcherImpl::directoryChangeCompletion(DWORD err, DWORD num_bytes, LPOVERLA
         // not in this completion routine
         Buffer::RawSlice buffer{(void*)data.data(), 1};
         auto result = watcher->write_handle_->writev(&buffer, 1);
-        RELEASE_ASSERT(result.rc_ == 1,
+        RELEASE_ASSERT(result.return_value_ == 1,
                        fmt::format("failed to write 1 byte: {}", result.err_->getErrorDetails()));
       }
     }
diff --git a/source/common/formatter/substitution_formatter.cc b/source/common/formatter/substitution_formatter.cc
index e1001871f038f..a50fef64617a8 100644
--- a/source/common/formatter/substitution_formatter.cc
+++ b/source/common/formatter/substitution_formatter.cc
@@ -93,7 +93,7 @@ const absl::optional<std::string> SubstitutionFormatUtils::getHostname() {
   const Api::SysCallIntResult result = os_sys_calls.gethostname(name, len);
 
   absl::optional<std::string> hostname;
-  if (result.rc_ == 0) {
+  if (result.return_value_ == 0) {
     hostname = name;
   }
 
diff --git a/source/common/network/connection_impl.cc b/source/common/network/connection_impl.cc
index cf9b86f35f72e..5325dab742648 100644
--- a/source/common/network/connection_impl.cc
+++ b/source/common/network/connection_impl.cc
@@ -288,13 +288,13 @@ void ConnectionImpl::noDelay(bool enable) {
   Api::SysCallIntResult result =
       socket_->setSocketOption(IPPROTO_TCP, TCP_NODELAY, &new_value, sizeof(new_value));
 #if defined(__APPLE__)
-  if (SOCKET_FAILURE(result.rc_) && result.errno_ == SOCKET_ERROR_INVAL) {
+  if (SOCKET_FAILURE(result.return_value_) && result.errno_ == SOCKET_ERROR_INVAL) {
     // Sometimes occurs when the connection is not yet fully formed. Empirically, TCP_NODELAY is
     // enabled despite this result.
     return;
   }
 #elif defined(WIN32)
-  if (SOCKET_FAILURE(result.rc_) &&
+  if (SOCKET_FAILURE(result.return_value_) &&
       (result.errno_ == SOCKET_ERROR_AGAIN || result.errno_ == SOCKET_ERROR_INVAL)) {
     // Sometimes occurs when the connection is not yet fully formed. Empirically, TCP_NODELAY is
     // enabled despite this result.
@@ -302,8 +302,9 @@ void ConnectionImpl::noDelay(bool enable) {
   }
 #endif
 
-  RELEASE_ASSERT(result.rc_ == 0, fmt::format("Failed to set TCP_NODELAY with error {}, {}",
-                                              result.errno_, errorDetails(result.errno_)));
+  RELEASE_ASSERT(result.return_value_ == 0,
+                 fmt::format("Failed to set TCP_NODELAY with error {}, {}", result.errno_,
+                             errorDetails(result.errno_)));
 }
 
 void ConnectionImpl::onRead(uint64_t read_buffer_size) {
@@ -648,7 +649,7 @@ ConnectionImpl::unixSocketPeerCredentials() const {
 #else
   struct ucred ucred;
   socklen_t ucred_size = sizeof(ucred);
-  int rc = socket_->getSocketOption(SOL_SOCKET, SO_PEERCRED, &ucred, &ucred_size).rc_;
+  int rc = socket_->getSocketOption(SOL_SOCKET, SO_PEERCRED, &ucred, &ucred_size).return_value_;
   if (SOCKET_FAILURE(rc)) {
     return absl::nullopt;
   }
@@ -663,8 +664,8 @@ void ConnectionImpl::onWriteReady() {
   if (connecting_) {
     int error;
     socklen_t error_size = sizeof(error);
-    RELEASE_ASSERT(socket_->getSocketOption(SOL_SOCKET, SO_ERROR, &error, &error_size).rc_ == 0,
-                   "");
+    RELEASE_ASSERT(
+        socket_->getSocketOption(SOL_SOCKET, SO_ERROR, &error, &error_size).return_value_ == 0, "");
 
     if (error == 0) {
       ENVOY_CONN_LOG(debug, "connected", *this);
@@ -846,7 +847,7 @@ ClientConnectionImpl::ClientConnectionImpl(
 
   if (*source != nullptr) {
     Api::SysCallIntResult result = socket_->bind(*source);
-    if (result.rc_ < 0) {
+    if (result.return_value_ < 0) {
       // TODO(lizan): consider add this error into transportFailureReason.
       ENVOY_LOG_MISC(debug, "Bind failure. Failed to bind to {}: {}", source->get()->asString(),
                      errorDetails(result.errno_));
@@ -865,13 +866,13 @@ void ClientConnectionImpl::connect() {
   ENVOY_CONN_LOG(debug, "connecting to {}", *this,
                  socket_->addressProvider().remoteAddress()->asString());
   const Api::SysCallIntResult result = socket_->connect(socket_->addressProvider().remoteAddress());
-  if (result.rc_ == 0) {
+  if (result.return_value_ == 0) {
     // write will become ready.
     ASSERT(connecting_);
     return;
   }
 
-  ASSERT(SOCKET_FAILURE(result.rc_));
+  ASSERT(SOCKET_FAILURE(result.return_value_));
 #ifdef WIN32
   // winsock2 connect returns EWOULDBLOCK if the socket is non-blocking and the connection
   // cannot be completed immediately. We do not check for `EINPROGRESS` as that error is for
diff --git a/source/common/network/io_socket_handle_impl.cc b/source/common/network/io_socket_handle_impl.cc
index 8f2d2e0b56872..452f57711b5e4 100644
--- a/source/common/network/io_socket_handle_impl.cc
+++ b/source/common/network/io_socket_handle_impl.cc
@@ -74,7 +74,7 @@ Api::IoCallUint64Result IoSocketHandleImpl::close() {
   }
 
   ASSERT(SOCKET_VALID(fd_));
-  const int rc = Api::OsSysCallsSingleton::get().close(fd_).rc_;
+  const int rc = Api::OsSysCallsSingleton::get().close(fd_).return_value_;
   SET_SOCKET_INVALID(fd_);
   return Api::IoCallUint64Result(rc, Api::IoErrorPtr(nullptr, IoSocketError::deleteIoError));
 }
@@ -117,7 +117,7 @@ Api::IoCallUint64Result IoSocketHandleImpl::read(Buffer::Instance& buffer,
   Buffer::Reservation reservation = buffer.reserveForRead();
   Api::IoCallUint64Result result = readv(std::min(reservation.length(), max_length),
                                          reservation.slices(), reservation.numSlices());
-  uint64_t bytes_to_commit = result.ok() ? result.rc_ : 0;
+  uint64_t bytes_to_commit = result.ok() ? result.return_value_ : 0;
   ASSERT(bytes_to_commit <= max_length);
   reservation.commit(bytes_to_commit);
 
@@ -164,8 +164,8 @@ Api::IoCallUint64Result IoSocketHandleImpl::write(Buffer::Instance& buffer) {
   constexpr uint64_t MaxSlices = 16;
   Buffer::RawSliceVector slices = buffer.getRawSlices(MaxSlices);
   Api::IoCallUint64Result result = writev(slices.begin(), slices.size());
-  if (result.ok() && result.rc_ > 0) {
-    buffer.drain(static_cast<uint64_t>(result.rc_));
+  if (result.ok() && result.return_value_ > 0) {
+    buffer.drain(static_cast<uint64_t>(result.return_value_));
   }
 
   // Emulated edge events need to registered if the socket operation did not complete
@@ -342,7 +342,7 @@ Api::IoCallUint64Result IoSocketHandleImpl::recvmsg(Buffer::RawSlice* slices,
   hdr.msg_controllen = cmsg_space_;
   Api::SysCallSizeResult result =
       Api::OsSysCallsSingleton::get().recvmsg(fd_, &hdr, messageTruncatedOption());
-  if (result.rc_ < 0) {
+  if (result.return_value_ < 0) {
     auto io_result = sysCallResultToIoCallResult(result);
     // Emulated edge events need to registered if the socket operation did not complete
     // because the socket would block.
@@ -354,8 +354,8 @@ Api::IoCallUint64Result IoSocketHandleImpl::recvmsg(Buffer::RawSlice* slices,
     return io_result;
   }
   if ((hdr.msg_flags & MSG_TRUNC) != 0) {
-    ENVOY_LOG_MISC(debug, "Dropping truncated UDP packet with size: {}.", result.rc_);
-    result.rc_ = 0;
+    ENVOY_LOG_MISC(debug, "Dropping truncated UDP packet with size: {}.", result.return_value_);
+    result.return_value_ = 0;
     (*output.dropped_packets_)++;
     output.msg_[0].truncated_and_dropped_ = true;
     return sysCallResultToIoCallResult(result);
@@ -441,7 +441,7 @@ Api::IoCallUint64Result IoSocketHandleImpl::recvmmsg(RawSliceArrays& slices, uin
       Api::OsSysCallsSingleton::get().recvmmsg(fd_, mmsg_hdr.data(), num_packets_per_mmsg_call,
                                                messageTruncatedOption() | MSG_WAITFORONE, nullptr);
 
-  if (result.rc_ <= 0) {
+  if (result.return_value_ <= 0) {
     auto io_result = sysCallResultToIoCallResult(result);
     // Emulated edge events need to registered if the socket operation did not complete
     // because the socket would block.
@@ -453,7 +453,7 @@ Api::IoCallUint64Result IoSocketHandleImpl::recvmmsg(RawSliceArrays& slices, uin
     return io_result;
   }
 
-  int num_packets_read = result.rc_;
+  int num_packets_read = result.return_value_;
 
   for (int i = 0; i < num_packets_read; ++i) {
     msghdr& hdr = mmsg_hdr[i].msg_hdr;
@@ -533,11 +533,11 @@ Api::SysCallIntResult IoSocketHandleImpl::listen(int backlog) {
 
 IoHandlePtr IoSocketHandleImpl::accept(struct sockaddr* addr, socklen_t* addrlen) {
   auto result = Api::OsSysCallsSingleton::get().accept(fd_, addr, addrlen);
-  if (SOCKET_INVALID(result.rc_)) {
+  if (SOCKET_INVALID(result.return_value_)) {
     return nullptr;
   }
 
-  return std::make_unique<IoSocketHandleImpl>(result.rc_, socket_v6only_, domain_);
+  return std::make_unique<IoSocketHandleImpl>(result.return_value_, socket_v6only_, domain_);
 }
 
 Api::SysCallIntResult IoSocketHandleImpl::connect(Address::InstanceConstSharedPtr address) {
@@ -568,9 +568,10 @@ Api::SysCallIntResult IoSocketHandleImpl::setBlocking(bool blocking) {
 
 IoHandlePtr IoSocketHandleImpl::duplicate() {
   auto result = Api::OsSysCallsSingleton::get().duplicate(fd_);
-  RELEASE_ASSERT(result.rc_ != -1, fmt::format("duplicate failed for '{}': ({}) {}", fd_,
-                                               result.errno_, errorDetails(result.errno_)));
-  return std::make_unique<IoSocketHandleImpl>(result.rc_, socket_v6only_, domain_);
+  RELEASE_ASSERT(result.return_value_ != -1,
+                 fmt::format("duplicate failed for '{}': ({}) {}", fd_, result.errno_,
+                             errorDetails(result.errno_)));
+  return std::make_unique<IoSocketHandleImpl>(result.return_value_, socket_v6only_, domain_);
 }
 
 absl::optional<int> IoSocketHandleImpl::domain() { return domain_; }
@@ -581,7 +582,7 @@ Address::InstanceConstSharedPtr IoSocketHandleImpl::localAddress() {
   auto& os_sys_calls = Api::OsSysCallsSingleton::get();
   Api::SysCallIntResult result =
       os_sys_calls.getsockname(fd_, reinterpret_cast<sockaddr*>(&ss), &ss_len);
-  if (result.rc_ != 0) {
+  if (result.return_value_ != 0) {
     throw EnvoyException(fmt::format("getsockname failed for '{}': ({}) {}", fd_, result.errno_,
                                      errorDetails(result.errno_)));
   }
@@ -594,7 +595,7 @@ Address::InstanceConstSharedPtr IoSocketHandleImpl::peerAddress() {
   auto& os_sys_calls = Api::OsSysCallsSingleton::get();
   Api::SysCallIntResult result =
       os_sys_calls.getpeername(fd_, reinterpret_cast<sockaddr*>(&ss), &ss_len);
-  if (result.rc_ != 0) {
+  if (result.return_value_ != 0) {
     throw EnvoyException(
         fmt::format("getpeername failed for '{}': {}", errorDetails(result.errno_)));
   }
@@ -605,7 +606,7 @@ Address::InstanceConstSharedPtr IoSocketHandleImpl::peerAddress() {
     // mechanisms to hide things, of which there are many).
     ss_len = sizeof ss;
     result = os_sys_calls.getsockname(fd_, reinterpret_cast<sockaddr*>(&ss), &ss_len);
-    if (result.rc_ != 0) {
+    if (result.return_value_ != 0) {
       throw EnvoyException(
           fmt::format("getsockname failed for '{}': {}", fd_, errorDetails(result.errno_)));
     }
@@ -643,7 +644,7 @@ Api::SysCallIntResult IoSocketHandleImpl::shutdown(int how) {
 absl::optional<std::chrono::milliseconds> IoSocketHandleImpl::lastRoundTripTime() {
   Api::EnvoyTcpInfo info;
   auto result = Api::OsSysCallsSingleton::get().socketTcpInfo(fd_, &info);
-  if (!result.rc_) {
+  if (!result.return_value_) {
     return {};
   }
   return std::chrono::duration_cast<std::chrono::milliseconds>(info.tcpi_rtt);
diff --git a/source/common/network/io_socket_handle_impl.h b/source/common/network/io_socket_handle_impl.h
index 398ab1f554f5f..ae4129de73e5a 100644
--- a/source/common/network/io_socket_handle_impl.h
+++ b/source/common/network/io_socket_handle_impl.h
@@ -85,9 +85,9 @@ class IoSocketHandleImpl : public IoHandle, protected Logger::Loggable<Logger::I
   // Converts a SysCallSizeResult to IoCallUint64Result.
   template <typename T>
   Api::IoCallUint64Result sysCallResultToIoCallResult(const Api::SysCallResult<T>& result) {
-    if (result.rc_ >= 0) {
+    if (result.return_value_ >= 0) {
       // Return nullptr as IoError upon success.
-      return Api::IoCallUint64Result(result.rc_,
+      return Api::IoCallUint64Result(result.return_value_,
                                      Api::IoErrorPtr(nullptr, IoSocketError::deleteIoError));
     }
     RELEASE_ASSERT(result.errno_ != SOCKET_ERROR_INVAL, "Invalid argument passed in.");
diff --git a/source/common/network/listen_socket_impl.cc b/source/common/network/listen_socket_impl.cc
index 283ef3fac76de..4c91190581e7c 100644
--- a/source/common/network/listen_socket_impl.cc
+++ b/source/common/network/listen_socket_impl.cc
@@ -22,7 +22,7 @@ Api::SysCallIntResult ListenSocketImpl::bind(Network::Address::InstanceConstShar
   address_provider_->setLocalAddress(address);
 
   const Api::SysCallIntResult result = SocketImpl::bind(address_provider_->localAddress());
-  if (SOCKET_FAILURE(result.rc_)) {
+  if (SOCKET_FAILURE(result.return_value_)) {
     close();
     throw SocketBindException(fmt::format("cannot bind '{}': {}",
                                           address_provider_->localAddress()->asString(),
diff --git a/source/common/network/listen_socket_impl.h b/source/common/network/listen_socket_impl.h
index b3f10a13c14d7..08eb48d0f2fbc 100644
--- a/source/common/network/listen_socket_impl.h
+++ b/source/common/network/listen_socket_impl.h
@@ -108,7 +108,7 @@ template <typename T> class NetworkListenSocket : public ListenSocketImpl {
 #ifndef WIN32
     int on = 1;
     auto status = setSocketOption(SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
-    RELEASE_ASSERT(status.rc_ != -1, "failed to set SO_REUSEADDR socket option");
+    RELEASE_ASSERT(status.return_value_ != -1, "failed to set SO_REUSEADDR socket option");
 #endif
   }
 };
diff --git a/source/common/network/raw_buffer_socket.cc b/source/common/network/raw_buffer_socket.cc
index 788cdc7b1d38e..447da05eeb53c 100644
--- a/source/common/network/raw_buffer_socket.cc
+++ b/source/common/network/raw_buffer_socket.cc
@@ -21,13 +21,13 @@ IoResult RawBufferSocket::doRead(Buffer::Instance& buffer) {
     Api::IoCallUint64Result result = callbacks_->ioHandle().read(buffer, absl::nullopt);
 
     if (result.ok()) {
-      ENVOY_CONN_LOG(trace, "read returns: {}", callbacks_->connection(), result.rc_);
-      if (result.rc_ == 0) {
+      ENVOY_CONN_LOG(trace, "read returns: {}", callbacks_->connection(), result.return_value_);
+      if (result.return_value_ == 0) {
         // Remote close.
         end_stream = true;
         break;
       }
-      bytes_read += result.rc_;
+      bytes_read += result.return_value_;
       if (callbacks_->shouldDrainReadBuffer()) {
         callbacks_->setTransportSocketIsReadable();
         break;
@@ -64,8 +64,8 @@ IoResult RawBufferSocket::doWrite(Buffer::Instance& buffer, bool end_stream) {
     Api::IoCallUint64Result result = callbacks_->ioHandle().write(buffer);
 
     if (result.ok()) {
-      ENVOY_CONN_LOG(trace, "write returns: {}", callbacks_->connection(), result.rc_);
-      bytes_written += result.rc_;
+      ENVOY_CONN_LOG(trace, "write returns: {}", callbacks_->connection(), result.return_value_);
+      bytes_written += result.return_value_;
     } else {
       ENVOY_CONN_LOG(trace, "write error: {}", callbacks_->connection(),
                      result.err_->getErrorDetails());
diff --git a/source/common/network/socket_impl.cc b/source/common/network/socket_impl.cc
index 08505cb65b0a4..76d1bd47c37cf 100644
--- a/source/common/network/socket_impl.cc
+++ b/source/common/network/socket_impl.cc
@@ -56,9 +56,9 @@ Api::SysCallIntResult SocketImpl::bind(Network::Address::InstanceConstSharedPtr
     }
     // Not storing a reference to syscalls singleton because of unit test mocks
     bind_result = io_handle_->bind(address);
-    if (pipe->mode() != 0 && !abstract_namespace && bind_result.rc_ == 0) {
+    if (pipe->mode() != 0 && !abstract_namespace && bind_result.return_value_ == 0) {
       auto set_permissions = Api::OsSysCallsSingleton::get().chmod(pipe_sa->sun_path, pipe->mode());
-      if (set_permissions.rc_ != 0) {
+      if (set_permissions.return_value_ != 0) {
         throw EnvoyException(fmt::format("Failed to create socket with mode {}: {}",
                                          std::to_string(pipe->mode()),
                                          errorDetails(set_permissions.errno_)));
@@ -68,7 +68,7 @@ Api::SysCallIntResult SocketImpl::bind(Network::Address::InstanceConstSharedPtr
   }
 
   bind_result = io_handle_->bind(address);
-  if (bind_result.rc_ == 0 && address->ip()->port() == 0) {
+  if (bind_result.return_value_ == 0 && address->ip()->port() == 0) {
     address_provider_->setLocalAddress(io_handle_->localAddress());
   }
   return bind_result;
diff --git a/source/common/network/socket_interface_impl.cc b/source/common/network/socket_interface_impl.cc
index 4847161321e5e..1d87e3295ee9c 100644
--- a/source/common/network/socket_interface_impl.cc
+++ b/source/common/network/socket_interface_impl.cc
@@ -47,13 +47,13 @@ IoHandlePtr SocketInterfaceImpl::socket(Socket::Type socket_type, Address::Type
   }
 
   const Api::SysCallSocketResult result = Api::OsSysCallsSingleton::get().socket(domain, flags, 0);
-  RELEASE_ASSERT(SOCKET_VALID(result.rc_),
+  RELEASE_ASSERT(SOCKET_VALID(result.return_value_),
                  fmt::format("socket(2) failed, got error: {}", errorDetails(result.errno_)));
-  IoHandlePtr io_handle = makeSocket(result.rc_, socket_v6only, domain);
+  IoHandlePtr io_handle = makeSocket(result.return_value_, socket_v6only, domain);
 
 #if defined(__APPLE__) || defined(WIN32)
   // Cannot set SOCK_NONBLOCK as a ::socket flag.
-  const int rc = io_handle->setBlocking(false).rc_;
+  const int rc = io_handle->setBlocking(false).return_value_;
   RELEASE_ASSERT(!SOCKET_FAILURE(rc), "");
 #endif
 
@@ -74,7 +74,7 @@ IoHandlePtr SocketInterfaceImpl::socket(Socket::Type socket_type,
     // Setting IPV6_V6ONLY restricts the IPv6 socket to IPv6 connections only.
     const Api::SysCallIntResult result = io_handle->setOption(
         IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char*>(&v6only), sizeof(v6only));
-    RELEASE_ASSERT(!SOCKET_FAILURE(result.rc_), "");
+    RELEASE_ASSERT(!SOCKET_FAILURE(result.return_value_), "");
   }
   return io_handle;
 }
@@ -82,11 +82,12 @@ IoHandlePtr SocketInterfaceImpl::socket(Socket::Type socket_type,
 bool SocketInterfaceImpl::ipFamilySupported(int domain) {
   Api::OsSysCalls& os_sys_calls = Api::OsSysCallsSingleton::get();
   const Api::SysCallSocketResult result = os_sys_calls.socket(domain, SOCK_STREAM, 0);
-  if (SOCKET_VALID(result.rc_)) {
-    RELEASE_ASSERT(os_sys_calls.close(result.rc_).rc_ == 0,
-                   fmt::format("Fail to close fd: response code {}", errorDetails(result.rc_)));
+  if (SOCKET_VALID(result.return_value_)) {
+    RELEASE_ASSERT(
+        os_sys_calls.close(result.return_value_).return_value_ == 0,
+        fmt::format("Fail to close fd: response code {}", errorDetails(result.return_value_)));
   }
-  return SOCKET_VALID(result.rc_);
+  return SOCKET_VALID(result.return_value_);
 }
 
 Server::BootstrapExtensionPtr
diff --git a/source/common/network/socket_option_impl.cc b/source/common/network/socket_option_impl.cc
index 53d3bc8efd1ff..929979c8fa128 100644
--- a/source/common/network/socket_option_impl.cc
+++ b/source/common/network/socket_option_impl.cc
@@ -22,7 +22,7 @@ bool SocketOptionImpl::setOption(Socket& socket,
 
     const Api::SysCallIntResult result =
         SocketOptionImpl::setSocketOption(socket, optname_, value_.data(), value_.size());
-    if (result.rc_ != 0) {
+    if (result.return_value_ != 0) {
       ENVOY_LOG(warn, "Setting {} option on socket failed: {}", optname_.name(),
                 errorDetails(result.errno_));
       return false;
diff --git a/source/common/network/udp_listener_impl.cc b/source/common/network/udp_listener_impl.cc
index d21ebb0add8a8..f6dcb614d2788 100644
--- a/source/common/network/udp_listener_impl.cc
+++ b/source/common/network/udp_listener_impl.cc
@@ -112,9 +112,9 @@ Api::IoCallUint64Result UdpListenerImpl::send(const UdpSendData& send_data) {
   Api::IoCallUint64Result send_result =
       cb_.udpPacketWriter().writePacket(buffer, send_data.local_ip_, send_data.peer_address_);
 
-  // The send_result normalizes the rc_ value to 0 in error conditions.
+  // The send_result normalizes the return_value_ value to 0 in error conditions.
   // The drain call is hence 'safe' in success and failure cases.
-  buffer.drain(send_result.rc_);
+  buffer.drain(send_result.return_value_);
   return send_result;
 }
 
diff --git a/source/common/network/utility.cc b/source/common/network/utility.cc
index 08b830fd799ca..4145f3f4d5d68 100644
--- a/source/common/network/utility.cc
+++ b/source/common/network/utility.cc
@@ -110,7 +110,7 @@ Api::IoCallUint64Result receiveMessage(uint64_t max_rx_datagram_size, Buffer::In
   Api::IoCallUint64Result result = handle.recvmsg(&slice, 1, local_address.ip()->port(), output);
 
   if (result.ok()) {
-    reservation.commit(std::min(max_rx_datagram_size, result.rc_));
+    reservation.commit(std::min(max_rx_datagram_size, result.return_value_));
   }
 
   return result;
@@ -405,9 +405,10 @@ Address::InstanceConstSharedPtr Utility::getOriginalDst(Socket& sock) {
   int status;
 
   if (*ipVersion == Address::IpVersion::v4) {
-    status = sock.getSocketOption(SOL_IP, SO_ORIGINAL_DST, &orig_addr, &addr_len).rc_;
+    status = sock.getSocketOption(SOL_IP, SO_ORIGINAL_DST, &orig_addr, &addr_len).return_value_;
   } else {
-    status = sock.getSocketOption(SOL_IPV6, IP6T_SO_ORIGINAL_DST, &orig_addr, &addr_len).rc_;
+    status =
+        sock.getSocketOption(SOL_IPV6, IP6T_SO_ORIGINAL_DST, &orig_addr, &addr_len).return_value_;
   }
 
   if (status != 0) {
@@ -557,7 +558,7 @@ Api::IoCallUint64Result Utility::writeToSocket(IoHandle& handle, Buffer::RawSlic
            send_result.err_->getErrorCode() == Api::IoError::IoErrorCode::Interrupt);
 
   if (send_result.ok()) {
-    ENVOY_LOG_MISC(trace, "sendmsg bytes {}", send_result.rc_);
+    ENVOY_LOG_MISC(trace, "sendmsg bytes {}", send_result.return_value_);
   } else {
     ENVOY_LOG_MISC(debug, "sendmsg failed with error code {}: {}",
                    static_cast<int>(send_result.err_->getErrorCode()),
@@ -607,13 +608,14 @@ Api::IoCallUint64Result Utility::readFromSocket(IoHandle& handle,
     }
 
     const uint64_t gso_size = output.msg_[0].gso_size_;
-    ENVOY_LOG_MISC(trace, "gro recvmsg bytes {} with gso_size as {}", result.rc_, gso_size);
+    ENVOY_LOG_MISC(trace, "gro recvmsg bytes {} with gso_size as {}", result.return_value_,
+                   gso_size);
 
     // Skip gso segmentation and proceed as a single payload.
     if (gso_size == 0u) {
-      passPayloadToProcessor(result.rc_, std::move(buffer), std::move(output.msg_[0].peer_address_),
-                             std::move(output.msg_[0].local_address_), udp_packet_processor,
-                             receive_time);
+      passPayloadToProcessor(
+          result.return_value_, std::move(buffer), std::move(output.msg_[0].peer_address_),
+          std::move(output.msg_[0].local_address_), udp_packet_processor, receive_time);
       return result;
     }
 
@@ -662,7 +664,7 @@ Api::IoCallUint64Result Utility::readFromSocket(IoHandle& handle,
       return result;
     }
 
-    uint64_t packets_read = result.rc_;
+    uint64_t packets_read = result.return_value_;
     ENVOY_LOG_MISC(trace, "recvmmsg read {} packets", packets_read);
     for (uint64_t i = 0; i < packets_read; ++i) {
       if (output.msg_[i].truncated_and_dropped_) {
@@ -694,11 +696,11 @@ Api::IoCallUint64Result Utility::readFromSocket(IoHandle& handle,
     return result;
   }
 
-  ENVOY_LOG_MISC(trace, "recvmsg bytes {}", result.rc_);
+  ENVOY_LOG_MISC(trace, "recvmsg bytes {}", result.return_value_);
 
-  passPayloadToProcessor(result.rc_, std::move(buffer), std::move(output.msg_[0].peer_address_),
-                         std::move(output.msg_[0].local_address_), udp_packet_processor,
-                         receive_time);
+  passPayloadToProcessor(
+      result.return_value_, std::move(buffer), std::move(output.msg_[0].peer_address_),
+      std::move(output.msg_[0].local_address_), udp_packet_processor, receive_time);
   return result;
 }
 
diff --git a/source/common/network/win32_redirect_records_option_impl.cc b/source/common/network/win32_redirect_records_option_impl.cc
index 2786e85df1140..b6dfce8e54105 100644
--- a/source/common/network/win32_redirect_records_option_impl.cc
+++ b/source/common/network/win32_redirect_records_option_impl.cc
@@ -44,7 +44,7 @@ bool Win32RedirectRecordsOptionImpl::setOption(
         socket.ioctl(ENVOY_SIO_SET_WFP_CONNECTION_REDIRECT_RECORDS,
                      const_cast<void*>(reinterpret_cast<const void*>(redirect_records_.buf_)),
                      redirect_records_.buf_size_, nullptr, 0, &size);
-    if (result.rc_ != 0) {
+    if (result.return_value_ != 0) {
       ENVOY_LOG(warn, "Setting WFP records on socket failed: {}", errorDetails(result.errno_));
       return false;
     }
diff --git a/source/common/quic/envoy_quic_packet_writer.cc b/source/common/quic/envoy_quic_packet_writer.cc
index 5ee3b5da3a57f..6a3d358bae017 100644
--- a/source/common/quic/envoy_quic_packet_writer.cc
+++ b/source/common/quic/envoy_quic_packet_writer.cc
@@ -11,7 +11,7 @@ namespace {
 
 quic::WriteResult convertToQuicWriteResult(Api::IoCallUint64Result& result) {
   if (result.ok()) {
-    return {quic::WRITE_STATUS_OK, static_cast<int>(result.rc_)};
+    return {quic::WRITE_STATUS_OK, static_cast<int>(result.return_value_)};
   }
   quic::WriteStatus status = result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again
                                  ? quic::WRITE_STATUS_BLOCKED
diff --git a/source/exe/win32/platform_impl.cc b/source/exe/win32/platform_impl.cc
index 8b788a60e586d..7653541cafdcb 100644
--- a/source/exe/win32/platform_impl.cc
+++ b/source/exe/win32/platform_impl.cc
@@ -30,7 +30,7 @@ BOOL WINAPI CtrlHandler(DWORD fdwCtrlType) {
   char data[] = {'a'};
   Buffer::RawSlice buffer{data, 1};
   auto result = handler->writev(&buffer, 1);
-  RELEASE_ASSERT(result.rc_ == 1,
+  RELEASE_ASSERT(result.return_value_ == 1,
                  fmt::format("failed to write 1 byte: {}", result.err_->getErrorDetails()));
 
   if (fdwCtrlType == CTRL_LOGOFF_EVENT || fdwCtrlType == CTRL_SHUTDOWN_EVENT) {
diff --git a/source/exe/win32/service_base.cc b/source/exe/win32/service_base.cc
index 0c226a8acf637..1f553b2a37779 100644
--- a/source/exe/win32/service_base.cc
+++ b/source/exe/win32/service_base.cc
@@ -111,7 +111,7 @@ void ServiceBase::Stop(DWORD control) {
   char data[] = {'a'};
   Buffer::RawSlice buffer{data, 1};
   auto result = handler->writev(&buffer, 1);
-  RELEASE_ASSERT(result.rc_ == 1,
+  RELEASE_ASSERT(result.return_value_ == 1,
                  fmt::format("failed to write 1 byte: {}", result.err_->getErrorDetails()));
 }
 
diff --git a/source/extensions/filters/listener/http_inspector/http_inspector.cc b/source/extensions/filters/listener/http_inspector/http_inspector.cc
index 2a69f38c77714..59b28e1febcb3 100644
--- a/source/extensions/filters/listener/http_inspector/http_inspector.cc
+++ b/source/extensions/filters/listener/http_inspector/http_inspector.cc
@@ -98,7 +98,7 @@ Network::FilterStatus Filter::onAccept(Network::ListenerFilterCallbacks& cb) {
 
 ParseState Filter::onRead() {
   auto result = cb_->socket().ioHandle().recv(buf_, Config::MAX_INSPECT_SIZE, MSG_PEEK);
-  ENVOY_LOG(trace, "http inspector: recv: {}", result.rc_);
+  ENVOY_LOG(trace, "http inspector: recv: {}", result.return_value_);
   if (!result.ok()) {
     if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
       return ParseState::Continue;
@@ -108,7 +108,7 @@ ParseState Filter::onRead() {
   }
 
   const auto parse_state =
-      parseHttpHeader(absl::string_view(reinterpret_cast<const char*>(buf_), result.rc_));
+      parseHttpHeader(absl::string_view(reinterpret_cast<const char*>(buf_), result.return_value_));
   switch (parse_state) {
   case ParseState::Continue:
     // do nothing but wait for the next event
diff --git a/source/extensions/filters/listener/original_dst/original_dst.cc b/source/extensions/filters/listener/original_dst/original_dst.cc
index f1465fad803e2..1b737c2c2a1a4 100644
--- a/source/extensions/filters/listener/original_dst/original_dst.cc
+++ b/source/extensions/filters/listener/original_dst/original_dst.cc
@@ -38,7 +38,7 @@ Network::FilterStatus OriginalDstFilter::onAccept(Network::ListenerFilterCallbac
           auto status = socket.ioctl(SIO_QUERY_WFP_CONNECTION_REDIRECT_RECORDS, NULL, 0,
                                      redirect_records->buf_, sizeof(redirect_records->buf_),
                                      &redirect_records->buf_size_);
-          if (status.rc_ != 0) {
+          if (status.return_value_ != 0) {
             ENVOY_LOG(debug,
                       "closing connection: cannot broker connection to original destination "
                       "[Query redirect record failed] with error {}",
diff --git a/source/extensions/filters/listener/proxy_protocol/proxy_protocol.cc b/source/extensions/filters/listener/proxy_protocol/proxy_protocol.cc
index 4a2c2db29c3b7..6e9fa236f38d0 100644
--- a/source/extensions/filters/listener/proxy_protocol/proxy_protocol.cc
+++ b/source/extensions/filters/listener/proxy_protocol/proxy_protocol.cc
@@ -313,10 +313,10 @@ ReadOrParseState Filter::parseExtensions(Network::IoHandle& io_handle, uint8_t*
       return ReadOrParseState::Error;
     }
 
-    proxy_protocol_header_.value().extensions_length_ -= recv_result.rc_;
+    proxy_protocol_header_.value().extensions_length_ -= recv_result.return_value_;
 
     if (nullptr != buf_off) {
-      *buf_off += recv_result.rc_;
+      *buf_off += recv_result.return_value_;
     }
   }
 
@@ -427,7 +427,7 @@ ReadOrParseState Filter::readProxyHeader(Network::IoHandle& io_handle) {
       ENVOY_LOG(debug, "failed to read proxy protocol (no bytes read)");
       return ReadOrParseState::Error;
     }
-    ssize_t nread = result.rc_;
+    ssize_t nread = result.return_value_;
 
     if (nread < 1) {
       ENVOY_LOG(debug, "failed to read proxy protocol (no bytes read)");
@@ -454,12 +454,12 @@ ReadOrParseState Filter::readProxyHeader(Network::IoHandle& io_handle) {
       if (buf_off_ < PROXY_PROTO_V2_HEADER_LEN) {
         ssize_t exp = PROXY_PROTO_V2_HEADER_LEN - buf_off_;
         const auto read_result = io_handle.recv(buf_ + buf_off_, exp, 0);
-        if (!result.ok() || read_result.rc_ != uint64_t(exp)) {
+        if (!result.ok() || read_result.return_value_ != uint64_t(exp)) {
           ENVOY_LOG(debug, "failed to read proxy protocol (remote closed)");
           return ReadOrParseState::Error;
         }
-        buf_off_ += read_result.rc_;
-        nread -= read_result.rc_;
+        buf_off_ += read_result.return_value_;
+        nread -= read_result.return_value_;
       }
       absl::optional<ssize_t> addr_len_opt = lenV2Address(buf_);
       if (!addr_len_opt.has_value()) {
@@ -476,11 +476,11 @@ ReadOrParseState Filter::readProxyHeader(Network::IoHandle& io_handle) {
       if (ssize_t(buf_off_) + nread >= PROXY_PROTO_V2_HEADER_LEN + addr_len) {
         ssize_t missing = (PROXY_PROTO_V2_HEADER_LEN + addr_len) - buf_off_;
         const auto read_result = io_handle.recv(buf_ + buf_off_, missing, 0);
-        if (!result.ok() || read_result.rc_ != uint64_t(missing)) {
+        if (!result.ok() || read_result.return_value_ != uint64_t(missing)) {
           ENVOY_LOG(debug, "failed to read proxy protocol (remote closed)");
           return ReadOrParseState::Error;
         }
-        buf_off_ += read_result.rc_;
+        buf_off_ += read_result.return_value_;
         // The TLV remain, they are read/discard in parseExtensions() which is called from the
         // parent (if needed).
         if (parseV2Header(buf_)) {
@@ -490,7 +490,7 @@ ReadOrParseState Filter::readProxyHeader(Network::IoHandle& io_handle) {
         }
       } else {
         const auto result = io_handle.recv(buf_ + buf_off_, nread, 0);
-        nread = result.rc_;
+        nread = result.return_value_;
         if (!result.ok()) {
           ENVOY_LOG(debug, "failed to read proxy protocol (remote closed)");
           return ReadOrParseState::Error;
@@ -524,7 +524,7 @@ ReadOrParseState Filter::readProxyHeader(Network::IoHandle& io_handle) {
       }
 
       const auto result = io_handle.recv(buf_ + buf_off_, ntoread, 0);
-      nread = result.rc_;
+      nread = result.return_value_;
       ASSERT(result.ok() && size_t(nread) == ntoread);
 
       buf_off_ += nread;
diff --git a/source/extensions/filters/listener/tls_inspector/tls_inspector.cc b/source/extensions/filters/listener/tls_inspector/tls_inspector.cc
index c2798827f6c91..fb0f06e6c2d56 100644
--- a/source/extensions/filters/listener/tls_inspector/tls_inspector.cc
+++ b/source/extensions/filters/listener/tls_inspector/tls_inspector.cc
@@ -166,7 +166,7 @@ ParseState Filter::onRead() {
   // TODO(ggreenway): write an integration test to ensure the events work as expected on all
   // platforms.
   const auto result = cb_->socket().ioHandle().recv(buf_, config_->maxClientHelloSize(), MSG_PEEK);
-  ENVOY_LOG(trace, "tls inspector: recv: {}", result.rc_);
+  ENVOY_LOG(trace, "tls inspector: recv: {}", result.return_value_);
 
   if (!result.ok()) {
     if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
@@ -178,10 +178,10 @@ ParseState Filter::onRead() {
 
   // Because we're doing a MSG_PEEK, data we've seen before gets returned every time, so
   // skip over what we've already processed.
-  if (static_cast<uint64_t>(result.rc_) > read_) {
+  if (static_cast<uint64_t>(result.return_value_) > read_) {
     const uint8_t* data = buf_ + read_;
-    const size_t len = result.rc_ - read_;
-    read_ = result.rc_;
+    const size_t len = result.return_value_ - read_;
+    read_ = result.return_value_;
     return parseClientHello(data, len);
   }
   return ParseState::Continue;
diff --git a/source/extensions/tracers/xray/daemon_broker.cc b/source/extensions/tracers/xray/daemon_broker.cc
index 2734996be51f8..6d4406b5d51e0 100644
--- a/source/extensions/tracers/xray/daemon_broker.cc
+++ b/source/extensions/tracers/xray/daemon_broker.cc
@@ -42,7 +42,7 @@ void DaemonBrokerImpl::send(const std::string& data) const {
   const auto rc = Network::Utility::writeToSocket(*io_handle_, &buf, 1 /*num_slices*/,
                                                   nullptr /*local_ip*/, *address_);
 
-  if (rc.rc_ != payload.length()) {
+  if (rc.return_value_ != payload.length()) {
     // TODO(marcomagdy): report this in stats
     ENVOY_LOG_TO_LOGGER(logger, debug, "Failed to send trace payload to the X-Ray daemon.");
   }
diff --git a/source/extensions/transport_sockets/proxy_protocol/proxy_protocol.cc b/source/extensions/transport_sockets/proxy_protocol/proxy_protocol.cc
index 66a93f45e9021..4488396f3a513 100644
--- a/source/extensions/transport_sockets/proxy_protocol/proxy_protocol.cc
+++ b/source/extensions/transport_sockets/proxy_protocol/proxy_protocol.cc
@@ -85,8 +85,8 @@ Network::IoResult UpstreamProxyProtocolSocket::writeHeader() {
     Api::IoCallUint64Result result = callbacks_->ioHandle().write(header_buffer_);
 
     if (result.ok()) {
-      ENVOY_CONN_LOG(trace, "write returns: {}", callbacks_->connection(), result.rc_);
-      bytes_written += result.rc_;
+      ENVOY_CONN_LOG(trace, "write returns: {}", callbacks_->connection(), result.return_value_);
+      bytes_written += result.return_value_;
     } else {
       ENVOY_CONN_LOG(trace, "write error: {}", callbacks_->connection(),
                      result.err_->getErrorDetails());
diff --git a/source/extensions/transport_sockets/tls/io_handle_bio.cc b/source/extensions/transport_sockets/tls/io_handle_bio.cc
index f7ede00cd45a7..3b595f7062aa2 100644
--- a/source/extensions/transport_sockets/tls/io_handle_bio.cc
+++ b/source/extensions/transport_sockets/tls/io_handle_bio.cc
@@ -61,7 +61,7 @@ int io_handle_read(BIO* b, char* out, int outl) {
     }
     return -1;
   }
-  return result.rc_;
+  return result.return_value_;
 }
 
 // NOLINTNEXTLINE(readability-identifier-naming)
@@ -78,7 +78,7 @@ int io_handle_write(BIO* b, const char* in, int inl) {
     }
     return -1;
   }
-  return result.rc_;
+  return result.return_value_;
 }
 
 // NOLINTNEXTLINE(readability-identifier-naming)
diff --git a/source/server/hot_restart_impl.cc b/source/server/hot_restart_impl.cc
index 3b2160c9eb63e..347167217b957 100644
--- a/source/server/hot_restart_impl.cc
+++ b/source/server/hot_restart_impl.cc
@@ -39,20 +39,20 @@ SharedMemory* attachSharedMemory(uint32_t base_id, uint32_t restart_epoch) {
 
   const Api::SysCallIntResult result =
       hot_restart_os_sys_calls.shmOpen(shmem_name.c_str(), flags, S_IRUSR | S_IWUSR);
-  if (result.rc_ == -1) {
+  if (result.return_value_ == -1) {
     PANIC(fmt::format("cannot open shared memory region {} check user permissions. Error: {}",
                       shmem_name, errorDetails(result.errno_)));
   }
 
   if (restart_epoch == 0) {
     const Api::SysCallIntResult truncateRes =
-        os_sys_calls.ftruncate(result.rc_, sizeof(SharedMemory));
-    RELEASE_ASSERT(truncateRes.rc_ != -1, "");
+        os_sys_calls.ftruncate(result.return_value_, sizeof(SharedMemory));
+    RELEASE_ASSERT(truncateRes.return_value_ != -1, "");
   }
 
   const Api::SysCallPtrResult mmapRes = os_sys_calls.mmap(
-      nullptr, sizeof(SharedMemory), PROT_READ | PROT_WRITE, MAP_SHARED, result.rc_, 0);
-  SharedMemory* shmem = reinterpret_cast<SharedMemory*>(mmapRes.rc_);
+      nullptr, sizeof(SharedMemory), PROT_READ | PROT_WRITE, MAP_SHARED, result.return_value_, 0);
+  SharedMemory* shmem = reinterpret_cast<SharedMemory*>(mmapRes.return_value_);
   RELEASE_ASSERT(shmem != MAP_FAILED, "");
   RELEASE_ASSERT((reinterpret_cast<uintptr_t>(shmem) % alignof(decltype(shmem))) == 0, "");
 
diff --git a/source/server/hot_restarting_base.cc b/source/server/hot_restarting_base.cc
index 22e8286ca02d2..bc1e164b8effa 100644
--- a/source/server/hot_restarting_base.cc
+++ b/source/server/hot_restarting_base.cc
@@ -20,7 +20,7 @@ HotRestartingBase::~HotRestartingBase() {
   if (my_domain_socket_ != -1) {
     Api::OsSysCalls& os_sys_calls = Api::OsSysCallsSingleton::get();
     Api::SysCallIntResult result = os_sys_calls.close(my_domain_socket_);
-    ASSERT(result.rc_ == 0);
+    ASSERT(result.return_value_ == 0);
   }
 }
 
@@ -56,7 +56,7 @@ void HotRestartingBase::bindDomainSocket(uint64_t id, const std::string& role,
   unlink(address.sun_path);
   Api::SysCallIntResult result =
       os_sys_calls.bind(my_domain_socket_, reinterpret_cast<sockaddr*>(&address), sizeof(address));
-  if (result.rc_ != 0) {
+  if (result.return_value_ != 0) {
     const auto msg = fmt::format(
         "unable to bind domain socket with base_id={}, id={}, errno={} (see --base-id option)",
         base_id_, id, result.errno_);
@@ -119,7 +119,7 @@ void HotRestartingBase::sendHotRestartMessage(sockaddr_un& address,
     bool sent = false;
     for (int i = 0; i < SENDMSG_MAX_RETRIES; i++) {
       auto result = os_sys_calls.sendmsg(my_domain_socket_, &message, 0);
-      rc = result.rc_;
+      rc = result.return_value_;
       saved_errno = result.errno_;
 
       if (rc == static_cast<int>(cur_chunk_size)) {
diff --git a/source/server/options_impl_platform_linux.cc b/source/server/options_impl_platform_linux.cc
index 9365614dc1840..f649f7a6f0305 100644
--- a/source/server/options_impl_platform_linux.cc
+++ b/source/server/options_impl_platform_linux.cc
@@ -22,7 +22,7 @@ uint32_t OptionsImplPlatformLinux::getCpuAffinityCount(unsigned int hw_threads)
   CPU_ZERO(&mask);
   const Api::SysCallIntResult result =
       linux_os_syscalls.sched_getaffinity(pid, sizeof(cpu_set_t), &mask);
-  if (result.rc_ == -1) {
+  if (result.return_value_ == -1) {
     // Fall back to number of hardware threads.
     return hw_threads;
   }
diff --git a/test/common/buffer/buffer_fuzz.cc b/test/common/buffer/buffer_fuzz.cc
index 46241032beff0..9d7cb96004e1c 100644
--- a/test/common/buffer/buffer_fuzz.cc
+++ b/test/common/buffer/buffer_fuzz.cc
@@ -361,7 +361,7 @@ uint32_t bufferAction(Context& ctxt, char insert_value, uint32_t max_alloc, Buff
     const ssize_t rc = ::write(pipe_fds[1], data.data(), max_length);
     FUZZ_ASSERT(rc > 0);
     Api::IoCallUint64Result result = io_handle.read(target_buffer, max_length);
-    FUZZ_ASSERT(result.rc_ == static_cast<uint64_t>(rc));
+    FUZZ_ASSERT(result.return_value_ == static_cast<uint64_t>(rc));
     FUZZ_ASSERT(::close(pipe_fds[1]) == 0);
     break;
   }
@@ -371,23 +371,24 @@ uint32_t bufferAction(Context& ctxt, char insert_value, uint32_t max_alloc, Buff
     Network::IoSocketHandleImpl io_handle(pipe_fds[1]);
     FUZZ_ASSERT(::fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) == 0);
     FUZZ_ASSERT(::fcntl(pipe_fds[1], F_SETFL, O_NONBLOCK) == 0);
-    uint64_t rc;
+    uint64_t return_value;
     do {
       const bool empty = target_buffer.length() == 0;
       const std::string previous_data = target_buffer.toString();
       const auto result = io_handle.write(target_buffer);
       FUZZ_ASSERT(result.ok());
-      rc = result.rc_;
-      ENVOY_LOG_MISC(trace, "Write rc: {} errno: {}", rc,
+      return_value = result.return_value_;
+      ENVOY_LOG_MISC(trace, "Write return_value: {} errno: {}", return_value,
                      result.err_ != nullptr ? result.err_->getErrorDetails() : "-");
       if (empty) {
-        FUZZ_ASSERT(rc == 0);
+        FUZZ_ASSERT(return_value == 0);
       } else {
-        auto buf = std::make_unique<char[]>(rc);
-        FUZZ_ASSERT(static_cast<uint64_t>(::read(pipe_fds[0], buf.get(), rc)) == rc);
-        FUZZ_ASSERT(::memcmp(buf.get(), previous_data.data(), rc) == 0);
+        auto buf = std::make_unique<char[]>(return_value);
+        FUZZ_ASSERT(static_cast<uint64_t>(::read(pipe_fds[0], buf.get(), return_value)) ==
+                    return_value);
+        FUZZ_ASSERT(::memcmp(buf.get(), previous_data.data(), return_value) == 0);
       }
-    } while (rc > 0);
+    } while (return_value > 0);
     FUZZ_ASSERT(::close(pipe_fds[0]) == 0);
     break;
   }
diff --git a/test/common/buffer/owned_impl_test.cc b/test/common/buffer/owned_impl_test.cc
index ea5cf249ae1dd..55a877a01370e 100644
--- a/test/common/buffer/owned_impl_test.cc
+++ b/test/common/buffer/owned_impl_test.cc
@@ -263,44 +263,44 @@ TEST_F(OwnedImplTest, Write) {
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{7, 0}));
   Api::IoCallUint64Result result = io_handle.write(buffer);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(7, result.rc_);
+  EXPECT_EQ(7, result.return_value_);
   EXPECT_EQ(0, buffer.length());
 
   buffer.add("example");
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{6, 0}));
   result = io_handle.write(buffer);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(6, result.rc_);
+  EXPECT_EQ(6, result.return_value_);
   EXPECT_EQ(1, buffer.length());
 
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{0, 0}));
   result = io_handle.write(buffer);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(1, buffer.length());
 
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{-1, 0}));
   result = io_handle.write(buffer);
   EXPECT_EQ(Api::IoError::IoErrorCode::UnknownError, result.err_->getErrorCode());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(1, buffer.length());
 
   EXPECT_CALL(os_sys_calls, writev(_, _, _))
       .WillOnce(Return(Api::SysCallSizeResult{-1, SOCKET_ERROR_AGAIN}));
   result = io_handle.write(buffer);
   EXPECT_EQ(Api::IoError::IoErrorCode::Again, result.err_->getErrorCode());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(1, buffer.length());
 
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{1, 0}));
   result = io_handle.write(buffer);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(1, result.rc_);
+  EXPECT_EQ(1, result.return_value_);
   EXPECT_EQ(0, buffer.length());
 
   EXPECT_CALL(os_sys_calls, writev(_, _, _)).Times(0);
   result = io_handle.write(buffer);
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(0, buffer.length());
 }
 
@@ -313,14 +313,14 @@ TEST_F(OwnedImplTest, Read) {
   EXPECT_CALL(os_sys_calls, readv(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{0, 0}));
   Api::IoCallUint64Result result = io_handle.read(buffer, 100);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(0, buffer.length());
   EXPECT_THAT(buffer.describeSlicesForTest(), testing::IsEmpty());
 
   EXPECT_CALL(os_sys_calls, readv(_, _, _)).WillOnce(Return(Api::SysCallSizeResult{-1, 0}));
   result = io_handle.read(buffer, 100);
   EXPECT_EQ(Api::IoError::IoErrorCode::UnknownError, result.err_->getErrorCode());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(0, buffer.length());
   EXPECT_THAT(buffer.describeSlicesForTest(), testing::IsEmpty());
 
@@ -328,13 +328,13 @@ TEST_F(OwnedImplTest, Read) {
       .WillOnce(Return(Api::SysCallSizeResult{-1, SOCKET_ERROR_AGAIN}));
   result = io_handle.read(buffer, 100);
   EXPECT_EQ(Api::IoError::IoErrorCode::Again, result.err_->getErrorCode());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(0, buffer.length());
   EXPECT_THAT(buffer.describeSlicesForTest(), testing::IsEmpty());
 
   EXPECT_CALL(os_sys_calls, readv(_, _, _)).Times(0);
   result = io_handle.read(buffer, 0);
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
   EXPECT_EQ(0, buffer.length());
   EXPECT_THAT(buffer.describeSlicesForTest(), testing::IsEmpty());
 }
@@ -1151,21 +1151,21 @@ TEST_F(OwnedImplTest, ReserveZeroCommit) {
   os_fd_t pipe_fds[2] = {0, 0};
   auto& os_sys_calls = Api::OsSysCallsSingleton::get();
 #ifdef WIN32
-  ASSERT_EQ(os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).rc_, 0);
+  ASSERT_EQ(os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).return_value_, 0);
 #else
   ASSERT_EQ(pipe(pipe_fds), 0);
 #endif
   Network::IoSocketHandleImpl io_handle(pipe_fds[0]);
-  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[0], false).rc_, 0);
-  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[1], false).rc_, 0);
+  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[0], false).return_value_, 0);
+  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[1], false).return_value_, 0);
   const uint32_t max_length = 1953;
   std::string data(max_length, 'e');
-  const ssize_t rc = os_sys_calls.write(pipe_fds[1], data.data(), max_length).rc_;
+  const ssize_t rc = os_sys_calls.write(pipe_fds[1], data.data(), max_length).return_value_;
   ASSERT_GT(rc, 0);
   const uint32_t previous_length = buf.length();
   Api::IoCallUint64Result result = io_handle.read(buf, max_length);
-  ASSERT_EQ(result.rc_, static_cast<uint64_t>(rc));
-  ASSERT_EQ(os_sys_calls.close(pipe_fds[1]).rc_, 0);
+  ASSERT_EQ(result.return_value_, static_cast<uint64_t>(rc));
+  ASSERT_EQ(os_sys_calls.close(pipe_fds[1]).return_value_, 0);
   ASSERT_EQ(previous_length, buf.search(data.data(), rc, previous_length, 0));
   EXPECT_EQ("bbbbb", buf.toString().substr(0, 5));
   expectSlices({{5, 0, 4096}, {1953, 14431, 16384}}, buf);
@@ -1179,21 +1179,21 @@ TEST_F(OwnedImplTest, ReadReserveAndCommit) {
   os_fd_t pipe_fds[2] = {0, 0};
   auto& os_sys_calls = Api::OsSysCallsSingleton::get();
 #ifdef WIN32
-  ASSERT_EQ(os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).rc_, 0);
+  ASSERT_EQ(os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).return_value_, 0);
 #else
   ASSERT_EQ(pipe(pipe_fds), 0);
 #endif
   Network::IoSocketHandleImpl io_handle(pipe_fds[0]);
-  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[0], false).rc_, 0);
-  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[1], false).rc_, 0);
+  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[0], false).return_value_, 0);
+  ASSERT_EQ(os_sys_calls.setsocketblocking(pipe_fds[1], false).return_value_, 0);
 
   const uint32_t read_length = 32768;
   std::string data = "e";
-  const ssize_t rc = os_sys_calls.write(pipe_fds[1], data.data(), data.size()).rc_;
+  const ssize_t rc = os_sys_calls.write(pipe_fds[1], data.data(), data.size()).return_value_;
   ASSERT_GT(rc, 0);
   Api::IoCallUint64Result result = io_handle.read(buf, read_length);
-  ASSERT_EQ(result.rc_, static_cast<uint64_t>(rc));
-  ASSERT_EQ(os_sys_calls.close(pipe_fds[1]).rc_, 0);
+  ASSERT_EQ(result.return_value_, static_cast<uint64_t>(rc));
+  ASSERT_EQ(os_sys_calls.close(pipe_fds[1]).return_value_, 0);
   EXPECT_EQ("bbbbbe", buf.toString());
   expectSlices({{6, 4090, 4096}}, buf);
 }
diff --git a/test/common/buffer/watermark_buffer_test.cc b/test/common/buffer/watermark_buffer_test.cc
index 548318a8065ab..071d9f1169067 100644
--- a/test/common/buffer/watermark_buffer_test.cc
+++ b/test/common/buffer/watermark_buffer_test.cc
@@ -247,7 +247,7 @@ TEST_F(WatermarkBufferTest, WatermarkFdFunctions) {
   os_fd_t pipe_fds[2] = {0, 0};
 #ifdef WIN32
   auto& os_sys_calls = Api::OsSysCallsSingleton::get();
-  ASSERT_EQ(0, os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).rc_);
+  ASSERT_EQ(0, os_sys_calls.socketpair(AF_INET, SOCK_STREAM, 0, pipe_fds).return_value_);
 #else
   ASSERT_EQ(0, pipe(pipe_fds));
 #endif
@@ -264,7 +264,7 @@ TEST_F(WatermarkBufferTest, WatermarkFdFunctions) {
     if (!result.ok()) {
       ASSERT_EQ(Api::IoError::IoErrorCode::Again, result.err_->getErrorCode());
     } else {
-      bytes_written_total += result.rc_;
+      bytes_written_total += result.return_value_;
     }
   }
   EXPECT_EQ(1, times_high_watermark_called_);
@@ -275,7 +275,7 @@ TEST_F(WatermarkBufferTest, WatermarkFdFunctions) {
   Network::IoSocketHandleImpl io_handle2(pipe_fds[0]);
   while (bytes_read_total < 20) {
     Api::IoCallUint64Result result = io_handle2.read(buffer_, 20);
-    bytes_read_total += result.rc_;
+    bytes_read_total += result.return_value_;
   }
   EXPECT_EQ(2, times_high_watermark_called_);
   EXPECT_EQ(20, buffer_.length());
diff --git a/test/common/event/dispatcher_impl_test.cc b/test/common/event/dispatcher_impl_test.cc
index 240a9485196fd..7538a8c495c07 100644
--- a/test/common/event/dispatcher_impl_test.cc
+++ b/test/common/event/dispatcher_impl_test.cc
@@ -1534,7 +1534,7 @@ TEST_F(DispatcherWithWatchdogTest, TouchBeforeTimer) {
 }
 
 TEST_F(DispatcherWithWatchdogTest, TouchBeforeFdEvent) {
-  os_fd_t fd = os_sys_calls_.socket(AF_INET6, SOCK_DGRAM, 0).rc_;
+  os_fd_t fd = os_sys_calls_.socket(AF_INET6, SOCK_DGRAM, 0).return_value_;
   ASSERT_TRUE(SOCKET_VALID(fd));
 
   ReadyWatcher watcher;
diff --git a/test/common/event/file_event_impl_test.cc b/test/common/event/file_event_impl_test.cc
index 67986afab8da6..6bcd002d3c390 100644
--- a/test/common/event/file_event_impl_test.cc
+++ b/test/common/event/file_event_impl_test.cc
@@ -25,14 +25,14 @@ class FileEventImplTest : public testing::Test {
 
   void SetUp() override {
 #ifdef WIN32
-    ASSERT_EQ(0, os_sys_calls_.socketpair(AF_INET, SOCK_STREAM, 0, fds_).rc_);
+    ASSERT_EQ(0, os_sys_calls_.socketpair(AF_INET, SOCK_STREAM, 0, fds_).return_value_);
 #else
-    ASSERT_EQ(0, os_sys_calls_.socketpair(AF_UNIX, SOCK_DGRAM, 0, fds_).rc_);
+    ASSERT_EQ(0, os_sys_calls_.socketpair(AF_UNIX, SOCK_DGRAM, 0, fds_).return_value_);
 #endif
     int data = 1;
 
     const Api::SysCallSizeResult result = os_sys_calls_.write(fds_[1], &data, sizeof(data));
-    ASSERT_EQ(sizeof(data), static_cast<size_t>(result.rc_));
+    ASSERT_EQ(sizeof(data), static_cast<size_t>(result.return_value_));
   }
 
   void clearReadable() {
@@ -42,8 +42,8 @@ class FileEventImplTest : public testing::Test {
       buffer, sizeof(buffer)
     };
     const Api::SysCallSizeResult result = os_sys_calls_.readv(fds_[0], &vec, 1);
-    EXPECT_LT(0, static_cast<size_t>(result.rc_));
-    EXPECT_GT(sizeof(buffer), static_cast<size_t>(result.rc_));
+    EXPECT_LT(0, static_cast<size_t>(result.return_value_));
+    EXPECT_GT(sizeof(buffer), static_cast<size_t>(result.return_value_));
   }
 
   void TearDown() override {
@@ -79,7 +79,7 @@ INSTANTIATE_TEST_SUITE_P(IpVersions, FileEventImplActivateTest,
                          testing::ValuesIn(TestEnvironment::getIpVersionsForTest()));
 
 TEST_P(FileEventImplActivateTest, Activate) {
-  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_STREAM, 0).rc_;
+  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_STREAM, 0).return_value_;
   ASSERT_TRUE(SOCKET_VALID(fd));
 
   Api::ApiPtr api = Api::createApiForTest();
@@ -117,7 +117,7 @@ TEST_P(FileEventImplActivateTest, Activate) {
 }
 
 TEST_P(FileEventImplActivateTest, ActivateChaining) {
-  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_DGRAM, 0).rc_;
+  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_DGRAM, 0).return_value_;
   ASSERT_TRUE(SOCKET_VALID(fd));
 
   Api::ApiPtr api = Api::createApiForTest();
@@ -181,7 +181,7 @@ TEST_P(FileEventImplActivateTest, ActivateChaining) {
 }
 
 TEST_P(FileEventImplActivateTest, SetEnableCancelsActivate) {
-  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_DGRAM, 0).rc_;
+  os_fd_t fd = os_sys_calls_.socket(domain(), SOCK_DGRAM, 0).return_value_;
   ASSERT_TRUE(SOCKET_VALID(fd));
 
   Api::ApiPtr api = Api::createApiForTest();
diff --git a/test/common/filesystem/filesystem_impl_test.cc b/test/common/filesystem/filesystem_impl_test.cc
index fe21296388147..a079d2e422e25 100644
--- a/test/common/filesystem/filesystem_impl_test.cc
+++ b/test/common/filesystem/filesystem_impl_test.cc
@@ -112,13 +112,15 @@ TEST_F(FileSystemImplTest, FileReadToEndDenylisted) {
 }
 
 #ifndef WIN32
-TEST_F(FileSystemImplTest, CanonicalPathSuccess) { EXPECT_EQ("/", canonicalPath("//").rc_); }
+TEST_F(FileSystemImplTest, CanonicalPathSuccess) {
+  EXPECT_EQ("/", canonicalPath("//").return_value_);
+}
 #endif
 
 #ifndef WIN32
 TEST_F(FileSystemImplTest, CanonicalPathFail) {
   const Api::SysCallStringResult result = canonicalPath("/_some_non_existent_file");
-  EXPECT_TRUE(result.rc_.empty());
+  EXPECT_TRUE(result.return_value_.empty());
   EXPECT_EQ("No such file or directory", errorDetails(result.errno_));
 }
 #endif
@@ -262,7 +264,7 @@ TEST_F(FileSystemImplTest, Open) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult result = file->open(DefaultFlags);
-  EXPECT_TRUE(result.rc_);
+  EXPECT_TRUE(result.return_value_);
   EXPECT_TRUE(file->isOpen());
 }
 
@@ -276,7 +278,7 @@ TEST_F(FileSystemImplTest, OpenReadOnly) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult result = file->open(ReadOnlyFlags);
-  EXPECT_TRUE(result.rc_);
+  EXPECT_TRUE(result.return_value_);
   EXPECT_TRUE(file->isOpen());
 }
 
@@ -290,13 +292,13 @@ TEST_F(FileSystemImplTest, OpenTwice) {
 
   const Api::IoCallBoolResult result1 = file->open(DefaultFlags);
   const filesystem_os_id_t initial_fd = getFd(file.get());
-  EXPECT_TRUE(result1.rc_);
+  EXPECT_TRUE(result1.return_value_);
   EXPECT_TRUE(file->isOpen());
 
   // check that we don't leak a file descriptor
   const Api::IoCallBoolResult result2 = file->open(DefaultFlags);
   EXPECT_EQ(initial_fd, getFd(file.get()));
-  EXPECT_TRUE(result2.rc_);
+  EXPECT_TRUE(result2.return_value_);
   EXPECT_TRUE(file->isOpen());
 }
 
@@ -304,7 +306,7 @@ TEST_F(FileSystemImplTest, OpenBadFilePath) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, ""};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult result = file->open(DefaultFlags);
-  EXPECT_FALSE(result.rc_);
+  EXPECT_FALSE(result.return_value_);
 }
 
 TEST_F(FileSystemImplTest, ExistingFile) {
@@ -315,10 +317,10 @@ TEST_F(FileSystemImplTest, ExistingFile) {
     FilePathAndType new_file_info{Filesystem::DestinationType::File, file_path};
     FilePtr file = file_system_.createFile(new_file_info);
     const Api::IoCallBoolResult open_result = file->open(DefaultFlags);
-    EXPECT_TRUE(open_result.rc_);
+    EXPECT_TRUE(open_result.return_value_);
     std::string data(" new data");
     const Api::IoCallSizeResult result = file->write(data);
-    EXPECT_EQ(data.length(), result.rc_);
+    EXPECT_EQ(data.length(), result.return_value_);
   }
 
   auto contents = TestEnvironment::readFileToStringForTest(file_path);
@@ -333,10 +335,10 @@ TEST_F(FileSystemImplTest, NonExistingFile) {
     FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
     FilePtr file = file_system_.createFile(new_file_info);
     const Api::IoCallBoolResult open_result = file->open(DefaultFlags);
-    EXPECT_TRUE(open_result.rc_);
+    EXPECT_TRUE(open_result.return_value_);
     std::string data(" new data");
     const Api::IoCallSizeResult result = file->write(data);
-    EXPECT_EQ(data.length(), result.rc_);
+    EXPECT_EQ(data.length(), result.return_value_);
   }
 
   auto contents = TestEnvironment::readFileToStringForTest(new_file_path);
@@ -347,22 +349,24 @@ TEST_F(FileSystemImplTest, StdOut) {
   FilePathAndType file_info{Filesystem::DestinationType::Stdout, ""};
   FilePtr file = file_system_.createFile(file_info);
   const Api::IoCallBoolResult open_result = file->open(DefaultFlags);
-  EXPECT_TRUE(open_result.rc_);
+  EXPECT_TRUE(open_result.return_value_);
   EXPECT_TRUE(file->isOpen());
   std::string data(" new data\n");
   const Api::IoCallSizeResult result = file->write(data);
-  EXPECT_EQ(data.length(), result.rc_) << fmt::format("{}", result.err_->getErrorDetails());
+  EXPECT_EQ(data.length(), result.return_value_)
+      << fmt::format("{}", result.err_->getErrorDetails());
 }
 
 TEST_F(FileSystemImplTest, StdErr) {
   FilePathAndType file_info{Filesystem::DestinationType::Stderr, ""};
   FilePtr file = file_system_.createFile(file_info);
   const Api::IoCallBoolResult open_result = file->open(DefaultFlags);
-  EXPECT_TRUE(open_result.rc_) << fmt::format("{}", open_result.err_->getErrorDetails());
+  EXPECT_TRUE(open_result.return_value_) << fmt::format("{}", open_result.err_->getErrorDetails());
   EXPECT_TRUE(file->isOpen());
   std::string data(" new data\n");
   const Api::IoCallSizeResult result = file->write(data);
-  EXPECT_EQ(data.length(), result.rc_) << fmt::format("{}", result.err_->getErrorDetails());
+  EXPECT_EQ(data.length(), result.return_value_)
+      << fmt::format("{}", result.err_->getErrorDetails());
 }
 
 #ifdef WIN32
@@ -375,7 +379,7 @@ TEST_F(FileSystemImplTest, Win32InvalidHandleThrows) {
   auto original_handle = GetStdHandle(STD_OUTPUT_HANDLE);
   EXPECT_TRUE(SetStdHandle(STD_OUTPUT_HANDLE, NULL));
   const Api::IoCallBoolResult result = file->open(DefaultFlags);
-  EXPECT_FALSE(result.rc_);
+  EXPECT_FALSE(result.return_value_);
   EXPECT_TRUE(SetStdHandle(STD_OUTPUT_HANDLE, original_handle));
 }
 #endif
@@ -387,11 +391,11 @@ TEST_F(FileSystemImplTest, Close) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult result1 = file->open(DefaultFlags);
-  EXPECT_TRUE(result1.rc_);
+  EXPECT_TRUE(result1.return_value_);
   EXPECT_TRUE(file->isOpen());
 
   const Api::IoCallBoolResult result2 = file->close();
-  EXPECT_TRUE(result2.rc_);
+  EXPECT_TRUE(result2.return_value_);
   EXPECT_FALSE(file->isOpen());
 }
 
@@ -402,11 +406,11 @@ TEST_F(FileSystemImplTest, WriteAfterClose) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult bool_result1 = file->open(DefaultFlags);
-  EXPECT_TRUE(bool_result1.rc_);
+  EXPECT_TRUE(bool_result1.return_value_);
   const Api::IoCallBoolResult bool_result2 = file->close();
-  EXPECT_TRUE(bool_result2.rc_);
+  EXPECT_TRUE(bool_result2.return_value_);
   const Api::IoCallSizeResult size_result = file->write(" new data");
-  EXPECT_EQ(-1, size_result.rc_);
+  EXPECT_EQ(-1, size_result.return_value_);
   EXPECT_EQ(IoFileError::IoErrorCode::BadFd, size_result.err_->getErrorCode());
 }
 
@@ -418,7 +422,7 @@ TEST_F(FileSystemImplTest, NonExistingFileAndReadOnly) {
   FilePathAndType new_file_info{Filesystem::DestinationType::File, new_file_path};
   FilePtr file = file_system_.createFile(new_file_info);
   const Api::IoCallBoolResult open_result = file->open(flag);
-  EXPECT_FALSE(open_result.rc_);
+  EXPECT_FALSE(open_result.return_value_);
 }
 
 TEST_F(FileSystemImplTest, ExistingReadOnlyFileAndWrite) {
@@ -430,10 +434,10 @@ TEST_F(FileSystemImplTest, ExistingReadOnlyFileAndWrite) {
     FilePathAndType new_file_info{Filesystem::DestinationType::File, file_path};
     FilePtr file = file_system_.createFile(new_file_info);
     const Api::IoCallBoolResult open_result = file->open(flag);
-    EXPECT_TRUE(open_result.rc_);
+    EXPECT_TRUE(open_result.return_value_);
     std::string data(" new data");
     const Api::IoCallSizeResult result = file->write(data);
-    EXPECT_TRUE(result.rc_ < 0);
+    EXPECT_TRUE(result.return_value_ < 0);
 #ifdef WIN32
     EXPECT_EQ(IoFileError::IoErrorCode::Permission, result.err_->getErrorCode());
 #else
diff --git a/test/common/network/address_impl_test.cc b/test/common/network/address_impl_test.cc
index 3eb42caf7fd27..76f7e9e4c42f8 100644
--- a/test/common/network/address_impl_test.cc
+++ b/test/common/network/address_impl_test.cc
@@ -56,18 +56,21 @@ void testSocketBindAndConnect(Network::Address::IpVersion ip_version, bool v6onl
   if (addr_port->ip()->version() == IpVersion::v6) {
     int socket_v6only = 0;
     socklen_t size_int = sizeof(socket_v6only);
-    ASSERT_GE(sock.getSocketOption(IPPROTO_IPV6, IPV6_V6ONLY, &socket_v6only, &size_int).rc_, 0);
+    ASSERT_GE(
+        sock.getSocketOption(IPPROTO_IPV6, IPV6_V6ONLY, &socket_v6only, &size_int).return_value_,
+        0);
     EXPECT_EQ(v6only, socket_v6only != 0);
   }
 
   // Bind the socket to the desired address and port.
   const Api::SysCallIntResult result = sock.bind(addr_port);
-  ASSERT_EQ(result.rc_, 0) << addr_port->asString() << "\nerror: " << errorDetails(result.errno_)
-                           << "\nerrno: " << result.errno_;
+  ASSERT_EQ(result.return_value_, 0)
+      << addr_port->asString() << "\nerror: " << errorDetails(result.errno_)
+      << "\nerrno: " << result.errno_;
 
   // Do a bare listen syscall. Not bothering to accept connections as that would
   // require another thread.
-  ASSERT_EQ(sock.listen(128).rc_, 0);
+  ASSERT_EQ(sock.listen(128).return_value_, 0);
 
   auto client_connect = [](Address::InstanceConstSharedPtr addr_port) {
     // Create a client socket and connect to the server.
@@ -79,12 +82,13 @@ void testSocketBindAndConnect(Network::Address::IpVersion ip_version, bool v6onl
     // operation of ::connect(), so connect returns with errno==EWOULDBLOCK before the tcp
     // handshake can complete. For testing convenience, re-enable blocking on the socket
     // so that connect will wait for the handshake to complete.
-    ASSERT_EQ(client_sock.setBlockingForTest(true).rc_, 0);
+    ASSERT_EQ(client_sock.setBlockingForTest(true).return_value_, 0);
 
     // Connect to the server.
     const Api::SysCallIntResult result = client_sock.connect(addr_port);
-    ASSERT_EQ(result.rc_, 0) << addr_port->asString() << "\nerror: " << errorDetails(result.errno_)
-                             << "\nerrno: " << result.errno_;
+    ASSERT_EQ(result.return_value_, 0)
+        << addr_port->asString() << "\nerror: " << errorDetails(result.errno_)
+        << "\nerrno: " << result.errno_;
   };
 
   auto client_addr_port = Network::Utility::parseInternetAddressAndPort(
@@ -349,13 +353,14 @@ TEST(PipeInstanceTest, BasicPermission) {
   EXPECT_TRUE(sock.ioHandle().isOpen()) << pipe.asString();
 
   Api::SysCallIntResult result = sock.bind(address);
-  ASSERT_EQ(result.rc_, 0) << pipe.asString() << "\nerror: " << errorDetails(result.errno_)
-                           << "\terrno: " << result.errno_;
+  ASSERT_EQ(result.return_value_, 0)
+      << pipe.asString() << "\nerror: " << errorDetails(result.errno_)
+      << "\terrno: " << result.errno_;
 
   Api::OsSysCalls& os_sys_calls = Api::OsSysCallsSingleton::get();
   struct stat stat_buf;
   result = os_sys_calls.stat(path.c_str(), &stat_buf);
-  EXPECT_EQ(result.rc_, 0);
+  EXPECT_EQ(result.return_value_, 0);
   // Get file permissions bits
   ASSERT_EQ(stat_buf.st_mode & 07777, mode)
       << path << std::oct << "\t" << (stat_buf.st_mode & 07777) << std::dec << "\t"
@@ -449,8 +454,9 @@ TEST(PipeInstanceTest, UnlinksExistingFile) {
 
     const Api::SysCallIntResult result = sock.bind(address);
 
-    ASSERT_EQ(result.rc_, 0) << pipe.asString() << "\nerror: " << errorDetails(result.errno_)
-                             << "\nerrno: " << result.errno_;
+    ASSERT_EQ(result.return_value_, 0)
+        << pipe.asString() << "\nerror: " << errorDetails(result.errno_)
+        << "\nerrno: " << result.errno_;
   };
 
   const std::string path = TestEnvironment::unixDomainSocketPath("UnlinksExistingFile.sock");
diff --git a/test/common/network/io_socket_handle_impl_integration_test.cc b/test/common/network/io_socket_handle_impl_integration_test.cc
index 31d8ac67de946..d438a636d19f6 100644
--- a/test/common/network/io_socket_handle_impl_integration_test.cc
+++ b/test/common/network/io_socket_handle_impl_integration_test.cc
@@ -26,7 +26,7 @@ TEST(IoSocketHandleImplIntegration, LastRoundTripIntegrationTest) {
   Address::InstanceConstSharedPtr addr(new Address::Ipv4Instance(&server));
   auto socket_ = std::make_shared<Envoy::Network::ClientSocketImpl>(addr, nullptr);
   socket_->setBlockingForTest(true);
-  EXPECT_TRUE(socket_->connect(addr).rc_ == 0);
+  EXPECT_TRUE(socket_->connect(addr).return_value_ == 0);
 
   EXPECT_TRUE(socket_->ioHandle().lastRoundTripTime() != absl::nullopt);
 }
diff --git a/test/common/network/listen_socket_impl_test.cc b/test/common/network/listen_socket_impl_test.cc
index 5c78af7a2e2c5..5468031588d41 100644
--- a/test/common/network/listen_socket_impl_test.cc
+++ b/test/common/network/listen_socket_impl_test.cc
@@ -96,7 +96,7 @@ class ListenSocketImplTest : public testing::TestWithParam<Address::IpVersion> {
       // instead of if block.
       auto os_sys_calls = Api::OsSysCallsSingleton::get();
       if (NetworkSocketTrait<Type>::type == Socket::Type::Stream) {
-        EXPECT_EQ(0, socket1->listen(0).rc_);
+        EXPECT_EQ(0, socket1->listen(0).return_value_);
       }
 
       EXPECT_EQ(addr->ip()->port(), socket1->addressProvider().localAddress()->ip()->port());
@@ -118,8 +118,9 @@ class ListenSocketImplTest : public testing::TestWithParam<Address::IpVersion> {
       // Test createListenSocketPtr from IoHandlePtr's os_fd_t constructor
       int domain = version_ == Address::IpVersion::v4 ? AF_INET : AF_INET6;
       auto socket_result = os_sys_calls.socket(domain, SOCK_STREAM, 0);
-      EXPECT_TRUE(SOCKET_VALID(socket_result.rc_));
-      Network::IoHandlePtr io_handle = std::make_unique<IoSocketHandleImpl>(socket_result.rc_);
+      EXPECT_TRUE(SOCKET_VALID(socket_result.return_value_));
+      Network::IoHandlePtr io_handle =
+          std::make_unique<IoSocketHandleImpl>(socket_result.return_value_);
       auto socket3 = createListenSocketPtr(std::move(io_handle), addr, nullptr);
       EXPECT_EQ(socket3->addressProvider().localAddress()->asString(), addr->asString());
 
diff --git a/test/common/network/socket_option_impl_test.cc b/test/common/network/socket_option_impl_test.cc
index 2bbf4eba6400e..c2736caed50d9 100644
--- a/test/common/network/socket_option_impl_test.cc
+++ b/test/common/network/socket_option_impl_test.cc
@@ -12,7 +12,7 @@ TEST_F(SocketOptionImplTest, BadFd) {
   absl::string_view zero("\0\0\0\0", 4);
   Api::SysCallIntResult result =
       SocketOptionImpl::setSocketOption(socket_, {}, zero.data(), zero.size());
-  EXPECT_EQ(-1, result.rc_);
+  EXPECT_EQ(-1, result.return_value_);
   EXPECT_EQ(SOCKET_ERROR_NOT_SUP, result.errno_);
 }
 
diff --git a/test/common/network/socket_option_test.h b/test/common/network/socket_option_test.h
index c2a60bc1bf372..a13a9a76b61c9 100644
--- a/test/common/network/socket_option_test.h
+++ b/test/common/network/socket_option_test.h
@@ -42,13 +42,15 @@ class SocketOptionTest : public testing::Test {
         .Times(AnyNumber())
         .WillRepeatedly(Invoke([this](os_fd_t sockfd, int level, int optname, const void* optval,
                                       socklen_t optlen) -> int {
-          return os_sys_calls_actual_.setsockopt(sockfd, level, optname, optval, optlen).rc_;
+          return os_sys_calls_actual_.setsockopt(sockfd, level, optname, optval, optlen)
+              .return_value_;
         }));
     EXPECT_CALL(os_sys_calls_, getsockopt_(_, _, _, _, _))
         .Times(AnyNumber())
         .WillRepeatedly(Invoke(
             [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-              return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+              return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                  .return_value_;
             }));
     EXPECT_CALL(os_sys_calls_, getsockname(_, _, _))
         .Times(AnyNumber())
diff --git a/test/common/network/udp_listener_impl_batch_writer_test.cc b/test/common/network/udp_listener_impl_batch_writer_test.cc
index 817553ef10184..7e6f1ec296242 100644
--- a/test/common/network/udp_listener_impl_batch_writer_test.cc
+++ b/test/common/network/udp_listener_impl_batch_writer_test.cc
@@ -113,7 +113,7 @@ TEST_P(UdpListenerImplBatchWriterTest, SendData) {
 
     auto send_result = listener_->send(send_data);
     EXPECT_TRUE(send_result.ok()) << "send() failed : " << send_result.err_->getErrorDetails();
-    EXPECT_EQ(send_result.rc_, payload.length());
+    EXPECT_EQ(send_result.return_value_, payload.length());
 
     // Verify udp_packet_writer stats for batch writing
     if (internal_buffer.length() == 0 ||       /* internal buffer is empty*/
@@ -202,7 +202,7 @@ TEST_P(UdpListenerImplBatchWriterTest, WriteBlocked) {
     auto send_result = listener_->send(initial_send_data);
     internal_buffer.append(initial_payload);
     EXPECT_TRUE(send_result.ok());
-    EXPECT_EQ(send_result.rc_, initial_payload.length());
+    EXPECT_EQ(send_result.return_value_, initial_payload.length());
     EXPECT_FALSE(udp_packet_writer_->isWriteBlocked());
     EXPECT_EQ(listener_config_.listenerScope()
                   .gaugeFromString("internal_buffer_size", Stats::Gauge::ImportMode::NeverImport)
@@ -229,12 +229,12 @@ TEST_P(UdpListenerImplBatchWriterTest, WriteBlocked) {
       // The following payload should get buffered if it is
       // shorter than initial payload
       EXPECT_TRUE(send_result.ok());
-      EXPECT_EQ(send_result.rc_, following_payload.length());
+      EXPECT_EQ(send_result.return_value_, following_payload.length());
       EXPECT_TRUE(udp_packet_writer_->isWriteBlocked());
       internal_buffer.append(following_payload);
     } else {
       EXPECT_FALSE(send_result.ok());
-      EXPECT_EQ(send_result.rc_, 0);
+      EXPECT_EQ(send_result.return_value_, 0);
     }
     EXPECT_TRUE(udp_packet_writer_->isWriteBlocked());
     EXPECT_EQ(listener_config_.listenerScope().counterFromString("total_bytes_sent").value(),
@@ -253,7 +253,7 @@ TEST_P(UdpListenerImplBatchWriterTest, WriteBlocked) {
         }));
     auto flush_result = udp_packet_writer_->flush();
     EXPECT_TRUE(flush_result.ok());
-    EXPECT_EQ(flush_result.rc_, 0);
+    EXPECT_EQ(flush_result.return_value_, 0);
     EXPECT_FALSE(udp_packet_writer_->isWriteBlocked());
     EXPECT_EQ(listener_config_.listenerScope()
                   .gaugeFromString("internal_buffer_size", Stats::Gauge::ImportMode::NeverImport)
diff --git a/test/common/network/udp_listener_impl_test.cc b/test/common/network/udp_listener_impl_test.cc
index 1561d4ba05b6d..21e640de9c5a3 100644
--- a/test/common/network/udp_listener_impl_test.cc
+++ b/test/common/network/udp_listener_impl_test.cc
@@ -85,7 +85,7 @@ class UdpListenerImplTest : public UdpListenerImplTestBase {
     socklen_t int_size = static_cast<socklen_t>(sizeof(get_recvbuf_size));
     const Api::SysCallIntResult result2 =
         server_socket_->getSocketOption(SOL_SOCKET, SO_RCVBUF, &get_recvbuf_size, &int_size);
-    EXPECT_EQ(0, result2.rc_);
+    EXPECT_EQ(0, result2.return_value_);
     // Kernel increases the buffer size to allow bookkeeping overhead.
     if (get_recvbuf_size < 4 * 1024 * 1024) {
       recvbuf_large_enough_ = false;
@@ -318,14 +318,14 @@ TEST_P(UdpListenerImplTest, UdpEcho) {
                                                   1, nullptr, *test_peer_address);
 
         if (send_rc.ok()) {
-          total_sent += send_rc.rc_;
+          total_sent += send_rc.return_value_;
           if (total_sent >= data_size) {
             break;
           }
         } else if (send_rc.err_->getErrorCode() != Api::IoError::IoErrorCode::Again) {
           break;
         }
-      } while (((send_rc.rc_ == 0) &&
+      } while (((send_rc.return_value_ == 0) &&
                 (send_rc.err_->getErrorCode() == Api::IoError::IoErrorCode::Again)) ||
                (total_sent < data_size));
 
@@ -460,7 +460,7 @@ TEST_P(UdpListenerImplTest, SendData) {
   // Verify External Flush is a No-op
   auto flush_result = udp_packet_writer_->flush();
   EXPECT_TRUE(flush_result.ok());
-  EXPECT_EQ(0, flush_result.rc_);
+  EXPECT_EQ(0, flush_result.return_value_);
 }
 
 /**
diff --git a/test/common/quic/active_quic_listener_test.cc b/test/common/quic/active_quic_listener_test.cc
index 100e60657e1c4..13da84735c546 100644
--- a/test/common/quic/active_quic_listener_test.cc
+++ b/test/common/quic/active_quic_listener_test.cc
@@ -219,7 +219,7 @@ class ActiveQuicListenerTest : public QuicMultiVersionTest {
     auto send_rc =
         Network::Utility::writeToSocket(client_sockets_.back()->ioHandle(), slice.data(), 1,
                                         nullptr, *listen_socket_->addressProvider().localAddress());
-    ASSERT_EQ(slice[0].len_, send_rc.rc_);
+    ASSERT_EQ(slice[0].len_, send_rc.return_value_);
 
 #if defined(__APPLE__)
     // This sleep makes the tests pass more reliably. Some debugging showed that without this,
@@ -242,7 +242,7 @@ class ActiveQuicListenerTest : public QuicMultiVersionTest {
             client_socket->ioHandle().read(*result_buffer, bytes_to_read - bytes_read);
 
         if (result.ok()) {
-          bytes_read += result.rc_;
+          bytes_read += result.return_value_;
         } else if (retry == 10 || result.err_->getErrorCode() != Api::IoError::IoErrorCode::Again) {
           break;
         }
diff --git a/test/common/quic/platform/quic_test_output_impl.cc b/test/common/quic/platform/quic_test_output_impl.cc
index 94290fffdcde4..45da4d97d7661 100644
--- a/test/common/quic/platform/quic_test_output_impl.cc
+++ b/test/common/quic/platform/quic_test_output_impl.cc
@@ -51,12 +51,12 @@ void quicRecordTestOutputToFile(const std::string& filename, absl::string_view d
   Envoy::Filesystem::FilePathAndType new_file_info{Envoy::Filesystem::DestinationType::File,
                                                    output_path};
   Envoy::Filesystem::FilePtr file = file_system.createFile(new_file_info);
-  if (!file->open(DefaultFlags).rc_) {
+  if (!file->open(DefaultFlags).return_value_) {
     QUIC_LOG(ERROR) << "Failed to open test output file: " << output_path;
     return;
   }
 
-  if (file->write(data).rc_ != static_cast<ssize_t>(data.size())) {
+  if (file->write(data).return_value_ != static_cast<ssize_t>(data.size())) {
     QUIC_LOG(ERROR) << "Failed to write to test output file: " << output_path;
   } else {
     QUIC_LOG(INFO) << "Recorded test output into " << output_path;
diff --git a/test/extensions/filters/listener/common/fuzz/fuzzed_input_test.cc b/test/extensions/filters/listener/common/fuzz/fuzzed_input_test.cc
index 54c3cb7314e7a..856980e1fc638 100644
--- a/test/extensions/filters/listener/common/fuzz/fuzzed_input_test.cc
+++ b/test/extensions/filters/listener/common/fuzz/fuzzed_input_test.cc
@@ -27,19 +27,19 @@ TEST(FuzzedInputStream, OneRead) {
   std::array<uint8_t, 5> read_data;
 
   // Test peeking
-  EXPECT_EQ(data.read(read_data.data(), 5, true).rc_, 5);
+  EXPECT_EQ(data.read(read_data.data(), 5, true).return_value_, 5);
   EXPECT_EQ(data.size(), 5);
 
   // Test length > data.size()
-  EXPECT_EQ(data.read(read_data.data(), 10, true).rc_, 5);
+  EXPECT_EQ(data.read(read_data.data(), 10, true).return_value_, 5);
   EXPECT_EQ(data.size(), 5);
 
   // Test non-peeking
-  EXPECT_EQ(data.read(read_data.data(), 3, false).rc_, 3);
+  EXPECT_EQ(data.read(read_data.data(), 3, false).return_value_, 3);
   EXPECT_EQ(data.size(), 2);
 
   // Test reaching end-of-stream
-  EXPECT_EQ(data.read(read_data.data(), 5, false).rc_, 2);
+  EXPECT_EQ(data.read(read_data.data(), 5, false).return_value_, 2);
   EXPECT_EQ(data.size(), 0);
 }
 
@@ -54,7 +54,7 @@ TEST(FuzzedInputStream, MultipleReads) {
   std::array<uint8_t, 5> read_data;
 
   // Test peeking (first read)
-  EXPECT_EQ(data.read(read_data.data(), 5, true).rc_, 2);
+  EXPECT_EQ(data.read(read_data.data(), 5, true).return_value_, 2);
   EXPECT_EQ(data.size(), 2);
 
   data.next();
@@ -62,7 +62,7 @@ TEST(FuzzedInputStream, MultipleReads) {
   EXPECT_EQ(data.size(), 4);
 
   // Test non-peeking (second read)
-  EXPECT_EQ(data.read(read_data.data(), 3, false).rc_, 3);
+  EXPECT_EQ(data.read(read_data.data(), 3, false).return_value_, 3);
   EXPECT_EQ(data.size(), 1);
 
   data.next();
@@ -70,7 +70,7 @@ TEST(FuzzedInputStream, MultipleReads) {
   EXPECT_EQ(data.size(), 2);
 
   // Test non-peeking (third read) and reaching end-of-stream
-  EXPECT_EQ(data.read(read_data.data(), 5, false).rc_, 2);
+  EXPECT_EQ(data.read(read_data.data(), 5, false).return_value_, 2);
   EXPECT_EQ(data.size(), 0);
 }
 
diff --git a/test/extensions/filters/listener/proxy_protocol/proxy_protocol_test.cc b/test/extensions/filters/listener/proxy_protocol/proxy_protocol_test.cc
index e9cc8f02ec022..5de9c4c9e4e7e 100644
--- a/test/extensions/filters/listener/proxy_protocol/proxy_protocol_test.cc
+++ b/test/extensions/filters/listener/proxy_protocol/proxy_protocol_test.cc
@@ -335,7 +335,8 @@ TEST_P(ProxyProtocolTest, ErrorRecv_2) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(
           [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                .return_value_;
           }));
   EXPECT_CALL(os_sys_calls, getsockname(_, _, _))
       .Times(AnyNumber())
@@ -395,7 +396,8 @@ TEST_P(ProxyProtocolTest, ErrorRecv_1) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(
           [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                .return_value_;
           }));
   EXPECT_CALL(os_sys_calls, getsockname(_, _, _))
       .Times(AnyNumber())
@@ -605,7 +607,7 @@ TEST_P(ProxyProtocolTest, V2ParseExtensionsRecvError) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke([this](os_fd_t fd, void* buf, size_t n, int flags) {
         const Api::SysCallSizeResult x = os_sys_calls_actual_.recv(fd, buf, n, flags);
-        if (x.rc_ == sizeof(tlv)) {
+        if (x.return_value_ == sizeof(tlv)) {
           return Api::SysCallSizeResult{-1, 0};
         } else {
           return x;
@@ -630,7 +632,8 @@ TEST_P(ProxyProtocolTest, V2ParseExtensionsRecvError) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(
           [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                .return_value_;
           }));
   EXPECT_CALL(os_sys_calls, getsockname(_, _, _))
       .Times(AnyNumber())
@@ -782,7 +785,8 @@ TEST_P(ProxyProtocolTest, V2Fragmented3Error) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(
           [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                .return_value_;
           }));
   EXPECT_CALL(os_sys_calls, getsockname(_, _, _))
       .Times(AnyNumber())
@@ -848,7 +852,8 @@ TEST_P(ProxyProtocolTest, V2Fragmented4Error) {
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(
           [this](os_fd_t sockfd, int level, int optname, void* optval, socklen_t* optlen) -> int {
-            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen).rc_;
+            return os_sys_calls_actual_.getsockopt(sockfd, level, optname, optval, optlen)
+                .return_value_;
           }));
   EXPECT_CALL(os_sys_calls, getsockname(_, _, _))
       .Times(AnyNumber())
diff --git a/test/extensions/filters/udp/dns_filter/dns_filter_test.cc b/test/extensions/filters/udp/dns_filter/dns_filter_test.cc
index 28a2c6fac665a..db9d906fff1fd 100644
--- a/test/extensions/filters/udp/dns_filter/dns_filter_test.cc
+++ b/test/extensions/filters/udp/dns_filter/dns_filter_test.cc
@@ -32,7 +32,7 @@ namespace {
 
 Api::IoCallUint64Result makeNoError(uint64_t rc) {
   auto no_error = Api::ioCallUint64ResultNoError();
-  no_error.rc_ = rc;
+  no_error.return_value_ = rc;
   return no_error;
 }
 
diff --git a/test/extensions/filters/udp/udp_proxy/udp_proxy_filter_test.cc b/test/extensions/filters/udp/udp_proxy/udp_proxy_filter_test.cc
index 8e56df53c6cec..f59a51f7a833c 100644
--- a/test/extensions/filters/udp/udp_proxy/udp_proxy_filter_test.cc
+++ b/test/extensions/filters/udp/udp_proxy/udp_proxy_filter_test.cc
@@ -42,7 +42,7 @@ class TestUdpProxyFilter : public UdpProxyFilter {
 
 Api::IoCallUint64Result makeNoError(uint64_t rc) {
   auto no_error = Api::ioCallUint64ResultNoError();
-  no_error.rc_ = rc;
+  no_error.return_value_ = rc;
   return no_error;
 }
 
diff --git a/test/extensions/io_socket/user_space/io_handle_impl_test.cc b/test/extensions/io_socket/user_space/io_handle_impl_test.cc
index 83f8cd0ee3e72..fab734bb395d6 100644
--- a/test/extensions/io_socket/user_space/io_handle_impl_test.cc
+++ b/test/extensions/io_socket/user_space/io_handle_impl_test.cc
@@ -61,8 +61,8 @@ TEST_F(IoHandleImplTest, BasicRecv) {
   io_handle_peer_->write(buf_to_write);
   {
     auto result = io_handle_->recv(buf_.data(), buf_.size(), 0);
-    ASSERT_EQ(10, result.rc_);
-    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.rc_));
+    ASSERT_EQ(10, result.return_value_);
+    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.return_value_));
   }
   {
     auto result = io_handle_->recv(buf_.data(), buf_.size(), 0);
@@ -84,22 +84,22 @@ TEST_F(IoHandleImplTest, RecvPeek) {
   {
     ::memset(buf_.data(), 1, buf_.size());
     auto result = io_handle_->recv(buf_.data(), 5, MSG_PEEK);
-    ASSERT_EQ(5, result.rc_);
-    ASSERT_EQ("01234", absl::string_view(buf_.data(), result.rc_));
+    ASSERT_EQ(5, result.return_value_);
+    ASSERT_EQ("01234", absl::string_view(buf_.data(), result.return_value_));
     // The data beyond the boundary is untouched.
     ASSERT_EQ(std::string(buf_.size() - 5, 1), absl::string_view(buf_.data() + 5, buf_.size() - 5));
   }
   {
     auto result = io_handle_->recv(buf_.data(), buf_.size(), MSG_PEEK);
-    ASSERT_EQ(10, result.rc_);
-    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.rc_));
+    ASSERT_EQ(10, result.return_value_);
+    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.return_value_));
   }
   {
     // Drain the pending buffer.
     auto recv_result = io_handle_->recv(buf_.data(), buf_.size(), 0);
     EXPECT_TRUE(recv_result.ok());
-    EXPECT_EQ(10, recv_result.rc_);
-    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), recv_result.rc_));
+    EXPECT_EQ(10, recv_result.return_value_);
+    ASSERT_EQ("0123456789", absl::string_view(buf_.data(), recv_result.return_value_));
     auto peek_result = io_handle_->recv(buf_.data(), buf_.size(), 0);
     // `EAGAIN`.
     EXPECT_FALSE(peek_result.ok());
@@ -109,7 +109,7 @@ TEST_F(IoHandleImplTest, RecvPeek) {
     // Peek upon shutdown.
     io_handle_->setWriteEnd();
     auto result = io_handle_->recv(buf_.data(), buf_.size(), MSG_PEEK);
-    EXPECT_EQ(0, result.rc_);
+    EXPECT_EQ(0, result.return_value_);
     ASSERT(result.ok());
   }
 }
@@ -118,8 +118,8 @@ TEST_F(IoHandleImplTest, RecvPeekWhenPendingDataButShutdown) {
   Buffer::OwnedImpl buf_to_write("0123456789");
   io_handle_peer_->write(buf_to_write);
   auto result = io_handle_->recv(buf_.data(), buf_.size(), MSG_PEEK);
-  ASSERT_EQ(10, result.rc_);
-  ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.rc_));
+  ASSERT_EQ(10, result.return_value_);
+  ASSERT_EQ("0123456789", absl::string_view(buf_.data(), result.return_value_));
 }
 
 TEST_F(IoHandleImplTest, MultipleRecvDrain) {
@@ -128,13 +128,13 @@ TEST_F(IoHandleImplTest, MultipleRecvDrain) {
   {
     auto result = io_handle_->recv(buf_.data(), 1, 0);
     EXPECT_TRUE(result.ok());
-    EXPECT_EQ(1, result.rc_);
+    EXPECT_EQ(1, result.return_value_);
     EXPECT_EQ("a", absl::string_view(buf_.data(), 1));
   }
   {
     auto result = io_handle_->recv(buf_.data(), buf_.size(), 0);
     EXPECT_TRUE(result.ok());
-    EXPECT_EQ(3, result.rc_);
+    EXPECT_EQ(3, result.return_value_);
 
     EXPECT_EQ("bcd", absl::string_view(buf_.data(), 3));
     EXPECT_EQ(0, io_handle_->getWriteBuffer()->length());
@@ -150,7 +150,7 @@ TEST_F(IoHandleImplTest, ReadEmpty) {
   io_handle_->setWriteEnd();
   result = io_handle_->read(buf, 10);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
 }
 
 // Read allows max_length value 0 and returns no error.
@@ -159,7 +159,7 @@ TEST_F(IoHandleImplTest, ReadWhileProvidingNoCapacity) {
   absl::optional<uint64_t> max_length_opt{0};
   auto result = io_handle_->read(buf, max_length_opt);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
 }
 
 // Test read side effects.
@@ -170,12 +170,12 @@ TEST_F(IoHandleImplTest, ReadContent) {
   Buffer::OwnedImpl buf;
   auto result = io_handle_->read(buf, 3);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(3, result.rc_);
+  EXPECT_EQ(3, result.return_value_);
   ASSERT_EQ(3, buf.length());
   ASSERT_EQ(4, io_handle_->getWriteBuffer()->length());
   result = io_handle_->read(buf, 10);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(4, result.rc_);
+  EXPECT_EQ(4, result.return_value_);
   ASSERT_EQ(7, buf.length());
   ASSERT_EQ(0, io_handle_->getWriteBuffer()->length());
 }
@@ -194,7 +194,7 @@ TEST_F(IoHandleImplTest, ReadThrottling) {
     // Read at most 8 * FRAGMENT_SIZE to unlimited buffer.
     auto result0 = io_handle_->read(unlimited_buf, absl::nullopt);
     EXPECT_TRUE(result0.ok());
-    EXPECT_EQ(result0.rc_, 8 * FRAGMENT_SIZE);
+    EXPECT_EQ(result0.return_value_, 8 * FRAGMENT_SIZE);
     EXPECT_EQ(unlimited_buf.length(), 8 * FRAGMENT_SIZE);
     EXPECT_EQ(unlimited_buf.toString(), std::string(8 * FRAGMENT_SIZE, 'a'));
   }
@@ -205,7 +205,7 @@ TEST_F(IoHandleImplTest, ReadThrottling) {
     // Verify that read() populates the buf to high watermark.
     auto result = io_handle_->read(buf, 8 * FRAGMENT_SIZE + 1);
     EXPECT_TRUE(result.ok());
-    EXPECT_EQ(result.rc_, FRAGMENT_SIZE + 1);
+    EXPECT_EQ(result.return_value_, FRAGMENT_SIZE + 1);
     EXPECT_EQ(buf.length(), FRAGMENT_SIZE + 1);
     EXPECT_FALSE(buf.highWatermarkTriggered());
     EXPECT_EQ(buf.toString(), std::string(FRAGMENT_SIZE + 1, 'a'));
@@ -215,7 +215,7 @@ TEST_F(IoHandleImplTest, ReadThrottling) {
     // Verify that read returns FRAGMENT_SIZE if the buf is over high watermark.
     auto result1 = io_handle_->read(buf, 8 * FRAGMENT_SIZE + 1);
     EXPECT_TRUE(result1.ok());
-    EXPECT_EQ(result1.rc_, FRAGMENT_SIZE);
+    EXPECT_EQ(result1.return_value_, FRAGMENT_SIZE);
     EXPECT_EQ(buf.length(), 2 * FRAGMENT_SIZE + 1);
     EXPECT_TRUE(buf.highWatermarkTriggered());
     EXPECT_EQ(buf.toString(), std::string(2 * FRAGMENT_SIZE + 1, 'a'));
@@ -228,7 +228,7 @@ TEST_F(IoHandleImplTest, ReadThrottling) {
     EXPECT_TRUE(buf.highWatermarkTriggered());
     auto result2 = io_handle_->read(buf, 8 * FRAGMENT_SIZE + 1);
     EXPECT_TRUE(result2.ok());
-    EXPECT_EQ(result2.rc_, FRAGMENT_SIZE);
+    EXPECT_EQ(result2.return_value_, FRAGMENT_SIZE);
     EXPECT_TRUE(buf.highWatermarkTriggered());
     EXPECT_EQ(buf.toString(), std::string(buf.highWatermark() - 1 + FRAGMENT_SIZE, 'a'));
   }
@@ -243,7 +243,7 @@ TEST_F(IoHandleImplTest, ReadThrottling) {
     EXPECT_FALSE(buf.highWatermarkTriggered());
     auto result3 = io_handle_->read(buf, 8 * FRAGMENT_SIZE + 1);
     EXPECT_TRUE(result3.ok());
-    EXPECT_EQ(result3.rc_, FRAGMENT_SIZE);
+    EXPECT_EQ(result3.return_value_, FRAGMENT_SIZE);
     EXPECT_TRUE(buf.highWatermarkTriggered());
     EXPECT_EQ(buf.toString(), std::string(buf.highWatermark() - 1 + FRAGMENT_SIZE, 'a'));
   }
@@ -260,7 +260,7 @@ TEST_F(IoHandleImplTest, BasicReadv) {
   auto result = io_handle_->readv(1024, &slice, 1);
 
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(3, result.rc_);
+  EXPECT_EQ(3, result.return_value_);
 
   result = io_handle_->readv(1024, &slice, 1);
 
@@ -271,7 +271,7 @@ TEST_F(IoHandleImplTest, BasicReadv) {
   result = io_handle_->readv(1024, &slice, 1);
   // EOF
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(0, result.rc_);
+  EXPECT_EQ(0, result.return_value_);
 }
 
 // Test readv on slices.
@@ -286,7 +286,7 @@ TEST_F(IoHandleImplTest, ReadvMultiSlices) {
 
   EXPECT_EQ(absl::string_view(full_frag, 1024), std::string(1024, 'a'));
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(1024, result.rc_);
+  EXPECT_EQ(1024, result.return_value_);
 }
 
 TEST_F(IoHandleImplTest, FlowControl) {
@@ -318,7 +318,7 @@ TEST_F(IoHandleImplTest, FlowControl) {
     }
     auto result = io_handle_->recv(buf_.data(), 32, 0);
     EXPECT_TRUE(result.ok());
-    EXPECT_EQ(32, result.rc_);
+    EXPECT_EQ(32, result.return_value_);
   }
   ASSERT_EQ(0, internal_buffer.length());
   ASSERT_TRUE(writable_flipped);
@@ -334,13 +334,13 @@ TEST_F(IoHandleImplTest, NoErrorWriteZeroDataToClosedIoHandle) {
   {
     Buffer::OwnedImpl buf;
     auto result = io_handle_->write(buf);
-    ASSERT_EQ(0, result.rc_);
+    ASSERT_EQ(0, result.return_value_);
     ASSERT(result.ok());
   }
   {
     Buffer::RawSlice slice{nullptr, 0};
     auto result = io_handle_->writev(&slice, 1);
-    ASSERT_EQ(0, result.rc_);
+    ASSERT_EQ(0, result.return_value_);
     ASSERT(result.ok());
   }
 }
@@ -382,8 +382,8 @@ TEST_F(IoHandleImplTest, ErrorOnClosedIoHandle) {
 }
 
 TEST_F(IoHandleImplTest, RepeatedShutdownWR) {
-  EXPECT_EQ(io_handle_peer_->shutdown(ENVOY_SHUT_WR).rc_, 0);
-  EXPECT_EQ(io_handle_peer_->shutdown(ENVOY_SHUT_WR).rc_, 0);
+  EXPECT_EQ(io_handle_peer_->shutdown(ENVOY_SHUT_WR).return_value_, 0);
+  EXPECT_EQ(io_handle_peer_->shutdown(ENVOY_SHUT_WR).return_value_, 0);
 }
 
 TEST_F(IoHandleImplTest, ShutDownOptionsNotSupported) {
@@ -395,7 +395,7 @@ TEST_F(IoHandleImplTest, WriteByMove) {
   Buffer::OwnedImpl buf("0123456789");
   auto result = io_handle_peer_->write(buf);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(10, result.rc_);
+  EXPECT_EQ(10, result.return_value_);
   EXPECT_EQ("0123456789", io_handle_->getWriteBuffer()->toString());
   EXPECT_EQ(0, buf.length());
 }
@@ -425,7 +425,7 @@ TEST_F(IoHandleImplTest, PartialWrite) {
     // is not triggered.
     auto result = io_handle_->write(pending_data);
     EXPECT_TRUE(result.ok());
-    EXPECT_EQ(result.rc_, FRAGMENT_SIZE + 1);
+    EXPECT_EQ(result.return_value_, FRAGMENT_SIZE + 1);
     EXPECT_EQ(pending_data.length(), INITIAL_SIZE - (FRAGMENT_SIZE + 1));
     EXPECT_TRUE(io_handle_peer_->isWritable());
     EXPECT_EQ(io_handle_peer_->getWriteBuffer()->toString(), std::string(FRAGMENT_SIZE + 1, 'a'));
@@ -434,7 +434,7 @@ TEST_F(IoHandleImplTest, PartialWrite) {
     // Write another fragment since when high watermark is reached.
     auto result1 = io_handle_->write(pending_data);
     EXPECT_TRUE(result1.ok());
-    EXPECT_EQ(result1.rc_, FRAGMENT_SIZE);
+    EXPECT_EQ(result1.return_value_, FRAGMENT_SIZE);
     EXPECT_EQ(pending_data.length(), INITIAL_SIZE - (FRAGMENT_SIZE + 1) - FRAGMENT_SIZE);
     EXPECT_FALSE(io_handle_peer_->isWritable());
     EXPECT_EQ(io_handle_peer_->getWriteBuffer()->toString(),
@@ -444,14 +444,14 @@ TEST_F(IoHandleImplTest, PartialWrite) {
     // Confirm that the further write return `EAGAIN`.
     auto result2 = io_handle_->write(pending_data);
     ASSERT_EQ(result2.err_->getErrorCode(), Api::IoError::IoErrorCode::Again);
-    ASSERT_EQ(result2.rc_, 0);
+    ASSERT_EQ(result2.return_value_, 0);
   }
   {
     // Make the peer writable again.
     Buffer::OwnedImpl black_hole_buffer;
     auto result_drain =
         io_handle_peer_->read(black_hole_buffer, FRAGMENT_SIZE + FRAGMENT_SIZE / 2 + 2);
-    ASSERT_EQ(result_drain.rc_, FRAGMENT_SIZE + FRAGMENT_SIZE / 2 + 2);
+    ASSERT_EQ(result_drain.return_value_, FRAGMENT_SIZE + FRAGMENT_SIZE / 2 + 2);
     EXPECT_TRUE(io_handle_peer_->isWritable());
   }
   {
@@ -461,7 +461,7 @@ TEST_F(IoHandleImplTest, PartialWrite) {
     EXPECT_LT(io_handle_peer_->getWriteBuffer()->highWatermark() - len, FRAGMENT_SIZE);
     EXPECT_GT(pending_data.length(), FRAGMENT_SIZE);
     auto result3 = io_handle_->write(pending_data);
-    EXPECT_EQ(result3.rc_, FRAGMENT_SIZE);
+    EXPECT_EQ(result3.return_value_, FRAGMENT_SIZE);
     EXPECT_FALSE(io_handle_peer_->isWritable());
     EXPECT_EQ(io_handle_peer_->getWriteBuffer()->toString(), std::string(len + FRAGMENT_SIZE, 'a'));
   }
@@ -511,8 +511,8 @@ TEST_F(IoHandleImplTest, PartialWritev) {
   EXPECT_EQ(3, slices.size());
   auto result = io_handle_->writev(slices.data(), slices.size());
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(result.rc_, 256);
-  pending_data.drain(result.rc_);
+  EXPECT_EQ(result.return_value_, 256);
+  pending_data.drain(result.return_value_);
   EXPECT_EQ(pending_data.length(), 3);
   EXPECT_FALSE(io_handle_peer_->isWritable());
 
@@ -527,8 +527,8 @@ TEST_F(IoHandleImplTest, PartialWritev) {
   EXPECT_TRUE(io_handle_peer_->isWritable());
   auto slices3 = pending_data.getRawSlices();
   auto result3 = io_handle_->writev(slices3.data(), slices3.size());
-  EXPECT_EQ(result3.rc_, 3);
-  pending_data.drain(result3.rc_);
+  EXPECT_EQ(result3.return_value_, 3);
+  pending_data.drain(result3.return_value_);
   EXPECT_EQ(0, pending_data.length());
 }
 
@@ -639,7 +639,7 @@ TEST_F(IoHandleImplTest, ReadAndWriteAreEdgeTriggered) {
   // Drain 1 bytes.
   auto result = io_handle_->recv(buf_.data(), 1, 0);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(1, result.rc_);
+  EXPECT_EQ(1, result.return_value_);
 
   ASSERT_FALSE(schedulable_cb->enabled_);
   io_handle_->resetFileEvents();
@@ -733,11 +733,11 @@ TEST_F(IoHandleImplTest, Close) {
             auto result = io_handle_->recv(buf_.data(), buf_.size(), 0);
             if (result.ok()) {
               // Read EOF.
-              if (result.rc_ == 0) {
+              if (result.return_value_ == 0) {
                 should_close = true;
                 break;
               } else {
-                accumulator += std::string(buf_.data(), result.rc_);
+                accumulator += std::string(buf_.data(), result.return_value_);
               }
             } else if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
               ENVOY_LOG_MISC(debug, "read returns EAGAIN");
@@ -792,7 +792,7 @@ TEST_F(IoHandleImplTest, ShutDownRaiseEvent) {
         if (events & Event::FileReadyType::Read) {
           auto result = io_handle_->recv(buf_.data(), buf_.size(), 0);
           if (result.ok()) {
-            accumulator += std::string(buf_.data(), result.rc_);
+            accumulator += std::string(buf_.data(), result.return_value_);
           } else if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
             ENVOY_LOG_MISC(debug, "read returns EAGAIN");
           } else {
@@ -832,7 +832,7 @@ TEST_F(IoHandleImplTest, WriteScheduleWritableEvent) {
           auto slice = reservation.slice();
           auto result = handle->readv(1024, &slice, 1);
           if (result.ok()) {
-            accumulator += std::string(static_cast<char*>(slice.mem_), result.rc_);
+            accumulator += std::string(static_cast<char*>(slice.mem_), result.return_value_);
           } else if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
             ENVOY_LOG_MISC(debug, "read returns EAGAIN");
           } else {
@@ -872,7 +872,7 @@ TEST_F(IoHandleImplTest, WritevScheduleWritableEvent) {
           auto slice = reservation.slice();
           auto result = handle->readv(1024, &slice, 1);
           if (result.ok()) {
-            accumulator += std::string(static_cast<char*>(slice.mem_), result.rc_);
+            accumulator += std::string(static_cast<char*>(slice.mem_), result.return_value_);
           } else if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
             ENVOY_LOG_MISC(debug, "read returns EAGAIN");
           } else {
@@ -913,10 +913,10 @@ TEST_F(IoHandleImplTest, ReadAfterShutdownWrite) {
           auto slice = reservation.slice();
           auto result = handle->readv(1024, &slice, 1);
           if (result.ok()) {
-            if (result.rc_ == 0) {
+            if (result.return_value_ == 0) {
               should_close = true;
             } else {
-              accumulator += std::string(static_cast<char*>(slice.mem_), result.rc_);
+              accumulator += std::string(static_cast<char*>(slice.mem_), result.return_value_);
             }
           } else if (result.err_->getErrorCode() == Api::IoError::IoErrorCode::Again) {
             ENVOY_LOG_MISC(debug, "read returns EAGAIN");
@@ -966,13 +966,13 @@ TEST_F(IoHandleImplTest, NotifyWritableAfterShutdownWrite) {
 
   EXPECT_CALL(*schedulable_cb, scheduleCallbackNextIteration()).Times(0);
   auto result = io_handle_peer_->recv(buf_.data(), buf_.size(), 0);
-  EXPECT_EQ(256, result.rc_);
+  EXPECT_EQ(256, result.return_value_);
   // Readable event is not activated due to edge trigger type.
   EXPECT_FALSE(schedulable_cb->enabled_);
 
   // The `end of stream` is delivered.
   auto result_at_eof = io_handle_peer_->recv(buf_.data(), buf_.size(), 0);
-  EXPECT_EQ(0, result_at_eof.rc_);
+  EXPECT_EQ(0, result_at_eof.return_value_);
 
   // Also confirm `EOS` can triggered read ready event.
   EXPECT_CALL(*schedulable_cb, enabled());
@@ -1006,7 +1006,7 @@ TEST_F(IoHandleImplTest, DomainNullOpt) { EXPECT_FALSE(io_handle_->domain().has_
 TEST_F(IoHandleImplTest, Connect) {
   auto address_is_ignored =
       std::make_shared<Network::Address::EnvoyInternalInstance>("listener_id");
-  EXPECT_EQ(0, io_handle_->connect(address_is_ignored).rc_);
+  EXPECT_EQ(0, io_handle_->connect(address_is_ignored).return_value_);
 }
 
 TEST_F(IoHandleImplTest, ActivateEvent) {
diff --git a/test/extensions/stats_sinks/common/statsd/udp_statsd_test.cc b/test/extensions/stats_sinks/common/statsd/udp_statsd_test.cc
index 919f37a97910c..ed2f816fee84c 100644
--- a/test/extensions/stats_sinks/common/statsd/udp_statsd_test.cc
+++ b/test/extensions/stats_sinks/common/statsd/udp_statsd_test.cc
@@ -64,7 +64,7 @@ TEST(UdpOverUdsStatsdSinkTest, InitWithPipeAddress) {
 
   // Start the server.
   Network::SocketImpl sock(Network::Socket::Type::Datagram, uds_address, nullptr);
-  RELEASE_ASSERT(sock.setBlockingForTest(false).rc_ != -1, "");
+  RELEASE_ASSERT(sock.setBlockingForTest(false).return_value_ != -1, "");
   sock.bind(uds_address);
 
   // Do the flush which should have somewhere to write now.
diff --git a/test/integration/fake_upstream.cc b/test/integration/fake_upstream.cc
index 52ee01dd3dc89..d0dd2ee4a41a2 100644
--- a/test/integration/fake_upstream.cc
+++ b/test/integration/fake_upstream.cc
@@ -749,7 +749,7 @@ void FakeUpstream::sendUdpDatagram(const std::string& buffer,
   dispatcher_->post([this, buffer, peer] {
     const auto rc = Network::Utility::writeToSocket(socket_->ioHandle(), Buffer::OwnedImpl(buffer),
                                                     nullptr, *peer);
-    EXPECT_TRUE(rc.rc_ == buffer.length());
+    EXPECT_TRUE(rc.return_value_ == buffer.length());
   });
 }
 
@@ -770,7 +770,7 @@ testing::AssertionResult FakeUpstream::rawWriteConnection(uint32_t index, const
 
 void FakeUpstream::FakeListenSocketFactory::doFinalPreWorkerInit() {
   if (socket_->socketType() == Network::Socket::Type::Stream) {
-    ASSERT_EQ(0, socket_->ioHandle().listen(ENVOY_TCP_BACKLOG_SIZE).rc_);
+    ASSERT_EQ(0, socket_->ioHandle().listen(ENVOY_TCP_BACKLOG_SIZE).return_value_);
   } else {
     ASSERT(socket_->socketType() == Network::Socket::Type::Datagram);
     ASSERT_TRUE(Network::Socket::applyOptions(socket_->options(), *socket_,
diff --git a/test/integration/filters/test_socket_interface.cc b/test/integration/filters/test_socket_interface.cc
index cf0c1aa8a0de5..e32d5ace315ec 100644
--- a/test/integration/filters/test_socket_interface.cc
+++ b/test/integration/filters/test_socket_interface.cc
@@ -26,22 +26,22 @@ Api::IoCallUint64Result TestIoSocketHandle::writev(const Buffer::RawSlice* slice
 
 IoHandlePtr TestIoSocketHandle::accept(struct sockaddr* addr, socklen_t* addrlen) {
   auto result = Api::OsSysCallsSingleton::get().accept(fd_, addr, addrlen);
-  if (SOCKET_INVALID(result.rc_)) {
+  if (SOCKET_INVALID(result.return_value_)) {
     return nullptr;
   }
 
-  return std::make_unique<TestIoSocketHandle>(writev_override_, result.rc_, socket_v6only_,
-                                              domain_);
+  return std::make_unique<TestIoSocketHandle>(writev_override_, result.return_value_,
+                                              socket_v6only_, domain_);
 }
 
 IoHandlePtr TestIoSocketHandle::duplicate() {
   auto result = Api::OsSysCallsSingleton::get().duplicate(fd_);
-  if (result.rc_ == -1) {
+  if (result.return_value_ == -1) {
     throw EnvoyException(fmt::format("duplicate failed for '{}': ({}) {}", fd_, result.errno_,
                                      errorDetails(result.errno_)));
   }
-  return std::make_unique<TestIoSocketHandle>(writev_override_, result.rc_, socket_v6only_,
-                                              domain_);
+  return std::make_unique<TestIoSocketHandle>(writev_override_, result.return_value_,
+                                              socket_v6only_, domain_);
 }
 
 IoHandlePtr TestSocketInterface::makeSocket(int socket_fd, bool socket_v6only,
diff --git a/test/integration/overload_integration_test.cc b/test/integration/overload_integration_test.cc
index 33973434429c6..b9dfd3b6629cf 100644
--- a/test/integration/overload_integration_test.cc
+++ b/test/integration/overload_integration_test.cc
@@ -405,7 +405,8 @@ TEST_P(OverloadScaledTimerIntegrationTest, TlsHandshakeTimeout) {
     transport_callbacks->connection().dispatcher().exit();
     // Read some amount of data; what's more important is whether the socket was remote-closed. That
     // needs to be propagated to the socket.
-    return Network::IoResult{transport_callbacks->ioHandle().read(buffer, 2 * 1024).rc_ == 0
+    return Network::IoResult{transport_callbacks->ioHandle().read(buffer, 2 * 1024).return_value_ ==
+                                     0
                                  ? Network::PostIoAction::Close
                                  : Network::PostIoAction::KeepOpen,
                              0, false};
diff --git a/test/integration/uds_integration_test.cc b/test/integration/uds_integration_test.cc
index 11cfcd10efacb..3fb1ecfc70e11 100644
--- a/test/integration/uds_integration_test.cc
+++ b/test/integration/uds_integration_test.cc
@@ -105,7 +105,7 @@ TEST_P(UdsListenerIntegrationTest, TestSocketMode) {
 
   Api::OsSysCalls& os_sys_calls = Api::OsSysCallsSingleton::get();
   struct stat listener_stat;
-  EXPECT_EQ(os_sys_calls.stat(getListenerSocketName().c_str(), &listener_stat).rc_, 0);
+  EXPECT_EQ(os_sys_calls.stat(getListenerSocketName().c_str(), &listener_stat).return_value_, 0);
   if (mode_ == 0) {
     EXPECT_NE(listener_stat.st_mode & 0777, 0);
   } else {
diff --git a/test/mocks/filesystem/mocks.cc b/test/mocks/filesystem/mocks.cc
index 9ce4201006d6e..bbc1e17413b76 100644
--- a/test/mocks/filesystem/mocks.cc
+++ b/test/mocks/filesystem/mocks.cc
@@ -13,7 +13,7 @@ Api::IoCallBoolResult MockFile::open(FlagSet flag) {
   Thread::LockGuard lock(open_mutex_);
 
   Api::IoCallBoolResult result = open_(flag);
-  is_open_ = result.rc_;
+  is_open_ = result.return_value_;
   num_opens_++;
   open_event_.notifyOne();
 
@@ -35,7 +35,7 @@ Api::IoCallSizeResult MockFile::write(absl::string_view buffer) {
 
 Api::IoCallBoolResult MockFile::close() {
   Api::IoCallBoolResult result = close_();
-  is_open_ = !result.rc_;
+  is_open_ = !result.return_value_;
 
   return result;
 }
diff --git a/test/server/listener_manager_impl_test.cc b/test/server/listener_manager_impl_test.cc
index 20d61b146dee7..8a8139fa33275 100644
--- a/test/server/listener_manager_impl_test.cc
+++ b/test/server/listener_manager_impl_test.cc
@@ -1760,7 +1760,7 @@ name: foo
   )EOF";
 
   auto syscall_result = os_sys_calls_actual_.socket(AF_INET, SOCK_STREAM, 0);
-  ASSERT_TRUE(SOCKET_VALID(syscall_result.rc_));
+  ASSERT_TRUE(SOCKET_VALID(syscall_result.return_value_));
 
   ListenerHandle* listener_foo = expectListenerCreate(true, true);
   EXPECT_CALL(listener_factory_,
@@ -1799,7 +1799,7 @@ name: foo
   )EOF";
 
   auto syscall_result = os_sys_calls_actual_.socket(AF_INET, SOCK_STREAM, 0);
-  ASSERT_TRUE(SOCKET_VALID(syscall_result.rc_));
+  ASSERT_TRUE(SOCKET_VALID(syscall_result.return_value_));
 
   // On Windows if the socket has not been bound to an address with bind
   // the call to getsockname fails with `WSAEINVAL`. To avoid that we make sure
@@ -1808,7 +1808,7 @@ name: foo
       .WillByDefault(Invoke(
           [&](os_fd_t sockfd, const sockaddr* addr, socklen_t addrlen) -> Api::SysCallIntResult {
             Api::SysCallIntResult result = os_sys_calls_actual_.bind(sockfd, addr, addrlen);
-            ASSERT(result.rc_ >= 0);
+            ASSERT(result.return_value_ >= 0);
             return result;
           }));
   ListenerHandle* listener_foo = expectListenerCreate(true, true);
diff --git a/test/server/server_test.cc b/test/server/server_test.cc
index 5081f1a05315c..5d83592881f3b 100644
--- a/test/server/server_test.cc
+++ b/test/server/server_test.cc
@@ -1271,7 +1271,7 @@ void bindAndListenTcpSocket(const Network::Address::InstanceConstSharedPtr& addr
   auto socket = std::make_unique<Network::TcpListenSocket>(address, options, true);
   // Some kernels erroneously allow `bind` without SO_REUSEPORT for addresses
   // with some other socket already listening on it, see #7636.
-  if (SOCKET_FAILURE(socket->ioHandle().listen(1).rc_)) {
+  if (SOCKET_FAILURE(socket->ioHandle().listen(1).return_value_)) {
     // Mimic bind exception for the test simplicity.
     throw Network::SocketBindException(fmt::format("cannot listen: {}", errorDetails(errno)),
                                        errno);
diff --git a/test/test_common/environment.cc b/test/test_common/environment.cc
index d2d33a73c4e71..d7a3692199385 100644
--- a/test/test_common/environment.cc
+++ b/test/test_common/environment.cc
@@ -414,9 +414,9 @@ std::string TestEnvironment::writeStringToFileForTest(const std::string& filenam
   const Filesystem::FlagSet flags{1 << Filesystem::File::Operation::Write |
                                   1 << Filesystem::File::Operation::Create};
   const Api::IoCallBoolResult open_result = file->open(flags);
-  EXPECT_TRUE(open_result.rc_);
+  EXPECT_TRUE(open_result.return_value_);
   const Api::IoCallSizeResult result = file->write(contents);
-  EXPECT_EQ(contents.length(), result.rc_);
+  EXPECT_EQ(contents.length(), result.return_value_);
   return out_path;
 }
 
diff --git a/test/test_common/network_utility.cc b/test/test_common/network_utility.cc
index 976f2e2205e65..6cf11038fbd77 100644
--- a/test/test_common/network_utility.cc
+++ b/test/test_common/network_utility.cc
@@ -34,12 +34,12 @@ Address::InstanceConstSharedPtr findOrCheckFreePort(Address::InstanceConstShared
   // to set REUSEADDR on listener sockets created by tests using an address validated by this means.
   Api::SysCallIntResult result = sock.bind(addr_port);
   const char* failing_fn = nullptr;
-  if (result.rc_ != 0) {
+  if (result.return_value_ != 0) {
     failing_fn = "bind";
   } else if (type == Socket::Type::Stream) {
     // Try listening on the port also, if the type is TCP.
     result = sock.listen(1);
-    if (result.rc_ != 0) {
+    if (result.return_value_ != 0) {
       failing_fn = "listen";
     }
   }
@@ -171,7 +171,7 @@ bindFreeLoopbackPort(Address::IpVersion version, Socket::Type type, bool reuse_p
                          envoy::config::core::v3::SocketOption::STATE_PREBIND);
   }
   Api::SysCallIntResult result = sock->bind(addr);
-  if (0 != result.rc_) {
+  if (0 != result.return_value_) {
     sock->close();
     std::string msg = fmt::format("bind failed for address {} with error: {} ({})",
                                   addr->asString(), errorDetails(result.errno_), result.errno_);
@@ -232,13 +232,13 @@ UdpSyncPeer::UdpSyncPeer(Network::Address::IpVersion version, uint64_t max_rx_da
     : socket_(
           std::make_unique<UdpListenSocket>(getCanonicalLoopbackAddress(version), nullptr, true)),
       max_rx_datagram_size_(max_rx_datagram_size) {
-  RELEASE_ASSERT(socket_->setBlockingForTest(true).rc_ != -1, "");
+  RELEASE_ASSERT(socket_->setBlockingForTest(true).return_value_ != -1, "");
 }
 
 void UdpSyncPeer::write(const std::string& buffer, const Network::Address::Instance& peer) {
   const auto rc = Network::Utility::writeToSocket(socket_->ioHandle(), Buffer::OwnedImpl(buffer),
                                                   nullptr, peer);
-  ASSERT_EQ(rc.rc_, buffer.length());
+  ASSERT_EQ(rc.return_value_, buffer.length());
 }
 
 void UdpSyncPeer::recv(Network::UdpRecvData& datagram) {
diff --git a/test/test_common/network_utility.h b/test/test_common/network_utility.h
index 2eb6f82b2b180..ab60a012672cc 100644
--- a/test/test_common/network_utility.h
+++ b/test/test_common/network_utility.h
@@ -220,7 +220,7 @@ class TcpListenSocketImmediateListen : public Network::TcpListenSocket {
   TcpListenSocketImmediateListen(const Address::InstanceConstSharedPtr& address,
                                  const Network::Socket::OptionsSharedPtr& options = nullptr)
       : TcpListenSocket(address, options, true) {
-    EXPECT_EQ(0, io_handle_->listen(ENVOY_TCP_BACKLOG_SIZE).rc_);
+    EXPECT_EQ(0, io_handle_->listen(ENVOY_TCP_BACKLOG_SIZE).return_value_);
   }
 };