[libc++] Qualifies ptrdiff_t and max_align_t.

[Mordante]

Summary

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.

[Mordante]

CI fixes

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

void test_non_const_arg_cmp() {
         std::sort(std::begin(arr), std::end(arr), cmp);
         assert(std::is_sorted(std::begin(arr), std::end(arr)));
     }
 }
 
 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;
 
     ValueIterator() { }
 
     reference operator*() { return 0; }
     ValueIterator& operator++() { return *this; }
 

libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp

int main(int, char**)
     test<std::uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
     test<char>();
-    test<ptrdiff_t>();
+    test<std::ptrdiff_t>();
     test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/ranges.find_first_of.pass.cpp

 static_assert(!HasFindFirstOfR<UncheckedRange<int*>, ForwardRangeNotSentinelSemiregular>);
 static_assert(!HasFindFirstOfR<UncheckedRange<int*>, ForwardRangeNotSentinelEqualityComparableWith>);
 static_assert(!HasFindFirstOfR<UncheckedRange<int*>, UncheckedRange<int**>>); // not indirectly_comparable
 
 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>
 constexpr void test(Data<N1, N2> d) {
   {
     std::same_as<Iter1> decltype(auto) ret =
         std::ranges::find_first_of(Iter1(d.input1.data()), Sent1(Iter1(d.input1.data() + d.input1.size())),
                                    Iter2(d.input2.data()), Sent2(Iter2(d.input2.data() + d.input2.size())));

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

#endif
   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::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>);
 
   // Just check that the symbols in the global namespace are visible.
   using ::atomic_compare_exchange_strong;
   using ::atomic_compare_exchange_strong_explicit;
   using ::atomic_compare_exchange_weak;
   using ::atomic_compare_exchange_weak_explicit;

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

 template <class A>
 struct test_atomic<A*, false>
 {
     test_atomic()
     {
         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
     }
 };
 
 template <class T>
 void
 test()
 {
#endif
     test< std::int32_t> ();
     test<std::uint32_t> ();
     test< std::int64_t> ();
     test<std::uint64_t> ();
 
     test<intptr_t>  ();
     test<uintptr_t> ();
     test<std::size_t>    ();
-    test<ptrdiff_t> ();
+    test<std::ptrdiff_t> ();
     test<intmax_t>  ();
     test<uintmax_t> ();
 
     test<uintmax_t> ();
     test<uintmax_t> ();
 
     test<TriviallyCopyable>();
     test<PaddedTriviallyCopyable>();

libcxx/test/std/containers/sequences/forwardlist/forwardlist.ops/splice_after_range.pass.cpp

 #include <stddef.h>
 #include <forward_list>
 #include <cassert>
 #include <iterator>
 
 #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]);
     assert(std::distance(c.begin(), c.end()) == size_t1 + (l > f+1 ? l-1-f : 0));
 }
 
 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)
             assert(*i == t1[n]);
     }
     else if (p < f)
     {
         for (n = 0; n < p; ++n, ++i)
tests(const C& c, std::ptrdiff_t p, ptrdiff_t f, ptrdiff_t l)
     assert(std::distance(c.begin(), c.end()) == size_t1);
 }
 
 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));
 
                 c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c2),
                       std::next(c2.cbefore_begin(), f), std::next(c2.cbefore_begin(), l));
                 testd(c1, p, f, l);
             }
         }
     }
 
     // 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));
 
                 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);
             }
         }
     }
     }
 #if TEST_STD_VER >= 11
     {
     // 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));
 
                 c1.splice_after(std::next(c1.cbefore_begin(), p), std::move(c2),
                       std::next(c2.cbefore_begin(), f), std::next(c2.cbefore_begin(), l));
                 testd(c1, p, f, l);
             }
         }
     }
 
     // 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));
 
                 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);
             }
         }
     }
     }
 #endif
 
   return 0;
 }

libcxx/test/std/iterators/iterator.container/ssize.pass.cpp

