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;
