Round debug float output to 4 decimal places (#55879)

Summary:

Float values in debug layout metrics output (used by Fantom test assertions) are
subject to floating-point precision differences across platforms and compilers
(e.g., `66.6667` vs `66.66666412353516`), causing flaky test comparisons.

This changes `toString(const double&)` in `DebugStringConvertible.cpp` to format
floats with 4 decimal places using `snprintf("%.4f")` and strip trailing zeros,
replacing `double-conversion`'s `ToShortest()`. This is debug-only code (guarded
by `#if RN_DEBUG_STRING_CONVERTIBLE`) so the precision change is safe for all
consumers.

The `double-conversion` dependency is also removed from the BUCK file since it is
no longer used.

Output examples:
- `0.0` → `"0"`
- `100.0` → `"100"`
- `66.66666412353516` → `"66.6667"`
- `1.5` → `"1.5"`
- `33.333333` → `"33.3333"`

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D95041966

Author: NickGerleman

packages/react-native/ReactCommon/react/renderer/components/view/conversions.h

@@ -22,6 +22,7 @@
 #include <react/renderer/css/CSSTransform.h>
 #include <react/renderer/css/CSSTransformOrigin.h>
 #include <react/renderer/css/CSSValueParser.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
 #include <react/renderer/debug/flags.h>
 #include <react/renderer/graphics/BackgroundPosition.h>
 #include <react/renderer/graphics/BackgroundRepeat.h>
@@ -1592,9 +1593,9 @@ inline std::string toString(const std::array<float, N> vec)
 
   s.append("{");
   for (size_t i = 0; i < N - 1; i++) {
-    s.append(std::to_string(vec[i]) + ", ");
+    s.append(toString(vec[i]) + ", ");
   }
-  s.append(std::to_string(vec[N - 1]));
+  s.append(toString(vec[N - 1]));
   s.append("}");
 
   return s;
@@ -1647,9 +1648,9 @@ inline std::string toString(const yoga::Style::Length &length)
   } else if (length.isAuto()) {
     return "auto";
   } else if (length.isPoints()) {
-    return std::to_string(length.value().unwrap());
+    return toString(length.value().unwrap());
   } else if (length.isPercent()) {
-    return std::to_string(length.value().unwrap()) + "%";
+    return toString(length.value().unwrap()) + "%";
   } else {
     return "unknown";
   }
@@ -1662,9 +1663,9 @@ inline std::string toString(const yoga::Style::SizeLength &length)
   } else if (length.isAuto()) {
     return "auto";
   } else if (length.isPoints()) {
-    return std::to_string(length.value().unwrap());
+    return toString(length.value().unwrap());
   } else if (length.isPercent()) {
-    return std::to_string(length.value().unwrap()) + "%";
+    return toString(length.value().unwrap()) + "%";
   } else if (length.isMaxContent()) {
     return "max-content";
   } else if (length.isFitContent()) {
@@ -1682,7 +1683,7 @@ inline std::string toString(const yoga::FloatOptional &value)
     return "undefined";
   }
 
-  return std::to_string(value.unwrap());
+  return toString(value.unwrap());
 }
 
 inline std::string toString(const LayoutConformance &value)
@@ -1698,14 +1699,10 @@ inline std::string toString(const LayoutConformance &value)
 inline std::string toString(const std::array<Float, 16> &m)
 {
   std::string result;
-  result += "[ " + std::to_string(m[0]) + " " + std::to_string(m[1]) + " " + std::to_string(m[2]) + " " +
-      std::to_string(m[3]) + " ]\n";
-  result += "[ " + std::to_string(m[4]) + " " + std::to_string(m[5]) + " " + std::to_string(m[6]) + " " +
-      std::to_string(m[7]) + " ]\n";
-  result += "[ " + std::to_string(m[8]) + " " + std::to_string(m[9]) + " " + std::to_string(m[10]) + " " +
-      std::to_string(m[11]) + " ]\n";
-  result += "[ " + std::to_string(m[12]) + " " + std::to_string(m[13]) + " " + std::to_string(m[14]) + " " +
-      std::to_string(m[15]) + " ]";
+  result += "[ " + toString(m[0]) + " " + toString(m[1]) + " " + toString(m[2]) + " " + toString(m[3]) + " ]\n";
+  result += "[ " + toString(m[4]) + " " + toString(m[5]) + " " + toString(m[6]) + " " + toString(m[7]) + " ]\n";
+  result += "[ " + toString(m[8]) + " " + toString(m[9]) + " " + toString(m[10]) + " " + toString(m[11]) + " ]\n";
+  result += "[ " + toString(m[12]) + " " + toString(m[13]) + " " + toString(m[14]) + " " + toString(m[15]) + " ]";
   return result;
 }
 