int main(int, char**)
     test_const_container ( il );
 
     std::string_view sv{"ABC"};
     test_container ( sv );
     ASSERT_SAME_TYPE(SSize, decltype(std::ssize(sv)));
     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 );
 
 //  From P1227R2:
 //     Note that the code does not just return the std::make_signed variant of
 //     the container's size() method, because it's conceivable that a container
 //     might choose to represent its size as a uint16_t, supporting up to
 //     65,535 elements, and it would be a disaster for std::ssize() to turn a

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_move.pass.cpp

 #include "test_macros.h"
 
 int global;
 
 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);
   }
 
   int& operator*() const { static int a; return a; }
 
   MaybeNoexceptMove& operator++();

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/iter_swap.pass.cpp

 #include <type_traits>
 #include <utility>
 #include "test_iterators.h"
 #include "test_macros.h"
 
 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) {
   }
 
   int& operator*() const { static int x; return x; }
 
   MaybeNoexceptSwap& operator++();
   MaybeNoexceptSwap operator++(int);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.cmp/sfinae.compile.pass.cpp

 #include <iterator>
 #include <cassert>
 
 #include "test_macros.h"
 
 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&;
 
   reference operator*() const;
   pointer operator->() const;
 };
 
 template<class T> concept HasEqual = requires (T t) { t == t; };

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_move.pass.cpp

