Unparse floating-point flags using absl::HighPrecision.

absl::StrCat(absl::HighPrecision(v)) formats floats and doubles into short
locale-independent strings guaranteed to round-trip, simplifying the
implementation.
PiperOrigin-RevId: 1017360072
diff --git a/absl/flags/BUILD.bazel b/absl/flags/BUILD.bazel
index a43151f..4dbf975 100644
--- a/absl/flags/BUILD.bazel
+++ b/absl/flags/BUILD.bazel
@@ -118,7 +118,6 @@
         "//absl/base:log_severity",
         "//absl/numeric:int128",
         "//absl/strings",
-        "//absl/strings:str_format",
         "//absl/strings:string_view",
         "//absl/types:optional",
     ],
diff --git a/absl/flags/CMakeLists.txt b/absl/flags/CMakeLists.txt
index 788ff0a..57dcc50 100644
--- a/absl/flags/CMakeLists.txt
+++ b/absl/flags/CMakeLists.txt
@@ -92,7 +92,6 @@
     absl::int128
     absl::log_severity
     absl::optional
-    absl::str_format
     absl::string_view
     absl::strings
 )
diff --git a/absl/flags/marshalling.cc b/absl/flags/marshalling.cc
index 99d1edd..cb829a4 100644
--- a/absl/flags/marshalling.cc
+++ b/absl/flags/marshalling.cc
@@ -17,8 +17,6 @@
 
 #include <stddef.h>
 
-#include <cmath>
-#include <limits>
 #include <sstream>
 #include <string>
 #include <type_traits>
@@ -32,7 +30,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
@@ -197,27 +194,8 @@
   return ss.str();
 }
 
-template <typename T>
-std::string UnparseFloatingPointVal(T v) {
-  // digits10 is guaranteed to roundtrip correctly in string -> value -> string
-  // conversions, but may not be enough to represent all the values correctly.
-  std::string digit10_str =
-      absl::StrFormat("%.*g", std::numeric_limits<T>::digits10, v);
-  if (std::isnan(v) || std::isinf(v)) return digit10_str;
-
-  T roundtrip_val = 0;
-  std::string err;
-  if (absl::ParseFlag(digit10_str, &roundtrip_val, &err) &&
-      roundtrip_val == v) {
-    return digit10_str;
-  }
-
-  // max_digits10 is the number of base-10 digits that are necessary to uniquely
-  // represent all distinct values.
-  return absl::StrFormat("%.*g", std::numeric_limits<T>::max_digits10, v);
-}
-std::string Unparse(float v) { return UnparseFloatingPointVal(v); }
-std::string Unparse(double v) { return UnparseFloatingPointVal(v); }
+std::string Unparse(float v) { return absl::StrCat(absl::HighPrecision(v)); }
+std::string Unparse(double v) { return absl::StrCat(absl::HighPrecision(v)); }
 std::string AbslUnparseFlag(absl::string_view v) { return std::string(v); }
 std::string AbslUnparseFlag(const std::vector<std::string>& v) {
   return absl::StrJoin(v, ",");
diff --git a/absl/flags/marshalling_test.cc b/absl/flags/marshalling_test.cc
index 9629744..6870920 100644
--- a/absl/flags/marshalling_test.cc
+++ b/absl/flags/marshalling_test.cc
@@ -1007,6 +1007,18 @@
   EXPECT_EQ(absl::UnparseFlag(value), "0.0123");
   value = -0.71f;
   EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
+  value = 0.0f;
+  EXPECT_EQ(absl::UnparseFlag(value), "0");
+  value = -0.0f;
+  EXPECT_EQ(absl::UnparseFlag(value), "-0");
+  value = std::nanf("");
+  EXPECT_EQ(absl::UnparseFlag(value), "nan");
+  value = -std::nanf("");
+  EXPECT_EQ(absl::UnparseFlag(value), "nan");
+  value = std::numeric_limits<float>::infinity();
+  EXPECT_EQ(absl::UnparseFlag(value), "inf");
+  value = -std::numeric_limits<float>::infinity();
+  EXPECT_EQ(absl::UnparseFlag(value), "-inf");
 }
 
 // --------------------------------------------------------------------
@@ -1024,10 +1036,16 @@
   EXPECT_EQ(absl::UnparseFlag(value), "-0.71");
   value = -0;
   EXPECT_EQ(absl::UnparseFlag(value), "0");
+  value = -0.0;
+  EXPECT_EQ(absl::UnparseFlag(value), "-0");
   value = std::nan("");
   EXPECT_EQ(absl::UnparseFlag(value), "nan");
+  value = -std::nan("");
+  EXPECT_EQ(absl::UnparseFlag(value), "nan");
   value = std::numeric_limits<double>::infinity();
   EXPECT_EQ(absl::UnparseFlag(value), "inf");
+  value = -std::numeric_limits<double>::infinity();
+  EXPECT_EQ(absl::UnparseFlag(value), "-inf");
 }
 
 // --------------------------------------------------------------------
@@ -1161,6 +1179,11 @@
   TestRoundtrip(0.123456e-20f);
   TestRoundtrip(0.1234567e-20f);
   TestRoundtrip(0.12345678e-20f);
+
+  TestRoundtrip(std::numeric_limits<float>::min());
+  TestRoundtrip(std::numeric_limits<float>::max());
+  TestRoundtrip(std::numeric_limits<float>::lowest());
+  TestRoundtrip(std::numeric_limits<float>::denorm_min());
 }
 
 TEST(MarshallingTest, TestDoubleRoundTrip) {
@@ -1217,6 +1240,11 @@
   TestRoundtrip(0.123456789123456e-50);
   TestRoundtrip(0.1234567891234567e-50);
   TestRoundtrip(0.12345678912345678e-50);
+
+  TestRoundtrip(std::numeric_limits<double>::min());
+  TestRoundtrip(std::numeric_limits<double>::max());
+  TestRoundtrip(std::numeric_limits<double>::lowest());
+  TestRoundtrip(std::numeric_limits<double>::denorm_min());
 }
 
 }  // namespace