[libc++] Qualifies intmax_t and uintmax_t.

[Mordante]

Summary

This has been done using the following command

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

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

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

#endif
   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<std::intptr_t>,  ::atomic_intptr_t>);
   static_assert(std::is_same_v<std::atomic<std::uintptr_t>, ::atomic_uintptr_t>);
   static_assert(std::is_same_v<std::atomic<std::size_t>,    ::atomic_size_t>);
   static_assert(std::is_same_v<std::atomic<std::ptrdiff_t>, ::atomic_ptrdiff_t>);
-  static_assert(std::is_same_v<std::atomic<intmax_t>,  ::atomic_intmax_t>);
-  static_assert(std::is_same_v<std::atomic<uintmax_t>, ::atomic_uintmax_t>);
+  static_assert(std::is_same_v<std::atomic<std::intmax_t>,  ::atomic_intmax_t>);
+  static_assert(std::is_same_v<std::atomic<std::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;
   using ::atomic_exchange;
   using ::atomic_exchange_explicit;

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

#endif
     test<std::uint32_t> ();
     test< std::int64_t> ();
     test<std::uint64_t> ();
 
     test<std::intptr_t>  ();
     test<std::uintptr_t> ();
     test<std::size_t>    ();
     test<std::ptrdiff_t> ();
-    test<intmax_t>  ();
-    test<uintmax_t> ();
+    test<std::intmax_t>  ();
+    test<std::uintmax_t> ();
 
-    test<uintmax_t> ();
-    test<uintmax_t> ();
+    test<std::uintmax_t> ();
+    test<std::uintmax_t> ();
 
     test<TriviallyCopyable>();
     test<PaddedTriviallyCopyable>();
 #ifndef __APPLE__ // Apple doesn't ship libatomic
     /*
         These aren't going to be lock-free,
         so some libatomic.a is necessary.
     */

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp

const path sym = env.create_symlink("file1", "sym");
     remove(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
     TEST_DOES_NOT_THROW(ent.refresh());
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     // doesn't throw!
     //
     //
     //
     //TEST_THROWS_TYPE(filesystem_error, ent.file_size());
   }
   env.create_file("file1", 99);
   {
     directory_entry ent(sym);
     assert(ent.is_symlink());
     assert(ent.is_regular_file());
     assert(ent.file_size() == 99);
 
     remove(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     assert(!ec);
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     TEST_THROWS_TYPE(filesystem_error, ent.file_size());
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
// test file doesn't exist
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_symlink, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
-    CHECK_ACCESS(hard_link_count, uintmax_t(-1));
+    CHECK_ACCESS(hard_link_count, std::uintmax_t(-1));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_in_dir);
     assert(ent.is_symlink());
     assert(ent.is_regular_file());
     assert(ent.exists());
 
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_symlink, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
-    CHECK_ACCESS(hard_link_count, uintmax_t(-1));
+    CHECK_ACCESS(hard_link_count, std::uintmax_t(-1));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym);
     assert(ent.is_symlink());
     assert(ent.is_regular_file());
     assert(ent.exists());
 
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
     assert(!ec);
     assert(ent.is_symlink());
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_regular_file, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
-    CHECK_ACCESS(hard_link_count, uintmax_t(-1));
+    CHECK_ACCESS(hard_link_count, std::uintmax_t(-1));
   }
 #undef CHECK_ACCESS
 }
 #endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
 int main(int, char**) {
   test_refresh_method();
   test_refresh_ec_method();

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp

 
 #include "test_macros.h"
 
 static void signatures() {
   using namespace fs;
   {
     const fs::directory_entry e = {};
     std::error_code ec;
-    static_assert(std::is_same<decltype(e.file_size()), uintmax_t>::value, "");
-    static_assert(std::is_same<decltype(e.file_size(ec)), uintmax_t>::value,
+    static_assert(std::is_same<decltype(e.file_size()), std::uintmax_t>::value, "");
+    static_assert(std::is_same<decltype(e.file_size(ec)), std::uintmax_t>::value,
                   "");
     static_assert(noexcept(e.file_size()) == false, "");
     static_assert(noexcept(e.file_size(ec)) == true, "");
   }
 }
 
 static void basic() {
   using namespace fs;
 
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dir = env.create_dir("dir");
   const path sym = env.create_symlink("file", "sym");
 
   {
     directory_entry ent(file);
-    uintmax_t expect = file_size(ent);
+    std::uintmax_t expect = file_size(ent);
     assert(expect == 42);
 
     // Remove the file to show that the results were already in the cache.
     LIBCPP_ONLY(remove(file));
 
     std::error_code ec = GetTestEC();
     assert(ent.file_size(ec) == expect);
     assert(!ec);
   }
   env.create_file("file", 99);
   {
     directory_entry ent(sym);
 
-    uintmax_t expect = file_size(ent);
+    std::uintmax_t expect = file_size(ent);
     assert(expect == 99);
 
     LIBCPP_ONLY(remove(ent));
 
     std::error_code ec = GetTestEC();
     assert(ent.file_size(ec) == 99);
     assert(!ec);
   }
#endif
 
   for (auto const& TC : TestCases) {
     const path& p = TC.p;
     directory_entry ent(p);
     assert(ent.path() == p);
     std::error_code ec = GetTestEC(0);
 
     std::error_code other_ec = GetTestEC(1);
-    uintmax_t expect = file_size(p, other_ec);
+    std::uintmax_t expect = file_size(p, other_ec);
 
-    uintmax_t got = ent.file_size(ec);
+    std::uintmax_t got = ent.file_size(ec);
     assert(got == expect);
-    assert(got == uintmax_t(-1));
+    assert(got == std::uintmax_t(-1));
     assert(ec == other_ec);
     assert(ErrorIs(ec, TC.expected_err));
 
     ExceptionChecker Checker(p, TC.expected_err, "directory_entry::file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
 }
 
// test a file which doesn't exist
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
     assert(ent.path() == static_env.DNE);
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    uintmax_t expect_bad = file_size(static_env.BadSymlink, ec);
-    assert(expect_bad == uintmax_t(-1));
+    std::uintmax_t expect_bad = file_size(static_env.BadSymlink, ec);
+    assert(expect_bad == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     ent.assign(static_env.BadSymlink, ec);
     assert(ent.path() == static_env.BadSymlink);
     assert(!ec);
 
     ec = GetTestEC();
     assert(ent.file_size(ec) == expect_bad);
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
-    uintmax_t expect_good = file_size(file);
+    std::uintmax_t expect_good = file_size(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
     assert(ent.path() == file);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied, "file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     assert(ent.file_size(ec) == expect_good);
     assert(!ec);
     TEST_DOES_NOT_THROW(ent.file_size());
   }
   permissions(dir, old_perms);
   // test a symlink w/o appropriate permissions.
   {
     directory_entry ent;
-    uintmax_t expect_good = file_size(sym_in_dir);
+    std::uintmax_t expect_good = file_size(sym_in_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
     assert(ent.path() == sym_in_dir);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     assert(ent.file_size(ec) == expect_good);
     assert(!ec);
     TEST_DOES_NOT_THROW(ent.file_size());
   }
   permissions(dir, old_perms);
   // test a symlink to a file w/o appropriate permissions
   {
     directory_entry ent;
-    uintmax_t expect_good = file_size(sym_out_of_dir);
+    std::uintmax_t expect_good = file_size(sym_out_of_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
     assert(ent.path() == sym_out_of_dir);
     assert(!ec);
 
     ec = GetTestEC();
-    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ent.file_size(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
                              "file_size");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp

 
 #include "test_macros.h"
 
 static void signatures() {
   using namespace fs;
   {
     const directory_entry e = {};
     std::error_code ec;
-    static_assert(std::is_same<decltype(e.hard_link_count()), uintmax_t>::value, "");
-    static_assert(std::is_same<decltype(e.hard_link_count(ec)), uintmax_t>::value,
+    static_assert(std::is_same<decltype(e.hard_link_count()), std::uintmax_t>::value, "");
+    static_assert(std::is_same<decltype(e.hard_link_count(ec)), std::uintmax_t>::value,
                   "");
     static_assert(noexcept(e.hard_link_count()) == false, "");
     static_assert(noexcept(e.hard_link_count(ec)) == true, "");
   }
 }
 
 static void basic() {
   using namespace fs;
 
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dir = env.create_dir("dir");
   const path sym = env.create_symlink("file", "sym");
 
   {
     directory_entry ent(file);
-    uintmax_t expect = hard_link_count(ent);
+    std::uintmax_t expect = hard_link_count(ent);
 
     // Remove the file to show that the results were already in the cache.
     LIBCPP_ONLY(remove(file));
 
     std::error_code ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect);
     assert(!ec);
   }
   {
     directory_entry ent(dir);
-    uintmax_t expect = hard_link_count(ent);
+    std::uintmax_t expect = hard_link_count(ent);
 
     LIBCPP_ONLY(remove(dir));
 
     std::error_code ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect);
     assert(!ec);
   }
   env.create_file("file", 99);
static void not_regular_file() {
 
   const perms old_perms = status(dir).permissions();
 
   auto test_path = [=](const path &p) {
     std::error_code dummy_ec = GetTestEC();
     directory_entry ent(p, dummy_ec);
     assert(!dummy_ec);
 
-    uintmax_t expect = hard_link_count(p);
+    std::uintmax_t expect = hard_link_count(p);
 
     LIBCPP_ONLY(permissions(dir, perms::none));
 
     std::error_code ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect);
     assert(!ec);
     TEST_DOES_NOT_THROW(ent.hard_link_count());
     permissions(dir, old_perms);
// test a file which doesn't exist
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
     assert(ec);
     assert(ent.path() == static_env.DNE);
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ent.hard_link_count(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
-    uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec);
-    assert(expect_bad == uintmax_t(-1));
+    std::uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec);
+    assert(expect_bad == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     ent.assign(static_env.BadSymlink, ec);
     assert(ent.path() == static_env.BadSymlink);
     assert(!ec);
 
     ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect_bad);
     assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
   }
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
-    uintmax_t expect_good = hard_link_count(file);
+    std::uintmax_t expect_good = hard_link_count(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
     assert(ent.path() == file);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ent.hard_link_count(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "hard_link_count");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect_good);
     assert(!ec);
     TEST_DOES_NOT_THROW(ent.hard_link_count());
   }
   permissions(dir, old_perms);
   // test a symlink w/o appropriate permissions.
   {
     directory_entry ent;
-    uintmax_t expect_good = hard_link_count(sym_in_dir);
+    std::uintmax_t expect_good = hard_link_count(sym_in_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
     assert(ent.path() == sym_in_dir);
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ent.hard_link_count(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "hard_link_count");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
     assert(ent.hard_link_count(ec) == expect_good);
     assert(!ec);
     TEST_DOES_NOT_THROW(ent.hard_link_count());
   }
   permissions(dir, old_perms);
   // test a symlink to a file w/o appropriate permissions
   {
     directory_entry ent;
-    uintmax_t expect_good = hard_link_count(sym_out_of_dir);
+    std::uintmax_t expect_good = hard_link_count(sym_out_of_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
     assert(ent.path() == sym_out_of_dir);
     assert(!ec);
 
     ec = GetTestEC();
-    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ent.hard_link_count(ec) == std::uintmax_t(-1));
     assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
                              "hard_link_count");
     TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp

 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
-    ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t);
-    ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t);
+    ASSERT_SAME_TYPE(decltype(hard_link_count(p)), std::uintmax_t);
+    ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), std::uintmax_t);
     ASSERT_NOT_NOEXCEPT(hard_link_count(p));
     ASSERT_NOEXCEPT(hard_link_count(p, ec));
 }
 
 static void hard_link_count_for_file()
 {
     static_test_env static_env;
     assert(hard_link_count(static_env.File) == 1);
     std::error_code ec;
     assert(hard_link_count(static_env.File, ec) == 1);
 }
 
 static void hard_link_count_for_directory()
 {
     static_test_env static_env;
-    uintmax_t DirExpect = 3; // hard link from . .. and Dir2
-    uintmax_t Dir3Expect = 2; // hard link from . ..
-    uintmax_t DirExpectAlt = DirExpect;
-    uintmax_t Dir3ExpectAlt = Dir3Expect;
+    std::uintmax_t DirExpect = 3; // hard link from . .. and Dir2
+    std::uintmax_t Dir3Expect = 2; // hard link from . ..
+    std::uintmax_t DirExpectAlt = DirExpect;
+    std::uintmax_t Dir3ExpectAlt = Dir3Expect;
 #if defined(__APPLE__)
     // Filesystems formatted with case sensitive hfs+ behave unixish as
     // expected. Normal hfs+ filesystems report the number of directory
     // entries instead.
     DirExpectAlt = 5; // .  ..  Dir2  file1  file2
     Dir3Expect = 3; // .  ..  file5
 #endif
     assert(hard_link_count(static_env.Dir) == DirExpect ||

 
 static void hard_link_count_error_cases()
 {
     static_test_env static_env;
     const path testCases[] = {
         static_env.BadSymlink,
         static_env.DNE
     };
-    const uintmax_t expect = static_cast<uintmax_t>(-1);
+    const std::uintmax_t expect = static_cast<std::uintmax_t>(-1);
     for (auto& TC : testCases) {
         std::error_code ec;
         assert(hard_link_count(TC, ec) == expect);
         assert(ec);
     }
 }
 
 int main(int, char**) {
     signature_test();
     hard_link_count_for_file();
     hard_link_count_for_directory();
     hard_link_count_increments_test();
     hard_link_count_error_cases();
 
     return 0;
 }

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp

 using namespace fs;
 
 // This test is intended to test 'sendfile's 2gb limit for a single call, and
 // to ensure that libc++ correctly copies files larger than that limit.
 // However it requires allocating ~5GB of filesystem space. This might not
 // be acceptable on all systems.
 static void large_file() {
   using namespace fs;
-  constexpr uintmax_t sendfile_size_limit = 2147479552ull;
-  constexpr uintmax_t additional_size = 1024;
-  constexpr uintmax_t test_file_size = sendfile_size_limit + additional_size;
+  constexpr std::uintmax_t sendfile_size_limit = 2147479552ull;
+  constexpr std::uintmax_t additional_size = 1024;
+  constexpr std::uintmax_t test_file_size = sendfile_size_limit + additional_size;
   static_assert(test_file_size > sendfile_size_limit, "");
 
   scoped_test_env env;
 
   // Check that we have more than sufficient room to create the files needed
   // to perform the test.
   if (space(env.test_root).available < 3 * test_file_size) {
     return;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp

 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
-    ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t);
-    ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t);
+    ASSERT_SAME_TYPE(decltype(file_size(p)), std::uintmax_t);
+    ASSERT_SAME_TYPE(decltype(file_size(p, ec)), std::uintmax_t);
     ASSERT_NOT_NOEXCEPT(file_size(p));
     ASSERT_NOEXCEPT(file_size(p, ec));
 }
 
 static void file_size_empty_test()
 {
     static_test_env static_env;
     const path p = static_env.EmptyFile;
struct {
     path p;
     std::errc expected_err;
   } TestCases[] = {
       {static_env.Dir, std::errc::is_a_directory},
       {static_env.SymlinkToDir, std::errc::is_a_directory},
       {static_env.BadSymlink, std::errc::no_such_file_or_directory},
       {static_env.DNE, std::errc::no_such_file_or_directory},
       {"", std::errc::no_such_file_or_directory}};
-    const uintmax_t expect = static_cast<uintmax_t>(-1);
+    const std::uintmax_t expect = static_cast<std::uintmax_t>(-1);
     for (auto& TC : TestCases) {
       std::error_code ec = GetTestEC();
       assert(file_size(TC.p, ec) == expect);
       assert(ErrorIs(ec, TC.expected_err));
 
       ExceptionChecker Checker(TC.p, TC.expected_err, "file_size");
       TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, file_size(TC.p));
     }

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

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

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

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

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

 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, std::int8_t>);
     static_assert(!std::is_invocable_v<L, std::int16_t>);
     static_assert(!std::is_invocable_v<L, std::int32_t>);
     static_assert(!std::is_invocable_v<L, std::int64_t>);
-    static_assert(!std::is_invocable_v<L, intmax_t>);
+    static_assert(!std::is_invocable_v<L, std::intmax_t>);
     static_assert(!std::is_invocable_v<L, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, std::int8_t>);
     static_assert(!std::is_invocable_v<L, std::int16_t>);
     static_assert(!std::is_invocable_v<L, std::int32_t>);
     static_assert(!std::is_invocable_v<L, std::int64_t>);
-    static_assert(!std::is_invocable_v<L, intmax_t>);
+    static_assert(!std::is_invocable_v<L, std::intmax_t>);
     static_assert(!std::is_invocable_v<L, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);

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

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

 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, std::int8_t>);
     static_assert(!std::is_invocable_v<L, std::int16_t>);
     static_assert(!std::is_invocable_v<L, std::int32_t>);
     static_assert(!std::is_invocable_v<L, std::int64_t>);
-    static_assert(!std::is_invocable_v<L, intmax_t>);
+    static_assert(!std::is_invocable_v<L, std::intmax_t>);
     static_assert(!std::is_invocable_v<L, std::intptr_t>);
     static_assert(!std::is_invocable_v<L, std::ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
     static_assert(!std::is_invocable_v<L, char8_t>);

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

libcxx/test/std/time/time.hms/time.hms.nonmembers/ostream.pass.cpp

 template <class CharT>
 static void test() {
   // Note std::atto can't be tested since the ratio conversion from std::atto
   // std::chrono::seconds to std::chrono::hours overflows when intmax_t is a
   // 64-bit type. This is a limitiation in the constructor of
   // std::chrono::hh_mm_ss.
 
   // C locale - integral power of 10 ratios
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::femto>{1'234'567'890}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::femto>{1'234'567'890}}) ==
          SV("00:00:00.000001234567890"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::pico>{1'234'567'890}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::pico>{1'234'567'890}}) ==
          SV("00:00:00.001234567890"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::nano>{1'234'567'890}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::nano>{1'234'567'890}}) ==
          SV("00:00:01.234567890"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::micro>{1'234'567}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::micro>{1'234'567}}) ==
          SV("00:00:01.234567"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::milli>{123'456}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::milli>{123'456}}) ==
          SV("00:02:03.456"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::centi>{12'345}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::centi>{12'345}}) ==
          SV("00:02:03.45"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::deci>{1'234}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::deci>{1'234}}) ==
          SV("00:02:03.4"));
 
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t>{123}}) == SV("00:02:03"));
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t>{123}}) == SV("00:02:03"));
 
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::deca>{-366}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::deca>{-366}}) ==
          SV("-01:01:00"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::hecto>{-72}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::hecto>{-72}}) ==
          SV("-02:00:00"));
