From f2c6fbc11ebdf6a1e546ef7cabd4d6df5749fb29 Mon Sep 17 00:00:00 2001
From: "A. Unique TensorFlower" <gardener@tensorflow.org>
Date: Wed, 31 Dec 2025 18:47:01 -0800
Subject: [PATCH] Automated Code Change

PiperOrigin-RevId: 850864594
---
 tsl/platform/abi.cc                       |  2 +-
 tsl/platform/base64.cc                    | 13 ++---
 tsl/platform/coding.cc                    | 48 +++++++++----------
 tsl/platform/coding.h                     | 38 ++++++++-------
 tsl/platform/cpu_info.cc                  | 26 +++++-----
 tsl/platform/demangle.h                   |  4 +-
 tsl/platform/hash.cc                      | 24 ++++++----
 tsl/platform/hash.h                       | 24 +++++-----
 tsl/platform/hash_test.cc                 | 14 +++---
 tsl/platform/host_info.h                  |  4 +-
 tsl/platform/human_readable_json.h        |  4 +-
 tsl/platform/integral_types_test.cc       | 14 +++---
 tsl/platform/null_file_system.h           | 34 ++++++-------
 tsl/platform/numbers_test.cc              | 20 ++++----
 tsl/platform/path.cc                      | 37 ++++++++-------
 tsl/platform/protobuf_util.cc             |  2 +-
 tsl/platform/random.cc                    |  6 +--
 tsl/platform/random.h                     |  6 +--
 tsl/platform/random_test.cc               |  4 +-
 tsl/platform/raw_coding.h                 | 28 +++++------
 tsl/platform/retrying_file_system.h       | 51 ++++++++++----------
 tsl/platform/retrying_file_system_test.cc | 58 ++++++++++++-----------
 tsl/platform/scanner_test.cc              |  4 +-
 tsl/platform/snappy.h                     |  4 +-
 tsl/platform/str_util.cc                  | 17 +++----
 tsl/platform/str_util.h                   | 23 +++++----
 tsl/platform/str_util_test.cc             | 40 ++++++++--------
 tsl/platform/stringpiece_test.cc          |  6 +--
 tsl/platform/stringprintf_test.cc         | 34 ++++++-------
 tsl/platform/tracing.h                    | 12 ++---
 30 files changed, 312 insertions(+), 289 deletions(-)

