Merge facebook/hermes version RN 0.74.3

API/hermes/CMakeLists.txt

@@ -143,6 +143,14 @@ if(APPLE AND HERMES_BUILD_APPLE_FRAMEWORK)
     add_custom_command(TARGET libhermes POST_BUILD
       COMMAND /usr/libexec/PlistBuddy -c "Add :LSMinimumSystemVersion string ${CMAKE_OSX_DEPLOYMENT_TARGET}" $<TARGET_FILE_DIR:libhermes>/Resources/Info.plist
     )
+  elseif(HERMES_APPLE_TARGET_PLATFORM MATCHES "xr")
+    if(CMAKE_VERSION VERSION_LESS 3.28.4)
+      message("VisionOS Simulator requires CMake version >= 3.28.4")
+    endif()
+
+    add_custom_command(TARGET libhermes POST_BUILD
+      COMMAND /usr/libexec/PlistBuddy -c "Add :MinimumOSVersion string ${CMAKE_OSX_DEPLOYMENT_TARGET}" $<TARGET_FILE_DIR:libhermes>/Info.plist
+    )
   endif()
 endif()
 

API/hermes/SynthTrace.cpp

@@ -336,6 +336,14 @@ bool SynthTrace::CreateObjectRecord::operator==(const Record &that) const {
   return objID_ == thatCasted.objID_;
 }
 
