Replace folly::Optional::hasValue() by has_value()

Differential Revision: D19882830

fbshipit-source-id: 031217f9890351022bc8d171f0ccd7e045dd6972

folly/compression/Compression.cpp

@@ -700,7 +700,7 @@ std::unique_ptr<IOBuf> LZ4Codec::doUncompress(
     }
   } else {
     // Invariants
-    DCHECK(uncompressedLength.hasValue());
+    DCHECK(uncompressedLength.has_value());
     DCHECK(*uncompressedLength <= maxUncompressedLength());
     actualUncompressedLength = *uncompressedLength;
   }

folly/compression/Zlib.cpp

@@ -342,7 +342,7 @@ bool ZlibStreamCodec::doCompressStream(
     resetDeflateStream();
     needReset_ = false;
   }
-  DCHECK(deflateStream_.hasValue());
+  DCHECK(deflateStream_.has_value());
   // zlib will return Z_STREAM_ERROR if output.data() is null.
   if (output.data() == nullptr) {
     return false;
@@ -377,7 +377,7 @@ bool ZlibStreamCodec::doUncompressStream(
     resetInflateStream();
     needReset_ = false;
   }
-  DCHECK(inflateStream_.hasValue());
+  DCHECK(inflateStream_.has_value());
   // zlib will return Z_STREAM_ERROR if output.data() is null.
   if (output.data() == nullptr) {
     return false;

folly/container/test/UtilTest.cpp

@@ -470,7 +470,7 @@ TEST(Util, callWithConstructedKey) {
   // very useful in real life.  Verify that it works.
   sink.reset();
   detail::callWithConstructedKey<Tracked<0>, FalseFunc1>(a, sinkFunc);
-  EXPECT_TRUE(sink.hasValue());
+  EXPECT_TRUE(sink.has_value());
 }
 
 // We're deliberately allowing only a subset of the desired heterogeneous

folly/experimental/bser/Dump.cpp

@@ -38,7 +38,7 @@ serialization_opts::serialization_opts()
 static const dynamic* getTemplate(
     const serialization_opts& opts,
     dynamic const& dynArray) {
-  if (!opts.templates.hasValue()) {
+  if (!opts.templates.has_value()) {
     return nullptr;
   }
   const auto& templates = opts.templates.value();

folly/experimental/settings/test/SettingsTest.cpp

@@ -98,7 +98,7 @@ TEST(Settings, user_defined) {
   {
     folly::settings::Snapshot sn;
     auto info = sn.getAsString("follytest_user_defined");
-    EXPECT_TRUE(info.hasValue());
+    EXPECT_TRUE(info.has_value());
     EXPECT_EQ(info->first, "a_out");
     EXPECT_EQ(info->second, "test");
   }
@@ -113,7 +113,7 @@ TEST(Settings, user_defined) {
   {
     folly::settings::Snapshot sn;
     auto info = sn.getAsString("follytest_user_defined");
-    EXPECT_TRUE(info.hasValue());
+    EXPECT_TRUE(info.has_value());
     EXPECT_EQ(info->first, "a_out");
     EXPECT_EQ(info->second, "test");
   }
@@ -126,7 +126,7 @@ TEST(Settings, user_defined) {
   {
     folly::settings::Snapshot sn;
     auto info = sn.getAsString("follytest_user_defined");
-    EXPECT_TRUE(info.hasValue());
+    EXPECT_TRUE(info.has_value());
     EXPECT_EQ(info->first, "b_out");
     EXPECT_EQ(info->second, "default");
   }
@@ -140,7 +140,7 @@ TEST(Settings, user_defined) {
   {
     folly::settings::Snapshot sn;
     auto info = sn.getAsString("follytest_user_defined");
-    EXPECT_TRUE(info.hasValue());
+    EXPECT_TRUE(info.has_value());
     EXPECT_EQ(info->first, "b_out");
     EXPECT_EQ(info->second, "default");
   }
@@ -161,13 +161,13 @@ TEST(Settings, basic) {
   {
     folly::settings::Snapshot sn;
     auto res = sn.getAsString("follytest_public_flag_to_a");
-    EXPECT_TRUE(res.hasValue());
+    EXPECT_TRUE(res.has_value());
     EXPECT_EQ(res->first, "200");
     EXPECT_EQ(res->second, "remote_set");
   }
   {
     auto meta = folly::settings::getSettingsMeta("follytest_public_flag_to_a");
-    EXPECT_TRUE(meta.hasValue());
+    EXPECT_TRUE(meta.has_value());
     const auto& md = meta.value();
     EXPECT_EQ(md.project, "follytest");
     EXPECT_EQ(md.name, "public_flag_to_a");
@@ -176,7 +176,7 @@ TEST(Settings, basic) {
   }
   {
     auto meta = folly::settings::getSettingsMeta("follytest_some_flag");
-    EXPECT_TRUE(meta.hasValue());
+    EXPECT_TRUE(meta.has_value());
     const auto& md = meta.value();
     EXPECT_EQ(md.project, "follytest");
     EXPECT_EQ(md.name, "some_flag");
@@ -186,7 +186,7 @@ TEST(Settings, basic) {
   {
     folly::settings::Snapshot sn;
     auto res = sn.getAsString("follytest_nonexisting");
-    EXPECT_FALSE(res.hasValue());
+    EXPECT_FALSE(res.has_value());
   }
   {
     folly::settings::Snapshot sn;
@@ -199,7 +199,7 @@ TEST(Settings, basic) {
   {
     folly::settings::Snapshot sn;
     auto res = sn.getAsString("follytest_public_flag_to_a");
-    EXPECT_TRUE(res.hasValue());
+    EXPECT_TRUE(res.has_value());
     EXPECT_EQ(res->first, "300");
     EXPECT_EQ(res->second, "from_string");
   }

folly/fibers/test/FibersTest.cpp

@@ -1113,8 +1113,8 @@ TEST(FiberManager, remoteFiberBasic) {
 
   manager.loopUntilNoReady();
 
-  EXPECT_TRUE(savedPromise[0].hasValue());
-  EXPECT_TRUE(savedPromise[1].hasValue());
+  EXPECT_TRUE(savedPromise[0].has_value());
+  EXPECT_TRUE(savedPromise[1].has_value());
   EXPECT_EQ(0, result[0]);
   EXPECT_EQ(0, result[1]);
 
@@ -1156,8 +1156,8 @@ TEST(FiberManager, addTaskRemoteBasic) {
 
   manager.loopUntilNoReady();
 
-  EXPECT_TRUE(savedPromise[0].hasValue());
-  EXPECT_TRUE(savedPromise[1].hasValue());
+  EXPECT_TRUE(savedPromise[0].has_value());
+  EXPECT_TRUE(savedPromise[1].has_value());
   EXPECT_EQ(0, result[0]);
   EXPECT_EQ(0, result[1]);
 

folly/futures/test/PollTest.cpp

@@ -29,7 +29,7 @@ TEST(Poll, ready) {
 TEST(Poll, notReady) {
   Promise<int> p;
   auto f = p.getFuture();
-  EXPECT_FALSE(f.poll().hasValue());
+  EXPECT_FALSE(f.poll().has_value());
 }
 
 TEST(Poll, exception) {

folly/gen/test/BaseTest.cpp

@@ -491,7 +491,7 @@ TEST(Gen, Composed) {
   // Operator, Operator
   // clang-format off
   auto valuesOf
-    = filter([](Optional<int>& o) { return o.hasValue(); })
+    = filter([](Optional<int>& o) { return o.has_value(); })
     | map([](Optional<int>& o) -> int& { return o.value(); });
   // clang-format on
   std::vector<Optional<int>> opts{none, 4, none, 6, none};
@@ -1378,13 +1378,13 @@ TEST(Gen, Unwrap) {
   // optional has a value, and that value is non-null
   EXPECT_TRUE(bool(oup | unwrap));
   EXPECT_EQ(5, *(oup | unwrap));
-  EXPECT_TRUE(oup.hasValue()); // still has a pointer (null or not)
+  EXPECT_TRUE(oup.has_value()); // still has a pointer (null or not)
   EXPECT_TRUE(bool(oup.value())); // that value isn't null
 
   auto moved1 = std::move(oup) | unwrapOr(std::make_unique<int>(6));
   // oup still has a value, but now it's now nullptr since the pointer was moved
   // into moved1
-  EXPECT_TRUE(oup.hasValue());
+  EXPECT_TRUE(oup.has_value());
   EXPECT_FALSE(oup.value());
   EXPECT_TRUE(bool(moved1));
   EXPECT_EQ(5, *moved1);

folly/io/async/AsyncUDPSocket.cpp

@@ -742,7 +742,7 @@ bool AsyncUDPSocket::setGSO(int val) {
 
 int AsyncUDPSocket::getGSO() {
   // check if we can return the cached value
-  if (FOLLY_UNLIKELY(!gso_.hasValue())) {
+  if (FOLLY_UNLIKELY(!gso_.has_value())) {
 #ifdef FOLLY_HAVE_MSG_ERRQUEUE
     int gso = -1;
     socklen_t optlen = sizeof(gso);

folly/io/async/test/AsyncSSLSocketTest.cpp

@@ -512,16 +512,16 @@ class NextProtocolTest : public Test {
   }
 
   void expectHandshakeSuccess() {
-    EXPECT_FALSE(client->except.hasValue())
+    EXPECT_FALSE(client->except.has_value())
         << "client handshake error: " << client->except->what();
-    EXPECT_FALSE(server->except.hasValue())
+    EXPECT_FALSE(server->except.has_value())
         << "server handshake error: " << server->except->what();
   }
 
   void expectHandshakeError() {
-    EXPECT_TRUE(client->except.hasValue())
+    EXPECT_TRUE(client->except.has_value())
         << "Expected client handshake error!";
-    EXPECT_TRUE(server->except.hasValue())
+    EXPECT_TRUE(server->except.has_value())
         << "Expected server handshake error!";
   }
 

folly/io/async/test/AsyncSocketTest2.cpp

@@ -3200,10 +3200,10 @@ TEST_P(AsyncSocketErrMessageCallbackTest, ErrMessageCallback) {
   // set the number of error messages before socket is closed or callback reset
   const auto testParams = GetParam();
   errMsgCB.socket_ = socket.get();
-  if (testParams.resetCallbackAfter.hasValue()) {
+  if (testParams.resetCallbackAfter.has_value()) {
     errMsgCB.resetCallbackAfter_ = testParams.resetCallbackAfter.value();
   }
-  if (testParams.closeSocketAfter.hasValue()) {
+  if (testParams.closeSocketAfter.has_value()) {
     errMsgCB.closeSocketAfter_ = testParams.closeSocketAfter.value();
   }
 

folly/io/async/test/BlockingSocket.h

@@ -59,7 +59,7 @@ class BlockingSocket : public folly::AsyncSocket::ConnectCallback,
     DCHECK_LE(timeout.count(), std::numeric_limits<int>::max());
     sock_->connect(this, address_, folly::to_narrow(timeout.count()));
     eventBase_.loop();
-    if (err_.hasValue()) {
+    if (err_.has_value()) {
       throw err_.value();
     }
   }
@@ -77,7 +77,7 @@ class BlockingSocket : public folly::AsyncSocket::ConnectCallback,
       folly::WriteFlags flags = folly::WriteFlags::NONE) {
     sock_->write(this, buf, len, flags);
     eventBase_.loop();
-    if (err_.hasValue()) {
+    if (err_.has_value()) {
       throw err_.value();
     }
     return folly::to_narrow(folly::to_signed(len));
@@ -154,7 +154,7 @@ class BlockingSocket : public folly::AsyncSocket::ConnectCallback,
       }
     }
     sock_->setReadCB(nullptr);
-    if (err_.hasValue()) {
+    if (err_.has_value()) {
       throw err_.value();
     }
     if (all && readLen_ > 0) {

folly/json_patch.cpp

@@ -266,7 +266,7 @@ json_patch::apply(dynamic& obj) {
         break;
       }
       case op_code::add: {
-        DCHECK(op.value.hasValue());
+        DCHECK(op.value.has_value());
         auto ret = do_add(resolved_path, *op.value, op.path.tokens().back());
         if (ret.hasError()) {
           return makeUnexpected(error{ret.error(), index});
@@ -283,7 +283,7 @@ json_patch::apply(dynamic& obj) {
         break;
       }
       case op_code::move: {
-        DCHECK(op.from.hasValue());
+        DCHECK(op.from.has_value());
         auto resolved_from = obj.try_get_ptr(*op.from);
         if (!resolved_from.hasValue()) {
           return makeUnexpected(error{error_code::from_not_found, index});
@@ -304,7 +304,7 @@ json_patch::apply(dynamic& obj) {
         break;
       }
       case op_code::copy: {
-        DCHECK(op.from.hasValue());
+        DCHECK(op.from.has_value());
         auto const resolved_from = obj.try_get_ptr(*op.from);
         if (!resolved_from.hasValue()) {
           return makeUnexpected(error{error_code::from_not_found, index});

folly/logging/FileWriterFactory.cpp

@@ -46,12 +46,12 @@ std::shared_ptr<LogWriter> FileWriterFactory::createWriter(File file) {
   // Determine whether we should use ImmediateFileWriter or AsyncFileWriter
   if (async_) {
     auto asyncWriter = make_shared<AsyncFileWriter>(std::move(file));
-    if (maxBufferSize_.hasValue()) {
+    if (maxBufferSize_.has_value()) {
       asyncWriter->setMaxBufferSize(maxBufferSize_.value());
     }
     return asyncWriter;
   } else {
-    if (maxBufferSize_.hasValue()) {
+    if (maxBufferSize_.has_value()) {
       throw std::invalid_argument(to<string>(
           "the \"max_buffer_size\" option is only valid for async file "
           "handlers"));

folly/logging/LogConfig.cpp

@@ -33,7 +33,7 @@ void LogConfig::update(const LogConfig& other) {
   // Update handlerConfigs_ with all of the entries from the other LogConfig.
   // Any entries already present in our handlerConfigs_ are replaced wholesale.
   for (const auto& entry : other.handlerConfigs_) {
-    if (entry.second.type.hasValue()) {
+    if (entry.second.type.has_value()) {
       // This is a complete LogHandlerConfig that should be inserted
       // or completely replace an existing handler config with this name.
       auto result = handlerConfigs_.insert(entry);
@@ -65,7 +65,7 @@ void LogConfig::update(const LogConfig& other) {
       auto* existingEntry = &result.first->second;
       auto oldHandlers = std::move(existingEntry->handlers);
       *existingEntry = entry.second;
-      if (!existingEntry->handlers.hasValue()) {
+      if (!existingEntry->handlers.has_value()) {
         existingEntry->handlers = std::move(oldHandlers);
       }
     }

folly/logging/LogConfigParser.cpp

@@ -402,7 +402,7 @@ std::pair<std::string, LogHandlerConfig> parseHandlerConfig(StringPiece value) {
         handlerName,
         "\": name cannot contain a comma when using the basic config format")};
   }
-  if (handlerType.hasValue()) {
+  if (handlerType.has_value()) {
     if (handlerType->empty()) {
       throw LogConfigParseError{to<string>(
           "error parsing configuration for log handler \"",
@@ -584,7 +584,7 @@ dynamic logConfigToDynamic(const LogHandlerConfig& config) {
     options.insert(opt.first, opt.second);
   }
   auto result = dynamic::object("options", options);
-  if (config.type.hasValue()) {
+  if (config.type.has_value()) {
     result("type", config.type.value());
   }
   return result;
@@ -594,7 +594,7 @@ dynamic logConfigToDynamic(const LogCategoryConfig& config) {
   auto value = dynamic::object("level", logLevelToString(config.level))(
       "inherit", config.inheritParentLevel)(
       "propagate", logLevelToString(config.propagateLevelMessagesToParent));
-  if (config.handlers.hasValue()) {
+  if (config.handlers.has_value()) {
     auto handlers = dynamic::array();
     for (const auto& handlerName : config.handlers.value()) {
       handlers.push_back(handlerName);

folly/logging/LogHandlerConfig.cpp

@@ -27,18 +27,18 @@ LogHandlerConfig::LogHandlerConfig() = default;
 LogHandlerConfig::LogHandlerConfig(StringPiece t) : type{t.str()} {}
 
 LogHandlerConfig::LogHandlerConfig(Optional<StringPiece> t)
-    : type{t.hasValue() ? Optional<string>{t->str()} : Optional<string>{}} {}
+    : type{t.has_value() ? Optional<string>{t->str()} : Optional<string>{}} {}
 
 LogHandlerConfig::LogHandlerConfig(StringPiece t, Options opts)
     : type{t.str()}, options{std::move(opts)} {}
 
 LogHandlerConfig::LogHandlerConfig(Optional<StringPiece> t, Options opts)
-    : type{t.hasValue() ? Optional<string>{t->str()} : Optional<string>{}},
+    : type{t.has_value() ? Optional<string>{t->str()} : Optional<string>{}},
       options{std::move(opts)} {}
 
 void LogHandlerConfig::update(const LogHandlerConfig& other) {
   FOLLY_SAFE_DCHECK(
-      !other.type.hasValue(), "LogHandlerConfig type cannot be updated");
+      !other.type.has_value(), "LogHandlerConfig type cannot be updated");
   for (const auto& option : other.options) {
     options[option.first] = option.second;
   }

folly/logging/LoggerDB.cpp

@@ -217,7 +217,7 @@ void LoggerDB::startConfigUpdate(
 
     LogHandlerConfig updatedConfig;
     const LogHandlerConfig* handlerConfig;
-    if (entry.second.type.hasValue()) {
+    if (entry.second.type.has_value()) {
       handlerConfig = &entry.second;
     } else {
       // This configuration is intended to update an existing LogHandler
@@ -227,7 +227,7 @@ void LoggerDB::startConfigUpdate(
       }
 
       updatedConfig = oldHandler->getConfig();
-      if (!updatedConfig.type.hasValue()) {
+      if (!updatedConfig.type.has_value()) {
         // This normally should not happen unless someone improperly manually
         // constructed a LogHandler object.  All existing LogHandler objects
         // should indicate their type.
@@ -279,7 +279,7 @@ void LoggerDB::startConfigUpdate(
   // Before we start making any LogCategory changes, confirm that all handlers
   // named in the category configs are known handlers.
   for (const auto& entry : config.getCategoryConfigs()) {
-    if (!entry.second.handlers.hasValue()) {
+    if (!entry.second.handlers.has_value()) {
       continue;
     }
     for (const auto& handlerName : entry.second.handlers.value()) {
@@ -374,7 +374,7 @@ void LoggerDB::updateConfig(const LogConfig& config) {
         getOrCreateCategoryLocked(*loggersByName, entry.first);
 
     // Update the log handlers
-    if (entry.second.handlers.hasValue()) {
+    if (entry.second.handlers.has_value()) {
       auto catHandlers = buildCategoryHandlerList(
           handlers, entry.first, entry.second.handlers.value());
       category->replaceHandlers(std::move(catHandlers));
@@ -442,7 +442,7 @@ void LoggerDB::resetConfig(const LogConfig& config) {
       // If the handler list is not set in the config, clear out any existing
       // handlers rather than leaving it as-is.
       std::vector<std::shared_ptr<LogHandler>> catHandlers;
-      if (catConfig.handlers.hasValue()) {
+      if (catConfig.handlers.has_value()) {
         catHandlers = buildCategoryHandlerList(
             handlers, entry.first, catConfig.handlers.value());
       }

folly/logging/test/ConfigHelpers.cpp

@@ -68,7 +68,7 @@ std::ostream& operator<<(std::ostream& os, const LogCategoryConfig& config) {
   if (config.propagateLevelMessagesToParent > LogLevel::MIN_LEVEL) {
     os << "[" << config.propagateLevelMessagesToParent << "]";
   }
-  if (config.handlers.hasValue()) {
+  if (config.handlers.has_value()) {
     os << ":" << join(",", config.handlers.value());
   }
   return os;

folly/test/IPAddressTest.cpp

@@ -1249,33 +1249,33 @@ TEST(IPAddress, StringFormat) {
 
 TEST(IPAddress, getMacAddressFromLinkLocal) {
   IPAddressV6 ip6("fe80::f652:14ff:fec5:74d8");
-  EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().hasValue());
+  EXPECT_TRUE(ip6.getMacAddressFromLinkLocal().has_value());
   EXPECT_EQ("f4:52:14:c5:74:d8", ip6.getMacAddressFromLinkLocal()->toString());
 }
 
 TEST(IPAddress, getMacAddressFromLinkLocal_Negative) {
   IPAddressV6 no_link_local_ip6("2803:6082:a2:4447::1");
-  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
+  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().has_value());
   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ccc5:74d8");
-  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
+  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().has_value());
   no_link_local_ip6 = IPAddressV6("fe80::f652:14ff:ffc5:74d8");
-  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
+  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().has_value());
   no_link_local_ip6 = IPAddressV6("fe81::f652:14ff:ffc5:74d8");
-  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().hasValue());
+  EXPECT_FALSE(no_link_local_ip6.getMacAddressFromLinkLocal().has_value());
 }
 
 TEST(IPAddress, getMacAddressFromEUI64) {
   IPAddressV6 ip6("2401:db00:3020:51dc:4a57:ddff:fe04:5643");
-  EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
+  EXPECT_TRUE(ip6.getMacAddressFromEUI64().has_value());
   EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
   ip6 = IPAddressV6("fe80::4a57:ddff:fe04:5643");
-  EXPECT_TRUE(ip6.getMacAddressFromEUI64().hasValue());
+  EXPECT_TRUE(ip6.getMacAddressFromEUI64().has_value());
   EXPECT_EQ("48:57:dd:04:56:43", ip6.getMacAddressFromEUI64()->toString());
 }
 
 TEST(IPAddress, getMacAddressFromEUI64_Negative) {
   IPAddressV6 not_eui64_ip6("2401:db00:3020:51dc:face:0000:009a:0000");
-  EXPECT_FALSE(not_eui64_ip6.getMacAddressFromEUI64().hasValue());
+  EXPECT_FALSE(not_eui64_ip6.getMacAddressFromEUI64().has_value());
 }
 
 TEST(IPAddress, LongestCommonPrefix) {

folly/test/MapUtilTest.cpp

@@ -65,9 +65,9 @@ TEST(MapUtil, get_or_throw_specified) {
 TEST(MapUtil, get_optional) {
   std::map<int, int> m;
   m[1] = 2;
-  EXPECT_TRUE(get_optional(m, 1).hasValue());
+  EXPECT_TRUE(get_optional(m, 1).has_value());
   EXPECT_EQ(2, get_optional(m, 1).value());
-  EXPECT_FALSE(get_optional(m, 2).hasValue());
+  EXPECT_FALSE(get_optional(m, 2).has_value());
 }
 
 TEST(MapUtil, get_optional_path_simple) {

folly/test/OptionalCoroutinesTest.cpp

@@ -44,7 +44,7 @@ TEST(Optional, CoroutineSuccess) {
     EXPECT_EQ((int)(2.0 * 7 + 7), *z);
     co_return* z;
   }();
-  EXPECT_TRUE(r0.hasValue());
+  EXPECT_TRUE(r0.has_value());
   EXPECT_EQ(21, *r0);
 }
 
@@ -60,7 +60,7 @@ TEST(Optional, CoroutineFailure) {
     ADD_FAILURE();
     co_return z;
   }();
-  EXPECT_TRUE(!r1.hasValue());
+  EXPECT_TRUE(!r1.has_value());
 }
 
 Optional<int> throws() {
@@ -94,7 +94,7 @@ TEST(Optional, CoroutineCleanedUp) {
     ADD_FAILURE() << "Should not be resuming";
     co_return x;
   }();
-  EXPECT_FALSE(r.hasValue());
+  EXPECT_FALSE(r.has_value());
   EXPECT_EQ(1, count_dest);
 }
 

folly/test/OptionalTest.cpp

@@ -346,26 +346,26 @@ TEST(Optional, Swap) {
   Optional<std::string> b;
 
   swap(a, b);
-  EXPECT_FALSE(a.hasValue());
-  EXPECT_FALSE(b.hasValue());
+  EXPECT_FALSE(a.has_value());
+  EXPECT_FALSE(b.has_value());
 
   a = "hello";
-  EXPECT_TRUE(a.hasValue());
-  EXPECT_FALSE(b.hasValue());
+  EXPECT_TRUE(a.has_value());
+  EXPECT_FALSE(b.has_value());
   EXPECT_EQ("hello", a.value());
 
   swap(a, b);
-  EXPECT_FALSE(a.hasValue());
-  EXPECT_TRUE(b.hasValue());
+  EXPECT_FALSE(a.has_value());
+  EXPECT_TRUE(b.has_value());
   EXPECT_EQ("hello", b.value());
 
   a = "bye";
-  EXPECT_TRUE(a.hasValue());
+  EXPECT_TRUE(a.has_value());
   EXPECT_EQ("bye", a.value());
 
   swap(a, b);
-  EXPECT_TRUE(a.hasValue());
-  EXPECT_TRUE(b.hasValue());
+  EXPECT_TRUE(a.has_value());
+  EXPECT_TRUE(b.has_value());
   EXPECT_EQ("hello", a.value());
   EXPECT_EQ("bye", b.value());
 }
@@ -620,7 +620,7 @@ TEST(Optional, MakeOptional) {
   // const L-value version
   const std::string s("abc");
   auto optStr = folly::make_optional(s);
-  ASSERT_TRUE(optStr.hasValue());
+  ASSERT_TRUE(optStr.has_value());
   EXPECT_EQ(*optStr, "abc");
   *optStr = "cde";
   EXPECT_EQ(s, "abc");
@@ -629,7 +629,7 @@ TEST(Optional, MakeOptional) {
   // L-value version
   std::string s2("abc");
   auto optStr2 = folly::make_optional(s2);
-  ASSERT_TRUE(optStr2.hasValue());
+  ASSERT_TRUE(optStr2.has_value());
   EXPECT_EQ(*optStr2, "abc");
   *optStr2 = "cde";
   // it's vital to check that s2 wasn't clobbered
@@ -638,7 +638,7 @@ TEST(Optional, MakeOptional) {
   // L-value reference version
   std::string& s3(s2);
   auto optStr3 = folly::make_optional(s3);
-  ASSERT_TRUE(optStr3.hasValue());
+  ASSERT_TRUE(optStr3.has_value());
   EXPECT_EQ(*optStr3, "abc");
   *optStr3 = "cde";
   EXPECT_EQ(s3, "abc");
@@ -647,7 +647,7 @@ TEST(Optional, MakeOptional) {
   unique_ptr<int> pInt(new int(3));
   auto optIntPtr = folly::make_optional(std::move(pInt));
   EXPECT_TRUE(pInt.get() == nullptr);
-  ASSERT_TRUE(optIntPtr.hasValue());
+  ASSERT_TRUE(optIntPtr.has_value());
   EXPECT_EQ(**optIntPtr, 3);
 
   // variadic version
@@ -682,11 +682,11 @@ TEST(Optional, TestDisambiguationMakeOptionalVariants) {
 TEST(Optional, SelfAssignment) {
   Optional<int> a = 42;
   a = static_cast<decltype(a)&>(a); // suppress self-assign warning
-  ASSERT_TRUE(a.hasValue() && a.value() == 42);
+  ASSERT_TRUE(a.has_value() && a.value() == 42);
 
   Optional<int> b = 23333333;
   b = static_cast<decltype(b)&&>(b); // suppress self-move warning
-  ASSERT_TRUE(b.hasValue() && b.value() == 23333333);
+  ASSERT_TRUE(b.has_value() && b.value() == 23333333);
 }
 
 namespace {
@@ -696,7 +696,7 @@ class ContainsOptional {
   ContainsOptional() {}
   explicit ContainsOptional(int x) : opt_(x) {}
   bool hasValue() const {
-    return opt_.hasValue();
+    return opt_.has_value();
   }
   int value() const {
     return opt_.value();