diff --git a/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp b/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
--- a/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -68,7 +68,7 @@
                            unsigned num_reserve1,
                            unsigned num_reserve2)
 {
-    std::unordered_map<uint64_t, unsigned long> m;
+    std::unordered_map<std::uint64_t, unsigned long> m;
     m.reserve(num_reserve1);
     for (unsigned I = 0; I < num_inserts; ++I) m[I] = 0;
     m.reserve(num_reserve2);
diff --git a/libcxx/test/libcxx/fuzzing/random.pass.cpp b/libcxx/test/libcxx/fuzzing/random.pass.cpp
--- a/libcxx/test/libcxx/fuzzing/random.pass.cpp
+++ b/libcxx/test/libcxx/fuzzing/random.pass.cpp
@@ -38,7 +38,7 @@
   using ResultT = typename Dist::result_type;
   static_assert(std::is_same<ResultT, typename ParamT::distribution_type::result_type>::value, "");
 
-  static ParamT Create(const uint8_t* data, std::size_t size, bool &OK) {
+  static ParamT Create(const std::uint8_t* data, std::size_t size, bool &OK) {
     constexpr bool select_vector_result = std::is_constructible<ParamT, ResultT*, ResultT*, ResultT*>::value;
     constexpr bool select_vector_double = std::is_constructible<ParamT, double*, double*>::value;
     constexpr int selector = select_vector_result ? 0 : (select_vector_double ? 1 : 2);
diff --git a/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp b/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
--- a/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
+++ b/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
@@ -280,12 +280,12 @@
 int main(int, char**) {
   { assert((test_case<file_time_type, time_t, struct timespec>::test())); }
   {
-    assert((test_case<TestFileTimeT<int64_t>, int64_t,
-                      TestTimeSpec<int64_t, long> >::test()));
+    assert((test_case<TestFileTimeT<std::int64_t>, std::int64_t,
+                      TestTimeSpec<std::int64_t, long> >::test()));
   }
   {
-    assert((test_case<TestFileTimeT<long long>, int32_t,
-                      TestTimeSpec<int32_t, int32_t> >::test()));
+    assert((test_case<TestFileTimeT<long long>, std::int32_t,
+                      TestTimeSpec<std::int32_t, std::int32_t> >::test()));
   }
   {
     // Test that insane platforms like ppc64 linux, which use long double as time_t,
@@ -295,12 +295,12 @@
   }
 #ifndef TEST_HAS_NO_INT128_T
   {
-    assert((test_case<TestFileTimeT<__int128_t, std::nano>, int64_t,
-                      TestTimeSpec<int64_t, long> >::test()));
+    assert((test_case<TestFileTimeT<__int128_t, std::nano>, std::int64_t,
+                      TestTimeSpec<std::int64_t, long> >::test()));
   }
   {
-    assert((test_case<TestFileTimeT<__int128_t, std::nano>, int32_t,
-                      TestTimeSpec<int32_t, int32_t> >::test()));
+    assert((test_case<TestFileTimeT<__int128_t, std::nano>, std::int32_t,
+                      TestTimeSpec<std::int32_t, std::int32_t> >::test()));
   }
 #endif
 
diff --git a/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp b/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
--- a/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
+++ b/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
@@ -40,10 +40,10 @@
     test<long>();
     test<long long>();
 
-    test<int8_t>();
-    test<int16_t>();
-    test<int32_t>();
-    test<int64_t>();
+    test<std::int8_t>();
+    test<std::int16_t>();
+    test<std::int32_t>();
+    test<std::int64_t>();
 
     test<unsigned char>();
     test<unsigned short>();
@@ -51,10 +51,10 @@
     test<unsigned long>();
     test<unsigned long long>();
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
diff --git a/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp b/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
@@ -18,7 +18,7 @@
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
@@ -26,8 +26,8 @@
 public:
   using value_type = T;
   using pointer = small_pointer<T>;
-  using size_type = int16_t;
-  using difference_type = int16_t;
+  using size_type = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
diff --git a/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp b/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
@@ -16,7 +16,7 @@
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
@@ -24,8 +24,8 @@
 public:
   using value_type = T;
   using pointer = small_pointer<T>;
-  using size_type = int16_t;
-  using difference_type = int16_t;
+  using size_type = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
@@ -20,7 +20,7 @@
 #include "min_allocator.h"
 
 int main(int, char**) {
-  using T = decltype(uint8_t() - uint8_t());
+  using T = decltype(std::uint8_t() - std::uint8_t());
   {
     typedef std::string C;
     C c(1, '\0');
diff --git a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
--- a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
+++ b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
@@ -71,7 +71,7 @@
     // Bit-castable arithmetic types.
 
     // 8-bit types.
-    using integral_8 = types::type_list<char8_t, int8_t, uint8_t>;
+    using integral_8 = types::type_list<char8_t, std::int8_t, std::uint8_t>;
     using chars = types::type_list<char, unsigned char, signed char>;
 #if CHAR_BIT == 8
     check<true, types::concatenate_t<integral_8, chars>>();
@@ -81,7 +81,7 @@
 #endif
 
     // 16-bit types.
-    using integral_16 = types::type_list<char16_t, int16_t, uint16_t>;
+    using integral_16 = types::type_list<char16_t, std::int16_t, std::uint16_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
     check<true, types::concatenate_t<integral_16, types::type_list<wchar_t>>>();
 #else
@@ -89,7 +89,7 @@
 #endif
 
     // 32-bit types.
-    using integral_32 = types::type_list<char32_t, int32_t, std::uint32_t>;
+    using integral_32 = types::type_list<char32_t, std::int32_t, std::uint32_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
     check<true, types::concatenate_t<integral_32, types::type_list<wchar_t>>>();
 #else
@@ -97,7 +97,7 @@
 #endif
 
     // 64-bit types.
-    using integral_64 = types::type_list<int64_t, uint64_t>;
+    using integral_64 = types::type_list<std::int64_t, std::uint64_t>;
     check<true, integral_64>();
 
     // 128-bit types.
diff --git a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
--- a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
+++ b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
@@ -18,21 +18,21 @@
 
 #include "test_macros.h"
 
-static_assert(std::is_same_v<std::underlying_type_t<std::__format::__arg_t>, uint8_t>);
-
-static_assert(uint8_t(std::__format::__arg_t::__none) == 0);
-static_assert(uint8_t(std::__format::__arg_t::__boolean) == 1);
-static_assert(uint8_t(std::__format::__arg_t::__char_type) == 2);
-static_assert(uint8_t(std::__format::__arg_t::__int) == 3);
-static_assert(uint8_t(std::__format::__arg_t::__long_long) == 4);
-static_assert(uint8_t(std::__format::__arg_t::__i128) == 5);
-static_assert(uint8_t(std::__format::__arg_t::__unsigned) == 6);
-static_assert(uint8_t(std::__format::__arg_t::__unsigned_long_long) == 7);
-static_assert(uint8_t(std::__format::__arg_t::__u128) == 8);
-static_assert(uint8_t(std::__format::__arg_t::__float) == 9);
-static_assert(uint8_t(std::__format::__arg_t::__double) == 10);
-static_assert(uint8_t(std::__format::__arg_t::__long_double) == 11);
-static_assert(uint8_t(std::__format::__arg_t::__const_char_type_ptr) == 12);
-static_assert(uint8_t(std::__format::__arg_t::__string_view) == 13);
-static_assert(uint8_t(std::__format::__arg_t::__ptr) == 14);
-static_assert(uint8_t(std::__format::__arg_t::__handle) == 15);
+static_assert(std::is_same_v<std::underlying_type_t<std::__format::__arg_t>, std::uint8_t>);
+
+static_assert(std::uint8_t(std::__format::__arg_t::__none) == 0);
+static_assert(std::uint8_t(std::__format::__arg_t::__boolean) == 1);
+static_assert(std::uint8_t(std::__format::__arg_t::__char_type) == 2);
+static_assert(std::uint8_t(std::__format::__arg_t::__int) == 3);
+static_assert(std::uint8_t(std::__format::__arg_t::__long_long) == 4);
+static_assert(std::uint8_t(std::__format::__arg_t::__i128) == 5);
+static_assert(std::uint8_t(std::__format::__arg_t::__unsigned) == 6);
+static_assert(std::uint8_t(std::__format::__arg_t::__unsigned_long_long) == 7);
+static_assert(std::uint8_t(std::__format::__arg_t::__u128) == 8);
+static_assert(std::uint8_t(std::__format::__arg_t::__float) == 9);
+static_assert(std::uint8_t(std::__format::__arg_t::__double) == 10);
+static_assert(std::uint8_t(std::__format::__arg_t::__long_double) == 11);
+static_assert(std::uint8_t(std::__format::__arg_t::__const_char_type_ptr) == 12);
+static_assert(std::uint8_t(std::__format::__arg_t::__string_view) == 13);
+static_assert(std::uint8_t(std::__format::__arg_t::__ptr) == 14);
+static_assert(std::uint8_t(std::__format::__arg_t::__handle) == 15);
diff --git a/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp b/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
--- a/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
+++ b/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
@@ -18,7 +18,7 @@
 #include "test_macros.h"
 
 typedef std::__murmur2_or_cityhash<std::uint32_t> Hash32;
-typedef std::__murmur2_or_cityhash<uint64_t> Hash64;
+typedef std::__murmur2_or_cityhash<std::uint64_t> Hash64;
 
 void test(const void* key, int len) {
   for (int i=1; i <= len; ++i) {
diff --git a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
--- a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
+++ b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
@@ -33,14 +33,14 @@
 };
 
 int main(int, char**) {
-  const std::pair<std::string, uint64_t> TestCases[] = {
+  const std::pair<std::string, std::uint64_t> TestCases[] = {
       {CityHash[0], CHOOSE_BY_ENDIANESS(0x87c69099911bab7eULL, 0x297621d7fa436a3ULL)},
       {CityHash[1], CHOOSE_BY_ENDIANESS(0x87c69099911bab7eULL, 0xb17be531dde56e57ULL)},
       {CityHash[2], CHOOSE_BY_ENDIANESS(0x85322632e188694aULL, 0xe14f578b688e266dULL)},
       {CityHash[3], CHOOSE_BY_ENDIANESS(0x85322632e188694aULL, 0xca5a764a0450eac6ULL)},
   };
 
-  std::__murmur2_or_cityhash<uint64_t> h64;
+  std::__murmur2_or_cityhash<std::uint64_t> h64;
   for (const auto& test_case : TestCases) {
     assert(h64(test_case.first.data(), test_case.first.size()) == test_case.second);
   }
diff --git a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
--- a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
+++ b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
@@ -32,14 +32,14 @@
 };
 
 int main(int, char**) {
-  const std::pair<std::string, uint64_t> TestCases[] = {
+  const std::pair<std::string, std::uint64_t> TestCases[] = {
       {CityHash[0], CHOOSE_BY_ENDIANESS(0x4382a8d0fe8edb17ULL, 0xca84e809bef16fbcULL)},
       {CityHash[1], CHOOSE_BY_ENDIANESS(0xecefb080a6854061ULL, 0xd7feb824250272dcULL)},
       {CityHash[2], CHOOSE_BY_ENDIANESS(0x169ea3aebf908d6dULL, 0xea8cef3ca6f6e368ULL)},
       {CityHash[3], CHOOSE_BY_ENDIANESS(0xe18298a2760f09faULL, 0xf33a7700bb7a94a8ULL)},
   };
 
-  std::__murmur2_or_cityhash<uint64_t> h64;
+  std::__murmur2_or_cityhash<std::uint64_t> h64;
   for (const auto& test_case : TestCases) {
     assert(h64(test_case.first.data(), test_case.first.size()) == test_case.second);
   }
diff --git a/libcxx/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp b/libcxx/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
--- a/libcxx/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.generic/cstdint_typedefs.pass.cpp
@@ -41,23 +41,23 @@
 
 int main(int, char**)
 {
-    static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_int_least8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_uint_least8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least16_t>,  std::atomic_int_least16_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least16_t>, std::atomic_uint_least16_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least32_t>,  std::atomic_int_least32_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least32_t>, std::atomic_uint_least32_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least64_t>,  std::atomic_int_least64_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least64_t>, std::atomic_uint_least64_t>::value), "");
+    static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_std::int_least8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_std::uint_least8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least16_t>,  std::atomic_std::int_least16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least16_t>, std::atomic_std::uint_least16_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least32_t>,  std::atomic_std::int_least32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least32_t>, std::atomic_std::uint_least32_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least64_t>,  std::atomic_std::int_least64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least64_t>, std::atomic_std::uint_least64_t>::value), "");
 
-    static_assert((std::is_same<std::atomic<  std::int_fast8_t>,   std::atomic_int_fast8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::uint_fast8_t>,  std::atomic_uint_fast8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast16_t>,  std::atomic_int_fast16_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast16_t>, std::atomic_uint_fast16_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast32_t>,  std::atomic_int_fast32_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast32_t>, std::atomic_uint_fast32_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast64_t>,  std::atomic_int_fast64_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast64_t>, std::atomic_uint_fast64_t>::value), "");
+    static_assert((std::is_same<std::atomic<  std::int_fast8_t>,   std::atomic_std::int_fast8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::uint_fast8_t>,  std::atomic_std::uint_fast8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast16_t>,  std::atomic_std::int_fast16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast16_t>, std::atomic_std::uint_fast16_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast32_t>,  std::atomic_std::int_fast32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast32_t>, std::atomic_std::uint_fast32_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast64_t>,  std::atomic_std::int_fast64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast64_t>, std::atomic_std::uint_fast64_t>::value), "");
 
     static_assert((std::is_same<std::atomic< std::intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<std::uintptr_t>, std::atomic_uintptr_t>::value), "");
diff --git a/libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp b/libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp
--- a/libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -184,14 +184,14 @@
     test<std::atomic_wchar_t, wchar_t>();
 #endif
 
-    test<std::atomic_int8_t,    int8_t>();
-    test<std::atomic_uint8_t,  uint8_t>();
-    test<std::atomic_int16_t,   int16_t>();
-    test<std::atomic_uint16_t, uint16_t>();
-    test<std::atomic_int32_t,   int32_t>();
-    test<std::atomic_uint32_t, uint32_t>();
-    test<std::atomic_int64_t,   int64_t>();
-    test<std::atomic_uint64_t, uint64_t>();
+    test<std::atomic_std::int8_t,    std::int8_t>();
+    test<std::atomic_std::uint8_t,  std::uint8_t>();
+    test<std::atomic_std::int16_t,   std::int16_t>();
+    test<std::atomic_std::uint16_t, std::uint16_t>();
+    test<std::atomic_std::int32_t,   std::int32_t>();
+    test<std::atomic_std::uint32_t, std::uint32_t>();
+    test<std::atomic_std::int64_t,   std::int64_t>();
+    test<std::atomic_std::uint64_t, std::uint64_t>();
 
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
@@ -210,14 +210,14 @@
     test<volatile std::atomic_wchar_t, wchar_t>();
 #endif
 
-    test<volatile std::atomic_int8_t,    int8_t>();
-    test<volatile std::atomic_uint8_t,  uint8_t>();
-    test<volatile std::atomic_int16_t,   int16_t>();
-    test<volatile std::atomic_uint16_t, uint16_t>();
-    test<volatile std::atomic_int32_t,   int32_t>();
-    test<volatile std::atomic_uint32_t, uint32_t>();
-    test<volatile std::atomic_int64_t,   int64_t>();
-    test<volatile std::atomic_uint64_t, uint64_t>();
+    test<volatile std::atomic_std::int8_t,    std::int8_t>();
+    test<volatile std::atomic_std::uint8_t,  std::uint8_t>();
+    test<volatile std::atomic_std::int16_t,   std::int16_t>();
+    test<volatile std::atomic_std::uint16_t, std::uint16_t>();
+    test<volatile std::atomic_std::int32_t,   std::int32_t>();
+    test<volatile std::atomic_std::uint32_t, std::uint32_t>();
+    test<volatile std::atomic_std::int64_t,   std::int64_t>();
+    test<volatile std::atomic_std::uint64_t, std::uint64_t>();
 
   return 0;
 }
diff --git a/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp b/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
--- a/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -67,14 +67,14 @@
     static_assert((std::is_same<std::atomic<intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<uintptr_t>, std::atomic_uintptr_t>::value), "");
 
-    static_assert((std::is_same<std::atomic<int8_t>,    std::atomic_int8_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint8_t>,   std::atomic_uint8_t>::value), "");
-    static_assert((std::is_same<std::atomic<int16_t>,   std::atomic_int16_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint16_t>,  std::atomic_uint16_t>::value), "");
-    static_assert((std::is_same<std::atomic<int32_t>,   std::atomic_int32_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
-    static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int8_t>,    std::atomic_std::int8_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint8_t>,   std::atomic_std::uint8_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int16_t>,   std::atomic_std::int16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint16_t>,  std::atomic_std::uint16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int32_t>,   std::atomic_std::int32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint32_t>,  std::atomic_std::uint32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int64_t>,   std::atomic_std::int64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint64_t>,  std::atomic_std::uint64_t>::value), "");
 
   return 0;
 }
diff --git a/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp b/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp
--- a/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp
+++ b/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp
@@ -173,32 +173,32 @@
   static_assert(std::is_same_v<std::atomic<wchar_t>,  ::atomic_wchar_t>);
 #endif
 
-  static_assert(std::is_same_v<std::atomic<int8_t>,   ::atomic_int8_t>);
-  static_assert(std::is_same_v<std::atomic<uint8_t>,  ::atomic_uint8_t>);
-  static_assert(std::is_same_v<std::atomic<int16_t>,  ::atomic_int16_t>);
-  static_assert(std::is_same_v<std::atomic<uint16_t>, ::atomic_uint16_t>);
-  static_assert(std::is_same_v<std::atomic<int32_t>,  ::atomic_int32_t>);
-  static_assert(std::is_same_v<std::atomic<uint32_t>, ::atomic_uint32_t>);
-  static_assert(std::is_same_v<std::atomic<int64_t>,  ::atomic_int64_t>);
-  static_assert(std::is_same_v<std::atomic<uint64_t>, ::atomic_uint64_t>);
-
-  static_assert(std::is_same_v<std::atomic<int_least8_t>,   ::atomic_int_least8_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least8_t>,  ::atomic_uint_least8_t>);
-  static_assert(std::is_same_v<std::atomic<int_least16_t>,  ::atomic_int_least16_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least16_t>, ::atomic_uint_least16_t>);
-  static_assert(std::is_same_v<std::atomic<int_least32_t>,  ::atomic_int_least32_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least32_t>, ::atomic_uint_least32_t>);
-  static_assert(std::is_same_v<std::atomic<int_least64_t>,  ::atomic_int_least64_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least64_t>, ::atomic_uint_least64_t>);
-
-  static_assert(std::is_same_v<std::atomic<int_fast8_t>,    ::atomic_int_fast8_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast8_t>,   ::atomic_uint_fast8_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast16_t>,   ::atomic_int_fast16_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast16_t>,  ::atomic_uint_fast16_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast32_t>,   ::atomic_int_fast32_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast32_t>,  ::atomic_uint_fast32_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast64_t>,   ::atomic_int_fast64_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast64_t>,  ::atomic_uint_fast64_t>);
+  static_assert(std::is_same_v<std::atomic<std::int8_t>,   ::atomic_std::int8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint8_t>,  ::atomic_std::uint8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int16_t>,  ::atomic_std::int16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint16_t>, ::atomic_std::uint16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int32_t>,  ::atomic_std::int32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint32_t>, ::atomic_std::uint32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int64_t>,  ::atomic_std::int64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint64_t>, ::atomic_std::uint64_t>);
+
+  static_assert(std::is_same_v<std::atomic<std::int_least8_t>,   ::atomic_std::int_least8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least8_t>,  ::atomic_std::uint_least8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least16_t>,  ::atomic_std::int_least16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least16_t>, ::atomic_std::uint_least16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least32_t>,  ::atomic_std::int_least32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least32_t>, ::atomic_std::uint_least32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least64_t>,  ::atomic_std::int_least64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least64_t>, ::atomic_std::uint_least64_t>);
+
+  static_assert(std::is_same_v<std::atomic<std::int_fast8_t>,    ::atomic_std::int_fast8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast8_t>,   ::atomic_std::uint_fast8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast16_t>,   ::atomic_std::int_fast16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast16_t>,  ::atomic_std::uint_fast16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast32_t>,   ::atomic_std::int_fast32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast32_t>,  ::atomic_std::uint_fast32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast64_t>,   ::atomic_std::int_fast64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast64_t>,  ::atomic_std::uint_fast64_t>);
 
   static_assert(std::is_same_v<std::atomic<intptr_t>,  ::atomic_intptr_t>);
   static_assert(std::is_same_v<std::atomic<uintptr_t>, ::atomic_uintptr_t>);
diff --git a/libcxx/test/std/atomics/types.pass.cpp b/libcxx/test/std/atomics/types.pass.cpp
--- a/libcxx/test/std/atomics/types.pass.cpp
+++ b/libcxx/test/std/atomics/types.pass.cpp
@@ -119,32 +119,32 @@
     test<wchar_t>            ();
 #endif
 
-    test<int_least8_t>   ();
-    test<uint_least8_t>  ();
-    test<int_least16_t>  ();
-    test<uint_least16_t> ();
-    test<int_least32_t>  ();
-    test<uint_least32_t> ();
-    test<int_least64_t>  ();
-    test<uint_least64_t> ();
-
-    test<int_fast8_t>   ();
-    test<uint_fast8_t>  ();
-    test<int_fast16_t>  ();
-    test<uint_fast16_t> ();
-    test<int_fast32_t>  ();
-    test<uint_fast32_t> ();
-    test<int_fast64_t>  ();
-    test<uint_fast64_t> ();
-
-    test< int8_t>  ();
-    test<uint8_t>  ();
-    test< int16_t> ();
-    test<uint16_t> ();
-    test< int32_t> ();
+    test<std::int_least8_t>   ();
+    test<std::uint_least8_t>  ();
+    test<std::int_least16_t>  ();
+    test<std::uint_least16_t> ();
+    test<std::int_least32_t>  ();
+    test<std::uint_least32_t> ();
+    test<std::int_least64_t>  ();
+    test<std::uint_least64_t> ();
+
+    test<std::int_fast8_t>   ();
+    test<std::uint_fast8_t>  ();
+    test<std::int_fast16_t>  ();
+    test<std::uint_fast16_t> ();
+    test<std::int_fast32_t>  ();
+    test<std::uint_fast32_t> ();
+    test<std::int_fast64_t>  ();
+    test<std::uint_fast64_t> ();
+
+    test< std::int8_t>  ();
+    test<std::uint8_t>  ();
+    test< std::int16_t> ();
+    test<std::uint16_t> ();
+    test< std::int32_t> ();
     test<std::uint32_t> ();
-    test< int64_t> ();
-    test<uint64_t> ();
+    test< std::int64_t> ();
+    test<std::uint64_t> ();
 
     test<intptr_t>  ();
     test<uintptr_t> ();
diff --git a/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
--- a/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
@@ -14,7 +14,7 @@
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
@@ -22,8 +22,8 @@
 public:
   using value_type      = T;
   using pointer         = small_pointer<T>;
-  using size_type       = int16_t;
-  using difference_type = int16_t;
+  using size_type       = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -190,7 +190,7 @@
   }
   {
     // Though the types are different, initialization can be done with `memcpy`.
-    int32_t array[1] = { -1 };
+    std::int32_t array[1] = { -1 };
     std::vector<std::uint32_t> v(array, array + 1);
     assert(v[0] == 4294967295U);
   }
diff --git a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
@@ -42,26 +42,26 @@
     sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 12>>) == 16,
     "");
 static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) ==
+    sizeof(ex::simd<std::int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) ==
         16,
     "");
 static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) ==
