Route JS errors from UI runtime throught RN's LogBox module

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -58,8 +58,11 @@ NativeReanimatedModule::NativeReanimatedModule(
           platformDepMethodsHolder.configurePropsFunction)
 #endif
 {
-  auto requestAnimationFrame = [=](FrameCallback callback) {
-    frameCallbacks.push_back(callback);
+  auto requestAnimationFrame = [=](jsi::Runtime &rt, const jsi::Value &fn) {
+    auto jsFunction = std::make_shared<jsi::Value>(rt, fn);
+    frameCallbacks.push_back([=](double timestamp) {
+      runtimeHelper->runOnUIGuarded(*jsFunction, jsi::Value(timestamp));
+    });
     maybeRequestRender();
   };
 
@@ -174,20 +177,23 @@ NativeReanimatedModule::NativeReanimatedModule(
 
 void NativeReanimatedModule::installCoreFunctions(
     jsi::Runtime &rt,
-    const jsi::Value &valueUnpacker,
-    const jsi::Value &layoutAnimationStartFunction) {
+    const jsi::Value &callGuard,
+    const jsi::Value &valueUnpacker) {
   if (!runtimeHelper) {
     // initialize runtimeHelper here if not already present. We expect only one
     // instace of the helper to exists.
     runtimeHelper =
         std::make_shared<JSRuntimeHelper>(&rt, this->runtime.get(), scheduler);
   }
+  runtimeHelper->callGuard =
+      std::make_unique<CoreFunction>(runtimeHelper.get(), callGuard);
   runtimeHelper->valueUnpacker =
-      std::make_shared<CoreFunction>(runtimeHelper.get(), valueUnpacker);
+      std::make_unique<CoreFunction>(runtimeHelper.get(), valueUnpacker);
 }
 
 NativeReanimatedModule::~NativeReanimatedModule() {
   if (runtimeHelper) {
+    runtimeHelper->callGuard = nullptr;
     runtimeHelper->valueUnpacker = nullptr;
     // event handler registry and frame callbacks store some JSI values from UI
     // runtime, so they have to go away before we tear down the runtime
@@ -206,11 +212,10 @@ void NativeReanimatedModule::scheduleOnUI(
   assert(
       shareableWorklet->valueType() == Shareable::WorkletType &&
       "only worklets can be scheduled to run on UI");
-  auto uiRuntime = runtimeHelper->uiRuntime();
   frameCallbacks.push_back([=](double timestamp) {
-    jsi::Runtime &rt = *uiRuntime;
+    jsi::Runtime &rt = *runtimeHelper->uiRuntime();
     auto workletValue = shareableWorklet->getJSValue(rt);
-    workletValue.asObject(rt).asFunction(rt).call(rt);
+    runtimeHelper->runOnUIGuarded(workletValue);
   });
   maybeRequestRender();
 }

Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -49,8 +49,8 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
 
   void installCoreFunctions(
       jsi::Runtime &rt,
-      const jsi::Value &workletMaker,
-      const jsi::Value &layoutAnimationStartFunction) override;
+      const jsi::Value &callGuard,
+      const jsi::Value &valueUnpacker) override;
 
   jsi::Value makeShareableClone(jsi::Runtime &rt, const jsi::Value &value)
       override;

Common/cpp/NativeModules/NativeReanimatedModuleSpec.h

@@ -24,8 +24,8 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
  public:
   virtual void installCoreFunctions(
       jsi::Runtime &rt,
-      const jsi::Value &valueUnpacker,
-      const jsi::Value &layoutAnimationStartFunction) = 0;
+      const jsi::Value &callGuard,
+      const jsi::Value &valueUnpacker) = 0;
 
   // SharedValue
   virtual jsi::Value makeShareableClone(

Common/cpp/ReanimatedRuntime/ReanimatedHermesRuntime.cpp

@@ -9,6 +9,7 @@
 #include <jsi/jsi.h>
 
 #include <memory>
+#include <string>
 #include <utility>
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
@@ -79,6 +80,35 @@ ReanimatedHermesRuntime::ReanimatedHermesRuntime(
   // that the thread was indeed `quit` before
   jsQueue->quitSynchronous();
 #endif
+
+#ifdef DEBUG
+  facebook::hermes::HermesRuntime *wrappedRuntime = runtime_.get();
+  jsi::Value evalWithSourceMap = jsi::Function::createFromHostFunction(
+      *runtime_,
+      jsi::PropNameID::forAscii(*runtime_, "evalWithSourceMap"),
+      3,
+      [wrappedRuntime](
+          jsi::Runtime &rt,
+          const jsi::Value &thisValue,
+          const jsi::Value *args,
+          size_t count) -> jsi::Value {
+        auto code = std::make_shared<const jsi::StringBuffer>(
+            args[0].asString(rt).utf8(rt));
+        std::string sourceURL;
+        if (count > 1 && args[1].isString()) {
+          sourceURL = args[1].asString(rt).utf8(rt);
+        }
+        std::shared_ptr<const jsi::Buffer> sourceMap;
+        if (count > 2 && args[2].isString()) {
+          sourceMap = std::make_shared<const jsi::StringBuffer>(
+              args[2].asString(rt).utf8(rt));
+        }
+        return wrappedRuntime->evaluateJavaScriptWithSourceMap(
+            code, sourceMap, sourceURL);
+      });
+  runtime_->global().setProperty(
+      *runtime_, "evalWithSourceMap", evalWithSourceMap);
+#endif // DEBUG
 }
 
 ReanimatedHermesRuntime::~ReanimatedHermesRuntime() {

Common/cpp/ReanimatedRuntime/ReanimatedHermesRuntime.h

@@ -116,7 +116,7 @@ class ReanimatedHermesRuntime
   ~ReanimatedHermesRuntime();
 
  private:
-  std::shared_ptr<facebook::hermes::HermesRuntime> runtime_;
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
   ReanimatedReentrancyCheck reentrancyCheck_;
 };
 

Common/cpp/SharedItems/Shareables.cpp

@@ -13,7 +13,9 @@ CoreFunction::CoreFunction(
   rnFunction_ = std::make_unique<jsi::Function>(workletObject.asFunction(rt));
   functionBody_ =
       workletObject.getProperty(rt, "asString").asString(rt).utf8(rt);
-  location_ = workletObject.getProperty(rt, "__location").asString(rt).utf8(rt);
+  location_ = "worklet_" +
+      std::to_string(static_cast<unsigned long long>(
+          workletObject.getProperty(rt, "__workletHash").getNumber()));
 }
 
 std::unique_ptr<jsi::Function> &CoreFunction::getFunction(jsi::Runtime &rt) {

Common/cpp/SharedItems/Shareables.h

@@ -20,7 +20,29 @@ using namespace facebook;
 
 namespace reanimated {
 
-class CoreFunction;
+class JSRuntimeHelper;
+
+// Core functions are not allowed to capture outside variables, otherwise they'd
+// try to access _closure variable which is something we want to avoid for
+// simplicity reasons.
+class CoreFunction {
+ private:
+  std::unique_ptr<jsi::Function> rnFunction_;
+  std::unique_ptr<jsi::Function> uiFunction_;
+  std::string functionBody_;
+  std::string location_;
+  JSRuntimeHelper
+      *runtimeHelper_; // runtime helper holds core function references, so we
+                       // use normal pointer here to avoid ref cycles.
+  std::unique_ptr<jsi::Function> &getFunction(jsi::Runtime &rt);
+
+ public:
+  CoreFunction(JSRuntimeHelper *runtimeHelper, const jsi::Value &workletObject);
+  template <typename... Args>
+  jsi::Value call(jsi::Runtime &rt, Args &&...args) {
+    return getFunction(rt)->call(rt, args...);
+  }
+};
 
 class JSRuntimeHelper {
  private:
@@ -36,7 +58,8 @@ class JSRuntimeHelper {
       : rnRuntime_(rnRuntime), uiRuntime_(uiRuntime), scheduler_(scheduler) {}
 
   volatile bool uiRuntimeDestroyed;
-  std::shared_ptr<CoreFunction> valueUnpacker;
+  std::unique_ptr<CoreFunction> callGuard;
+  std::unique_ptr<CoreFunction> valueUnpacker;
 
   inline jsi::Runtime *uiRuntime() const {
     return uiRuntime_;
@@ -61,27 +84,19 @@ class JSRuntimeHelper {
   void scheduleOnJS(std::function<void()> job) {
     scheduler_->scheduleOnJS(job);
   }
-};
-
-// Core functions are not allowed to capture outside variables, otherwise they'd
-// try to access _closure variable which is something we want to avoid for
-// simplicity reasons.
-class CoreFunction {
- private:
-  std::unique_ptr<jsi::Function> rnFunction_;
-  std::unique_ptr<jsi::Function> uiFunction_;
-  std::string functionBody_;
-  std::string location_;
-  JSRuntimeHelper
-      *runtimeHelper_; // runtime helper holds core function references, so we
-                       // use normal pointer here to avoid ref cycles.
-  std::unique_ptr<jsi::Function> &getFunction(jsi::Runtime &rt);
 
- public:
-  CoreFunction(JSRuntimeHelper *runtimeHelper, const jsi::Value &workletObject);
   template <typename... Args>
-  jsi::Value call(jsi::Runtime &rt, Args &&...args) {
-    return getFunction(rt)->call(rt, args...);
+  inline void runOnUIGuarded(const jsi::Value &function, Args &&...args) {
+    // We only use callGuard in debug mode, otherwise we call the provided
+    // function directly. CallGuard provides a way of capturing exceptions in
+    // JavaScript and propagating them to the main React Native thread such that
+    // they can be presented using RN's LogBox.
+    jsi::Runtime &rt = *uiRuntime_;
+#ifdef DEBUG
+    callGuard->call(rt, function, args...);
+#else
+    function.asObject(rt).asFunction(rt).call(rt, args...);
+#endif
   }
 };
 

Common/cpp/Tools/RuntimeDecorator.cpp

@@ -32,7 +32,30 @@ void RuntimeDecorator::decorateRuntime(
 
   rt.global().setProperty(rt, "global", rt.global());
 
-  rt.global().setProperty(rt, "jsThis", jsi::Value::undefined());
+#ifdef DEBUG
+  auto evalWithSourceUrl = [](jsi::Runtime &rt,
+                              const jsi::Value &thisValue,
+                              const jsi::Value *args,
+                              size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(
+        args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
+    }
+
+    return rt.evaluateJavaScript(code, url);
+  };
+
+  rt.global().setProperty(
+      rt,
+      "evalWithSourceUrl",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
+          1,
+          evalWithSourceUrl));
+#endif // DEBUG
 
   auto callback = [](jsi::Runtime &rt,
                      const jsi::Value &thisValue,
@@ -208,11 +231,7 @@ void RuntimeDecorator::decorateUIRuntime(
                   const jsi::Value &thisValue,
                   const jsi::Value *args,
                   const size_t count) -> jsi::Value {
-    auto fun =
-        std::make_shared<jsi::Function>(args[0].asObject(rt).asFunction(rt));
-    requestFrame([&rt, fun](double timestampMs) {
-      fun->call(rt, jsi::Value(timestampMs));
-    });
+    requestFrame(rt, std::move(args[0]));
     return jsi::Value::undefined();
   };
   jsi::Value requestAnimationFrame = jsi::Function::createFromHostFunction(

Common/cpp/Tools/RuntimeDecorator.h

@@ -11,7 +11,8 @@ using namespace facebook;
 
 namespace reanimated {
 
-using RequestFrameFunction = std::function<void(std::function<void(double)>)>;
+using RequestFrameFunction =
+    std::function<void(jsi::Runtime &, const jsi::Value &)>;
 using ScheduleOnJSFunction =
     std::function<void(jsi::Runtime &, const jsi::Value &, const jsi::Value &)>;
 using MakeShareableCloneFunction =