-  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::kilo>{-86}}) ==
+  assert(stream_c_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::kilo>{-86}}) ==
          SV("-23:53:20"));
 
   // Starting at mega it will pass one day
 
   // fr_FR locale - integral power of not 10 ratios
   assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{
-             std::chrono::duration<intmax_t, std::ratio<1, 5'000'000>>{5'000}}) == SV("00:00:00,0010000"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 8'000>>{3}}) ==
+             std::chrono::duration<std::intmax_t, std::ratio<1, 5'000'000>>{5'000}}) == SV("00:00:00,0010000"));
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 8'000>>{3}}) ==
          SV("00:00:00,000375"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 4'000>>{1}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 4'000>>{1}}) ==
          SV("00:00:00,00025"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 5'000>>{5}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 5'000>>{5}}) ==
          SV("00:00:00,0010"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 8>>{-4}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 8>>{-4}}) ==
          SV("-00:00:00,500"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 4>>{-8}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 4>>{-8}}) ==
          SV("-00:00:02,00"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 5>>{-5}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 5>>{-5}}) ==
          SV("-00:00:01,0"));
 
   // TODO FMT Note there's no wording on the rounding
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 9>>{5}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 9>>{5}}) ==
          SV("00:00:00,555555"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 7>>{7}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 7>>{7}}) ==
          SV("00:00:01,000000"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 6>>{1}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 6>>{1}}) ==
          SV("00:00:00,166666"));
