[libc++] Qualifies intptr_t and uintptr_t.

[Mordante]

Summary

This has been done using the following command

find libcxx/test -type f -exec perl -pi -e 's|^([^/]+?)((?<!::)(?<!::u)u?intptr_t)|\1std::\2|' \{} \;

The std module doesn't export declarations in the global namespaace.
This is a preparation for that module.

libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp

 #endif
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     static_assert((std::is_same<std::atomic<char8_t>, std::atomic_char8_t>::value), "");
 #endif
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
 
 //  Added by LWG 2441
-    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<std::intptr_t>,  std::atomic_intptr_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::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), "");
 
   return 0;
 }

libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp

#endif
   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<intptr_t>,  ::atomic_intptr_t>);
-  static_assert(std::is_same_v<std::atomic<uintptr_t>, ::atomic_uintptr_t>);
+  static_assert(std::is_same_v<std::atomic<std::intptr_t>,  ::atomic_intptr_t>);
+  static_assert(std::is_same_v<std::atomic<std::uintptr_t>, ::atomic_uintptr_t>);
   static_assert(std::is_same_v<std::atomic<std::size_t>,    ::atomic_size_t>);
   static_assert(std::is_same_v<std::atomic<std::ptrdiff_t>, ::atomic_ptrdiff_t>);
   static_assert(std::is_same_v<std::atomic<intmax_t>,  ::atomic_intmax_t>);
   static_assert(std::is_same_v<std::atomic<uintmax_t>, ::atomic_uintmax_t>);
 
   // Just check that the symbols in the global namespace are visible.
   using ::atomic_compare_exchange_strong;
   using ::atomic_compare_exchange_strong_explicit;

libcxx/test/std/atomics/types.pass.cpp

#endif
     test<std::uint8_t>  ();
     test< std::int16_t> ();
     test<std::uint16_t> ();
     test< std::int32_t> ();
     test<std::uint32_t> ();
     test< std::int64_t> ();
     test<std::uint64_t> ();
 
-    test<intptr_t>  ();
-    test<uintptr_t> ();
+    test<std::intptr_t>  ();
+    test<std::uintptr_t> ();
     test<std::size_t>    ();
     test<std::ptrdiff_t> ();
     test<intmax_t>  ();
     test<uintmax_t> ();
 
     test<uintmax_t> ();
     test<uintmax_t> ();
 

libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp

struct identity {
   int operator()(std::integral_constant<std::size_t, value>) const {
     return value;
   }
 };
 
 void compile_generator() {
   supported_simd128_ctor<int>(identity());
   not_supported_simd128_ctor<int>([](int i) { return float(i); });
-  not_supported_simd128_ctor<int>([](intptr_t i) { return (int*)(i); });
+  not_supported_simd128_ctor<int>([](std::intptr_t i) { return (int*)(i); });
   not_supported_simd128_ctor<int>([](int* i) { return i; });
 }
 
 struct limited_identity {
   template <std::size_t value>
   typename std::conditional<value <= 2, std::int32_t, std::int64_t>::type
   operator()(std::integral_constant<std::size_t, value>) const {
     return value;

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp

int main(int, char**)
     static_assert(toobig<unsigned long long>(), ""); // 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<std::uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<std::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}}
+    static_assert(toobig<std::uintptr_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif
#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif

 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif
#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp

#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     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, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);
 #endif
#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<std::uint8_t>());
     static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
     static_assert(test<std::uint64_t>());
     static_assert(test<uintmax_t>());
-    static_assert(test<uintptr_t>());
+    static_assert(test<std::uintptr_t>());
     static_assert(test<std::size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.other.pass.cpp

 #include <tuple>
 
 #include "../types.h"
 
 template <bool Const>
 struct ConvertibleIter : IterBase<ConvertibleIter<Const>> {
   using iterator_category = std::random_access_iterator_tag;
   using value_type        = std::tuple<int>;
-  using difference_type   = intptr_t;
+  using difference_type   = std::intptr_t;
 
   bool movedFromOtherConst = false;
   int i                    = 0;
 
   constexpr ConvertibleIter() = default;
   constexpr ConvertibleIter(int ii) : i(ii) {}
   template <bool otherConst>
     requires(Const != otherConst)

libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/equality.pass.cpp

 
 #include "../types.h"
 
 template <bool Const>
 struct Iter {
   std::tuple<int>* it_;
 
   using value_type       = std::tuple<int>;
-  using difference_type  = intptr_t;
+  using difference_type  = std::intptr_t;
   using iterator_concept = std::input_iterator_tag;
 
   constexpr decltype(auto) operator*() const { return *it_; }
   constexpr Iter& operator++() {
     ++it_;
     return *this;
   }
   constexpr void operator++(int) { ++it_; }

libcxx/test/std/ranges/range.adaptors/range.elements/types.h

 static_assert(!std::ranges::sized_range<SimpleNonCommon>);
 LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleNonCommon>);
 LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommon>);
 
 template <class Derived>
 struct IterBase {
   using iterator_concept = std::random_access_iterator_tag;
   using value_type       = std::tuple<int>;
-  using difference_type  = intptr_t;
+  using difference_type  = std::intptr_t;
 
   constexpr std::tuple<int> operator*() const { return std::tuple<int>(5); }
 
   constexpr Derived& operator++() { return *this; }
   constexpr void operator++(int) {}
 
   friend constexpr bool operator==(const IterBase&, const IterBase&) = default;
 };
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ELEMENTS_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.split/types.h

 #include "test_macros.h"
 #include "test_iterators.h"
 #include "test_range.h"
 
 template <class Derived>
 struct ForwardIterBase {
   using iterator_concept = std::forward_iterator_tag;
   using value_type       = int;
-  using difference_type  = intptr_t;
+  using difference_type  = std::intptr_t;
 
   constexpr int operator*() const { return 5; }
 
   constexpr Derived& operator++() { return static_cast<Derived&>(*this); }
   constexpr Derived operator++(int) { return {}; }
 
   friend constexpr bool operator==(const ForwardIterBase&, const ForwardIterBase&) { return true; };
 };
 
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_SPLIT_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.take.while/sentinel/equality.pass.cpp

 
 #include "../types.h"
 
 template <bool Const>
 struct Iter {
   int* it_;
 
   using value_type       = int;
-  using difference_type  = intptr_t;
+  using difference_type  = std::intptr_t;
   using iterator_concept = std::input_iterator_tag;
 
   constexpr decltype(auto) operator*() const { return *it_; }
   constexpr Iter& operator++() {
     ++it_;
     return *this;
   }
   constexpr void operator++(int) { ++it_; }

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

static_assert(std::ranges::contiguous_range<decltype(b)>);
 
     it1 += 3;
     assert(it1 == it2);
     auto [x1, y1] = *it2;
     assert(&x1 == &(a[3]));
     assert(&y1 == &(b[3]));
 
     using Iter = decltype(it1);
-    static_assert(canPlusEqual<Iter, intptr_t>);
+    static_assert(canPlusEqual<Iter, std::intptr_t>);
   }
 
   {
     // operator-(x, n) and operator-=
     std::ranges::zip_view v(a, b);
     auto it1 = v.end();
 
     auto it2 = it1 - 3;
     auto [x2, y2] = *it2;
     assert(&x2 == &(a[2]));
     assert(&y2 == &(b[2]));
 
     it1 -= 3;
     assert(it1 == it2);
     auto [x1, y1] = *it2;
     assert(&x1 == &(a[2]));
     assert(&y1 == &(b[2]));
 
     using Iter = decltype(it1);
-    static_assert(canMinusEqual<Iter, intptr_t>);
+    static_assert(canMinusEqual<Iter, std::intptr_t>);
   }
 
   {
     // operator-(x, y)
     std::ranges::zip_view v(a, b);
     assert((v.end() - v.begin()) == 5);
 
     auto it1 = v.begin() + 2;
static_assert(std::ranges::contiguous_range<decltype(b)>);
     assert((it1 - it2) == -5);
     assert((it2 - it1) == 5);
   }
 
   {
     // One of the ranges is not random access
     std::ranges::zip_view v(a, b, ForwardSizedView{buffer1});
     using Iter = decltype(v.begin());
-    static_assert(!std::invocable<std::plus<>, Iter, intptr_t>);
-    static_assert(!std::invocable<std::plus<>, intptr_t, Iter>);
-    static_assert(!canPlusEqual<Iter, intptr_t>);
-    static_assert(!std::invocable<std::minus<>, Iter, intptr_t>);
+    static_assert(!std::invocable<std::plus<>, Iter, std::intptr_t>);
+    static_assert(!std::invocable<std::plus<>, std::intptr_t, Iter>);
+    static_assert(!canPlusEqual<Iter, std::intptr_t>);
+    static_assert(!std::invocable<std::minus<>, Iter, std::intptr_t>);
     static_assert(std::invocable<std::minus<>, Iter, Iter>);
-    static_assert(!canMinusEqual<Iter, intptr_t>);
+    static_assert(!canMinusEqual<Iter, std::intptr_t>);
   }
 
   {
     // One of the ranges does not have sized sentinel
     std::ranges::zip_view v(a, b, InputCommonView{buffer1});
     using Iter = decltype(v.begin());
     static_assert(!std::invocable<std::minus<>, Iter, Iter>);
   }

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

 // non-constant expression for the compile time tests.
 struct LessThanIterator {
   int* it_ = nullptr;
   LessThanIterator() = default;
   constexpr LessThanIterator(int* it) : it_(it) {}
 
   using iterator_category = std::random_access_iterator_tag;
   using value_type = int;
-  using difference_type = intptr_t;
+  using difference_type = std::intptr_t;
 
   constexpr int& operator*() const { return *it_; }
   constexpr int& operator[](difference_type n) const { return it_[n]; }
   constexpr LessThanIterator& operator++() {
     ++it_;
     return *this;
   }
   constexpr LessThanIterator& operator--() {

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp

 
 #include "../types.h"
 
 struct PODIter {
   int i; // deliberately uninitialised
 
   using iterator_category = std::random_access_iterator_tag;
   using value_type = int;
-  using difference_type = intptr_t;
+  using difference_type = std::intptr_t;
 
   constexpr int operator*() const { return i; }
 
   constexpr PODIter& operator++() { return *this; }
   constexpr void operator++(int) {}
 
   friend constexpr bool operator==(const PODIter&, const PODIter&) = default;
 };

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp

#endif
     static_assert(std::is_same_v<Iter::iterator_concept, std::input_iterator_tag>);
     static_assert(!HasIterCategory<Iter>);
     static_assert(std::is_same_v<Iter::difference_type, std::ptrdiff_t>);
     static_assert(std::is_same_v<Iter::value_type, std::tuple<int>>);
   }
 
   {
     // difference_type of single view
-    std::ranges::zip_view v{DiffTypeRange<intptr_t>{}};
+    std::ranges::zip_view v{DiffTypeRange<std::intptr_t>{}};
     using Iter = decltype(v.begin());
-    static_assert(std::is_same_v<Iter::difference_type, intptr_t>);
+    static_assert(std::is_same_v<Iter::difference_type, std::intptr_t>);
   }
 
   {
     // difference_type of multiple views should be the common type
-    std::ranges::zip_view v{DiffTypeRange<intptr_t>{}, DiffTypeRange<std::ptrdiff_t>{}};
+    std::ranges::zip_view v{DiffTypeRange<std::intptr_t>{}, DiffTypeRange<std::ptrdiff_t>{}};
     using Iter = decltype(v.begin());
-    static_assert(std::is_same_v<Iter::difference_type, std::common_type_t<intptr_t, std::ptrdiff_t>>);
+    static_assert(std::is_same_v<Iter::difference_type, std::common_type_t<std::intptr_t, std::ptrdiff_t>>);
   }
 
   const std::array foos{Foo{}};
   std::array bars{Bar{}, Bar{}};
   {
     // value_type of single view
     std::ranges::zip_view v{foos};
     using Iter = decltype(v.begin());

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp

 #include "../types.h"
 
 template <class Base = int*>
 struct convertible_forward_sized_iterator {
   Base it_ = nullptr;
 
   using iterator_category = std::forward_iterator_tag;
   using value_type = int;
-  using difference_type = intptr_t;
+  using difference_type = std::intptr_t;
 
   convertible_forward_sized_iterator() = default;
   constexpr convertible_forward_sized_iterator(Base it) : it_(it) {}
 
   template <std::convertible_to<Base> U>
   constexpr convertible_forward_sized_iterator(const convertible_forward_sized_iterator<U>& it) : it_(it.it_) {}
 
   constexpr decltype(*Base{}) operator*() const { return *it_; }

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

 };
 
 template <class Base = int*>
 struct forward_sized_iterator {
   Base it_ = nullptr;
 
   using iterator_category = std::forward_iterator_tag;
   using value_type = int;
-  using difference_type = intptr_t;
+  using difference_type = std::intptr_t;
   using pointer = Base;
   using reference = decltype(*Base{});
 
   forward_sized_iterator() = default;
   constexpr forward_sized_iterator(Base it) : it_(it) {}
 
   constexpr reference operator*() const { return *it_; }
 

 struct iter_move_swap_iterator {
 
   std::reference_wrapper<int> iter_move_called_times;
   std::reference_wrapper<int> iter_swap_called_times;
   int i = 0;
 
   using iterator_category = std::input_iterator_tag;
   using value_type = int;
-  using difference_type = intptr_t;
+  using difference_type = std::intptr_t;
 
   constexpr int operator*() const { return i; }
 
   constexpr iter_move_swap_iterator& operator++() {
     ++i;
     return *this;
   }
   constexpr void operator++(int) { ++i; }

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp

FormatCtxT format_ctx =
       test_format_context_create<decltype(out), CharT>(out, std::make_format_args<FormatCtxT>(arg));
   formatter.format(arg, format_ctx);
 
   if (expected.empty()) {
     std::array<char, 128> buffer;
     buffer[0] = CharT('0');
     buffer[1] = CharT('x');
     expected.append(buffer.begin(),
-                    std::to_chars(buffer.begin() + 2, buffer.end(), reinterpret_cast<uintptr_t>(arg), 16).ptr);
+                    std::to_chars(buffer.begin() + 2, buffer.end(), reinterpret_cast<std::uintptr_t>(arg), 16).ptr);
   }
   assert(result == expected);
 }
 
 template <class StringT, class PointerT>
 void test_termination_condition(StringT expected, StringT f, PointerT arg) {
   // The format-spec is valid if completely consumed or terminates at a '}'.
   // The valid inputs all end with a '}'. The test is executed twice:

libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

//  LWG #2119
     test<std::int_fast64_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<std::intptr_t>();
 
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
 
     test<std::uint_fast8_t>();
     test<std::uint_fast16_t>();
     test<std::uint_fast32_t>();
     test<std::uint_fast64_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>();
+    test<std::uintptr_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp

 struct alignas(32) A {
     int field;
 };
 
 int main(int, char**)
 {
     std::pair<A*, std::ptrdiff_t> ip = std::get_temporary_buffer<A>(5);
     assert(!(ip.first == nullptr) ^ (ip.second == 0));
-    assert(reinterpret_cast<uintptr_t>(ip.first) % alignof(A) == 0);
+    assert(reinterpret_cast<std::uintptr_t>(ip.first) % alignof(A) == 0);
     std::return_temporary_buffer(ip.first);
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp

struct Foo {
   Foo(Foo a, Foo b) : val(a.val + b.val) {}
 };
 
 struct Bar {
   std::max_align_t y;
 };
 
 void test_aligned(void* p, std::size_t align) {
-  assert(reinterpret_cast<uintptr_t>(p) % align == 0);
+  assert(reinterpret_cast<std::uintptr_t>(p) % align == 0);
 }
 
 int main(int, char**) {
   {
     std::shared_ptr<int> p = std::allocate_shared<int>(MyAllocator<int>());
     assert(construct_called);
   }
   assert(destroy_called);

libcxx/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp

 public:
     ~Class();
 };
 
 int main(int, char**)
 {
     test_alignment_of<int&, 4>();
     test_alignment_of<Class, 1>();
-    test_alignment_of<int*, sizeof(intptr_t)>();
-    test_alignment_of<const int*, sizeof(intptr_t)>();
+    test_alignment_of<int*, sizeof(std::intptr_t)>();
+    test_alignment_of<const int*, sizeof(std::intptr_t)>();
     test_alignment_of<char[3], 1>();
     test_alignment_of<int, 4>();
     test_alignment_of<double, TEST_ALIGNOF(double)>();
     test_alignment_of<bool, 1>();
     test_alignment_of<unsigned, 4>();
 
   return 0;
 }