Deprecate tsl::strings::Hex in favor of absl::Hex.

PiperOrigin-RevId: 751542019

Author: allanrenucci

tsl/platform/BUILD

@@ -773,7 +773,9 @@ cc_library(
     deps = [
         ":numbers",
         ":stringpiece",
+        "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/meta:type_traits",
+        "@com_google_absl//absl/strings",
         "@xla//xla/tsl/platform:logging",
         "@xla//xla/tsl/platform:macros",
         "@xla//xla/tsl/platform:types",
@@ -1365,6 +1367,7 @@ tsl_cc_test(
         "strcat_test.cc",
     ],
     deps = [
+        ":bfloat16",
         ":strcat",
         ":stringprintf",
         "@com_google_absl//absl/strings",

tsl/platform/strcat.cc

@@ -32,7 +32,7 @@ AlphaNum::AlphaNum(Hex hex) {
   char *const end = &digits_[kFastToBufferSize];
   char *writer = end;
   uint64 value = hex.value;
-  uint64 width = hex.spec;
+  uint64 width = hex.width;
   // We accomplish minimum width by OR'ing in 0x10000 to the user's value,
   // where 0x10000 is the smallest hex number that is as wide as the user
   // asked for.

tsl/platform/strcat.h

@@ -22,6 +22,9 @@ limitations under the License.
 
 #include <string>
 
+#include "absl/base/attributes.h"
+#include "absl/base/macros.h"
+#include "absl/strings/str_cat.h"
 #include "xla/tsl/platform/macros.h"
 #include "xla/tsl/platform/types.h"
 #include "tsl/platform/numbers.h"
@@ -52,47 +55,30 @@ limitations under the License.
 // You can convert to Hexadecimal output rather than Decimal output using Hex.
 // To do this, pass strings::Hex(my_int) as a parameter to StrCat. You may
 // specify a minimum field width using a separate parameter, so the equivalent
-// of Printf("%04x", my_int) is StrCat(Hex(my_int, strings::kZeroPad4))
+// of Printf("%04x", my_int) is StrCat(Hex(my_int, absl::kZeroPad4))
 //
 // This class has implicit constructors.
 namespace tsl {
 namespace strings {
 
-enum PadSpec {
-  kNoPad = 1,
-  kZeroPad2,
-  kZeroPad3,
-  kZeroPad4,
-  kZeroPad5,
-  kZeroPad6,
-  kZeroPad7,
-  kZeroPad8,
-  kZeroPad9,
-  kZeroPad10,
-  kZeroPad11,
-  kZeroPad12,
-  kZeroPad13,
-  kZeroPad14,
-  kZeroPad15,
-  kZeroPad16
-};
-
-struct Hex {
-  uint64 value;
-  enum PadSpec spec;
-  template <class Int>
-  explicit Hex(Int v, PadSpec s = kNoPad) : spec(s) {
-    // Prevent sign-extension by casting integers to
-    // their unsigned counterparts.
-    static_assert(
-        sizeof(v) == 1 || sizeof(v) == 2 || sizeof(v) == 4 || sizeof(v) == 8,
-        "Unknown integer type");
-    value = sizeof(v) == 1   ? static_cast<uint8>(v)
-            : sizeof(v) == 2 ? static_cast<uint16>(v)
-            : sizeof(v) == 4 ? static_cast<uint32>(v)
-                             : static_cast<uint64>(v);
-  }
-};
+using PadSpec ABSL_DEPRECATE_AND_INLINE() = absl::PadSpec;
+using absl::kNoPad;
+using absl::kZeroPad10;
+using absl::kZeroPad11;
+using absl::kZeroPad12;
+using absl::kZeroPad13;
+using absl::kZeroPad14;
+using absl::kZeroPad15;
+using absl::kZeroPad16;
+using absl::kZeroPad2;
+using absl::kZeroPad3;
+using absl::kZeroPad4;
+using absl::kZeroPad5;
+using absl::kZeroPad6;
+using absl::kZeroPad7;
+using absl::kZeroPad8;
+using absl::kZeroPad9;
+using Hex ABSL_DEPRECATE_AND_INLINE() = absl::Hex;
 
 class AlphaNum {
   // NOLINTBEGIN(google-explicit-constructor)
@@ -121,10 +107,10 @@ class AlphaNum {
 
   AlphaNum(Hex hex);  // NOLINT(runtime/explicit)
 
-  AlphaNum(const char *c_str) : piece_(c_str) {}   // NOLINT(runtime/explicit)
+  AlphaNum(const char *c_str) : piece_(c_str) {}  // NOLINT(runtime/explicit)
   AlphaNum(const absl::string_view &pc)
-      : piece_(pc) {}                              // NOLINT(runtime/explicit)
-  AlphaNum(const std::string &str)                 // NOLINT(runtime/explicit)
+      : piece_(pc) {}               // NOLINT(runtime/explicit)
+  AlphaNum(const std::string &str)  // NOLINT(runtime/explicit)
       : piece_(str) {}
   AlphaNum(const tstring &str)  // NOLINT(runtime/explicit)
       : piece_(str) {}

tsl/platform/strcat_test.cc

@@ -15,11 +15,15 @@ limitations under the License.
 
 #include "tsl/platform/strcat.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <string>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "xla/tsl/platform/test.h"
 #include "xla/tsl/platform/types.h"
+#include "tsl/platform/bfloat16.h"
 #include "tsl/platform/stringprintf.h"
 
 #ifdef _MSC_VER
@@ -336,35 +340,35 @@ TEST(StrAppend, Death) {
 }
 
 static void CheckHex64(uint64 v) {
-  string actual = StrCat(Hex(v, kZeroPad16));
+  string actual = strings::StrCat(absl::Hex(v, absl::kZeroPad16));
   string expected = Printf("%016llx", static_cast<unsigned long long>(v));
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 
-  actual = StrCat(Hex(v, kZeroPad8));
+  actual = strings::StrCat(absl::Hex(v, absl::kZeroPad8));
   expected = Printf("%08llx", static_cast<unsigned long long>(v));
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 
-  actual = StrCat(Hex(v));
+  actual = strings::StrCat(absl::Hex(v));
   expected = Printf("%llx", static_cast<unsigned long long>(v));
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 }
 
 static void CheckHex32(uint32 v) {
-  string actual = StrCat(Hex(v, kZeroPad8));
+  string actual = strings::StrCat(absl::Hex(v, absl::kZeroPad8));
   string expected = Printf("%08x", v);
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 
-  actual = StrCat(Hex(v));
+  actual = strings::StrCat(absl::Hex(v));
   expected = Printf("%x", v);
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 }
 
 static void CheckHexSigned32(int32_t v) {
-  string actual = StrCat(Hex(v, kZeroPad8));
+  string actual = strings::StrCat(absl::Hex(v, absl::kZeroPad8));
   string expected = Printf("%08x", v);
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 
-  actual = StrCat(Hex(v));
+  actual = strings::StrCat(absl::Hex(v));
   expected = Printf("%x", v);
   EXPECT_EQ(expected, actual) << " decimal value " << v;
 }
@@ -381,10 +385,10 @@ static void TestFastPrints() {
   CheckHex32(0x12345678);
 
   int8_t minus_one_8bit = -1;
-  EXPECT_EQ("ff", StrCat(Hex(minus_one_8bit)));
+  EXPECT_EQ("ff", strings::StrCat(absl::Hex(minus_one_8bit)));
 
   int16_t minus_one_16bit = -1;
-  EXPECT_EQ("ffff", StrCat(Hex(minus_one_16bit)));
+  EXPECT_EQ("ffff", strings::StrCat(absl::Hex(minus_one_16bit)));
 }
 
 TEST(Numbers, TestFunctionsMovedOverFromNumbersMain) { TestFastPrints(); }