Fix up CSSValueVariant

Author: MatiPl01

packages/react-native-reanimated/Common/cpp/reanimated/CSS/common/values/CSSValueVariant.h

@@ -71,22 +71,42 @@ class CSSValueVariant final : public CSSValue {
   CSSValueVariant() = default;
 
   /**
-   * Construct from any TValue that is or can construct one of the AllowedTypes
+   * Construct from any value that is or can construct one of the AllowedTypes
    * (chooses the first one that matches)
    */
-  template <typename TValue>
-  explicit CSSValueVariant(TValue &&value)
-    requires((std::is_constructible_v<AllowedTypes, TValue> || ...))
+  explicit CSSValueVariant(auto &&value)
+    requires((std::is_constructible_v<AllowedTypes, decltype(value)> || ...))
   { // NOLINT(whitespace/braces)
-    // If TValue exactly matches one of AllowedTypes, store it directly:
+    using ValueType = decltype(value);
+
+    // If value type exactly matches one of AllowedTypes, store it directly:
     if constexpr ((std::is_same_v<
-                       std::remove_reference_t<TValue>,
+                       std::remove_reference_t<ValueType>,
                        AllowedTypes> ||
                    ...)) {
-      storage_ = std::forward<TValue>(value);
+      storage_ = std::forward<ValueType>(value);
     } else {
-      // Otherwise, try each type in turn
-      if (!tryConstruct(std::forward<TValue>(value))) {
+      // Otherwise, try to construct the CSSValue from each type in turn
+      auto tryOne = [&]<typename TCSSValue>() -> bool {
+        if constexpr (std::is_constructible_v<TCSSValue, ValueType>) {
+          if constexpr (ValueConstructibleCSSValue<TCSSValue, ValueType>) {
+            // For construction from a non-jsi::Value, we perform a runtime
+            // canConstruct check only if the type has a canConstruct method.
+            // (this is needed e.g. when different CSS value types can be
+            // constructed from the same value type, like CSSLength and
+            // CSSKeyword)
+            if (!TCSSValue::canConstruct(std::forward<ValueType>(value))) {
+              return false;
+            }
+          }
+          storage_ = TCSSValue(std::forward<ValueType>(value));
+          return true;
+        }
+        return false;
+      };
+
+      // Try constructing with each allowed type until one succeeds
+      if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
         throw std::runtime_error(
             "[Reanimated] No compatible type found for construction");
       }
@@ -98,15 +118,43 @@ class CSSValueVariant final : public CSSValue {
    * (chooses the first one that matches)
    */
   CSSValueVariant(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-    if (!tryConstruct(rt, jsiValue)) {
+    auto tryOne = [&]<typename TCSSValue>() -> bool {
+      // We have to check in a runtime if the type can be constructed from the
+      // provided jsi::Value. The first match will be used to construct the
+      // CSS value.
+      if (!TCSSValue::canConstruct(rt, jsiValue)) {
+        return false;
+      }
+      storage_ = TCSSValue(rt, jsiValue);
+      return true;
+    };
+
+    // Try constructing with each allowed type until one succeeds
+    if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
       throw std::runtime_error(
           "[Reanimated] No compatible type found for construction from: " +
           stringifyJSIValue(rt, jsiValue));
     }
   }
 
+  /**
+   * Construct from folly::dynamic if it matches any AllowedType's constructor
+   * (chooses the first one that matches)
+   */
   explicit CSSValueVariant(const folly::dynamic &value) {
-    if (!tryConstruct(value)) {
+    auto tryOne = [&]<typename TCSSValue>() -> bool {
+      // We have to check in a runtime if the type can be constructed from the
+      // provided folly::dynamic. The first match will be used to construct the
+      // CSS value.
+      if (!TCSSValue::canConstruct(value)) {
+        return false;
+      }
+      storage_ = TCSSValue(value);
+      return true;
+    };
+
+    // Try constructing with each allowed type until one succeeds
+    if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
       throw std::runtime_error(
           "[Reanimated] No compatible type found for construction from: " +
           folly::toJson(value));
@@ -212,70 +260,6 @@ class CSSValueVariant final : public CSSValue {
       const double fallbackInterpolateThreshold) const {
     return (progress < fallbackInterpolateThreshold) ? *this : to;
   }
-
-  /**
-   * Tries to construct type from a given value
-   */
-  template <typename TValue>
-  bool tryConstruct(TValue &&value) {
-    auto tryOne = [&]<typename TCSSValue>() -> bool {
-      if constexpr (std::is_constructible_v<TCSSValue, TValue>) {
-        if constexpr (ValueConstructibleCSSValue<TCSSValue, TValue>) {
-          // For construction from a non-jsi::Value, we perform a runtime
-          // canConstruct check only if the type has a canConstruct method.
-          // (this is needed e.g. when different CSS value types can be
-          // constructed from the same value type, like CSSLength and
-          // CSSKeyword)
-          if (!TCSSValue::canConstruct(std::forward<TValue>(value))) {
-            return false;
-          }
-        }
-        storage_ = TCSSValue(std::forward<TValue>(value));
-        return true;
-      }
-      return false;
-    };
-
-    // Try constructing with each allowed type until one succeeds
-    return (tryOne.template operator()<AllowedTypes>() || ...);
-  }
-
-  /**
-   * Tries to construct type from a given jsi::Value
-   */
-  bool tryConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-    auto tryOne = [&]<typename TCSSValue>() -> bool {
-      // We have to check in a runtime if the type can be constructed from the
-      // provided jsi::Value. The first match will be used to construct the
-      // CSS value.
-      if (!TCSSValue::canConstruct(rt, jsiValue)) {
-        return false;
-      }
-      storage_ = TCSSValue(rt, jsiValue);
-      return true;
-    };
-
-    // Try constructing with each allowed type until one succeeds
-    return (tryOne.template operator()<AllowedTypes>() || ...);
-  }
-
-  /**
-   * Tries to construct type from a given folly::dynamic
-   */
-  bool tryConstruct(const folly::dynamic &value) {
-    auto tryOne = [&]<typename TCSSValue>() -> bool {
-      // We have to check in a runtime if the type can be constructed from the
-      // provided folly::dynamic. The first match will be used to construct the
-      // CSS value.
-      if (!TCSSValue::canConstruct(value)) {
-        return false;
-      }
-      storage_ = TCSSValue(value);
-      return true;
-    };
-    // Try constructing with each allowed type until one succeeds
-    return (tryOne.template operator()<AllowedTypes>() || ...);
-  }
 };
 
 } // namespace reanimated::css