// Check that the `iter_move` customization point is being used.
     assert(iter_move_invocations == 1);
   }
 
   // Check the `noexcept` specification.
   {
     {
       struct ThrowingCopyNoexceptDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         ThrowingCopyNoexceptDecrement();
         ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
 
         int& operator*() const noexcept { static int x; return x; }
 
         ThrowingCopyNoexceptDecrement& operator++();
         ThrowingCopyNoexceptDecrement operator++(int);
         ThrowingCopyNoexceptDecrement& operator--() noexcept;
         ThrowingCopyNoexceptDecrement operator--(int) noexcept;
 
         bool operator==(const ThrowingCopyNoexceptDecrement&) const = default;
       };
       static_assert(std::bidirectional_iterator<ThrowingCopyNoexceptDecrement>);
 
       static_assert(!std::is_nothrow_copy_constructible_v<ThrowingCopyNoexceptDecrement>);
       ASSERT_NOEXCEPT(std::ranges::iter_move(--std::declval<ThrowingCopyNoexceptDecrement&>()));
       using RI = std::reverse_iterator<ThrowingCopyNoexceptDecrement>;
       ASSERT_NOT_NOEXCEPT(iter_move(std::declval<RI>()));
     }
 
     {
       struct NoexceptCopyThrowingDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyThrowingDecrement();
         NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
 
         int& operator*() const { static int x; return x; }
 
         NoexceptCopyThrowingDecrement& operator++();
         NoexceptCopyThrowingDecrement operator++(int);
         NoexceptCopyThrowingDecrement& operator--();
         NoexceptCopyThrowingDecrement operator--(int);
 
         bool operator==(const NoexceptCopyThrowingDecrement&) const = default;
       };
       static_assert(std::bidirectional_iterator<NoexceptCopyThrowingDecrement>);
 
       static_assert( std::is_nothrow_copy_constructible_v<NoexceptCopyThrowingDecrement>);
       ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(--std::declval<NoexceptCopyThrowingDecrement&>()));
       using RI = std::reverse_iterator<NoexceptCopyThrowingDecrement>;
       ASSERT_NOT_NOEXCEPT(iter_move(std::declval<RI>()));
     }
 
     {
       struct NoexceptCopyAndDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyAndDecrement();
         NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
 
         int& operator*() const noexcept { static int x; return x; }
 
         NoexceptCopyAndDecrement& operator++();
         NoexceptCopyAndDecrement operator++(int);

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.nonmember/iter_swap.pass.cpp

// Check that the `iter_swap` customization point is being used.
     assert(iter_swap_invocations == 2);
   }
 
   // Check the `noexcept` specification.
   {
     {
       struct ThrowingCopyNoexceptDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         ThrowingCopyNoexceptDecrement();
         ThrowingCopyNoexceptDecrement(const ThrowingCopyNoexceptDecrement&);
 
         int& operator*() const noexcept { static int x; return x; }
 
         ThrowingCopyNoexceptDecrement& operator++();
         ThrowingCopyNoexceptDecrement operator++(int);
// Check the `noexcept` specification.
       using RI2 = std::reverse_iterator<int*>;
       ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<RI1>(), std::declval<RI2>()));
       ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<RI2>(), std::declval<RI1>()));
     }
 
     {
       struct NoexceptCopyThrowingDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyThrowingDecrement();
         NoexceptCopyThrowingDecrement(const NoexceptCopyThrowingDecrement&) noexcept;
 
         int& operator*() const { static int x; return x; }
 
         NoexceptCopyThrowingDecrement& operator++();
         NoexceptCopyThrowingDecrement operator++(int);
// Check the `noexcept` specification.
       using RI2 = std::reverse_iterator<int*>;
       ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<RI1>(), std::declval<RI2>()));
       ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<RI2>(), std::declval<RI1>()));
     }
 
     {
       struct NoexceptCopyAndDecrement {
         using value_type = int;
-        using difference_type = ptrdiff_t;
+        using difference_type = std::ptrdiff_t;
 
         NoexceptCopyAndDecrement();
         NoexceptCopyAndDecrement(const NoexceptCopyAndDecrement&) noexcept;
 
         int& operator*() const noexcept { static int x; return x; }
 
         NoexceptCopyAndDecrement& operator++();
         NoexceptCopyAndDecrement operator++(int);

libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp

 #if TEST_STD_VER <= 17
 static_assert(std::is_pod<std::max_align_t>::value, "");
 #endif
 static_assert(alignof(std::max_align_t) >= alignof(long long), "");
 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

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

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

 #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, 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>);
     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
     static_assert(!std::is_invocable_v<L, char16_t>);

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

int main(int, char**)
     unsigned_test<std::uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     unsigned_test<__uint128_t>();
     signed_test<__int128_t>();
 #endif
 
 //     int_test<char>();
-    signed_test<ptrdiff_t>();
+    signed_test<std::ptrdiff_t>();
     unsigned_test<std::size_t>();
 
     return 0;
 }

libcxx/test/std/ranges/range.access/ssize.pass.cpp

constexpr bool test() {
 
   SizedSentinelRange b;
   assert(std::ranges::ssize(b) == 2);
   ASSERT_SAME_TYPE(decltype(std::ranges::ssize(b)), std::ptrdiff_t);
 
   // 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;
 }
 
 // Test ADL-proofing.
 struct Incomplete;
 template<class T> struct Holder { T t; };
 static_assert(!std::is_invocable_v<RangeSSizeT, Holder<Incomplete>*>);
 static_assert(!std::is_invocable_v<RangeSSizeT, Holder<Incomplete>*&>);
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.lazy.split/constraints.compile.pass.cpp

 
 } // namespace test2
 
 // `View` is not an input range.
 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;
     constexpr AlmostInputIterator& operator++();
     constexpr void operator++(int);
     constexpr bool operator==(const AlmostInputIterator&) const;
   };
 

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp

 #include <utility>
 #include "../types.h"
 
 namespace adl {
 
 template <bool IsNoexcept = false>
 struct MaybeNoexceptIterator {
   using value_type = int;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
 
   value_type* ptr_ = nullptr;
   int* iter_move_invocations_ = nullptr;
 
   constexpr MaybeNoexceptIterator() = default;
   constexpr explicit MaybeNoexceptIterator(int* p, int& iter_moves) : ptr_(p), iter_move_invocations_(&iter_moves) {}
 
   constexpr value_type& operator*() const { return *ptr_; }

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.pass.cpp

 #include <utility>
 #include "../types.h"
 
 namespace adl {
 
 template <bool IsNoexcept = false>
 struct MaybeNoexceptIterator {
   using value_type = int;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
 
   value_type* ptr_ = nullptr;
   int* iter_swap_invocations_ = nullptr;
 
   constexpr MaybeNoexceptIterator() = default;
   constexpr explicit MaybeNoexceptIterator(int& iter_swaps) : iter_swap_invocations_(&iter_swaps) {}
 
   value_type& operator*() const { return *ptr_; }

libcxx/test/std/strings/string.view/types.pass.cpp

 void
 test()
 {
     typedef std::basic_string_view<typename Traits::char_type, Traits> S;
 
     static_assert((std::is_same<typename S::traits_type,     Traits>::value), "");
     static_assert((std::is_same<typename S::value_type,      typename Traits::char_type>::value), "");
     static_assert((std::is_same<typename S::size_type,       std::size_t>::value), "");
-    static_assert((std::is_same<typename S::difference_type, ptrdiff_t>::value), "");
+    static_assert((std::is_same<typename S::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<typename S::reference,             typename S::value_type&>::value), "");
     static_assert((std::is_same<typename S::const_reference, const typename S::value_type&>::value), "");
     static_assert((std::is_same<typename S::pointer,               typename S::value_type*>::value), "");
     static_assert((std::is_same<typename S::const_pointer,   const typename S::value_type*>::value), "");
     static_assert((std::is_same<
         typename std::iterator_traits<typename S::iterator>::iterator_category,
         std::random_access_iterator_tag>::value), "");
     static_assert((std::is_same<

libcxx/test/std/thread/thread.semaphore/max.pass.cpp

 
 #include "test_macros.h"
 
 int main(int, char**)
 {
   static_assert(std::counting_semaphore<>::max() >= 1, "");
   static_assert(std::counting_semaphore<1>::max() >= 1, "");
   static_assert(std::counting_semaphore<std::numeric_limits<int>::max()>::max() >= std::numeric_limits<int>::max(), "");
-  static_assert(std::counting_semaphore<std::numeric_limits<ptrdiff_t>::max()>::max() == std::numeric_limits<ptrdiff_t>::max(), "");
+  static_assert(std::counting_semaphore<std::numeric_limits<std::ptrdiff_t>::max()>::max() == std::numeric_limits<ptrdiff_t>::max(), "");
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp

 
 auto test_format_to_n =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) {
       {
         std::size_t n = expected.size();
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected);
       }
 #ifndef TEST_HAS_NO_LOCALIZATION
       {
         std::size_t n = expected.size();
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result =
             std::format_to_n(out.begin(), n, std::locale(), fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected);
       }
 #endif // TEST_HAS_NO_LOCALIZATION
       {
-        ptrdiff_t n = 0;
+        std::ptrdiff_t n = 0;
         std::basic_string<CharT> out;
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out.empty());
       }
       {
-        ptrdiff_t n = expected.size() / 2;
+        std::ptrdiff_t n = expected.size() / 2;
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected.substr(0, n));
       }
     };
 
 template <class CharT>
 void test_char() {
   // *** P2286 examples ***

libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp

 
 auto test_format_to_n =
     []<class CharT, class... Args>(
         std::basic_string_view<CharT> expected, test_format_string<CharT, Args...> fmt, Args&&... args) {
       {
         std::size_t n = expected.size();
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected);
       }
 #ifndef TEST_HAS_NO_LOCALIZATION
       {
         std::size_t n = expected.size();
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result =
             std::format_to_n(out.begin(), n, std::locale(), fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected);
       }
 #endif // TEST_HAS_NO_LOCALIZATION
       {
-        ptrdiff_t n = 0;
+        std::ptrdiff_t n = 0;
         std::basic_string<CharT> out;
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out.empty());
       }
       {
-        ptrdiff_t n = expected.size() / 2;
+        std::ptrdiff_t n = expected.size() / 2;
         std::basic_string<CharT> out(n, CharT(' '));
         std::format_to_n_result result = std::format_to_n(out.begin(), n, fmt, std::forward<Args>(args)...);
-        assert(result.size == static_cast<ptrdiff_t>(expected.size()));
+        assert(result.size == static_cast<std::ptrdiff_t>(expected.size()));
         assert(result.out == out.end());
         assert(out == expected.substr(0, n));
       }
     };
 
 template <class CharT>
 void test_char() {
   // *** P2286 examples ***

libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp

 // format_kind<R> is range_format::disabled.
 // [Note 1: This prevents constraint recursion for ranges whose reference type
 // is the same range type. For example, std::filesystem::path is a range of
 // std::filesystem::path. - end note]
 struct recursive_range {
   struct iterator {
     using iterator_concept = std::input_iterator_tag;
     using value_type       = recursive_range;
-    using difference_type  = ptrdiff_t;
+    using difference_type  = std::ptrdiff_t;
     using reference        = recursive_range;
 
     reference operator*() const;
 
     iterator& operator++();
     iterator operator++(int);
 
     friend bool operator==(const iterator&, const iterator&);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple.include.ranges.pass.cpp

 // Note: make sure to not include `<utility>` (or any other header including `<utility>`) because it also makes some
 // tuple specializations available, thus obscuring whether the `<ranges>` includes work correctly.
 
 using Iterator = int*;
 
 class SizedSentinel {
 public:
     constexpr bool operator==(int*) const;
-    friend constexpr ptrdiff_t operator-(const SizedSentinel&, int*);
-    friend constexpr ptrdiff_t operator-(int*, const SizedSentinel&);
+    friend constexpr std::ptrdiff_t operator-(const SizedSentinel&, int*);
+    friend constexpr std::ptrdiff_t operator-(int*, const SizedSentinel&);
 };
 
 static_assert(std::sized_sentinel_for<SizedSentinel, Iterator>);
 using SizedRange = std::ranges::subrange<Iterator, SizedSentinel>;
 
 using UnsizedSentinel = std::unreachable_sentinel_t;
 static_assert(!std::sized_sentinel_for<UnsizedSentinel, Iterator>);
 using UnsizedRange = std::ranges::subrange<Iterator, UnsizedSentinel>;

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_bytes.pass.cpp

void test() {
 
   std::pmr::polymorphic_allocator<T> allocator(&resource);
 
   {
     std::same_as<void*> decltype(auto) allocation = allocator.allocate_bytes(13);
     auto ptr                                      = static_cast<char*>(allocation);
     std::fill(ptr, ptr + 13, '0');
     assert(last_size == 13);
-    assert(last_alignment == alignof(max_align_t));
+    assert(last_alignment == alignof(std::max_align_t));
     allocator.deallocate_bytes(allocation, 13);
     assert(last_size == 13);
-    assert(last_alignment == alignof(max_align_t));
+    assert(last_alignment == alignof(std::max_align_t));
   }
   {
     void* allocation = allocator.allocate_bytes(13, 64);
     auto ptr         = static_cast<char*>(allocation);
     std::fill(ptr, ptr + 13, '0');
     assert(last_size == 13);
     assert(last_alignment == 64);
     allocator.deallocate_bytes(allocation, 13, 64);

libcxx/test/support/test_iterators.h

 #endif // TEST_STD_VER > 17
 
 template <class Iter> // ADL base() for everything else (including pointers)
 TEST_CONSTEXPR Iter base(Iter i) { return i; }
 
 template <typename T>
 struct ThrowingIterator {
     typedef std::bidirectional_iterator_tag iterator_category;
-    typedef ptrdiff_t                       difference_type;
+    typedef std::ptrdiff_t                       difference_type;
     typedef const T                         value_type;
     typedef const T *                       pointer;
     typedef const T &                       reference;
 
     enum ThrowingAction { TAIncrement, TADecrement, TADereference, TAAssignment, TAComparison };
 
     TEST_CONSTEXPR ThrowingIterator()
         : begin_(nullptr), end_(nullptr), current_(nullptr), action_(TADereference), index_(0) {}
private:
     const T* current_;
     ThrowingAction action_;
     mutable int index_;
 };
 
 template <typename T>
 struct NonThrowingIterator {
     typedef std::bidirectional_iterator_tag iterator_category;
-    typedef ptrdiff_t                       difference_type;
+    typedef std::ptrdiff_t                       difference_type;
     typedef const T                         value_type;
     typedef const T *                       pointer;
     typedef const T &                       reference;
 
     NonThrowingIterator()
         : begin_(nullptr), end_(nullptr), current_(nullptr) {}
     explicit NonThrowingIterator(const T *first, const T *last)
         : begin_(first), end_(last), current_(first) {}

 sized_sentinel(It) -> sized_sentinel<It>;
 
 namespace adl {
 
 class Iterator {
  public:
   using value_type = int;
   using reference = int&;
-  using difference_type = ptrdiff_t;
+  using difference_type = std::ptrdiff_t;
 
  private:
   value_type* ptr_ = nullptr;
   int* iter_moves_ = nullptr;
   int* iter_swaps_ = nullptr;
 
   constexpr Iterator(int* p, int* iter_moves, int* iter_swaps)
     : ptr_(p)