react-native 0.69.1 → 0.70.0-rc.0

package/ReactCommon/react/renderer/mounting/StubViewTree.cpp

@@ -200,6 +200,11 @@ void StubViewTree::mutate(ShadowViewMutationList const &mutations) {
         break;
       }
 
+      case ShadowViewMutation::RemoveDeleteTree: {
+        // TODO: do something here
+        break;
+      }
+
       case ShadowViewMutation::Update: {
         STUB_VIEW_LOG({
           LOG(ERROR) << "StubView: Update [" << mutation.newChildShadowView.tag

package/ReactCommon/react/renderer/mounting/tests/MountingTest.cpp

@@ -50,7 +50,7 @@ static ShadowNode::Shared makeNode(
 
   return componentDescriptor.createShadowNode(
       ShadowNodeFragment{
-          props, std::make_shared<SharedShadowNodeList>(children)},
+          props, std::make_shared<ShadowNode::ListOfShared>(children)},
       componentDescriptor.createFamily({tag, SurfaceId(1), nullptr}, nullptr));
 }
 
@@ -111,32 +111,32 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   auto shadowNodeV1 = viewComponentDescriptor.createShadowNode(
       ShadowNodeFragment{
           generateDefaultProps(viewComponentDescriptor),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{childB, childC, childD})},
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{childB, childC, childD})},
       family);
   auto shadowNodeV2 = shadowNodeV1->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childA, childB, childC, childD})});
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childA, childB, childC, childD})});
   auto shadowNodeV3 = shadowNodeV2->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childB, childC, childD})});
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childB, childC, childD})});
   auto shadowNodeV4 = shadowNodeV3->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childB, childD, childE})});
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childB, childD, childE})});
   auto shadowNodeV5 = shadowNodeV4->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childB, childA, childE, childC})});
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childB, childA, childE, childC})});
   auto shadowNodeV6 = shadowNodeV5->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(SharedShadowNodeList{
+      std::make_shared<ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
           childB, childA, childD, childF, childE, childC})});
   auto shadowNodeV7 = shadowNodeV6->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(SharedShadowNodeList{
+      std::make_shared<ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
           childF,
           childE,
           childC,
@@ -151,38 +151,38 @@ TEST(MountingTest, testReorderingInstructionGeneration) {
   auto rootNodeV1 = std::static_pointer_cast<RootShadowNode const>(
       emptyRootNode->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV1})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV1})}));
   auto rootNodeV2 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV1->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV2})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV2})}));
   auto rootNodeV3 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV2->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV3})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV3})}));
   auto rootNodeV4 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV3->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV4})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV4})}));
   auto rootNodeV5 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV4->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV5})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV5})}));
   auto rootNodeV6 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV5->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV6})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV6})}));
   auto rootNodeV7 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV6->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV7})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV7})}));
 
   // Layout
   std::vector<LayoutableShadowNode const *> affectedLayoutableNodesV1{};
