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
@@ -53,7 +53,7 @@
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
diff --git a/libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp b/libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp
--- a/libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp
+++ b/libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp
@@ -94,12 +94,12 @@
 #endif
   check_integral_types<char16_t, int>();
   // On some platforms, unsigned int and long are the same size.  These
-  // platforms have a choice of making uint32_t an int or a long.  However
+  // platforms have a choice of making std::uint32_t an int or a long.  However
   // char32_t must promote to an unsigned int on these platforms [conv.prom].
   // Use the following logic to make the test work on such platforms.
-  // (sizeof(uint32_t) == sizeof(unsigned int)) ? unsigned int : uint32_t;
-  typedef std::conditional<sizeof(uint32_t) == sizeof(unsigned int),
-                           unsigned int, uint32_t>::type char_integral;
+  // (sizeof(std::uint32_t) == sizeof(unsigned int)) ? unsigned int : std::uint32_t;
+  typedef std::conditional<sizeof(std::uint32_t) == sizeof(unsigned int),
+                           unsigned int, std::uint32_t>::type char_integral;
   check_integral_types<char32_t, char_integral>();
   check_integral_types<short, int>();
   check_integral_types<unsigned short, int>();
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
@@ -89,7 +89,7 @@
 #endif
 
     // 32-bit types.
-    using integral_32 = types::type_list<char32_t, int32_t, uint32_t>;
+    using integral_32 = types::type_list<char32_t, 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
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
@@ -17,7 +17,7 @@
 
 #include "test_macros.h"
 
-typedef std::__murmur2_or_cityhash<uint32_t> Hash32;
+typedef std::__murmur2_or_cityhash<std::uint32_t> Hash32;
 typedef std::__murmur2_or_cityhash<uint64_t> Hash64;
 
 void test(const void* key, int len) {
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
@@ -142,7 +142,7 @@
     test< int16_t> ();
     test<uint16_t> ();
     test< int32_t> ();
-    test<uint32_t> ();
+    test<std::uint32_t> ();
     test< int64_t> ();
     test<uint64_t> ();
 
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
@@ -184,7 +184,7 @@
   {
     // Though the types are different, initialization can be done with `memcpy`.
     int32_t array[1] = { -1 };
-    std::vector<uint32_t> v(array, array + 1);
+    std::vector<std::uint32_t> v(array, array + 1);
     assert(v[0] == 4294967295U);
   }
 }
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
@@ -43,7 +43,7 @@
   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<uint32_t>(3);
+  supported_native_simd_ctor<std::uint32_t>(3);
   supported_native_simd_ctor<uint64_t>(3);
   supported_native_simd_ctor<float>(3.f);
   supported_native_simd_ctor<double>(3.);
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
@@ -38,13 +38,13 @@
 
 void compile_load_ctor() {
   supported_native_simd_ctor<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((int*)nullptr,
+  supported_native_simd_ctor<std::uint32_t>((int*)nullptr,
                                        ex::element_aligned_tag());
   supported_native_simd_ctor<double>((float*)nullptr,
                                      ex::element_aligned_tag());
   supported_native_simd_ctor<uint16_t>((unsigned int*)nullptr,
                                        ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((float*)nullptr,
+  supported_native_simd_ctor<std::uint32_t>((float*)nullptr,
                                        ex::element_aligned_tag());
 
   not_supported_native_simd_ctor<int>((int*)nullptr, int());
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
@@ -39,10 +39,10 @@
 
 void compile_load() {
   supported_load<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_load<uint32_t>((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<uint32_t>((float*)nullptr, ex::element_aligned_tag());
+  supported_load<std::uint32_t>((float*)nullptr, ex::element_aligned_tag());
 
   not_supported_load<int>((int*)nullptr, int());
 }
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
@@ -29,7 +29,7 @@
 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<uint32_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<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<double>>::value, "");
@@ -40,7 +40,7 @@
 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<uint32_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<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<double>>::value, "");
@@ -72,7 +72,7 @@
 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<uint32_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<float>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<double>>, "");
@@ -83,7 +83,7 @@
 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<uint32_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<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
@@ -29,7 +29,7 @@
 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<uint32_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<float>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<double>>::value, "");
@@ -40,7 +40,7 @@
 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<uint32_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<float, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 1>>::value, "");
@@ -51,7 +51,7 @@
 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<uint32_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<float, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 3>>::value, "");
@@ -62,7 +62,7 @@
 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<uint32_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<float, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 32>>::value, "");
@@ -80,7 +80,7 @@
 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<uint32_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<float>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<double>>, "");
@@ -91,7 +91,7 @@
 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<uint32_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<float, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 1>>, "");
@@ -102,7 +102,7 @@
 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<uint32_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<float, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 3>>, "");
@@ -113,7 +113,7 @@
 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<uint32_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<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_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
