From 1826c0bed3ff413ef0d8ef90338acef068a9eaa0 Mon Sep 17 00:00:00 2001
From: Scott Hart <sdhart@google.com>
Date: Thu, 27 Aug 2026 19:20:09 -0400
Subject: [PATCH] chore: migrate from deprecated absl types to std equivalents

---
 MODULE.bazel                                  |  2 +-
 generator/internal/http_annotation_parser.cc  |  5 ++--
 .../internal/http_annotation_parser_test.cc   | 15 ++++++-----
 generator/internal/http_option_utils.cc       | 11 ++++----
 generator/internal/longrunning.cc             | 24 ++++++++---------
 .../minimal/internal/common_v2_resources.cc   |  7 ++---
 google/cloud/bigtable/column_family.h         |  6 ++---
 google/cloud/bigtable/filters.h               |  6 ++---
 .../bigtable/internal/default_row_reader.cc   |  7 ++---
 google/cloud/bigtable/mutations.h             |  5 ++--
 google/cloud/bigtable/table.h                 | 14 +++++-----
 google/cloud/bigtable/value_test.cc           |  2 +-
 google/cloud/future_generic.h                 |  3 +--
 google/cloud/internal/future_impl.h           |  5 ++--
 google/cloud/internal/future_then_impl.h      |  5 ++--
 google/cloud/internal/type_list.h             |  3 +--
 google/cloud/rest_options.h                   |  1 +
 .../cloud/spanner/internal/connection_impl.cc |  5 ++--
 google/cloud/storage/async/client.cc          |  9 ++++---
 google/cloud/storage/async/reader.cc          |  7 ++---
 google/cloud/storage/client.h                 |  3 +--
 google/cloud/storage/client_object_test.cc    |  3 ++-
 .../storage/examples/storage_async_samples.cc |  5 ++--
 .../examples/storage_object_samples.cc        | 17 ++++++------
 .../connection_impl_appendable_upload_test.cc |  9 ++++---
 .../async/connection_impl_read_test.cc        |  5 ++--
 .../async/connection_impl_upload_hash_test.cc | 13 ++++-----
 .../async/connection_impl_upload_test.cc      | 11 ++++----
 .../async/object_descriptor_reader_tracing.cc |  7 ++---
 .../async/reader_connection_resume.cc         |  7 ++---
 .../async/reader_connection_tracing.cc        |  7 ++---
 .../async/writer_connection_buffered.cc       | 27 ++++++++++---------
 .../internal/async/writer_connection_impl.cc  |  9 ++++---
 .../async/writer_connection_resumed.cc        | 21 ++++++++-------
 .../cloud/storage/internal/grpc/make_cord.h   |  3 +--
 .../internal/grpc/metrics_exporter_options.cc |  3 ++-
 google/cloud/storage/internal/tuple_filter.h  |  5 ++--
 .../list_objects_and_prefixes_reader.h        |  5 ++--
 .../tests/async_client_integration_test.cc    |  5 ++--
 .../storage/tests/object_integration_test.cc  | 25 ++++++++---------
 google/cloud/stream_range.h                   |  3 ++-
 .../cloud/testing_util/validate_metadata.cc   |  3 +--
 42 files changed, 180 insertions(+), 158 deletions(-)

diff --git a/MODULE.bazel b/MODULE.bazel
index 6f08aaec5e0e3..2348ef5558578 100644
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -23,7 +23,7 @@ module(
 bazel_dep(name = "platforms", version = "1.1.0")
 bazel_dep(name = "bazel_skylib", version = "1.9.2")
 bazel_dep(name = "rules_cc", version = "0.2.17")
-bazel_dep(name = "abseil-cpp", version = "20250814.2")
+bazel_dep(name = "abseil-cpp", version = "20260526.0")
 
 # For backwards compatibility with WORKSPACE.
 # The name "com_google_protobuf" is internally used by @bazel_tools,
diff --git a/generator/internal/http_annotation_parser.cc b/generator/internal/http_annotation_parser.cc
index 03096241d581a..2a188dfece8e0 100644
--- a/generator/internal/http_annotation_parser.cc
+++ b/generator/internal/http_annotation_parser.cc
@@ -19,6 +19,7 @@
 #include "absl/strings/str_cat.h"
 #include <cassert>
 #include <functional>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -246,7 +247,7 @@ StatusOr<PathTemplate> ParsePathTemplate(absl::string_view input) {
     return MakeParseError(input, v->end, " end of input", GCP_ERROR_INFO());
   }
   return PathTemplate{std::move(s->value),
-                      absl::get<std::string>(v->value.value)};
+                      std::get<std::string>(v->value.value)};
 }
 
 std::ostream& operator<<(std::ostream& os, PathTemplate::Segment const& rhs) {
@@ -263,7 +264,7 @@ std::ostream& operator<<(std::ostream& os, PathTemplate::Segment const& rhs) {
     }
   };
   os << "{";
-  absl::visit(Visitor{os}, rhs.value);
+  std::visit(Visitor{os}, rhs.value);
   os << "}";
   return os;
 }
diff --git a/generator/internal/http_annotation_parser_test.cc b/generator/internal/http_annotation_parser_test.cc
index ca6ea916b2978..f3ff0d980ba7f 100644
--- a/generator/internal/http_annotation_parser_test.cc
+++ b/generator/internal/http_annotation_parser_test.cc
@@ -17,6 +17,7 @@
 #include <gmock/gmock.h>
 #include <algorithm>
 #include <sstream>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -65,21 +66,21 @@ bool SameValues(PathTemplate::Segment const& a,
   struct Visitor {
     PathTemplate::Segment const& a;
     bool operator()(PathTemplate::Match const&) {
-      return absl::holds_alternative<PathTemplate::Match>(a.value);
+      return std::holds_alternative<PathTemplate::Match>(a.value);
     }
     bool operator()(PathTemplate::MatchRecursive const&) {
-      return absl::holds_alternative<PathTemplate::MatchRecursive>(a.value);
+      return std::holds_alternative<PathTemplate::MatchRecursive>(a.value);
     }
     bool operator()(std::string const& s) {
-      return absl::holds_alternative<std::string>(a.value) &&
-             absl::get<std::string>(a.value) == s;
+      return std::holds_alternative<std::string>(a.value) &&
+             std::get<std::string>(a.value) == s;
     }
     bool operator()(PathTemplate::Variable const& v) {
-      return absl::holds_alternative<PathTemplate::Variable>(a.value) &&
-             SameValues(absl::get<PathTemplate::Variable>(a.value), v);
+      return std::holds_alternative<PathTemplate::Variable>(a.value) &&
+             SameValues(std::get<PathTemplate::Variable>(a.value), v);
     }
   };