@@ -419,159 +419,169 @@ TEST(MountingTest, testViewReparentingInstructionGeneration) {
   auto reparentedViewA = makeNode(
       viewComponentDescriptor,
       1000,
-      SharedShadowNodeList{
+      ShadowNode::ListOfShared{
           childC->clone({}), childA->clone({}), childB->clone({})});
   auto reparentedViewB = makeNode(
       viewComponentDescriptor,
       2000,
-      SharedShadowNodeList{
+      ShadowNode::ListOfShared{
           childF->clone({}), childE->clone({}), childD->clone({})});
 
   // Root -> G* -> H -> I -> J -> A* [nodes with * are _not_ flattened]
   auto shadowNodeV1 = viewComponentDescriptor.createShadowNode(
       ShadowNodeFragment{
           generateDefaultProps(viewComponentDescriptor),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{childG->clone(ShadowNodeFragment{
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{childG->clone(ShadowNodeFragment{
                   nonFlattenedDefaultProps(viewComponentDescriptor),
-                  std::make_shared<SharedShadowNodeList>(
-                      SharedShadowNodeList{childH->clone(ShadowNodeFragment{
+                  std::make_shared<ShadowNode::ListOfShared>(
+                      ShadowNode::ListOfShared{childH->clone(ShadowNodeFragment{
                           generateDefaultProps(viewComponentDescriptor),
-                          std::make_shared<
-                              SharedShadowNodeList>(SharedShadowNodeList{
-                              childI->clone(ShadowNodeFragment{
-                                  generateDefaultProps(viewComponentDescriptor),
-                                  std::make_shared<SharedShadowNodeList>(
-                                      SharedShadowNodeList{
-                                          childJ->clone(ShadowNodeFragment{
-                                              generateDefaultProps(
-                                                  viewComponentDescriptor),
-                                              std::make_shared<
-                                                  SharedShadowNodeList>(
-                                                  SharedShadowNodeList{
-                                                      reparentedViewA->clone(
-                                                          {})})})})})})})})})})},
+                          std::make_shared<ShadowNode::ListOfShared>(
+                              ShadowNode::ListOfShared{
+                                  childI->clone(ShadowNodeFragment{
+                                      generateDefaultProps(
+                                          viewComponentDescriptor),
+                                      std::make_shared<
+                                          ShadowNode::ListOfShared>(
+                                          ShadowNode::ListOfShared{
+                                              childJ->clone(ShadowNodeFragment{
+                                                  generateDefaultProps(
+                                                      viewComponentDescriptor),
+                                                  std::make_shared<
+                                                      ShadowNode::ListOfShared>(
+                                                      ShadowNode::ListOfShared{
+                                                          reparentedViewA->clone(
+                                                              {})})})})})})})})})})},
       family);
 
   // Root -> G* -> H* -> I -> J -> A* [nodes with * are _not_ flattened]
   auto shadowNodeV2 = shadowNodeV1->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childG->clone(ShadowNodeFragment{
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childG->clone(ShadowNodeFragment{
               nonFlattenedDefaultProps(viewComponentDescriptor),
-              std::make_shared<SharedShadowNodeList>(
-                  SharedShadowNodeList{childH->clone(ShadowNodeFragment{
+              std::make_shared<ShadowNode::ListOfShared>(
+                  ShadowNode::ListOfShared{childH->clone(ShadowNodeFragment{
                       nonFlattenedDefaultProps(viewComponentDescriptor),
-                      std::make_shared<SharedShadowNodeList>(
-                          SharedShadowNodeList{childI->clone(ShadowNodeFragment{
+                      std::make_shared<
+                          ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
+                          childI->clone(ShadowNodeFragment{
                               generateDefaultProps(viewComponentDescriptor),
-                              std::make_shared<
-                                  SharedShadowNodeList>(SharedShadowNodeList{
-                                  childJ->clone(ShadowNodeFragment{
-                                      generateDefaultProps(
-                                          viewComponentDescriptor),
-                                      std::make_shared<SharedShadowNodeList>(
-                                          SharedShadowNodeList{
-                                              reparentedViewA->clone(
-                                                  {})})})})})})})})})})});
+                              std::make_shared<ShadowNode::ListOfShared>(
+                                  ShadowNode::ListOfShared{
+                                      childJ->clone(ShadowNodeFragment{
+                                          generateDefaultProps(
+                                              viewComponentDescriptor),
+                                          std::make_shared<
+                                              ShadowNode::ListOfShared>(
+                                              ShadowNode::ListOfShared{
+                                                  reparentedViewA->clone(
+                                                      {})})})})})})})})})})});
 
   // Root -> G* -> H -> I -> J -> A* [nodes with * are _not_ flattened]
   auto shadowNodeV3 = shadowNodeV2->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childG->clone(ShadowNodeFragment{
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childG->clone(ShadowNodeFragment{
               nonFlattenedDefaultProps(viewComponentDescriptor),
-              std::make_shared<SharedShadowNodeList>(
-                  SharedShadowNodeList{childH->clone(ShadowNodeFragment{
+              std::make_shared<ShadowNode::ListOfShared>(
+                  ShadowNode::ListOfShared{childH->clone(ShadowNodeFragment{
                       generateDefaultProps(viewComponentDescriptor),
-                      std::make_shared<SharedShadowNodeList>(
-                          SharedShadowNodeList{childI->clone(ShadowNodeFragment{
+                      std::make_shared<
+                          ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
+                          childI->clone(ShadowNodeFragment{
                               generateDefaultProps(viewComponentDescriptor),
-                              std::make_shared<
-                                  SharedShadowNodeList>(SharedShadowNodeList{
-                                  childJ->clone(ShadowNodeFragment{
-                                      generateDefaultProps(
-                                          viewComponentDescriptor),
-                                      std::make_shared<SharedShadowNodeList>(
-                                          SharedShadowNodeList{
-                                              reparentedViewA->clone(
-                                                  {})})})})})})})})})})});
+                              std::make_shared<ShadowNode::ListOfShared>(
+                                  ShadowNode::ListOfShared{
+                                      childJ->clone(ShadowNodeFragment{
+                                          generateDefaultProps(
+                                              viewComponentDescriptor),
+                                          std::make_shared<
+                                              ShadowNode::ListOfShared>(
+                                              ShadowNode::ListOfShared{
+                                                  reparentedViewA->clone(
+                                                      {})})})})})})})})})})});
 
   // The view is reparented 1 level down with a different sibling
   // Root -> G* -> H* -> I* -> J -> [B*, A*] [nodes with * are _not_ flattened]
   auto shadowNodeV4 = shadowNodeV3->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childG->clone(ShadowNodeFragment{
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childG->clone(ShadowNodeFragment{
               nonFlattenedDefaultProps(viewComponentDescriptor),
-              std::make_shared<SharedShadowNodeList>(
-                  SharedShadowNodeList{childH->clone(ShadowNodeFragment{
+              std::make_shared<ShadowNode::ListOfShared>(
+                  ShadowNode::ListOfShared{childH->clone(ShadowNodeFragment{
                       nonFlattenedDefaultProps(viewComponentDescriptor),
-                      std::make_shared<SharedShadowNodeList>(
-                          SharedShadowNodeList{childI->clone(ShadowNodeFragment{
+                      std::make_shared<
+                          ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
+                          childI->clone(ShadowNodeFragment{
                               nonFlattenedDefaultProps(viewComponentDescriptor),
-                              std::make_shared<
-                                  SharedShadowNodeList>(SharedShadowNodeList{
-                                  childJ->clone(ShadowNodeFragment{
-                                      generateDefaultProps(
-                                          viewComponentDescriptor),
-                                      std::make_shared<SharedShadowNodeList>(
-                                          SharedShadowNodeList{
-                                              reparentedViewB->clone({}),
-                                              reparentedViewA->clone(
-                                                  {})})})})})})})})})})});
+                              std::make_shared<ShadowNode::ListOfShared>(
+                                  ShadowNode::ListOfShared{
+                                      childJ->clone(ShadowNodeFragment{
+                                          generateDefaultProps(
+                                              viewComponentDescriptor),
+                                          std::make_shared<
+                                              ShadowNode::ListOfShared>(
+                                              ShadowNode::ListOfShared{
+                                                  reparentedViewB->clone({}),
+                                                  reparentedViewA->clone(
+                                                      {})})})})})})})})})})});
 
   // The view is reparented 1 level further down with its order with the sibling
   // swapped
   // Root -> G* -> H* -> I* -> J* -> [A*, B*] [nodes with * are _not_ flattened]
   auto shadowNodeV5 = shadowNodeV4->clone(ShadowNodeFragment{
       generateDefaultProps(viewComponentDescriptor),
-      std::make_shared<SharedShadowNodeList>(
-          SharedShadowNodeList{childG->clone(ShadowNodeFragment{
+      std::make_shared<ShadowNode::ListOfShared>(
+          ShadowNode::ListOfShared{childG->clone(ShadowNodeFragment{
               nonFlattenedDefaultProps(viewComponentDescriptor),
-              std::make_shared<SharedShadowNodeList>(
-                  SharedShadowNodeList{childH->clone(ShadowNodeFragment{
+              std::make_shared<ShadowNode::ListOfShared>(
+                  ShadowNode::ListOfShared{childH->clone(ShadowNodeFragment{
                       nonFlattenedDefaultProps(viewComponentDescriptor),
-                      std::make_shared<SharedShadowNodeList>(
-                          SharedShadowNodeList{childI->clone(ShadowNodeFragment{
+                      std::make_shared<
+                          ShadowNode::ListOfShared>(ShadowNode::ListOfShared{
+                          childI->clone(ShadowNodeFragment{
                               nonFlattenedDefaultProps(viewComponentDescriptor),
-                              std::make_shared<
-                                  SharedShadowNodeList>(SharedShadowNodeList{
-                                  childJ->clone(ShadowNodeFragment{
-                                      nonFlattenedDefaultProps(
-                                          viewComponentDescriptor),
-                                      std::make_shared<SharedShadowNodeList>(
-                                          SharedShadowNodeList{
-                                              reparentedViewA->clone({}),
-                                              reparentedViewB->clone(
-                                                  {})})})})})})})})})})});
+                              std::make_shared<ShadowNode::ListOfShared>(
+                                  ShadowNode::ListOfShared{
+                                      childJ->clone(ShadowNodeFragment{
+                                          nonFlattenedDefaultProps(
+                                              viewComponentDescriptor),
+                                          std::make_shared<
+                                              ShadowNode::ListOfShared>(
+                                              ShadowNode::ListOfShared{
+                                                  reparentedViewA->clone({}),
+                                                  reparentedViewB->clone(
+                                                      {})})})})})})})})})})});
 
   // Injecting a tree into the root node.
   auto rootNodeV1 = std::static_pointer_cast<RootShadowNode const>(
       emptyRootNode->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV1})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV1})}));
   auto rootNodeV2 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV1->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV2})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV2})}));
   auto rootNodeV3 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV2->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV3})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV3})}));
   auto rootNodeV4 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV3->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV4})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV4})}));
   auto rootNodeV5 = std::static_pointer_cast<RootShadowNode const>(
       rootNodeV4->ShadowNode::clone(ShadowNodeFragment{
           ShadowNodeFragment::propsPlaceholder(),
-          std::make_shared<SharedShadowNodeList>(
-              SharedShadowNodeList{shadowNodeV5})}));
+          std::make_shared<ShadowNode::ListOfShared>(
+              ShadowNode::ListOfShared{shadowNodeV5})}));
 
   // Layout
   std::vector<LayoutableShadowNode const *> affectedLayoutableNodesV1{};

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -77,8 +77,8 @@ static void testShadowNodeTreeLifeCycle(
     auto currentRootNode = std::static_pointer_cast<RootShadowNode const>(
         emptyRootNode->ShadowNode::clone(ShadowNodeFragment{
             ShadowNodeFragment::propsPlaceholder(),
-            std::make_shared<SharedShadowNodeList>(
-                SharedShadowNodeList{singleRootChildNode})}));
+            std::make_shared<ShadowNode::ListOfShared>(
+                ShadowNode::ListOfShared{singleRootChildNode})}));
 
     // Building an initial view hierarchy.
     auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*emptyRootNode);