@@ -1722,48 +1719,48 @@ inline std::string toString(const Transform &transform)
 
     switch (operation.type) {
       case TransformOperationType::Perspective: {
-        result += "{\"perspective\": " + std::to_string(operation.x.value) + "}";
+        result += "{\"perspective\": " + toString(operation.x.value) + "}";
         break;
       }
       case TransformOperationType::Rotate: {
         if (operation.x.value != 0 && operation.y.value == 0 && operation.z.value == 0) {
-          result += R"({"rotateX": ")" + std::to_string(operation.x.value) + "rad\"}";
+          result += R"({"rotateX": ")" + toString(operation.x.value) + "rad\"}";
         } else if (operation.x.value == 0 && operation.y.value != 0 && operation.z.value == 0) {
-          result += R"({"rotateY": ")" + std::to_string(operation.y.value) + "rad\"}";
+          result += R"({"rotateY": ")" + toString(operation.y.value) + "rad\"}";
         } else if (operation.x.value == 0 && operation.y.value == 0 && operation.z.value != 0) {
-          result += R"({"rotateZ": ")" + std::to_string(operation.z.value) + "rad\"}";
+          result += R"({"rotateZ": ")" + toString(operation.z.value) + "rad\"}";
         }
         break;
       }
       case TransformOperationType::Scale: {
         if (operation.x.value == operation.y.value && operation.x.value == operation.z.value) {
-          result += "{\"scale\": " + std::to_string(operation.x.value) + "}";
+          result += "{\"scale\": " + toString(operation.x.value) + "}";
         } else if (operation.y.value == 1 && operation.z.value == 1) {
-          result += "{\"scaleX\": " + std::to_string(operation.x.value) + "}";
+          result += "{\"scaleX\": " + toString(operation.x.value) + "}";
         } else if (operation.x.value == 1 && operation.z.value == 1) {
-          result += "{\"scaleY\": " + std::to_string(operation.y.value) + "}";
+          result += "{\"scaleY\": " + toString(operation.y.value) + "}";
         } else if (operation.x.value == 1 && operation.y.value == 1) {
-          result += "{\"scaleZ\": " + std::to_string(operation.z.value) + "}";
+          result += "{\"scaleZ\": " + toString(operation.z.value) + "}";
         }
         break;
       }
       case TransformOperationType::Translate: {
         if (operation.x.value != 0 && operation.y.value != 0 && operation.z.value == 0) {
           result += "{\"translate\": [";
-          result += std::to_string(operation.x.value) + ", " + std::to_string(operation.y.value);
+          result += toString(operation.x.value) + ", " + toString(operation.y.value);
           result += "]}";
         } else if (operation.x.value != 0 && operation.y.value == 0) {
-          result += "{\"translateX\": " + std::to_string(operation.x.value) + "}";
+          result += "{\"translateX\": " + toString(operation.x.value) + "}";
         } else if (operation.x.value == 0 && operation.y.value != 0) {
-          result += "{\"translateY\": " + std::to_string(operation.y.value) + "}";
+          result += "{\"translateY\": " + toString(operation.y.value) + "}";
         }
         break;
       }
       case TransformOperationType::Skew: {
         if (operation.x.value != 0 && operation.y.value == 0) {
-          result += R"({"skewX": ")" + std::to_string(operation.x.value) + "rad\"}";
+          result += R"({"skewX": ")" + toString(operation.x.value) + "rad\"}";
         } else if (operation.x.value == 0 && operation.y.value != 0) {
-          result += R"({"skewY": ")" + std::to_string(operation.y.value) + "rad\"}";
+          result += R"({"skewY": ")" + toString(operation.y.value) + "rad\"}";
         }
         break;
       }

packages/react-native/ReactCommon/react/renderer/debug/DebugStringConvertible.cpp

@@ -7,11 +7,9 @@
 
 #include "DebugStringConvertible.h"
 
-#include <array>
-#include <cinttypes>
-#include <cstdio>
-
-#include <double-conversion/double-conversion.h>
+#include <cstdint>
+#include <iomanip>
+#include <sstream>
 
 namespace facebook::react {
 
@@ -129,33 +127,30 @@ SharedDebugStringConvertibleList DebugStringConvertible::getDebugProps() const {
  * `toString`-family implementation.
  */
 std::string toString(const double& value) {
-  // Format taken from folly's toString
-  static double_conversion::DoubleToStringConverter conv(
-      0,
-      "Infinity",
-      "NaN",
-      'E',
-      -6, // detail::kConvMaxDecimalInShortestLow,
-      21, // detail::kConvMaxDecimalInShortestHigh,
-      6, // max leading padding zeros
-      1); // max trailing padding zeros
-  std::array<char, 256> buffer{};
-  double_conversion::StringBuilder builder(buffer.data(), buffer.size());
-  conv.ToShortest(value, &builder);
-  return builder.Finalize();
+  std::ostringstream stream;
+  stream << std::fixed << std::setprecision(4) << value;
+  std::string result = stream.str();
+
+  // Strip trailing zeros and unnecessary decimal point
+  if (auto dotPos = result.find('.'); dotPos != std::string::npos) {
+    auto lastNonZero = result.find_last_not_of('0');
+    if (lastNonZero == dotPos) {
+      result.erase(dotPos);
+    } else {
+      result.erase(lastNonZero + 1);
+    }
+  }
+  return result;
 }
 
 std::string toString(const void* value) {
   if (value == nullptr) {
     return "null";
   }
-  std::array<char, 20> buffer{};
-  std::snprintf(
-      buffer.data(),
-      buffer.size(),
-      "0x%" PRIXPTR,
-      reinterpret_cast<uintptr_t>(value));
-  return buffer.data();
+  std::ostringstream stream;
+  stream << "0x" << std::uppercase << std::hex
+         << reinterpret_cast<uintptr_t>(value);
+  return stream.str();
 }
 
 #endif