[libc++] Qualifies intptr_t and uintptr_t.

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.

Reviewed By: #libc, ldionne

Differential Revision: https://reviews.llvm.org/D146643

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
index 92bef959469793b4b291056777f45e6e1f496f76..5e52cdec28cafdb47a06dc38f0e45e3d68faf097 100644 (file)
--- a/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
+++ b/libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp
@@ -64,8 +64,8 @@ int main(int, char**)
     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), "");

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
index 3121e7c57bafe972f64e09794427c5d993b13a33..28125888f27df7254fb76880d9b5368f2f0e47df 100644 (file)
--- a/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp
+++ b/libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp
@@ -200,8 +200,8 @@ void f() {
   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>);

diff --git a/libcxx/test/std/atomics/types.pass.cpp b/libcxx/test/std/atomics/types.pass.cpp
index 63ab0f30c4a752ea015d13da31d9e0e0caaa1098..cb8dde0d513dbd95080adb3c47c7724e5522b181 100644 (file)
--- a/libcxx/test/std/atomics/types.pass.cpp
+++ b/libcxx/test/std/atomics/types.pass.cpp
@@ -146,8 +146,8 @@ int main(int, char**)
     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>  ();

diff --git a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
index b28e1af29a89e01a01c5deba9f4f08e4e3ea84b2..05a12895e9213360062fcd4bf2f0e8d6ac291e27 100644 (file)
--- a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -47,7 +47,7 @@ struct identity {
 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; });
 }
 

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
index 1d4699c18d8ea73467716ee127cab074424f73ca..89e2b6bf397b07728b16d8581533747f6154688f 100644 (file)
--- 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
@@ -45,7 +45,7 @@ int main(int, char**)
     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;
 }

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
index cbaf5dfbec19c87f9371e6359cd434264c556857..a4d70dc8c52c997a630b88e5668fc4c25533c976 100644 (file)
--- 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
@@ -89,7 +89,7 @@ int main(int, char**)
     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>);
@@ -120,7 +120,7 @@ int main(int, char**)
     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>();
@@ -136,7 +136,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 473238be5e92c7a532b7c3e23a31dcf634d099b6..0af4cddb074d1f6baeb5cfd242c732579eefcd29 100644 (file)
--- 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
@@ -86,7 +86,7 @@ int main(int, char**)
     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>);
@@ -118,7 +118,7 @@ int main(int, char**)
     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>();
@@ -135,7 +135,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 8110048e13960c6e49d850ab9cc006483880953d..747b4e02bac5cc9ad1b29c2ca5984df2ea173438 100644 (file)
--- 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
@@ -91,7 +91,7 @@ int main(int, char**)
     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>);
@@ -122,7 +122,7 @@ int main(int, char**)
     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>();
@@ -138,7 +138,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 1c30f5cec519174eb2b70b8fae3cf24c5a115240..398fee8cafc1d21827b65d7fc20c0788cb19bad2 100644 (file)
--- 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
@@ -89,7 +89,7 @@ int main(int, char**)
     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>);
@@ -120,7 +120,7 @@ int main(int, char**)
     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>();
@@ -136,7 +136,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index b236e37ee8791f43d575124eb22391c6696203dd..7b8f6da809b265e7ee3737f04bce4e05b6081b66 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
@@ -86,7 +86,7 @@ int main(int, char**)
     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>);
@@ -117,7 +117,7 @@ int main(int, char**)
     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>();
@@ -133,7 +133,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 58c953f0b97a89b565dbcaead9bd7d74c3b2295c..4b0f8156d621b8ee80833db7ccd514b0c5cbdd3d 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
@@ -85,7 +85,7 @@ int main(int, char**)
     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>);
@@ -116,7 +116,7 @@ int main(int, char**)
     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>();
@@ -132,7 +132,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 208e694e0282ad60a1fdf25f3a1cd521ef34684e..b88a770745d5d8de0819ece74091ad8b532b54d1 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
@@ -90,7 +90,7 @@ int main(int, char**)
     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>);