-  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<intmax_t, std::ratio<1, 3>>{2}}) ==
+  assert(stream_fr_FR_locale<CharT>(std::chrono::hh_mm_ss{std::chrono::duration<std::intmax_t, std::ratio<1, 3>>{2}}) ==
          SV("00:00:00,666666"));
 
   // ja_JP locale - floating points
   assert(stream_ja_JP_locale<CharT>(std::chrono::hh_mm_ss{
              std::chrono::duration<long double, std::femto>{1'234'567'890.123}}) == SV("00:00:00.000001234567890"));
   assert(stream_ja_JP_locale<CharT>(std::chrono::hh_mm_ss{
              std::chrono::duration<long double, std::pico>{1'234'567'890.123}}) == SV("00:00:00.001234567890"));
   assert(stream_ja_JP_locale<CharT>(std::chrono::hh_mm_ss{

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

//  LWG #2119
     test<std::int_fast32_t>();
     test<std::int_fast64_t>();
 
     test<std::int_least8_t>();
     test<std::int_least16_t>();
     test<std::int_least32_t>();
     test<std::int_least64_t>();
 
-    test<intmax_t>();
+    test<std::intmax_t>();
     test<std::intptr_t>();
 
     test<std::uint8_t>();
     test<std::uint16_t>();
     test<std::uint32_t>();
     test<std::uint64_t>();
 
     test<std::uint_fast8_t>();
     test<std::uint_fast16_t>();
     test<std::uint_fast32_t>();
     test<std::uint_fast64_t>();
 
     test<std::uint_least8_t>();
     test<std::uint_least16_t>();
     test<std::uint_least32_t>();
     test<std::uint_least64_t>();
 
-    test<uintmax_t>();
+    test<std::uintmax_t>();
     test<std::uintptr_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
   return 0;
 }

libcxx/test/support/filesystem_test_helper.h

std::string sanitize_path(std::string raw) {
         return raw;
     }
 
     // Purposefully using a size potentially larger than off_t here so we can
     // test the behavior of libc++fs when it is built with _FILE_OFFSET_BITS=64
     // but the caller is not (std::filesystem also uses uintmax_t rather than
     // off_t). On a 32-bit system this allows us to create a file larger than
     // 2GB.
-    std::string create_file(fs::path filename_path, uintmax_t size = 0) {
+    std::string create_file(fs::path filename_path, std::uintmax_t size = 0) {
         std::string filename = sanitize_path(filename_path.string());
 
         if (size >
             static_cast<typename std::make_unsigned<utils::off64_t>::type>(
                 std::numeric_limits<utils::off64_t>::max())) {
             fprintf(stderr, "create_file(%s, %ju) too large\n",
                     filename.c_str(), size);
             abort();