+    sizeof(ex::simd<std::int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) ==
         32,
     "");
 static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
+    std::is_same<ex::simd_abi::native<std::int8_t>,
                  ex::__simd_abi<ex::_StorageKind::_VecExt, reg_width()>>::value,
     "");
 #else
 static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
+    std::is_same<ex::simd_abi::native<std::int8_t>,
                  ex::__simd_abi<ex::_StorageKind::_Array, reg_width()>>::value,
     "");
 
 #endif
 
-static_assert(std::is_same<ex::simd_abi::compatible<int8_t>,
+static_assert(std::is_same<ex::simd_abi::compatible<std::int8_t>,
                            ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value,
               "");
 
diff --git a/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
@@ -26,7 +26,7 @@
 void test_access() {
   {
     SimdType a(42), b(4);
-    static_assert(std::is_convertible<decltype(a[0]), int8_t>::value, "");
+    static_assert(std::is_convertible<decltype(a[0]), std::int8_t>::value, "");
 
     assert(a[0] == 42);
     assert(!a[0] == !42);
diff --git a/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
@@ -22,26 +22,26 @@
 namespace ex = std::experimental::parallelism_v2;
 
 static_assert(
-    std::is_same<decltype(ex::simd_cast<int32_t>(ex::native_simd<int32_t>())),
-                 ex::native_simd<int32_t>>::value,
+    std::is_same<decltype(ex::simd_cast<std::int32_t>(ex::native_simd<std::int32_t>())),
+                 ex::native_simd<std::int32_t>>::value,
     "");
 
-static_assert(std::is_same<decltype(ex::simd_cast<int64_t>(
-                               ex::fixed_size_simd<int32_t, 4>())),
-                           ex::fixed_size_simd<int64_t, 4>>::value,
+static_assert(std::is_same<decltype(ex::simd_cast<std::int64_t>(
+                               ex::fixed_size_simd<std::int32_t, 4>())),
+                           ex::fixed_size_simd<std::int64_t, 4>>::value,
               "");
 
 static_assert(
-    std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<int64_t, 1>>(
-                     ex::simd<int32_t, ex::simd_abi::scalar>())),
-                 ex::fixed_size_simd<int64_t, 1>>::value,
+    std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<std::int64_t, 1>>(
+                     ex::simd<std::int32_t, ex::simd_abi::scalar>())),
+                 ex::fixed_size_simd<std::int64_t, 1>>::value,
     "");
 
 static_assert(
     std::is_same<
-        decltype(ex::simd_cast<ex::simd<int64_t, ex::simd_abi::scalar>>(
-            ex::fixed_size_simd<int32_t, 1>())),
-        ex::simd<int64_t, ex::simd_abi::scalar>>::value,
+        decltype(ex::simd_cast<ex::simd<std::int64_t, ex::simd_abi::scalar>>(
+            ex::fixed_size_simd<std::int32_t, 1>())),
+        ex::simd<std::int64_t, ex::simd_abi::scalar>>::value,
     "");
 
 int main(int, char**) {
diff --git a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
@@ -37,37 +37,37 @@
 void supported_native_simd_ctor(...) = delete;
 
 void compile_narrowing_conversion() {
-  supported_native_simd_ctor<int8_t>(3);
-  supported_native_simd_ctor<int16_t>(3);
-  supported_native_simd_ctor<int32_t>(3);
-  supported_native_simd_ctor<int64_t>(3);
-  supported_native_simd_ctor<uint8_t>(3);
-  supported_native_simd_ctor<uint16_t>(3);
+  supported_native_simd_ctor<std::int8_t>(3);
+  supported_native_simd_ctor<std::int16_t>(3);
+  supported_native_simd_ctor<std::int32_t>(3);
+  supported_native_simd_ctor<std::int64_t>(3);
+  supported_native_simd_ctor<std::uint8_t>(3);
+  supported_native_simd_ctor<std::uint16_t>(3);
   supported_native_simd_ctor<std::uint32_t>(3);
-  supported_native_simd_ctor<uint64_t>(3);
+  supported_native_simd_ctor<std::uint64_t>(3);
   supported_native_simd_ctor<float>(3.f);
   supported_native_simd_ctor<double>(3.);
   supported_native_simd_ctor<long double>(3.);
 
   not_supported_native_simd_ctor<float>(3.);
-  not_supported_native_simd_ctor<int8_t>(long(3));
+  not_supported_native_simd_ctor<std::int8_t>(long(3));
   not_supported_native_simd_ctor<float>(long(3));
   not_supported_native_simd_ctor<int>(3.);
 }
 
 void compile_convertible() {
   struct ConvertibleToInt {
-    operator int64_t() const;
+    operator std::int64_t() const;
   };
-  supported_native_simd_ctor<int64_t>(ConvertibleToInt());
+  supported_native_simd_ctor<std::int64_t>(ConvertibleToInt());
 
   struct NotConvertibleToInt {};
-  not_supported_native_simd_ctor<int64_t>(NotConvertibleToInt());
+  not_supported_native_simd_ctor<std::int64_t>(NotConvertibleToInt());
 }
 
 void compile_unsigned() {
   not_supported_native_simd_ctor<int>(3u);
-  supported_native_simd_ctor<uint16_t>(3u);
+  supported_native_simd_ctor<std::uint16_t>(3u);
 }
 
 template <typename SimdType>
diff --git a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
@@ -21,10 +21,10 @@
 namespace ex = std::experimental::parallelism_v2;
 
 int main(int, char**) {
-  static_assert(ex::native_simd<int32_t>().size() > 0, "");
-  static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, "");
-  static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, "");
-  static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, "");
+  static_assert(ex::native_simd<std::int32_t>().size() > 0, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 4>().size() == 4, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 5>().size() == 5, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 1>().size() == 1, "");
   static_assert(ex::fixed_size_simd<char, 32>().size() == 32, "");
 
   return 0;
diff --git a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -53,15 +53,15 @@
 
 struct limited_identity {
   template <size_t value>
-  typename std::conditional<value <= 2, int32_t, int64_t>::type
+  typename std::conditional<value <= 2, std::int32_t, std::int64_t>::type
   operator()(std::integral_constant<size_t, value>) const {
     return value;
   }
 };
 
 void compile_limited_identity() {
-  supported_simd128_ctor<int64_t>(limited_identity());
-  not_supported_simd128_ctor<int32_t>(limited_identity());
+  supported_simd128_ctor<std::int64_t>(limited_identity());
+  not_supported_simd128_ctor<std::int32_t>(limited_identity());
 }
 
 template <typename SimdType>
@@ -84,9 +84,9 @@
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_generator<ex::native_simd<int32_t>>();
-  test_generator<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_generator<ex::native_simd<std::int32_t>>();
+  test_generator<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
@@ -42,7 +42,7 @@
                                        ex::element_aligned_tag());
   supported_native_simd_ctor<double>((float*)nullptr,
                                      ex::element_aligned_tag());
