react-native 0.0.0-16bb2ae4f → 0.0.0-18697adec

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

@@ -9,6 +9,7 @@
 
 #include <react/renderer/core/EventDispatcher.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawPropsParser.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/State.h>
@@ -40,8 +41,8 @@ class ComponentDescriptor {
    * and `ComponentHandle` (the particular custom implementation might use
    * stored `flavor` to return different values from those virtual methods).
    * Since it's a very niche requirement (e.g. we plan to use it for
-   * an interoperability layer with Paper), we are thinking about removing this
-   * feature completely after it's no longer needed.
+   * an interoperability layer with old renderer), we are thinking about
+   * removing this feature completely after it's no longer needed.
    */
   using Flavor = std::shared_ptr<void const>;
 
@@ -101,6 +102,7 @@ class ComponentDescriptor {
    * Must return an object which is NOT pointer equal to `props`.
    */
   virtual SharedProps cloneProps(
+      const PropsParserContext &context,
       const SharedProps &props,
       const RawProps &rawProps) const = 0;
 
@@ -109,6 +111,7 @@ class ComponentDescriptor {
    * between `props` and `newProps`.
    */
   virtual SharedProps interpolateProps(
+      const PropsParserContext &context,
       float animationProgress,
       const SharedProps &props,
       const SharedProps &newProps) const = 0;

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

@@ -11,9 +11,11 @@
 #include <memory>
 
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/components/view/ViewPropsInterpolation.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/EventDispatcher.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/core/State.h>
@@ -78,10 +80,6 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   ShadowNode::Unshared cloneShadowNode(
       const ShadowNode &sourceShadowNode,
       const ShadowNodeFragment &fragment) const override {
-    react_native_assert(
-        dynamic_cast<ConcreteShadowNode const *>(&sourceShadowNode) &&
-        "Provided `sourceShadowNode` has an incompatible type.");
-
     auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
 
     adopt(shadowNode);
@@ -91,10 +89,6 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   void appendChild(
       const ShadowNode::Shared &parentShadowNode,
       const ShadowNode::Shared &childShadowNode) const override {
-    react_native_assert(
-        dynamic_cast<ConcreteShadowNode const *>(parentShadowNode.get()) &&
-        "Provided `parentShadowNode` has an incompatible type.");
-
     auto concreteParentShadowNode =
         std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
     auto concreteNonConstParentShadowNode =
@@ -103,13 +97,9 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
   virtual SharedProps cloneProps(
+      const PropsParserContext &context,
       const SharedProps &props,
       const RawProps &rawProps) const override {
-    react_native_assert(
-        !props ||
-        dynamic_cast<ConcreteProps const *>(props.get()) &&
-            "Provided `props` has an incompatible type.");
-
     // Optimization:
     // Quite often nodes are constructed with default/empty props: the base
     // `props` object is `null` (there no base because it's not cloning) and the
@@ -119,25 +109,33 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       return ShadowNodeT::defaultSharedProps();
     }
 
-    rawProps.parse(rawPropsParser_);
+    rawProps.parse(rawPropsParser_, context);
 
-    return ShadowNodeT::Props(rawProps, props);
+    return ShadowNodeT::Props(context, rawProps, props);
   };
 
-  virtual SharedProps interpolateProps(
+  SharedProps interpolateProps(
+      const PropsParserContext &context,
       float animationProgress,
       const SharedProps &props,
       const SharedProps &newProps) const override {
-    // By default, this does nothing.
 #ifdef ANDROID
     // On Android only, the merged props should have the same RawProps as the
     // final props struct
-    if (newProps != nullptr) {
-      return cloneProps(newProps, newProps->rawProps);
-    }
+    SharedProps interpolatedPropsShared =
+        (newProps != nullptr ? cloneProps(context, newProps, newProps->rawProps)
+                             : cloneProps(context, newProps, {}));
+#else
+    SharedProps interpolatedPropsShared = cloneProps(context, newProps, {});
 #endif
 
-    return cloneProps(newProps, {});
+    if (ConcreteShadowNode::BaseTraits().check(
+            ShadowNodeTraits::Trait::ViewKind)) {
+      interpolateViewProps(
+          animationProgress, props, newProps, interpolatedPropsShared);
+    }
+
+    return interpolatedPropsShared;
   };
 
   virtual State::Shared createInitialState(

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

@@ -10,6 +10,8 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/ConcreteState.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/StateData.h>
 
@@ -68,9 +70,11 @@ class ConcreteShadowNode : public BaseShadowNodeT {
   }
 
   static SharedConcreteProps Props(
+      const PropsParserContext &context,
       RawProps const &rawProps,
       SharedProps const &baseProps = nullptr) {
     return std::make_shared<PropsT const>(
+        context,
         baseProps ? static_cast<PropsT const &>(*baseProps) : PropsT(),
         rawProps);
   }

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

@@ -20,8 +20,7 @@ EventDispatcher::EventDispatcher(
     EventQueueProcessor eventProcessor,
     EventBeat::Factory const &synchonousEventBeatFactory,
     EventBeat::Factory const &asynchonousEventBeatFactory,
-    EventBeat::SharedOwnerBox const &ownerBox,
-    bool unbatchedQueuesOnly)
+    EventBeat::SharedOwnerBox const &ownerBox)
     : synchronousUnbatchedQueue_(std::make_unique<UnbatchedEventQueue>(
           eventProcessor,
           synchonousEventBeatFactory(ownerBox))),
@@ -33,8 +32,7 @@ EventDispatcher::EventDispatcher(
           asynchonousEventBeatFactory(ownerBox))),
       asynchronousBatchedQueue_(std::make_unique<BatchedEventQueue>(
           eventProcessor,
-          asynchonousEventBeatFactory(ownerBox))),
-      unbatchedQueuesOnly_(unbatchedQueuesOnly) {}
+          asynchonousEventBeatFactory(ownerBox))) {}
 
 void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
     const {
@@ -48,36 +46,19 @@ void EventDispatcher::dispatchStateUpdate(
 }
 
 void EventDispatcher::dispatchUniqueEvent(RawEvent &&rawEvent) const {
-  if (unbatchedQueuesOnly_) {
-    asynchronousUnbatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
-  } else {
-    asynchronousBatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
-  }
+  asynchronousBatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
 }
 
 const EventQueue &EventDispatcher::getEventQueue(EventPriority priority) const {
-  if (unbatchedQueuesOnly_) {
-    switch (priority) {
-      case EventPriority::SynchronousUnbatched:
-        return *synchronousUnbatchedQueue_;
-      case EventPriority::SynchronousBatched:
-        return *synchronousUnbatchedQueue_;
-      case EventPriority::AsynchronousUnbatched:
-        return *asynchronousUnbatchedQueue_;
-      case EventPriority::AsynchronousBatched:
-        return *asynchronousUnbatchedQueue_;
-    }
-  } else {
-    switch (priority) {
-      case EventPriority::SynchronousUnbatched:
-        return *synchronousUnbatchedQueue_;
-      case EventPriority::SynchronousBatched:
-        return *synchronousBatchedQueue_;
-      case EventPriority::AsynchronousUnbatched:
-        return *asynchronousUnbatchedQueue_;
-      case EventPriority::AsynchronousBatched:
-        return *asynchronousBatchedQueue_;
-    }
+  switch (priority) {
+    case EventPriority::SynchronousUnbatched:
+      return *synchronousUnbatchedQueue_;
+    case EventPriority::SynchronousBatched:
+      return *synchronousBatchedQueue_;
+    case EventPriority::AsynchronousUnbatched:
+      return *asynchronousUnbatchedQueue_;
+    case EventPriority::AsynchronousBatched:
+      return *asynchronousBatchedQueue_;
   }
 }
 

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

@@ -32,8 +32,7 @@ class EventDispatcher {
       EventQueueProcessor eventProcessor,
       EventBeat::Factory const &synchonousEventBeatFactory,
       EventBeat::Factory const &asynchonousEventBeatFactory,
-      EventBeat::SharedOwnerBox const &ownerBox,
-      bool unbatchedQueuesOnly);
+      EventBeat::SharedOwnerBox const &ownerBox);
 
   /*
    * Dispatches a raw event with given priority using event-delivery pipe.
@@ -60,8 +59,6 @@ class EventDispatcher {
   std::unique_ptr<BatchedEventQueue> synchronousBatchedQueue_;
   std::unique_ptr<UnbatchedEventQueue> asynchronousUnbatchedQueue_;
   std::unique_ptr<BatchedEventQueue> asynchronousBatchedQueue_;
-
-  bool const unbatchedQueuesOnly_;
 };
 
 } // namespace react

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

@@ -170,9 +170,6 @@ inline LayoutableShadowNode const &traitCast<LayoutableShadowNode const &>(
     ShadowNode const &shadowNode) {
   bool castable =
       shadowNode.getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  react_native_assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(&shadowNode) != nullptr));
   react_native_assert(castable);
   (void)castable;
   return static_cast<LayoutableShadowNode const &>(shadowNode);
@@ -186,9 +183,6 @@ inline LayoutableShadowNode const *traitCast<LayoutableShadowNode const *>(
   }
   bool castable =
       shadowNode->getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  react_native_assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(shadowNode) != nullptr));
   if (!castable) {
     return nullptr;
   }

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

@@ -13,8 +13,16 @@
 namespace facebook {
 namespace react {
 
-Props::Props(const Props &sourceProps, const RawProps &rawProps)
-    : nativeId(convertRawProp(rawProps, "nativeID", sourceProps.nativeId, {})),
+Props::Props(
+    const PropsParserContext &context,
+    const Props &sourceProps,
+    const RawProps &rawProps)
+    : nativeId(convertRawProp(
+          context,
+          rawProps,
+          "nativeID",
+          sourceProps.nativeId,
+          {})),
       revision(sourceProps.revision + 1)
 #ifdef ANDROID
       ,

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

@@ -9,6 +9,8 @@
 
 #include <folly/dynamic.h>
 
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/Sealable.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
@@ -28,7 +30,10 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   using Shared = std::shared_ptr<Props const>;
 
   Props() = default;
-  Props(Props const &sourceProps, RawProps const &rawProps);
+  Props(
+      const PropsParserContext &context,
+      const Props &sourceProps,
+      RawProps const &rawProps);
   virtual ~Props() = default;
 
   std::string nativeId;

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/ReactPrimitives.h>
+#include <react/utils/ContextContainer.h>
+
+namespace facebook {
+namespace react {
+
+// For props requiring some context to parse, this toolbox can be used.
+// It should be used as infrequently as possible - most props can and should
+// be parsed without any context.
+struct PropsParserContext {
+  // Non-copyable
+  PropsParserContext(const PropsParserContext &) = delete;
+  PropsParserContext &operator=(const PropsParserContext &) = delete;
+
+  SurfaceId const surfaceId;
+  ContextContainer const &contextContainer;
+};
+
+} // namespace react
+} // namespace facebook

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

@@ -47,7 +47,8 @@ RawProps::RawProps(folly::dynamic const &dynamic) noexcept {
   dynamic_ = dynamic;
 }
 
-void RawProps::parse(RawPropsParser const &parser) const noexcept {
+void RawProps::parse(RawPropsParser const &parser, const PropsParserContext &)
+    const noexcept {
   react_native_assert(parser_ == nullptr && "A parser was already assigned.");
   parser_ = &parser;
   parser.preparse(*this);

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

@@ -16,6 +16,7 @@
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
 #include <jsi/jsi.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsPrimitives.h>
 #include <react/renderer/core/RawValue.h>
@@ -74,7 +75,8 @@ class RawProps final {
   RawProps(RawProps const &other) noexcept = delete;
   RawProps &operator=(RawProps const &other) noexcept = delete;
 
-  void parse(RawPropsParser const &parser) const noexcept;
+  void parse(RawPropsParser const &parser, const PropsParserContext &)
+      const noexcept;
 
   /*
    * Deprecated. Do not use.

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

@@ -51,10 +51,18 @@ RawPropsKey::operator std::string() const noexcept {
   return std::string{buffer, length};
 }
 
+static bool areFieldsEqual(char const *lhs, char const *rhs) {
+  if (lhs == nullptr || rhs == nullptr) {
+    return lhs == rhs;
+  }
+  return std::string(lhs) == std::string(rhs);
+}
+
 bool operator==(RawPropsKey const &lhs, RawPropsKey const &rhs) noexcept {
   // Note: We check the name first.
-  return lhs.name == rhs.name && lhs.prefix == rhs.prefix &&
-      lhs.suffix == rhs.suffix;
+  return areFieldsEqual(lhs.name, rhs.name) &&
+      areFieldsEqual(lhs.prefix, rhs.prefix) &&
+      areFieldsEqual(lhs.suffix, rhs.suffix);
 }
 
 bool operator!=(RawPropsKey const &lhs, RawPropsKey const &rhs) noexcept {

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

@@ -10,6 +10,7 @@
 #include <better/map.h>
 #include <better/small_vector.h>
 #include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsKeyMap.h>
@@ -40,8 +41,16 @@ class RawPropsParser final {
         std::is_base_of<Props, PropsT>::value,
         "PropsT must be a descendant of Props");
     RawProps emptyRawProps{};
-    emptyRawProps.parse(*this);
-    PropsT({}, emptyRawProps);
+
+    // Create a stub parser context.
+    // Since this prepares the parser by passing in
+    // empty props, no prop parsers should actually reference the
+    // ContextContainer or SurfaceId here.
+    ContextContainer contextContainer{};
+    PropsParserContext parserContext{-1, contextContainer};
+
+    emptyRawProps.parse(*this, parserContext);
+    PropsT(parserContext, {}, emptyRawProps);
     postPrepare();
   }
 

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

@@ -8,8 +8,6 @@
 #pragma once
 
 #include <folly/dynamic.h>
-#include <react/renderer/core/RawProps.h>
-#include <react/renderer/core/RawValue.h>
 #include <memory>
 #include <string>
 

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

@@ -6,7 +6,6 @@
  */
 
 #include "ShadowNode.h"
-#include "Constants.h"
 #include "DynamicPropsUtilities.h"
 #include "ShadowNodeFragment.h"
 
@@ -39,15 +38,13 @@ SharedProps ShadowNode::propsForClonedShadowNode(
     ShadowNode const &sourceShadowNode,
     Props::Shared const &props) {
 #ifdef ANDROID
-  if (Constants::getPropsForwardingEnabled()) {
-    bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
-    bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
-    if (!hasBeenMounted && sourceNodeHasRawProps && props) {
-      auto &castedProps = const_cast<Props &>(*props);
-      castedProps.rawProps = mergeDynamicProps(
-          sourceShadowNode.getProps()->rawProps, props->rawProps);
-      return props;
-    }
+  bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
+  bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
+  if (!hasBeenMounted && sourceNodeHasRawProps && props) {
+    auto &castedProps = const_cast<Props &>(*props);
+    castedProps.rawProps = mergeDynamicProps(
+        sourceShadowNode.getProps()->rawProps, props->rawProps);
+    return props;
   }
 #endif
   return props ? props : sourceShadowNode.getProps();

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

@@ -240,5 +240,9 @@ ShadowNodeReferenceT traitCast(ShadowNode const &shadowNode);
 template <typename ShadowNodePointerT>
 ShadowNodePointerT traitCast(ShadowNode const *shadowNode);
 
+template <typename ShadowNodePointerT>
+std::shared_ptr<ShadowNodePointerT const> traitCast(
+    std::shared_ptr<ShadowNode const> shadowNode);
+
 } // namespace react
 } // namespace facebook

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

@@ -10,6 +10,7 @@
 #include <memory>
 
 #include <better/mutex.h>
+#include <better/small_vector.h>
 
 #include <react/renderer/core/EventEmitter.h>
 #include <react/renderer/core/ReactPrimitives.h>

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

@@ -21,7 +21,7 @@ class ShadowNodeTraits {
  public:
   /*
    * Underlying type for the traits.
-   * The first 18 bits are reserved for Core.
+   * The first 23 bits are reserved for Core.
    */
   enum Trait : int32_t {
     None = 0,
@@ -88,6 +88,16 @@ class ShadowNodeTraits {
 
     // Inherits 'TextShadowNode'
     Text = 1 << 17,
+
+    // Reserved
+    ReservedTrait1 = 1 << 18,
+    ReservedTrait2 = 1 << 19,
+    ReservedTrait3 = 1 << 20,
+    ReservedTrait4 = 1 << 21,
+    ReservedTrait5 = 1 << 22,
+
+    // Unserved - alias these for local usage
+    UnreservedTrait1 = 1 << 23
   };
 
   /*

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

@@ -10,6 +10,7 @@
 #include <better/optional.h>
 #include <folly/Likely.h>
 #include <folly/dynamic.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
@@ -19,12 +20,18 @@ namespace facebook {
 namespace react {
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, T &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    T &result) {
   result = (T)rawValue;
 }
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    std::vector<T> &result) {
   if (rawValue.hasType<std::vector<RawValue>>()) {
     auto items = (std::vector<RawValue>)rawValue;
     auto length = items.size();
@@ -32,7 +39,7 @@ void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
     result.reserve(length);
     for (size_t i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -42,12 +49,13 @@ void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T>
 void fromRawValue(
+    const PropsParserContext &context,
     RawValue const &rawValue,
     std::vector<std::vector<T>> &result) {
   if (rawValue.hasType<std::vector<std::vector<RawValue>>>()) {
@@ -57,7 +65,7 @@ void fromRawValue(
     result.reserve(length);
     for (int i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -67,12 +75,13 @@ void fromRawValue(
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T, typename U = T>
 T convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     T const &sourceValue,
@@ -92,12 +101,13 @@ T convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return result;
 }
 
 template <typename T>
 static better::optional<T> convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     better::optional<T> const &sourceValue,
@@ -117,7 +127,7 @@ static better::optional<T> convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return better::optional<T>{result};
 }
 

package/ReactCommon/react/renderer/core/tests/ComponentDescriptorTest.cpp

@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+#include <react/renderer/core/PropsParserContext.h>
+
 #include "TestComponent.h"
 
 using namespace facebook::react;
@@ -21,8 +23,11 @@ TEST(ComponentDescriptorTest, createShadowNode) {
   EXPECT_STREQ(descriptor->getComponentName(), TestShadowNode::Name());
   EXPECT_STREQ(descriptor->getComponentName(), "Test");
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
 
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
@@ -52,8 +57,11 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 9,
@@ -73,7 +81,8 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
   EXPECT_EQ(cloned->getSurfaceId(), 1);
   EXPECT_STREQ(cloned->getProps()->nativeId.c_str(), "abc");
 
-  auto clonedButSameProps = descriptor->cloneProps(props, RawProps());
+  auto clonedButSameProps =
+      descriptor->cloneProps(parserContext, props, RawProps());
   EXPECT_NE(clonedButSameProps, props);
 }
 
@@ -83,8 +92,11 @@ TEST(ComponentDescriptorTest, appendChild) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family1 = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 1,