react-native 0.69.1 → 0.70.0-rc.0

package/ReactCommon/react/renderer/components/view/YogaStylableProps.h

@@ -25,6 +25,12 @@ class YogaStylableProps : public Props {
       RawProps const &rawProps,
       bool shouldSetRawProps = true);
 
+  void setProp(
+      const PropsParserContext &context,
+      RawPropsPropNameHash hash,
+      const char *propName,
+      RawValue const &value);
+
 #pragma mark - Props
 
   YGStyle yogaStyle{};

package/ReactCommon/react/renderer/components/view/conversions.h

@@ -392,8 +392,11 @@ inline void fromRawValue(
             YGUnitPercent};
         return;
       } else {
-        result = YGValue{folly::to<float>(stringValue), YGUnitPoint};
-        return;
+        auto tryValue = folly::tryTo<float>(stringValue);
+        if (tryValue.hasValue()) {
+          result = YGValue{tryValue.value(), YGUnitPoint};
+          return;
+        }
       }
     }
   }

package/ReactCommon/react/renderer/components/view/primitives.h

@@ -49,6 +49,13 @@ struct ViewEvents {
     TouchMove = 17,
     TouchEnd = 18,
     TouchCancel = 19,
+
+    // W3C Pointer Events
+    PointerEnterCapture = 23,
+    PointerLeaveCapture = 24,
+    PointerMoveCapture = 25,
+    PointerOver = 26,
+    PointerOut = 27,
   };
 
   constexpr bool operator[](const Offset offset) const {

package/ReactCommon/react/renderer/components/view/propsConversions.h

@@ -16,6 +16,8 @@
 namespace facebook {
 namespace react {
 
+// Nearly this entire file can be deleted when iterator-style Prop parsing
+// ships fully for View
 static inline YGStyle::Dimensions convertRawProp(
     const PropsParserContext &context,
     RawProps const &rawProps,
@@ -35,7 +37,7 @@ static inline YGStyle::Dimensions convertRawProp(
       rawProps,
       heightName,
       sourceValue[YGDimensionHeight],
-      defaultValue[YGDimensionWidth]);
+      defaultValue[YGDimensionHeight]);
   return dimensions;
 }
 
@@ -301,6 +303,7 @@ static inline YGStyle convertRawProp(
   return yogaStyle;
 }
 
+// This can be deleted when non-iterator ViewProp parsing is deleted
 template <typename T>
 static inline CascadedRectangleCorners<T> convertRawProp(
     const PropsParserContext &context,
@@ -465,6 +468,7 @@ static inline CascadedRectangleEdges<T> convertRawProp(
   return result;
 }
 
+// This can be deleted when non-iterator ViewProp parsing is deleted
 static inline ViewEvents convertRawProp(
     const PropsParserContext &context,
     RawProps const &rawProps,
@@ -492,6 +496,38 @@ static inline ViewEvents convertRawProp(
       sourceValue[Offset::PointerLeave],
       defaultValue[Offset::PointerLeave]);
 
+  // Experimental W3C Pointer callbacks
+  result[Offset::PointerEnterCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerEnterCapture",
+      sourceValue[Offset::PointerEnterCapture],
+      defaultValue[Offset::PointerEnterCapture]);
+  result[Offset::PointerMoveCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerMoveCapture",
+      sourceValue[Offset::PointerMoveCapture],
+      defaultValue[Offset::PointerMoveCapture]);
+  result[Offset::PointerLeaveCapture] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerLeaveCapture",
+      sourceValue[Offset::PointerLeaveCapture],
+      defaultValue[Offset::PointerLeaveCapture]);
+  result[Offset::PointerOver] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerOver",
+      sourceValue[Offset::PointerOver],
+      defaultValue[Offset::PointerOver]);
+  result[Offset::PointerOut] = convertRawProp(
+      context,
+      rawProps,
+      "onPointerOut",
+      sourceValue[Offset::PointerOut],
+      defaultValue[Offset::PointerOut]);
+
   // PanResponder callbacks
   result[Offset::MoveShouldSetResponder] = convertRawProp(
       context,

package/ReactCommon/react/renderer/core/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",
         "//xplat/jsi:JSIDynamic",

package/ReactCommon/react/renderer/core/ComponentDescriptor.h

@@ -102,20 +102,20 @@ class ComponentDescriptor {
    * will be used.
    * Must return an object which is NOT pointer equal to `props`.
    */
-  virtual SharedProps cloneProps(
+  virtual Props::Shared cloneProps(
       const PropsParserContext &context,
-      const SharedProps &props,
+      const Props::Shared &props,
       const RawProps &rawProps) const = 0;
 
   /*
    * Creates a new `Props` of a particular type with all values interpolated
    * between `props` and `newProps`.
    */
-  virtual SharedProps interpolateProps(
+  virtual Props::Shared interpolateProps(
       const PropsParserContext &context,
       Float animationProgress,
-      const SharedProps &props,
-      const SharedProps &newProps) const = 0;
+      const Props::Shared &props,
+      const Props::Shared &newProps) const = 0;
 
   /*
    * Create an initial State object that represents (and contains) an initial

package/ReactCommon/react/renderer/core/ConcreteComponentDescriptor.h

@@ -94,9 +94,9 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
     concreteNonConstParentShadowNode->appendChild(childShadowNode);
   }
 
-  virtual SharedProps cloneProps(
+  virtual Props::Shared cloneProps(
       const PropsParserContext &context,
-      const SharedProps &props,
+      const Props::Shared &props,
       const RawProps &rawProps) const override {
     // Optimization:
     // Quite often nodes are constructed with default/empty props: the base
@@ -109,22 +109,36 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
 
     rawProps.parse(rawPropsParser_, context);
 
-    return ShadowNodeT::Props(context, rawProps, props);
+    // Call old-style constructor
+    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
+
+    // Use the new-style iterator
+    // Note that we just check if `Props` has this flag set, no matter
+    // the type of ShadowNode; it acts as the single global flag.
+    if (Props::enablePropIteratorSetter) {
+      rawProps.iterateOverValues([&](RawPropsPropNameHash hash,
+                                     const char *propName,
+                                     RawValue const &fn) {
+        shadowNodeProps.get()->setProp(context, hash, propName, fn);
+      });
+    }
+
+    return shadowNodeProps;
   };
 
-  SharedProps interpolateProps(
+  Props::Shared interpolateProps(
       const PropsParserContext &context,
       Float animationProgress,
-      const SharedProps &props,
-      const SharedProps &newProps) const override {
+      const Props::Shared &props,
+      const Props::Shared &newProps) const override {
 #ifdef ANDROID
     // On Android only, the merged props should have the same RawProps as the
     // final props struct
-    SharedProps interpolatedPropsShared =
+    Props::Shared interpolatedPropsShared =
         (newProps != nullptr ? cloneProps(context, newProps, newProps->rawProps)
                              : cloneProps(context, newProps, {}));
 #else
-    SharedProps interpolatedPropsShared = cloneProps(context, newProps, {});
+    Props::Shared interpolatedPropsShared = cloneProps(context, newProps, {});
 #endif
 
     if (ConcreteShadowNode::BaseTraits().check(

package/ReactCommon/react/renderer/core/ConcreteShadowNode.h

@@ -47,6 +47,7 @@ class ConcreteShadowNode : public BaseShadowNodeT {
 
   using ConcreteProps = PropsT;
   using SharedConcreteProps = std::shared_ptr<PropsT const>;
+  using UnsharedConcreteProps = std::shared_ptr<PropsT>;
   using ConcreteEventEmitter = EventEmitterT;
   using SharedConcreteEventEmitter = std::shared_ptr<EventEmitterT const>;
   using SharedConcreteShadowNode = std::shared_ptr<ConcreteShadowNode const>;
@@ -69,11 +70,11 @@ class ConcreteShadowNode : public BaseShadowNodeT {
     return BaseShadowNodeT::BaseTraits();
   }
 
-  static SharedConcreteProps Props(
+  static UnsharedConcreteProps Props(
       const PropsParserContext &context,
       RawProps const &rawProps,
-      SharedProps const &baseProps = nullptr) {
-    return std::make_shared<PropsT const>(
+      Props::Shared const &baseProps = nullptr) {
+    return std::make_shared<PropsT>(
         context,
         baseProps ? static_cast<PropsT const &>(*baseProps) : PropsT(),
         rawProps);

package/ReactCommon/react/renderer/core/Props.cpp

@@ -13,17 +13,21 @@
 namespace facebook {
 namespace react {
 
+bool Props::enablePropIteratorSetter = false;
+
 Props::Props(
     const PropsParserContext &context,
     const Props &sourceProps,
     const RawProps &rawProps,
     const bool shouldSetRawProps)
-    : nativeId(convertRawProp(
-          context,
-          rawProps,
-          "nativeID",
-          sourceProps.nativeId,
-          {})),
+    : nativeId(
+          enablePropIteratorSetter ? sourceProps.nativeId
+                                   : convertRawProp(
+                                         context,
+                                         rawProps,
+                                         "nativeID",
+                                         sourceProps.nativeId,
+                                         {})),
       revision(sourceProps.revision + 1)
 #ifdef ANDROID
       ,
@@ -31,7 +35,20 @@ Props::Props(
           shouldSetRawProps ? (folly::dynamic)rawProps
                             : /* null */ folly::dynamic())
 #endif
-          {};
+{
+}
+
+void Props::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  switch (hash) {
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("nativeID"):
+      fromRawValue(context, value, nativeId, {});
+      return;
+  }
+}
 
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/Props.h

@@ -9,6 +9,7 @@
 
 #include <folly/dynamic.h>
 
+#include <react/renderer/core/PropsMacros.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ReactPrimitives.h>
@@ -18,10 +19,6 @@
 namespace facebook {
 namespace react {
 
-class Props;
-
-using SharedProps = std::shared_ptr<Props const>;
-
 /*
  * Represents the most generic props object.
  */
@@ -37,6 +34,24 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
       bool shouldSetRawProps = true);
   virtual ~Props() = default;
 
+  static bool enablePropIteratorSetter;
+
+  /**
+   * Set a prop value via iteration (see enableIterator above).
+   * If setProp is defined for a particular props struct, it /must/
+   * be called every time setProp is called on the hierarchy.
+   * For example, ViewProps overrides setProp and so ViewProps must
+   * explicitly call Props::setProp every time ViewProps::setProp is
+   * called. This is because a single prop from JS can be reused
+   * multiple times for different values in the hierarchy. For example, if
+   * ViewProps uses "propX", Props may also use "propX".
+   */
+  void setProp(
+      const PropsParserContext &context,
+      RawPropsPropNameHash hash,
+      const char *propName,
+      RawValue const &value);
+
   std::string nativeId;
 
   /*

package/ReactCommon/react/renderer/core/PropsMacros.h

@@ -0,0 +1,94 @@
+/*
+ * 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 <react/renderer/core/RawPropsPrimitives.h>
+
+// We need to use clang pragmas inside of a macro below,
+// so we need to pull out the "if" statement here.
+#if __clang__
+#define CLANG_PRAGMA(s) _Pragma(s)
+#else
+#define CLANG_PRAGMA(s)
+#endif
+
+// Get hash at compile-time. sizeof(str) - 1 == strlen
+#define CONSTEXPR_RAW_PROPS_KEY_HASH(s)                   \
+  ({                                                      \
+    CLANG_PRAGMA("clang diagnostic push")                 \
+    CLANG_PRAGMA("clang diagnostic ignored \"-Wshadow\"") \
+    constexpr RawPropsPropNameHash propNameHash =         \
+        folly::hash::fnv32_buf(s, sizeof(s) - 1);         \
+    propNameHash;                                         \
+    CLANG_PRAGMA("clang diagnostic pop")                  \
+  })
+
+#define RAW_PROPS_KEY_HASH(s) folly::hash::fnv32_buf(s, std::strlen(s))
+
+// Convenience for building setProps switch statements.
+// This injects `fromRawValue` into source; each file that uses
+// this macro must import the proper, respective headers required.
+#define RAW_SET_PROP_SWITCH_CASE(field, jsPropName, defaultValue) \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(jsPropName):                  \
+    fromRawValue(context, value, field, defaultValue);            \
+    return;
+
+// Convenience for building setProps switch statements where the field name is
+// the same as the string identifier
+#define RAW_SET_PROP_SWITCH_CASE_BASIC(field, defaultValue) \
+  RAW_SET_PROP_SWITCH_CASE(field, #field, defaultValue)
+
+#define CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(         \
+    struct, field, fieldNameString, value)              \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldNameString): { \
+    if (!value.hasValue()) {                            \
+      decltype(struct) defaultValues{};                 \
+      struct.field = defaultValues.field;               \
+      return;                                           \
+    }                                                   \
+    fromRawValue(context, value, struct.field);         \
+    return;                                             \
+  }
+
+#define SET_CASCADED_RECTANGLE_CORNERS(struct, prefix, suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topLeft, prefix "TopLeft" suffix, rawValue)                \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topRight, prefix "TopRight" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomLeft, prefix "BottomLeft" suffix, rawValue)          \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomRight, prefix "BottomRight" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topStart, prefix "TopStart" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, topEnd, prefix "TopEnd" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomStart, prefix "BottomStart" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, bottomEnd, prefix "BottomEnd" suffix, rawValue)
+
+#define SET_CASCADED_RECTANGLE_EDGES(struct, prefix, suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, left, prefix "Left" suffix, rawValue)                    \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, right, prefix "Right" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, top, prefix "Top" suffix, rawValue)                      \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, bottom, prefix "Bottom" suffix, rawValue)                \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, start, prefix "Start" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, end, prefix "End" suffix, rawValue)                      \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, horizontal, prefix "Horizontal" suffix, rawValue)        \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, vertical, prefix "Vertical" suffix, rawValue)            \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, all, prefix "" suffix, rawValue)

package/ReactCommon/react/renderer/core/RawProps.cpp

@@ -93,5 +93,12 @@ const RawValue *RawProps::at(
   return parser_->at(*this, RawPropsKey{prefix, name, suffix});
 }
 
+void RawProps::iterateOverValues(
+    std::function<
+        void(RawPropsPropNameHash, const char *, RawValue const &)> const &fn)
+    const {
+  return parser_->iterateOverValues(*this, fn);
+}
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/RawProps.h

@@ -97,6 +97,15 @@ class RawProps final {
   const RawValue *at(char const *name, char const *prefix, char const *suffix)
       const noexcept;
 
+  /**
+   * Iterator functions: for when you want to iterate over values in-order
+   * instead of using `at` to access values randomly.
+   */
+  void iterateOverValues(
+      std::function<
+          void(RawPropsPropNameHash, const char *, RawValue const &)> const &fn)
+      const;
+
  private:
   friend class RawPropsParser;
 

package/ReactCommon/react/renderer/core/RawPropsParser.cpp

@@ -8,6 +8,7 @@
 #include "RawPropsParser.h"
 
 #include <folly/Likely.h>
+#include <folly/hash/Hash.h>
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/RawProps.h>
 
@@ -99,6 +100,13 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
   // Resetting the cursor, the next increment will give `0`.
   rawProps.keyIndexCursor_ = static_cast<int>(keyCount - 1);
 
+  // If the Props constructor doesn't use ::at at all, we might be
+  // able to skip this entirely (in those cases, the Props struct probably
+  // uses setProp instead).
+  if (keyCount == 0) {
+    return;
+  }
+
   switch (rawProps.mode_) {
     case RawProps::Mode::Empty:
       return;
@@ -123,6 +131,7 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
 
         auto keyIndex = nameToIndex_.at(
             name.data(), static_cast<RawPropsPropNameLength>(name.size()));
+
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;
         }
@@ -145,6 +154,7 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
 
         auto keyIndex = nameToIndex_.at(
             name.data(), static_cast<RawPropsPropNameLength>(name.size()));
+
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;
         }
@@ -158,5 +168,58 @@ void RawPropsParser::preparse(RawProps const &rawProps) const noexcept {
   }
 }
 
+/**
+ * To be used by RawProps only. Value iterator functions.
+ */
+void RawPropsParser::iterateOverValues(
+    RawProps const &rawProps,
+    std::function<
+        void(RawPropsPropNameHash, const char *, RawValue const &)> const
+        &visit) const {
+  switch (rawProps.mode_) {
+    case RawProps::Mode::Empty:
+      return;
+
+    case RawProps::Mode::JSI: {
+      auto &runtime = *rawProps.runtime_;
+      if (!rawProps.value_.isObject()) {
+        LOG(ERROR) << "Preparse props: rawProps value is not object";
+      }
+      react_native_assert(rawProps.value_.isObject());
+      auto object = rawProps.value_.asObject(runtime);
+
+      auto names = object.getPropertyNames(runtime);
+      auto count = names.size(runtime);
+
+      for (size_t i = 0; i < count; i++) {
+        auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
+        auto value = object.getProperty(runtime, nameValue);
+
+        auto name = nameValue.utf8(runtime);
+
+        auto nameHash = RAW_PROPS_KEY_HASH(name.c_str());
+        auto rawValue = RawValue(jsi::dynamicFromValue(runtime, value));
+
+        visit(nameHash, name.c_str(), rawValue);
+      }
+
+      break;
+    }
+
+    case RawProps::Mode::Dynamic: {
+      auto const &dynamic = rawProps.dynamic_;
+
+      for (auto const &pair : dynamic.items()) {
+        auto name = pair.first.getString();
+
+        auto nameHash = RAW_PROPS_KEY_HASH(name.c_str());
+        auto rawValue = RawValue{pair.second};
+        visit(nameHash, name.c_str(), rawValue);
+      }
+      break;
+    }
+  }
+}
+
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/core/RawPropsParser.h

@@ -76,6 +76,15 @@ class RawPropsParser final {
   RawValue const *at(RawProps const &rawProps, RawPropsKey const &key)
       const noexcept;
 
+  /**
+   * To be used by RawProps only. Value iterator functions.
+   */
+  void iterateOverValues(
+      RawProps const &rawProps,
+      std::function<
+          void(RawPropsPropNameHash, const char *, RawValue const &)> const &fn)
+      const;
+
   mutable butter::small_vector<RawPropsKey, kNumberOfPropsPerComponentSoftCap>
       keys_{};
   mutable RawPropsKeyMap nameToIndex_{};

package/ReactCommon/react/renderer/core/RawPropsPrimitives.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <folly/hash/Hash.h>
 #include <limits>
 
 namespace facebook {
@@ -20,6 +21,7 @@ static_assert(
     sizeof(RawPropsValueIndex) == 1,
     "RawPropsValueIndex must be one byte size.");
 using RawPropsPropNameLength = uint8_t;
+using RawPropsPropNameHash = uint32_t;
 
 /*
  * The number which is *usually* bigger than a number of explicitly specified

package/ReactCommon/react/renderer/core/RawValue.h

@@ -12,6 +12,8 @@
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
 
+#include <react/renderer/core/RawPropsPrimitives.h>
+
 #include <react/debug/react_native_assert.h>
 
 namespace facebook {

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -22,9 +22,9 @@
 namespace facebook {
 namespace react {
 
-SharedShadowNodeSharedList ShadowNode::emptySharedShadowNodeSharedList() {
+ShadowNode::SharedListOfShared ShadowNode::emptySharedShadowNodeSharedList() {
   static const auto emptySharedShadowNodeSharedList =
-      std::make_shared<SharedShadowNodeList>();
+      std::make_shared<ShadowNode::ListOfShared>();
   return emptySharedShadowNodeSharedList;
 }
 
@@ -36,7 +36,7 @@ SharedShadowNodeSharedList ShadowNode::emptySharedShadowNodeSharedList() {
  * Background Executor and should be removed once reimplementation of JNI layer
  * is finished.
  */
-SharedProps ShadowNode::propsForClonedShadowNode(
+Props::Shared ShadowNode::propsForClonedShadowNode(
     ShadowNode const &sourceShadowNode,
     Props::Shared const &props) {
 #ifdef ANDROID
@@ -131,7 +131,7 @@ ComponentHandle ShadowNode::getComponentHandle() const {
   return family_->getComponentHandle();
 }
 
-const SharedShadowNodeList &ShadowNode::getChildren() const {
+const ShadowNode::ListOfShared &ShadowNode::getChildren() const {
   return *children_;
 }
 
@@ -139,7 +139,7 @@ ShadowNodeTraits ShadowNode::getTraits() const {
   return traits_;
 }
 
-const SharedProps &ShadowNode::getProps() const {
+const Props::Shared &ShadowNode::getProps() const {
   return props_;
 }
 
@@ -192,7 +192,7 @@ void ShadowNode::appendChild(const ShadowNode::Shared &child) {
 
   cloneChildrenIfShared();
   auto nonConstChildren =
-      std::const_pointer_cast<SharedShadowNodeList>(children_);
+      std::const_pointer_cast<ShadowNode::ListOfShared>(children_);
   nonConstChildren->push_back(child);
 
   child->family_->setParent(family_);
@@ -237,7 +237,7 @@ void ShadowNode::cloneChildrenIfShared() {
   }
 
   traits_.unset(ShadowNodeTraits::Trait::ChildrenAreShared);
-  children_ = std::make_shared<SharedShadowNodeList>(*children_);
+  children_ = std::make_shared<ShadowNode::ListOfShared>(*children_);
 }
 
 void ShadowNode::setMounted(bool mounted) const {
@@ -285,7 +285,7 @@ ShadowNode::Unshared ShadowNode::cloneTree(
 
     childNode = parentNode.clone({
         ShadowNodeFragment::propsPlaceholder(),
-        std::make_shared<SharedShadowNodeList>(children),
+        std::make_shared<ShadowNode::ListOfShared>(children),
     });
   }