Implement queueMicrotask in Hermes

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

@@ -1165,6 +1165,14 @@ Value TraceInterpreter::execFunction(
                 locals);
             break;
           }
+          case RecordType::QueueMicrotask: {
+            const auto &queueRecord =
+                static_cast<const SynthTrace::QueueMicrotaskRecord &>(*rec);
+            jsi::Function callback =
+                getObjForUse(queueRecord.callbackID_).asFunction(rt_);
+            rt_.queueMicrotask(callback);
+            break;
+          }
           case RecordType::DrainMicrotasks: {
             const auto &drainRecord =
                 static_cast<const SynthTrace::DrainMicrotasksRecord &>(*rec);

API/hermes/TracingRuntime.cpp

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

API/hermes/TracingRuntime.h

@@ -43,6 +43,7 @@ class TracingRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
       const std::shared_ptr<const jsi::Buffer> &buffer,
       const std::string &sourceURL) override;
 
+  void queueMicrotask(const jsi::Function &callback) override;
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
 
   jsi::Object createObject() override;

API/hermes/hermes.cpp

@@ -573,6 +573,7 @@ class HermesRuntimeImpl final : public HermesRuntime,
   jsi::Value evaluateJavaScript(
       const std::shared_ptr<const jsi::Buffer> &buffer,
       const std::string &sourceURL) override;
+  void queueMicrotask(const jsi::Function &callback) override;
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
   jsi::Object global() override;
 
@@ -1502,6 +1503,17 @@ jsi::Value HermesRuntimeImpl::evaluateJavaScript(
   return evaluateJavaScriptWithSourceMap(buffer, nullptr, sourceURL);
 }
 
+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());
+}
+
 bool HermesRuntimeImpl::drainMicrotasks(int maxMicrotasksHint) {
   if (runtime_.hasMicrotaskQueue()) {
     checkStatus(runtime_.drainJobs());

API/jsi/jsi/decorator.h

@@ -126,6 +126,9 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
       const std::shared_ptr<const PreparedJavaScript>& js) override {
     return plain().evaluatePreparedJavaScript(js);
   }
+  void queueMicrotask(const jsi::Function& callback) override {
+    return plain().queueMicrotask(callback);
+  }
   bool drainMicrotasks(int maxMicrotasksHint) override {
     return plain().drainMicrotasks(maxMicrotasksHint);
   }
@@ -544,6 +547,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::evaluatePreparedJavaScript(js);
   }
+  void queueMicrotask(const Function& callback) override {
+    Around around{with_};
+    RD::queueMicrotask(callback);
+  }
   bool drainMicrotasks(int maxMicrotasksHint) override {
     Around around{with_};
     return RD::drainMicrotasks(maxMicrotasksHint);

API/jsi/jsi/jsi.cpp

@@ -87,6 +87,10 @@ NativeState::~NativeState() {}
 
 Runtime::~Runtime() {}
 
+void Runtime::queueMicrotask(const jsi::Function& /*callback*/) {
+  throw JSINativeException("queueMicrotask is not implemented in this runtime");
+}
+
 Instrumentation& Runtime::instrumentation() {
   class NoInstrumentation : public Instrumentation {
     std::string getRecordedGCStats() override {

API/jsi/jsi/jsi.h

@@ -209,6 +209,13 @@ class JSI_EXPORT Runtime {
   virtual Value evaluatePreparedJavaScript(
       const std::shared_ptr<const PreparedJavaScript>& js) = 0;
 
+  /// Queues a microtask in the JavaScript VM internal Microtask (a.k.a. Job in
+  /// ECMA262) queue, to be executed when the host drains microtasks in
+  /// its event loop implementation.
+  ///
+  /// \param callback a function to be executed as a microtask.
+  virtual void queueMicrotask(const jsi::Function& callback);
+
   /// Drain the JavaScript VM internal Microtask (a.k.a. Job in ECMA262) queue.
   ///
   /// \param maxMicrotasksHint a hint to tell an implementation that it should

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.
@@ -1519,6 +1520,24 @@ HermesInternal.enqueueJob(inc);
   }
 }
 
+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);
+  }
+}
+
 using NonDeterminismReplayTest = SynthTraceReplayTest;
 
 TEST_F(NonDeterminismReplayTest, DateNowTest) {