@@ -227,8 +227,8 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
     auto currentRootNode = std::static_pointer_cast<RootShadowNode const>(
         emptyRootNode->ShadowNode::clone(ShadowNodeFragment{
             ShadowNodeFragment::propsPlaceholder(),
-            std::make_shared<SharedShadowNodeList>(
-                SharedShadowNodeList{singleRootChildNode})}));
+            std::make_shared<ShadowNode::ListOfShared>(
+                ShadowNode::ListOfShared{singleRootChildNode})}));
 
     // Building an initial view hierarchy.
     auto viewTree = buildStubViewTreeWithoutUsingDifferentiator(*emptyRootNode);

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -22,19 +22,13 @@ RuntimeScheduler::RuntimeScheduler(
 
 void RuntimeScheduler::scheduleWork(
     std::function<void(jsi::Runtime &)> callback) const {
-  if (enableYielding_) {
-    runtimeAccessRequests_ += 1;
-    runtimeExecutor_(
-        [this, callback = std::move(callback)](jsi::Runtime &runtime) {
-          runtimeAccessRequests_ -= 1;
-          callback(runtime);
-          startWorkLoop(runtime);
-        });
-  } else {
-    runtimeExecutor_([callback = std::move(callback)](jsi::Runtime &runtime) {
-      callback(runtime);
-    });
-  }
+  runtimeAccessRequests_ += 1;
+  runtimeExecutor_(
+      [this, callback = std::move(callback)](jsi::Runtime &runtime) {
+        runtimeAccessRequests_ -= 1;
+        callback(runtime);
+        startWorkLoop(runtime);
+      });
 }
 
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
@@ -70,10 +64,6 @@ RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
   return now_();
 }
 