+bool SynthTrace::QueueMicrotaskRecord::operator==(const Record &that) const {
+  if (!Record::operator==(that)) {
+    return false;
+  }
+  const auto &thatCasted = dynamic_cast<const QueueMicrotaskRecord &>(that);
+  return callbackID_ == thatCasted.callbackID_;
+}
+
 bool SynthTrace::DrainMicrotasksRecord::operator==(const Record &that) const {
   if (!Record::operator==(that)) {
     return false;
@@ -634,6 +642,11 @@ void SynthTrace::HasPropertyRecord::toJSONInternal(JSONEmitter &json) const {
 #endif
 }
 
+void SynthTrace::QueueMicrotaskRecord::toJSONInternal(JSONEmitter &json) const {
+  Record::toJSONInternal(json);
+  json.emitKeyValue("callbackID", callbackID_);
+}
+
 void SynthTrace::DrainMicrotasksRecord::toJSONInternal(
     JSONEmitter &json) const {
   Record::toJSONInternal(json);
@@ -831,6 +844,7 @@ llvh::raw_ostream &operator<<(
     CASE(CreatePropNameID);
     CASE(CreateHostObject);
     CASE(CreateHostFunction);
+    CASE(QueueMicrotask);
     CASE(DrainMicrotasks);
     CASE(GetProperty);
     CASE(SetProperty);
@@ -877,6 +891,7 @@ std::istream &operator>>(std::istream &is, SynthTrace::RecordType &type) {
   CASE(CreatePropNameID)
   CASE(CreateHostObject)
   CASE(CreateHostFunction)
+  CASE(QueueMicrotask)
   CASE(DrainMicrotasks)
   CASE(GetProperty)
   CASE(SetProperty)

API/hermes/SynthTrace.h

@@ -187,6 +187,7 @@ class SynthTrace {
     CreatePropNameID,
     CreateHostObject,
     CreateHostFunction,
+    QueueMicrotask,
     DrainMicrotasks,
     GetProperty,
     SetProperty,
@@ -723,6 +724,26 @@ class SynthTrace {
     void toJSONInternal(::hermes::JSONEmitter &json) const override;
   };
 
+  struct QueueMicrotaskRecord : public Record {
+    static constexpr RecordType type{RecordType::QueueMicrotask};
+    const ObjectID callbackID_;
+
+    QueueMicrotaskRecord(TimeSinceStart time, ObjectID callbackID)
+        : Record(time), callbackID_(callbackID) {}
+
+    bool operator==(const Record &that) const final;
+
+    RecordType getType() const override {
+      return type;
+    }
+
+    void toJSONInternal(::hermes::JSONEmitter &json) const override;
+
+    std::vector<ObjectID> uses() const override {
+      return {callbackID_};
+    }
+  };
+
   struct DrainMicrotasksRecord : public Record {
     static constexpr RecordType type{RecordType::DrainMicrotasks};
     int maxMicrotasksHint_;

API/hermes/SynthTraceParser.cpp

@@ -266,6 +266,13 @@ SynthTrace getTrace(JSONArray *array, SynthTrace::ObjectID globalObjID) {
         trace.emplace_back<SynthTrace::CreateObjectRecord>(
             timeFromStart, objID->getValue());
         break;
+      case RecordType::QueueMicrotask: {
+        auto callbackID =
+            getNumberAs<SynthTrace::ObjectID>(obj->get("callbackID"));
+        trace.emplace_back<SynthTrace::QueueMicrotaskRecord>(
+            timeFromStart, callbackID);
+        break;
+      }
       case RecordType::DrainMicrotasks: {
         int maxMicrotasksHint = getNumberAs<int>(obj->get("maxMicrotasksHint"));
         trace.emplace_back<SynthTrace::DrainMicrotasksRecord>(

API/hermes/TraceInterpreter.cpp

@@ -1188,6 +1188,18 @@ Value TraceInterpreter::execFunction(
                 locals);
             break;
           }
+          case RecordType::QueueMicrotask: {
+#if JSI_VERSION >= 12
+            const auto &queueRecord =
+                static_cast<const SynthTrace::QueueMicrotaskRecord &>(*rec);
+            jsi::Function callback =
+                getObjForUse(queueRecord.callbackID_).asFunction(rt_);
+            rt_.queueMicrotask(callback);
+#else
+            throw std::runtime_error("queueMicrotask is not supported");
+#endif
+            break;
+          }
           case RecordType::DrainMicrotasks: {
 #if JSI_VERSION >= 4
             const auto &drainRecord =

API/hermes/TracingRuntime.cpp

@@ -185,6 +185,14 @@ jsi::Value TracingRuntime::evaluateJavaScript(
   return res;
 }
 
+#if JSI_VERSION >= 12
+void TracingRuntime::queueMicrotask(const jsi::Function &callback) {
+  RD::queueMicrotask(callback);
+  trace_.emplace_back<SynthTrace::QueueMicrotaskRecord>(
+      getTimeSinceStart(), getUniqueID(callback));
+}
+#endif
+
 #if JSI_VERSION >= 4
 bool TracingRuntime::drainMicrotasks(int maxMicrotasksHint) {
   auto res = RD::drainMicrotasks(maxMicrotasksHint);

API/hermes/TracingRuntime.h

@@ -45,6 +45,9 @@ class TracingRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
       const std::shared_ptr<const jsi::Buffer> &buffer,
       const std::string &sourceURL) override;
 
+#if JSI_VERSION >= 12
+  void queueMicrotask(const jsi::Function &callback) override;
+#endif
 #if JSI_VERSION >= 4
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
 #endif

API/hermes/hermes.cpp

@@ -581,6 +581,9 @@ class HermesRuntimeImpl final : public HermesRuntime,
   jsi::Value evaluateJavaScript(
       const std::shared_ptr<const jsi::Buffer> &buffer,
       const std::string &sourceURL) override;
+#if JSI_VERSION >= 12
+  void queueMicrotask(const jsi::Function &callback) override;
+#endif
 #if JSI_VERSION >= 4
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
 #endif
@@ -1537,6 +1540,19 @@ jsi::Value HermesRuntimeImpl::evaluateJavaScript(
   return evaluateJavaScriptWithSourceMap(buffer, nullptr, sourceURL);
 }
 
+#if JSI_VERSION >= 12
+void HermesRuntimeImpl::queueMicrotask(const jsi::Function &callback) {
+  if (LLVM_UNLIKELY(!runtime_.hasMicrotaskQueue())) {
+    throw jsi::JSINativeException(
+        "Could not enqueue microtask because they are disabled in this runtime");
+  }
+
+  vm::Handle<vm::Callable> handle =
+      vm::Handle<vm::Callable>::vmcast(&phv(callback));
+  runtime_.enqueueJob(handle.get());
+}
+#endif
+
 #if JSI_VERSION >= 4
 bool HermesRuntimeImpl::drainMicrotasks(int maxMicrotasksHint) {
   if (runtime_.hasMicrotaskQueue()) {

API/hermes_abi/HermesABIRuntimeWrapper.cpp

@@ -710,6 +710,10 @@ class HermesABIRuntimeWrapper : public Runtime {
     return evaluateJavaScript(sjp, sjp->sourceURL());
   }
 
+  void queueMicrotask(const Function & /*callback*/) override {
+    THROW_UNIMPLEMENTED();
+  }
+
   bool drainMicrotasks(int maxMicrotasksHint = -1) override {
     return unwrap(vtable_->drain_microtasks(abiRt_, maxMicrotasksHint));
   }

API/hermes_sandbox/HermesSandboxRuntime.cpp

@@ -1701,6 +1701,10 @@ class HermesSandboxRuntimeImpl : public facebook::hermes::HermesSandboxRuntime,
     return evaluateJavaScript(sjp, sjp->sourceURL());
   }
 
+  void queueMicrotask(const Function & /*callback*/) override {
+    THROW_UNIMPLEMENTED();
+  }
+
   bool drainMicrotasks(int maxMicrotasksHint = -1) override {
     SandboxBoolOrError resBoolOrError{
         vt_.drain_microtasks(this, srt_, maxMicrotasksHint)};

API/jsi/jsi/decorator.h

@@ -567,6 +567,12 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::evaluatePreparedJavaScript(js);
   }
+#if JSI_VERSION >= 12
+  void queueMicrotask(const Function& callback) override {
+    Around around{with_};
+    RD::queueMicrotask(callback);
+  }
+#endif
 #if JSI_VERSION >= 4
   bool drainMicrotasks(int maxMicrotasksHint) override {
     Around around{with_};

API/jsi/jsi/jsi.h

@@ -28,7 +28,7 @@
 
 #ifndef JSI_VERSION
 // Use the latest version by default
-#define JSI_VERSION 11
+#define JSI_VERSION 12
 #endif
 
 #if JSI_VERSION >= 3

lib/Platform/Logging.cpp

@@ -11,6 +11,7 @@
 #include <android/log.h>
 #elif defined(__APPLE__)
 #include <os/log.h>
+#include <stdio.h>
 #elif defined(_MSC_VER)
 #include <windows.h>
 #include <TraceLoggingProvider.h>

merged-hermes-revision.txt

@@ -1,2 +1,2 @@
-bb1e74fe1e95c2b5a2f4f9311152da052badc2bc
-Tag: hermes-2024-06-03-RNv0.74.2-bb1e74fe1e95c2b5a2f4f9311152da052badc2bc
+7bda0c267e76d11b68a585f84cfdd65000babf85
+Tag: hermes-2024-06-28-RNv0.74.3-7bda0c267e76d11b68a585f84cfdd65000babf85

unittests/API/SynthTraceTest.cpp

@@ -38,6 +38,7 @@ struct SynthTraceTest : public ::testing::Test {
         ::hermes::vm::RuntimeConfig::Builder()
             .withSynthTraceMode(
                 ::hermes::vm::SynthTraceMode::TracingAndReplaying)
+            .withMicrotaskQueue(true)
             .build();
     // We pass "forReplay = true" below, to prevent the TracingHermesRuntime
     // from interactions it does automatically on non-replay runs.
@@ -1533,6 +1534,26 @@ HermesInternal.enqueueJob(inc);
 }
 #endif
 
+#if JSI_VERSION >= 12
+TEST_F(JobQueueReplayTest, QueueMicrotask) {
+  {
+    auto &rt = *traceRt;
+    auto microtask =
+        eval(rt, "var x = 3; function updateX() { x = 4; }; updateX")
+            .asObject(rt)
+            .asFunction(rt);
+    rt.queueMicrotask(microtask);
+    rt.drainMicrotasks();
+    EXPECT_EQ(eval(rt, "x").asNumber(), 4);
+  }
+  replay();
+  {
+    auto &rt = *replayRt;
+    EXPECT_EQ(eval(rt, "x").asNumber(), 4);
+  }
+}
+#endif
+
 using NonDeterminismReplayTest = SynthTraceReplayTest;
 
 TEST_F(NonDeterminismReplayTest, DateNowTest) {