react-native-tvos 0.73.7-1 → 0.74.0-0

package/ReactCommon/jsi/jsi/test/testlib.cpp

@@ -1444,14 +1444,106 @@ TEST_P(JSITest, ArrayBufferSizeTest) {
   auto ab =
       eval("var x = new ArrayBuffer(10); x").getObject(rt).getArrayBuffer(rt);
   EXPECT_EQ(ab.size(rt), 10);
-  // Ensure we can safely write some data to the buffer.
-  memset(ab.data(rt), 0xab, 10);
+
+  try {
+    // Ensure we can safely write some data to the buffer.
+    memset(ab.data(rt), 0xab, 10);
+  } catch (const JSINativeException& ex) {
+    // data() is unimplemented by some runtimes, ignore such failures.
+  }
 
   // Ensure that setting the byteLength property does not change the length.
   eval("Object.defineProperty(x, 'byteLength', {value: 20})");
   EXPECT_EQ(ab.size(rt), 10);
 }
 
+namespace {
+
+struct IntState : public NativeState {
+  explicit IntState(int value) : value(value) {}
+  int value;
+};
+
+} // namespace
+
+TEST_P(JSITest, NativeState) {
+  Object holder(rt);
+  EXPECT_FALSE(holder.hasNativeState(rt));
+
+  auto stateValue = std::make_shared<IntState>(42);
+  holder.setNativeState(rt, stateValue);
+  EXPECT_TRUE(holder.hasNativeState(rt));
+  EXPECT_EQ(
+      std::dynamic_pointer_cast<IntState>(holder.getNativeState(rt))->value,
+      42);
+
+  stateValue = std::make_shared<IntState>(21);
+  holder.setNativeState(rt, stateValue);
+  EXPECT_TRUE(holder.hasNativeState(rt));
+  EXPECT_EQ(
+      std::dynamic_pointer_cast<IntState>(holder.getNativeState(rt))->value,
+      21);
+
+  // There's currently way to "delete" the native state of a component fully
+  // Even when reset with nullptr, hasNativeState will still return true
+  holder.setNativeState(rt, nullptr);
+  EXPECT_TRUE(holder.hasNativeState(rt));
+  EXPECT_TRUE(holder.getNativeState(rt) == nullptr);
+}
+
+TEST_P(JSITest, NativeStateSymbolOverrides) {
+  Object holder(rt);
+
+  auto stateValue = std::make_shared<IntState>(42);
+  holder.setNativeState(rt, stateValue);
+
+  // Attempting to change configurable attribute of unconfigurable property
+  try {
+    function(
+        "function (obj) {"
+        "  var mySymbol = Symbol();"
+        "  obj[mySymbol] = 'foo';"
+        "  var allSymbols = Object.getOwnPropertySymbols(obj);"
+        "  for (var sym of allSymbols) {"
+        "    Object.defineProperty(obj, sym, {configurable: true, writable: true});"
+        "    obj[sym] = 'bar';"
+        "  }"
+        "}")
+        .call(rt, holder);
+  } catch (const JSError& ex) {
+    // On JSC this throws, but it doesn't on Hermes
+    std::string exc = ex.what();
+    EXPECT_NE(
+        exc.find(
+            "Attempting to change configurable attribute of unconfigurable property"),
+        std::string::npos);
+  }
+
+  EXPECT_TRUE(holder.hasNativeState(rt));
+  EXPECT_EQ(
+      std::dynamic_pointer_cast<IntState>(holder.getNativeState(rt))->value,
+      42);
+}
+
+TEST_P(JSITest, UTF8ExceptionTest) {
+  // Test that a native exception containing UTF-8 characters is correctly
+  // passed through.
+  Function throwUtf8 = Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "throwUtf8"),
+      1,
+      [](Runtime& rt, const Value&, const Value* args, size_t) -> Value {
+        throw JSINativeException(args[0].asString(rt).utf8(rt));
+      });
+  std::string utf8 = "👍";
+  try {
+    throwUtf8.call(rt, utf8);
+    FAIL();
+  } catch (const JSError& e) {
+    EXPECT_NE(e.getMessage().find(utf8), std::string::npos);
+  }
+}
+
 INSTANTIATE_TEST_CASE_P(
     Runtimes,
     JSITest,

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -16,8 +16,9 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2022.05.16.00'
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+folly_version = folly_config[:version]
 boost_compiler_flags = '-Wno-documentation'
 
 Pod::Spec.new do |s|
@@ -40,8 +41,9 @@ Pod::Spec.new do |s|
   s.dependency "React-perflogger", version
   s.dependency "RCT-Folly", folly_version
   s.dependency "DoubleConversion"
-  s.dependency 'fmt' , '~> 6.2.1'
+  s.dependency "fmt", "9.1.0"
   s.dependency "glog"
+  add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
 
   if ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == "1"
     s.dependency 'hermes-engine'

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -208,30 +208,6 @@ void JSIExecutor::registerBundle(
       ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
 }
 
-// Looping on \c drainMicrotasks until it completes or hits the retries bound.
-static void performMicrotaskCheckpoint(jsi::Runtime& runtime) {
-  uint8_t retries = 0;
-  // A heuristic number to guard infinite or absurd numbers of retries.
-  const static unsigned int kRetriesBound = 255;
-
-  while (retries < kRetriesBound) {
-    try {
-      // The default behavior of \c drainMicrotasks is unbounded execution.
-      // We may want to make it bounded in the future.
-      if (runtime.drainMicrotasks()) {
-        break;
-      }
-    } catch (jsi::JSError& error) {
-      handleJSError(runtime, error, true);
-    }
-    retries++;
-  }
-
-  if (retries == kRetriesBound) {
-    throw std::runtime_error("Hits microtasks retries bound.");
-  }
-}
-
 void JSIExecutor::callFunction(
     const std::string& moduleId,
     const std::string& methodId,
@@ -267,8 +243,6 @@ void JSIExecutor::callFunction(
         std::runtime_error("Error calling " + moduleId + "." + methodId));
   }
 
-  performMicrotaskCheckpoint(*runtime_);
-
   callNativeModules(ret, true);
 }
 