-void RuntimeScheduler::setEnableYielding(bool enableYielding) {
-  enableYielding_ = enableYielding;
-}
-
 void RuntimeScheduler::executeNowOnTheSameThread(
     std::function<void(jsi::Runtime &runtime)> callback) {
   runtimeAccessRequests_ += 1;

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -105,7 +105,6 @@ class RuntimeScheduler final {
    * Thread synchronization must be enforced externally.
    */
   void callExpiredTasks(jsi::Runtime &runtime);
-  void setEnableYielding(bool enableYielding);
 
  private:
   mutable std::priority_queue<
@@ -144,15 +143,6 @@ class RuntimeScheduler final {
    */
   mutable std::atomic_bool isWorkLoopScheduled_{false};
 
-  /*
-   * Flag indicating if yielding is enabled.
-   *
-   * If set to true and Concurrent Mode is enabled on the surface,
-   * React Native will ask React to yield in case any work has been scheduled.
-   * Default value is false
-   */
-  bool enableYielding_{false};
-
   /*
    * This flag is set while performing work, to prevent re-entrancy.
    */

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp

@@ -152,9 +152,21 @@ jsi::Value RuntimeSchedulerBinding::get(
         });
   }
 
+  // TODO: remmove this, as it's deprecated in the JS scheduler
   if (propertyName == "unstable_getCurrentPriorityLevel") {
-    auto currentPriorityLevel = runtimeScheduler_->getCurrentPriorityLevel();
-    return jsi::Value(runtime, serialize(currentPriorityLevel));
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *,
+            size_t) noexcept -> jsi::Value {
+          auto currentPriorityLevel =
+              runtimeScheduler_->getCurrentPriorityLevel();
+          return jsi::Value(runtime, serialize(currentPriorityLevel));
+        });
   }
 
   if (propertyName == "unstable_ImmediatePriority") {
@@ -182,8 +194,11 @@ jsi::Value RuntimeSchedulerBinding::get(
     return jsi::Value::undefined();
   }
 
-  react_native_assert(false && "undefined property");
+#ifdef REACT_NATIVE_DEBUG
+  throw std::runtime_error("undefined property");
+#else
   return jsi::Value::undefined();
+#endif
 }
 
 } // namespace react

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -43,7 +43,6 @@ class RuntimeSchedulerTest : public testing::Test {
 
     runtimeScheduler_ =
         std::make_unique<RuntimeScheduler>(runtimeExecutor, stubNow);
-    runtimeScheduler_->setEnableYielding(true);
   }
 
   jsi::Function createHostFunctionFromLambda(
@@ -317,24 +316,6 @@ TEST_F(RuntimeSchedulerTest, getCurrentPriorityLevel) {
       SchedulerPriority::NormalPriority);
 }
 
