Revert D38938632: Add key to prop conversion errors

Differential Revision:
D38938632 (7909b913ef)

Original commit changeset: 1dc9a544ca67

Original Phabricator Diff: D38938632 (7909b913ef)

fbshipit-source-id: ddfe699ebf2ec7b118079d9ecb9ce77f2bf4a2ac

ReactCommon/react/renderer/core/RawValue.h

@@ -96,7 +96,7 @@ class RawValue {
    * Casts the value to a specified type.
    */
   template <typename T>
-  explicit operator T() const {
+  explicit operator T() const noexcept {
     return castValue(dynamic_, (T *)nullptr);
   }
 
@@ -212,36 +212,40 @@ class RawValue {
     return RawValue(dynamic);
   }
 
-  static bool castValue(const folly::dynamic &dynamic, bool *type) {
+  static bool castValue(const folly::dynamic &dynamic, bool *type) noexcept {
     return dynamic.getBool();
   }
 
-  static int castValue(const folly::dynamic &dynamic, int *type) {
+  static int castValue(const folly::dynamic &dynamic, int *type) noexcept {
     return static_cast<int>(dynamic.asInt());
   }
 
-  static int64_t castValue(const folly::dynamic &dynamic, int64_t *type) {
+  static int64_t castValue(
+      const folly::dynamic &dynamic,
+      int64_t *type) noexcept {
     return dynamic.asInt();
   }
 
-  static float castValue(const folly::dynamic &dynamic, float *type) {
+  static float castValue(const folly::dynamic &dynamic, float *type) noexcept {
     return static_cast<float>(dynamic.asDouble());
   }
 
-  static double castValue(const folly::dynamic &dynamic, double *type) {
+  static double castValue(
+      const folly::dynamic &dynamic,
+      double *type) noexcept {
     return dynamic.asDouble();
   }
 
   static std::string castValue(
       const folly::dynamic &dynamic,
-      std::string *type) {
+      std::string *type) noexcept {
     return dynamic.getString();
   }
 
   template <typename T>
   static std::vector<T> castValue(
       const folly::dynamic &dynamic,
-      std::vector<T> *type) {
+      std::vector<T> *type) noexcept {
     react_native_assert(dynamic.isArray());
     auto result = std::vector<T>{};
     result.reserve(dynamic.size());
@@ -254,7 +258,7 @@ class RawValue {
   template <typename T>
   static std::vector<std::vector<T>> castValue(
       const folly::dynamic &dynamic,
-      std::vector<std::vector<T>> *type) {
+      std::vector<std::vector<T>> *type) noexcept {
     react_native_assert(dynamic.isArray());
     auto result = std::vector<std::vector<T>>{};
     result.reserve(dynamic.size());
@@ -267,7 +271,7 @@ class RawValue {
   template <typename T>
   static butter::map<std::string, T> castValue(
       const folly::dynamic &dynamic,
-      butter::map<std::string, T> *type) {
+      butter::map<std::string, T> *type) noexcept {
     react_native_assert(dynamic.isObject());
     auto result = butter::map<std::string, T>{};
     for (const auto &item : dynamic.items()) {

ReactCommon/react/renderer/core/propsConversions.h

@@ -10,9 +10,9 @@
 #include <optional>
 
 #include <folly/Likely.h>
+#include <folly/dynamic.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
-#include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/graphics/conversions.h>
@@ -43,18 +43,18 @@ template <typename T>
 void fromRawValue(
     const PropsParserContext &context,
     RawValue const &rawValue,
-    T &result) {
-  result = (T)rawValue;
+    std::optional<T> &result) {
+  T res{};
+  fromRawValue(context, rawValue, res);
+  result = std::optional<T>(res);
 }
 
 template <typename T>
 void fromRawValue(
     const PropsParserContext &context,
     RawValue const &rawValue,
-    std::optional<T> &result) {
-  T resultValue;
-  fromRawValue(context, rawValue, resultValue);
-  result = std::optional<T>{std::move(resultValue)};
+    T &result) {
+  result = (T)rawValue;
 }
 
 template <typename T>
@@ -119,6 +119,7 @@ T convertRawProp(
     char const *namePrefix = nullptr,
     char const *nameSuffix = nullptr) {
   const auto *rawValue = rawProps.at(name, namePrefix, nameSuffix);
+
   if (LIKELY(rawValue == nullptr)) {
     return sourceValue;
   }
@@ -129,18 +130,35 @@ T convertRawProp(
     return defaultValue;
   }
 
-  try {
-    T result;
-    fromRawValue(context, *rawValue, result);
-    return result;
-  } catch (const std::exception &e) {
-    // In case of errors, log the error and fall back to the default
-    RawPropsKey key{namePrefix, name, nameSuffix};
-    // TODO: report this using ErrorUtils so it's more visible to the user
-    LOG(ERROR) << "Error while converting prop '"
-               << static_cast<std::string>(key) << "': " << e.what();
+  T result;
+  fromRawValue(context, *rawValue, result);
+  return result;
+}
+
+template <typename T>
+static std::optional<T> convertRawProp(
+    const PropsParserContext &context,
+    RawProps const &rawProps,
+    char const *name,
+    std::optional<T> const &sourceValue,
+    std::optional<T> const &defaultValue,
+    char const *namePrefix = nullptr,
+    char const *nameSuffix = nullptr) {
+  const auto *rawValue = rawProps.at(name, namePrefix, nameSuffix);
+
+  if (LIKELY(rawValue == nullptr)) {
+    return sourceValue;
+  }
+
+  // Special case: `null` always means `the prop was removed, use default
+  // value`.
+  if (UNLIKELY(!rawValue->hasValue())) {
     return defaultValue;
   }
+
+  T result;
+  fromRawValue(context, *rawValue, result);
+  return std::optional<T>{result};
 }
 
 } // namespace react