@@ -29,7 +29,7 @@
 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<uint32_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<float>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, "");
@@ -45,7 +45,7 @@
               "");
 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<uint32_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,
               "");
@@ -63,7 +63,7 @@
               "");
 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<uint32_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,
               "");
@@ -82,7 +82,7 @@
               "");
 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<uint32_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,
               "");
@@ -103,7 +103,7 @@
 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<uint32_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<float>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<double>>, "");
@@ -114,7 +114,7 @@
 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<uint32_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<float, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 1>>, "");
@@ -125,7 +125,7 @@
 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<uint32_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<float, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 3>>, "");
@@ -136,7 +136,7 @@
 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<uint32_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<float, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 32>>, "");
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
@@ -65,7 +65,7 @@
 
     test_octal<uint16_t>(                "177777");
     test_octal< int16_t>(                "177777");
-    test_octal<uint32_t>(           "37777777777");
+    test_octal<std::uint32_t>(           "37777777777");
     test_octal< int32_t>(           "37777777777");
     test_octal<uint64_t>("1777777777777777777777");
     test_octal< int64_t>("1777777777777777777777");
@@ -85,7 +85,7 @@
 
     test_dec<uint16_t>(               "65535");
     test_dec< int16_t>(                  "-1");
-    test_dec<uint32_t>(          "4294967295");
+    test_dec<std::uint32_t>(          "4294967295");
     test_dec< int32_t>(                  "-1");
     test_dec<uint64_t>("18446744073709551615");
     test_dec< int64_t>(                  "-1");
@@ -100,7 +100,7 @@
 
     test_hex<uint16_t>(            "FFFF");
     test_hex< int16_t>(            "FFFF");
-    test_hex<uint32_t>(        "FFFFFFFF");
+    test_hex<std::uint32_t>(        "FFFFFFFF");
     test_hex< int32_t>(        "FFFFFFFF");
     test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
     test_hex< int64_t>("FFFFFFFFFFFFFFFF");
diff --git a/libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp b/libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp
--- a/libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp
@@ -38,7 +38,7 @@
 
 //  Try to check at runtime
     {
-    uint32_t i = 0x01020304;
+    std::uint32_t i = 0x01020304;
     char c[4];
     static_assert(sizeof(i) == sizeof(c));
     std::memcpy(c, &i, sizeof(c));
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
@@ -41,7 +41,7 @@
 
     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<uint32_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<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}}
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
@@ -117,7 +117,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -133,7 +133,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -115,7 +115,7 @@
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -132,7 +132,7 @@
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -119,7 +119,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -135,7 +135,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -117,7 +117,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -133,7 +133,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -114,7 +114,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -130,7 +130,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -113,7 +113,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -129,7 +129,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -118,7 +118,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -134,7 +134,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -115,7 +115,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -131,7 +131,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -125,7 +125,7 @@
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -141,7 +141,7 @@
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -114,7 +114,7 @@
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -131,7 +131,7 @@
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -115,7 +115,7 @@
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
@@ -132,7 +132,7 @@
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_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
@@ -56,7 +56,7 @@
 constexpr bool test() {
   test_num<uint8_t>(0xAB, 0xAB);
   test_num<uint16_t>(0xCDEF, 0xEFCD);
-  test_num<uint32_t>(0x01234567, 0x67452301);
+  test_num<std::uint32_t>(0x01234567, 0x67452301);
   test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
   test_num<int8_t>(static_cast<int8_t>(0xAB), static_cast<int8_t>(0xAB));
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
@@ -18,6 +18,7 @@
 #include <numeric>
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
 #include "test_macros.h"
 
 template <typename T>
@@ -127,7 +128,7 @@
 
     unsigned_test<uint8_t>();
     unsigned_test<uint16_t>();
-    unsigned_test<uint32_t>();
+    unsigned_test<std::uint32_t>();
     unsigned_test<uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
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
@@ -202,7 +202,7 @@
     {"8.32116e+55", 0x4B8B2628393E02CDULL},
 };
 