-TEST_F(RuntimeSchedulerTest, scheduleWork) {
-  runtimeScheduler_->setEnableYielding(false);
-  bool wasCalled = false;
-  runtimeScheduler_->scheduleWork(
-      [&](jsi::Runtime const &) { wasCalled = true; });
-
-  EXPECT_FALSE(wasCalled);
-
-  EXPECT_FALSE(runtimeScheduler_->getShouldYield());
-
-  EXPECT_EQ(stubQueue_->size(), 1);
-
-  stubQueue_->tick();
-
-  EXPECT_TRUE(wasCalled);
-  EXPECT_EQ(stubQueue_->size(), 0);
-}
-
 TEST_F(RuntimeSchedulerTest, scheduleWorkWithYielding) {
   bool wasCalled = false;
   runtimeScheduler_->scheduleWork(
@@ -472,7 +453,7 @@ TEST_F(RuntimeSchedulerTest, handlingError) {
   bool didRunTask = false;
   auto firstCallback = createHostFunctionFromLambda([this, &didRunTask](bool) {
     didRunTask = true;
-    jsi::detail::throwJSError(*runtime_, "Test error");
+    throw jsi::JSError(*runtime_, "Test error");
     return jsi::Value::undefined();
   });
 

package/ReactCommon/react/renderer/scheduler/BUCK

@@ -47,7 +47,7 @@ rn_xplat_cxx_library(
     deps = [
         "//third-party/glog:glog",
         "//xplat/fbsystrace:fbsystrace",
-        "//xplat/folly:headers_only",
+        "//xplat/folly:headers_only_do_not_use",
         "//xplat/folly:memory",
         "//xplat/folly:molly",
         "//xplat/jsi:JSIDynamic",

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -264,8 +264,8 @@ void Scheduler::renderTemplateToSurface(
                     ShadowNodeFragment{
                         /* .props = */ ShadowNodeFragment::propsPlaceholder(),
                         /* .children = */
-                        std::make_shared<SharedShadowNodeList>(
-                            SharedShadowNodeList{tree}),
+                        std::make_shared<ShadowNode::ListOfShared>(
+                            ShadowNode::ListOfShared{tree}),
                     });
               });
         });

package/ReactCommon/react/renderer/telemetry/BUCK

@@ -50,7 +50,7 @@ rn_xplat_cxx_library(
     deps = [
         "//third-party/glog:glog",
         "//xplat/fbsystrace:fbsystrace",
-        "//xplat/folly:headers_only",
+        "//xplat/folly:headers_only_do_not_use",
         "//xplat/folly:memory",
         "//xplat/folly:molly",
         react_native_xplat_target("butter:butter"),

package/ReactCommon/react/renderer/templateprocessor/BUCK

@@ -49,7 +49,7 @@ rn_xplat_cxx_library(
     deps = [
         "//third-party/glog:glog",
         "//xplat/fbsystrace:fbsystrace",
-        "//xplat/folly:headers_only",
+        "//xplat/folly:headers_only_do_not_use",
         "//xplat/folly:memory",
         "//xplat/folly:molly",
         "//xplat/jsi:JSIDynamic",

package/ReactCommon/react/renderer/templateprocessor/UITemplateProcessor.cpp

@@ -25,17 +25,17 @@ bool constexpr DEBUG_FLY = false;
 
 struct RBCContext {
   const Tag rootTag;
-  const std::vector<SharedShadowNode> &nodes;
+  const std::vector<ShadowNode::Shared> &nodes;
   const std::vector<folly::dynamic> &registers;
   const ComponentDescriptorRegistry &componentDescriptorRegistry;
   const NativeModuleRegistry &nativeModuleRegistry;
 };
 
 // TODO: use RBCContext instead of all the separate arguments.
-SharedShadowNode UITemplateProcessor::runCommand(
+ShadowNode::Shared UITemplateProcessor::runCommand(
     const folly::dynamic &command,
     SurfaceId surfaceId,
-    std::vector<SharedShadowNode> &nodes,
+    std::vector<ShadowNode::Shared> &nodes,
     std::vector<folly::dynamic> &registers,
     const ComponentDescriptorRegistry &componentDescriptorRegistry,
     const NativeModuleRegistry &nativeModuleRegistry,
@@ -100,7 +100,7 @@ SharedShadowNode UITemplateProcessor::runCommand(
   return nullptr;
 }
 
-SharedShadowNode UITemplateProcessor::buildShadowTree(
+ShadowNode::Shared UITemplateProcessor::buildShadowTree(
     const std::string &jsonStr,
     SurfaceId surfaceId,
     const folly::dynamic &params,
@@ -122,7 +122,7 @@ SharedShadowNode UITemplateProcessor::buildShadowTree(
   }
   auto parsed = folly::parseJson(content);
   auto commands = parsed["commands"];
-  std::vector<SharedShadowNode> nodes(commands.size() * 2);
+  std::vector<ShadowNode::Shared> nodes(commands.size() * 2);
   std::vector<folly::dynamic> registers(32);
   for (const auto &command : commands) {
     try {
@@ -148,7 +148,7 @@ SharedShadowNode UITemplateProcessor::buildShadowTree(
   LOG(ERROR) << "react ui template missing returnRoot command :(";
   throw std::runtime_error(
       "Missing returnRoot command in template content:\n" + content);
-  return SharedShadowNode{};
+  return ShadowNode::Shared{};
 }
 
 } // namespace react