@@ -288,8 +262,6 @@ void JSIExecutor::invokeCallback(
         folly::to<std::string>("Error invoking callback ", callbackId)));
   }
 
-  performMicrotaskCheckpoint(*runtime_);
-
   callNativeModules(ret, true);
 }
 
@@ -426,7 +398,6 @@ void JSIExecutor::flush() {
   SystraceSection s("JSIExecutor::flush");
   if (flushedQueue_) {
     Value ret = flushedQueue_->call(*runtime_);
-    performMicrotaskCheckpoint(*runtime_);
     callNativeModules(ret, true);
     return;
   }
@@ -444,7 +415,6 @@ void JSIExecutor::flush() {
     // get the pending queue of native calls.
     bindBridge();
     Value ret = flushedQueue_->call(*runtime_);
-    performMicrotaskCheckpoint(*runtime_);
     callNativeModules(ret, true);
   } else if (delegate_) {
     // If we have a delegate, we need to call it; we pass a null list to

package/ReactCommon/jsinspector-modern/CMakeLists.txt

@@ -11,6 +11,16 @@ add_compile_options(
         -std=c++20)
 
 file(GLOB jsinspector_SRC CONFIGURE_DEPENDS *.cpp)
+# jsinspector contains singletons that hold app-global state (InspectorFlags, InspectorImpl).
+# Placing it in a shared library makes the singletons safe to use from arbitrary shared libraries
+# (even ones that don't depend on one another).
 add_library(jsinspector SHARED ${jsinspector_SRC})
 
 target_include_directories(jsinspector PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(jsinspector
+        folly_runtime
+        glog
+        react_featureflags
+        runtimeexecutor
+)

package/ReactCommon/jsinspector-modern/CONCEPTS.md

@@ -0,0 +1,27 @@
+# jsinspector-modern concepts
+
+## CDP object model
+
+### Target
+
+A debuggable entity that a debugger frontend can connect to.
+
+### Target Delegate
+
+An interface between a Target class and the underlying debuggable entity. For example, PageTargetDelegate is used by PageTarget to send page-related events to the native platform implementation.
+
+### Target Controller
+
+A private interface exposed by a Target class to its Sessions/Agents. For example, PageTargetController is used by PageAgent to safely access the page's PageTargetDelegate, without exposing PageTarget's other private state.
+
+### Session
+
+A single connection between a debugger frontend and a target. There can be multiple active sessions connected to the same target.
+
+### Agent
+
+A handler for a subset of CDP messages for a specific target as part of a specific session.
+
+### Agent Delegate
+
+An interface between an Agent class and some integration-specific, per-session logic/state it relies on (that does not fit in a Target Delegate). For example, a RuntimeAgentDelegate is used by RuntimeAgent to host Hermes's native CDP handler and delegate messages to it. The interface may look exactly like an Agent (purely CDP messages in/out) or there may be a more involved API to expose state/functionality needed by the Agent.

package/ReactCommon/jsinspector-modern/ExecutionContext.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "ExecutionContext.h"
+
+namespace facebook::react::jsinspector_modern {
+
+namespace {
+
+template <class>
+inline constexpr bool always_false_v = false;
+
+} // namespace
+
+bool ExecutionContextSelector::matches(
+    const ExecutionContextDescription& context) const noexcept {
+  // Exhaustiveness checking based on the example in
+  // https://en.cppreference.com/w/cpp/utility/variant/visit.
+  return std::visit(
+      [&context](auto&& arg) {
+        using T = std::decay_t<decltype(arg)>;
+        if constexpr (std::is_same_v<T, AllContexts>) {
+          return true;
+        } else if constexpr (std::is_same_v<T, ContextId>) {
+          return context.id == arg;
+        } else if constexpr (std::is_same_v<T, ContextName>) {
+          return context.name == arg;
+        } else {
+          static_assert(always_false_v<T>, "non-exhaustive visitor");
+        }
+      },
+      value_);
+
+  // Prevent the compiler from thinking always_false_v is unused when the
+  // visitor is (correctly) exhaustive.
+  (void)always_false_v<void>;
+}
+
+ExecutionContextSelector ExecutionContextSelector::byId(int32_t id) {
+  return ExecutionContextSelector{id};
+}
+
+ExecutionContextSelector ExecutionContextSelector::byName(std::string name) {
+  return ExecutionContextSelector{std::move(name)};
+}
+
+ExecutionContextSelector ExecutionContextSelector::all() {
+  return ExecutionContextSelector{AllContexts{}};
+}
+
+bool matchesAny(
+    const ExecutionContextDescription& context,
+    const ExecutionContextSelectorSet& selectors) {
+  for (const auto& selector : selectors) {
+    if (selector.matches(context)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/ExecutionContext.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include "UniqueMonostate.h"
+
+#include <cinttypes>
+#include <optional>
+#include <string>
+#include <unordered_set>
+#include <variant>
+
+namespace facebook::react::jsinspector_modern {
+
+struct ExecutionContextDescription {
+  int32_t id{};
+  std::string origin{""};
+  std::string name{"<anonymous>"};
+  std::optional<std::string> uniqueId;
+};
+
+/**
+ * A type-safe selector for execution contexts.
+ */
+class ExecutionContextSelector {
+ public:
+  /**
+   * Returns true iff this selector matches \c context.
+   */
+  bool matches(const ExecutionContextDescription& context) const noexcept;
+
+  /**
+   * Returns a new selector that matches only the given execution context ID.
+   */
+  static ExecutionContextSelector byId(int32_t id);
+
+  /**
+   * Returns a new selector that matches only the given execution context name.
+   */
+  static ExecutionContextSelector byName(std::string name);
+
+  /**
+   * Returns a new selector that matches any execution context.
+   */
+  static ExecutionContextSelector all();
+
+  ExecutionContextSelector() = delete;
+  ExecutionContextSelector(const ExecutionContextSelector& other) = default;
+  ExecutionContextSelector(ExecutionContextSelector&& other) noexcept = default;
+  ExecutionContextSelector& operator=(const ExecutionContextSelector& other) =
+      default;
+  ExecutionContextSelector& operator=(
+      ExecutionContextSelector&& other) noexcept = default;
+  ~ExecutionContextSelector() = default;
+
+  inline bool operator==(const ExecutionContextSelector& other) const noexcept {
+    return value_ == other.value_;
+  }
+
+ private:
+  /**
+   * Marker type used to represent "all execution contexts".
+   *
+   * Q: What is a UniqueMonostate?
+   * A: std::monostate, but it's distinct from other UniqueMonostate<...>s, so
+   *    you can use multiple of them in the same variant without ambiguity.
+   */
+  using AllContexts = UniqueMonostate<0>;
+  using ContextId = int32_t;
+  using ContextName = std::string;
+
+  using Representation = std::variant<AllContexts, ContextId, ContextName>;
+
+  explicit inline ExecutionContextSelector(Representation&& r) : value_(r) {}
+
+  Representation value_;
+
+  friend struct std::hash<
+      facebook::react::jsinspector_modern::ExecutionContextSelector>;
+};
+
+using ExecutionContextSelectorSet =
+    std::unordered_set<ExecutionContextSelector>;
+
+bool matchesAny(
+    const ExecutionContextDescription& context,
+    const ExecutionContextSelectorSet& selectors);
+
+} // namespace facebook::react::jsinspector_modern
+
+namespace std {
+
+template <>
+struct hash<::facebook::react::jsinspector_modern::ExecutionContextSelector> {
+  size_t operator()(
+      const ::facebook::react::jsinspector_modern::ExecutionContextSelector&
+          selector) const {
+    return hash<::facebook::react::jsinspector_modern::
+                    ExecutionContextSelector::Representation>{}(
+        selector.value_);
+  }
+};
+
+} // namespace std

package/ReactCommon/jsinspector-modern/ExecutionContextManager.cpp

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "ExecutionContextManager.h"
+
+#include <cassert>
+
+namespace facebook::react::jsinspector_modern {
+
+int32_t ExecutionContextManager::allocateExecutionContextId() {
+  assert(nextExecutionContextId_ != INT32_MAX);
+  return nextExecutionContextId_++;
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/ExecutionContextManager.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cinttypes>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Generates unique execution context IDs.
+ */
+class ExecutionContextManager {
+ public:
+  int32_t allocateExecutionContextId();
+
+ private:
+  int32_t nextExecutionContextId_{1};
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/FallbackRuntimeAgentDelegate.cpp

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "FallbackRuntimeAgentDelegate.h"
+
+#include <chrono>
+#include <string>
+
+using namespace std::chrono;
+using namespace std::literals::string_view_literals;
+using namespace std::literals::string_literals;
+
+namespace facebook::react::jsinspector_modern {
+
+#define ANSI_WEIGHT_BOLD "\x1B[1m"
+#define ANSI_WEIGHT_RESET "\x1B[22m"
+#define ANSI_STYLE_ITALIC "\x1B[3m"
+#define ANSI_STYLE_RESET "\x1B[23m"
+#define ANSI_COLOR_BG_YELLOW "\x1B[48;2;253;247;231m"
+
+FallbackRuntimeAgentDelegate::FallbackRuntimeAgentDelegate(
+    FrontendChannel frontendChannel,
+    const SessionState& sessionState,
+    std::string engineDescription)
+    : frontendChannel_(frontendChannel), engineDescription_(engineDescription) {
+  if (sessionState.isLogDomainEnabled) {
+    sendFallbackRuntimeWarning();
+  }
+}
+
+bool FallbackRuntimeAgentDelegate::handleRequest(
+    const cdp::PreparsedRequest& req) {
+  if (req.method == "Log.enable") {
+    sendFallbackRuntimeWarning();
+
+    // The parent Agent should send a response.
+    return false;
+  }
+
+  // The parent Agent should send a response or report an error.
+  return false;
+}
+
+void FallbackRuntimeAgentDelegate::sendFallbackRuntimeWarning() {
+  sendWarningLogEntry(
+      "The current JavaScript engine, " ANSI_STYLE_ITALIC + engineDescription_ +
+      ANSI_STYLE_RESET
+      ", does not support debugging over the Chrome DevTools Protocol. "
+      "See https://reactnative.dev/docs/debugging for more information.");
+}
+
+void FallbackRuntimeAgentDelegate::sendWarningLogEntry(std::string_view text) {
+  frontendChannel_(
+      folly::toJson(folly::dynamic::object("method", "Log.entryAdded")(
+          "params",
+          folly::dynamic::object(
+              "entry",
+              folly::dynamic::object(
+                  "timestamp",
+                  duration_cast<milliseconds>(
+                      system_clock::now().time_since_epoch())
+                      .count())("source", "other")(
+                  "level", "warning")("text", text)))));
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/FallbackRuntimeAgentDelegate.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include "SessionState.h"
+
+#include <jsinspector-modern/InspectorInterfaces.h>
+#include <jsinspector-modern/RuntimeAgent.h>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * A RuntimeAgentDelegate that handles requests from the Chrome DevTools
+ * Protocol for a JavaScript runtime that does not support debugging.
+ */
+class FallbackRuntimeAgentDelegate : public RuntimeAgentDelegate {
+ public:
+  /**
+   * \param frontendChannel A channel used to send responses and events to the
+   * frontend.
+   * \param sessionState The state of the current debugger session.
+   * \param engineDescription A description of the JavaScript engine being
+   * debugged. This string will be used in messages sent to the frontend.
+   */
+  FallbackRuntimeAgentDelegate(
+      FrontendChannel frontendChannel,
+      const SessionState& sessionState,
+      std::string engineDescription);
+
+  /**
+   * Handle a CDP request.  The response will be sent over the provided
+   * \c FrontendChannel synchronously or asynchronously.
+   * \param req The parsed request.
+   * \returns true if this agent has responded, or will respond asynchronously,
+   * to the request (with either a success or error message). False if the
+   * agent expects another agent to respond to the request instead.
+   */
+  bool handleRequest(const cdp::PreparsedRequest& req) override;
+
+ private:
+  /**
+   * Send a user-facing message explaining that this is not a debuggable
+   * runtime. You must ensure that the frontend has enabled Log notifications
+   * (using Log.enable) prior to calling this function.
+   */
+  void sendFallbackRuntimeWarning();
+
+  /**
+   * Send a simple Log.entryAdded notification with the given
+   * \param text. You must ensure that the frontend has enabled Log
+   * notifications (using Log.enable) prior to calling this function. In Chrome
+   * DevTools, the message will appear in the Console tab along with regular
+   * console messages.
+   */
+  void sendWarningLogEntry(std::string_view text);
+
+  FrontendChannel frontendChannel_;
+  std::string engineDescription_;
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "InspectorFlags.h"
+
+#include <glog/logging.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+
+namespace facebook::react::jsinspector_modern {
+
+InspectorFlags& InspectorFlags::getInstance() {
+  static InspectorFlags instance;
+  return instance;
+}
+
+InspectorFlags::InspectorFlags()
+    : enableModernCDPRegistry_(
+          ReactNativeFeatureFlags::inspectorEnableModernCDPRegistry()),
+      enableCxxInspectorPackagerConnection_(
+          ReactNativeFeatureFlags::
+              inspectorEnableCxxInspectorPackagerConnection()) {}
+
+bool InspectorFlags::getEnableModernCDPRegistry() const {
+  assertFlagsMatchUpstream();
+  return enableModernCDPRegistry_;
+}
+
+bool InspectorFlags::getEnableCxxInspectorPackagerConnection() const {
+  assertFlagsMatchUpstream();
+  return enableCxxInspectorPackagerConnection_ ||
+      // If we are using the modern CDP registry, then we must also use the C++
+      // InspectorPackagerConnection implementation.
+      enableModernCDPRegistry_;
+}
+
+void InspectorFlags::assertFlagsMatchUpstream() const {
+  if (inconsistentFlagsStateLogged_) {
+    return;
+  }
+
+  if (enableModernCDPRegistry_ !=
+          ReactNativeFeatureFlags::inspectorEnableModernCDPRegistry() ||
+      enableCxxInspectorPackagerConnection_ !=
+          ReactNativeFeatureFlags::
+              inspectorEnableCxxInspectorPackagerConnection()) {
+    LOG(ERROR)
+        << "[InspectorFlags] Error: One or more ReactNativeFeatureFlags values "
+        << "have changed during the global app lifetime. This may lead to "
+        << "inconsistent inspector behaviour. Please quit and restart the app.";
+    inconsistentFlagsStateLogged_ = true;
+  }
+}
+
+} // namespace facebook::react::jsinspector_modern