[libc++] Qualifies ptrdiff_t and max_align_t.

mordante · mordante · commit d868135691bb · 2023-03-22T17:27:57.000+01:00
This has been done using the following commands find libcxx/test -type f -exec perl -pi -e 's|^([^/]+?)((?<!::)ptrdiff_t)|\1std::\2|' \{} \; find libcxx/test -type f -exec perl -pi -e 's|^([^/]+?)((?<!::)max_align_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/D146550
diff --git a/libcxx/test/libcxx/algorithms/debug_less.pass.cpp b/libcxx/test/libcxx/algorithms/debug_less.pass.cpp
@@ -207,7 +207,7 @@ void test_non_const_arg_cmp() {
 struct ValueIterator {
     typedef std::input_iterator_tag iterator_category;
     typedef std::size_t value_type;
-    typedef ptrdiff_t difference_type;
+    typedef std::ptrdiff_t difference_type;
     typedef std::size_t reference;
     typedef std::size_t* pointer;
 
diff --git a/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp b/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
@@ -62,7 +62,7 @@ int main(int, char**)
 #endif
 
     test<char>();
-    test<ptrdiff_t>();
+    test<std::ptrdiff_t>();
     test<std::size_t>();
 
     return 0;
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/ranges.find_first_of.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/ranges.find_first_of.pass.cpp
@@ -71,7 +71,7 @@ template <int N1, int N2>
 struct Data {
   std::array<int, N1> input1;
   std::array<int, N2> input2;
-  ptrdiff_t expected;
+  std::ptrdiff_t expected;
 };
 
 template <class Iter1, class Sent1, class Iter2, class Sent2, int N1, int N2>
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
@@ -203,7 +203,7 @@ void f() {
   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::size_t>,    ::atomic_size_t>);
-  static_assert(std::is_same_v<std::atomic<ptrdiff_t>, ::atomic_ptrdiff_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>);
 
diff --git a/libcxx/test/std/atomics/types.pass.cpp b/libcxx/test/std/atomics/types.pass.cpp
@@ -61,7 +61,7 @@ struct test_atomic<A*, false>
         A a; (void)a;
 #if TEST_STD_VER >= 17
     static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
-    static_assert((std::is_same_v<typename A::difference_type, ptrdiff_t>), "");
+    static_assert((std::is_same_v<typename A::difference_type, std::ptrdiff_t>), "");
 #endif
     }
 };
@@ -149,7 +149,7 @@ int main(int, char**)
     test<intptr_t>  ();
     test<uintptr_t> ();
     test<std::size_t>    ();
-    test<ptrdiff_t> ();
+    test<std::ptrdiff_t> ();
     test<intmax_t>  ();
     test<uintmax_t> ();
 
diff --git a/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp b/libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp
@@ -19,21 +19,21 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-typedef ptrdiff_t T;
+typedef std::ptrdiff_t T;
 const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7};
 const T t2[] = {10, 11, 12, 13, 14, 15};
-const ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
-const ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
+const std::ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);
+const std::ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);
 
 template <class C>
 void
-testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
+testd(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
 {
     typename C::const_iterator i = c.begin();
-    ptrdiff_t n1 = 0;
+    std::ptrdiff_t n1 = 0;
     for (; n1 < p; ++n1, ++i)
         assert(*i == t1[n1]);
-    for (ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)
+    for (std::ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)
         assert(*i == t2[n2]);
     for (; n1 < size_t1; ++n1, ++i)
         assert(*i == t1[n1]);
@@ -42,11 +42,11 @@ testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
 
 template <class C>
 void
-tests(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
+tests(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
 {
     typename C::const_iterator i = c.begin();
-    ptrdiff_t n = 0;
-    ptrdiff_t d = l > f+1 ? l-1-f : 0;
+    std::ptrdiff_t n = 0;
+    std::ptrdiff_t d = l > f+1 ? l-1-f : 0;
     if (d == 0 || p == f)
     {
         for (n = 0; n < size_t1; ++n, ++i)
@@ -82,11 +82,11 @@ int main(int, char**)
     {
     // splicing different containers
     typedef std::forward_list<T> C;
-    for (ptrdiff_t f = 0; f <= size_t2+1; ++f)
+    for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)
     {
-        for (ptrdiff_t l = f; l <= size_t2+1; ++l)
+        for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)
         {
-            for (ptrdiff_t p = 0; p <= size_t1; ++p)
+            for (std::ptrdiff_t p = 0; p <= size_t1; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
                 C c2(std::begin(t2), std::end(t2));
@@ -99,19 +99,19 @@ int main(int, char**)
     }
 
     // splicing within same container
-    for (ptrdiff_t f = 0; f <= size_t1+1; ++f)
+    for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)
     {
-        for (ptrdiff_t l = f; l <= size_t1; ++l)
+        for (std::ptrdiff_t l = f; l <= size_t1; ++l)
         {
-            for (ptrdiff_t p = 0; p <= f; ++p)
+            for (std::ptrdiff_t p = 0; p <= f; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
 
                 c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c1),
                       std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));
                 tests(c1, p, f, l);
             }
-            for (ptrdiff_t p = l; p <= size_t1; ++p)
+            for (std::ptrdiff_t p = l; p <= size_t1; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
 
@@ -126,11 +126,11 @@ int main(int, char**)
     {
     // splicing different containers
     typedef std::forward_list<T, min_allocator<T>> C;
-    for (ptrdiff_t f = 0; f <= size_t2+1; ++f)
+    for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)
     {
-        for (ptrdiff_t l = f; l <= size_t2+1; ++l)
+        for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)
         {
-            for (ptrdiff_t p = 0; p <= size_t1; ++p)
+            for (std::ptrdiff_t p = 0; p <= size_t1; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
                 C c2(std::begin(t2), std::end(t2));
@@ -143,19 +143,19 @@ int main(int, char**)
     }
 
     // splicing within same container
-    for (ptrdiff_t f = 0; f <= size_t1+1; ++f)
+    for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)
     {
-        for (ptrdiff_t l = f; l <= size_t1; ++l)
+        for (std::ptrdiff_t l = f; l <= size_t1; ++l)
         {
-            for (ptrdiff_t p = 0; p <= f; ++p)
+            for (std::ptrdiff_t p = 0; p <= f; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
 
                 c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c1),
                       std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));
                 tests(c1, p, f, l);
             }
-            for (ptrdiff_t p = l; p <= size_t1; ++p)
+            for (std::ptrdiff_t p = l; p <= size_t1; ++p)
             {
                 C c1(std::begin(t1), std::end(t1));
 
diff --git a/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp b/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
@@ -100,7 +100,7 @@ int main(int, char**)
     test_const_container ( sv );
 
     static constexpr int arrA [] { 1, 2, 3 };
-    ASSERT_SAME_TYPE(ptrdiff_t, decltype(std::ssize(arrA)));
+    ASSERT_SAME_TYPE(std::ptrdiff_t, decltype(std::ssize(arrA)));
     static_assert( std::is_signed_v<decltype(std::ssize(arrA))>, "");
     test_const_array ( arrA );
 
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_move.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_move.pass.cpp
@@ -28,7 +28,7 @@ template <bool IsNoexcept>
 struct MaybeNoexceptMove {
   int x;
   using value_type = int;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
 
   constexpr friend value_type&& iter_move(MaybeNoexceptMove) noexcept(IsNoexcept) {
     return std::move(global);
diff --git a/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_swap.pass.cpp b/libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_swap.pass.cpp
@@ -26,7 +26,7 @@
 template <bool IsNoexcept>
 struct MaybeNoexceptSwap {
   using value_type = int;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
 
   constexpr friend void iter_swap(MaybeNoexceptSwap, MaybeNoexceptSwap) noexcept(IsNoexcept) {
   }
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cmp/sfinae.compile.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cmp/sfinae.compile.pass.cpp
@@ -49,7 +49,7 @@
 struct IterBase {
   using iterator_category = std::bidirectional_iterator_tag;
   using value_type = int;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
   using pointer = int*;
   using reference = int&;
 
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_move.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_move.pass.cpp
@@ -55,7 +55,7 @@ constexpr bool test() {
     {
       struct ThrowingCopyNoexceptDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         ThrowingCopyNoexceptDecrement();
         ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
@@ -80,7 +80,7 @@ constexpr bool test() {
     {
       struct NoexceptCopyThrowingDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyThrowingDecrement();
         NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
@@ -105,7 +105,7 @@ constexpr bool test() {
     {
       struct NoexceptCopyAndDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyAndDecrement();
         NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
diff --git a/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_swap.pass.cpp b/libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_swap.pass.cpp
@@ -61,7 +61,7 @@ constexpr bool test() {
     {
       struct ThrowingCopyNoexceptDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         ThrowingCopyNoexceptDecrement();
         ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
@@ -89,7 +89,7 @@ constexpr bool test() {
     {
       struct NoexceptCopyThrowingDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyThrowingDecrement();
         NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
@@ -117,7 +117,7 @@ constexpr bool test() {
     {
       struct NoexceptCopyAndDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyAndDecrement();
         NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
diff --git a/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp b/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp
@@ -26,5 +26,5 @@ static_assert(alignof(std::max_align_t) >= alignof(long double), "");
 static_assert(alignof(std::max_align_t) >= alignof(void*), "");
 #if TEST_STD_VER > 14
 static_assert(alignof(std::max_align_t) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__,
-              "max_align_t alignment should be no larger than operator new's alignment");
+              "std::max_align_t alignment should be no larger than operator new's alignment");
 #endif
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
@@ -90,7 +90,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -87,7 +87,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -92,7 +92,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -90,7 +90,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -87,7 +87,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -86,7 +86,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -91,7 +91,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -88,7 +88,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
diff --git a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
@@ -98,7 +98,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
@@ -86,7 +86,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
@@ -87,7 +87,7 @@ int main(int, char**)
     static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
-    static_assert(!std::is_invocable_v<L, ptrdiff_t>);
+    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>);
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
@@ -137,7 +137,7 @@ int main(int, char**)
 #endif
 
 //     int_test<char>();
-    signed_test<ptrdiff_t>();
+    signed_test<std::ptrdiff_t>();
     unsigned_test<std::size_t>();
 
     return 0;
diff --git a/libcxx/test/std/ranges/range.access/ssize.pass.cpp b/libcxx/test/std/ranges/range.access/ssize.pass.cpp
@@ -71,7 +71,7 @@ constexpr bool test() {
   // This gets converted to ptrdiff_t because it's wider.
   ShortUnsignedReturnType c;
   assert(std::ranges::ssize(c) == 42);
-  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), ptrdiff_t);
+  ASSERT_SAME_TYPE(decltype(std::ranges::ssize(c)), std::ptrdiff_t);
 
   return true;
 }
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/constraints.compile.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/constraints.compile.pass.cpp
@@ -66,7 +66,7 @@ namespace test3 {
 
   struct AlmostInputIterator {
     using value_type = char;
-    using difference_type = ptrdiff_t;
+    using difference_type = std::ptrdiff_t;
     using iterator_concept = int;
 
     constexpr const char& operator*() const;
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp
diff --git a/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.pass.cpp b/libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.pass.cpp
diff --git a/libcxx/test/std/strings/string.view/types.pass.cpp b/libcxx/test/std/strings/string.view/types.pass.cpp
diff --git a/libcxx/test/std/thread/thread.semaphore/max.pass.cpp b/libcxx/test/std/thread/thread.semaphore/max.pass.cpp
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
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
diff --git a/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp b/libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp
diff --git a/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp
diff --git a/libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_bytes.pass.cpp b/libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_bytes.pass.cpp
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h

Original file line number	Diff line number	Diff line change
`@@ -19,21 +19,21 @@`
`19`	`19`	`#include "test_macros.h"`
`20`	`20`	`#include "min_allocator.h"`
`21`	`21`
`22`		`-typedef ptrdiff_t T;`
	`22`	`+typedef std::ptrdiff_t T;`
`23`	`23`	`const T t1[] = {0, 1, 2, 3, 4, 5, 6, 7};`
`24`	`24`	`const T t2[] = {10, 11, 12, 13, 14, 15};`
`25`		`-const ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);`
`26`		`-const ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);`
	`25`	`+const std::ptrdiff_t size_t1 = std::end(t1) - std::begin(t1);`
	`26`	`+const std::ptrdiff_t size_t2 = std::end(t2) - std::begin(t2);`
`27`	`27`
`28`	`28`	`template <class C>`
`29`	`29`	`void`
`30`		`-testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)`
	`30`	`+testd(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)`
`31`	`31`	`{`
`32`	`32`	`typename C::const_iterator i = c.begin();`
`33`		`- ptrdiff_t n1 = 0;`
	`33`	`+ std::ptrdiff_t n1 = 0;`
`34`	`34`	`for (; n1 < p; ++n1, ++i)`
`35`	`35`	`assert(*i == t1[n1]);`
`36`		`- for (ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)`
	`36`	`+ for (std::ptrdiff_t n2 = f; n2 < l-1; ++n2, ++i)`
`37`	`37`	`assert(*i == t2[n2]);`
`38`	`38`	`for (; n1 < size_t1; ++n1, ++i)`
`39`	`39`	`assert(*i == t1[n1]);`
`@@ -42,11 +42,11 @@ testd(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)`
`42`	`42`
`43`	`43`	`template <class C>`
`44`	`44`	`void`
`45`		`-tests(const C& c, ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)`
	`45`	`+tests(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)`
`46`	`46`	`{`
`47`	`47`	`typename C::const_iterator i = c.begin();`
`48`		`- ptrdiff_t n = 0;`
`49`		`- ptrdiff_t d = l > f+1 ? l-1-f : 0;`
	`48`	`+ std::ptrdiff_t n = 0;`
	`49`	`+ std::ptrdiff_t d = l > f+1 ? l-1-f : 0;`
`50`	`50`	`if (d == 0 \|\| p == f)`
`51`	`51`	`{`
`52`	`52`	`for (n = 0; n < size_t1; ++n, ++i)`
`@@ -82,11 +82,11 @@ int main(int, char**)`
`82`	`82`	`{`
`83`	`83`	`// splicing different containers`
`84`	`84`	`typedef std::forward_list<T> C;`
`85`		`- for (ptrdiff_t f = 0; f <= size_t2+1; ++f)`
	`85`	`+ for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)`
`86`	`86`	`{`
`87`		`- for (ptrdiff_t l = f; l <= size_t2+1; ++l)`
	`87`	`+ for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)`
`88`	`88`	`{`
`89`		`- for (ptrdiff_t p = 0; p <= size_t1; ++p)`
	`89`	`+ for (std::ptrdiff_t p = 0; p <= size_t1; ++p)`
`90`	`90`	`{`
`91`	`91`	`C c1(std::begin(t1), std::end(t1));`
`92`	`92`	`C c2(std::begin(t2), std::end(t2));`
`@@ -99,19 +99,19 @@ int main(int, char**)`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// splicing within same container`
`102`		`- for (ptrdiff_t f = 0; f <= size_t1+1; ++f)`
	`102`	`+ for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)`
`103`	`103`	`{`
`104`		`- for (ptrdiff_t l = f; l <= size_t1; ++l)`
	`104`	`+ for (std::ptrdiff_t l = f; l <= size_t1; ++l)`
`105`	`105`	`{`
`106`		`- for (ptrdiff_t p = 0; p <= f; ++p)`
	`106`	`+ for (std::ptrdiff_t p = 0; p <= f; ++p)`
`107`	`107`	`{`
`108`	`108`	`C c1(std::begin(t1), std::end(t1));`
`109`	`109`
`110`	`110`	`c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c1),`
`111`	`111`	`std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));`
`112`	`112`	`tests(c1, p, f, l);`
`113`	`113`	`}`
`114`		`- for (ptrdiff_t p = l; p <= size_t1; ++p)`
	`114`	`+ for (std::ptrdiff_t p = l; p <= size_t1; ++p)`
`115`	`115`	`{`
`116`	`116`	`C c1(std::begin(t1), std::end(t1));`
`117`	`117`
`@@ -126,11 +126,11 @@ int main(int, char**)`
`126`	`126`	`{`
`127`	`127`	`// splicing different containers`
`128`	`128`	`typedef std::forward_list<T, min_allocator<T>> C;`
`129`		`- for (ptrdiff_t f = 0; f <= size_t2+1; ++f)`
	`129`	`+ for (std::ptrdiff_t f = 0; f <= size_t2+1; ++f)`
`130`	`130`	`{`
`131`		`- for (ptrdiff_t l = f; l <= size_t2+1; ++l)`
	`131`	`+ for (std::ptrdiff_t l = f; l <= size_t2+1; ++l)`
`132`	`132`	`{`
`133`		`- for (ptrdiff_t p = 0; p <= size_t1; ++p)`
	`133`	`+ for (std::ptrdiff_t p = 0; p <= size_t1; ++p)`
`134`	`134`	`{`
`135`	`135`	`C c1(std::begin(t1), std::end(t1));`
`136`	`136`	`C c2(std::begin(t2), std::end(t2));`
`@@ -143,19 +143,19 @@ int main(int, char**)`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`// splicing within same container`
`146`		`- for (ptrdiff_t f = 0; f <= size_t1+1; ++f)`
	`146`	`+ for (std::ptrdiff_t f = 0; f <= size_t1+1; ++f)`
`147`	`147`	`{`
`148`		`- for (ptrdiff_t l = f; l <= size_t1; ++l)`
	`148`	`+ for (std::ptrdiff_t l = f; l <= size_t1; ++l)`
`149`	`149`	`{`
`150`		`- for (ptrdiff_t p = 0; p <= f; ++p)`
	`150`	`+ for (std::ptrdiff_t p = 0; p <= f; ++p)`
`151`	`151`	`{`
`152`	`152`	`C c1(std::begin(t1), std::end(t1));`
`153`	`153`
`154`	`154`	`c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c1),`
`155`	`155`	`std::next(c1.cbefore_begin(), f), std::next(c1.cbefore_begin(), l));`
`156`	`156`	`tests(c1, p, f, l);`
`157`	`157`	`}`
`158`		`- for (ptrdiff_t p = l; p <= size_t1; ++p)`
	`158`	`+ for (std::ptrdiff_t p = l; p <= size_t1; ++p)`
`159`	`159`	`{`
`160`	`160`	`C c1(std::begin(t1), std::end(t1));`
`161`	`161`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@`
`26`	`26`	`template <bool IsNoexcept>`
`27`	`27`	`struct MaybeNoexceptSwap {`
`28`	`28`	`using value_type = int;`
`29`		`- using difference_type = ptrdiff_t;`
	`29`	`+ using difference_type = std::ptrdiff_t;`
`30`	`30`
`31`	`31`	`constexpr friend void iter_swap(MaybeNoexceptSwap, MaybeNoexceptSwap) noexcept(IsNoexcept) {`
`32`	`32`	`}`