-  supported_native_simd_ctor<uint16_t>((unsigned int*)nullptr,
+  supported_native_simd_ctor<std::uint16_t>((unsigned int*)nullptr,
                                        ex::element_aligned_tag());
   supported_native_simd_ctor<std::uint32_t>((float*)nullptr,
                                        ex::element_aligned_tag());
@@ -52,7 +52,7 @@
 
 template <typename SimdType>
 void test_load_ctor() {
-  alignas(32) int32_t buffer[] = {4, 3, 2, 1};
+  alignas(32) std::int32_t buffer[] = {4, 3, 2, 1};
   {
     SimdType a(buffer, ex::element_aligned_tag());
     assert(a[0] == 4);
@@ -110,11 +110,11 @@
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load_ctor<ex::native_simd<int32_t>>();
-  test_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load_ctor<ex::native_simd<int32_t>>();
-  test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_load_ctor<ex::native_simd<std::int32_t>>();
+  test_load_ctor<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_load_ctor<ex::native_simd<std::int32_t>>();
+  test_converting_load_ctor<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
@@ -41,7 +41,7 @@
   supported_load<int>((int*)nullptr, ex::element_aligned_tag());
   supported_load<std::uint32_t>((int*)nullptr, ex::element_aligned_tag());
   supported_load<double>((float*)nullptr, ex::element_aligned_tag());
-  supported_load<uint16_t>((unsigned int*)nullptr, ex::element_aligned_tag());
+  supported_load<std::uint16_t>((unsigned int*)nullptr, ex::element_aligned_tag());
   supported_load<std::uint32_t>((float*)nullptr, ex::element_aligned_tag());
 
   not_supported_load<int>((int*)nullptr, int());
@@ -49,7 +49,7 @@
 
 template <typename SimdType>
 void test_load() {
-  alignas(32) int32_t buffer[] = {4, 3, 2, 1};
+  alignas(32) std::int32_t buffer[] = {4, 3, 2, 1};
   {
     SimdType a;
     a.copy_from(buffer, ex::element_aligned_tag());
@@ -114,11 +114,11 @@
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load<ex::native_simd<int32_t>>();
-  test_load<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load<ex::native_simd<int32_t>>();
-  test_converting_load<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_load<ex::native_simd<std::int32_t>>();
+  test_load<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_load<ex::native_simd<std::int32_t>>();
+  test_converting_load<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
@@ -25,7 +25,7 @@
 void test_store() {
   SimdType a([](int i) { return 4 - i; });
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::element_aligned_tag());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -33,7 +33,7 @@
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::vector_aligned_tag());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -41,7 +41,7 @@
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::overaligned_tag<32>());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -50,7 +50,7 @@
   }
 
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::element_aligned);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -58,7 +58,7 @@
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::vector_aligned);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -66,7 +66,7 @@
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::overaligned<32>);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
@@ -88,10 +88,10 @@
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  test_store<ex::native_simd<int32_t>>();
-  test_store<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_store<ex::native_simd<int32_t>>();
-  test_converting_store<ex::fixed_size_simd<int32_t, 4>>();
+  test_store<ex::native_simd<std::int32_t>>();
+  test_store<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_store<ex::native_simd<std::int32_t>>();
+  test_converting_store<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
@@ -23,25 +23,25 @@
 
 struct UserType {};
 
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<int64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint16_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<double>>::value, "");
 
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int64_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint8_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint16_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint32_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<double>>::value, "");
 