@@ -121,7 +121,7 @@ int main(int, char**)
     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>();
@@ -137,7 +137,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

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
index 0d14d9e71044b4dfb2dc0d62671470d2e3649568..2f2f81d961ad93dd1f41ede80f19bf00c7d3f95c 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
@@ -87,7 +87,7 @@ int main(int, char**)
     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>);
@@ -118,7 +118,7 @@ int main(int, char**)
     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>();
@@ -134,7 +134,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

diff --git a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
index 383338a2f21bd4b8a7644e9ca833fe0060564dd4..605b84ed35158eeed4446950b0c77c9fa609d8a5 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
@@ -97,7 +97,7 @@ int main(int, char**)
     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>);
@@ -128,7 +128,7 @@ int main(int, char**)
     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>();
@@ -144,7 +144,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
index 6cc1410eb682fc964f84a31499a29753027bdaa0..2b56ae15682e062f797b78a380d6a8fb980919bb 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
@@ -85,7 +85,7 @@ int main(int, char**)
     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>);
@@ -117,7 +117,7 @@ int main(int, char**)
     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>();
@@ -134,7 +134,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
index b218bb0397335a86af7281ba2916e915a6acd824..fee122fe607b511b30c53fce27f6732ccd1c8d2f 100644 (file)
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
@@ -86,7 +86,7 @@ int main(int, char**)
     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>);
@@ -118,7 +118,7 @@ int main(int, char**)
     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>();
@@ -135,7 +135,7 @@ int main(int, char**)
     test<std::uint32_t>();
     test<std::uint64_t>();
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
     test<std::size_t>();
 
     return 0;

diff --git a/libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.other.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.other.pass.cpp
index 6756474024821d1588cba98ad2189096c190b132..4c94cd5edf62e5405f7646c411d5002a94778192 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.other.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.other.pass.cpp
@@ -21,7 +21,7 @@ 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;

diff --git a/libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/equality.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/equality.pass.cpp
index 55477cc997587a67c2ffb3c241fecd5a30cdbaa8..df95e07c97d972f78095bfab51f713d648611579 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/equality.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/equality.pass.cpp
@@ -23,7 +23,7 @@ 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_; }

diff --git a/libcxx/test/std/ranges/range.adaptors/range.elements/types.h b/libcxx/test/std/ranges/range.adaptors/range.elements/types.h
index a1c0884b6071989228f8f103d43e37228381b2fe..f1ee165c3cc63653a837a87e989a207547262ef3 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.elements/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.elements/types.h
@@ -93,7 +93,7 @@ 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); }
 

diff --git a/libcxx/test/std/ranges/range.adaptors/range.split/types.h b/libcxx/test/std/ranges/range.adaptors/range.split/types.h
index ff2ce38317cd90fdcf184ffb3fe77107b4b1735d..aa47faf0f468beb1de029e0b4e8e65cf9a965298 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.split/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.split/types.h
@@ -20,7 +20,7 @@ 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; }
 