-  return absl::visit(Visitor{a}, b.value);
+  return std::visit(Visitor{a}, b.value);
 }
 
 bool SameValues(PathTemplate const& a, PathTemplate const& b) {
diff --git a/generator/internal/http_option_utils.cc b/generator/internal/http_option_utils.cc
index c317cf3481f0a..05fb33fd172dd 100644
--- a/generator/internal/http_option_utils.cc
+++ b/generator/internal/http_option_utils.cc
@@ -30,6 +30,7 @@
 #include <google/protobuf/descriptor.h>
 #include <optional>
 #include <regex>
+#include <variant>
 #include <vector>
 
 using ::google::protobuf::MethodDescriptor;
@@ -96,7 +97,7 @@ struct RestPathVisitor {
 void RestPathVisitorHelper(
     std::optional<std::string> api_version, PathTemplate::Segment const& s,
     std::vector<HttpExtensionInfo::RestPathPiece>& path) {
-  absl::visit(RestPathVisitor{std::move(api_version), path}, s.value);
+  std::visit(RestPathVisitor{std::move(api_version), path}, s.value);
 }
 
 std::string FormatQueryParameterCode(
@@ -319,15 +320,15 @@ HttpExtensionInfo ParseHttpExtension(google::api::HttpRule const& http_rule) {
   };
   auto segment_formatter = [](std::string* out,
                               std::shared_ptr<PathTemplate::Segment> const& s) {
-    out->append(absl::visit(SegmentAsStringVisitor{}, s->value));
+    out->append(std::visit(SegmentAsStringVisitor{}, s->value));
   };
 
   auto api_version = FormatApiVersionFromUrlPattern(info.url_path);
   auto rest_path_visitor =
       RestPathVisitor(std::move(api_version), info.rest_path);
   for (auto const& s : parsed_http_rule->segments) {
-    if (absl::holds_alternative<PathTemplate::Variable>(s->value)) {
-      auto v = absl::get<PathTemplate::Variable>(s->value);
+    if (std::holds_alternative<PathTemplate::Variable>(s->value)) {
+      auto v = std::get<PathTemplate::Variable>(s->value);
       if (v.segments.empty()) {
         info.field_substitutions.emplace_back(v.field_path, v.field_path);
       } else {
@@ -336,7 +337,7 @@ HttpExtensionInfo ParseHttpExtension(google::api::HttpRule const& http_rule) {
       }
     }
 
-    absl::visit(rest_path_visitor, s->value);
+    std::visit(rest_path_visitor, s->value);
   }
 
   info.rest_path_verb = parsed_http_rule->verb;
diff --git a/generator/internal/longrunning.cc b/generator/internal/longrunning.cc
index 51b17fd945b25..43985e751fc9f 100644
--- a/generator/internal/longrunning.cc
+++ b/generator/internal/longrunning.cc
@@ -19,9 +19,9 @@
 #include "google/cloud/extended_operations.pb.h"
 #include "google/cloud/log.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/variant.h"
 #include "google/longrunning/operations.pb.h"
 #include <string>
+#include <variant>
 
 using ::google::protobuf::Descriptor;
 using ::google::protobuf::MethodDescriptor;
@@ -31,7 +31,7 @@ namespace cloud {
 namespace generator_internal {
 namespace {
 
-absl::variant<std::string, Descriptor const*> FullyQualifyMessageType(
+std::variant<std::string, Descriptor const*> FullyQualifyMessageType(
     MethodDescriptor const& method, std::string message_type) {
   Descriptor const* output_type =
       method.file()->pool()->FindMessageTypeByName(message_type);
@@ -63,7 +63,7 @@ struct FormatDoxygenLinkVisitor {
   }
 };
 
-absl::variant<std::string, Descriptor const*>
+std::variant<std::string, Descriptor const*>
 DeduceLongrunningOperationResponseType(
     MethodDescriptor const& method,
     google::longrunning::OperationInfo const& operation_info) {
@@ -100,36 +100,36 @@ void SetLongrunningOperationMethodVars(
   if (IsGRPCLongrunningOperation(method)) {
     auto operation_info =
         method.options().GetExtension(google::longrunning::operation_info);
-    method_vars["longrunning_metadata_type"] = ProtoNameToCppName(absl::visit(
+    method_vars["longrunning_metadata_type"] = ProtoNameToCppName(std::visit(
         FullyQualifiedMessageTypeVisitor(),
         FullyQualifyMessageType(method, operation_info.metadata_type())));
-    method_vars["longrunning_response_type"] = ProtoNameToCppName(absl::visit(
+    method_vars["longrunning_response_type"] = ProtoNameToCppName(std::visit(
         FullyQualifiedMessageTypeVisitor(),
         FullyQualifyMessageType(method, operation_info.response_type())));
     auto deduced_response_type =
         DeduceLongrunningOperationResponseType(method, operation_info);
     method_vars["longrunning_deduced_response_message_type"] =
-        absl::visit(FullyQualifiedMessageTypeVisitor(), deduced_response_type);
+        std::visit(FullyQualifiedMessageTypeVisitor(), deduced_response_type);
     method_vars["longrunning_deduced_response_type"] = ProtoNameToCppName(
         method_vars["longrunning_deduced_response_message_type"]);
     method_vars["method_longrunning_deduced_return_doxygen_link"] =
-        absl::visit(FormatDoxygenLinkVisitor{}, deduced_response_type);
+        std::visit(FormatDoxygenLinkVisitor{}, deduced_response_type);
     return;
   }
 
   if (IsHttpLongrunningOperation(method)) {
-    method_vars["longrunning_response_type"] = ProtoNameToCppName(absl::visit(
+    method_vars["longrunning_response_type"] = ProtoNameToCppName(std::visit(
         FullyQualifiedMessageTypeVisitor(),
         FullyQualifyMessageType(
             method, std::string{method.output_type()->full_name()})));
-    absl::variant<std::string, google::protobuf::Descriptor const*>
+    std::variant<std::string, google::protobuf::Descriptor const*>
         deduced_response_type = method.output_type();
     method_vars["longrunning_deduced_response_message_type"] =
-        absl::visit(FullyQualifiedMessageTypeVisitor(), deduced_response_type);
+        std::visit(FullyQualifiedMessageTypeVisitor(), deduced_response_type);
     method_vars["longrunning_deduced_response_type"] = ProtoNameToCppName(
         method_vars["longrunning_deduced_response_message_type"]);
     method_vars["method_longrunning_deduced_return_doxygen_link"] =
-        absl::visit(FormatDoxygenLinkVisitor{}, deduced_response_type);
+        std::visit(FormatDoxygenLinkVisitor{}, deduced_response_type);
   }
 }
 
@@ -170,7 +170,7 @@ void SetLongrunningOperationServiceVars(
     }
     if (IsHttpLongrunningOperation(*method)) {
       service_vars["longrunning_response_type"] =
-          ProtoNameToCppName(absl::visit(
+          ProtoNameToCppName(std::visit(
               FullyQualifiedMessageTypeVisitor(),
               FullyQualifyMessageType(
                   *method, std::string{method->output_type()->full_name()})));
diff --git a/google/cloud/bigquery/v2/minimal/internal/common_v2_resources.cc b/google/cloud/bigquery/v2/minimal/internal/common_v2_resources.cc
index 1b2ef4c79af3e..154e3f4a17570 100644
--- a/google/cloud/bigquery/v2/minimal/internal/common_v2_resources.cc
+++ b/google/cloud/bigquery/v2/minimal/internal/common_v2_resources.cc
@@ -17,6 +17,7 @@
 #include "google/cloud/internal/debug_string.h"
 #include "google/cloud/internal/format_time_point.h"
 #include "google/cloud/log.h"
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -148,7 +149,7 @@ void to_json(nlohmann::json& j, StandardSqlDataType const& t) {
     }
   };
 
-  absl::visit(Visitor{t.type_kind, j}, t.sub_type);
+  std::visit(Visitor{t.type_kind, j}, t.sub_type);
 }
 
 void from_json(nlohmann::json const& j, StandardSqlDataType& t) {
@@ -205,7 +206,7 @@ void to_json(nlohmann::json& j, Value const& v) {
     }
   };
 
-  absl::visit(Visitor{j}, v.value_kind);
+  std::visit(Visitor{j}, v.value_kind);
 }
 
 void from_json(nlohmann::json const& j, Value& v) {
@@ -493,7 +494,7 @@ std::string StandardSqlDataType::DebugString(absl::string_view name,
 std::string Value::DebugString(absl::string_view name,
                                TracingOptions const& options,
                                int indent) const {
-  return absl::visit(ValueKindDebugString{name, options, indent}, value_kind);
+  return std::visit(ValueKindDebugString{name, options, indent}, value_kind);
 }
 
 std::string SystemVariables::DebugString(absl::string_view name,
diff --git a/google/cloud/bigtable/column_family.h b/google/cloud/bigtable/column_family.h
index 28c898df25139..ea0868ca736ad 100644
--- a/google/cloud/bigtable/column_family.h
+++ b/google/cloud/bigtable/column_family.h
@@ -16,13 +16,13 @@
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_COLUMN_FAMILY_H
 
 #include "google/cloud/bigtable/version.h"
-#include "absl/meta/type_traits.h"
 #include "google/bigtable/admin/v2/bigtable_table_admin.pb.h"
 #include "google/bigtable/admin/v2/table.pb.h"
 #include <google/protobuf/util/message_differencer.h>
 #include <chrono>
 #include <memory>
 #include <string>
+#include <type_traits>
 
 namespace google {
 namespace cloud {
@@ -96,7 +96,7 @@ class GcRule {
     // letting the compiler figure things out N levels deep as it recurses on
     // `add_intersection()`.
     static_assert(
-        absl::conjunction<std::is_convertible<GcRuleTypes, GcRule>...>::value,
+        std::conjunction<std::is_convertible<GcRuleTypes, GcRule>...>::value,
         "The arguments to Intersection must be convertible to GcRule");
     GcRule tmp;
     auto& intersection = *tmp.gc_rule_.mutable_intersection();
@@ -121,7 +121,7 @@ class GcRule {
     // letting the compiler figure things out N levels deep as it recurses on
     // `add_intersection()`.
     static_assert(
-        absl::conjunction<std::is_convertible<GcRuleTypes, GcRule>...>::value,
+        std::conjunction<std::is_convertible<GcRuleTypes, GcRule>...>::value,
         "The arguments to Union must be convertible to GcRule");
     GcRule tmp;
     auto& gc_rule_union = *tmp.gc_rule_.mutable_union_();
diff --git a/google/cloud/bigtable/filters.h b/google/cloud/bigtable/filters.h
index 5e93c549605cd..80413cc068bf7 100644
--- a/google/cloud/bigtable/filters.h
+++ b/google/cloud/bigtable/filters.h
@@ -16,11 +16,11 @@
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_FILTERS_H
 
 #include "google/cloud/bigtable/version.h"
-#include "absl/meta/type_traits.h"
 #include "google/bigtable/v2/data.pb.h"
 #include <google/protobuf/util/message_differencer.h>
 #include <chrono>
 #include <string>
+#include <type_traits>
 
 namespace google {
 namespace cloud {
@@ -572,7 +572,7 @@ class Filter {
     // just letting the compiler figure things out 3 levels deep
     // as it recurses on append_types().
     static_assert(
-        absl::conjunction<std::is_convertible<FilterTypes, Filter>...>::value,
+        std::conjunction<std::is_convertible<FilterTypes, Filter>...>::value,
         "The arguments passed to Chain(...) must be convertible to Filter");
     Filter tmp;
     auto& chain = *tmp.filter_.mutable_chain();
@@ -636,7 +636,7 @@ class Filter {
   template <typename... FilterTypes>
   static Filter Interleave(FilterTypes&&... streams) {
     static_assert(
-        absl::conjunction<std::is_convertible<FilterTypes, Filter>...>::value,
+        std::conjunction<std::is_convertible<FilterTypes, Filter>...>::value,
         "The arguments passed to Interleave(...) must be convertible"
         " to Filter");
     Filter tmp;
diff --git a/google/cloud/bigtable/internal/default_row_reader.cc b/google/cloud/bigtable/internal/default_row_reader.cc
index 12427521f514d..68d27cf5fb766 100644
--- a/google/cloud/bigtable/internal/default_row_reader.cc
+++ b/google/cloud/bigtable/internal/default_row_reader.cc
@@ -18,6 +18,7 @@
 #include "google/cloud/grpc_options.h"
 #include "google/cloud/internal/make_status.h"
 #include "google/cloud/internal/retry_loop_helpers.h"
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -107,12 +108,12 @@ absl::variant<Status, bigtable::Row> DefaultRowReader::Advance() {
   }
   while (true) {
     auto variant = AdvanceOrFail();
-    if (absl::holds_alternative<bigtable::Row>(variant)) {
+    if (std::holds_alternative<bigtable::Row>(variant)) {
       operation_context_->ElementDelivery(*client_context_);
-      return absl::get<bigtable::Row>(std::move(variant));
+      return std::get<bigtable::Row>(std::move(variant));
     }
 
-    auto status = absl::get<Status>(std::move(variant));
+    auto status = std::get<Status>(std::move(variant));
     if (status.ok()) return Status{};
 
     // In the unlikely case when we have already reached the requested
diff --git a/google/cloud/bigtable/mutations.h b/google/cloud/bigtable/mutations.h
index 642fe4969e299..4ed555f9478b1 100644
--- a/google/cloud/bigtable/mutations.h
+++ b/google/cloud/bigtable/mutations.h
@@ -22,7 +22,6 @@
 #include "google/cloud/internal/big_endian.h"
 #include "google/cloud/status.h"
 #include "google/cloud/status_or.h"
-#include "absl/meta/type_traits.h"
 #include "google/bigtable/v2/bigtable.pb.h"
 #include "google/bigtable/v2/data.pb.h"
 #include <google/protobuf/util/message_differencer.h>
@@ -325,7 +324,7 @@ class SingleRowMutation {
             >
   explicit SingleRowMutation(RowKey&& row_key, M&&... m) {
     static_assert(
-        absl::conjunction<std::is_convertible<M, Mutation>...>::value,
+        std::conjunction<std::is_convertible<M, Mutation>...>::value,
         "The arguments passed to SingleRowMutation(std::string, ...) must be "
         "convertible to Mutation");
     request_.set_row_key(std::forward<RowKey>(row_key));
@@ -523,7 +522,7 @@ class BulkMutation {
   /// Create a multi-row mutation from a variadic list.
   template <typename... M,
             /// @cond implementation_details
-            std::enable_if_t<absl::conjunction<std::is_convertible<
+            std::enable_if_t<std::conjunction<std::is_convertible<
                                  M, SingleRowMutation>...>::value,
                              int> = 0
             /// @endcond
diff --git a/google/cloud/bigtable/table.h b/google/cloud/bigtable/table.h
index 19a7c35deb678..e785953243265 100644
--- a/google/cloud/bigtable/table.h
+++ b/google/cloud/bigtable/table.h
@@ -40,8 +40,8 @@
 #include "google/cloud/options.h"
 #include "google/cloud/status.h"
 #include "google/cloud/status_or.h"
-#include "absl/meta/type_traits.h"
 #include <string>
+#include <type_traits>
 #include <vector>
 
 namespace google {
@@ -157,13 +157,13 @@ class Table {
   /// A meta function to check if @p P is a valid Policy type.
   template <typename P>
   struct ValidPolicy
-      : absl::disjunction<std::is_base_of<RPCBackoffPolicy, P>,
-                          std::is_base_of<RPCRetryPolicy, P>,
-                          std::is_base_of<IdempotentMutationPolicy, P>> {};
+      : std::disjunction<std::is_base_of<RPCBackoffPolicy, P>,
+                         std::is_base_of<RPCRetryPolicy, P>,
+                         std::is_base_of<IdempotentMutationPolicy, P>> {};
 
   /// A meta function to check if all the @p Policies are valid policy types.
   template <typename... Policies>
-  struct ValidPolicies : absl::conjunction<ValidPolicy<Policies>...> {};
+  struct ValidPolicies : std::conjunction<ValidPolicy<Policies>...> {};
 
  public:
   /**
@@ -589,7 +589,7 @@ class Table {
     // Generate a better compile time error message than the default one
     // if the types do not match
     static_assert(
-        absl::conjunction<absl::disjunction<
+        std::conjunction<std::disjunction<
             std::is_convertible<Args, bigtable::ReadModifyWriteRule>,
             std::is_same<std::decay_t<Args>, Options>>...>::value,
         "The arguments passed to ReadModifyWriteRow(row_key,...) must be "
@@ -643,7 +643,7 @@ class Table {
     // Generate a better compile time error message than the default one
     // if the types do not match
     static_assert(
-        absl::conjunction<absl::disjunction<
+        std::conjunction<std::disjunction<
             std::is_convertible<Args, bigtable::ReadModifyWriteRule>,
             std::is_same<std::decay_t<Args>, Options>>...>::value,
         "The arguments passed to AsyncReadModifyWriteRow(row_key,...) must be "
diff --git a/google/cloud/bigtable/value_test.cc b/google/cloud/bigtable/value_test.cc
index 3ac6792e92c1e..2c911534fe475 100644
--- a/google/cloud/bigtable/value_test.cc
+++ b/google/cloud/bigtable/value_test.cc
@@ -305,7 +305,7 @@ template <
         std::is_same<std::remove_cv_t<std::remove_reference_t<U>>,
                      absl::Cord>::value>::type* = nullptr,
     typename std::enable_if_t<
-        absl::disjunction<std::is_same<T, std::string>,
+        std::disjunction<std::is_same<T, std::string>,
                           std::is_same<T, std::optional<std::string>>>::value,
         int> = 0>
 
diff --git a/google/cloud/future_generic.h b/google/cloud/future_generic.h
index 4c3049dd4d6c2..ad3a014d5787d 100644
--- a/google/cloud/future_generic.h
+++ b/google/cloud/future_generic.h
@@ -20,7 +20,6 @@
 #include "google/cloud/internal/future_impl.h"
 #include "google/cloud/internal/invoke_result.h"
 #include "google/cloud/version.h"
-#include "absl/meta/type_traits.h"
 #include <future>
 #include <type_traits>
 
@@ -64,7 +63,7 @@ class future final : private internal::future_base<T> {
    * future's result type.
    */
   template <class U, typename Enable =
-                         absl::enable_if_t<std::is_constructible<T, U>::value>>
+                         std::enable_if_t<std::is_constructible<T, U>::value>>
   explicit future(future<U>&& rhs);
 
   /**
diff --git a/google/cloud/internal/future_impl.h b/google/cloud/internal/future_impl.h
index 23fb11151f795..31fdc20cf7aea 100644
--- a/google/cloud/internal/future_impl.h
+++ b/google/cloud/internal/future_impl.h
@@ -26,6 +26,7 @@
 #include <future>
 #include <mutex>
 #include <utility>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -222,7 +223,7 @@ class future_shared_state final {  // NOLINT(readability-identifier-naming)
     // future, so new calls will fail.
     ValueType tmp(FutureValueRetrieved{});
     tmp.swap(value_);
-    return absl::visit(Visitor{}, std::move(tmp));
+    return std::visit(Visitor{}, std::move(tmp));
   }
 
   /**
@@ -421,7 +422,7 @@ class future_shared_state final {  // NOLINT(readability-identifier-naming)
 
  protected:
   bool is_ready_unlocked() const {
-    return !absl::holds_alternative<absl::monostate>(value_);
+    return !std::holds_alternative<absl::monostate>(value_);
   }
 
   /// Satisfy the shared state using an exception.
diff --git a/google/cloud/internal/future_then_impl.h b/google/cloud/internal/future_then_impl.h
index a73fe09aa8752..4344e29a6e23b 100644
--- a/google/cloud/internal/future_then_impl.h
+++ b/google/cloud/internal/future_then_impl.h
@@ -22,6 +22,7 @@
 #include "absl/functional/function_ref.h"
 #include <exception>
 #include <type_traits>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -104,7 +105,7 @@ struct FutureThenImpl {
           void operator()(FutureValueRetrieved) { output->abandon(); }
           void operator()(T v) { set_value(*output, std::move(v)); }
         };
-        return absl::visit(Visitor{std::move(output_)}, s.value());
+        return std::visit(Visitor{std::move(output_)}, s.value());
       }
 
      private:
@@ -140,7 +141,7 @@ struct FutureThenImpl {
             unwrap(std::move(output), std::move(v.shared_state_));
           }
         };
-        return absl::visit(Visitor{std::move(output_)}, s.value());
+        return std::visit(Visitor{std::move(output_)}, s.value());
       }
 
      private:
diff --git a/google/cloud/internal/type_list.h b/google/cloud/internal/type_list.h
index caaa771e526f3..23100126dc9fe 100644
--- a/google/cloud/internal/type_list.h
+++ b/google/cloud/internal/type_list.h
@@ -16,7 +16,6 @@
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_INTERNAL_TYPE_LIST_H
 
 #include "google/cloud/version.h"
-#include "absl/meta/type_traits.h"
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -93,7 +92,7 @@ struct TypeListHasType;
 
 template <typename... Us, typename T>
 struct TypeListHasType<TypeList<Us...>, T>
-    : absl::disjunction<std::is_same<T, Us>...> {};
+    : std::disjunction<std::is_same<T, Us>...> {};
 
 template <template <typename> class Predicate, typename List>
 struct TypeListFilter;
diff --git a/google/cloud/rest_options.h b/google/cloud/rest_options.h
index 38a9e09ddc643..8d3e5c6b943b4 100644
--- a/google/cloud/rest_options.h
+++ b/google/cloud/rest_options.h
@@ -20,6 +20,7 @@
 #include "google/cloud/tracing_options.h"
 #include "google/cloud/version.h"
 #include <chrono>
+#include <functional>
 #include <string>
 
 namespace google {
diff --git a/google/cloud/spanner/internal/connection_impl.cc b/google/cloud/spanner/internal/connection_impl.cc
index 45a3e2e7a7536..b7b303c926946 100644
--- a/google/cloud/spanner/internal/connection_impl.cc
+++ b/google/cloud/spanner/internal/connection_impl.cc
@@ -28,6 +28,7 @@
 #include "google/cloud/internal/algorithm.h"
 #include "google/cloud/internal/make_status.h"
 #include "google/cloud/internal/resumable_streaming_read_rpc.h"
+#include <variant>
 #include "google/cloud/internal/retry_loop.h"
 #include "google/cloud/internal/streaming_read_rpc.h"
 #include "google/cloud/options.h"
@@ -638,7 +639,7 @@ spanner::RowStream ConnectionImpl::ReadImpl(
         *std::move(params.read_options.request_tag));
   }
   request->mutable_request_options()->set_transaction_tag(ctx.tag);
-  absl::visit(DirectedReadVisitor([&request] {
+  std::visit(DirectedReadVisitor([&request] {
                 return request->mutable_directed_read_options();
               }),
               params.directed_read_option);
@@ -825,7 +826,7 @@ StatusOr<ResultType> ConnectionImpl::ExecuteSqlImpl(
         *params.query_options.request_tag());
   }
   request.mutable_request_options()->set_transaction_tag(ctx.tag);
-  absl::visit(DirectedReadVisitor([&request] {
+  std::visit(DirectedReadVisitor([&request] {
                 return request.mutable_directed_read_options();
               }),
               params.directed_read_option);
diff --git a/google/cloud/storage/async/client.cc b/google/cloud/storage/async/client.cc
index 0ed676913569d..888f806a6876a 100644
--- a/google/cloud/storage/async/client.cc
+++ b/google/cloud/storage/async/client.cc
@@ -22,6 +22,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -222,7 +223,7 @@ AsyncClient::StartBufferedUpload(
       .then([](auto f) -> StatusOr<std::pair<AsyncWriter, AsyncToken>> {
         auto w = f.get();
         if (!w) return std::move(w).status();
-        auto t = absl::holds_alternative<google::storage::v2::Object>(
+        auto t = std::holds_alternative<google::storage::v2::Object>(
                      (*w)->PersistedState())
                      ? AsyncToken()
                      : storage_internal::MakeAsyncToken(w->get());
@@ -247,7 +248,7 @@ AsyncClient::ResumeBufferedUpload(
       .then([](auto f) -> StatusOr<std::pair<AsyncWriter, AsyncToken>> {
         auto w = f.get();
         if (!w) return std::move(w).status();
-        auto t = absl::holds_alternative<google::storage::v2::Object>(
+        auto t = std::holds_alternative<google::storage::v2::Object>(
                      (*w)->PersistedState())
                      ? AsyncToken()
                      : storage_internal::MakeAsyncToken(w->get());
@@ -275,7 +276,7 @@ AsyncClient::StartUnbufferedUpload(
       .then([](auto f) -> StatusOr<std::pair<AsyncWriter, AsyncToken>> {
         auto w = f.get();
         if (!w) return std::move(w).status();
-        auto t = absl::holds_alternative<google::storage::v2::Object>(
+        auto t = std::holds_alternative<google::storage::v2::Object>(
                      (*w)->PersistedState())
                      ? AsyncToken()
                      : storage_internal::MakeAsyncToken(w->get());
@@ -300,7 +301,7 @@ AsyncClient::ResumeUnbufferedUpload(
       .then([](auto f) -> StatusOr<std::pair<AsyncWriter, AsyncToken>> {
         auto w = f.get();
         if (!w) return std::move(w).status();
-        auto t = absl::holds_alternative<google::storage::v2::Object>(
+        auto t = std::holds_alternative<google::storage::v2::Object>(
                      (*w)->PersistedState())
                      ? AsyncToken()
                      : storage_internal::MakeAsyncToken(w->get());
diff --git a/google/cloud/storage/async/reader.cc b/google/cloud/storage/async/reader.cc
index f1f5b105bda8a..c8ee9376d191d 100644
--- a/google/cloud/storage/async/reader.cc
+++ b/google/cloud/storage/async/reader.cc
@@ -17,6 +17,7 @@
 #include "google/cloud/internal/make_status.h"
 #include <memory>
 #include <utility>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -46,7 +47,7 @@ class Discard : public std::enable_shared_from_this<Discard> {
     self->impl_->Read().then([self](auto f) mutable {
       auto s = std::move(self);
       auto response = f.get();
-      if (absl::holds_alternative<Status>(response)) return;
+      if (std::holds_alternative<Status>(response)) return;
       s->Loop();
     });
   }
@@ -84,8 +85,8 @@ future<StatusOr<std::pair<ReadPayload, AsyncToken>>> AsyncReader::Read(
   };
   return impl_->Read().then([this, v = Visitor{std::move(t)}](auto f) mutable {
     auto response = f.get();
-    if (absl::holds_alternative<Status>(response)) finished_ = true;
-    return absl::visit(std::move(v), std::move(response));
+    if (std::holds_alternative<Status>(response)) finished_ = true;
+    return std::visit(std::move(v), std::move(response));
   });
 }
 
diff --git a/google/cloud/storage/client.h b/google/cloud/storage/client.h
index 9b62a8be5d088..ac80d12cb550b 100644
--- a/google/cloud/storage/client.h
+++ b/google/cloud/storage/client.h
@@ -39,7 +39,6 @@
 #include "google/cloud/options.h"
 #include "google/cloud/status.h"
 #include "google/cloud/status_or.h"
-#include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include <memory>
 #include <string>
@@ -1321,7 +1320,7 @@ class Client {
     // does not support (nor should it support) the UseResumableUploadSession
     // option.
     using HasUseResumableUpload =
-        absl::disjunction<std::is_same<UseResumableUploadSession, Options>...>;
+        std::disjunction<std::is_same<UseResumableUploadSession, Options>...>;
     return UploadFileImpl(file_name, bucket_name, object_name,
                           HasUseResumableUpload{},
                           std::forward<Options>(options)...);
diff --git a/google/cloud/storage/client_object_test.cc b/google/cloud/storage/client_object_test.cc
index 4e81f53c5cdac..0f938cd6f6138 100644
--- a/google/cloud/storage/client_object_test.cc
+++ b/google/cloud/storage/client_object_test.cc
@@ -26,6 +26,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -204,7 +205,7 @@ TEST_F(ObjectTest, ListObjectsAndPrefixes) {
       "test-bucket-name", Options{}.set<UserProjectOption>("u-p-test"));
   for (auto&& o : list) {
     EXPECT_STATUS_OK(o);
-    names.push_back(absl::get<ObjectMetadata>(*o).name());
+    names.push_back(std::get<ObjectMetadata>(*o).name());
   }
   EXPECT_THAT(names, ElementsAre("object-1", "object-2", "object-3"));
 }
diff --git a/google/cloud/storage/examples/storage_async_samples.cc b/google/cloud/storage/examples/storage_async_samples.cc
index 8ca76cb72f6d3..97a9bc454adb7 100644
--- a/google/cloud/storage/examples/storage_async_samples.cc
+++ b/google/cloud/storage/examples/storage_async_samples.cc
@@ -34,6 +34,7 @@
 #include <stdexcept>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace {
@@ -759,7 +760,7 @@ void CreateAndWriteAppendableObject(google::cloud::storage::AsyncClient& client,
     if (!flush_status.ok()) throw std::runtime_error(flush_status.message());
 
     std::cout << "Flush completed. Persisted size is now "
-              << absl::get<std::int64_t>(writer.PersistedState()) << "\n";
+              << std::get<std::int64_t>(writer.PersistedState()) << "\n";
 
     // The writer is still open. We can write more data.
     token = (co_await writer.Write(std::move(token),
@@ -850,7 +851,7 @@ void PauseAndResumeAppendableUpload(google::cloud::storage::AsyncClient& client,
              gcs::BucketName(bucket_name), object_name, metadata.generation()))
             .value();
     std::cout << "Upload resumed from offset "
-              << absl::get<std::int64_t>(writer.PersistedState()) << "\n";
+              << std::get<std::int64_t>(writer.PersistedState()) << "\n";
 
     // Append the rest of the data.
     token = (co_await writer.Write(std::move(token),
diff --git a/google/cloud/storage/examples/storage_object_samples.cc b/google/cloud/storage/examples/storage_object_samples.cc
index c737a00d7b188..ce894c31cd93a 100644
--- a/google/cloud/storage/examples/storage_object_samples.cc
+++ b/google/cloud/storage/examples/storage_object_samples.cc
@@ -26,6 +26,7 @@
 #include <string>
 #include <thread>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace {
@@ -92,11 +93,11 @@ void ListObjectsAndPrefixes(google::cloud::storage::Client client,
              bucket_name, gcs::Prefix(bucket_prefix), gcs::Delimiter("/"))) {
       if (!item) throw std::move(item).status();
       auto result = *std::move(item);
-      if (absl::holds_alternative<gcs::ObjectMetadata>(result)) {
+      if (std::holds_alternative<gcs::ObjectMetadata>(result)) {
         std::cout << "object_name="
-                  << absl::get<gcs::ObjectMetadata>(result).name() << "\n";
-      } else if (absl::holds_alternative<std::string>(result)) {
-        std::cout << "prefix     =" << absl::get<std::string>(result) << "\n";
+                  << std::get<gcs::ObjectMetadata>(result).name() << "\n";
+      } else if (std::holds_alternative<std::string>(result)) {
+        std::cout << "prefix     =" << std::get<std::string>(result) << "\n";
       }
     }
   }
@@ -115,11 +116,11 @@ void ListObjectsAndFolders(google::cloud::storage::Client client,
              gcs::IncludeFoldersAsPrefixes(true))) {
       if (!item) throw std::move(item).status();
       auto result = *std::move(item);
-      if (absl::holds_alternative<gcs::ObjectMetadata>(result)) {
+      if (std::holds_alternative<gcs::ObjectMetadata>(result)) {
         std::cout << "object_name="
-                  << absl::get<gcs::ObjectMetadata>(result).name() << "\n";
-      } else if (absl::holds_alternative<std::string>(result)) {
-        std::cout << "prefix     =" << absl::get<std::string>(result) << "\n";
+                  << std::get<gcs::ObjectMetadata>(result).name() << "\n";
+      } else if (std::holds_alternative<std::string>(result)) {
+        std::cout << "prefix     =" << std::get<std::string>(result) << "\n";
       }
     }
   }
diff --git a/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc b/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc
index 189af38f74830..7a13831c1e36c 100644
--- a/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc
+++ b/google/cloud/storage/internal/async/connection_impl_appendable_upload_test.cc
@@ -29,6 +29,7 @@
 #include "google/cloud/testing_util/status_matchers.h"
 #include <google/protobuf/text_format.h>
 #include <gmock/gmock.h>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -290,7 +291,7 @@ TEST_F(AsyncConnectionImplAppendableTest, StartAppendableObjectUploadSuccess) {
   auto r = pending.get();
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   // Write some data.
   // An empty payload might be a no-op in the implementation, which would
@@ -363,7 +364,7 @@ TEST_F(AsyncConnectionImplAppendableTest, ResumeAppendableObjectUploadSuccess) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   // Verify the persisted state is correctly reported.
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), kPersistedSize);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), kPersistedSize);
 
   auto w1 = writer->Write(storage::WritePayload("some more data"));
   next = sequencer.PopFrontWithName();
@@ -512,7 +513,7 @@ TEST_F(AsyncConnectionImplAppendableTest, AppendableUploadRedirect) {
   auto r = pending.get();
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 1024);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 1024);
 
   // Write some data.
   auto w1 = writer->Write(storage::WritePayload("some data"));
@@ -612,7 +613,7 @@ TEST_F(AsyncConnectionImplAppendableTest, AppendableUploadRedirectNoHandle) {
   auto r = pending.get();
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 1024);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 1024);
 
   // Write some data.
   auto w1 = writer->Write(storage::WritePayload("some data"));
diff --git a/google/cloud/storage/internal/async/connection_impl_read_test.cc b/google/cloud/storage/internal/async/connection_impl_read_test.cc
index cd001040ade39..eb9e1deca61fa 100644
--- a/google/cloud/storage/internal/async/connection_impl_read_test.cc
+++ b/google/cloud/storage/internal/async/connection_impl_read_test.cc
@@ -31,6 +31,7 @@
 #include "google/cloud/testing_util/validate_metadata.h"
 #include <google/protobuf/text_format.h>
 #include <gmock/gmock.h>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -211,7 +212,7 @@ TEST_F(AsyncConnectionImplTest, ReadObject) {
   EXPECT_EQ(next.second, "Read");
   next.first.set_value(true);
   auto response = data.get();
-  ASSERT_TRUE(absl::holds_alternative<storage::ReadPayload>(response));
+  ASSERT_TRUE(std::holds_alternative<storage::ReadPayload>(response));
 
   // The `Read()` and `Finish()` calls must happen before the second `Read()` is
   // satisfied.
@@ -311,7 +312,7 @@ TEST_F(AsyncConnectionImplTest, ReadObjectWithTimeout) {
   next.first.set_value(true);
 
   auto response = data.get();
-  ASSERT_TRUE(absl::holds_alternative<storage::ReadPayload>(response));
+  ASSERT_TRUE(std::holds_alternative<storage::ReadPayload>(response));
 
   // Trigger another read. Since this closes the stream, the `Read()` and
   // `Finish()` calls must happen before the second `Read()` is satisfied.
diff --git a/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc b/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc
index 8d208f9cc3b9a..70c6495fd949e 100644
--- a/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc
+++ b/google/cloud/storage/internal/async/connection_impl_upload_hash_test.cc
@@ -32,6 +32,7 @@
 #include <gmock/gmock.h>
 #include <iomanip>
 #include <iostream>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -267,7 +268,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, StartUnbuffered) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   next = sequencer.PopFrontWithName();
@@ -377,7 +378,7 @@ TEST_P(AsyncConnectionImplUploadHashTest,
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "resume-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   next = sequencer.PopFrontWithName();
@@ -485,7 +486,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeUnbufferedWithPersistedData) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "resume-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 256 * 1024);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 256 * 1024);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   next = sequencer.PopFrontWithName();
@@ -609,7 +610,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, StartBuffered) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   // The `Finalize()` call triggers a `Flush()` first.
@@ -726,7 +727,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeBufferedWithoutPersistedData) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "resume-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   next = sequencer.PopFrontWithName();
@@ -834,7 +835,7 @@ TEST_P(AsyncConnectionImplUploadHashTest, ResumeBufferedWithPersistedData) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "resume-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 256 * 1024);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 256 * 1024);
 
   auto w2 = writer->Finalize(storage::WritePayload(kQuickFox));
   next = sequencer.PopFrontWithName();
diff --git a/google/cloud/storage/internal/async/connection_impl_upload_test.cc b/google/cloud/storage/internal/async/connection_impl_upload_test.cc
index d0b617fef28d1..6d3941de03266 100644
--- a/google/cloud/storage/internal/async/connection_impl_upload_test.cc
+++ b/google/cloud/storage/internal/async/connection_impl_upload_test.cc
@@ -30,6 +30,7 @@
 #include "google/cloud/testing_util/validate_metadata.h"
 #include <google/protobuf/text_format.h>
 #include <gmock/gmock.h>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -249,7 +250,7 @@ TEST_F(AsyncConnectionImplTest, StartUnbufferedUpload) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w1 = writer->Write({});
   next = sequencer.PopFrontWithName();
@@ -361,7 +362,7 @@ TEST_F(AsyncConnectionImplTest, UnbufferedUploadNewUploadWithTimeout) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w2 = writer->Finalize({});
   timer = sequencer.PopFrontWithName();
@@ -591,7 +592,7 @@ TEST_F(AsyncConnectionImplTest, ResumeUnbufferedUpload) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 16384);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 16384);
 
   auto w1 = writer->Write({});
   next = sequencer.PopFrontWithName();
@@ -957,7 +958,7 @@ TEST_F(AsyncConnectionImplTest, BufferedUploadNewUpload) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 0);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 0);
 
   auto w1 = writer->Finalize({});
   next = sequencer.PopFrontWithName();
@@ -1210,7 +1211,7 @@ TEST_F(AsyncConnectionImplTest, ResumeBufferedUpload) {
   ASSERT_STATUS_OK(r);
   auto writer = *std::move(r);
   EXPECT_EQ(writer->UploadId(), "test-upload-id");
-  EXPECT_EQ(absl::get<std::int64_t>(writer->PersistedState()), 16384);
+  EXPECT_EQ(std::get<std::int64_t>(writer->PersistedState()), 16384);
 
   auto w1 = writer->Write({});
   next = sequencer.PopFrontWithName();
diff --git a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc
index 03d9a896a96e6..150375926c606 100644
--- a/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc
+++ b/google/cloud/storage/internal/async/object_descriptor_reader_tracing.cc
@@ -19,6 +19,7 @@
 #include "google/cloud/version.h"
 #include <opentelemetry/semconv/incubating/thread_attributes.h>
 #include <memory>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -59,8 +60,8 @@ class ObjectDescriptorReaderTracing : public ObjectDescriptorReader {
             auto f) -> ReadResponse {
           auto result = f.get();
           internal::DetachOTelContext(oc);
-          if (!absl::holds_alternative<Status>(result)) {
-            auto const& payload = absl::get<storage::ReadPayload>(result);
+          if (!std::holds_alternative<Status>(result)) {
+            auto const& payload = std::get<storage::ReadPayload>(result);
 
             span->AddEvent(
                 "gl-cpp.read-range",
@@ -73,7 +74,7 @@ class ObjectDescriptorReaderTracing : public ObjectDescriptorReader {
                 {{/*sc::kRpcMessageType=*/"rpc.message.type", "RECEIVED"},
                  {sc::thread::kThreadId, internal::CurrentThreadId()}});
             return internal::EndSpan(*span,
-                                     absl::get<Status>(std::move(result)));
+                                     std::get<Status>(std::move(result)));
           }
           return result;
         });
diff --git a/google/cloud/storage/internal/async/reader_connection_resume.cc b/google/cloud/storage/internal/async/reader_connection_resume.cc
index a42c657027a99..7fedf9620d694 100644
--- a/google/cloud/storage/internal/async/reader_connection_resume.cc
+++ b/google/cloud/storage/internal/async/reader_connection_resume.cc
@@ -17,6 +17,7 @@
 #include "google/cloud/internal/make_status.h"
 #include "google/cloud/log.h"
 #include "absl/strings/str_cat.h"
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -55,9 +56,9 @@ future<ReadResponse> AsyncReaderConnectionResume::Read(
 }
 
 future<ReadResponse> AsyncReaderConnectionResume::OnRead(ReadResponse r) {
-  if (absl::holds_alternative<storage::ReadPayload>(r)) {
+  if (std::holds_alternative<storage::ReadPayload>(r)) {
     resume_policy_->OnStartSuccess();
-    auto response = absl::get<storage::ReadPayload>(std::move(r));
+    auto response = std::get<storage::ReadPayload>(std::move(r));
     hash_validator_->ProcessHashValues(
         ReadPayloadImpl::GetObjectHashes(response).value_or(
             storage::internal::HashValues{}));
@@ -74,7 +75,7 @@ future<ReadResponse> AsyncReaderConnectionResume::OnRead(ReadResponse r) {
     }
     return make_ready_future(ReadResponse(std::move(response)));
   }
-  auto const& status = absl::get<Status>(r);
+  auto const& status = std::get<Status>(r);
   if (status.ok()) {
     CheckOverrun();
     // The download finished. Validate the hash results, if any.
diff --git a/google/cloud/storage/internal/async/reader_connection_tracing.cc b/google/cloud/storage/internal/async/reader_connection_tracing.cc
index eef65f7bb7208..7b0a52e0bce63 100644
--- a/google/cloud/storage/internal/async/reader_connection_tracing.cc
+++ b/google/cloud/storage/internal/async/reader_connection_tracing.cc
@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <string>
 #include <utility>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -48,7 +49,7 @@ class AsyncReaderConnectionTracing : public storage::AsyncReaderConnection {
     return impl_->Read()
         .then([count = ++count_, span = span_](auto f) -> ReadResponse {
           auto r = f.get();
-          if (absl::holds_alternative<Status>(r)) {
+          if (std::holds_alternative<Status>(r)) {
             span->AddEvent(
                 "gl-cpp.read",
                 {
@@ -56,9 +57,9 @@ class AsyncReaderConnectionTracing : public storage::AsyncReaderConnection {
                     {/*sc::kRpcMessageId=*/"rpc.message.id", count},
                     {sc::thread::kThreadId, internal::CurrentThreadId()},
                 });
-            return internal::EndSpan(*span, absl::get<Status>(std::move(r)));
+            return internal::EndSpan(*span, std::get<Status>(std::move(r)));
           }
-          auto const& payload = absl::get<storage::ReadPayload>(r);
+          auto const& payload = std::get<storage::ReadPayload>(r);
           span->AddEvent(
               "gl-cpp.read",
               {
diff --git a/google/cloud/storage/internal/async/writer_connection_buffered.cc b/google/cloud/storage/internal/async/writer_connection_buffered.cc
index 2b6bf22cbe2cb..db0ad541b9ff7 100644
--- a/google/cloud/storage/internal/async/writer_connection_buffered.cc
+++ b/google/cloud/storage/internal/async/writer_connection_buffered.cc
@@ -24,6 +24,7 @@
 #include <deque>
 #include <memory>
 #include <mutex>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -86,15 +87,15 @@ class AsyncWriterConnectionBufferedState
     finalized_future_ = finalized_.get_future();
     closed_future_ = closed_.get_future();
     auto state = impl_->PersistedState();
-    if (absl::holds_alternative<google::storage::v2::Object>(state)) {
+    if (std::holds_alternative<google::storage::v2::Object>(state)) {
       SetFinalized(std::unique_lock<std::mutex>(mu_),
-                   absl::get<google::storage::v2::Object>(std::move(state)));
+                   std::get<google::storage::v2::Object>(std::move(state)));
       cancelled_ = true;
       resume_status_ = internal::CancelledError("upload already finalized",
                                                 GCP_ERROR_INFO());
       return;
     }
-    buffer_offset_ = absl::get<std::int64_t>(state);
+    buffer_offset_ = std::get<std::int64_t>(state);
   }
 
   void Cancel() {
@@ -319,10 +320,10 @@ class AsyncWriterConnectionBufferedState
     auto impl = Impl(lk);
     auto const& state = impl->PersistedState();
     std::int64_t persisted_size = 0;
-    if (absl::holds_alternative<google::storage::v2::Object>(state)) {
-      persisted_size = absl::get<google::storage::v2::Object>(state).size();
+    if (std::holds_alternative<google::storage::v2::Object>(state)) {
+      persisted_size = std::get<google::storage::v2::Object>(state).size();
     } else {
-      persisted_size = absl::get<std::int64_t>(state);
+      persisted_size = std::get<std::int64_t>(state);
     }
     lk.unlock();
     OnQuery(persisted_size);
@@ -462,11 +463,11 @@ class AsyncWriterConnectionBufferedState
     if (was_finalizing) {
       // If resuming due to a finalization error, we *must* complete the
       // finalized_ promise now, based on the resume attempt's outcome.
-      if (absl::holds_alternative<google::storage::v2::Object>(state)) {
+      if (std::holds_alternative<google::storage::v2::Object>(state)) {
         // Resume found the object is finalized. Success.
         return SetFinalized(
             std::move(lk),
-            absl::get<google::storage::v2::Object>(std::move(state)));
+            std::get<google::storage::v2::Object>(std::move(state)));
       }
       // Resume succeeded, but the object is still not finalized.
       // This means the original finalization attempt failed permanently.
@@ -479,7 +480,7 @@ class AsyncWriterConnectionBufferedState
     if (was_closing) {
       // If resuming due to a close error, we must complete the
       // closed_ promise now, based on the resume attempt's outcome.
-      if (absl::holds_alternative<google::storage::v2::Object>(state)) {
+      if (std::holds_alternative<google::storage::v2::Object>(state)) {
         // Resume found the object is finalized (which implies closed). Success.
         return SetClosed(std::move(lk), Status{});
       }
@@ -491,13 +492,13 @@ class AsyncWriterConnectionBufferedState
       return SetError(std::move(lk), std::move(original_status));
     }
 
-    if (absl::holds_alternative<google::storage::v2::Object>(state)) {
+    if (std::holds_alternative<google::storage::v2::Object>(state)) {
       // Found finalized object (maybe finalized concurrently or resumed).
-      return SetFinalized(std::move(lk), absl::get<google::storage::v2::Object>(
+      return SetFinalized(std::move(lk), std::get<google::storage::v2::Object>(
                                              std::move(state)));
     }
     // Regular resume succeeded, object not finalized. Continue writing.
-    OnQuery(std::move(lk), absl::get<std::int64_t>(state), /*is_resume=*/true);
+    OnQuery(std::move(lk), std::get<std::int64_t>(state), /*is_resume=*/true);
   }
 
   void SetFinalized(std::unique_lock<std::mutex> lk,
@@ -848,7 +849,7 @@ std::unique_ptr<storage::AsyncWriterConnection> MakeWriterConnectionBuffered(
     WriterConnectionFactory factory,
     std::unique_ptr<storage::AsyncWriterConnection> impl,
     Options const& options) {
-  return absl::make_unique<AsyncWriterConnectionBuffered>(
+  return std::make_unique<AsyncWriterConnectionBuffered>(
       std::move(factory), std::move(impl), options,
       options.get<storage::BufferedUploadLwmOption>(),
       options.get<storage::BufferedUploadHwmOption>());
diff --git a/google/cloud/storage/internal/async/writer_connection_impl.cc b/google/cloud/storage/internal/async/writer_connection_impl.cc
index 5e0ee2e2376a3..d17efec3f1da6 100644
--- a/google/cloud/storage/internal/async/writer_connection_impl.cc
+++ b/google/cloud/storage/internal/async/writer_connection_impl.cc
@@ -22,6 +22,7 @@
 #include "google/cloud/storage/internal/grpc/object_metadata_parser.h"
 #include "google/cloud/storage/internal/grpc/object_request_parser.h"
 #include "google/cloud/internal/make_status.h"
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -215,11 +216,11 @@ future<Status> AsyncWriterConnectionImpl::Close(storage::WritePayload payload) {
 
 future<StatusOr<std::int64_t>> AsyncWriterConnectionImpl::Query() {
   std::unique_lock<std::mutex> lk(mu_);
-  if (auto* size = absl::get_if<std::int64_t>(&persisted_state_)) {
+  if (auto* size = std::get_if<std::int64_t>(&persisted_state_)) {
     return make_ready_future(make_status_or(*size));
   }
   if (auto* meta =
-          absl::get_if<google::storage::v2::Object>(&persisted_state_)) {
+          std::get_if<google::storage::v2::Object>(&persisted_state_)) {
     return make_ready_future(
         make_status_or(static_cast<std::int64_t>(meta->size())));
   }
@@ -397,13 +398,13 @@ AsyncWriterConnectionImpl::OnFinalUpload(std::size_t upload_size,
         [this](auto f2) -> StatusOr<google::storage::v2::Object> {
           auto status = f2.get();
           if (!status.ok()) return status;
-          if (!absl::holds_alternative<google::storage::v2::Object>(
+          if (!std::holds_alternative<google::storage::v2::Object>(
                   persisted_state_)) {
             return internal::InternalError(
                 "no object metadata returned after finalizing upload",
                 GCP_ERROR_INFO());
           }
-          return absl::get<google::storage::v2::Object>(persisted_state_);
+          return std::get<google::storage::v2::Object>(persisted_state_);
         });
   });
 }
diff --git a/google/cloud/storage/internal/async/writer_connection_resumed.cc b/google/cloud/storage/internal/async/writer_connection_resumed.cc
index 17f6179cfa55c..afbe4007d4e27 100644
--- a/google/cloud/storage/internal/async/writer_connection_resumed.cc
+++ b/google/cloud/storage/internal/async/writer_connection_resumed.cc
@@ -25,6 +25,7 @@
 #include <deque>
 #include <memory>
 #include <mutex>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -89,10 +90,10 @@ class AsyncWriterConnectionResumedState
     finalized_future_ = finalized_.get_future();
     closed_future_ = closed_.get_future();
     auto state = impl_->PersistedState();
-    if (absl::holds_alternative<google::storage::v2::Object>(state)) {
-      buffer_offset_ = absl::get<google::storage::v2::Object>(state).size();
+    if (std::holds_alternative<google::storage::v2::Object>(state)) {
+      buffer_offset_ = std::get<google::storage::v2::Object>(state).size();
     } else {
-      buffer_offset_ = absl::get<std::int64_t>(state);
+      buffer_offset_ = std::get<std::int64_t>(state);
     }
     if (first_response_.has_write_handle()) {
       latest_write_handle_ = first_response_.write_handle();
@@ -336,10 +337,10 @@ class AsyncWriterConnectionResumedState
     auto impl = Impl(lk);
     auto const& state = impl->PersistedState();
     std::int64_t persisted_size = 0;
-    if (absl::holds_alternative<google::storage::v2::Object>(state)) {
-      persisted_size = absl::get<google::storage::v2::Object>(state).size();
+    if (std::holds_alternative<google::storage::v2::Object>(state)) {
+      persisted_size = std::get<google::storage::v2::Object>(state).size();
     } else {
-      persisted_size = absl::get<std::int64_t>(state);
+      persisted_size = std::get<std::int64_t>(state);
     }
     lk.unlock();
     OnQuery(persisted_size);
@@ -504,12 +505,12 @@ class AsyncWriterConnectionResumedState
       persisted_offset = first_res.persisted_size();
     } else {
       auto state = impl_->PersistedState();
-      if (absl::holds_alternative<google::storage::v2::Object>(state)) {
+      if (std::holds_alternative<google::storage::v2::Object>(state)) {
         finalized = true;
         finalized_object =
-            absl::get<google::storage::v2::Object>(std::move(state));
+            std::get<google::storage::v2::Object>(std::move(state));
       } else {
-        persisted_offset = absl::get<std::int64_t>(state);
+        persisted_offset = std::get<std::int64_t>(state);
       }
     }
 
@@ -902,7 +903,7 @@ std::unique_ptr<storage::AsyncWriterConnection> MakeWriterConnectionResumed(
     std::shared_ptr<storage::internal::HashFunction> hash_function,
     google::storage::v2::BidiWriteObjectResponse const& first_response,
     Options const& options) {
-  return absl::make_unique<AsyncWriterConnectionResumed>(
+  return std::make_unique<AsyncWriterConnectionResumed>(
       std::move(factory), std::move(impl), std::move(initial_request),
       std::move(hash_function), std::move(first_response), std::move(options));
 }
diff --git a/google/cloud/storage/internal/grpc/make_cord.h b/google/cloud/storage/internal/grpc/make_cord.h
index ba486f5f71ee7..1e2663faba9ab 100644
--- a/google/cloud/storage/internal/grpc/make_cord.h
+++ b/google/cloud/storage/internal/grpc/make_cord.h
@@ -17,7 +17,6 @@
 
 #include "google/cloud/internal/invoke_result.h"
 #include "google/cloud/version.h"
-#include "absl/meta/type_traits.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include <cstddef>
@@ -35,7 +34,7 @@ namespace storage_internal {
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 
 template <typename T>
-using IsPayloadType = absl::disjunction<
+using IsPayloadType = std::disjunction<
 #if GOOGLE_CLOUD_CPP_CPP_VERSION >= 201703L
     std::is_same<T, std::byte>,
 #endif
diff --git a/google/cloud/storage/internal/grpc/metrics_exporter_options.cc b/google/cloud/storage/internal/grpc/metrics_exporter_options.cc
index 27c50ec1424a0..959f9880396a0 100644
--- a/google/cloud/storage/internal/grpc/metrics_exporter_options.cc
+++ b/google/cloud/storage/internal/grpc/metrics_exporter_options.cc
@@ -25,6 +25,7 @@
 #include <opentelemetry/semconv/incubating/host_attributes.h>
 #include <algorithm>
 #include <type_traits>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -36,7 +37,7 @@ auto ByName(opentelemetry::sdk::resource::ResourceAttributes const& attributes,
             std::string const& name, std::string default_value) {
   auto const l = attributes.find(name);
   if (l == attributes.end()) return default_value;
-  return absl::get<std::string>(l->second);
+  return std::get<std::string>(l->second);
 }
 
 }  // namespace
diff --git a/google/cloud/storage/internal/tuple_filter.h b/google/cloud/storage/internal/tuple_filter.h
index df509f88acf8f..a999f861156d2 100644
--- a/google/cloud/storage/internal/tuple_filter.h
+++ b/google/cloud/storage/internal/tuple_filter.h
@@ -19,7 +19,6 @@
 #include "google/cloud/internal/invoke_result.h"
 #include "google/cloud/internal/tuple.h"
 #include "google/cloud/internal/utility.h"
-#include "absl/meta/type_traits.h"
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -148,7 +147,7 @@ StaticTupleFilter(Tuple&& t) {
 template <typename... Types>
 struct Among {
   template <typename T>
-  using TPred = absl::disjunction<std::is_same<std::decay_t<T>, Types>...>;
+  using TPred = std::disjunction<std::is_same<std::decay_t<T>, Types>...>;
 };
 
 /**
@@ -160,7 +159,7 @@ template <typename... Types>
 struct NotAmong {
   template <typename T>
   using TPred = std::integral_constant<
-      bool, !absl::disjunction<std::is_same<std::decay_t<T>, Types>...>::value>;
+      bool, !std::disjunction<std::is_same<std::decay_t<T>, Types>...>::value>;
 };
 
 }  // namespace internal
diff --git a/google/cloud/storage/list_objects_and_prefixes_reader.h b/google/cloud/storage/list_objects_and_prefixes_reader.h
index 78c8530345f03..682bb86f528fa 100644
--- a/google/cloud/storage/list_objects_and_prefixes_reader.h
+++ b/google/cloud/storage/list_objects_and_prefixes_reader.h
@@ -20,6 +20,7 @@
 #include "absl/types/variant.h"
 #include <iterator>
 #include <string>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -41,8 +42,8 @@ inline void SortObjectsAndPrefixes(std::vector<ObjectOrPrefix>& in) {
   };
   std::sort(in.begin(), in.end(),
             [](ObjectOrPrefix const& a, ObjectOrPrefix const& b) {
-              return (absl::visit(GetNameOrPrefix{}, a) <
-                      absl::visit(GetNameOrPrefix{}, b));
+              return (std::visit(GetNameOrPrefix{}, a) <
+                      std::visit(GetNameOrPrefix{}, b));
             });
 }
 }  // namespace internal
diff --git a/google/cloud/storage/tests/async_client_integration_test.cc b/google/cloud/storage/tests/async_client_integration_test.cc
index 7513f5f464d92..9aaf733e6c964 100644
--- a/google/cloud/storage/tests/async_client_integration_test.cc
+++ b/google/cloud/storage/tests/async_client_integration_test.cc
@@ -32,6 +32,7 @@
 #include <string>
 #include <tuple>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -378,7 +379,7 @@ TEST_F(AsyncClientIntegrationTest, StartUnbufferedUploadResume) {
   // Incidentally, this shows the value fits into an `int`.
   ASSERT_THAT(persisted, VariantWith<std::int64_t>(Le(kDesiredSize)));
   // Cast to `int` because otherwise we need to write multiple casts below.
-  auto offset = static_cast<int>(absl::get<std::int64_t>(persisted));
+  auto offset = static_cast<int>(std::get<std::int64_t>(persisted));
   if (offset % kBlockSize != 0) {
     auto s = block.substr(offset % kBlockSize);
     auto const size = s.size();
@@ -844,7 +845,7 @@ TEST_F(AsyncClientIntegrationTest, ResumeAppendableObjectUpload) {
   auto const persisted = writer.PersistedState();
   ASSERT_THAT(persisted, VariantWith<std::int64_t>(Le(kDesiredSize)));
   // Cast to `int` because otherwise we need to write multiple casts below.
-  auto offset = static_cast<int>(absl::get<std::int64_t>(persisted));
+  auto offset = static_cast<int>(std::get<std::int64_t>(persisted));
   if (offset % kBlockSize != 0) {
     auto s = block.substr(offset % kBlockSize);
     auto const size = s.size();
diff --git a/google/cloud/storage/tests/object_integration_test.cc b/google/cloud/storage/tests/object_integration_test.cc
index 134157180e410..ef8d14d8aa4d7 100644
--- a/google/cloud/storage/tests/object_integration_test.cc
+++ b/google/cloud/storage/tests/object_integration_test.cc
@@ -29,6 +29,7 @@
 #include <sstream>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace google {
@@ -162,10 +163,10 @@ TEST_F(ObjectIntegrationTest, ListObjectsAndPrefixes) {
   std::vector<std::string> objects;
   for (auto& it : reader) {
     auto const& result = it.value();
-    if (absl::holds_alternative<std::string>(result)) {
-      prefixes.push_back(absl::get<std::string>(result));
+    if (std::holds_alternative<std::string>(result)) {
+      prefixes.push_back(std::get<std::string>(result));
     } else {
-      auto const& meta = absl::get<ObjectMetadata>(result);
+      auto const& meta = std::get<ObjectMetadata>(result);
       EXPECT_EQ(bucket_name_, meta.bucket());
       objects.push_back(meta.name());
     }
@@ -196,10 +197,10 @@ TEST_F(ObjectIntegrationTest, ListObjectsAndPrefixesWithFolders) {
   std::vector<std::string> objects;
   for (auto& it : reader) {
     auto const& result = it.value();
-    if (absl::holds_alternative<std::string>(result)) {
-      prefixes.push_back(absl::get<std::string>(result));
+    if (std::holds_alternative<std::string>(result)) {
+      prefixes.push_back(std::get<std::string>(result));
     } else {
-      auto const& meta = absl::get<ObjectMetadata>(result);
+      auto const& meta = std::get<ObjectMetadata>(result);
       EXPECT_EQ(bucket_name_, meta.bucket());
       objects.push_back(meta.name());
     }
@@ -230,10 +231,10 @@ TEST_F(ObjectIntegrationTest, ListObjectsStartEndOffset) {
   std::vector<std::string> objects;
   for (auto& it : reader) {
     auto const& result = it.value();
-    if (absl::holds_alternative<std::string>(result)) {
-      prefixes.push_back(absl::get<std::string>(result));
+    if (std::holds_alternative<std::string>(result)) {
+      prefixes.push_back(std::get<std::string>(result));
     } else {
-      auto const& meta = absl::get<ObjectMetadata>(result);
+      auto const& meta = std::get<ObjectMetadata>(result);
       EXPECT_EQ(bucket_name_, meta.bucket());
       objects.push_back(meta.name());
     }
@@ -286,10 +287,10 @@ TEST_F(ObjectIntegrationTest, ListObjectsIncludeTrailingDelimiter) {
   std::vector<std::string> objects;
   for (auto& it : reader) {
     auto const& result = it.value();
-    if (absl::holds_alternative<std::string>(result)) {
-      prefixes.push_back(absl::get<std::string>(result));
+    if (std::holds_alternative<std::string>(result)) {
+      prefixes.push_back(std::get<std::string>(result));
     } else {
-      auto const& meta = absl::get<ObjectMetadata>(result);
+      auto const& meta = std::get<ObjectMetadata>(result);
       EXPECT_EQ(bucket_name_, meta.bucket());
       objects.push_back(meta.name());
     }
diff --git a/google/cloud/stream_range.h b/google/cloud/stream_range.h
index 0a699f088ef0a..62019759caaa5 100644
--- a/google/cloud/stream_range.h
+++ b/google/cloud/stream_range.h
@@ -24,6 +24,7 @@
 #include <functional>
 #include <iterator>
 #include <utility>
+#include <variant>
 
 namespace google {
 namespace cloud {
@@ -205,7 +206,7 @@ class StreamRange {
     };
     internal::ScopedCallContext scope(call_context_);
     auto v = reader_(*call_context_.options);
-    absl::visit(UnpackVariant{*this}, std::move(v));
+    std::visit(UnpackVariant{*this}, std::move(v));
   }
 
   template <typename U>
diff --git a/google/cloud/testing_util/validate_metadata.cc b/google/cloud/testing_util/validate_metadata.cc
index 229089b752535..620de51fd7105 100644
--- a/google/cloud/testing_util/validate_metadata.cc
+++ b/google/cloud/testing_util/validate_metadata.cc
@@ -16,7 +16,6 @@
 #include "google/cloud/internal/url_encode.h"
 #include "google/cloud/log.h"
 #include "google/cloud/status_or.h"
-#include "absl/meta/type_traits.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_replace.h"
 #include "absl/strings/str_split.h"
@@ -309,7 +308,7 @@ struct GetAuthorityImpl {
 
 template <typename T>
 struct GetAuthorityImpl<
-    T, absl::void_t<decltype(std::declval<T>().ExperimentalGetAuthority())>> {
+    T, std::void_t<decltype(std::declval<T>().ExperimentalGetAuthority())>> {
   absl::optional<std::string> Get(T& sc) {
     auto result = sc.ExperimentalGetAuthority();
     return std::string(result.data(), result.size());