react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -8,10 +8,11 @@
 #include "UIManager.h"
 
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/core/DynamicPropsUtilities.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
+#include <react/renderer/core/TraitCast.h>
 #include <react/renderer/debug/SystraceSection.h>
-#include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/uimanager/SurfaceRegistryBinding.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
@@ -110,14 +111,33 @@ ShadowNode::Shared UIManager::cloneNode(
       shadowNode.getFamily().getSurfaceId(), *contextContainer_.get()};
 
   auto &componentDescriptor = shadowNode.getComponentDescriptor();
+  auto &family = shadowNode.getFamily();
+  auto props = ShadowNodeFragment::propsPlaceholder();
+
+  if (rawProps != nullptr) {
+    if (family.nativeProps_DEPRECATED != nullptr) {
+      // Values in `rawProps` patch (take precedence over)
+      // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
+      // and `rawProps` contain key 'A'. Value from `rawProps` overrides what
+      // was previously in `nativeProps_DEPRECATED`.
+      family.nativeProps_DEPRECATED =
+          std::make_unique<folly::dynamic>(mergeDynamicProps(
+              *family.nativeProps_DEPRECATED, (folly::dynamic)*rawProps));
+
+      props = componentDescriptor.cloneProps(
+          propsParserContext,
+          shadowNode.getProps(),
+          RawProps(*family.nativeProps_DEPRECATED));
+    } else {
+      props = componentDescriptor.cloneProps(
+          propsParserContext, shadowNode.getProps(), *rawProps);
+    }
+  }
+
   auto clonedShadowNode = componentDescriptor.cloneShadowNode(
       shadowNode,
       {
-          /* .props = */
-          rawProps != nullptr
-              ? componentDescriptor.cloneProps(
-                    propsParserContext, shadowNode.getProps(), *rawProps)
-              : ShadowNodeFragment::propsPlaceholder(),
+          /* .props = */ props,
           /* .children = */ children,
       });
 
@@ -290,34 +310,37 @@ void UIManager::updateState(StateUpdate const &stateUpdate) const {
 
   shadowTreeRegistry_.visit(
       family->getSurfaceId(), [&](ShadowTree const &shadowTree) {
-        shadowTree.commit([&](RootShadowNode const &oldRootShadowNode) {
-          auto isValid = true;
-
-          auto rootNode = oldRootShadowNode.cloneTree(
-              *family, [&](ShadowNode const &oldShadowNode) {
-                auto newData =
-                    callback(oldShadowNode.getState()->getDataPointer());
-
-                if (!newData) {
-                  isValid = false;
-                  // Just return something, we will discard it anyway.
-                  return oldShadowNode.clone({});
-                }
-
-                auto newState =
-                    componentDescriptor.createState(*family, newData);
-
-                return oldShadowNode.clone({
-                    /* .props = */ ShadowNodeFragment::propsPlaceholder(),
-                    /* .children = */
-                    ShadowNodeFragment::childrenPlaceholder(),
-                    /* .state = */ newState,
-                });
-              });
-
-          return isValid ? std::static_pointer_cast<RootShadowNode>(rootNode)
-                         : nullptr;
-        });
+        shadowTree.commit(
+            [&](RootShadowNode const &oldRootShadowNode) {
+              auto isValid = true;
+
+              auto rootNode = oldRootShadowNode.cloneTree(
+                  *family, [&](ShadowNode const &oldShadowNode) {
+                    auto newData =
+                        callback(oldShadowNode.getState()->getDataPointer());
+
+                    if (!newData) {
+                      isValid = false;
+                      // Just return something, we will discard it anyway.
+                      return oldShadowNode.clone({});
+                    }
+
+                    auto newState =
+                        componentDescriptor.createState(*family, newData);
+
+                    return oldShadowNode.clone({
+                        /* .props = */ ShadowNodeFragment::propsPlaceholder(),
+                        /* .children = */
+                        ShadowNodeFragment::childrenPlaceholder(),
+                        /* .state = */ newState,
+                    });
+                  });
+
+              return isValid
+                  ? std::static_pointer_cast<RootShadowNode>(rootNode)
+                  : nullptr;
+            },
+            {/* default commit options */});
       });
 }
 
@@ -330,6 +353,48 @@ void UIManager::dispatchCommand(
   }
 }
 
