react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/hermes/inspector/chrome/MessageTypesInlines.h

@@ -10,6 +10,7 @@
 #include <hermes/inspector/chrome/MessageInterfaces.h>
 
 #include <memory>
+#include <optional>
 #include <type_traits>
 
 namespace facebook {
@@ -21,7 +22,7 @@ namespace message {
 using dynamic = folly::dynamic;
 
 template <typename T>
-using optional = folly::Optional<T>;
+using optional = std::optional<T>;
 
 template <typename>
 struct is_vector : std::false_type {};
@@ -90,7 +91,7 @@ void assign(optional<T> &lhs, const dynamic &obj, const U &key) {
   if (it != obj.items().end()) {
     lhs = valueFromDynamic<T>(it->second);
   } else {
-    lhs.clear();
+    lhs.reset();
   }
 }
 
@@ -136,7 +137,7 @@ void put(dynamic &obj, const K &key, const V &value) {
 
 template <typename K, typename V>
 void put(dynamic &obj, const K &key, const optional<V> &optValue) {
-  if (optValue.hasValue()) {
+  if (optValue.has_value()) {
     obj[key] = valueToDynamic(optValue.value());
   } else {
     obj.erase(key);

package/ReactCommon/hermes/inspector/chrome/tests/ConnectionTests.cpp

@@ -23,6 +23,7 @@
 #include <hermes/hermes.h>
 #include <hermes/inspector/chrome/MessageTypes.h>
 #include <jsi/instrumentation.h>
+#include <optional>
 
 namespace facebook {
 namespace hermes {
@@ -181,7 +182,7 @@ void expectCallFrames(
       EXPECT_EQ(frame.scopeChain.size(), info.scopeCount);
 
       for (int j = 0; j < info.scopeCount; j++) {
-        EXPECT_TRUE(frame.scopeChain[j].object.objectId.hasValue());
+        EXPECT_TRUE(frame.scopeChain[j].object.objectId.has_value());
       }
     }
 
@@ -250,7 +251,7 @@ m::debugger::ScriptParsedNotification expectScriptParsed(
   EXPECT_GT(note.scriptId.size(), 0);
 
   if (sourceMapURL.empty()) {
-    EXPECT_FALSE(note.sourceMapURL.hasValue());
+    EXPECT_FALSE(note.sourceMapURL.has_value());
   } else {
     EXPECT_EQ(note.sourceMapURL.value(), sourceMapURL);
   }
@@ -304,7 +305,7 @@ void expectEvalResponse(
   EXPECT_EQ(resp.id, id);
   EXPECT_EQ(resp.result.type, "string");
   EXPECT_EQ(resp.result.value, expectedValue);
-  EXPECT_FALSE(resp.exceptionDetails.hasValue());
+  EXPECT_FALSE(resp.exceptionDetails.has_value());
 }
 
 void expectEvalResponse(SyncConnection &conn, int id, bool expectedValue) {
@@ -314,7 +315,7 @@ void expectEvalResponse(SyncConnection &conn, int id, bool expectedValue) {
   EXPECT_EQ(resp.id, id);
   EXPECT_EQ(resp.result.type, "boolean");
   EXPECT_EQ(resp.result.value, expectedValue);
-  EXPECT_FALSE(resp.exceptionDetails.hasValue());
+  EXPECT_FALSE(resp.exceptionDetails.has_value());
 }
 
 void expectEvalResponse(SyncConnection &conn, int id, int expectedValue) {
@@ -324,7 +325,7 @@ void expectEvalResponse(SyncConnection &conn, int id, int expectedValue) {
   EXPECT_EQ(resp.id, id);
   EXPECT_EQ(resp.result.type, "number");
   EXPECT_EQ(resp.result.value, expectedValue);
-  EXPECT_FALSE(resp.exceptionDetails.hasValue());
+  EXPECT_FALSE(resp.exceptionDetails.has_value());
 }
 
 void expectEvalException(
@@ -336,7 +337,7 @@ void expectEvalException(
       expectResponse<m::debugger::EvaluateOnCallFrameResponse>(conn, id);
 
   EXPECT_EQ(resp.id, id);
-  EXPECT_TRUE(resp.exceptionDetails.hasValue());
+  EXPECT_TRUE(resp.exceptionDetails.has_value());
 
   m::runtime::ExceptionDetails &details = resp.exceptionDetails.value();
   EXPECT_EQ(details.text, exceptionText);
@@ -344,7 +345,7 @@ void expectEvalException(
   // TODO: Hermes doesn't seem to populate the line number for the exception?
   EXPECT_EQ(details.lineNumber, 0);
 
-  EXPECT_TRUE(details.stackTrace.hasValue());
+  EXPECT_TRUE(details.stackTrace.has_value());
 
   m::runtime::StackTrace &stackTrace = details.stackTrace.value();
   EXPECT_EQ(stackTrace.callFrames.size(), infos.size());
@@ -381,9 +382,9 @@ struct PropInfo {
   }
 
   std::string type;
-  folly::Optional<std::string> subtype;
-  folly::Optional<folly::dynamic> value;
-  folly::Optional<std::string> unserializableValue;
+  std::optional<std::string> subtype;
+  std::optional<folly::dynamic> value;
+  std::optional<std::string> unserializableValue;
 };
 
 std::unordered_map<std::string, std::string> expectProps(
@@ -412,23 +413,23 @@ std::unordered_map<std::string, std::string> expectProps(
     if (infoIt != infos.end()) {
       const PropInfo &info = infoIt->second;
 
-      EXPECT_TRUE(desc.value.hasValue());
+      EXPECT_TRUE(desc.value.has_value());
 
       m::runtime::RemoteObject &remoteObj = desc.value.value();
       EXPECT_EQ(remoteObj.type, info.type);
 
-      if (info.subtype.hasValue()) {
-        EXPECT_TRUE(remoteObj.subtype.hasValue());
+      if (info.subtype.has_value()) {
+        EXPECT_TRUE(remoteObj.subtype.has_value());
         EXPECT_EQ(remoteObj.subtype.value(), info.subtype.value());
       }
 
-      if (info.value.hasValue()) {
-        EXPECT_TRUE(remoteObj.value.hasValue());
+      if (info.value.has_value()) {
+        EXPECT_TRUE(remoteObj.value.has_value());
         EXPECT_EQ(remoteObj.value.value(), info.value.value());
       }
 
-      if (info.unserializableValue.hasValue()) {
-        EXPECT_TRUE(remoteObj.unserializableValue.hasValue());
+      if (info.unserializableValue.has_value()) {
+        EXPECT_TRUE(remoteObj.unserializableValue.has_value());
         EXPECT_EQ(
             remoteObj.unserializableValue.value(),
             info.unserializableValue.value());
@@ -436,7 +437,7 @@ std::unordered_map<std::string, std::string> expectProps(
 
       if ((info.type == "object" && info.subtype != "null") ||
           info.type == "function") {
-        EXPECT_TRUE(remoteObj.objectId.hasValue());
+        EXPECT_TRUE(remoteObj.objectId.has_value());
         objectIds[desc.name] = remoteObj.objectId.value();
       }
     }
@@ -454,9 +455,9 @@ void expectEvalResponse(
 
   EXPECT_EQ(resp.id, id);
   EXPECT_EQ(resp.result.type, "object");
-  EXPECT_FALSE(resp.exceptionDetails.hasValue());
+  EXPECT_FALSE(resp.exceptionDetails.has_value());
 
-  EXPECT_TRUE(resp.result.objectId.hasValue());
+  EXPECT_TRUE(resp.result.objectId.has_value());
   expectProps(conn, id + 1, resp.result.objectId.value(), infos);
 }
 
@@ -1007,7 +1008,7 @@ TEST(ConnectionTests, testSetBreakpointConditional) {
   m::debugger::SetBreakpointByUrlRequest req0;
   req0.id = msgId++;
   req0.lineNumber = 4;
-  req0.condition = folly::Optional<std::string>("throw Error('Boom!')");
+  req0.condition = std::optional<std::string>("throw Error('Boom!')");
   conn.send(req0.toJson());
 
   expectBreakpointResponse(conn, req0.id, 4, 4);
@@ -1015,7 +1016,7 @@ TEST(ConnectionTests, testSetBreakpointConditional) {
   m::debugger::SetBreakpointByUrlRequest req1;
   req1.id = msgId++;
   req1.lineNumber = 5;
-  req1.condition = folly::Optional<std::string>("b === a");
+  req1.condition = std::optional<std::string>("b === a");
   conn.send(req1.toJson());
 
   expectBreakpointResponse(conn, req1.id, 5, 5);
@@ -1023,7 +1024,7 @@ TEST(ConnectionTests, testSetBreakpointConditional) {
   m::debugger::SetBreakpointByUrlRequest req2;
   req2.id = msgId++;
   req2.lineNumber = 6;
-  req2.condition = folly::Optional<std::string>("c === 5");
+  req2.condition = std::optional<std::string>("c === 5");
   conn.send(req2.toJson());
 
   expectBreakpointResponse(conn, req2.id, 6, 6);
@@ -1321,7 +1322,7 @@ TEST(ConnectionTests, testRuntimeEvaluateReturnByValue) {
   auto resp =
       expectResponse<m::debugger::EvaluateOnCallFrameResponse>(conn, msgId);
   EXPECT_EQ(resp.result.type, "object");
-  ASSERT_TRUE(resp.result.value.hasValue());
+  ASSERT_TRUE(resp.result.value.has_value());
   EXPECT_EQ(folly::toJson(resp.result.value.value()), object);
 
   // [3] exit run loop
@@ -1484,7 +1485,7 @@ TEST(ConnectionTests, testGetProperties) {
       conn, "other", {{"bar", 17, 3}, {"foo", 19, 2}, {"global", 23, 1}});
 
   auto &scopeObj = pausedNote.callFrames.at(1).scopeChain.at(0).object;
-  EXPECT_TRUE(scopeObj.objectId.hasValue());
+  EXPECT_TRUE(scopeObj.objectId.has_value());
   std::string scopeObjId = scopeObj.objectId.value();
   objIds.push_back(scopeObjId);
 
@@ -1963,7 +1964,7 @@ TEST(ConnectionTests, testScopeVariables) {
   req.objectId = globalScopeObject.objectId.value();
   conn.send(req.toJson());
   auto resp = expectResponse<m::runtime::GetPropertiesResponse>(conn, req.id);
-  std::unordered_map<std::string, folly::Optional<m::runtime::RemoteObject>>
+  std::unordered_map<std::string, std::optional<m::runtime::RemoteObject>>
       globalProperties;
   for (auto propertyDescriptor : resp.result) {
     globalProperties[propertyDescriptor.name] = propertyDescriptor.value;
@@ -1972,20 +1973,20 @@ TEST(ConnectionTests, testScopeVariables) {
 
   // globalString should be of type "string" and have value "global-string".
   EXPECT_EQ(globalProperties.count("globalString"), 1);
-  EXPECT_TRUE(globalProperties["globalString"].hasValue());
+  EXPECT_TRUE(globalProperties["globalString"].has_value());
   EXPECT_EQ(globalProperties["globalString"].value().type, "string");
   EXPECT_EQ(
       globalProperties["globalString"].value().value.value(), "global-string");
 
   // func should be of type "function".
   EXPECT_EQ(globalProperties.count("func"), 1);
-  EXPECT_TRUE(globalProperties["func"].hasValue());
+  EXPECT_TRUE(globalProperties["func"].has_value());
   EXPECT_EQ(globalProperties["func"].value().type, "function");
 
   // globalObject should be of type "object" with "number" and "bool"
   // properties.
   EXPECT_EQ(globalProperties.count("globalObject"), 1);
-  EXPECT_TRUE(globalProperties["globalObject"].hasValue());
+  EXPECT_TRUE(globalProperties["globalObject"].has_value());
   EXPECT_EQ(globalProperties["globalObject"].value().type, "object");
   expectProps(
       conn,
@@ -2076,7 +2077,7 @@ TEST(ConnectionTests, testRuntimeCallFunctionOnObject) {
   /// ensures that \p objId has all of the expected properties; Returns the
   /// runtime::RemoteObjectId for the "self_ref" property (which must exist).
   auto verifyObjShape = [&](const m::runtime::RemoteObjectId &objId)
-      -> folly::Optional<std::string> {
+      -> std::optional<std::string> {
     auto objProps = expectProps(conn, msgId++, objId, expectedPropInfos);
     EXPECT_TRUE(objProps.count("__proto__"));
     auto objPropIt = objProps.find("self_ref");
@@ -2133,7 +2134,7 @@ TEST(ConnectionTests, testRuntimeCallFunctionOnExecutionContext) {
     req.objectId = objId;
     conn.send(req.toJson());
     auto resp = expectResponse<m::runtime::GetPropertiesResponse>(conn, req.id);
-    std::unordered_map<std::string, folly::Optional<m::runtime::RemoteObject>>
+    std::unordered_map<std::string, std::optional<m::runtime::RemoteObject>>
         properties;
     for (auto propertyDescriptor : resp.result) {
       properties[propertyDescriptor.name] = propertyDescriptor.value;
@@ -2202,18 +2203,18 @@ TEST(ConnectionTests, testRuntimeCallFunctionOnExecutionContext) {
       // and it should have a value.
       ASSERT_TRUE(it->second) << test.propName;
 
-      if (it->second->value.hasValue()) {
+      if (it->second->value.has_value()) {
         // the property has a value, so make sure that's what's being expected.
         auto actual = it->second->value;
         auto expected = test.callArg.value;
-        ASSERT_TRUE(expected.hasValue()) << test.propName;
+        ASSERT_TRUE(expected.has_value()) << test.propName;
         EXPECT_EQ(*actual, *expected) << test.propName;
-      } else if (it->second->unserializableValue.hasValue()) {
+      } else if (it->second->unserializableValue.has_value()) {
         // the property has an unserializable value, so make sure that's what's
         // being expected.
         auto actual = it->second->unserializableValue;
         auto expected = test.callArg.unserializableValue;
-        ASSERT_TRUE(expected.hasValue()) << test.propName;
+        ASSERT_TRUE(expected.has_value()) << test.propName;
         EXPECT_EQ(*actual, *expected) << test.propName;
       } else {
         FAIL() << "No value or unserializable value in " << test.propName;
@@ -2353,7 +2354,7 @@ TEST(ConnectionTests, testThisObject) {
   req.objectId = globalThisObj.objectId.value();
   conn.send(req.toJson());
   auto resp = expectResponse<m::runtime::GetPropertiesResponse>(conn, req.id);
-  std::unordered_map<std::string, folly::Optional<m::runtime::RemoteObject>>
+  std::unordered_map<std::string, std::optional<m::runtime::RemoteObject>>
       properties;
   for (auto propertyDescriptor : resp.result) {
     properties[propertyDescriptor.name] = propertyDescriptor.value;
@@ -2361,7 +2362,7 @@ TEST(ConnectionTests, testThisObject) {
 
   // globalString should be of type "string" and have value "global-string".
   EXPECT_EQ(properties.count("globalString"), 1);
-  EXPECT_TRUE(properties["globalString"].hasValue());
+  EXPECT_TRUE(properties["globalString"].has_value());
   EXPECT_EQ(properties["globalString"].value().type, "string");
   EXPECT_EQ(properties["globalString"].value().value.value(), "global-string");
 
@@ -2613,7 +2614,7 @@ TEST(ConnectionTests, canBreakOnScriptsWithSourceMap) {
   auto note = expectNotification<m::debugger::PausedNotification>(conn);
   ASSERT_FALSE(asyncRuntime.hasStoredValue());
   EXPECT_EQ(note.reason, "other");
-  ASSERT_TRUE(note.hitBreakpoints.hasValue());
+  ASSERT_TRUE(note.hitBreakpoints.has_value());
   ASSERT_EQ(note.hitBreakpoints->size(), 1);
   EXPECT_EQ(note.hitBreakpoints->at(0), bpId);
 

package/ReactCommon/hermes/inspector/chrome/tests/MessageTests.cpp

@@ -56,10 +56,10 @@ TEST(MessageTests, testDeserializeSomeFieldsInRequest) {
   EXPECT_EQ(req.id, 10);
   EXPECT_EQ(req.method, "Debugger.setBreakpointByUrl");
   EXPECT_EQ(req.lineNumber, 42);
-  EXPECT_FALSE(req.columnNumber.hasValue());
-  EXPECT_FALSE(req.condition.hasValue());
+  EXPECT_FALSE(req.columnNumber.has_value());
+  EXPECT_FALSE(req.condition.has_value());
   EXPECT_EQ(req.url, "http://example.com");
-  EXPECT_FALSE(req.urlRegex.hasValue());
+  EXPECT_FALSE(req.urlRegex.has_value());
 }
 
 TEST(MessageTests, testSerializeAllFieldsInRequest) {
@@ -329,12 +329,12 @@ TEST(MessageTests, testDeserializeNotification) {
 
   debugger::Location &startLocation = scope.startLocation.value();
   EXPECT_EQ(startLocation.lineNumber, 1);
-  EXPECT_FALSE(startLocation.columnNumber.hasValue());
+  EXPECT_FALSE(startLocation.columnNumber.has_value());
   EXPECT_EQ(startLocation.scriptId, "script1");
 
   debugger::Location &endLocation = scope.endLocation.value();
   EXPECT_EQ(endLocation.lineNumber, 2);
-  EXPECT_FALSE(endLocation.columnNumber.hasValue());
+  EXPECT_FALSE(endLocation.columnNumber.has_value());
   EXPECT_EQ(endLocation.scriptId, "script2");
 }
 
@@ -550,11 +550,11 @@ TEST(MessageTests, testEvaluateOnCallFrameRequestMinimal) {
   EXPECT_EQ(resolvedReq->callFrameId, deserializedReq.callFrameId);
   EXPECT_EQ(resolvedReq->expression, deserializedReq.expression);
 
-  EXPECT_FALSE(resolvedReq->objectGroup.hasValue());
-  EXPECT_FALSE(resolvedReq->includeCommandLineAPI.hasValue());
-  EXPECT_FALSE(resolvedReq->silent.hasValue());
-  EXPECT_FALSE(resolvedReq->returnByValue.hasValue());
-  EXPECT_FALSE(resolvedReq->throwOnSideEffect.hasValue());
+  EXPECT_FALSE(resolvedReq->objectGroup.has_value());
+  EXPECT_FALSE(resolvedReq->includeCommandLineAPI.has_value());
+  EXPECT_FALSE(resolvedReq->silent.has_value());
+  EXPECT_FALSE(resolvedReq->returnByValue.has_value());
+  EXPECT_FALSE(resolvedReq->throwOnSideEffect.has_value());
 }
 
 TEST(MessageTests, testEvaluateOnCallFrameRequestFull) {
@@ -593,11 +593,11 @@ TEST(MessageTests, testEvaluateOnCallFrameRequestFull) {
   EXPECT_EQ(resolvedReq->callFrameId, "42");
   EXPECT_EQ(resolvedReq->expression, "Foo Bar");
 
-  EXPECT_TRUE(resolvedReq->objectGroup.hasValue());
-  EXPECT_TRUE(resolvedReq->includeCommandLineAPI.hasValue());
-  EXPECT_TRUE(resolvedReq->silent.hasValue());
-  EXPECT_TRUE(resolvedReq->returnByValue.hasValue());
-  EXPECT_TRUE(resolvedReq->throwOnSideEffect.hasValue());
+  EXPECT_TRUE(resolvedReq->objectGroup.has_value());
+  EXPECT_TRUE(resolvedReq->includeCommandLineAPI.has_value());
+  EXPECT_TRUE(resolvedReq->silent.has_value());
+  EXPECT_TRUE(resolvedReq->returnByValue.has_value());
+  EXPECT_TRUE(resolvedReq->throwOnSideEffect.has_value());
 
   EXPECT_TRUE(resolvedReq->objectGroup.value() == "FooBarGroup");
   EXPECT_TRUE(resolvedReq->includeCommandLineAPI.value() == false);
@@ -761,7 +761,7 @@ TEST(MessageTests, testSetBreakpointRequestMinimal) {
   EXPECT_EQ(resolvedReq->location.lineNumber, 2);
   EXPECT_EQ(resolvedReq->location.columnNumber, 3);
 
-  EXPECT_FALSE(resolvedReq->condition.hasValue());
+  EXPECT_FALSE(resolvedReq->condition.has_value());
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
   EXPECT_EQ(resolvedReq->method, deserializedReq.method);
@@ -810,7 +810,7 @@ TEST(MessageTests, testSetBreakpointRequestFull) {
   EXPECT_EQ(resolvedReq->location.lineNumber, 2);
   EXPECT_EQ(resolvedReq->location.columnNumber, 3);
 
-  EXPECT_TRUE(resolvedReq->condition.hasValue());
+  EXPECT_TRUE(resolvedReq->condition.has_value());
   EXPECT_EQ(resolvedReq->condition.value(), "FooBarCondition");
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
@@ -853,10 +853,10 @@ TEST(MessageTests, testSetBreakpointByUrlRequestMinimal) {
   EXPECT_EQ(resolvedReq->method, "Debugger.setBreakpointByUrl");
   EXPECT_EQ(resolvedReq->lineNumber, 2);
 
-  EXPECT_FALSE(resolvedReq->condition.hasValue());
-  EXPECT_FALSE(resolvedReq->columnNumber.hasValue());
-  EXPECT_FALSE(resolvedReq->url.hasValue());
-  EXPECT_FALSE(resolvedReq->urlRegex.hasValue());
+  EXPECT_FALSE(resolvedReq->condition.has_value());
+  EXPECT_FALSE(resolvedReq->columnNumber.has_value());
+  EXPECT_FALSE(resolvedReq->url.has_value());
+  EXPECT_FALSE(resolvedReq->urlRegex.has_value());
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
   EXPECT_EQ(resolvedReq->method, deserializedReq.method);
@@ -896,13 +896,13 @@ TEST(MessageTests, testSetBreakpointByUrlRequestFull) {
   EXPECT_EQ(resolvedReq->method, "Debugger.setBreakpointByUrl");
   EXPECT_EQ(resolvedReq->lineNumber, 2);
 
-  EXPECT_TRUE(resolvedReq->condition.hasValue());
+  EXPECT_TRUE(resolvedReq->condition.has_value());
   EXPECT_EQ(resolvedReq->condition.value(), "foo == 42");
-  EXPECT_TRUE(resolvedReq->columnNumber.hasValue());
+  EXPECT_TRUE(resolvedReq->columnNumber.has_value());
   EXPECT_EQ(resolvedReq->columnNumber.value(), 3);
-  EXPECT_TRUE(resolvedReq->url.hasValue());
+  EXPECT_TRUE(resolvedReq->url.has_value());
   EXPECT_EQ(resolvedReq->url.value(), "http://example.com/example.js");
-  EXPECT_TRUE(resolvedReq->urlRegex.hasValue());
+  EXPECT_TRUE(resolvedReq->urlRegex.has_value());
   EXPECT_EQ(resolvedReq->urlRegex.value(), "http://example.com/.*");
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
@@ -955,7 +955,7 @@ TEST(MessageTests, testSetInstrumentationBreakpointRequest) {
       "id": 1,
       "method": "Debugger.setInstrumentationBreakpoint",
       "params": {
-        "instrumentation": "TODO: THIS SHOUD NOT BE ACCEPTED BY ENUM"
+        "instrumentation": "TODO: THIS SHOULD NOT BE ACCEPTED BY ENUM"
       }
     }
   )";
@@ -977,7 +977,8 @@ TEST(MessageTests, testSetInstrumentationBreakpointRequest) {
   EXPECT_EQ(resolvedReq->id, 1);
   EXPECT_EQ(resolvedReq->method, "Debugger.setInstrumentationBreakpoint");
   EXPECT_EQ(
-      resolvedReq->instrumentation, "TODO: THIS SHOUD NOT BE ACCEPTED BY ENUM");
+      resolvedReq->instrumentation,
+      "TODO: THIS SHOULD NOT BE ACCEPTED BY ENUM");
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
   EXPECT_EQ(resolvedReq->method, deserializedReq.method);
@@ -990,7 +991,7 @@ TEST(MessageTests, testSetPauseOnExceptionsRequest) {
       "id": 1,
       "method": "Debugger.setPauseOnExceptions",
       "params": {
-        "state": "TODO: THIS SHOUD NOT BE ACCEPTED BY ENUM"
+        "state": "TODO: THIS SHOULD NOT BE ACCEPTED BY ENUM"
       }
     }
   )";
@@ -1011,7 +1012,7 @@ TEST(MessageTests, testSetPauseOnExceptionsRequest) {
   // Specifics
   EXPECT_EQ(resolvedReq->id, 1);
   EXPECT_EQ(resolvedReq->method, "Debugger.setPauseOnExceptions");
-  EXPECT_EQ(resolvedReq->state, "TODO: THIS SHOUD NOT BE ACCEPTED BY ENUM");
+  EXPECT_EQ(resolvedReq->state, "TODO: THIS SHOULD NOT BE ACCEPTED BY ENUM");
 
   EXPECT_EQ(resolvedReq->id, deserializedReq.id);
   EXPECT_EQ(resolvedReq->method, deserializedReq.method);
@@ -1123,11 +1124,11 @@ TEST(MessageTests, testEvaluateOnCallFrameResponseMinimal) {
   debugger::EvaluateOnCallFrameResponse deserializedReq(messageJSON);
   EXPECT_EQ(deserializedReq.toDynamic(), messageJSON);
 
-  EXPECT_FALSE(deserializedReq.result.subtype.hasValue());
-  EXPECT_FALSE(deserializedReq.result.value.hasValue());
-  EXPECT_FALSE(deserializedReq.result.unserializableValue.hasValue());
-  EXPECT_FALSE(deserializedReq.result.description.hasValue());
-  EXPECT_FALSE(deserializedReq.result.objectId.hasValue());
+  EXPECT_FALSE(deserializedReq.result.subtype.has_value());
+  EXPECT_FALSE(deserializedReq.result.value.has_value());
+  EXPECT_FALSE(deserializedReq.result.unserializableValue.has_value());
+  EXPECT_FALSE(deserializedReq.result.description.has_value());
+  EXPECT_FALSE(deserializedReq.result.objectId.has_value());
 
   // Specifics
   EXPECT_EQ(deserializedReq.id, 2);
@@ -1157,11 +1158,11 @@ TEST(MessageTests, testEvaluateOnCallFrameResponseFull) {
   debugger::EvaluateOnCallFrameResponse deserializedReq(messageJSON);
   EXPECT_EQ(deserializedReq.toDynamic(), messageJSON);
 
-  EXPECT_TRUE(deserializedReq.result.subtype.hasValue());
-  EXPECT_TRUE(deserializedReq.result.value.hasValue());
-  EXPECT_TRUE(deserializedReq.result.unserializableValue.hasValue());
-  EXPECT_TRUE(deserializedReq.result.description.hasValue());
-  EXPECT_TRUE(deserializedReq.result.objectId.hasValue());
+  EXPECT_TRUE(deserializedReq.result.subtype.has_value());
+  EXPECT_TRUE(deserializedReq.result.value.has_value());
+  EXPECT_TRUE(deserializedReq.result.unserializableValue.has_value());
+  EXPECT_TRUE(deserializedReq.result.description.has_value());
+  EXPECT_TRUE(deserializedReq.result.objectId.has_value());
 
   EXPECT_EQ(deserializedReq.result.subtype.value(), "SuperString");
   EXPECT_EQ(
@@ -1319,11 +1320,11 @@ TEST(MessageTests, testPauseNotificationMinimal) {
   debugger::PausedNotification deserializedReq(messageJSON);
   EXPECT_EQ(deserializedReq.toDynamic(), messageJSON);
 
-  EXPECT_FALSE(deserializedReq.callFrames[0].functionLocation.hasValue());
-  EXPECT_FALSE(deserializedReq.callFrames[0].returnValue.hasValue());
-  EXPECT_FALSE(deserializedReq.asyncStackTrace.hasValue());
-  EXPECT_FALSE(deserializedReq.hitBreakpoints.hasValue());
-  EXPECT_FALSE(deserializedReq.data.hasValue());
+  EXPECT_FALSE(deserializedReq.callFrames[0].functionLocation.has_value());
+  EXPECT_FALSE(deserializedReq.callFrames[0].returnValue.has_value());
+  EXPECT_FALSE(deserializedReq.asyncStackTrace.has_value());
+  EXPECT_FALSE(deserializedReq.hitBreakpoints.has_value());
+  EXPECT_FALSE(deserializedReq.data.has_value());
 
   // Specifics
   EXPECT_EQ(deserializedReq.method, "Debugger.paused");
@@ -1404,8 +1405,8 @@ TEST(MessageTests, testPauseNotificationFull) {
     }
   )";
 
-  folly::Optional<debugger::Location> functionLocation;
-  folly::Optional<runtime::RemoteObject> returnValue;
+  std::optional<debugger::Location> functionLocation;
+  std::optional<runtime::RemoteObject> returnValue;
   // Serialize and Deserialize are inverse functions
   dynamic messageJSON = folly::parseJson(message);
   debugger::PausedNotification deserializedReq(messageJSON);
@@ -1413,25 +1414,26 @@ TEST(MessageTests, testPauseNotificationFull) {
 
   // Check optionnals
   // ----------------
-  EXPECT_TRUE(deserializedReq.callFrames[0].functionLocation.hasValue());
-  EXPECT_TRUE(deserializedReq.callFrames[0].returnValue.hasValue());
-  EXPECT_TRUE(deserializedReq.asyncStackTrace.hasValue());
-  EXPECT_TRUE(deserializedReq.hitBreakpoints.hasValue());
-  EXPECT_TRUE(deserializedReq.data.hasValue());
+  EXPECT_TRUE(deserializedReq.callFrames[0].functionLocation.has_value());
+  EXPECT_TRUE(deserializedReq.callFrames[0].returnValue.has_value());
+  EXPECT_TRUE(deserializedReq.asyncStackTrace.has_value());
+  EXPECT_TRUE(deserializedReq.hitBreakpoints.has_value());
+  EXPECT_TRUE(deserializedReq.data.has_value());
 
   EXPECT_TRUE(
-      deserializedReq.callFrames[0].returnValue.value().subtype.hasValue());
+      deserializedReq.callFrames[0].returnValue.value().subtype.has_value());
   EXPECT_TRUE(
-      deserializedReq.callFrames[0].returnValue.value().className.hasValue());
+      deserializedReq.callFrames[0].returnValue.value().className.has_value());
   EXPECT_TRUE(deserializedReq.callFrames[0]
                   .returnValue.value()
-                  .unserializableValue.hasValue());
+                  .unserializableValue.has_value());
   EXPECT_TRUE(
-      deserializedReq.callFrames[0].returnValue.value().value.hasValue());
-  EXPECT_TRUE(
-      deserializedReq.callFrames[0].returnValue.value().description.hasValue());
+      deserializedReq.callFrames[0].returnValue.value().value.has_value());
+  EXPECT_TRUE(deserializedReq.callFrames[0]
+                  .returnValue.value()
+                  .description.has_value());
   EXPECT_TRUE(
-      deserializedReq.callFrames[0].returnValue.value().objectId.hasValue());
+      deserializedReq.callFrames[0].returnValue.value().objectId.has_value());
 
   // Check optionnals Values
   // -----------------------
@@ -1447,25 +1449,26 @@ TEST(MessageTests, testPauseNotificationFull) {
       deserializedReq.callFrames[0].returnValue.value().type,
       "aRemoteObjectType");
   EXPECT_EQ(
-      deserializedReq.callFrames[0].returnValue.value().subtype.hasValue(),
+      deserializedReq.callFrames[0].returnValue.value().subtype.has_value(),
       true);
   EXPECT_EQ(
       deserializedReq.callFrames[0].returnValue.value().subtype.value(),
       "subtype");
   EXPECT_EQ(
-      deserializedReq.callFrames[0].returnValue.value().className.hasValue(),
+      deserializedReq.callFrames[0].returnValue.value().className.has_value(),
       true);
   EXPECT_EQ(
       deserializedReq.callFrames[0].returnValue.value().className.value(),
       "className");
   EXPECT_EQ(
-      deserializedReq.callFrames[0].returnValue.value().value.hasValue(), true);
+      deserializedReq.callFrames[0].returnValue.value().value.has_value(),
+      true);
   EXPECT_EQ(
       deserializedReq.callFrames[0].returnValue.value().value.value(), "value");
   EXPECT_EQ(
       deserializedReq.callFrames[0]
           .returnValue.value()
-          .unserializableValue.hasValue(),
+          .unserializableValue.has_value(),
       true);
   EXPECT_EQ(
       deserializedReq.callFrames[0]
@@ -1473,13 +1476,13 @@ TEST(MessageTests, testPauseNotificationFull) {
           .unserializableValue.value(),
       "unserializableValue");
   EXPECT_EQ(
-      deserializedReq.callFrames[0].returnValue.value().description.hasValue(),
+      deserializedReq.callFrames[0].returnValue.value().description.has_value(),
       true);
   EXPECT_EQ(
       deserializedReq.callFrames[0].returnValue.value().description.value(),
       "description");
   EXPECT_EQ(
-      deserializedReq.callFrames[0].returnValue.value().objectId.hasValue(),
+      deserializedReq.callFrames[0].returnValue.value().objectId.has_value(),
       true);
   EXPECT_EQ(
       deserializedReq.callFrames[0].returnValue.value().objectId.value(),

package/ReactCommon/hermes/inspector/chrome/tests/SyncConnection.cpp

@@ -38,9 +38,9 @@ std::string prettify(const std::string &str) {
 
 } // namespace
 
-class SyncConnection::RemoteConnnection : public IRemoteConnection {
+class SyncConnection::RemoteConnection : public IRemoteConnection {
  public:
-  RemoteConnnection(SyncConnection &conn) : conn_(conn) {}
+  RemoteConnection(SyncConnection &conn) : conn_(conn) {}
 
   void onMessage(std::string message) override {
     conn_.onReply(message);
@@ -59,7 +59,7 @@ SyncConnection::SyncConnection(
           std::make_unique<SharedRuntimeAdapter>(runtime),
           "testConn",
           waitForDebugger) {
-  connection_.connect(std::make_unique<RemoteConnnection>(*this));
+  connection_.connect(std::make_unique<RemoteConnection>(*this));
 }
 
 void SyncConnection::send(const std::string &str) {

package/ReactCommon/hermes/inspector/chrome/tests/SyncConnection.h

@@ -13,9 +13,9 @@
 #include <queue>
 
 #include <folly/Function.h>
-#include <folly/Optional.h>
 #include <hermes/hermes.h>
 #include <hermes/inspector/chrome/Connection.h>
+#include <optional>
 
 namespace facebook {
 namespace hermes {
@@ -49,8 +49,8 @@ class SyncConnection {
       std::chrono::milliseconds timeout = std::chrono::milliseconds(2500));
 
  private:
-  class RemoteConnnection;
-  friend class RemoteConnnection;
+  class RemoteConnection;
+  friend class RemoteConnection;
 
   void onReply(const std::string &message);
 

package/ReactCommon/hermes/inspector/detail/SerialExecutor.h

@@ -36,7 +36,7 @@ namespace detail {
 class SerialExecutor : public folly::Executor {
  public:
   SerialExecutor(const std::string &name);
-  ~SerialExecutor();
+  ~SerialExecutor() override;
 
   void add(folly::Func) override;
 

package/ReactCommon/hermes/inspector/tools/format

@@ -5,6 +5,6 @@ cd "$DIR"
 
 FBSOURCE="$(hg root)"
 CLANG_FORMAT="$FBSOURCE/tools/third-party/clang-format/clang-format"
-SRC="$FBSOURCE/xplat/js/react-native-github/ReactCommon/hermes/inspector"
+SRC="$FBSOURCE/xplat/js/react-native-github/packages/react-native/ReactCommon/hermes/inspector"
 
 find "$SRC" '(' -name '*.h' -or -name '*.cpp' ')' -exec "$CLANG_FORMAT" -i -style=file '{}' ';'