diff --git a/tsl/platform/abi.cc b/tsl/platform/abi.cc
index 9e969f312..889e02f19 100644
--- a/tsl/platform/abi.cc
+++ b/tsl/platform/abi.cc
@@ -39,7 +39,7 @@ extern "C" char* __unDName(char* output_string, const char* name,
 namespace tsl {
 namespace port {
 
-string MaybeAbiDemangle(const char* name) {
+std::string MaybeAbiDemangle(const char* name) {
 #if defined(_MSC_VER)
   std::unique_ptr<char> demangled{__unDName(nullptr, name, 0, std::malloc,
                                             std::free,
diff --git a/tsl/platform/base64.cc b/tsl/platform/base64.cc
index 7c21d29c9..fb4887bec 100644
--- a/tsl/platform/base64.cc
+++ b/tsl/platform/base64.cc
@@ -28,7 +28,7 @@ namespace tsl {
 namespace {
 // This array must have signed type.
 // clang-format off
-constexpr int8 kBase64Bytes[128] = {
+constexpr int8_t kBase64Bytes[128] = {
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
      -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
@@ -50,7 +50,7 @@ constexpr char kPadChar = '=';
 // Converts a char (8 bits) into a 6-bit value for decoding. If the input char
 // is invalid for base64 encoding, the return value has at least its upper 25
 // bits set.
-inline uint32 Convert(char x) {
+inline uint32_t Convert(char x) {
   // If x < 128, then we look up x in the table. If x is valid, then the table
   // will have a value <= 0x3F, otherwise the table will have -1. If x >= 128,
   // we still do some table lookup, but the value is ignored since we explicitly
@@ -59,13 +59,14 @@ inline uint32 Convert(char x) {
   const int8_t y = kBase64Bytes[x & 0x7F] | (x & 0x80);
   // Casting from int8 to int32 preserves sign by sign extension. If y was
   // negative, at least its 25 high bits of the return value are set.
-  const int32_t z = static_cast<int32>(y);
-  return static_cast<uint32>(z);
+  const int32_t z = static_cast<int32_t>(y);
+  return static_cast<uint32_t>(z);
 }
 
 absl::Status DecodeThreeChars(const char* codes, char* result) {
-  const uint32 packed = (Convert(codes[0]) << 18) | (Convert(codes[1]) << 12) |
-                        (Convert(codes[2]) << 6) | (Convert(codes[3]));
+  const uint32_t packed = (Convert(codes[0]) << 18) |
+                          (Convert(codes[1]) << 12) | (Convert(codes[2]) << 6) |
+                          (Convert(codes[3]));
   // Convert() return value has upper 25 bits set if input is invalid.
   // Therefore `packed` has high bits set iff at least one of code is invalid.
   if (TF_PREDICT_FALSE((packed & 0xFF000000) != 0)) {
diff --git a/tsl/platform/coding.cc b/tsl/platform/coding.cc
index d83312b1c..ec5189f7a 100644
--- a/tsl/platform/coding.cc
+++ b/tsl/platform/coding.cc
@@ -23,7 +23,7 @@ limitations under the License.
 namespace tsl {
 namespace core {
 
-void EncodeFixed16(char* buf, uint16 value) {
+void EncodeFixed16(char* buf, uint16_t value) {
   if (port::kLittleEndian) {
     memcpy(buf, &value, sizeof(value));
   } else {
@@ -32,7 +32,7 @@ void EncodeFixed16(char* buf, uint16 value) {
   }
 }
 
-void EncodeFixed32(char* buf, uint32 value) {
+void EncodeFixed32(char* buf, uint32_t value) {
   if (port::kLittleEndian) {
     memcpy(buf, &value, sizeof(value));
   } else {
@@ -43,7 +43,7 @@ void EncodeFixed32(char* buf, uint32 value) {
   }
 }
 
-void EncodeFixed64(char* buf, uint64 value) {
+void EncodeFixed64(char* buf, uint64_t value) {
   if (port::kLittleEndian) {
     memcpy(buf, &value, sizeof(value));
   } else {
@@ -58,25 +58,25 @@ void EncodeFixed64(char* buf, uint64 value) {
   }
 }
 
-void PutFixed16(string* dst, uint16 value) {
+void PutFixed16(std::string* dst, uint16_t value) {
   char buf[sizeof(value)];
   EncodeFixed16(buf, value);
   dst->append(buf, sizeof(buf));
 }
 
-void PutFixed32(string* dst, uint32 value) {
+void PutFixed32(std::string* dst, uint32_t value) {
   char buf[sizeof(value)];
   EncodeFixed32(buf, value);
   dst->append(buf, sizeof(buf));
 }
 
-void PutFixed64(string* dst, uint64 value) {
+void PutFixed64(std::string* dst, uint64_t value) {
   char buf[sizeof(value)];
   EncodeFixed64(buf, value);
   dst->append(buf, sizeof(buf));
 }
 
-char* EncodeVarint32(char* dst, uint32 v) {
+char* EncodeVarint32(char* dst, uint32_t v) {
   // Operate on characters as unsigneds
   unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
   static const int B = 128;
@@ -104,19 +104,19 @@ char* EncodeVarint32(char* dst, uint32 v) {
   return reinterpret_cast<char*>(ptr);
 }
 
-void PutVarint32(string* dst, uint32 v) {
+void PutVarint32(std::string* dst, uint32_t v) {
   char buf[5];
   char* ptr = EncodeVarint32(buf, v);
   dst->append(buf, ptr - buf);
 }
 
-void PutVarint32(tstring* dst, uint32 v) {
+void PutVarint32(tstring* dst, uint32_t v) {
   char buf[5];
   char* ptr = EncodeVarint32(buf, v);
   dst->append(buf, ptr - buf);
 }
 
-char* EncodeVarint64(char* dst, uint64 v) {
+char* EncodeVarint64(char* dst, uint64_t v) {
   static const int B = 128;
   unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
   while (v >= B) {
@@ -127,13 +127,13 @@ char* EncodeVarint64(char* dst, uint64 v) {
   return reinterpret_cast<char*>(ptr);
 }
 
-void PutVarint64(string* dst, uint64 v) {
+void PutVarint64(std::string* dst, uint64_t v) {
   char buf[10];
   char* ptr = EncodeVarint64(buf, v);
   dst->append(buf, ptr - buf);
 }
 
-void PutVarint64(tstring* dst, uint64 v) {
+void PutVarint64(tstring* dst, uint64_t v) {
   char buf[10];
   char* ptr = EncodeVarint64(buf, v);
   dst->append(buf, ptr - buf);
@@ -148,9 +148,9 @@ int VarintLength(uint64_t v) {
   return len;
 }
 
-const char* GetVarint32Ptr(const char* p, const char* limit, uint32* value) {
+const char* GetVarint32Ptr(const char* p, const char* limit, uint32_t* value) {
   if (p < limit) {
-    uint32 result = *(reinterpret_cast<const unsigned char*>(p));
+    uint32_t result = *(reinterpret_cast<const unsigned char*>(p));
     if ((result & 128) == 0) {
       *value = result;
       return p + 1;
@@ -160,10 +160,10 @@ const char* GetVarint32Ptr(const char* p, const char* limit, uint32* value) {
 }
 
 const char* GetVarint32PtrFallback(const char* p, const char* limit,
-                                   uint32* value) {
-  uint32 result = 0;
-  for (uint32 shift = 0; shift <= 28 && p < limit; shift += 7) {
-    uint32 byte = *(reinterpret_cast<const unsigned char*>(p));
+                                   uint32_t* value) {
+  uint32_t result = 0;
+  for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
+    uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));
     p++;
     if (byte & 128) {
       // More bytes are present
@@ -177,7 +177,7 @@ const char* GetVarint32PtrFallback(const char* p, const char* limit,
   return nullptr;
 }
 
-bool GetVarint32(absl::string_view* input, uint32* value) {
+bool GetVarint32(absl::string_view* input, uint32_t* value) {
   const char* p = input->data();
   const char* limit = p + input->size();
   const char* q = GetVarint32Ptr(p, limit, value);
@@ -189,10 +189,10 @@ bool GetVarint32(absl::string_view* input, uint32* value) {
   }
 }
 
-const char* GetVarint64Ptr(const char* p, const char* limit, uint64* value) {
-  uint64 result = 0;
-  for (uint32 shift = 0; shift <= 63 && p < limit; shift += 7) {
-    uint64 byte = *(reinterpret_cast<const unsigned char*>(p));
+const char* GetVarint64Ptr(const char* p, const char* limit, uint64_t* value) {
+  uint64_t result = 0;
+  for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {
+    uint64_t byte = *(reinterpret_cast<const unsigned char*>(p));
     p++;
     if (byte & 128) {
       // More bytes are present
@@ -206,7 +206,7 @@ const char* GetVarint64Ptr(const char* p, const char* limit, uint64* value) {
   return nullptr;
 }
 
-bool GetVarint64(absl::string_view* input, uint64* value) {
+bool GetVarint64(absl::string_view* input, uint64_t* value) {
   const char* p = input->data();
   const char* limit = p + input->size();
   const char* q = GetVarint64Ptr(p, limit, value);
diff --git a/tsl/platform/coding.h b/tsl/platform/coding.h
index ddd372b1c..a584f51f9 100644
--- a/tsl/platform/coding.h
+++ b/tsl/platform/coding.h
@@ -37,32 +37,34 @@ static const int kMaxVarint64Bytes = 10;
 
 // Lower-level versions of Put... that write directly into a character buffer
 // REQUIRES: dst has enough space for the value being written
-extern void EncodeFixed16(char* dst, uint16 value);
-extern void EncodeFixed32(char* dst, uint32 value);
-extern void EncodeFixed64(char* dst, uint64 value);
-extern void PutFixed16(string* dst, uint16 value);
-extern void PutFixed32(string* dst, uint32 value);
-extern void PutFixed64(string* dst, uint64 value);
+extern void EncodeFixed16(char* dst, uint16_t value);
+extern void EncodeFixed32(char* dst, uint32_t value);
+extern void EncodeFixed64(char* dst, uint64_t value);
+extern void PutFixed16(std::string* dst, uint16_t value);
+extern void PutFixed32(std::string* dst, uint32_t value);
+extern void PutFixed64(std::string* dst, uint64_t value);
 
-extern void PutVarint32(string* dst, uint32 value);
-extern void PutVarint64(string* dst, uint64 value);
+extern void PutVarint32(std::string* dst, uint32_t value);
+extern void PutVarint64(std::string* dst, uint64_t value);
 
-extern void PutVarint32(tstring* dst, uint32 value);
-extern void PutVarint64(tstring* dst, uint64 value);
+extern void PutVarint32(tstring* dst, uint32_t value);
+extern void PutVarint64(tstring* dst, uint64_t value);
 
-extern bool GetVarint32(absl::string_view* input, uint32* value);
-extern bool GetVarint64(absl::string_view* input, uint64* value);
+extern bool GetVarint32(absl::string_view* input, uint32_t* value);
+extern bool GetVarint64(absl::string_view* input, uint64_t* value);
 
-extern const char* GetVarint32Ptr(const char* p, const char* limit, uint32* v);
-extern const char* GetVarint64Ptr(const char* p, const char* limit, uint64* v);
+extern const char* GetVarint32Ptr(const char* p, const char* limit,
+                                  uint32_t* v);
+extern const char* GetVarint64Ptr(const char* p, const char* limit,
+                                  uint64_t* v);
 
 // Internal routine for use by fallback path of GetVarint32Ptr
 extern const char* GetVarint32PtrFallback(const char* p, const char* limit,
-                                          uint32* value);
+                                          uint32_t* value);
 extern const char* GetVarint32Ptr(const char* p, const char* limit,
-                                  uint32* value);
-extern char* EncodeVarint32(char* dst, uint32 v);
-extern char* EncodeVarint64(char* dst, uint64 v);
+                                  uint32_t* value);
+extern char* EncodeVarint32(char* dst, uint32_t v);
+extern char* EncodeVarint64(char* dst, uint64_t v);
 
 // Returns the length of the varint32 or varint64 encoding of "v"
 extern int VarintLength(uint64_t v);
diff --git a/tsl/platform/cpu_info.cc b/tsl/platform/cpu_info.cc
index 0b92c6d28..71f7f8f56 100644
--- a/tsl/platform/cpu_info.cc
+++ b/tsl/platform/cpu_info.cc
@@ -140,7 +140,7 @@ class CPUIDInfo {
     CHECK(cpuid == nullptr) << __func__ << " ran more than once";
     cpuid = new CPUIDInfo;
 
-    uint32 eax, ebx, ecx, edx;
+    uint32_t eax, ebx, ecx, edx;
 
     // Get vendor string (issue CPUID with eax = 0)
     GETCPUID(eax, ebx, ecx, edx, 0, 0);
@@ -173,15 +173,15 @@ class CPUIDInfo {
     cpuid->have_ssse3_ = (ecx >> 9) & 0x1;
     cpuid->have_hypervisor_ = (ecx >> 31) & 1;
 
-    const uint64 xcr0_xmm_mask = 0x2;
-    const uint64 xcr0_ymm_mask = 0x4;
-    const uint64 xcr0_maskreg_mask = 0x20;
-    const uint64 xcr0_zmm0_15_mask = 0x40;
-    const uint64 xcr0_zmm16_31_mask = 0x80;
+    const uint64_t xcr0_xmm_mask = 0x2;
+    const uint64_t xcr0_ymm_mask = 0x4;
+    const uint64_t xcr0_maskreg_mask = 0x20;
+    const uint64_t xcr0_zmm0_15_mask = 0x40;
+    const uint64_t xcr0_zmm16_31_mask = 0x80;
 
-    const uint64 xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask;
-    const uint64 xcr0_avx512_mask = xcr0_avx_mask | xcr0_maskreg_mask |
-                                    xcr0_zmm0_15_mask | xcr0_zmm16_31_mask;
+    const uint64_t xcr0_avx_mask = xcr0_xmm_mask | xcr0_ymm_mask;
+    const uint64_t xcr0_avx512_mask = xcr0_avx_mask | xcr0_maskreg_mask |
+                                      xcr0_zmm0_15_mask | xcr0_zmm16_31_mask;
 
     const bool have_avx =
         // Does the OS support XGETBV instruction use by applications?
@@ -207,7 +207,7 @@ class CPUIDInfo {
     // Architectures Software Developer's Manual Volume 2A: Instruction Set
     // Reference, A-M CPUID).
     GETCPUID(eax, ebx, ecx, edx, 7, 0);
-    const uint32 kMaxNumSubLeaves = eax;
+    const uint32_t kMaxNumSubLeaves = eax;
 
     cpuid->have_adx_ = (ebx >> 19) & 0x1;
     cpuid->have_avx2_ = have_avx && ((ebx >> 5) & 0x1);
@@ -312,7 +312,7 @@ class CPUIDInfo {
     return false;
   }
 
-  string vendor_str() const { return vendor_str_; }
+  std::string vendor_str() const { return vendor_str_; }
   int family() const { return family_; }
   int model_num() { return model_num_; }
 
@@ -364,7 +364,7 @@ class CPUIDInfo {
   int have_sse4_2_ : 1;
   int have_ssse3_ : 1;
   int have_hypervisor_ : 1;
-  string vendor_str_;
+  std::string vendor_str_;
   int family_;
   int model_num_;
 };
@@ -590,7 +590,7 @@ int CPUIDNumSMT() {
   // Section: Detecting Hardware Multi-threads Support and Topology
   // Uses CPUID Leaf 11 to enumerate system topology on Intel x86 architectures
   // Other cases not supported
-  uint32 eax, ebx, ecx, edx;
+  uint32_t eax, ebx, ecx, edx;
   // Check if system supports Leaf 11
   GETCPUID(eax, ebx, ecx, edx, 0, 0);
   if (eax >= 11) {
diff --git a/tsl/platform/demangle.h b/tsl/platform/demangle.h
index 4b7576f8d..8171be236 100644
--- a/tsl/platform/demangle.h
+++ b/tsl/platform/demangle.h
@@ -23,8 +23,8 @@ namespace port {
 
 // If the compiler supports, demangle a mangled symbol name and return
 // the demangled name. Otherwise, returns 'mangled' as is.
-string Demangle(const char* mangled);
-inline string Demangle(const string mangled) {
+std::string Demangle(const char* mangled);
+inline std::string Demangle(const std::string mangled) {
   return Demangle(mangled.c_str());
 }
 
diff --git a/tsl/platform/hash.cc b/tsl/platform/hash.cc
index 325aa93b0..5e7c7d7e0 100644
--- a/tsl/platform/hash.cc
+++ b/tsl/platform/hash.cc
@@ -24,22 +24,26 @@ limitations under the License.
 namespace tsl {
 
 // 0xff is in case char is signed.
-static inline uint32 ByteAs32(char c) { return static_cast<uint32>(c) & 0xff; }
-static inline uint64 ByteAs64(char c) { return static_cast<uint64>(c) & 0xff; }
+static inline uint32_t ByteAs32(char c) {
+  return static_cast<uint32_t>(c) & 0xff;
+}
+static inline uint64_t ByteAs64(char c) {
+  return static_cast<uint64_t>(c) & 0xff;
+}
 
-uint32 Hash32(const char* data, size_t n, uint32 seed) {
+uint32_t Hash32(const char* data, size_t n, uint32_t seed) {
   // 'm' and 'r' are mixing constants generated offline.
   // They're not really 'magic', they just happen to work well.
 
-  const uint32 m = 0x5bd1e995;
+  const uint32_t m = 0x5bd1e995;
   const int r = 24;
 
   // Initialize the hash to a 'random' value
-  uint32 h = seed ^ n;
+  uint32_t h = seed ^ n;
 
   // Mix 4 bytes at a time into the hash
   while (n >= 4) {
-    uint32 k = core::DecodeFixed32(data);
+    uint32_t k = core::DecodeFixed32(data);
 
     k *= m;
     k ^= k >> r;
@@ -76,14 +80,14 @@ uint32 Hash32(const char* data, size_t n, uint32 seed) {
   return h;
 }
 
-uint64 Hash64(const char* data, size_t n, uint64 seed) {
-  const uint64 m = 0xc6a4a7935bd1e995;
+uint64_t Hash64(const char* data, size_t n, uint64_t seed) {
+  const uint64_t m = 0xc6a4a7935bd1e995;
   const int r = 47;
 
-  uint64 h = seed ^ (n * m);
+  uint64_t h = seed ^ (n * m);
 
   while (n >= 8) {
-    uint64 k = core::DecodeFixed64(data);
+    uint64_t k = core::DecodeFixed64(data);
     data += 8;
     n -= 8;
 
diff --git a/tsl/platform/hash.h b/tsl/platform/hash.h
index 0945bf071..e27dee187 100644
--- a/tsl/platform/hash.h
+++ b/tsl/platform/hash.h
@@ -30,24 +30,26 @@ limitations under the License.
 
 namespace tsl {
 
-extern uint32 Hash32(const char* data, size_t n, uint32 seed);
-extern uint64 Hash64(const char* data, size_t n, uint64 seed);
+extern uint32_t Hash32(const char* data, size_t n, uint32_t seed);
+extern uint64_t Hash64(const char* data, size_t n, uint64_t seed);
 
-inline uint64 Hash64(const char* data, size_t n) {
+inline uint64_t Hash64(const char* data, size_t n) {
   return Hash64(data, n, 0xDECAFCAFFE);
 }
 
-inline uint64 Hash64(const char* data) { return Hash64(data, ::strlen(data)); }
+inline uint64_t Hash64(const char* data) {
+  return Hash64(data, ::strlen(data));
+}
 
-inline uint64 Hash64(const std::string& str) {
+inline uint64_t Hash64(const std::string& str) {
   return Hash64(str.data(), str.size());
 }
 
-inline uint64 Hash64(const tstring& str) {
+inline uint64_t Hash64(const tstring& str) {
   return Hash64(str.data(), str.size());
 }
 
-inline uint64 Hash64Combine(uint64 a, uint64 b) {
+inline uint64_t Hash64Combine(uint64_t a, uint64_t b) {
   return a ^ (b + 0x9e3779b97f4a7800ULL + (a << 10) + (a >> 4));
 }
 
@@ -55,7 +57,7 @@ inline uint64 Hash64Combine(uint64 a, uint64 b) {
 // associative and compute the same hash for a collection of elements
 // independent of traversal order. Note that it is better to combine hashes
 // symmetrically with addition rather than XOR, since (x^x) == 0 but (x+x) != 0.
-inline uint64 Hash64CombineUnordered(uint64 a, uint64 b) { return a + b; }
+inline uint64_t Hash64CombineUnordered(uint64_t a, uint64_t b) { return a + b; }
 
 // Hash functor suitable for use with power-of-two sized hashtables.  Use
 // instead of std::hash<T>.
@@ -80,7 +82,7 @@ struct hash<T, typename std::enable_if<std::is_enum<T>::value>::type> {
     // We should be able to remove this and use the default
     // tsl::hash<EnumTy>() once we stop building with GCC versions old
     // enough to not have this defect fixed.
-    return std::hash<uint64>()(static_cast<uint64>(value));
+    return std::hash<uint64_t>()(static_cast<uint64_t>(value));
   }
 };
 
@@ -94,8 +96,8 @@ struct hash<T*> {
 };
 
 template <>
-struct hash<string> {
-  size_t operator()(const string& s) const {
+struct hash<std::string> {
+  size_t operator()(const std::string& s) const {
     return static_cast<size_t>(Hash64(s));
   }
 };
diff --git a/tsl/platform/hash_test.cc b/tsl/platform/hash_test.cc
index 010ccde83..75f5c51f4 100644
--- a/tsl/platform/hash_test.cc
+++ b/tsl/platform/hash_test.cc
@@ -38,11 +38,11 @@ TEST(Hash, SignedUnsignedIssue) {
   };
 
   struct Case {
-    uint32 hash32;
-    uint64 hash64;
+    uint32_t hash32;
+    uint64_t hash64;
     const unsigned char* data;
     size_t size;
-    uint32 seed;
+    uint32_t seed;
   };
 
   for (Case c : std::vector<Case>{
@@ -76,7 +76,7 @@ TEST(Hash, HashPtrIsNotIdentityFunction) {
 static void BM_Hash32(::testing::benchmark::State& state) {
   int len = state.range(0);
   std::string input(len, 'x');
-  uint32 h = 0;
+  uint32_t h = 0;
   for (auto s : state) {
     h = Hash32(input.data(), len, 1);
   }
@@ -107,9 +107,9 @@ TEST(StringPieceHasher, Equality) {
 }
 
 TEST(StringPieceHasher, HashMap) {
-  string s1("foo");
-  string s2("bar");
-  string s3("baz");
+  std::string s1("foo");
+  std::string s2("bar");
+  std::string s3("baz");
 
   absl::string_view p1(s1);
   absl::string_view p2(s2);
diff --git a/tsl/platform/host_info.h b/tsl/platform/host_info.h
index 687045c02..fb04ed3dc 100644
--- a/tsl/platform/host_info.h
+++ b/tsl/platform/host_info.h
@@ -37,11 +37,11 @@ struct IOStatistics {
 };
 
 // Return the hostname of the machine on which this process is running.
-string Hostname();
+std::string Hostname();
 
 // Return the job name as a string if it exists, otherwise return an empty
 // string.
-string JobName();
+std::string JobName();
 
 // Returns the Borg job UID as an int64_t if it exists. Otherwise return -1.
 int64_t JobUid();
diff --git a/tsl/platform/human_readable_json.h b/tsl/platform/human_readable_json.h
index 3fedff063..897a6b110 100644
--- a/tsl/platform/human_readable_json.h
+++ b/tsl/platform/human_readable_json.h
@@ -40,9 +40,9 @@ absl::StatusOr<std::string> ProtoToHumanReadableJson(
 
 // Converts a string produced by ProtoToHumanReadableJSON to a protobuf.  Not
 // guaranteed to work for general JSON.
-absl::Status HumanReadableJsonToProto(const string& str,
+absl::Status HumanReadableJsonToProto(const std::string& str,
                                       protobuf::Message* proto);
-absl::Status HumanReadableJsonToProto(const string& str,
+absl::Status HumanReadableJsonToProto(const std::string& str,
                                       protobuf::MessageLite* proto);
 
 }  // namespace tsl
diff --git a/tsl/platform/integral_types_test.cc b/tsl/platform/integral_types_test.cc
index b7142c5e2..b02f5079d 100644
--- a/tsl/platform/integral_types_test.cc
+++ b/tsl/platform/integral_types_test.cc
@@ -23,15 +23,15 @@ namespace tsl {
 namespace {
 
 TEST(IntegralTypes, Basic) {
-  EXPECT_EQ(1, sizeof(int8));
-  EXPECT_EQ(2, sizeof(int16));
-  EXPECT_EQ(4, sizeof(int32));
+  EXPECT_EQ(1, sizeof(int8_t));
+  EXPECT_EQ(2, sizeof(int16_t));
+  EXPECT_EQ(4, sizeof(int32_t));
   EXPECT_EQ(8, sizeof(int64_t));
 
-  EXPECT_EQ(1, sizeof(uint8));
-  EXPECT_EQ(2, sizeof(uint16));
-  EXPECT_EQ(4, sizeof(uint32));
-  EXPECT_EQ(8, sizeof(uint64));
+  EXPECT_EQ(1, sizeof(uint8_t));
+  EXPECT_EQ(2, sizeof(uint16_t));
+  EXPECT_EQ(4, sizeof(uint32_t));
+  EXPECT_EQ(8, sizeof(uint64_t));
 }
 
 TEST(IntegralTypes, MinAndMaxConstants) {
diff --git a/tsl/platform/null_file_system.h b/tsl/platform/null_file_system.h
index 8c8829858..544f36126 100644
--- a/tsl/platform/null_file_system.h
+++ b/tsl/platform/null_file_system.h
@@ -39,70 +39,72 @@ class NullFileSystem : public FileSystem {
   TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
 
   absl::Status NewRandomAccessFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<RandomAccessFile>* result) override {
     return errors::Unimplemented("NewRandomAccessFile unimplemented");
   }
 
-  absl::Status NewWritableFile(const string& fname, TransactionToken* token,
+  absl::Status NewWritableFile(const std::string& fname,
+                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override {
     return errors::Unimplemented("NewWritableFile unimplemented");
   }
 
   absl::Status NewAppendableFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<WritableFile>* result) override {
     return errors::Unimplemented("NewAppendableFile unimplemented");
   }
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
     return errors::Unimplemented(
         "NewReadOnlyMemoryRegionFromFile unimplemented");
   }
 
-  absl::Status FileExists(const string& fname,
+  absl::Status FileExists(const std::string& fname,
                           TransactionToken* token) override {
     return errors::Unimplemented("FileExists unimplemented");
   }
 
-  absl::Status GetChildren(const string& dir, TransactionToken* token,
-                           std::vector<string>* result) override {
+  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+                           std::vector<std::string>* result) override {
     return errors::Unimplemented("GetChildren unimplemented");
   }
 
-  absl::Status GetMatchingPaths(const string& pattern, TransactionToken* token,
-                                std::vector<string>* results) override {
+  absl::Status GetMatchingPaths(const std::string& pattern,
+                                TransactionToken* token,
+                                std::vector<std::string>* results) override {
     return internal::GetMatchingPaths(this, Env::Default(), pattern, results);
   }
 
-  absl::Status DeleteFile(const string& fname,
+  absl::Status DeleteFile(const std::string& fname,
                           TransactionToken* token) override {
     return errors::Unimplemented("DeleteFile unimplemented");
   }
 
-  absl::Status CreateDir(const string& dirname,
+  absl::Status CreateDir(const std::string& dirname,
                          TransactionToken* token) override {
     return errors::Unimplemented("CreateDir unimplemented");
   }
 
-  absl::Status DeleteDir(const string& dirname,
+  absl::Status DeleteDir(const std::string& dirname,
                          TransactionToken* token) override {
     return errors::Unimplemented("DeleteDir unimplemented");
   }
 
-  absl::Status GetFileSize(const string& fname, TransactionToken* token,
-                           uint64* file_size) override {
+  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+                           uint64_t* file_size) override {
     return errors::Unimplemented("GetFileSize unimplemented");
   }
 
-  absl::Status RenameFile(const string& src, const string& target,
+  absl::Status RenameFile(const std::string& src, const std::string& target,
                           TransactionToken* token) override {
     return errors::Unimplemented("RenameFile unimplemented");
   }
 
-  absl::Status Stat(const string& fname, TransactionToken* token,
+  absl::Status Stat(const std::string& fname, TransactionToken* token,
                     FileStatistics* stat) override {
     return errors::Unimplemented("Stat unimplemented");
   }
diff --git a/tsl/platform/numbers_test.cc b/tsl/platform/numbers_test.cc
index db94c2476..e6571d153 100644
--- a/tsl/platform/numbers_test.cc
+++ b/tsl/platform/numbers_test.cc
@@ -37,9 +37,9 @@ using strings_internal::kFastToBufferSize;
 TEST(FpToString, Ints) {
   for (int s = 0; s < 64; s++) {
     for (int delta = -1; delta <= 1; delta++) {
-      uint64 fp = (1ull << s) + delta;
-      string s = FpToString(fp);
-      uint64 fp2;
+      uint64_t fp = (1ull << s) + delta;
+      std::string s = FpToString(fp);
+      uint64_t fp2;
       EXPECT_TRUE(HexStringToUint64(s, &fp2));
       EXPECT_EQ(fp, fp2);
     }
@@ -53,14 +53,14 @@ TEST(FpToString, Ints) {
 TEST(Uint64ToHexString, Ints) {
   for (int s = 0; s < 64; s++) {
     for (int delta = -1; delta <= 1; delta++) {
-      uint64 fp = (1ull << s) + delta;
+      uint64_t fp = (1ull << s) + delta;
       std::string s = absl::StrCat(absl::Hex(fp, absl::kZeroPad16));
-      uint64 fp2;
+      uint64_t fp2;
       EXPECT_TRUE(HexStringToUint64(s, &fp2));
       EXPECT_EQ(fp, fp2) << s;
     }
   }
-  uint64 dummy;
+  uint64_t dummy;
   EXPECT_FALSE(HexStringToUint64("", &dummy));
   EXPECT_FALSE(HexStringToUint64("xyz", &dummy));
   EXPECT_FALSE(HexStringToUint64("0000000000000000xyz", &dummy));
@@ -128,7 +128,7 @@ TEST(HumanReadableElapsedTime, Basic) {
 }
 
 TEST(safe_strto32, Int32s) {
-  int32 result;
+  int32_t result;
 
   EXPECT_EQ(true, absl::SimpleAtoi("1", &result));
   EXPECT_EQ(1, result);
@@ -162,7 +162,7 @@ TEST(safe_strto32, Int32s) {
 }
 
 TEST(safe_strtou32, UInt32s) {
-  uint32 result;
+  uint32_t result;
 
   EXPECT_TRUE(absl::SimpleAtoi("0", &result));
   EXPECT_EQ(0, result);
@@ -195,7 +195,7 @@ TEST(safe_strtou32, UInt32s) {
 }
 
 TEST(safe_strto64, Int64s) {
-  int64 result;
+  int64_t result;
 
   EXPECT_EQ(true, absl::SimpleAtoi("1", &result));
   EXPECT_EQ(1, result);
@@ -231,7 +231,7 @@ TEST(safe_strto64, Int64s) {
 }
 
 TEST(safe_strtou64, UInt64s) {
-  uint64 result;
+  uint64_t result;
 
   EXPECT_TRUE(absl::SimpleAtoi("0", &result));
   EXPECT_EQ(0, result);
diff --git a/tsl/platform/path.cc b/tsl/platform/path.cc
index e251972c7..69c4dd8f4 100644
--- a/tsl/platform/path.cc
+++ b/tsl/platform/path.cc
@@ -46,14 +46,14 @@ namespace {
 const char kPathSep[] = "/";
 }  // namespace
 
-string JoinPathImpl(std::initializer_list<absl::string_view> paths) {
-  string result;
+std::string JoinPathImpl(std::initializer_list<absl::string_view> paths) {
+  std::string result;
 
   for (absl::string_view path : paths) {
     if (path.empty()) continue;
 
     if (result.empty()) {
-      result = string(path);
+      result = std::string(path);
       continue;
     }
 
@@ -136,10 +136,10 @@ absl::string_view BasenamePrefix(absl::string_view path) {
   return internal::SplitBasename(path).first;
 }
 
-string CleanPath(absl::string_view unclean_path) {
-  string path(unclean_path);
+std::string CleanPath(absl::string_view unclean_path) {
+  std::string path(unclean_path);
   const char* src = path.c_str();
-  string::iterator dst = path.begin();
+  std::string::iterator dst = path.begin();
 
   // Check for absolute path and determine initial backtrack limit.
   const bool is_absolute_path = *src == '/';
@@ -147,7 +147,7 @@ string CleanPath(absl::string_view unclean_path) {
     *dst++ = *src++;
     while (*src == '/') ++src;
   }
-  string::const_iterator backtrack_limit = dst;
+  std::string::const_iterator backtrack_limit = dst;
 
   // Process all parts
   while (*src) {
@@ -203,7 +203,7 @@ string CleanPath(absl::string_view unclean_path) {
   }
 
   // Calculate and check the length of the cleaned path.
-  string::difference_type path_length = dst - path.begin();
+  std::string::difference_type path_length = dst - path.begin();
   if (path_length != 0) {
     // Remove trailing '/' except if it is root path ("/" ==> path_length := 1)
     if (path_length > 1 && path[path_length - 1] == '/') {
@@ -249,10 +249,10 @@ void ParseURI(absl::string_view uri, absl::string_view* scheme,
   *path = uri;
 }
 
-string CreateURI(absl::string_view scheme, absl::string_view host,
-                 absl::string_view path) {
+std::string CreateURI(absl::string_view scheme, absl::string_view host,
+                      absl::string_view path) {
   if (scheme.empty()) {
-    return string(path);
+    return std::string(path);
   }
   return absl::StrCat(scheme, "://", host, path);
 }
@@ -265,10 +265,11 @@ int64_t UniqueId() {
   return ++id;
 }
 
-string CommonPathPrefix(absl::Span<const string> paths) {
+std::string CommonPathPrefix(absl::Span<const std::string> paths) {
   if (paths.empty()) return "";
   size_t min_filename_size =
-      absl::c_min_element(paths, [](const string& a, const string& b) {
+      absl::c_min_element(paths, [](const std::string& a,
+                                    const std::string& b) {
         return a.size() < b.size();
       })->size();
   if (min_filename_size == 0) return "";
@@ -294,7 +295,7 @@ string CommonPathPrefix(absl::Span<const string> paths) {
              : std::string(absl::string_view(paths[0]).substr(0, rpos + 1));
 }
 
-string GetTempFilename(const string& extension) {
+std::string GetTempFilename(const std::string& extension) {
 #if defined(__ANDROID__)
   LOG(FATAL) << "GetTempFilename is not implemented in this platform.";
 #elif defined(PLATFORM_WINDOWS)
@@ -325,7 +326,7 @@ string GetTempFilename(const string& extension) {
       // UniqueId is added here because mkstemps is not as thread safe as it
       // looks. https://github.com/tensorflow/tensorflow/issues/5804 shows
       // the problem.
-      string tmp_filepath;
+      std::string tmp_filepath;
       int fd;
       if (extension.length()) {
         tmp_filepath =
@@ -362,7 +363,7 @@ bool StartsWithSegment(absl::string_view path, absl::string_view segment) {
 }
 }  // namespace
 
-bool GetTestWorkspaceDir(string* dir) {
+bool GetTestWorkspaceDir(std::string* dir) {
   const char* srcdir = getenv("TEST_SRCDIR");
   if (srcdir == nullptr) {
     return false;
@@ -377,7 +378,7 @@ bool GetTestWorkspaceDir(string* dir) {
   return true;
 }
 
-bool GetTestUndeclaredOutputsDir(string* dir) {
+bool GetTestUndeclaredOutputsDir(std::string* dir) {
   const char* outputs_dir = getenv("TEST_UNDECLARED_OUTPUTS_DIR");
   if (outputs_dir == nullptr) {
     return false;
@@ -388,7 +389,7 @@ bool GetTestUndeclaredOutputsDir(string* dir) {
   return true;
 }
 
-bool ResolveTestPrefixes(absl::string_view path, string& resolved_path) {
+bool ResolveTestPrefixes(absl::string_view path, std::string& resolved_path) {
   constexpr absl::string_view kTestWorkspaceSegment = "TEST_WORKSPACE";
   constexpr absl::string_view kOutputDirSegment = "TEST_UNDECLARED_OUTPUTS_DIR";
 
diff --git a/tsl/platform/protobuf_util.cc b/tsl/platform/protobuf_util.cc
index 0bab61313..04d9de582 100644
--- a/tsl/platform/protobuf_util.cc
+++ b/tsl/platform/protobuf_util.cc
@@ -20,7 +20,7 @@ limitations under the License.
 namespace tsl {
 
 bool ParseProtoUnlimited(protobuf::MessageLite* proto,
-                         const string& serialized) {
+                         const std::string& serialized) {
   return proto->ParseFromString(serialized);
 }
 
diff --git a/tsl/platform/random.cc b/tsl/platform/random.cc
index 5d76de9a4..6c315c774 100644
--- a/tsl/platform/random.cc
+++ b/tsl/platform/random.cc
@@ -33,20 +33,20 @@ std::mt19937_64 InitRngWithDefaultSeed() { return std::mt19937_64(); }
 
 }  // anonymous namespace
 
-uint64 New64() {
+uint64_t New64() {
   static std::mt19937_64* rng = InitRngWithRandomSeed();
   static mutex mu(LINKER_INITIALIZED);
   mutex_lock l(mu);
   return (*rng)();
 }
 
-uint64 ThreadLocalNew64() {
+uint64_t ThreadLocalNew64() {
   static thread_local std::unique_ptr<std::mt19937_64> rng =
       std::unique_ptr<std::mt19937_64>(InitRngWithRandomSeed());
   return (*rng)();
 }
 
-uint64 New64DefaultSeed() {
+uint64_t New64DefaultSeed() {
   static std::mt19937_64 rng = InitRngWithDefaultSeed();
   static mutex mu(LINKER_INITIALIZED);
   mutex_lock l(mu);
diff --git a/tsl/platform/random.h b/tsl/platform/random.h
index 680520d08..25bc18050 100644
--- a/tsl/platform/random.h
+++ b/tsl/platform/random.h
@@ -23,14 +23,14 @@ namespace random {
 
 // Return a 64-bit random value.  Different sequences are generated
 // in different processes.
-uint64 New64();
+uint64_t New64();
 
 // Same as previous method, but uses a different RNG for each thread.
-uint64 ThreadLocalNew64();
+uint64_t ThreadLocalNew64();
 
 // Return a 64-bit random value. Uses
 // std::mersenne_twister_engine::default_seed as seed value.
-uint64 New64DefaultSeed();
+uint64_t New64DefaultSeed();
 
 }  // namespace random
 }  // namespace tsl
diff --git a/tsl/platform/random_test.cc b/tsl/platform/random_test.cc
index 2ca4e32fc..edda751bb 100644
--- a/tsl/platform/random_test.cc
+++ b/tsl/platform/random_test.cc
@@ -25,9 +25,9 @@ namespace random {
 namespace {
 
 TEST(New64Test, SanityCheck) {
-  std::set<uint64> values;
+  std::set<uint64_t> values;
   for (int i = 0; i < 1000000; i++) {
-    uint64 x = New64();
+    uint64_t x = New64();
     EXPECT_TRUE(values.insert(x).second) << "duplicate " << x;
   }
 }
diff --git a/tsl/platform/raw_coding.h b/tsl/platform/raw_coding.h
index 409b01d44..3e6a706bd 100644
--- a/tsl/platform/raw_coding.h
+++ b/tsl/platform/raw_coding.h
@@ -27,41 +27,41 @@ namespace core {
 // Lower-level versions of Get... that read directly from a character buffer
 // without any bounds checking.
 
-inline uint16 DecodeFixed16(const char* ptr) {
+inline uint16_t DecodeFixed16(const char* ptr) {
   if (port::kLittleEndian) {
     // Load the raw bytes
-    uint16 result;
+    uint16_t result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
   } else {
-    return ((static_cast<uint16>(static_cast<unsigned char>(ptr[0]))) |
-            (static_cast<uint16>(static_cast<unsigned char>(ptr[1])) << 8));
+    return ((static_cast<uint16_t>(static_cast<unsigned char>(ptr[0]))) |
+            (static_cast<uint16_t>(static_cast<unsigned char>(ptr[1])) << 8));
   }
 }
 
-inline uint32 DecodeFixed32(const char* ptr) {
+inline uint32_t DecodeFixed32(const char* ptr) {
   if (port::kLittleEndian) {
     // Load the raw bytes
-    uint32 result;
+    uint32_t result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
   } else {
-    return ((static_cast<uint32>(static_cast<unsigned char>(ptr[0]))) |
-            (static_cast<uint32>(static_cast<unsigned char>(ptr[1])) << 8) |
-            (static_cast<uint32>(static_cast<unsigned char>(ptr[2])) << 16) |
-            (static_cast<uint32>(static_cast<unsigned char>(ptr[3])) << 24));
+    return ((static_cast<uint32_t>(static_cast<unsigned char>(ptr[0]))) |
+            (static_cast<uint32_t>(static_cast<unsigned char>(ptr[1])) << 8) |
+            (static_cast<uint32_t>(static_cast<unsigned char>(ptr[2])) << 16) |
+            (static_cast<uint32_t>(static_cast<unsigned char>(ptr[3])) << 24));
   }
 }
 
-inline uint64 DecodeFixed64(const char* ptr) {
+inline uint64_t DecodeFixed64(const char* ptr) {
   if (port::kLittleEndian) {
     // Load the raw bytes
-    uint64 result;
+    uint64_t result;
     memcpy(&result, ptr, sizeof(result));  // gcc optimizes this to a plain load
     return result;
   } else {
-    uint64 lo = DecodeFixed32(ptr);
-    uint64 hi = DecodeFixed32(ptr + 4);
+    uint64_t lo = DecodeFixed32(ptr);
+    uint64_t hi = DecodeFixed32(ptr + 4);
     return (hi << 32) | lo;
   }
 }
diff --git a/tsl/platform/retrying_file_system.h b/tsl/platform/retrying_file_system.h
index 9bf86114d..26148ad82 100644
--- a/tsl/platform/retrying_file_system.h
+++ b/tsl/platform/retrying_file_system.h
@@ -42,21 +42,22 @@ class RetryingFileSystem : public FileSystem {
   TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
 
   absl::Status NewRandomAccessFile(
-      const string& filename, TransactionToken* token,
+      const std::string& filename, TransactionToken* token,
       std::unique_ptr<RandomAccessFile>* result) override;
 
-  absl::Status NewWritableFile(const string& filename, TransactionToken* token,
+  absl::Status NewWritableFile(const std::string& filename,
+                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override;
 
   absl::Status NewAppendableFile(
-      const string& filename, TransactionToken* token,
+      const std::string& filename, TransactionToken* token,
       std::unique_ptr<WritableFile>* result) override;
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const string& filename, TransactionToken* token,
+      const std::string& filename, TransactionToken* token,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override;
 
-  absl::Status FileExists(const string& fname,
+  absl::Status FileExists(const std::string& fname,
                           TransactionToken* token) override {
     return RetryingUtils::CallWithRetries(
         [this, &fname, token]() {
@@ -65,8 +66,8 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status GetChildren(const string& dir, TransactionToken* token,
-                           std::vector<string>* result) override {
+  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+                           std::vector<std::string>* result) override {
     return RetryingUtils::CallWithRetries(
         [this, &dir, result, token]() {
           return base_file_system_->GetChildren(dir, token, result);
@@ -74,8 +75,9 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status GetMatchingPaths(const string& pattern, TransactionToken* token,
-                                std::vector<string>* result) override {
+  absl::Status GetMatchingPaths(const std::string& pattern,
+                                TransactionToken* token,
+                                std::vector<std::string>* result) override {
     return RetryingUtils::CallWithRetries(
         [this, &pattern, result, token]() {
           return base_file_system_->GetMatchingPaths(pattern, token, result);
@@ -83,7 +85,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status Stat(const string& fname, TransactionToken* token,
+  absl::Status Stat(const std::string& fname, TransactionToken* token,
                     FileStatistics* stat) override {
     return RetryingUtils::CallWithRetries(
         [this, &fname, stat, token]() {
@@ -92,7 +94,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status DeleteFile(const string& fname,
+  absl::Status DeleteFile(const std::string& fname,
                           TransactionToken* token) override {
     return RetryingUtils::DeleteWithRetries(
         [this, &fname, token]() {
@@ -101,7 +103,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status CreateDir(const string& dirname,
+  absl::Status CreateDir(const std::string& dirname,
                          TransactionToken* token) override {
     return RetryingUtils::CallWithRetries(
         [this, &dirname, token]() {
@@ -110,7 +112,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status DeleteDir(const string& dirname,
+  absl::Status DeleteDir(const std::string& dirname,
                          TransactionToken* token) override {
     return RetryingUtils::DeleteWithRetries(
         [this, &dirname, token]() {
@@ -119,8 +121,8 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status GetFileSize(const string& fname, TransactionToken* token,
-                           uint64* file_size) override {
+  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+                           uint64_t* file_size) override {
     return RetryingUtils::CallWithRetries(
         [this, &fname, file_size, token]() {
           return base_file_system_->GetFileSize(fname, token, file_size);
@@ -128,7 +130,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status RenameFile(const string& src, const string& target,
+  absl::Status RenameFile(const std::string& src, const std::string& target,
                           TransactionToken* token) override {
     return RetryingUtils::CallWithRetries(
         [this, &src, &target, token]() {
@@ -137,7 +139,7 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status IsDirectory(const string& dirname,
+  absl::Status IsDirectory(const std::string& dirname,
                            TransactionToken* token) override {
     return RetryingUtils::CallWithRetries(
         [this, &dirname, token]() {
@@ -146,13 +148,14 @@ class RetryingFileSystem : public FileSystem {
         retry_config_);
   }
 
-  absl::Status HasAtomicMove(const string& path,
+  absl::Status HasAtomicMove(const std::string& path,
                              bool* has_atomic_move) override {
     // this method does not need to be retried
     return base_file_system_->HasAtomicMove(path, has_atomic_move);
   }
 
-  absl::Status DeleteRecursively(const string& dirname, TransactionToken* token,
+  absl::Status DeleteRecursively(const std::string& dirname,
+                                 TransactionToken* token,
                                  int64_t* undeleted_files,
                                  int64_t* undeleted_dirs) override {
     return RetryingUtils::DeleteWithRetries(
@@ -189,7 +192,7 @@ class RetryingRandomAccessFile : public RandomAccessFile {
     return base_file_->Name(result);
   }
 
-  absl::Status Read(uint64 offset, size_t n, absl::string_view* result,
+  absl::Status Read(uint64_t offset, size_t n, absl::string_view* result,
                     char* scratch) const override {
     return RetryingUtils::CallWithRetries(
         [this, offset, n, result, scratch]() {
@@ -248,7 +251,7 @@ class RetryingWritableFile : public WritableFile {
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewRandomAccessFile(
-    const string& filename, TransactionToken* token,
+    const std::string& filename, TransactionToken* token,
     std::unique_ptr<RandomAccessFile>* result) {
   std::unique_ptr<RandomAccessFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
@@ -264,7 +267,7 @@ absl::Status RetryingFileSystem<Underlying>::NewRandomAccessFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewWritableFile(
-    const string& filename, TransactionToken* token,
+    const std::string& filename, TransactionToken* token,
     std::unique_ptr<WritableFile>* result) {
   std::unique_ptr<WritableFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
@@ -279,7 +282,7 @@ absl::Status RetryingFileSystem<Underlying>::NewWritableFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewAppendableFile(
-    const string& filename, TransactionToken* token,
+    const std::string& filename, TransactionToken* token,
     std::unique_ptr<WritableFile>* result) {
   std::unique_ptr<WritableFile> base_file;
   TF_RETURN_IF_ERROR(RetryingUtils::CallWithRetries(
@@ -295,7 +298,7 @@ absl::Status RetryingFileSystem<Underlying>::NewAppendableFile(
 
 template <typename Underlying>
 absl::Status RetryingFileSystem<Underlying>::NewReadOnlyMemoryRegionFromFile(
-    const string& filename, TransactionToken* token,
+    const std::string& filename, TransactionToken* token,
     std::unique_ptr<ReadOnlyMemoryRegion>* result) {
   return RetryingUtils::CallWithRetries(
       [this, &filename, result, token]() {
diff --git a/tsl/platform/retrying_file_system_test.cc b/tsl/platform/retrying_file_system_test.cc
index d60a34445..4af55de84 100644
--- a/tsl/platform/retrying_file_system_test.cc
+++ b/tsl/platform/retrying_file_system_test.cc
@@ -24,9 +24,9 @@ limitations under the License.
 namespace tsl {
 namespace {
 
-typedef std::vector<std::tuple<string, absl::Status>> ExpectedCalls;
+typedef std::vector<std::tuple<std::string, absl::Status>> ExpectedCalls;
 
-ExpectedCalls CreateRetriableErrors(const string& method, int n) {
+ExpectedCalls CreateRetriableErrors(const std::string& method, int n) {
   ExpectedCalls expected_calls;
   expected_calls.reserve(n);
   for (int i = 0; i < n; i++) {
@@ -47,7 +47,7 @@ class MockCallSequence {
         << "the next expected call: " << std::get<0>(calls_.front());
   }
 
-  absl::Status ConsumeNextCall(const string& method) {
+  absl::Status ConsumeNextCall(const std::string& method) {
     EXPECT_FALSE(calls_.empty()) << "No more calls were expected.";
     auto call = calls_.front();
     calls_.erase(calls_.begin());
@@ -65,7 +65,7 @@ class MockRandomAccessFile : public RandomAccessFile {
   absl::Status Name(absl::string_view* result) const override {
     return calls_.ConsumeNextCall("Name");
   }
-  absl::Status Read(uint64 offset, size_t n, absl::string_view* result,
+  absl::Status Read(uint64_t offset, size_t n, absl::string_view* result,
                     char* scratch) const override {
     return calls_.ConsumeNextCall("Read");
   }
@@ -102,82 +102,84 @@ class MockFileSystem : public FileSystem {
   TF_USE_FILESYSTEM_METHODS_WITH_NO_TRANSACTION_SUPPORT;
 
   absl::Status NewRandomAccessFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<RandomAccessFile>* result) override {
     *result = std::move(random_access_file_to_return);
     return calls_.ConsumeNextCall("NewRandomAccessFile");
   }
 
-  absl::Status NewWritableFile(const string& fname, TransactionToken* token,
+  absl::Status NewWritableFile(const std::string& fname,
+                               TransactionToken* token,
                                std::unique_ptr<WritableFile>* result) override {
     *result = std::move(writable_file_to_return);
     return calls_.ConsumeNextCall("NewWritableFile");
   }
 
   absl::Status NewAppendableFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<WritableFile>* result) override {
     *result = std::move(writable_file_to_return);
     return calls_.ConsumeNextCall("NewAppendableFile");
   }
 
   absl::Status NewReadOnlyMemoryRegionFromFile(
-      const string& fname, TransactionToken* token,
+      const std::string& fname, TransactionToken* token,
       std::unique_ptr<ReadOnlyMemoryRegion>* result) override {
     return calls_.ConsumeNextCall("NewReadOnlyMemoryRegionFromFile");
   }
 
-  absl::Status FileExists(const string& fname,
+  absl::Status FileExists(const std::string& fname,
                           TransactionToken* token) override {
     return calls_.ConsumeNextCall("FileExists");
   }
 
-  absl::Status GetChildren(const string& dir, TransactionToken* token,
-                           std::vector<string>* result) override {
+  absl::Status GetChildren(const std::string& dir, TransactionToken* token,
+                           std::vector<std::string>* result) override {
     return calls_.ConsumeNextCall("GetChildren");
   }
 
-  absl::Status GetMatchingPaths(const string& dir, TransactionToken* token,
-                                std::vector<string>* result) override {
+  absl::Status GetMatchingPaths(const std::string& dir, TransactionToken* token,
+                                std::vector<std::string>* result) override {
     return calls_.ConsumeNextCall("GetMatchingPaths");
   }
 
-  absl::Status Stat(const string& fname, TransactionToken* token,
+  absl::Status Stat(const std::string& fname, TransactionToken* token,
                     FileStatistics* stat) override {
     return calls_.ConsumeNextCall("Stat");
   }
 
-  absl::Status DeleteFile(const string& fname,
+  absl::Status DeleteFile(const std::string& fname,
                           TransactionToken* token) override {
     return calls_.ConsumeNextCall("DeleteFile");
   }
 
-  absl::Status CreateDir(const string& dirname,
+  absl::Status CreateDir(const std::string& dirname,
                          TransactionToken* token) override {
     return calls_.ConsumeNextCall("CreateDir");
   }
 
-  absl::Status DeleteDir(const string& dirname,
+  absl::Status DeleteDir(const std::string& dirname,
                          TransactionToken* token) override {
     return calls_.ConsumeNextCall("DeleteDir");
   }
 
-  absl::Status GetFileSize(const string& fname, TransactionToken* token,
-                           uint64* file_size) override {
+  absl::Status GetFileSize(const std::string& fname, TransactionToken* token,
+                           uint64_t* file_size) override {
     return calls_.ConsumeNextCall("GetFileSize");
   }
 
-  absl::Status RenameFile(const string& src, const string& target,
+  absl::Status RenameFile(const std::string& src, const std::string& target,
                           TransactionToken* token) override {
     return calls_.ConsumeNextCall("RenameFile");
   }
 
-  absl::Status IsDirectory(const string& dirname,
+  absl::Status IsDirectory(const std::string& dirname,
                            TransactionToken* token) override {
     return calls_.ConsumeNextCall("IsDirectory");
   }
 
-  absl::Status DeleteRecursively(const string& dirname, TransactionToken* token,
+  absl::Status DeleteRecursively(const std::string& dirname,
+                                 TransactionToken* token,
                                  int64_t* undeleted_files,
                                  int64_t* undeleted_dirs) override {
     return calls_.ConsumeNextCall("DeleteRecursively");
@@ -496,7 +498,7 @@ TEST(RetryingFileSystemTest, GetChildren_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  std::vector<string> result;
+  std::vector<std::string> result;
   TF_EXPECT_OK(fs.GetChildren("gs://path", nullptr, &result));
 }
 
@@ -507,7 +509,7 @@ TEST(RetryingFileSystemTest, GetChildren_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  std::vector<string> result;
+  std::vector<std::string> result;
   const auto& status = fs.GetChildren("gs://path", nullptr, &result);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
@@ -523,7 +525,7 @@ TEST(RetryingFileSystemTest, GetMatchingPaths_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  std::vector<string> result;
+  std::vector<std::string> result;
   TF_EXPECT_OK(fs.GetMatchingPaths("gs://path/dir", nullptr, &result));
 }
 
@@ -535,7 +537,7 @@ TEST(RetryingFileSystemTest, GetMatchingPaths_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  std::vector<string> result;
+  std::vector<std::string> result;
   const auto& status = fs.GetMatchingPaths("gs://path/dir", nullptr, &result);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
@@ -623,7 +625,7 @@ TEST(RetryingFileSystemTest, GetFileSize_SuccessWith2ndTry) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  uint64 size;
+  uint64_t size;
   TF_EXPECT_OK(fs.GetFileSize("gs://path/file.txt", nullptr, &size));
 }
 
@@ -634,7 +636,7 @@ TEST(RetryingFileSystemTest, GetFileSize_AllRetriesFailed) {
   RetryingFileSystem<MockFileSystem> fs(
       std::move(base_fs), RetryConfig(0 /* init_delay_time_us */));
 
-  uint64 size;
+  uint64_t size;
   const auto& status = fs.GetFileSize("gs://path/file.txt", nullptr, &size);
   EXPECT_TRUE(absl::StrContains(status.message(), "Retriable error #10"))
       << status;
diff --git a/tsl/platform/scanner_test.cc b/tsl/platform/scanner_test.cc
index dead6fb18..1439b3358 100644
--- a/tsl/platform/scanner_test.cc
+++ b/tsl/platform/scanner_test.cc
@@ -23,8 +23,8 @@ namespace strings {
 class ScannerTest : public ::testing::Test {
  protected:
   // Returns a string with all chars that are in <clz>, in byte value order.
-  string ClassStr(Scanner::CharClass clz) {
-    string s;
+  std::string ClassStr(Scanner::CharClass clz) {
+    std::string s;
     for (int i = 0; i < 256; ++i) {
       char ch = i;
       if (Scanner::Matches(clz, ch)) {
diff --git a/tsl/platform/snappy.h b/tsl/platform/snappy.h
index d2acb8879..aa292e190 100644
--- a/tsl/platform/snappy.h
+++ b/tsl/platform/snappy.h
@@ -36,10 +36,10 @@ namespace tsl {
 namespace port {
 
 // Snappy compression/decompression support
-bool Snappy_Compress(const char* input, size_t length, string* output);
+bool Snappy_Compress(const char* input, size_t length, std::string* output);
 
 bool Snappy_CompressFromIOVec(const struct iovec* iov,
-                              size_t uncompressed_length, string* output);
+                              size_t uncompressed_length, std::string* output);
 
 bool Snappy_GetUncompressedLength(const char* input, size_t length,
                                   size_t* result);
diff --git a/tsl/platform/str_util.cc b/tsl/platform/str_util.cc
index 9a275de74..df9ceb89c 100644
--- a/tsl/platform/str_util.cc
+++ b/tsl/platform/str_util.cc
@@ -83,9 +83,9 @@ bool ConsumeNonWhitespace(absl::string_view* s, absl::string_view* val) {
   }
 }
 
-void TitlecaseString(string* s, absl::string_view delimiters) {
+void TitlecaseString(std::string* s, absl::string_view delimiters) {
   bool upper = true;
-  for (string::iterator ss = s->begin(); ss != s->end(); ++ss) {
+  for (std::string::iterator ss = s->begin(); ss != s->end(); ++ss) {
     if (upper) {
       *ss = absl::ascii_toupper(*ss);
     }
@@ -93,13 +93,14 @@ void TitlecaseString(string* s, absl::string_view delimiters) {
   }
 }
 
-string StringReplace(absl::string_view s, absl::string_view oldsub,
-                     absl::string_view newsub, bool replace_all) {
+std::string StringReplace(absl::string_view s, absl::string_view oldsub,
+                          absl::string_view newsub, bool replace_all) {
   // TODO(jlebar): We could avoid having to shift data around in the string if
   // we had a StringPiece::find() overload that searched for a StringPiece.
-  string res(s);
+  std::string res(s);
   size_t pos = 0;
-  while ((pos = res.find(oldsub.data(), pos, oldsub.size())) != string::npos) {
+  while ((pos = res.find(oldsub.data(), pos, oldsub.size())) !=
+         std::string::npos) {
     res.replace(pos, oldsub.size(), newsub.data(), newsub.size());
     pos += newsub.size();
     if (oldsub.empty()) {
@@ -112,7 +113,7 @@ string StringReplace(absl::string_view s, absl::string_view oldsub,
   return res;
 }
 
-string ArgDefCase(absl::string_view s) {
+std::string ArgDefCase(absl::string_view s) {
   const size_t n = s.size();
 
   // Compute the size of resulting string.
@@ -139,7 +140,7 @@ string ArgDefCase(absl::string_view s) {
 
   // Initialize result with all '_'s. There is no string
   // constructor that does not initialize memory.
-  string result(n + extra_us - to_skip, '_');
+  std::string result(n + extra_us - to_skip, '_');
   // i - index into s
   // j - index into result
   for (size_t i = to_skip, j = 0; i < n; ++i, ++j) {
diff --git a/tsl/platform/str_util.h b/tsl/platform/str_util.h
index 89a3fe55d..02f0b4e24 100644
--- a/tsl/platform/str_util.h
+++ b/tsl/platform/str_util.h
@@ -152,26 +152,29 @@ struct SkipWhitespace {
 
 // Split strings using any of the supplied delimiters. For example:
 // Split("a,b.c,d", ".,") would return {"a", "b", "c", "d"}.
-inline std::vector<string> Split(absl::string_view text,
-                                 absl::string_view delims) {
-  return text.empty() ? std::vector<string>()
+inline std::vector<std::string> Split(absl::string_view text,
+                                      absl::string_view delims) {
+  return text.empty() ? std::vector<std::string>()
                       : absl::StrSplit(text, absl::ByAnyChar(delims));
 }
 
 template <typename Predicate>
-std::vector<string> Split(absl::string_view text, absl::string_view delims,
-                          Predicate p) {
-  return text.empty() ? std::vector<string>()
+std::vector<std::string> Split(absl::string_view text, absl::string_view delims,
+                               Predicate p) {
+  return text.empty() ? std::vector<std::string>()
                       : absl::StrSplit(text, absl::ByAnyChar(delims), p);
 }
 
-inline std::vector<string> Split(absl::string_view text, char delim) {
-  return text.empty() ? std::vector<string>() : absl::StrSplit(text, delim);
+inline std::vector<std::string> Split(absl::string_view text, char delim) {
+  return text.empty() ? std::vector<std::string>()
+                      : absl::StrSplit(text, delim);
 }
 
 template <typename Predicate>
-std::vector<string> Split(absl::string_view text, char delim, Predicate p) {
-  return text.empty() ? std::vector<string>() : absl::StrSplit(text, delim, p);
+std::vector<std::string> Split(absl::string_view text, char delim,
+                               Predicate p) {
+  return text.empty() ? std::vector<std::string>()
+                      : absl::StrSplit(text, delim, p);
 }
 
 // StartsWith()
diff --git a/tsl/platform/str_util_test.cc b/tsl/platform/str_util_test.cc
index 4a2e14dd1..09f46133e 100644
--- a/tsl/platform/str_util_test.cc
+++ b/tsl/platform/str_util_test.cc
@@ -29,9 +29,9 @@ TEST(CEscape, Basic) {
   EXPECT_EQ(absl::CEscape("\320hi\200"), "\\320hi\\200");
 }
 
-string ExpectCUnescapeSuccess(absl::string_view source) {
-  string dest;
-  string error;
+std::string ExpectCUnescapeSuccess(absl::string_view source) {
+  std::string dest;
+  std::string error;
   EXPECT_TRUE(absl::CUnescape(source, &dest, &error)) << error;
   return dest;
 }
@@ -45,11 +45,11 @@ TEST(CUnescape, Basic) {
 }
 
 TEST(CUnescape, HandlesCopyOnWriteStrings) {
-  string dest = "hello";
-  string read = dest;
+  std::string dest = "hello";
+  std::string read = dest;
   // For std::string, read and dest now share the same buffer.
 
-  string error;
+  std::string error;
   absl::string_view source = "llohe";
   // CUnescape is going to write "llohe" to dest, so dest's buffer will be
   // reallocated, and read's buffer remains untouched.
@@ -58,7 +58,7 @@ TEST(CUnescape, HandlesCopyOnWriteStrings) {
 }
 
 TEST(StripTrailingWhitespace, Basic) {
-  string test;
+  std::string test;
   test = "hello";
   absl::StripTrailingAsciiWhitespace(&test);
   EXPECT_EQ(test, "hello");
@@ -81,7 +81,7 @@ TEST(StripTrailingWhitespace, Basic) {
 }
 
 TEST(RemoveLeadingWhitespace, Basic) {
-  string text = "  \t   \n  \r Quick\t";
+  std::string text = "  \t   \n  \r Quick\t";
   absl::string_view data(text);
   // check that all whitespace is removed
   EXPECT_EQ(str_util::RemoveLeadingWhitespace(&data), 11);
@@ -93,7 +93,7 @@ TEST(RemoveLeadingWhitespace, Basic) {
 
 TEST(RemoveLeadingWhitespace, TerminationHandling) {
   // check termination handling
-  string text = "\t";
+  std::string text = "\t";
   absl::string_view data(text);
   EXPECT_EQ(str_util::RemoveLeadingWhitespace(&data), 1);
   EXPECT_EQ(data, absl::string_view(""));
@@ -104,7 +104,7 @@ TEST(RemoveLeadingWhitespace, TerminationHandling) {
 }
 
 TEST(RemoveTrailingWhitespace, Basic) {
-  string text = "  \t   \n  \r Quick \t";
+  std::string text = "  \t   \n  \r Quick \t";
   absl::string_view data(text);
   // check that all whitespace is removed
   EXPECT_EQ(str_util::RemoveTrailingWhitespace(&data), 2);
@@ -116,7 +116,7 @@ TEST(RemoveTrailingWhitespace, Basic) {
 
 TEST(RemoveTrailingWhitespace, TerminationHandling) {
   // check termination handling
-  string text = "\t";
+  std::string text = "\t";
   absl::string_view data(text);
   EXPECT_EQ(str_util::RemoveTrailingWhitespace(&data), 1);
   EXPECT_EQ(data, absl::string_view(""));
@@ -127,7 +127,7 @@ TEST(RemoveTrailingWhitespace, TerminationHandling) {
 }
 
 TEST(RemoveWhitespaceContext, Basic) {
-  string text = "  \t   \n  \r Quick \t";
+  std::string text = "  \t   \n  \r Quick \t";
   absl::string_view data(text);
   // check that all whitespace is removed
   EXPECT_EQ(str_util::RemoveWhitespaceContext(&data), 13);
@@ -145,10 +145,10 @@ TEST(RemoveWhitespaceContext, Basic) {
 
 void TestConsumeLeadingDigits(absl::string_view s, int64_t expected,
                               absl::string_view remaining) {
-  uint64 v;
+  uint64_t v;
   absl::string_view input(s);
   if (str_util::ConsumeLeadingDigits(&input, &v)) {
-    EXPECT_EQ(v, static_cast<uint64>(expected));
+    EXPECT_EQ(v, static_cast<uint64_t>(expected));
     EXPECT_EQ(input, remaining);
   } else {
     EXPECT_LT(expected, 0);
@@ -200,7 +200,7 @@ TEST(ConsumeNonWhitespace, Basic) {
 }
 
 TEST(ConsumePrefix, Basic) {
-  string s("abcdef");
+  std::string s("abcdef");
   absl::string_view input(s);
   EXPECT_FALSE(absl::ConsumePrefix(&input, "abcdefg"));
   EXPECT_EQ(input, "abcdef");
@@ -232,7 +232,7 @@ TEST(StripPrefix, Basic) {
 }
 
 TEST(JoinStrings, Basic) {
-  std::vector<string> s;
+  std::vector<std::string> s;
   s = {"hi"};
   EXPECT_EQ(absl::StrJoin(s, " "), "hi");
   s = {"hi", "there", "strings"};
@@ -246,12 +246,12 @@ TEST(JoinStrings, Basic) {
 }
 
 TEST(JoinStrings, Join3) {
-  std::vector<string> s;
+  std::vector<std::string> s;
   s = {"hi"};
-  auto l1 = [](string* out, string s) { *out += s; };
+  auto l1 = [](std::string* out, std::string s) { *out += s; };
   EXPECT_EQ(str_util::Join(s, " ", l1), "hi");
   s = {"hi", "there", "strings"};
-  auto l2 = [](string* out, string s) { *out += s[0]; };
+  auto l2 = [](std::string* out, std::string s) { *out += s[0]; };
   EXPECT_EQ(str_util::Join(s, " ", l2), "h t s");
 }
 
@@ -321,7 +321,7 @@ TEST(SnakeCase, Basic) {
 }
 
 TEST(TitlecaseString, Basic) {
-  string s = "sparse_lookup";
+  std::string s = "sparse_lookup";
   str_util::TitlecaseString(&s, "_");
   ASSERT_EQ(s, "Sparse_Lookup");
 
diff --git a/tsl/platform/stringpiece_test.cc b/tsl/platform/stringpiece_test.cc
index f50c1275e..e1ef51cde 100644
--- a/tsl/platform/stringpiece_test.cc
+++ b/tsl/platform/stringpiece_test.cc
@@ -41,7 +41,7 @@ TEST(StringPiece, Ctor) {
   }
 
   {
-    string hola = "hola";
+    std::string hola = "hola";
     absl::string_view s30(hola);
     EXPECT_TRUE(s30.data() == hola.data());
     EXPECT_EQ(4, s30.size());
@@ -57,8 +57,8 @@ TEST(StringPiece, Ctor) {
 }
 
 TEST(StringPiece, ConversionToString) {
-  EXPECT_EQ("", string(absl::string_view("")));
-  EXPECT_EQ("foo", string(absl::string_view("foo")));
+  EXPECT_EQ("", std::string(absl::string_view("")));
+  EXPECT_EQ("foo", std::string(absl::string_view("foo")));
 }
 
 }  // namespace tsl
diff --git a/tsl/platform/stringprintf_test.cc b/tsl/platform/stringprintf_test.cc
index 94cfd688f..493ef76c6 100644
--- a/tsl/platform/stringprintf_test.cc
+++ b/tsl/platform/stringprintf_test.cc
@@ -24,39 +24,39 @@ namespace strings {
 namespace {
 
 TEST(PrintfTest, Empty) {
-  EXPECT_EQ("", Printf("%s", string().c_str()));
-  EXPECT_EQ("", Printf("%s", ""));
+  EXPECT_EQ("", absl::StrFormat("%s", string().c_str()));
+  EXPECT_EQ("", absl::StrFormat("%s", ""));
 }
 
 TEST(PrintfTest, Misc) {
 // MSVC does not support $ format specifier.
 #if !defined(_MSC_VER)
-  EXPECT_EQ("123hello w", Printf("%3$d%2$s %1$c", 'w', "hello", 123));
+  EXPECT_EQ("123hello w", absl::StrFormat("%3$d%2$s %1$c", 'w', "hello", 123));
 #endif  // !_MSC_VER
 }
 
 TEST(AppendfTest, Empty) {
-  string value("Hello");
+  std::string value("Hello");
   const char* empty = "";
-  Appendf(&value, "%s", empty);
+  absl::StrAppendFormat(&value, "%s", empty);
   EXPECT_EQ("Hello", value);
 }
 
 TEST(AppendfTest, EmptyString) {
-  string value("Hello");
-  Appendf(&value, "%s", "");
+  std::string value("Hello");
+  absl::StrAppendFormat(&value, "%s", "");
   EXPECT_EQ("Hello", value);
 }
 
 TEST(AppendfTest, String) {
-  string value("Hello");
-  Appendf(&value, " %s", "World");
+  std::string value("Hello");
+  absl::StrAppendFormat(&value, " %s", "World");
   EXPECT_EQ("Hello World", value);
 }
 
 TEST(AppendfTest, Int) {
-  string value("Hello");
-  Appendf(&value, " %d", 123);
+  std::string value("Hello");
+  absl::StrAppendFormat(&value, " %d", 123);
   EXPECT_EQ("Hello 123", value);
 }
 
@@ -71,7 +71,7 @@ TEST(PrintfTest, Multibyte) {
   setlocale(LC_CTYPE, "en_US.utf8");
 
   const char kInvalidCodePoint[] = "\375\067s";
-  string value = Printf("%.*s", 3, kInvalidCodePoint);
+  std::string value = absl::StrFormat("%.*s", 3, kInvalidCodePoint);
 
   // In some versions of glibc (e.g. eglibc-2.11.1, aka GRTEv2), snprintf
   // returns error given an invalid codepoint. Other versions
@@ -85,7 +85,8 @@ TEST(PrintfTest, Multibyte) {
   char* buf = new char[n + 1];
   memset(buf, ' ', n - 3);
   memcpy(buf + n - 3, kInvalidCodePoint, 4);
-  value = Printf("%.*s", n, buf);
+  char* arg2 = buf;
+  value = absl::StrFormat("%.*s", n, arg2);
   // See GRTEv2 vs. GRTEv3 comment above.
   EXPECT_TRUE(value.empty() || value == buf);
   delete[] buf;
@@ -97,7 +98,7 @@ TEST(PrintfTest, NoMultibyte) {
   // No multibyte handling, but the string contains funny chars.
   char* old_locale = setlocale(LC_CTYPE, nullptr);
   setlocale(LC_CTYPE, "POSIX");
-  string value = Printf("%.*s", 3, "\375\067s");
+  std::string value = absl::StrFormat("%.*s", 3, "\375\067s");
   setlocale(LC_CTYPE, old_locale);
   EXPECT_EQ("\375\067s", value);
 }
@@ -107,7 +108,7 @@ TEST(PrintfTest, DontOverwriteErrno) {
   // something significantly larger than what people are normally
   // printing in their badly written PLOG() statements.
   errno = ECHILD;
-  string value = Printf("Hello, %s!", "World");
+  std::string value = absl::StrFormat("Hello, %s!", "World");
   EXPECT_EQ(ECHILD, errno);
 }
 
@@ -117,7 +118,8 @@ TEST(PrintfTest, LargeBuf) {
   char* buf = new char[n + 1];
   memset(buf, ' ', n);
   buf[n] = 0;
-  string value = Printf("%s", buf);
+  char* arg1 = buf;
+  std::string value = absl::StrFormat("%s", arg1);
   EXPECT_EQ(buf, value);
   delete[] buf;
 }
diff --git a/tsl/platform/tracing.h b/tsl/platform/tracing.h
index 07a725f22..89728d4d3 100644
--- a/tsl/platform/tracing.h
+++ b/tsl/platform/tracing.h
@@ -45,8 +45,8 @@ const char* GetEventCategoryName(EventCategory);
 class EventCollector {
  public:
   virtual ~EventCollector() {}
-  virtual void RecordEvent(uint64 arg) const = 0;
-  virtual void StartRegion(uint64 arg) const = 0;
+  virtual void RecordEvent(uint64_t arg) const = 0;
+  virtual void StartRegion(uint64_t arg) const = 0;
   virtual void StopRegion() const = 0;
 
   // Annotates the current thread with a name.
@@ -74,13 +74,13 @@ inline const EventCollector* GetEventCollector(EventCategory category) {
 }
 
 // Returns a unique id to pass to RecordEvent/ScopedRegion. Never returns zero.
-uint64 GetUniqueArg();
+uint64_t GetUniqueArg();
 
 // Returns an id for name to pass to RecordEvent/ScopedRegion.
-uint64 GetArgForName(absl::string_view name);
+uint64_t GetArgForName(absl::string_view name);
 
 // Records an atomic event through the currently registered EventCollector.
-inline void RecordEvent(EventCategory category, uint64 arg) {
+inline void RecordEvent(EventCategory category, uint64_t arg) {
   if (auto collector = GetEventCollector(category)) {
     collector->RecordEvent(arg);
   }
@@ -95,7 +95,7 @@ class ScopedRegion {
     other.collector_ = nullptr;
   }
 
-  ScopedRegion(EventCategory category, uint64 arg)
+  ScopedRegion(EventCategory category, uint64_t arg)
       : collector_(GetEventCollector(category)) {
     if (collector_) {
       collector_->StartRegion(arg);