diff --git a/libcxx/test/std/ranges/range.adaptors/range.take.while/sentinel/equality.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.take.while/sentinel/equality.pass.cpp
index 3d5b835c01c27faf4927dec5c7bb235c6759ede3..db3e5764421af7b1faff4b06ac27f592a5c3ca1d 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.take.while/sentinel/equality.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.take.while/sentinel/equality.pass.cpp
@@ -26,7 +26,7 @@ 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_; }

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp
index ce7858f1a89218cb59a0ab636a0174fc343211ee..efe64b31f79fb8a70089adf2d77a4ecbb8047688 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp
@@ -63,7 +63,7 @@ constexpr bool test() {
     assert(&y1 == &(b[3]));
 
     using Iter = decltype(it1);
-    static_assert(canPlusEqual<Iter, intptr_t>);
+    static_assert(canPlusEqual<Iter, std::intptr_t>);
   }
 
   {
@@ -83,7 +83,7 @@ constexpr bool test() {
     assert(&y1 == &(b[2]));
 
     using Iter = decltype(it1);
-    static_assert(canMinusEqual<Iter, intptr_t>);
+    static_assert(canMinusEqual<Iter, std::intptr_t>);
   }
 
   {
@@ -116,12 +116,12 @@ constexpr bool test() {
     // 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>);
   }
 
   {

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp
index 19b5b999934952c23843d11bb736aa8a13d7ea17..fcbff722c39b3c7d397e5e79eed9e84855abc060 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp
@@ -41,7 +41,7 @@ struct LessThanIterator {
 
   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]; }

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp
index 8c038abdb24f5c9a42c0f7c20f37eabf8d143859..98078b2ce309542a88717a5416e7c27e7613a89a 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp
@@ -20,7 +20,7 @@ struct PODIter {
 
   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; }
 

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp
index 6b0c086d8c4fc6341f679963d0d08abf50281a78..c19f6c2b16524fa6c2871587c6f8a9250102eb99 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_types.compile.pass.cpp
@@ -144,16 +144,16 @@ void test() {
 
   {
     // 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{}};

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
index 7f8b513a9771730bf83c94e58e521bf5a1e4d623..c4c85bc24e1e878e1873a6ab1ac486b014efd759 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp
@@ -34,7 +34,7 @@ struct convertible_forward_sized_iterator {
 
   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) {}

diff --git a/libcxx/test/std/ranges/range.adaptors/range.zip/types.h b/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
index 299ffeac0489a32eae70fb85d6bf5003d6c58404..fa82b836f529b1f32478f1a33d40eb6b91872117 100644 (file)
--- a/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
+++ b/libcxx/test/std/ranges/range.adaptors/range.zip/types.h
@@ -201,7 +201,7 @@ struct forward_sized_iterator {
 
   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{});
 
@@ -405,7 +405,7 @@ struct iter_move_swap_iterator {
 
   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; }
 

diff --git a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp
index 37d50f3d17017d24235e7fb8d3db3e1e554219fd..83a3df3d1e4472bf371fe177cd666aeeffd1a03e 100644 (file)
--- a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.pointer.pass.cpp
@@ -59,7 +59,7 @@ void test(StringT expected, StringViewT fmt, PointerT arg) {
     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);
 }

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
index c645ad8f476f13c40109610d2e29b45b57ea1cbd..124eb843d298ea8c0095fdb85ff4f0d9ae71449f 100644 (file)
--- a/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -90,7 +90,7 @@ int main(int, char**)
     test<std::int_least64_t>();
 
     test<intmax_t>();
-    test<intptr_t>();
+    test<std::intptr_t>();
 
     test<std::uint8_t>();
     test<std::uint16_t>();
@@ -108,7 +108,7 @@ int main(int, char**)
     test<std::uint_least64_t>();
 
     test<uintmax_t>();
-    test<uintptr_t>();
+    test<std::uintptr_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();

diff --git a/libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp b/libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
index a4f534e4b212cb219370e471e39695b0a18eb033..3e1006ad984cd1b5b1d826c361dfc193e7320be0 100644 (file)
--- a/libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
+++ b/libcxx/test/std/utilities/memory/temporary.buffer/overaligned.pass.cpp
@@ -40,7 +40,7 @@ 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;

diff --git a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp
index e354d4a2721d520f1e254c29683585ddda6ba38d..4281cc1aa9e0db83f06dccbfee5d2e2c3ab620b1 100644 (file)
--- a/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp
+++ b/libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/allocate_shared_construct.pass.cpp
@@ -123,7 +123,7 @@ struct Bar {
 };
 
 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**) {

diff --git a/libcxx/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
index a1c24b745b441e748003c8f4a9362c9110011789..66318951a8c975fe49896eaf048b8972d1204a6f 100644 (file)
--- a/libcxx/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
+++ b/libcxx/test/std/utilities/meta/meta.unary.prop.query/alignment_of.pass.cpp
@@ -43,8 +43,8 @@ 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)>();