+void UIManager::setNativeProps_DEPRECATED(
+    ShadowNode::Shared const &shadowNode,
+    RawProps const &rawProps) const {
+  auto &family = shadowNode->getFamily();
+  if (family.nativeProps_DEPRECATED) {
+    // Values in `rawProps` patch (take precedence over)
+    // `nativeProps_DEPRECATED`. For example, if both `nativeProps_DEPRECATED`
+    // and `rawProps` contain key 'A'. Value from `rawProps` overrides what was
+    // previously in `nativeProps_DEPRECATED`.
+    family.nativeProps_DEPRECATED =
+        std::make_unique<folly::dynamic>(mergeDynamicProps(
+            *family.nativeProps_DEPRECATED, (folly::dynamic)rawProps));
+  } else {
+    family.nativeProps_DEPRECATED =
+        std::make_unique<folly::dynamic>((folly::dynamic)rawProps);
+  }
+
+  shadowTreeRegistry_.visit(
+      family.getSurfaceId(), [&](ShadowTree const &shadowTree) {
+        shadowTree.commit(
+            [&](RootShadowNode const &oldRootShadowNode) {
+              auto rootNode = oldRootShadowNode.cloneTree(
+                  family, [&](ShadowNode const &oldShadowNode) {
+                    auto &componentDescriptor =
+                        componentDescriptorRegistry_->at(
+                            shadowNode->getComponentHandle());
+                    PropsParserContext propsParserContext{
+                        family.getSurfaceId(), *contextContainer_.get()};
+                    auto props = componentDescriptor.cloneProps(
+                        propsParserContext,
+                        getNewestCloneOfShadowNode(*shadowNode)->getProps(),
+                        rawProps);
+
+                    return oldShadowNode.clone({/* .props = */ props});
+                  });
+
+              return std::static_pointer_cast<RootShadowNode>(rootNode);
+            },
+            {/* default commit options */});
+      });
+}
+
 void UIManager::sendAccessibilityEvent(
     const ShadowNode::Shared &shadowNode,
     std::string const &eventType) {
@@ -352,6 +417,57 @@ void UIManager::configureNextLayoutAnimation(
   }
 }
 
