Cleanup name qualification in the filesystem internals.

In most cases there is no reason why the filesystem internals
use the qualifier std:: or _VSTD::. This patch removes the unneeded
qualifiers, making the sources files more consistent

llvm-svn: 337684

3 files changed, 118 insertions, 118 deletions

diff --git a/libcxx/src/experimental/filesystem/directory_iterator.cpp b/libcxx/src/experimental/filesystem/directory_iterator.cpp
index b49ea398fe0..7b485b4c6d3 100644
--- a/libcxx/src/experimental/filesystem/directory_iterator.cpp
+++ b/libcxx/src/experimental/filesystem/directory_iterator.cpp
@@ -98,8 +98,8 @@ public:
   __dir_stream& operator=(const __dir_stream&) = delete;
 
   __dir_stream(__dir_stream&& __ds) noexcept
-      : __stream_(__ds.__stream_), __root_(std::move(__ds.__root_)),
-        __entry_(std::move(__ds.__entry_)) {
+      : __stream_(__ds.__stream_), __root_(move(__ds.__root_)),
+        __entry_(move(__ds.__entry_)) {
     __ds.__stream_ = INVALID_HANDLE_VALUE;
   }
 
@@ -107,7 +107,7 @@ public:
       : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
     __stream_ = ::FindFirstFileEx(root.c_str(),  &__data_);
     if (__stream_ == INVALID_HANDLE_VALUE) {
-      ec = error_code(::GetLastError(), std::generic_category());
+      ec = error_code(::GetLastError(), generic_category());
       const bool ignore_permission_denied =
           bool(opts & directory_options::skip_permission_denied);
       if (ignore_permission_denied && ec.value() == ERROR_ACCESS_DENIED)
@@ -138,16 +138,16 @@ public:
           directory_entry::__create_iter_result(get_file_type(__data)));
       return true;
     }
-    ec = error_code(::GetLastError(), std::generic_category());
+    ec = error_code(::GetLastError(), generic_category());
     close();
     return false;
   }
 
 private:
-  std::error_code close() noexcept {
-    std::error_code ec;
+  error_code close() noexcept {
+    error_code ec;
     if (!::FindClose(__stream_))
-      ec = error_code(::GetLastError(), std::generic_category());
+      ec = error_code(::GetLastError(), generic_category());
     __stream_ = INVALID_HANDLE_VALUE;
     return ec;
   }
@@ -166,8 +166,8 @@ public:
     __dir_stream& operator=(const __dir_stream&) = delete;
 
     __dir_stream(__dir_stream&& other) noexcept
-        : __stream_(other.__stream_), __root_(std::move(other.__root_)),
-          __entry_(std::move(other.__entry_))
+        : __stream_(other.__stream_), __root_(move(other.__root_)),
+          __entry_(move(other.__entry_))
     {
         other.__stream_ = nullptr;
     }
@@ -211,8 +211,8 @@ public:
         }
     }
 private:
-    std::error_code close() noexcept {
-        std::error_code m_ec;
+    error_code close() noexcept {
+        error_code m_ec;
         if (::closedir(__stream_) == -1)
            m_ec = detail::capture_errno();
         __stream_ = nullptr;
@@ -233,7 +233,7 @@ directory_iterator::directory_iterator(const path& p, error_code *ec,
 {
   ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
   if (ec)
     *ec = m_ec;
@@ -249,9 +249,9 @@ directory_iterator& directory_iterator::__increment(error_code *ec)
     _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
     ErrorHandler<void> err("directory_iterator::operator++()", ec);
 
-    std::error_code m_ec;
+    error_code m_ec;
     if (!__imp_->advance(m_ec)) {
-      path root = std::move(__imp_->__root_);
+      path root = move(__imp_->__root_);
       __imp_.reset();
       if (m_ec)
         err.report(m_ec, "at root \"%s\"", root);
@@ -278,16 +278,16 @@ recursive_directory_iterator::recursive_directory_iterator(const path& p,
 {
   ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   __dir_stream new_s(p, opt, m_ec);
   if (m_ec)
     err.report(m_ec);
   if (m_ec || !new_s.good())
     return;
 
-  __imp_ = _VSTD::make_shared<__shared_imp>();
+  __imp_ = make_shared<__shared_imp>();
   __imp_->__options_ = opt;
-  __imp_->__stack_.push(_VSTD::move(new_s));
+  __imp_->__stack_.push(move(new_s));
 }
 
 void recursive_directory_iterator::__pop(error_code* ec)
@@ -331,7 +331,7 @@ void recursive_directory_iterator::__advance(error_code* ec) {
 
   const directory_iterator end_it;
   auto& stack = __imp_->__stack_;
-  std::error_code m_ec;
+  error_code m_ec;
   while (stack.size() > 0) {
     if (stack.top().advance(m_ec))
       return;
@@ -341,7 +341,7 @@ void recursive_directory_iterator::__advance(error_code* ec) {
   }
 
     if (m_ec) {
-      path root = std::move(stack.top().__root_);
+      path root = move(stack.top().__root_);
       __imp_.reset();
       err.report(m_ec, "at root \"%s\"", root);
     } else {
@@ -357,7 +357,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
   auto& curr_it = __imp_->__stack_.top();
 
   bool skip_rec = false;
-  std::error_code m_ec;
+  error_code m_ec;
   if (!rec_sym) {
     file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
     if (m_ec && status_known(st))
@@ -375,7 +375,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
     if (!skip_rec) {
         __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
         if (new_it.good()) {
-            __imp_->__stack_.push(_VSTD::move(new_it));
+            __imp_->__stack_.push(move(new_it));
             return true;
         }
     }
@@ -385,7 +385,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
         if (m_ec.value() == EACCES && allow_eacess) {
           if (ec) ec->clear();
         } else {
-          path at_ent = std::move(curr_it.__entry_.__p_);
+          path at_ent = move(curr_it.__entry_.__p_);
           __imp_.reset();
           err.report(m_ec, "attempting recursion into \"%s\"", at_ent);
         }
diff --git a/libcxx/src/experimental/filesystem/filesystem_common.h b/libcxx/src/experimental/filesystem/filesystem_common.h
index 6db0cac7f04..22ad9c313ae 100644
--- a/libcxx/src/experimental/filesystem/filesystem_common.h
+++ b/libcxx/src/experimental/filesystem/filesystem_common.h
@@ -67,7 +67,7 @@ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
 namespace detail {
 namespace {
 
-static std::string format_string_imp(const char* msg, ...) {
+static string format_string_imp(const char* msg, ...) {
   // we might need a second shot at this, so pre-emptivly make a copy
   struct GuardVAList {
     va_list& target;
@@ -91,24 +91,24 @@ static std::string format_string_imp(const char* msg, ...) {
   va_copy(args_cp, args);
   GuardVAList args_copy_guard(args_cp);
 
-  std::array<char, 256> local_buff;
-  std::size_t size = local_buff.size();
+  array<char, 256> local_buff;
+  size_t size = local_buff.size();
   auto ret = ::vsnprintf(local_buff.data(), size, msg, args_cp);
 
   args_copy_guard.clear();
 
   // handle empty expansion
   if (ret == 0)
-    return std::string{};
-  if (static_cast<std::size_t>(ret) < size)
-    return std::string(local_buff.data());
+    return string{};
+  if (static_cast<size_t>(ret) < size)
+    return string(local_buff.data());
 
   // we did not provide a long enough buffer on our first attempt.
   // add 1 to size to account for null-byte in size cast to prevent overflow
-  size = static_cast<std::size_t>(ret) + 1;
-  auto buff_ptr = std::unique_ptr<char[]>(new char[size]);
+  size = static_cast<size_t>(ret) + 1;
+  auto buff_ptr = unique_ptr<char[]>(new char[size]);
   ret = ::vsnprintf(buff_ptr.get(), size, msg, args);
-  return std::string(buff_ptr.get());
+  return string(buff_ptr.get());
 }
 
 const char* unwrap(string const& s) { return s.c_str(); }
@@ -120,13 +120,13 @@ Arg const& unwrap(Arg const& a) {
 }
 
 template <class... Args>
-std::string format_string(const char* fmt, Args const&... args) {
+string format_string(const char* fmt, Args const&... args) {
   return format_string_imp(fmt, unwrap(args)...);
 }
 
-std::error_code capture_errno() {
+error_code capture_errno() {
   _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
-  return std::error_code(errno, std::generic_category());
+  return error_code(errno, generic_category());
 }
 
 template <class T>
@@ -375,7 +375,7 @@ using TimeStructArray = TimeStruct[2];
 #endif
 
 bool SetFileTimes(const path& p, TimeStructArray const& TS,
-                  std::error_code& ec) {
+                  error_code& ec) {
 #if !defined(_LIBCXX_USE_UTIMENSAT)
   if (::utimes(p.c_str(), TS) == -1)
 #else
diff --git a/libcxx/src/experimental/filesystem/operations.cpp b/libcxx/src/experimental/filesystem/operations.cpp
index a3dd4349dae..33583f45fc3 100644
--- a/libcxx/src/experimental/filesystem/operations.cpp
+++ b/libcxx/src/experimental/filesystem/operations.cpp
@@ -330,7 +330,7 @@ struct FileDescriptor {
 
   bool status_known() const { return _VSTD_FS::status_known(m_status); }
 
-  file_status refresh_status(std::error_code& ec);
+  file_status refresh_status(error_code& ec);
 
   void close() noexcept {
     if (fd != -1)
@@ -363,9 +363,9 @@ perms posix_get_perms(const struct ::stat& st) noexcept {
   return static_cast< ::mode_t>(prms & perms::mask);
 }
 
-file_status create_file_status(std::error_code& m_ec, path const& p,
+file_status create_file_status(error_code& m_ec, path const& p,
                                const struct ::stat& path_stat,
-                               std::error_code* ec) {
+                               error_code* ec) {
   if (ec)
     *ec = m_ec;
   if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
@@ -401,33 +401,33 @@ file_status create_file_status(std::error_code& m_ec, path const& p,
 }
 
 file_status posix_stat(path const& p, struct ::stat& path_stat,
-                       std::error_code* ec) {
-  std::error_code m_ec;
+                       error_code* ec) {
+  error_code m_ec;
   if (::stat(p.c_str(), &path_stat) == -1)
     m_ec = detail::capture_errno();
   return create_file_status(m_ec, p, path_stat, ec);
 }
 
-file_status posix_stat(path const& p, std::error_code* ec) {
+file_status posix_stat(path const& p, error_code* ec) {
   struct ::stat path_stat;
   return posix_stat(p, path_stat, ec);
 }
 
 file_status posix_lstat(path const& p, struct ::stat& path_stat,
-                        std::error_code* ec) {
-  std::error_code m_ec;
+                        error_code* ec) {
+  error_code m_ec;
   if (::lstat(p.c_str(), &path_stat) == -1)
     m_ec = detail::capture_errno();
   return create_file_status(m_ec, p, path_stat, ec);
 }
 
-file_status posix_lstat(path const& p, std::error_code* ec) {
+file_status posix_lstat(path const& p, error_code* ec) {
   struct ::stat path_stat;
   return posix_lstat(p, path_stat, ec);
 }
 
 bool posix_ftruncate(const FileDescriptor& fd, size_t to_size,
-                     std::error_code& ec) {
+                     error_code& ec) {
   if (::ftruncate(fd.fd, to_size) == -1) {
     ec = capture_errno();
     return false;
@@ -449,11 +449,11 @@ bool stat_equivalent(const StatT& st1, const StatT& st2) {
   return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
 }
 
-file_status FileDescriptor::refresh_status(std::error_code& ec) {
+file_status FileDescriptor::refresh_status(error_code& ec) {
   // FD must be open and good.
   m_status = file_status{};
   m_stat = {};
-  std::error_code m_ec;
+  error_code m_ec;
   if (::fstat(fd, &m_stat) == -1)
     m_ec = capture_errno();
   m_status = create_file_status(m_ec, name, m_stat, &ec);
@@ -486,7 +486,7 @@ void filesystem_error::__create_what(int __num_paths) {
   }();
 }
 
-static path __do_absolute(const path& p, path *cwd, std::error_code *ec) {
+static path __do_absolute(const path& p, path *cwd, error_code *ec) {
   if (ec) ec->clear();
     if (p.is_absolute())
       return p;
@@ -496,12 +496,12 @@ static path __do_absolute(const path& p, path *cwd, std::error_code *ec) {
     return (*cwd) / p;
 }
 
-path __absolute(const path& p, std::error_code *ec) {
+path __absolute(const path& p, error_code *ec) {
     path cwd;
     return __do_absolute(p, &cwd, ec);
 }
 
-path __canonical(path const & orig_p, std::error_code *ec)
+path __canonical(path const & orig_p, error_code *ec)
 {
     path cwd;
     ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
@@ -515,7 +515,7 @@ path __canonical(path const & orig_p, std::error_code *ec)
 }
 
 void __copy(const path& from, const path& to, copy_options options,
-            std::error_code *ec)
+            error_code *ec)
 {
   ErrorHandler<void> err("copy", ec, &from, &to);
 
@@ -524,7 +524,7 @@ void __copy(const path& from, const path& to, copy_options options,
 
   const bool sym_status2 = bool(options & copy_options::copy_symlinks);
 
-  std::error_code m_ec1;
+  error_code m_ec1;
   struct ::stat f_st = {};
   const file_status f = sym_status || sym_status2
                             ? detail::posix_lstat(from, f_st, &m_ec1)
@@ -588,7 +588,7 @@ void __copy(const path& from, const path& to, copy_options options,
         directory_iterator it = ec ? directory_iterator(from, *ec)
                                    : directory_iterator(from);
         if (ec && *ec) { return; }
-        std::error_code m_ec2;
+        error_code m_ec2;
         for (; it != directory_iterator(); it.increment(m_ec2)) {
           if (m_ec2) {
             return err.report(m_ec2);
@@ -651,27 +651,27 @@ bool copy_file_impl_copyfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
 __attribute__((unused)) bool copy_file_impl_default(FileDescriptor& read_fd,
                                                     FileDescriptor& write_fd,
                                                     error_code& ec) {
-  std::ifstream in;
-  in.__open(read_fd.fd, std::ios::binary);
+  ifstream in;
+  in.__open(read_fd.fd, ios::binary);
   if (!in.is_open()) {
     // This assumes that __open didn't reset the error code.
     ec = capture_errno();
     return false;
   }
-  std::ofstream out;
-  out.__open(write_fd.fd, std::ios::binary);
+  ofstream out;
+  out.__open(write_fd.fd, ios::binary);
   if (!out.is_open()) {
     ec = capture_errno();
     return false;
   }
 
   if (in.good() && out.good()) {
-    using InIt = std::istreambuf_iterator<char>;
-    using OutIt = std::ostreambuf_iterator<char>;
+    using InIt = istreambuf_iterator<char>;
+    using OutIt = ostreambuf_iterator<char>;
     InIt bin(in);
     InIt ein;
     OutIt bout(out);
-    std::copy(bin, ein, bout);
+    copy(bin, ein, bout);
   }
   if (out.fail() || in.fail()) {
     ec = make_error_code(errc::io_error);
@@ -696,12 +696,12 @@ bool copy_file_impl(FileDescriptor& from, FileDescriptor& to, error_code& ec) {
 } // namespace detail
 
 bool __copy_file(const path& from, const path& to, copy_options options,
-                 std::error_code *ec)
+                 error_code *ec)
 {
   using detail::FileDescriptor;
   ErrorHandler<bool> err("copy_file", ec, &to, &from);
 
-  std::error_code m_ec;
+  error_code m_ec;
   FileDescriptor from_fd =
       FileDescriptor::create_with_status(&from, m_ec, O_RDONLY | O_NONBLOCK);
   if (m_ec)
@@ -786,7 +786,7 @@ bool __copy_file(const path& from, const path& to, copy_options options,
 }
 
 void __copy_symlink(const path& existing_symlink, const path& new_symlink,
-                    std::error_code *ec)
+                    error_code *ec)
 {
     const path real_path(__read_symlink(existing_symlink, ec));
     if (ec && *ec) { return; }
@@ -796,11 +796,11 @@ void __copy_symlink(const path& existing_symlink, const path& new_symlink,
     __create_symlink(real_path, new_symlink, ec);
 }
 
-bool __create_directories(const path& p, std::error_code *ec)
+bool __create_directories(const path& p, error_code *ec)
 {
   ErrorHandler<bool> err("create_directories", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   auto const st = detail::posix_stat(p, &m_ec);
   if (!status_known(st))
     return err.report(m_ec);
@@ -824,7 +824,7 @@ bool __create_directories(const path& p, std::error_code *ec)
     return __create_directory(p, ec);
 }
 
-bool __create_directory(const path& p, std::error_code *ec)
+bool __create_directory(const path& p, error_code *ec)
 {
   ErrorHandler<bool> err("create_directory", ec, &p);
 
@@ -836,12 +836,12 @@ bool __create_directory(const path& p, std::error_code *ec)
 }
 
 bool __create_directory(path const & p, path const & attributes,
-                        std::error_code *ec)
+                        error_code *ec)
 {
   ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
 
   StatT attr_stat;
-  std::error_code mec;
+  error_code mec;
   auto st = detail::posix_stat(attributes, attr_stat, &mec);
   if (!status_known(st))
     return err.report(mec);
@@ -854,31 +854,31 @@ bool __create_directory(path const & p, path const & attributes,
 }
 
 void __create_directory_symlink(path const& from, path const& to,
-                                std::error_code* ec) {
+                                error_code* ec) {
   ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
   if (::symlink(from.c_str(), to.c_str()) != 0)
     return err.report(capture_errno());
 }
 
-void __create_hard_link(const path& from, const path& to, std::error_code *ec){
+void __create_hard_link(const path& from, const path& to, error_code *ec){
   ErrorHandler<void> err("create_hard_link", ec, &from, &to);
   if (::link(from.c_str(), to.c_str()) == -1)
     return err.report(capture_errno());
 }
 
-void __create_symlink(path const & from, path const & to, std::error_code *ec) {
+void __create_symlink(path const & from, path const & to, error_code *ec) {
   ErrorHandler<void> err("create_symlink", ec, &from, &to);
   if (::symlink(from.c_str(), to.c_str()) == -1)
     return err.report(capture_errno());
 }
 
-path __current_path(std::error_code *ec) {
+path __current_path(error_code *ec) {
   ErrorHandler<path> err("current_path", ec);
 
   auto size = ::pathconf(".", _PC_PATH_MAX);
   _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
 
-  auto buff = std::unique_ptr<char[]>(new char[size + 1]);
+  auto buff = unique_ptr<char[]>(new char[size + 1]);
   char* ret;
   if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr)
     return err.report(capture_errno(), "call to getcwd failed");
@@ -886,17 +886,17 @@ path __current_path(std::error_code *ec) {
   return {buff.get()};
 }
 
-void __current_path(const path& p, std::error_code *ec) {
+void __current_path(const path& p, error_code *ec) {
   ErrorHandler<void> err("current_path", ec, &p);
   if (::chdir(p.c_str()) == -1)
     err.report(capture_errno());
 }
 
-bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
+bool __equivalent(const path& p1, const path& p2, error_code *ec)
 {
   ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
 
-  std::error_code ec1, ec2;
+  error_code ec1, ec2;
   StatT st1 = {}, st2 = {};
   auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
   if (!exists(s1))
@@ -909,11 +909,11 @@ bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
 }
 
 
-std::uintmax_t __file_size(const path& p, std::error_code *ec)
+uintmax_t __file_size(const path& p, error_code *ec)
 {
   ErrorHandler<uintmax_t> err("file_size", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   struct ::stat st;
   file_status fst = detail::posix_stat(p, st, &m_ec);
   if (!exists(fst) || !is_regular_file(fst)) {
@@ -924,27 +924,27 @@ std::uintmax_t __file_size(const path& p, std::error_code *ec)
     return err.report(m_ec);
   }
     // is_regular_file(p) == true
-    return static_cast<std::uintmax_t>(st.st_size);
+    return static_cast<uintmax_t>(st.st_size);
 }
 
-std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
+uintmax_t __hard_link_count(const path& p, error_code *ec)
 {
   ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   StatT st;
   detail::posix_stat(p, st, &m_ec);
   if (m_ec)
     return err.report(m_ec);
-  return static_cast<std::uintmax_t>(st.st_nlink);
+  return static_cast<uintmax_t>(st.st_nlink);
 }
 
 
-bool __fs_is_empty(const path& p, std::error_code *ec)
+bool __fs_is_empty(const path& p, error_code *ec)
 {
   ErrorHandler<bool> err("is_empty", ec, &p);
 
-  std::error_code m_ec;
+  error_code m_ec;
   StatT pst;
   auto st = detail::posix_stat(p, pst, &m_ec);
   if (m_ec)
@@ -957,7 +957,7 @@ bool __fs_is_empty(const path& p, std::error_code *ec)
       return false;
     return it == directory_iterator{};
   } else if (is_regular_file(st))
-    return static_cast<std::uintmax_t>(pst.st_size) == 0;
+    return static_cast<uintmax_t>(pst.st_size) == 0;
 
   _LIBCPP_UNREACHABLE();
 }
@@ -974,12 +974,12 @@ static file_time_type __extract_last_write_time(const path& p, const StatT& st,
   return FSTime::convert_timespec(ts);
 }
 
-file_time_type __last_write_time(const path& p, std::error_code *ec)
+file_time_type __last_write_time(const path& p, error_code *ec)
 {
-    using namespace ::std::chrono;
+    using namespace chrono;
     ErrorHandler<file_time_type> err("last_write_time", ec, &p);
 
-    std::error_code m_ec;
+    error_code m_ec;
     StatT st;
     detail::posix_stat(p, st, &m_ec);
     if (m_ec)
@@ -988,14 +988,14 @@ file_time_type __last_write_time(const path& p, std::error_code *ec)
 }
 
 void __last_write_time(const path& p, file_time_type new_time,
-                       std::error_code *ec)
+                       error_code *ec)
 {
-    using namespace std::chrono;
+    using namespace chrono;
     using namespace detail;
 
     ErrorHandler<void> err("last_write_time", ec, &p);
 
-    std::error_code m_ec;
+    error_code m_ec;
     TimeStructArray tbuf;
 #if !defined(_LIBCXX_USE_UTIMENSAT)
     // This implementation has a race condition between determining the
@@ -1020,7 +1020,7 @@ void __last_write_time(const path& p, file_time_type new_time,
 
 
 void __permissions(const path& p, perms prms, perm_options opts,
-                   std::error_code *ec)
+                   error_code *ec)
 {
   ErrorHandler<void> err("permissions", ec, &p);
 
@@ -1036,7 +1036,7 @@ void __permissions(const path& p, perms prms, perm_options opts,
   bool set_sym_perms = false;
   prms &= perms::mask;
   if (!resolve_symlinks || (add_perms || remove_perms)) {
-    std::error_code m_ec;
+    error_code m_ec;
     file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
                                       : detail::posix_lstat(p, &m_ec);
     set_sym_perms = is_symlink(st);
@@ -1066,11 +1066,11 @@ void __permissions(const path& p, perms prms, perm_options opts,
 }
 
 
-path __read_symlink(const path& p, std::error_code *ec) {
+path __read_symlink(const path& p, error_code *ec) {
   ErrorHandler<path> err("read_symlink", ec, &p);
 
   char buff[PATH_MAX + 1];
-  std::error_code m_ec;
+  error_code m_ec;
   ::ssize_t ret;
   if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
     return err.report(capture_errno());
@@ -1082,7 +1082,7 @@ path __read_symlink(const path& p, std::error_code *ec) {
 }
 
 
-bool __remove(const path& p, std::error_code *ec) {
+bool __remove(const path& p, error_code *ec) {
   ErrorHandler<bool> err("remove", ec, &p);
   if (::remove(p.c_str()) == -1) {
     if (errno != ENOENT)
@@ -1094,12 +1094,12 @@ bool __remove(const path& p, std::error_code *ec) {
 
 namespace {
 
-std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
+uintmax_t remove_all_impl(path const & p, error_code& ec)
 {
-    const auto npos = static_cast<std::uintmax_t>(-1);
+    const auto npos = static_cast<uintmax_t>(-1);
     const file_status st = __symlink_status(p, &ec);
     if (ec) return npos;
-     std::uintmax_t count = 1;
+     uintmax_t count = 1;
     if (is_directory(st)) {
         for (directory_iterator it(p, ec); !ec && it != directory_iterator();
              it.increment(ec)) {
@@ -1115,10 +1115,10 @@ std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
 
 } // end namespace
 
-std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
+uintmax_t __remove_all(const path& p, error_code *ec) {
   ErrorHandler<uintmax_t> err("remove_all", ec, &p);
 
-  std::error_code mec;
+  error_code mec;
   auto count = remove_all_impl(p, mec);
   if (mec) {
     if (mec == errc::no_such_file_or_directory)
@@ -1128,32 +1128,32 @@ std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
     return count;
 }
 
-void __rename(const path& from, const path& to, std::error_code *ec) {
+void __rename(const path& from, const path& to, error_code *ec) {
   ErrorHandler<void> err("rename", ec, &from, &to);
   if (::rename(from.c_str(), to.c_str()) == -1)
     err.report(capture_errno());
 }
 
-void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
+void __resize_file(const path& p, uintmax_t size, error_code *ec) {
   ErrorHandler<void> err("resize_file", ec, &p);
   if (::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
     return err.report(capture_errno());
 }
 
-space_info __space(const path& p, std::error_code *ec) {
+space_info __space(const path& p, error_code *ec) {
   ErrorHandler<void> err("space", ec, &p);
   space_info si;
   struct statvfs m_svfs = {};
   if (::statvfs(p.c_str(), &m_svfs) == -1) {
     err.report(capture_errno());
-    si.capacity = si.free = si.available = static_cast<std::uintmax_t>(-1);
+    si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
     return si;
   }
     // Multiply with overflow checking.
-    auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
+    auto do_mult = [&](uintmax_t& out, uintmax_t other) {
       out = other * m_svfs.f_frsize;
       if (other == 0 || out / other != m_svfs.f_frsize)
-          out = static_cast<std::uintmax_t>(-1);
+          out = static_cast<uintmax_t>(-1);
     };
     do_mult(si.capacity, m_svfs.f_blocks);
     do_mult(si.free, m_svfs.f_bfree);
@@ -1161,28 +1161,28 @@ space_info __space(const path& p, std::error_code *ec) {
     return si;
 }
 
-file_status __status(const path& p, std::error_code *ec) {
+file_status __status(const path& p, error_code *ec) {
     return detail::posix_stat(p, ec);
 }
 
-file_status __symlink_status(const path& p, std::error_code *ec) {
+file_status __symlink_status(const path& p, error_code *ec) {
     return detail::posix_lstat(p, ec);
 }
 
-path __temp_directory_path(std::error_code* ec) {
+path __temp_directory_path(error_code* ec) {
   ErrorHandler<path> err("temp_directory_path", ec);
 
   const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
   const char* ret = nullptr;
 
   for (auto& ep : env_paths)
-    if ((ret = std::getenv(ep)))
+    if ((ret = getenv(ep)))
       break;
   if (ret == nullptr)
     ret = "/tmp";
 
   path p(ret);
-  std::error_code m_ec;
+  error_code m_ec;
   file_status st = detail::posix_stat(p, &m_ec);
   if (!status_known(st))
     return err.report(m_ec, "cannot access path \"%s\"", p);
@@ -1195,7 +1195,7 @@ path __temp_directory_path(std::error_code* ec) {
 }
 
 
-path __weakly_canonical(const path& p, std::error_code *ec) {
+path __weakly_canonical(const path& p, error_code *ec) {
   ErrorHandler<path> err("weakly_canonical", ec, &p);
 
   if (p.empty())
@@ -1206,11 +1206,11 @@ path __weakly_canonical(const path& p, std::error_code *ec) {
   tmp.__reserve(p.native().size());
   auto PP = PathParser::CreateEnd(p.native());
   --PP;
-  std::vector<string_view_t> DNEParts;
+  vector<string_view_t> DNEParts;
 
   while (PP.State != PathParser::PS_BeforeBegin) {
     tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
-    std::error_code m_ec;
+    error_code m_ec;
     file_status st = __status(tmp, &m_ec);
     if (!status_known(st)) {
       return err.report(m_ec);
@@ -1376,8 +1376,8 @@ path path::lexically_normal() const {
   if (__pn_.empty())
     return *this;
 
-  using PartKindPair = std::pair<string_view_t, PathPartKind>;
-  std::vector<PartKindPair> Parts;
+  using PartKindPair = pair<string_view_t, PathPartKind>;
+  vector<PartKindPair> Parts;
   // Guess as to how many elements the path has to avoid reallocating.
   Parts.reserve(32);
 
@@ -1533,7 +1533,7 @@ int path::__compare(string_view_t __s) const {
 size_t hash_value(const path& __p) noexcept {
   auto PP = PathParser::CreateBegin(__p.native());
   size_t hash_value = 0;
-  std::hash<string_view_t> hasher;
+  hash<string_view_t> hasher;
   while (PP) {
     hash_value = __hash_combine(hash_value, hasher(*PP));
     ++PP;