@@ -66,25 +66,25 @@
 static_assert(!ex::is_abi_tag<ex::simd_mask<int>>::value, "");
 static_assert(!ex::is_abi_tag<ex::simd_mask<float>>::value, "");
 
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint16_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<float>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<double>>, "");
 
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int64_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint8_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint16_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint32_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<float>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<double>>, "");
 
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -23,47 +23,47 @@
 
 struct UserType {};
 
-static_assert(ex::is_simd<ex::native_simd<int8_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int16_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int32_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<int64_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint8_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint16_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int8_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int16_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int32_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int64_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint8_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint16_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<std::uint32_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint64_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint64_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<float>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<double>>::value, "");
 
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int8_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint64_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 1>>::value, "");
 
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int8_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint64_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 3>>::value, "");
 
-static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int8_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint64_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 32>>::value, "");
 
@@ -74,47 +74,47 @@
 static_assert(!ex::is_simd<ex::simd_mask<float>>::value, "");
 static_assert(!ex::is_simd<UserType>::value, "");
 
-static_assert(ex::is_simd_v<ex::native_simd<int8_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int16_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int32_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<int64_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint8_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint16_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int8_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int16_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int32_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int64_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint8_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint16_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<std::uint32_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint64_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint64_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<float>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<double>>, "");
 
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int8_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint64_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 1>>, "");
 
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int8_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint64_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 3>>, "");
 
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int8_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint64_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 32>>, "");
 
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -32,8 +32,8 @@
 static_assert(!ex::is_simd_flag_type<int>::value, "");
 static_assert(!ex::is_simd_flag_type<float>::value, "");
 static_assert(!ex::is_simd_flag_type<UserType>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd<int8_t>>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd_mask<int8_t>>::value, "");
+static_assert(!ex::is_simd_flag_type<ex::simd<std::int8_t>>::value, "");
+static_assert(!ex::is_simd_flag_type<ex::simd_mask<std::int8_t>>::value, "");
 
 static_assert(ex::is_simd_flag_type_v<ex::element_aligned_tag>, "");
 static_assert(ex::is_simd_flag_type_v<ex::vector_aligned_tag>, "");
@@ -44,8 +44,8 @@
 static_assert(!ex::is_simd_flag_type_v<int>, "");
 static_assert(!ex::is_simd_flag_type_v<float>, "");
 static_assert(!ex::is_simd_flag_type_v<UserType>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, "");
+static_assert(!ex::is_simd_flag_type_v<ex::simd<std::int8_t>>, "");
+static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<std::int8_t>>, "");
 
 int main(int, char**) {
   return 0;
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -23,68 +23,68 @@
 
 struct UserType {};
 
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int8_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int16_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int32_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<int64_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint8_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint16_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int8_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int16_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int32_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int64_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint8_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint16_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint32_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint64_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint64_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<float>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, "");
 
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 1>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int8_t, 1>>::value, "");
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int16_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int32_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int64_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint8_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint16_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint64_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 1>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 1>>::value, "");
 
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 3>>::value, "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int8_t, 3>>::value, "");
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int16_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int32_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int64_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint8_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint16_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint64_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 3>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 3>>::value, "");
 
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int8_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int16_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int32_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::int64_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint8_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint16_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint64_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 32>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 32>>::value,
@@ -97,47 +97,47 @@
 static_assert(!ex::is_simd_mask<ex::simd<float>>::value, "");
 static_assert(!ex::is_simd_mask<UserType>::value, "");
 
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int8_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int16_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int32_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int64_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint8_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint16_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int8_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int16_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int32_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int64_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint8_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint16_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint32_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint64_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint64_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<float>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<double>>, "");
 
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int8_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint64_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 1>>, "");
 
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int8_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint64_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 3>>, "");
 
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int8_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint64_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 32>>, "");
 
diff --git a/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
--- a/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -51,8 +51,8 @@
 
 #ifdef _WIN32
 struct TimeSpec {
-  int64_t tv_sec;
-  int64_t tv_nsec;
+  std::int64_t tv_sec;
+  std::int64_t tv_nsec;
 };
 struct StatT {
   TimeSpec st_atim;
@@ -60,7 +60,7 @@
 };
 // There were 369 years and 89 leap days from the Windows epoch
 // (1601) to the Unix epoch (1970).
-#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
+#define FILE_TIME_OFFSET_SECS (std::uint64_t(369 * 365 + 89) * (24 * 60 * 60))
 static TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
   TimeSpec ret;
   ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
