Make consistent use of std::variant and std::optional instead of absl::*. PiperOrigin-RevId: 506436527
diff --git a/doc/domains-reference.md b/doc/domains-reference.md index e330fcb..ac8ae23 100644 --- a/doc/domains-reference.md +++ b/doc/domains-reference.md
@@ -60,7 +60,7 @@ ```c++ void MyProperty(const absl::flat_hash_map<uint32, MyProtoMessage>& m, - const absl::optional<std::string>& s) { + const std::optional<std::string>& s) { //... } FUZZ_TEST(MySuite, MyProperty);
diff --git a/domain_tests/BUILD b/domain_tests/BUILD index a07a4ab..c9d1854 100644 --- a/domain_tests/BUILD +++ b/domain_tests/BUILD
@@ -44,6 +44,8 @@ deps = [ ":domain_testing", "@com_google_absl//absl/random", + "@com_google_absl//absl/types:optional", + "@com_google_absl//absl/types:variant", "@com_google_fuzztest//fuzztest:domain", "@com_google_googletest//:gtest_main", ],
diff --git a/domain_tests/aggregate_combinators_test.cc b/domain_tests/aggregate_combinators_test.cc index 122f036..ab83bdb 100644 --- a/domain_tests/aggregate_combinators_test.cc +++ b/domain_tests/aggregate_combinators_test.cc
@@ -30,6 +30,8 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/random/random.h" +#include "absl/types/optional.h" +#include "absl/types/variant.h" #include "./fuzztest/domain.h" #include "./domain_tests/domain_testing.h"
diff --git a/fuzztest/BUILD b/fuzztest/BUILD index bde26bc..d564647 100644 --- a/fuzztest/BUILD +++ b/fuzztest/BUILD
@@ -353,7 +353,6 @@ "@com_google_absl//absl/strings", "@com_google_absl//absl/strings:str_format", "@com_google_absl//absl/types:span", - "@com_google_absl//absl/types:variant", ], )
diff --git a/fuzztest/internal/serialization.cc b/fuzztest/internal/serialization.cc index d276d9c..587f5f3 100644 --- a/fuzztest/internal/serialization.cc +++ b/fuzztest/internal/serialization.cc
@@ -20,13 +20,13 @@ #include <limits> #include <optional> #include <string> +#include <variant> #include <vector> #include "absl/strings/numbers.h" #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" -#include "absl/types/variant.h" namespace fuzztest::internal { @@ -62,10 +62,10 @@ void operator()(const std::vector<IRObject>& value) const { for (const auto& sub : value) { const bool sub_is_scalar = - !absl::holds_alternative<std::vector<IRObject>>(sub.value); + !std::holds_alternative<std::vector<IRObject>>(sub.value); absl::StrAppendFormat(&out, "%*ssub {%s", indent, "", sub_is_scalar ? " " : "\n"); - absl::visit(OutputVisitor{sub.value.index(), indent + 2, out}, sub.value); + std::visit(OutputVisitor{sub.value.index(), indent + 2, out}, sub.value); absl::StrAppendFormat(&out, "%*s}\n", sub_is_scalar ? 0 : indent, sub_is_scalar ? " " : ""); } @@ -175,7 +175,7 @@ std::string IRObject::ToString() const { std::string out = absl::StrCat(AsAbsl(kHeader), "\n"); - absl::visit(OutputVisitor{value.index(), 0, out}, value); + std::visit(OutputVisitor{value.index(), 0, out}, value); return out; }
diff --git a/fuzztest/internal/serialization.h b/fuzztest/internal/serialization.h index 2ce6092..3f91d9f 100644 --- a/fuzztest/internal/serialization.h +++ b/fuzztest/internal/serialization.h
@@ -23,11 +23,11 @@ #include <tuple> #include <type_traits> #include <utility> +#include <variant> #include <vector> #include "absl/numeric/int128.h" #include "absl/types/span.h" -#include "absl/types/variant.h" #include "./fuzztest/internal/meta.h" namespace fuzztest::internal { @@ -54,8 +54,8 @@ // set. struct IRObject { - using Value = absl::variant<std::monostate, uint64_t, double, std::string, - std::vector<IRObject>>; + using Value = std::variant<std::monostate, uint64_t, double, std::string, + std::vector<IRObject>>; Value value; IRObject() = default; @@ -77,15 +77,15 @@ auto inner = GetScalar<std::underlying_type_t<T>>(); return inner ? std::optional(static_cast<T>(*inner)) : std::nullopt; } else if constexpr (std::is_integral_v<T>) { - const uint64_t* i = absl::get_if<uint64_t>(&value); + const uint64_t* i = std::get_if<uint64_t>(&value); return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt; } else if constexpr (std::is_same_v<float, T> || std::is_same_v<double, T>) { - const double* i = absl::get_if<double>(&value); + const double* i = std::get_if<double>(&value); return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt; } else if constexpr (std::is_same_v<std::string, T>) { std::optional<std::string_view> out; - if (const auto* s = absl::get_if<std::string>(&value)) { + if (const auto* s = std::get_if<std::string>(&value)) { out = *s; } return out; @@ -113,12 +113,12 @@ // If this node contains subs, return it as a Span. Otherwise, nullopt. std::optional<absl::Span<const IRObject>> Subs() const { - if (const auto* i = absl::get_if<std::vector<IRObject>>(&value)) { + if (const auto* i = std::get_if<std::vector<IRObject>>(&value)) { return *i; } // The empty vector is serialized the same way as the monostate: nothing. // Handle that case too. - if (absl::holds_alternative<std::monostate>(value)) { + if (std::holds_alternative<std::monostate>(value)) { return absl::Span<const IRObject>{}; } return std::nullopt; @@ -128,10 +128,10 @@ // them. // Overwrites any existing data. std::vector<IRObject>& MutableSubs() { - if (!absl::holds_alternative<std::vector<IRObject>>(value)) { + if (!std::holds_alternative<std::vector<IRObject>>(value)) { value.emplace<std::vector<IRObject>>(); } - return absl::get<std::vector<IRObject>>(value); + return std::get<std::vector<IRObject>>(value); } // Conversion functions to map IRObject to/from corpus values. @@ -198,7 +198,7 @@ if constexpr (std::is_const_v<T>) { return ToCorpus<std::remove_const_t<T>>(); } else if constexpr (is_monostate_v<T>) { - if (absl::holds_alternative<std::monostate>(value)) return T{}; + if (std::holds_alternative<std::monostate>(value)) return T{}; return std::nullopt; } else if constexpr (std::is_same_v<T, IRObject>) { return *this; @@ -226,7 +226,7 @@ } return std::nullopt; } else if constexpr (is_protocol_buffer_v<T>) { - const std::string* v = absl::get_if<std::string>(&value); + const std::string* v = std::get_if<std::string>(&value); T out; if (v && out.ParseFromString(*v)) return out; return std::nullopt;