-constexpr std::pair<const char*, uint32_t> floating_point_test_cases_float[] = {
+constexpr std::pair<const char*, std::uint32_t> floating_point_test_cases_float[] = {
     // Verify small exactly-representable integers:
     {"1", 0x3F800000U},
     {"2", 0x40000000U},
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
@@ -54,7 +54,7 @@
     static_assert(w % 32 == 0);
     constexpr size_t k = w / 32;
 
-    vector<uint32_t> vec(n * k);
+    vector<std::uint32_t> vec(n * k);
 
     puts("USAGE:");
     puts("test.exe              : generates seed data from random_device.");
@@ -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>, uint32_t, uint64_t>;
+                using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, uint64_t>;
                 assert(opt_correct.has_value());
                 assert(_Bit_cast<Uint>(dest) == _Bit_cast<Uint>(opt_correct.value()));
             } else {
@@ -543,7 +543,7 @@
     test_from_chars<int>("-2147483650", 10, 11, out_ran); // beyond risky
 }
 
-void assert_message_bits(const bool b, const char* const msg, const uint32_t bits) {
+void assert_message_bits(const bool b, const char* const msg, const std::uint32_t bits) {
     if (!b) {
         fprintf(stderr, "%s failed for 0x%08zX\n", msg, static_cast<size_t>(bits));
         fprintf(stderr, "This is a randomized test.\n");
@@ -564,26 +564,26 @@
     }
 }
 
-constexpr uint32_t FractionBits = 10; // Tunable for test coverage vs. performance.
+constexpr std::uint32_t FractionBits = 10; // Tunable for test coverage vs. performance.
 static_assert(FractionBits >= 1, "Must test at least 1 fraction bit.");
 static_assert(FractionBits <= 23, "There are only 23 fraction bits in a float.");
 
-constexpr uint32_t Fractions = 1U << FractionBits;
-constexpr uint32_t Mask32    = ~((1U << FractionBits) - 1U);
+constexpr std::uint32_t Fractions = 1U << FractionBits;
+constexpr std::uint32_t Mask32    = ~((1U << FractionBits) - 1U);
 constexpr uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
 
-constexpr uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
+constexpr std::uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
 static_assert(PrefixesToTest >= 1, "Must test at least 1 prefix.");
 
-constexpr uint32_t PrefixLimit = 2 // sign bit
+constexpr std::uint32_t PrefixLimit = 2 // sign bit
                                * 255 // non-INF/NAN exponents for float
                                * (1U << (23 - FractionBits)); // fraction bits in prefix
 static_assert(PrefixesToTest <= PrefixLimit, "Too many prefixes.");
 
 template <bool IsDouble>
-void test_floating_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // "-1.2345678901234567e-100" or "-1.23456789e-10"
@@ -607,7 +607,7 @@
     constexpr size_t stdio_buffer_size = 1 + (IsDouble ? 309 : 39) + 1;
     char stdio_buffer[stdio_buffer_size];
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
@@ -643,9 +643,9 @@
 }
 
 template <bool IsDouble>
-void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // The precision is the number of hexits after the decimal point.
@@ -661,7 +661,7 @@
     FloatingType val;
 #endif
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
@@ -681,9 +681,9 @@
 }
 
 template <bool IsDouble>
-void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, 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.)
@@ -708,7 +708,7 @@
     char general_buffer[general_buffer_size];
     char general_stdio_buffer[general_buffer_size + 1]; // + null terminator
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
@@ -767,10 +767,10 @@
     }
 
     {
-        set<uint32_t> prefixes32;
+        set<std::uint32_t> prefixes32;
 
         while (prefixes32.size() < PrefixesToTest) {
-            const uint32_t val = static_cast<uint32_t>(mt64());
+            const std::uint32_t val = static_cast<std::uint32_t>(mt64());
 
             if ((val & 0x7F800000U) != 0x7F800000U) { // skip INF/NAN
                 prefixes32.insert(val & Mask32);
diff --git a/libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp b/libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp
--- a/libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp
@@ -224,7 +224,7 @@
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
diff --git a/libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp b/libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp
--- a/libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp
@@ -230,7 +230,7 @@
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
@@ -341,7 +341,7 @@
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
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
@@ -749,10 +749,10 @@
   check(SV("65535"), SV("{:#}"), std::numeric_limits<uint16_t>::max());
   check(SV("0xffff"), SV("{:#x}"), std::numeric_limits<uint16_t>::max());
 
-  check(SV("0b11111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<uint32_t>::max());
-  check(SV("037777777777"), SV("{:#o}"), std::numeric_limits<uint32_t>::max());
-  check(SV("4294967295"), SV("{:#}"), std::numeric_limits<uint32_t>::max());
-  check(SV("0xffffffff"), SV("{:#x}"), std::numeric_limits<uint32_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());
+  check(SV("4294967295"), SV("{:#}"), std::numeric_limits<std::uint32_t>::max());
+  check(SV("0xffffffff"), SV("{:#x}"), std::numeric_limits<std::uint32_t>::max());
 
   check(SV("0b1111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
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
@@ -94,7 +94,7 @@
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
 
     test<uint_fast8_t>();
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
@@ -88,7 +88,7 @@
     TestFunctor<int16_t>()();
     TestFunctor<uint16_t>()();
     TestFunctor<int32_t>()();
-    TestFunctor<uint32_t>()();
+    TestFunctor<std::uint32_t>()();
     TestFunctor<int64_t>()();
     TestFunctor<uint64_t>()();
   }