diff --git a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
--- a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -67,9 +67,9 @@
     test<unsigned int>(d, "4294967295");
     test<unsigned int>(x, "0xffffffff");
 
-    const bool long_is_32 = std::integral_constant<bool, sizeof(long) == sizeof(int32_t)>::value; // avoid compiler warnings
-    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(int64_t)>::value; // avoid compiler warnings
-    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(int64_t)>::value; // avoid compiler warnings
+    const bool long_is_32 = std::integral_constant<bool, sizeof(long) == sizeof(std::int32_t)>::value; // avoid compiler warnings
+    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
 
     if (long_is_32) {
         test<long>(o, "020000000000");
diff --git a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
--- a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
+++ b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -63,16 +63,16 @@
 int main(int, char**)
 {
 
-    test_octal<uint16_t>(                "177777");
-    test_octal< int16_t>(                "177777");
+    test_octal<std::uint16_t>(                "177777");
+    test_octal< std::int16_t>(                "177777");
     test_octal<std::uint32_t>(           "37777777777");
-    test_octal< int32_t>(           "37777777777");
-    test_octal<uint64_t>("1777777777777777777777");
-    test_octal< int64_t>("1777777777777777777777");
-    test_octal<uint64_t>("1777777777777777777777");
+    test_octal< std::int32_t>(           "37777777777");
+    test_octal<std::uint64_t>("1777777777777777777777");
+    test_octal< std::int64_t>("1777777777777777777777");
+    test_octal<std::uint64_t>("1777777777777777777777");
 
-    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(int64_t)>::value; // avoid compiler warnings
-    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(int64_t)>::value; // avoid compiler warnings
+    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
 
     if (long_is_64) {
         test_octal< unsigned long>("1777777777777777777777");
@@ -83,12 +83,12 @@
         test_octal<          long long>("1777777777777777777777");
     }
 
-    test_dec<uint16_t>(               "65535");
-    test_dec< int16_t>(                  "-1");
+    test_dec<std::uint16_t>(               "65535");
+    test_dec< std::int16_t>(                  "-1");
     test_dec<std::uint32_t>(          "4294967295");
-    test_dec< int32_t>(                  "-1");
-    test_dec<uint64_t>("18446744073709551615");
-    test_dec< int64_t>(                  "-1");
+    test_dec< std::int32_t>(                  "-1");
+    test_dec<std::uint64_t>("18446744073709551615");
+    test_dec< std::int64_t>(                  "-1");
     if (long_is_64) {
         test_dec<unsigned long>("18446744073709551615");
         test_dec<         long>(                  "-1");
@@ -98,12 +98,12 @@
         test_dec<         long long>(                  "-1");
     }
 
-    test_hex<uint16_t>(            "FFFF");
-    test_hex< int16_t>(            "FFFF");
+    test_hex<std::uint16_t>(            "FFFF");
+    test_hex< std::int16_t>(            "FFFF");
     test_hex<std::uint32_t>(        "FFFFFFFF");
-    test_hex< int32_t>(        "FFFFFFFF");
-    test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
-    test_hex< int64_t>("FFFFFFFFFFFFFFFF");
+    test_hex< std::int32_t>(        "FFFFFFFF");
+    test_hex<std::uint64_t>("FFFFFFFFFFFFFFFF");
+    test_hex< std::int64_t>("FFFFFFFFFFFFFFFF");
     if (long_is_64) {
         test_hex<unsigned long>("FFFFFFFFFFFFFFFF");
         test_hex<         long>("FFFFFFFFFFFFFFFF");
diff --git a/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp b/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
--- a/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
@@ -30,7 +30,7 @@
 TEST_GCC_DIAGNOSTIC_IGNORED("-Wtype-limits")
 
 struct short_container {
-    uint16_t size() const { return 60000; } // not noexcept
+    std::uint16_t size() const { return 60000; } // not noexcept
 };
 
 template<typename C>
diff --git a/libcxx/test/std/language.support/support.srcloc/general.pass.cpp b/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
--- a/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
+++ b/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
@@ -43,8 +43,8 @@
 ASSERT_NOEXCEPT(empty.column());
 ASSERT_NOEXCEPT(empty.file_name());
 ASSERT_NOEXCEPT(empty.function_name());
-std::same_as<uint_least32_t> auto line   = empty.line();
-std::same_as<uint_least32_t> auto column = empty.column();
+std::same_as<std::uint_least32_t> auto line   = empty.line();
+std::same_as<std::uint_least32_t> auto column = empty.column();
 std::same_as<const char*> auto file      = empty.file_name();
 std::same_as<const char*> auto function  = empty.function_name();
 
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
@@ -39,10 +39,10 @@
     static_assert(toobig<unsigned long>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned long long>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
-    static_assert(toobig<uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-    static_assert(toobig<uint16_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<std::uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<std::uint16_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::uint32_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-    static_assert(toobig<uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<std::uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<size_t>(), "");    // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uintmax_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uintptr_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
@@ -84,10 +84,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -115,10 +115,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -131,10 +131,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
@@ -81,10 +81,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -113,10 +113,10 @@
     static_assert(test<__uint128_t>());
 #endif
 
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -130,10 +130,10 @@
     test<__uint128_t>();
 #endif
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
@@ -86,10 +86,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -117,10 +117,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -133,10 +133,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
--- a/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
@@ -84,10 +84,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -115,10 +115,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -131,10 +131,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
@@ -81,10 +81,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -112,10 +112,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -128,10 +128,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
@@ -80,10 +80,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -111,10 +111,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -127,10 +127,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
@@ -85,10 +85,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -116,10 +116,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -132,10 +132,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
@@ -82,10 +82,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -113,10 +113,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -129,10 +129,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
@@ -92,10 +92,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -123,10 +123,10 @@
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -139,10 +139,10 @@
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
@@ -80,10 +80,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -112,10 +112,10 @@
     static_assert(test<__uint128_t>());
 #endif
 
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -129,10 +129,10 @@
     test<__uint128_t>();
 #endif
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
@@ -81,10 +81,10 @@
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
@@ -113,10 +113,10 @@
     static_assert(test<__uint128_t>());
 #endif
 
-    static_assert(test<uint8_t>());
-    static_assert(test<uint16_t>());
+    static_assert(test<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
@@ -130,10 +130,10 @@
     test<__uint128_t>();
 #endif
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
diff --git a/libcxx/test/std/numerics/bit/byteswap.pass.cpp b/libcxx/test/std/numerics/bit/byteswap.pass.cpp
--- a/libcxx/test/std/numerics/bit/byteswap.pass.cpp
+++ b/libcxx/test/std/numerics/bit/byteswap.pass.cpp
@@ -54,15 +54,15 @@
 }
 
 constexpr bool test() {
-  test_num<uint8_t>(0xAB, 0xAB);
-  test_num<uint16_t>(0xCDEF, 0xEFCD);
+  test_num<std::uint8_t>(0xAB, 0xAB);
+  test_num<std::uint16_t>(0xCDEF, 0xEFCD);
   test_num<std::uint32_t>(0x01234567, 0x67452301);
-  test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
+  test_num<std::uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
-  test_num<int8_t>(static_cast<int8_t>(0xAB), static_cast<int8_t>(0xAB));
-  test_num<int16_t>(static_cast<int16_t>(0xCDEF), static_cast<int16_t>(0xEFCD));
-  test_num<int32_t>(0x01234567, 0x67452301);
-  test_num<int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
+  test_num<std::int8_t>(static_cast<std::int8_t>(0xAB), static_cast<std::int8_t>(0xAB));
+  test_num<std::int16_t>(static_cast<std::int16_t>(0xCDEF), static_cast<std::int16_t>(0xEFCD));
+  test_num<std::int32_t>(0x01234567, 0x67452301);
+  test_num<std::int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
 #ifndef TEST_HAS_NO_INT128
   const auto in = static_cast<__uint128_t>(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
diff --git a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
--- a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
@@ -115,10 +115,10 @@
     signed_test<long>();
     signed_test<long long>();
 
-    signed_test<int8_t>();
-    signed_test<int16_t>();
-    signed_test<int32_t>();
-    signed_test<int64_t>();
+    signed_test<std::int8_t>();
+    signed_test<std::int16_t>();
+    signed_test<std::int32_t>();
+    signed_test<std::int64_t>();
 
     unsigned_test<unsigned char>();
     unsigned_test<unsigned short>();
@@ -126,10 +126,10 @@
     unsigned_test<unsigned long>();
     unsigned_test<unsigned long long>();
 
-    unsigned_test<uint8_t>();
-    unsigned_test<uint16_t>();
+    unsigned_test<std::uint8_t>();
+    unsigned_test<std::uint16_t>();
     unsigned_test<std::uint32_t>();
-    unsigned_test<uint64_t>();
+    unsigned_test<std::uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     unsigned_test<__uint128_t>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -529,8 +529,8 @@
     tests<unsigned long long>();
 
 #if defined(_LIBCPP_VERSION) // extension
-    tests<int8_t>();
-    tests<uint8_t>();
+    tests<std::int8_t>();
+    tests<std::uint8_t>();
 #if !defined(TEST_HAS_NO_INT128)
     tests<__int128_t>();
     tests<__uint128_t>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
@@ -306,8 +306,8 @@
     tests<unsigned long long>();
 
 #if defined(_LIBCPP_VERSION) // extension
-    tests<int8_t>();
-    tests<uint8_t>();
+    tests<std::int8_t>();
+    tests<std::uint8_t>();
 #if !defined(TEST_HAS_NO_INT128)
     tests<__int128_t>();
     tests<__uint128_t>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -124,8 +124,8 @@
     test_statistics<short, std::minstd_rand0>(SHRT_MIN, SHRT_MAX);
 
 #if defined(_LIBCPP_VERSION) // extension
-    test_statistics<int8_t, std::minstd_rand0>();
-    test_statistics<uint8_t, std::minstd_rand0>();
+    test_statistics<std::int8_t, std::minstd_rand0>();
+    test_statistics<std::uint8_t, std::minstd_rand0>();
 
 #if !defined(TEST_HAS_NO_INT128) && !defined(TEST_BUGGY_I128_FP)
     test_statistics<__int128_t, std::minstd_rand0>();
diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
--- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
@@ -267,8 +267,8 @@
     test1();
     test2();
 
-    test_implicit<std::mt19937, uint_fast32_t>();
-    test_implicit<std::mt19937_64, uint_fast64_t>();
+    test_implicit<std::mt19937, std::uint_fast32_t>();
+    test_implicit<std::mt19937_64, std::uint_fast64_t>();
 
     return 0;
 }
diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
--- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
@@ -76,8 +76,8 @@
     static_assert(test_convertible<std::ranlux48_base>(), "");
     test_implicit_ctor<std::ranlux24_base>();
     test_implicit_ctor<std::ranlux48_base>();
-    static_assert(!test_convertible<std::ranlux24_base, uint_fast32_t>(), "");
-    static_assert(!test_convertible<std::ranlux48_base, uint_fast64_t>(), "");
+    static_assert(!test_convertible<std::ranlux24_base, std::uint_fast32_t>(), "");
+    static_assert(!test_convertible<std::ranlux48_base, std::uint_fast64_t>(), "");
 #endif
 
   return 0;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -154,7 +154,7 @@
 
   { // test appending a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -155,7 +155,7 @@
 
   { // test assigning a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.assign(p, p + 4);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -145,7 +145,7 @@
 
   { // test assigning a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -1028,8 +1028,8 @@
   }
 
   { // test assigning a different type
-    const uint8_t pc[] = "ABCD";
-    uint8_t        p[] = "EFGH";
+    const std::uint8_t pc[] = "ABCD";
+    std::uint8_t        p[] = "EFGH";
 
     S s;
     s.replace(s.begin(), s.end(), pc, pc + 4);
diff --git a/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp b/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
--- a/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
+++ b/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 
 template <typename Duration>
-constexpr int64_t check_seconds(Duration d)
+constexpr std::int64_t check_seconds(Duration d)
 {
     using HMS = std::chrono::hh_mm_ss<Duration>;
     ASSERT_SAME_TYPE(std::chrono::seconds, decltype(std::declval<HMS>().seconds()));
diff --git a/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp b/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
--- a/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
+++ b/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
@@ -24,7 +24,7 @@
 #include "test_macros.h"
 
 template <typename Duration>
-constexpr int64_t check_subseconds(Duration d)
+constexpr std::int64_t check_subseconds(Duration d)
 {
     using HMS = std::chrono::hh_mm_ss<Duration>;
     ASSERT_SAME_TYPE(typename HMS::precision, decltype(std::declval<HMS>().subseconds()));
diff --git a/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
--- a/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
+++ b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
@@ -149,7 +149,7 @@
            "%EX='03:02:01'\t"
            "\n"),
         fmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   // The number of fractional seconds is 0 according to the Standard
   // TODO FMT Determine what to do.
@@ -260,7 +260,7 @@
            "%EX='03:02:01'\t"
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(SV("%H='01'\t"
            "%OH='01'\t"
@@ -379,7 +379,7 @@
 #  endif
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(loc,
         SV("%H='01'\t"
@@ -466,7 +466,7 @@
            "%EX='03時02分01秒'\t"
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(loc,
         SV("%H='01'\t"
diff --git a/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp b/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
--- a/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
+++ b/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
@@ -7,7 +7,7 @@
 #include <stdint.h>
 #include <utility>
 
-constexpr std::pair<const char*, uint64_t> floating_point_test_cases_double[] = {
+constexpr std::pair<const char*, std::uint64_t> floating_point_test_cases_double[] = {
     // Verify small exactly-representable integers:
     {"1", 0x3FF0000000000000ULL},
     {"2", 0x4000000000000000ULL},
diff --git a/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp b/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
--- a/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
+++ b/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
@@ -187,12 +187,12 @@
     "1t", "1u", "1v", "1w", "1x", "1y", "1z"};
 
 // https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
-constexpr uint64_t stress_chunks_positive                          = 12000000345000678900ULL;
-constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
+constexpr std::uint64_t stress_chunks_positive                          = 12000000345000678900ULL;
+constexpr pair<std::uint64_t, array<const char*, 37>> output_positive[] = {
     {123U, {{"skip0", "skip1", "1111011", "11120", "1323", "443", "323", "234", "173", "146", "123", "102", "a3", "96",
                "8b", "83", "7b", "74", "6f", "69", "63", "5i", "5d", "58", "53", "4n", "4j", "4f", "4b", "47", "43",
                "3u", "3r", "3o", "3l", "3i", "3f"}}},
-    {uint64_t{INT8_MAX}, {{"skip0", "skip1", "1111111", "11201", "1333", "1002", "331", "241", "177", "151", "127",
+    {std::uint64_t{INT8_MAX}, {{"skip0", "skip1", "1111111", "11201", "1333", "1002", "331", "241", "177", "151", "127",
                              "106", "a7", "9a", "91", "87", "7f", "78", "71", "6d", "67", "61", "5h", "5c", "57", "52",
                              "4n", "4j", "4f", "4b", "47", "43", "3v", "3s", "3p", "3m", "3j"}}},
     {161U, {{"skip0", "skip1", "10100001", "12222", "2201", "1121", "425", "320", "241", "188", "161", "137", "115",
@@ -204,7 +204,7 @@
     {1729U, {{"skip0", "skip1", "11011000001", "2101001", "123001", "23404", "12001", "5020", "3301", "2331", "1729",
                 "1332", "1001", "a30", "8b7", "7a4", "6c1", "5gc", "561", "4f0", "469", "3j7", "3cd", "364", "301",
                 "2j4", "2ed", "2a1", "25l", "21i", "1rj", "1oo", "1m1", "1jd", "1gt", "1ee", "1c1"}}},
-    {uint64_t{INT16_MAX}, {{"skip0", "skip1", "111111111111111", "1122221121", "13333333", "2022032", "411411",
+    {std::uint64_t{INT16_MAX}, {{"skip0", "skip1", "111111111111111", "1122221121", "13333333", "2022032", "411411",
                               "164350", "77777", "48847", "32767", "22689", "16b67", "11bb7", "bd27", "9a97", "7fff",
                               "6b68", "5b27", "4eeb", "41i7", "3b67", "31f9", "2flf", "28l7", "22ah", "1mc7", "1hpg",
                               "1dm7", "19rq", "16c7", "1330", "vvv", "u2v", "sbp", "qq7", "pa7"}}},
@@ -221,7 +221,7 @@
                     "1b9a06b2", "11973ba8", "9636514", "639e338", "43d49e6", "2g19gfb", "21b9d18", "19dec94", "124addi",
                     "h8f25b", "dhdfa6", "b13hg2", "8m91he", "7720j3", "5pgj58", "4pmelq", "43k17i", "3dg8ek", "2ro898",
                     "2f0et8", "23qif6", "1qw5lh", "1j7l7s", "1cdvli", "16cgrq"}}},
-    {uint64_t{INT32_MAX},
+    {std::uint64_t{INT32_MAX},
         {{"skip0", "skip1", "1111111111111111111111111111111", "12112122212110202101", "1333333333333333",
             "13344223434042", "553032005531", "104134211161", "17777777777", "5478773671", "2147483647", "a02220281",
             "4bb2308a7", "282ba4aaa", "1652ca931", "c87e66b7", "7fffffff", "53g7f548", "3928g3h1", "27c57h32",
@@ -247,7 +247,7 @@
             "4d0d5e232c53", "2d63h403i580", "1bf5h8185hdj", "kc3g550fkcg", "d41id5k9984", "8ef5n0him4g", "5i2dijfe1la",
             "3me22fm5fhi", "2hfmhgg73kd", "1ngpfabr53c", "18i7220bh11", "rm0lcjngpa", "kk1elesni1", "fgfge3c3fg",
             "bp4q5l6bjg", "8xna46jp0k", "6wejomvji5", "5di2s1qhv4"}}},
-    {uint64_t{INT64_MAX},
+    {std::uint64_t{INT64_MAX},
         {{"skip0", "skip1", "111111111111111111111111111111111111111111111111111111111111111",
             "2021110011022210012102010021220101220221", "13333333333333333333333333333333",
             "1104332401304422434310311212", "1540241003031030222122211", "22341010611245052052300",
@@ -290,8 +290,8 @@
 };
 
 // https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
-constexpr int64_t stress_chunks_negative                          = -9000876000000054321LL;
-constexpr pair<int64_t, array<const char*, 37>> output_negative[] = {
+constexpr std::int64_t stress_chunks_negative                          = -9000876000000054321LL;
+constexpr pair<std::int64_t, array<const char*, 37>> output_negative[] = {
     {-85, {{"skip0", "skip1", "-1010101", "-10011", "-1111", "-320", "-221", "-151", "-125", "-104", "-85", "-78",
               "-71", "-67", "-61", "-5a", "-55", "-50", "-4d", "-49", "-45", "-41", "-3j", "-3g", "-3d", "-3a", "-37",
               "-34", "-31", "-2r", "-2p", "-2n", "-2l", "-2j", "-2h", "-2f", "-2d"}}},
@@ -360,7 +360,7 @@
         test_integer_to_chars(static_cast<T>(base * 2 - 1), base, output_max_digit[base]);
 
         for (const auto& p : output_positive) {
-            if (p.first <= static_cast<uint64_t>(numeric_limits<T>::max())) {
+            if (p.first <= static_cast<std::uint64_t>(numeric_limits<T>::max())) {
                 test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<size_t>(base)]);
             }
         }
@@ -369,7 +369,7 @@
             test_integer_to_chars(static_cast<T>(-1), base, "-1");
 
             for (const auto& p : output_negative) {
-                if (p.first >= static_cast<int64_t>(numeric_limits<T>::min())) {
+                if (p.first >= static_cast<std::int64_t>(numeric_limits<T>::min())) {
                     test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<size_t>(base)]);
                 }
             }
@@ -402,7 +402,7 @@
     if (correct_ec == errc{} || (is_floating_point_v<T> && correct_ec == errc::result_out_of_range)) {
         if constexpr (is_floating_point_v<T>) {
             if (mode == TestFromCharsMode::Normal) {
-                using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, uint64_t>;
+                using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, std::uint64_t>;
                 assert(opt_correct.has_value());
                 assert(_Bit_cast<Uint>(dest) == _Bit_cast<Uint>(opt_correct.value()));
             } else {
@@ -553,7 +553,7 @@
     }
 }
 
-void assert_message_bits(const bool b, const char* const msg, const uint64_t bits) {
+void assert_message_bits(const bool b, const char* const msg, const std::uint64_t bits) {
     if (!b) {
         // libc++ uses long for 64-bit values.
         fprintf(stderr, "%s failed for 0x%016llX\n", msg, static_cast<unsigned long long>(bits));
@@ -570,7 +570,7 @@
 
 constexpr std::uint32_t Fractions = 1U << FractionBits;
 constexpr std::uint32_t Mask32    = ~((1U << FractionBits) - 1U);
-constexpr uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
+constexpr std::uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
 
 constexpr std::uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
 static_assert(PrefixesToTest >= 1, "Must test at least 1 prefix.");
@@ -581,9 +581,9 @@
 static_assert(PrefixesToTest <= PrefixLimit, "Too many prefixes.");
 
 template <bool IsDouble>
-void test_floating_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
+void test_floating_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // "-1.2345678901234567e-100" or "-1.23456789e-10"
@@ -643,9 +643,9 @@
 }
 
 template <bool IsDouble>
-void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
+void test_floating_hex_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // The precision is the number of hexits after the decimal point.
@@ -681,9 +681,9 @@
 }
 
 template <bool IsDouble>
-void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
+void test_floating_precision_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // Precision for min subnormal in fixed notation. (More than enough for scientific notation.)
@@ -748,10 +748,10 @@
 
 void test_floating_prefixes(mt19937_64& mt64) {
     {
-        set<uint64_t> prefixes64;
+        set<std::uint64_t> prefixes64;
 
         while (prefixes64.size() < PrefixesToTest) {
-            const uint64_t val = mt64();
+            const std::uint64_t val = mt64();
 
             if ((val & 0x7FF0000000000000ULL) != 0x7FF0000000000000ULL) { // skip INF/NAN
                 prefixes64.insert(val & Mask64);
diff --git a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
--- a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -23,26 +23,26 @@
 #include "charconv_test_helpers.h"
 
 #ifndef TEST_HAS_NO_INT128
-TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, std::uint64_t b) {
   a *= 1000000000000000000UL;
   a *= 10;
   return a + b;
 }
 
-TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b, uint64_t c) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, std::uint64_t b, std::uint64_t c) {
   a *= 10000000000000ULL;
   a += b;
   a *= 10000000000000ULL;
   return a + c;
 }
 
-TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, int64_t b) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, std::int64_t b) {
   if (a < 0)
     return -make_u128(-a, b);
   return make_u128(a, b);
 }
 
-TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, __int128_t b, int64_t c) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, __int128_t b, std::int64_t c) {
   if (a < 0)
     return -make_u128(-a, b, c);
   return make_u128(a, b, c);
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
--- a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
@@ -88,8 +88,8 @@
     test_termination_condition(STR("2147483647"), STR("}"), A(2147483647));
   }
   if (sizeof(A) > 4) {
-    test_termination_condition(STR("-9223372036854775808"), STR("}"), A(std::numeric_limits<int64_t>::min()));
-    test_termination_condition(STR("9223372036854775807"), STR("}"), A(std::numeric_limits<int64_t>::max()));
+    test_termination_condition(STR("-9223372036854775808"), STR("}"), A(std::numeric_limits<std::int64_t>::min()));
+    test_termination_condition(STR("9223372036854775807"), STR("}"), A(std::numeric_limits<std::int64_t>::max()));
   }
 #ifndef TEST_HAS_NO_INT128
   if (sizeof(A) > 8) {
diff --git a/libcxx/test/std/utilities/format/format.functions/format_tests.h b/libcxx/test/std/utilities/format/format.functions/format_tests.h
--- a/libcxx/test/std/utilities/format/format.functions/format_tests.h
+++ b/libcxx/test/std/utilities/format/format.functions/format_tests.h
@@ -663,27 +663,27 @@
   format_test_integer<__int128_t, CharT>(check, check_exception);
 #endif
   // *** check the minma and maxima ***
-  check(SV("-0b10000000"), SV("{:#b}"), std::numeric_limits<int8_t>::min());
-  check(SV("-0200"), SV("{:#o}"), std::numeric_limits<int8_t>::min());
-  check(SV("-128"), SV("{:#}"), std::numeric_limits<int8_t>::min());
-  check(SV("-0x80"), SV("{:#x}"), std::numeric_limits<int8_t>::min());
+  check(SV("-0b10000000"), SV("{:#b}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-0200"), SV("{:#o}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-128"), SV("{:#}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-0x80"), SV("{:#x}"), std::numeric_limits<std::int8_t>::min());
 
-  check(SV("-0b1000000000000000"), SV("{:#b}"), std::numeric_limits<int16_t>::min());
-  check(SV("-0100000"), SV("{:#o}"), std::numeric_limits<int16_t>::min());
-  check(SV("-32768"), SV("{:#}"), std::numeric_limits<int16_t>::min());
-  check(SV("-0x8000"), SV("{:#x}"), std::numeric_limits<int16_t>::min());
+  check(SV("-0b1000000000000000"), SV("{:#b}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-0100000"), SV("{:#o}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-32768"), SV("{:#}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-0x8000"), SV("{:#x}"), std::numeric_limits<std::int16_t>::min());
 
-  check(SV("-0b10000000000000000000000000000000"), SV("{:#b}"), std::numeric_limits<int32_t>::min());
-  check(SV("-020000000000"), SV("{:#o}"), std::numeric_limits<int32_t>::min());
-  check(SV("-2147483648"), SV("{:#}"), std::numeric_limits<int32_t>::min());
-  check(SV("-0x80000000"), SV("{:#x}"), std::numeric_limits<int32_t>::min());
+  check(SV("-0b10000000000000000000000000000000"), SV("{:#b}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-020000000000"), SV("{:#o}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-2147483648"), SV("{:#}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-0x80000000"), SV("{:#x}"), std::numeric_limits<std::int32_t>::min());
 
   check(SV("-0b1000000000000000000000000000000000000000000000000000000000000000"),
         SV("{:#b}"),
-        std::numeric_limits<int64_t>::min());
-  check(SV("-01000000000000000000000"), SV("{:#o}"), std::numeric_limits<int64_t>::min());
-  check(SV("-9223372036854775808"), SV("{:#}"), std::numeric_limits<int64_t>::min());
-  check(SV("-0x8000000000000000"), SV("{:#x}"), std::numeric_limits<int64_t>::min());
+        std::numeric_limits<std::int64_t>::min());
+  check(SV("-01000000000000000000000"), SV("{:#o}"), std::numeric_limits<std::int64_t>::min());
+  check(SV("-9223372036854775808"), SV("{:#}"), std::numeric_limits<std::int64_t>::min());
+  check(SV("-0x8000000000000000"), SV("{:#x}"), std::numeric_limits<std::int64_t>::min());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("-0b1000000000000000000000000000000000000000000000000000000000000000"
@@ -695,27 +695,27 @@
   check(SV("-0x80000000000000000000000000000000"), SV("{:#x}"), std::numeric_limits<__int128_t>::min());
 #endif
 
-  check(SV("0b1111111"), SV("{:#b}"), std::numeric_limits<int8_t>::max());
-  check(SV("0177"), SV("{:#o}"), std::numeric_limits<int8_t>::max());
-  check(SV("127"), SV("{:#}"), std::numeric_limits<int8_t>::max());
-  check(SV("0x7f"), SV("{:#x}"), std::numeric_limits<int8_t>::max());
+  check(SV("0b1111111"), SV("{:#b}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("0177"), SV("{:#o}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("127"), SV("{:#}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("0x7f"), SV("{:#x}"), std::numeric_limits<std::int8_t>::max());
 
-  check(SV("0b111111111111111"), SV("{:#b}"), std::numeric_limits<int16_t>::max());
-  check(SV("077777"), SV("{:#o}"), std::numeric_limits<int16_t>::max());
-  check(SV("32767"), SV("{:#}"), std::numeric_limits<int16_t>::max());
-  check(SV("0x7fff"), SV("{:#x}"), std::numeric_limits<int16_t>::max());
+  check(SV("0b111111111111111"), SV("{:#b}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("077777"), SV("{:#o}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("32767"), SV("{:#}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("0x7fff"), SV("{:#x}"), std::numeric_limits<std::int16_t>::max());
 
-  check(SV("0b1111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<int32_t>::max());
-  check(SV("017777777777"), SV("{:#o}"), std::numeric_limits<int32_t>::max());
-  check(SV("2147483647"), SV("{:#}"), std::numeric_limits<int32_t>::max());
-  check(SV("0x7fffffff"), SV("{:#x}"), std::numeric_limits<int32_t>::max());
+  check(SV("0b1111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("017777777777"), SV("{:#o}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("2147483647"), SV("{:#}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("0x7fffffff"), SV("{:#x}"), std::numeric_limits<std::int32_t>::max());
 
   check(SV("0b111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
-        std::numeric_limits<int64_t>::max());
-  check(SV("0777777777777777777777"), SV("{:#o}"), std::numeric_limits<int64_t>::max());
-  check(SV("9223372036854775807"), SV("{:#}"), std::numeric_limits<int64_t>::max());
-  check(SV("0x7fffffffffffffff"), SV("{:#x}"), std::numeric_limits<int64_t>::max());
+        std::numeric_limits<std::int64_t>::max());
+  check(SV("0777777777777777777777"), SV("{:#o}"), std::numeric_limits<std::int64_t>::max());
+  check(SV("9223372036854775807"), SV("{:#}"), std::numeric_limits<std::int64_t>::max());
+  check(SV("0x7fffffffffffffff"), SV("{:#x}"), std::numeric_limits<std::int64_t>::max());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("0b111111111111111111111111111111111111111111111111111111111111111"
@@ -739,15 +739,15 @@
   format_test_integer<__uint128_t, CharT>(check, check_exception);
 #endif
   // *** test the maxima ***
-  check(SV("0b11111111"), SV("{:#b}"), std::numeric_limits<uint8_t>::max());
-  check(SV("0377"), SV("{:#o}"), std::numeric_limits<uint8_t>::max());
-  check(SV("255"), SV("{:#}"), std::numeric_limits<uint8_t>::max());
-  check(SV("0xff"), SV("{:#x}"), std::numeric_limits<uint8_t>::max());
+  check(SV("0b11111111"), SV("{:#b}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("0377"), SV("{:#o}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("255"), SV("{:#}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("0xff"), SV("{:#x}"), std::numeric_limits<std::uint8_t>::max());
 
-  check(SV("0b1111111111111111"), SV("{:#b}"), std::numeric_limits<uint16_t>::max());
-  check(SV("0177777"), SV("{:#o}"), std::numeric_limits<uint16_t>::max());
-  check(SV("65535"), SV("{:#}"), std::numeric_limits<uint16_t>::max());
-  check(SV("0xffff"), SV("{:#x}"), std::numeric_limits<uint16_t>::max());
+  check(SV("0b1111111111111111"), SV("{:#b}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("0177777"), SV("{:#o}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("65535"), SV("{:#}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("0xffff"), SV("{:#x}"), std::numeric_limits<std::uint16_t>::max());
 
   check(SV("0b11111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<std::uint32_t>::max());
   check(SV("037777777777"), SV("{:#o}"), std::numeric_limits<std::uint32_t>::max());
@@ -756,10 +756,10 @@
 
   check(SV("0b1111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
-        std::numeric_limits<uint64_t>::max());
-  check(SV("01777777777777777777777"), SV("{:#o}"), std::numeric_limits<uint64_t>::max());
-  check(SV("18446744073709551615"), SV("{:#}"), std::numeric_limits<uint64_t>::max());
-  check(SV("0xffffffffffffffff"), SV("{:#x}"), std::numeric_limits<uint64_t>::max());
+        std::numeric_limits<std::uint64_t>::max());
+  check(SV("01777777777777777777777"), SV("{:#o}"), std::numeric_limits<std::uint64_t>::max());
+  check(SV("18446744073709551615"), SV("{:#}"), std::numeric_limits<std::uint64_t>::max());
+  check(SV("0xffffffffffffffff"), SV("{:#x}"), std::numeric_limits<std::uint64_t>::max());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("0b1111111111111111111111111111111111111111111111111111111111111111"
diff --git a/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -23,7 +23,7 @@
 enum class Cardinals { zero, one, two, three, five=5 };
 enum class LongColors : short { red, orange, yellow, green, blue, indigo, violet };
 enum class ShortColors : long { red, orange, yellow, green, blue, indigo, violet };
-enum class EightBitColors : uint8_t { red, orange, yellow, green, blue, indigo, violet };
+enum class EightBitColors : std::uint8_t { red, orange, yellow, green, blue, indigo, violet };
 
 enum Fruits { apple, pear, grape, mango, cantaloupe };
 
diff --git a/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
--- a/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -74,38 +74,38 @@
     test<std::ptrdiff_t>();
     test<size_t>();
 
-    test<int8_t>();
-    test<int16_t>();
-    test<int32_t>();
-    test<int64_t>();
+    test<std::int8_t>();
+    test<std::int16_t>();
+    test<std::int32_t>();
+    test<std::int64_t>();
 
-    test<int_fast8_t>();
-    test<int_fast16_t>();
-    test<int_fast32_t>();
-    test<int_fast64_t>();
+    test<std::int_fast8_t>();
+    test<std::int_fast16_t>();
+    test<std::int_fast32_t>();
+    test<std::int_fast64_t>();
 
-    test<int_least8_t>();
-    test<int_least16_t>();
-    test<int_least32_t>();
-    test<int_least64_t>();
+    test<std::int_least8_t>();
+    test<std::int_least16_t>();
+    test<std::int_least32_t>();
+    test<std::int_least64_t>();
 
     test<intmax_t>();
     test<intptr_t>();
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
 
-    test<uint_fast8_t>();
-    test<uint_fast16_t>();
-    test<uint_fast32_t>();
-    test<uint_fast64_t>();
+    test<std::uint_fast8_t>();
+    test<std::uint_fast16_t>();
+    test<std::uint_fast32_t>();
+    test<std::uint_fast64_t>();
 
-    test<uint_least8_t>();
-    test<uint_least16_t>();
-    test<uint_least32_t>();
-    test<uint_least64_t>();
+    test<std::uint_least8_t>();
+    test<std::uint_least16_t>();
+    test<std::uint_least32_t>();
+    test<std::uint_least64_t>();
 
     test<uintmax_t>();
     test<uintptr_t>();
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
--- a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
@@ -47,14 +47,14 @@
 }
 
 constexpr void test_in_range() {
-  constexpr Tuple<uint8_t> utup8;
-  constexpr Tuple<int8_t> stup8;
-  assert(!std::in_range<int8_t>(utup8.max));
+  constexpr Tuple<std::uint8_t> utup8;
+  constexpr Tuple<std::int8_t> stup8;
+  assert(!std::in_range<std::int8_t>(utup8.max));
   assert(std::in_range<short>(utup8.max));
-  assert(!std::in_range<uint8_t>(stup8.min));
-  assert(std::in_range<int8_t>(utup8.mid));
-  assert(!std::in_range<uint8_t>(stup8.mid));
-  assert(!std::in_range<uint8_t>(-1));
+  assert(!std::in_range<std::uint8_t>(stup8.min));
+  assert(std::in_range<std::int8_t>(utup8.mid));
+  assert(!std::in_range<std::uint8_t>(stup8.mid));
+  assert(!std::in_range<std::uint8_t>(-1));
 }
 
 template <class... Ts>
diff --git a/libcxx/test/support/atomic_helpers.h b/libcxx/test/support/atomic_helpers.h
--- a/libcxx/test/support/atomic_helpers.h
+++ b/libcxx/test/support/atomic_helpers.h
@@ -84,14 +84,14 @@
 #endif
     TestFunctor<char16_t>()();
     TestFunctor<char32_t>()();
-    TestFunctor<int8_t>()();
-    TestFunctor<uint8_t>()();
-    TestFunctor<int16_t>()();
-    TestFunctor<uint16_t>()();
-    TestFunctor<int32_t>()();
+    TestFunctor<std::int8_t>()();
+    TestFunctor<std::uint8_t>()();
+    TestFunctor<std::int16_t>()();
+    TestFunctor<std::uint16_t>()();
+    TestFunctor<std::int32_t>()();
     TestFunctor<std::uint32_t>()();
-    TestFunctor<int64_t>()();
-    TestFunctor<uint64_t>()();
+    TestFunctor<std::int64_t>()();
+    TestFunctor<std::uint64_t>()();
   }
 };
 
diff --git a/libcxx/test/support/filesystem_test_helper.h b/libcxx/test/support/filesystem_test_helper.h
--- a/libcxx/test/support/filesystem_test_helper.h
+++ b/libcxx/test/support/filesystem_test_helper.h
@@ -102,7 +102,7 @@
     // N.B. libc might define some of the foo[64] identifiers using macros from
     // foo64 -> foo or vice versa.
 #if defined(_WIN32)
-    using off64_t = int64_t;
+    using off64_t = std::int64_t;
 #elif defined(__MVS__) || defined(__LP64__)
     using off64_t = ::off_t;
 #else
diff --git a/libcxx/test/support/format.functions.common.h b/libcxx/test/support/format.functions.common.h
--- a/libcxx/test/support/format.functions.common.h
+++ b/libcxx/test/support/format.functions.common.h
@@ -44,7 +44,7 @@
 using context_t = typename context<T>::type;
 
 // A user-defined type used to test the handle formatter.
-enum class status : uint16_t { foo = 0xAAAA, bar = 0x5555, foobar = 0xAA55 };
+enum class status : std::uint16_t { foo = 0xAAAA, bar = 0x5555, foobar = 0xAA55 };
 
 // The formatter for a user-defined type used to test the handle formatter.
 template <class CharT>
@@ -90,7 +90,7 @@
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'x';
-      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
+      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<std::uint16_t>(s), 16).ptr;
       buffer[6] = '\0';
       break;
 
@@ -98,7 +98,7 @@
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'X';
-      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
+      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<std::uint16_t>(s), 16).ptr;
       std::transform(static_cast<const char*>(&buffer[2]), end, &buffer[2], [](char c) {
         return static_cast<char>(std::toupper(c)); });
       buffer[6] = '\0';