+static ShadowNode::Shared findShadowNodeByTagRecursively(
+    ShadowNode::Shared parentShadowNode,
+    Tag tag) {
+  if (parentShadowNode->getTag() == tag) {
+    return parentShadowNode;
+  }
+
+  for (ShadowNode::Shared const &shadowNode : parentShadowNode->getChildren()) {
+    auto result = findShadowNodeByTagRecursively(shadowNode, tag);
+    if (result) {
+      return result;
+    }
+  }
+
+  return nullptr;
+}
+
+ShadowNode::Shared UIManager::findShadowNodeByTag_DEPRECATED(Tag tag) const {
+  auto shadowNode = ShadowNode::Shared{};
+
+  shadowTreeRegistry_.enumerate([&](ShadowTree const &shadowTree, bool &stop) {
+    RootShadowNode const *rootShadowNode;
+    // The public interface of `ShadowTree` discourages accessing a stored
+    // pointer to a root node because of the possible data race.
+    // To work around this, we ask for a commit and immediately cancel it
+    // returning `nullptr` instead of a new shadow tree.
+    // We don't want to add a way to access a stored pointer to a root node
+    // because this `findShadowNodeByTag` is deprecated. It is only added
+    // to make migration to the new architecture easier.
+    shadowTree.tryCommit(
+        [&](RootShadowNode const &oldRootShadowNode) {
+          rootShadowNode = &oldRootShadowNode;
+          return nullptr;
+        },
+        {/* default commit options */});
+
+    if (rootShadowNode != nullptr) {
+      auto const &children = rootShadowNode->getChildren();
+      if (!children.empty()) {
+        auto const &child = children.front();
+        shadowNode = findShadowNodeByTagRecursively(child, tag);
+        if (shadowNode) {
+          stop = true;
+        }
+      }
+    }
+  });
+
+  return shadowNode;
+}
+
 void UIManager::setComponentDescriptorRegistry(
     const SharedComponentDescriptorRegistry &componentDescriptorRegistry) {
   componentDescriptorRegistry_ = componentDescriptorRegistry;
@@ -381,7 +497,7 @@ ShadowTreeRegistry const &UIManager::getShadowTreeRegistry() const {
 
 void UIManager::registerCommitHook(
     UIManagerCommitHook const &commitHook) const {
-  std::unique_lock<butter::shared_mutex> lock(commitHookMutex_);
+  std::unique_lock lock(commitHookMutex_);
   react_native_assert(
       std::find(commitHooks_.begin(), commitHooks_.end(), &commitHook) ==
       commitHooks_.end());
@@ -391,7 +507,7 @@ void UIManager::registerCommitHook(
 
 void UIManager::unregisterCommitHook(
     UIManagerCommitHook const &commitHook) const {
-  std::unique_lock<butter::shared_mutex> lock(commitHookMutex_);
+  std::unique_lock lock(commitHookMutex_);
   auto iterator =
       std::find(commitHooks_.begin(), commitHooks_.end(), &commitHook);
   react_native_assert(iterator != commitHooks_.end());
@@ -405,7 +521,7 @@ RootShadowNode::Unshared UIManager::shadowTreeWillCommit(
     ShadowTree const &shadowTree,
     RootShadowNode::Shared const &oldRootShadowNode,
     RootShadowNode::Unshared const &newRootShadowNode) const {
-  std::shared_lock<butter::shared_mutex> lock(commitHookMutex_);
+  std::shared_lock lock(commitHookMutex_);
 
   auto resultRootShadowNode = newRootShadowNode;
   for (auto const *commitHook : commitHooks_) {
@@ -417,12 +533,13 @@ RootShadowNode::Unshared UIManager::shadowTreeWillCommit(
 }
 
 void UIManager::shadowTreeDidFinishTransaction(
-    ShadowTree const & /*shadowTree*/,
-    MountingCoordinator::Shared const &mountingCoordinator) const {
+    MountingCoordinator::Shared mountingCoordinator,
+    bool mountSynchronously) const {
   SystraceSection s("UIManager::shadowTreeDidFinishTransaction");
 
   if (delegate_ != nullptr) {
-    delegate_->uiManagerDidFinishTransaction(mountingCoordinator);
+    delegate_->uiManagerDidFinishTransaction(
+        std::move(mountingCoordinator), mountSynchronously);
   }
 }
 
@@ -441,7 +558,7 @@ void UIManager::stopSurfaceForAnimationDelegate(SurfaceId surfaceId) const {
 void UIManager::animationTick() const {
   if (animationDelegate_ != nullptr &&
       animationDelegate_->shouldAnimateFrame()) {
-    shadowTreeRegistry_.enumerate([](ShadowTree const &shadowTree) {
+    shadowTreeRegistry_.enumerate([](ShadowTree const &shadowTree, bool &) {
       shadowTree.notifyDelegatesOfUpdates();
     });
   }

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -11,6 +11,7 @@
 #include <jsi/jsi.h>
 
 #include <ReactCommon/RuntimeExecutor.h>
+#include <shared_mutex>
 
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
 #include <react/renderer/core/RawValue.h>
@@ -103,8 +104,8 @@ class UIManager final : public ShadowTreeDelegate {
 #pragma mark - ShadowTreeDelegate
 
   void shadowTreeDidFinishTransaction(
-      ShadowTree const &shadowTree,
-      MountingCoordinator::Shared const &mountingCoordinator) const override;
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) const override;
 
   RootShadowNode::Unshared shadowTreeWillCommit(
       ShadowTree const &shadowTree,
@@ -162,10 +163,22 @@ class UIManager final : public ShadowTreeDelegate {
       std::string const &commandName,
       folly::dynamic const &args) const;
 
+  void setNativeProps_DEPRECATED(
+      ShadowNode::Shared const &shadowNode,
+      RawProps const &rawProps) const;
+
   void sendAccessibilityEvent(
       const ShadowNode::Shared &shadowNode,
       std::string const &eventType);
 
+  /*
+   * Iterates over all shadow nodes which are parts of all registered surfaces
+   * and find the one that has given `tag`. Returns `nullptr` if the node wasn't
+   * found. This is a temporary workaround that should not be used in any core
+   * functionality.
+   */
+  ShadowNode::Shared findShadowNodeByTag_DEPRECATED(Tag tag) const;
+
   ShadowTreeRegistry const &getShadowTreeRegistry() const;
 
  private:
@@ -191,7 +204,7 @@ class UIManager final : public ShadowTreeDelegate {
   BackgroundExecutor const backgroundExecutor_{};
   ContextContainer::Shared contextContainer_;
 
-  mutable butter::shared_mutex commitHookMutex_;
+  mutable std::shared_mutex commitHookMutex_;
   mutable std::vector<UIManagerCommitHook const *> commitHooks_;
 
   std::unique_ptr<LeakChecker> leakChecker_;

package/ReactCommon/react/renderer/uimanager/UIManagerAnimationDelegate.h

@@ -36,6 +36,14 @@ class UIManagerAnimationDelegate {
   virtual void setComponentDescriptorRegistry(
       const SharedComponentDescriptorRegistry &componentDescriptorRegistry) = 0;
 
+  /**
+   * Set Animation flags for dropping delete and create mutations
+   *
+   * @param reduceDeleteCreateMutation
+   */
+  virtual void setReduceDeleteCreateMutation(
+      bool reduceDeleteCreateMutation) = 0;
+
   /**
    * Only needed on Android to drive animations.
    */

package/ReactCommon/react/renderer/uimanager/UIManagerBinding.cpp

@@ -11,6 +11,7 @@
 #include <jsi/JSIDynamic.h>
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
+#include <react/renderer/core/TraitCast.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
@@ -403,7 +404,11 @@ jsi::Value UIManagerBinding::get(
             auto shadowNodeList =
                 shadowNodeListFromWeakList(weakShadowNodeList);
             if (shadowNodeList) {
-              uiManager->completeSurface(surfaceId, shadowNodeList, {true});
+              uiManager->completeSurface(
+                  surfaceId,
+                  shadowNodeList,
+                  {/* .enableStateReconciliation = */ true,
+                   /* .mountSynchronously = */ false});
             }
           } else {
             auto weakShadowNodeList =
@@ -429,7 +434,11 @@ jsi::Value UIManagerBinding::get(
                   auto strongUIManager = weakUIManager.lock();
                   if (shadowNodeList && strongUIManager) {
                     strongUIManager->completeSurface(
-                        surfaceId, shadowNodeList, {true, shouldYield});
+                        surfaceId,
+                        shadowNodeList,
+                        {/* .enableStateReconciliation = */ true,
+                         /* .mountSynchronously = */ false,
+                         /* .shouldYield = */ shouldYield});
                   }
                 });
           }
@@ -493,7 +502,7 @@ jsi::Value UIManagerBinding::get(
           auto shadowNode = shadowNodeFromValue(runtime, arguments[0]);
           if (shadowNode) {
             uiManager->dispatchCommand(
-                shadowNodeFromValue(runtime, arguments[0]),
+                shadowNode,
                 stringFromValue(runtime, arguments[1]),
                 commandArgsFromValue(runtime, arguments[2]));
           }
@@ -501,6 +510,24 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
+  if (methodName == "setNativeProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager](
+            jsi::Runtime &runtime,
+            const jsi::Value &,
+            const jsi::Value *arguments,
+            size_t) -> jsi::Value {
+          uiManager->setNativeProps_DEPRECATED(
+              shadowNodeFromValue(runtime, arguments[0]),
+              RawProps(runtime, arguments[1]));
+
+          return jsi::Value::undefined();
+        });
+  }
+
   // Legacy API
   if (methodName == "measureLayout") {
     return jsi::Function::createFromHostFunction(
@@ -594,7 +621,7 @@ jsi::Value UIManagerBinding::get(
               *shadowNodeFromValue(runtime, arguments[0]),
               nullptr,
               {/* .includeTransform = */ true,
-               /* includeViewportOffset = */ true});
+               /* .includeViewportOffset = */ true});
 
           auto onSuccessFunction =
               arguments[1].getObject(runtime).getFunction(runtime);
@@ -615,6 +642,40 @@ jsi::Value UIManagerBinding::get(
         });
   }
 
+  if (methodName == "getBoundingClientRect") {
+    // This is similar to `measureInWindow`, except it's explicitly synchronous
+    // (returns the result instead of passing it to a callback).
+    // The behavior is similar to `Element.prototype.getBoundingClientRect` from
+    // Web.
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager](
+            jsi::Runtime &runtime,
+            jsi::Value const & /*thisValue*/,
+            jsi::Value const *arguments,
+            size_t /*count*/) noexcept -> jsi::Value {
+          auto layoutMetrics = uiManager->getRelativeLayoutMetrics(
+              *shadowNodeFromValue(runtime, arguments[0]),
+              nullptr,
+              {/* .includeTransform = */ true,
+               /* .includeViewportOffset = */ true});
+
+          if (layoutMetrics == EmptyLayoutMetrics) {
+            return jsi::Value::undefined();
+          }
+
+          auto frame = layoutMetrics.frame;
+          return jsi::Array::createWithElements(
+              runtime,
+              jsi::Value{runtime, (double)frame.origin.x},
+              jsi::Value{runtime, (double)frame.origin.y},
+              jsi::Value{runtime, (double)frame.size.width},
+              jsi::Value{runtime, (double)frame.size.height});
+        });
+  }
+
   if (methodName == "sendAccessibilityEvent") {
     return jsi::Function::createFromHostFunction(
         runtime,
@@ -675,6 +736,27 @@ jsi::Value UIManagerBinding::get(
     return {serialize(ReactEventPriority::Discrete)};
   }
 
+  if (methodName == "findShadowNodeByTag_DEPRECATED") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) -> jsi::Value {
+          auto shadowNode = uiManager->findShadowNodeByTag_DEPRECATED(
+              tagFromValue(arguments[0]));
+
+          if (!shadowNode) {
+            return jsi::Value::null();
+          }
+
+          return valueFromShadowNode(runtime, shadowNode);
+        });
+  }
+
   return jsi::Value::undefined();
 }
 

package/ReactCommon/react/renderer/uimanager/UIManagerDelegate.h

@@ -23,7 +23,8 @@ class UIManagerDelegate {
    * For this moment the tree is already laid out and sealed.
    */
   virtual void uiManagerDidFinishTransaction(
-      MountingCoordinator::Shared const &mountingCoordinator) = 0;
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) = 0;
 
   /*
    * Called each time when UIManager constructs a new Shadow Node. Receiver

package/ReactCommon/react/renderer/uimanager/primitives.h

@@ -11,6 +11,7 @@
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/core/CoreFeatures.h>
 #include <react/renderer/core/EventHandler.h>
 #include <react/renderer/core/ShadowNode.h>
 
@@ -38,9 +39,9 @@ struct ShadowNodeWrapper : public jsi::HostObject {
   ShadowNode::Shared shadowNode;
 };
 
-struct ShadowNodeListWrapper : public jsi::HostObject {
+struct ShadowNodeListWrapper : public jsi::HostObject, public jsi::NativeState {
   ShadowNodeListWrapper(ShadowNode::UnsharedListOfShared shadowNodeList)
-      : shadowNodeList(shadowNodeList) {}
+      : shadowNodeList(std::move(shadowNodeList)) {}
 
   // The below method needs to be implemented out-of-line in order for the class
   // to have at least one "key function" (see
@@ -52,29 +53,63 @@ struct ShadowNodeListWrapper : public jsi::HostObject {
 
 inline static ShadowNode::Shared shadowNodeFromValue(
     jsi::Runtime &runtime,
-    jsi::Value const &value) {
+    const jsi::Value &value) {
   if (value.isNull()) {
     return nullptr;
   }
 
-  return value.getObject(runtime)
-      .getHostObject<ShadowNodeWrapper>(runtime)
-      ->shadowNode;
+  if (CoreFeatures::useNativeState) {
+    return value.getObject(runtime).getNativeState<ShadowNode>(runtime);
+  } else {
+    return value.getObject(runtime)
+        .getHostObject<ShadowNodeWrapper>(runtime)
+        ->shadowNode;
+  }
 }
 
 inline static jsi::Value valueFromShadowNode(
     jsi::Runtime &runtime,
     ShadowNode::Shared shadowNode) {
-  return jsi::Object::createFromHostObject(
-      runtime, std::make_shared<ShadowNodeWrapper>(std::move(shadowNode)));
+  if (CoreFeatures::useNativeState) {
+    jsi::Object obj(runtime);
+    // Need to const_cast since JSI only allows non-const pointees
+    obj.setNativeState(
+        runtime, std::const_pointer_cast<ShadowNode>(std::move(shadowNode)));
+    return obj;
+  } else {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<ShadowNodeWrapper>(std::move(shadowNode)));
+  }
 }
 
 inline static ShadowNode::UnsharedListOfShared shadowNodeListFromValue(
     jsi::Runtime &runtime,
-    jsi::Value const &value) {
-  return value.getObject(runtime)
-      .getHostObject<ShadowNodeListWrapper>(runtime)
-      ->shadowNodeList;
+    const jsi::Value &value) {
+  if (CoreFeatures::useNativeState) {
+    return value.getObject(runtime)
+        .getNativeState<ShadowNodeListWrapper>(runtime)
+        ->shadowNodeList;
+  } else {
+    return value.getObject(runtime)
+        .getHostObject<ShadowNodeListWrapper>(runtime)
+        ->shadowNodeList;
+  }
+}
+
+inline static jsi::Value valueFromShadowNodeList(
+    jsi::Runtime &runtime,
+    ShadowNode::UnsharedListOfShared shadowNodeList) {
+  auto wrapper =
+      std::make_shared<ShadowNodeListWrapper>(std::move(shadowNodeList));
+  if (CoreFeatures::useNativeState) {
+    // Use the wrapper for NativeState too, otherwise we can't implement
+    // the marker interface. Could be simplified to a simple struct wrapper.
+    jsi::Object obj(runtime);
+    obj.setNativeState(runtime, std::move(wrapper));
+    return obj;
+  } else {
+    return jsi::Object::createFromHostObject(runtime, std::move(wrapper));
+  }
 }
 
 inline static ShadowNode::UnsharedListOfShared shadowNodeListFromWeakList(
@@ -93,25 +128,14 @@ inline static ShadowNode::UnsharedListOfShared shadowNodeListFromWeakList(
 inline static ShadowNode::UnsharedListOfWeak weakShadowNodeListFromValue(
     jsi::Runtime &runtime,
     jsi::Value const &value) {
-  auto shadowNodeList = value.getObject(runtime)
-                            .getHostObject<ShadowNodeListWrapper>(runtime)
-                            ->shadowNodeList;
-
+  auto shadowNodeList = shadowNodeListFromValue(runtime, value);
   auto weakShadowNodeList = std::make_shared<ShadowNode::ListOfWeak>();
   for (auto const &shadowNode : *shadowNodeList) {
     weakShadowNodeList->push_back(shadowNode);
   }
-
   return weakShadowNodeList;
 }
 
-inline static jsi::Value valueFromShadowNodeList(
-    jsi::Runtime &runtime,
-    const ShadowNode::UnsharedListOfShared &shadowNodeList) {
-  return jsi::Object::createFromHostObject(
-      runtime, std::make_unique<ShadowNodeListWrapper>(shadowNodeList));
-}
-
 inline static Tag tagFromValue(jsi::Value const &value) {
   return (Tag)value.getNumber();
 }

package/ReactCommon/react/utils/.clang-tidy

@@ -2,4 +2,5 @@
 Checks: '>
 clang-diagnostic-*,
 '
+InheritParentConfig: true
 ...

package/ReactCommon/react/utils/BUCK

@@ -19,7 +19,6 @@ rn_xplat_cxx_library(
     srcs = glob(
         [
             "**/*.cpp",
-            "**/*.mm",
         ],
         exclude = glob(["tests/**/*.cpp"]),
     ),
@@ -42,6 +41,11 @@ rn_xplat_cxx_library(
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_frameworks = ["Foundation"],
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
+    fbobjc_srcs = glob(
+        [
+            "**/*.mm",
+        ],
+    ),
     force_static = True,
     labels = [
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
@@ -55,7 +59,7 @@ rn_xplat_cxx_library(
     tests = [],
     visibility = ["PUBLIC"],
     deps = [
-        "//xplat/folly:container_evicting_cache_map",
+        "//xplat/folly/container:evicting_cache_map",
         "//xplat/jsi:jsi",
         react_native_xplat_target("butter:butter"),
         react_native_xplat_target("react/debug:debug"),