[libcxx] Filesystem TS -- Complete

[EricWF]

Summary

This review contains the complete filesystem TS implementation.

NOTE: DO NOT APPLY THIS PATCH FROM PHABRICATOR! IT WILL NOT WORK!

Please clone https://github.com/efcs/libcxx/tree/filesystem-ts instead.

The test suite has symlinks checked in that are needed for a large portion of the tests. Using arc patch or downloading the diff directly will not
create these symlinks.

[EricWF]

Remove unintentional change in CMake.

[dexonsmith]

Light review below, looks like great work.

I noticed the tests seem somewhat inconsistent about whether to
glue & to the type or use two spaces (i.e., & ). Which one is
preferred in this codebase? Or is it laissez-faire?

The rest of my comments are inline.

[EricWF]

In D16948#345722, @dexonsmith wrote:

Light review below, looks like great work.

I noticed the tests seem somewhat inconsistent about whether to
glue & to the type or use two spaces (i.e., & ). Which one is
preferred in this codebase? Or is it laissez-faire?

I prefer it glued to the type *i think* but there is no set style currently. I'll try and make it more consistent as I see them.

The rest of my comments are inline.

Thanks! If I could bother you to put them on phab next time instead of email it really helps me track them.

[EricWF]

Address @dexonsmith's review comments. Thanks Duncan!

[EricWF]

Ping!

[EricWF]

Update the patch to contain the complete filesystem TS.

There still some junk in this patch (test/CMakelists.txt for example) but I thought I would update this review to show the current implementation status.

[EricWF]

Remove a bunch of duplicate tests that have since been rewritten.

[EricWF]

For reference here's the current test coverage: http://efcs.ca/filesystem-coverage/

[rmaprath]

Looks like I've completely missed this patch somehow. Will try to find some time (or someone) to have a look at it from an embedded-systems / ARM point of view asap.

Great work!!!

[EricWF]

In D16948#438880, @rmaprath wrote:

Looks like I've completely missed this patch somehow. Will try to find some time (or someone) to have a look at it from an embedded-systems / ARM point of view asap.

Great work!!!

Thanks! Even just attempting to run the tests is greatly appreciated. Writing portable tests is next to impossible so there are going to be kinks to iron out for each platform.

[EricWF]

Add more tests and improve temporary file removal at end of test-suite run.

[EricWF]

Added the remaining tests.

I have tested it on:

• Ubuntu 16.04
• Ubuntu 14.04
• FreeBSD 10.3
• OS X 10.11

[EricWF]

The build now works in -fno-exceptions mode and the test suite passes.

[rmaprath]

I'm seeing a few failures on my Fedora 20 system. Will go through these tomorrow.

[EricWF]

In D16948#443941, @rmaprath wrote:

I'm seeing a few failures on my Fedora 20 system. Will go through these tomorrow.

If you want to just send me the raw ouput I'll go over them tonight.

[rmaprath]

In D16948#443942, @EricWF wrote:

In D16948#443941, @rmaprath wrote:

I'm seeing a few failures on my Fedora 20 system. Will go through these tomorrow.

If you want to just send me the raw ouput I'll go over them tonight.

This is from a default (without extra cmake options) build: https://dl.dropboxusercontent.com/u/12212624/Other/filesystem_libcxx_results_fedora20.log

Some of them look obvious. For the rest, let me know if I can get you more info, I can debug tomorrow evening.

/ Asiri

[EricWF]

Add missing include in min_allocator.h.

[EricWF]

Thanks. I fixed the missing include causing most of the failures. Please update me when you can with new results.

[majnemer]

include/experimental/filesystem

611

Do we typically put names in TODOs?

673

TODO?

src/experimental/directory_iterator.cpp

48

readdir_r is deprecated, please use readdir.

101

Why is this commented out?

src/experimental/operations.cpp

128–129

What sort of logic is this trying to determine?

355–356

Any reason why mkdir isn't wrapped like the other fs calls?

382

Hmm, why compare against zero instead of -1?

404

Hmm, SUSv4 says:

The value returned for the variable {PATH_MAX} indicates the longest relative pathname that could be given if the specified directory is the current working directory of the process.

However, you want an absolute path relative to the root directory right?

507–533

I'd suggest you swap these two blocks around. This way we don't need to add more conjunctions if we add more special cases.

529

Isn't utime deprecated? I'd suggest using utimes.

660

Formatting?

664

Why not use uintmax_t instead of decltype(si.free) ?

668–670

Does the standard give any guidance if this calculation overflows?

688

Why all these environment variables?

706–708

Formatting?

[EricWF]

@majnemer Thanks for looking at this!

include/experimental/filesystem

611

IDK. I normally do?

673

I'll clarify that. I have no idea how to implement the locale conversions. I was going to wait until most of filesystem landed before worrying about them.

src/experimental/directory_iterator.cpp

101

It should be removed. After the stream is closed the __entry_ member is never referenced again.

src/experimental/operations.cpp

128–129

If two paths resolve the the same file according to https://rawgit.com/cplusplus/filesystem-ts/develop/working-draft.html#equivalent.

355–356

There are plenty of other fs calls that aren't wrapped. The wrapped ones are because they are used in a bunch of places.

382

Probably an oversight.

404

Yes, but that language confuses me. If I'm not mistaken the longest relative pathname for the CWD is going to be longer than the absolute one, since it's easy to take an absolute path and add "./././././././" and still refer to the same directory.

FYI this code also appears in tho opergroup spec for getcwd.
http://pubs.opengroup.org/onlinepubs/009695399/functions/getcwd.html

507–533

Ack.

529

If I'm not mistaken utimes is legacy, not utime. Also note that utimensat is used on all platforms except for apple, for which this is the fallback implementation.

660

Not ever sure what I was saying there. Removing it.

664

Not sure what I was thinking. Changing it.

668–670

It says:

Any members for which the value cannot be determined shall be set to static_cast<uintmax_t>(-1).

I overlooked overflow checking. I'll add it.

No idea how I'll test it though.

688

That's the example implementation given in the spec:
https://rawgit.com/cplusplus/filesystem-ts/develop/working-draft.html#temp_directory_path

[EricWF]

Address @majnemers review comments:

• Use readdir instead of readdir_r.
• Remove or clean up poor comments.
• reshuffle last_write_time implementation
• detect overflows in space calls.

[EricWF]

In D16948#443945, @rmaprath wrote:

In D16948#443942, @EricWF wrote:

In D16948#443941, @rmaprath wrote:

I'm seeing a few failures on my Fedora 20 system. Will go through these tomorrow.

If you want to just send me the raw ouput I'll go over them tonight.

This is from a default (without extra cmake options) build: https://dl.dropboxusercontent.com/u/12212624/Other/filesystem_libcxx_results_fedora20.log

Some of them look obvious. For the rest, let me know if I can get you more info, I can debug tomorrow evening.

I installed a Fedora 23 system and ran the test suite and I didn't see any of the same failures. It must be something other than the distro.
Are you using an odd filesystem? Or maybe it could be your system locale?

[rmaprath]

In D16948#443999, @EricWF wrote:

I installed a Fedora 23 system and ran the test suite and I didn't see any of the same failures. It must be something other than the distro.
Are you using an odd filesystem? Or maybe it could be your system locale?

I suspect so. Ran the latest patch just now and I'm still seeing the remaining failures.

Btw, when do you plan to land this? I'm a bit tight as we are on the run-up to a release. I will investigate my failures offline, but I don't think it should be blocking you (given that you've got them working on fedora 23). Mind you fedora 20 is a bit old.

/ Asiri

[rmaprath]

In D16948#444006, @rmaprath wrote:

In D16948#443999, @EricWF wrote:

I installed a Fedora 23 system and ran the test suite and I didn't see any of the same failures. It must be something other than the distro.
Are you using an odd filesystem? Or maybe it could be your system locale?

I suspect so. Ran the latest patch just now and I'm still seeing the remaining failures.

Btw, when do you plan to land this? I'm a bit tight as we are on the run-up to a release. I will investigate my failures offline, but I don't think it should be blocking you (given that you've got them working on fedora 23). Mind you fedora 20 is a bit old.

/ Asiri

I don't have an odd filesystem btw, I've let fedora manage the partitioning etc. (LVM stuff - I don't know much). Other than that, I have an SSD (but don't think it can affect these tests).

/ Asiri

[EricWF]

In D16948#444006, @rmaprath wrote:

In D16948#443999, @EricWF wrote:

I installed a Fedora 23 system and ran the test suite and I didn't see any of the same failures. It must be something other than the distro.
Are you using an odd filesystem? Or maybe it could be your system locale?

I suspect so. Ran the latest patch just now and I'm still seeing the remaining failures.

Btw, when do you plan to land this? I'm a bit tight as we are on the run-up to a release. I will investigate my failures offline, but I don't think it should be blocking you (given that you've got them working on fedora 23). Mind you fedora 20 is a bit old.

/ Asiri

I have no immediate plans to land it. I'm going to try and get some eyeballs on it and some other people to try it first. If it lands and starts causing large amounts of failures it's going to be a headache and likely get reverted.

[rmaprath]

Would you / community be open to the idea of hiding the os syscalls behind an API? (like we are doing for pthreads)?

I think this is the only way we could get at least some of this functionality working on bare-metal ARM (it should work on arm-linux without much trouble - I think). How much work do you think this refactoring would need? I'm happy to do that after you land the patch.

I will see if I can try this out on arm-linux, as soon as I resolve this fedora20 mystery of mine :)

Cheers,

/ Asiri

[EricWF]

Ah I figured it out! The test suite has symlinks within it. Git handles them properly but they obviously don't survive the round trip to phabricator and back. So all of the tests that depend on them fail (with is evidently a lot).

[rmaprath]

In D16948#444010, @EricWF wrote:

Ah I figured it out! The test suite has symlinks within it. Git handles them properly but they obviously don't survive the round trip to phabricator and back. So all of the tests that depend on them fail (with is evidently a lot).

Perhaps you can put up a tarball somewhere?

/ Asiri

[EricWF]

In D16948#444009, @rmaprath wrote:

Would you / community be open to the idea of hiding the os syscalls behind an API? (like we are doing for pthreads)?

Yes I would be very open to that. Then I could also have test shims in order to test truly exceptional cases.

I think this is the only way we could get at least some of this functionality working on bare-metal ARM (it should work on arm-linux without much trouble - I think). How much work do you think this refactoring would need? I'm happy to do that after you land the patch.

It shouldn't be that much work to get path, directory_iterator and recursive_directory_iterator working. They have like 4 system calls in there implementation.

The rest of the TS is just a set of free functions. Each uses a separate system call for the most part. However the API is very simple and you can pick and choose which functions you want to support.

I will see if I can try this out on arm-linux, as soon as I resolve this fedora20 mystery of mine :)

Cheers,

/ Asiri

[EricWF]

The git branch I develop on is public: https://github.com/efcs/libcxx/tree/filesystem-ts

You can download or clone from there (and it will always be up to date!).

[rmaprath]

In D16948#444013, @EricWF wrote:

The git branch I develop on is public: https://github.com/efcs/libcxx/tree/filesystem-ts

You can download or clone from there (and it will always be up to date!).

All tests pass! :-)

I'll try to find an arm-linux setup soon and run this there as well.

/ Asiri

[majnemer]

src/experimental/operations.cpp

530

SUSv4 says:

The utime() function is marked obsolescent.

However, utimes was made legacy in SUSv3 and removed from legacy in SUSv4
http://pubs.opengroup.org/onlinepubs/9699919799/functions/utimes.html

[majnemer]

src/experimental/operations.cpp

129–130

It is possible for st_ino to wrap around while the machine is still running.
I'd mix st_gen into the comparison if we are running under one of the BSDs or Darwin.

Linux has a FS_IOC_GETVERSION ioctl but it requires a file descriptor. Maybe such heroics are not worth it.

[ahatanak]

test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp

57

Can you explain why this change was needed? I'm trying to figure out why the two static_asserts in the #else part fail.

[EricWF]

src/experimental/operations.cpp

129–130

It is possible for st_ino to wrap around while the machine is still running.

Can you clarify this point? Maybe some docs I could read.

I'd mix st_gen into the comparison if we are running under one of the BSDs or Darwin.

According to the darwin docs st_gen is only available as a super user and even then my tests show it's always zero.
https://developer.apple.com/library/ios/documentation/System/Conceptual/ManPages_iPhoneOS/man2/stat.2.html

How does mixing that in help if st_ino wraps?

test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp

57

Woops that sneaked in. I was investigating some GCC behavior unrelated to filesystem but forgot to revert the changes.

[EricWF]

Address review comments:

• Make last_write_time(path, time) use utimes instead of utime on OS X.
• Remove unintended changes to is_nothrow_callabletest.

[EricWF]

@mclow.lists Just a reminder that 3.9 branches for release on July 19th.

[EricWF]

• Mark the filesystem tests as UNSUPPORTED when libc++experimental.a is not present. This uses lit.local.cfg files as opposed to //UNSUPPORTED: comments in every file.
• Add missing trailing newlines in the tests.

[EricWF]

Unless there are any objections I plan to commit this change on Friday.

That will give it about a month of in-tree time before the 3.9 release branch.

[rmaprath]

In D16948#456929, @EricWF wrote:

Unless there are any objections I plan to commit this change on Friday.

That will give it about a month of in-tree time before the 3.9 release branch.

Fine by me.

I didn't have much time to go through the patch, is there a way to disable this module from building? It won't compile for our targets until we put in some sort of a porting layer (which I need to start thinking of). Would be nice if there is some CMake switch to turn this off until such time.

Thanks!

/ Asiri

[EricWF]

In D16948#456966, @rmaprath wrote:

In D16948#456929, @EricWF wrote:

Unless there are any objections I plan to commit this change on Friday.

That will give it about a month of in-tree time before the 3.9 release branch.

Fine by me.

I didn't have much time to go through the patch, is there a way to disable this module from building? It won't compile for our targets until we put in some sort of a porting layer (which I need to start thinking of). Would be nice if there is some CMake switch to turn this off until such time.

Currently you can switch it off using the CMake option -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF. This turns off all of the experimental libraries, including filesystem and polymorphic memory resources.

Would this be sufficient for your use case? Otherwise I can create an option to specifically disable filesystem.

[rmaprath]

Fine by me.

I didn't have much time to go through the patch, is there a way to disable this module from building? It won't compile for our targets until we put in some sort of a porting layer (which I need to start thinking of). Would be nice if there is some CMake switch to turn this off until such time.

Currently you can switch it off using the CMake option -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=OFF. This turns off all of the experimental libraries, including filesystem and polymorphic memory resources.

Would this be sufficient for your use case? Otherwise I can create an option to specifically disable filesystem.

We can currently build the rest of the experimental library (polymorphic memory resource), so it would be great if we can selectively disable just the filesystem module.

Thanks.

(sorry for the late response - went to bed)

/ Asiri

[EricWF]

Add LIBCXX_ENABLE_FILESYSTEM CMake option to turn off only the filesystem parts of libc++experimental.a.

[rmaprath]

In D16948#457266, @EricWF wrote:

Add LIBCXX_ENABLE_FILESYSTEM CMake option to turn off only the filesystem parts of libc++experimental.a.

Thanks!

[EricWF]

Final cleanup before commit. Filesystem incoming!

[EricWF]

Accepting before committing. Speak now or forever hold your peace. (Or just speak post commit)

[EricWF]

Committed as r273034.

include/experimental/filesystem

+// -*- C++ -*-
+//===--------------------------- filesystem -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP_EXPERIMENTAL_FILESYSTEM
+#define _LIBCPP_EXPERIMENTAL_FILESYSTEM
+/*
+    filesystem synopsis
+
+    namespace std { namespace experimental { namespace filesystem { inline namespace v1 {
+
+    class path;
+
+    void swap(path& lhs, path& rhs) _NOEXCEPT;
+    size_t hash_value(const path& p) _NOEXCEPT;
+
+    bool operator==(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator!=(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator< (const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator<=(const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator> (const path& lhs, const path& rhs) _NOEXCEPT;
+    bool operator>=(const path& lhs, const path& rhs) _NOEXCEPT;
+
+    path operator/ (const path& lhs, const path& rhs);
+
+    template <class charT, class traits>
+    basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const path& p);
+
+    template <class charT, class traits>
+    basic_istream<charT, traits>&
+    operator>>(basic_istream<charT, traits>& is, path& p);
+
+    template <class Source>
+      path u8path(const Source& source);
+    template <class InputIterator>
+      path u8path(InputIterator first, InputIterator last);
+
+    class filesystem_error;
+    class directory_entry;
+
+    class directory_iterator;
+
+    // enable directory_iterator range-based for statements
+    directory_iterator begin(directory_iterator iter) noexcept;
+    directory_iterator end(const directory_iterator&) noexcept;
+
+    class recursive_directory_iterator;
+
+    // enable recursive_directory_iterator range-based for statements
+    recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
+    recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
+
+    class file_status;
+
+    struct space_info
+    {
+      uintmax_t capacity;
+      uintmax_t free; 
+      uintmax_t available;
+    };
+
+    enum class file_type;
+    enum class perms;
+    enum class copy_options;
+    enum class directory_options;
+
+    typedef chrono::time_point<trivial-clock>  file_time_type;
+
+    // operational functions
+
+    path absolute(const path& p, const path& base=current_path());
+
+    path canonical(const path& p, const path& base = current_path());
+    path canonical(const path& p, error_code& ec);
+    path canonical(const path& p, const path& base, error_code& ec);
+
+    void copy(const path& from, const path& to);
+    void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+    void copy(const path& from, const path& to, copy_options options);
+    void copy(const path& from, const path& to, copy_options options,  
+                   error_code& ec) _NOEXCEPT;
+
+    bool copy_file(const path& from, const path& to);
+    bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+    bool copy_file(const path& from, const path& to, copy_options option);
+    bool copy_file(const path& from, const path& to, copy_options option,
+                           error_code& ec) _NOEXCEPT;
+
+    void copy_symlink(const path& existing_symlink, const path& new_symlink);
+    void copy_symlink(const path& existing_symlink, const path& new_symlink,
+                              error_code& ec) _NOEXCEPT;
+
+    bool create_directories(const path& p);
+    bool create_directories(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool create_directory(const path& p);
+    bool create_directory(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool create_directory(const path& p, const path& attributes);
+    bool create_directory(const path& p, const path& attributes,
+                                  error_code& ec) _NOEXCEPT;
+
+    void create_directory_symlink(const path& to, const path& new_symlink);
+    void create_directory_symlink(const path& to, const path& new_symlink,
+                                          error_code& ec) _NOEXCEPT;
+
+    void create_hard_link(const path& to, const path& new_hard_link);
+    void create_hard_link(const path& to, const path& new_hard_link,
+                                  error_code& ec) _NOEXCEPT;
+
+    void create_symlink(const path& to, const path& new_symlink);
+    void create_symlink(const path& to, const path& new_symlink,
+                                error_code& ec) _NOEXCEPT;
+
+    path current_path();
+    path current_path(error_code& ec);
+    void current_path(const path& p);
+    void current_path(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool exists(file_status s) _NOEXCEPT;
+    bool exists(const path& p);
+    bool exists(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool equivalent(const path& p1, const path& p2);
+    bool equivalent(const path& p1, const path& p2, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    file_size(const path& p);
+    uintmax_t    file_size(const path& p, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    hard_link_count(const path& p);
+    uintmax_t    hard_link_count(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_block_file(file_status s) _NOEXCEPT;
+    bool is_block_file(const path& p);
+    bool is_block_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_character_file(file_status s) _NOEXCEPT;
+    bool is_character_file(const path& p);
+    bool is_character_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_directory(file_status s) _NOEXCEPT;
+    bool is_directory(const path& p);
+    bool is_directory(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_empty(const path& p);
+    bool is_empty(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_fifo(file_status s) _NOEXCEPT;
+    bool is_fifo(const path& p);
+    bool is_fifo(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_other(file_status s) _NOEXCEPT;
+    bool is_other(const path& p);
+    bool is_other(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_regular_file(file_status s) _NOEXCEPT; 
+    bool is_regular_file(const path& p);
+    bool is_regular_file(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_socket(file_status s) _NOEXCEPT;
+    bool is_socket(const path& p);
+    bool is_socket(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool is_symlink(file_status s) _NOEXCEPT;
+    bool is_symlink(const path& p);
+    bool is_symlink(const path& p, error_code& ec) _NOEXCEPT;
+
+    file_time_type  last_write_time(const path& p);
+    file_time_type  last_write_time(const path& p, error_code& ec) _NOEXCEPT;
+    void last_write_time(const path& p, file_time_type new_time);
+    void last_write_time(const path& p, file_time_type new_time,
+                                 error_code& ec) _NOEXCEPT;
+
+    void permissions(const path& p, perms prms);
+    void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT;
+
+    path read_symlink(const path& p);
+    path read_symlink(const path& p, error_code& ec);
+
+    bool remove(const path& p);
+    bool remove(const path& p, error_code& ec) _NOEXCEPT;
+
+    uintmax_t    remove_all(const path& p);
+    uintmax_t    remove_all(const path& p, error_code& ec) _NOEXCEPT;
+
+    void rename(const path& from, const path& to);
+    void rename(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+
+    void resize_file(const path& p, uintmax_t size);
+    void resize_file(const path& p, uintmax_t size, error_code& ec) _NOEXCEPT;
+
+    space_info   space(const path& p);
+    space_info   space(const path& p, error_code& ec) _NOEXCEPT;
+
+    file_status  status(const path& p);
+    file_status  status(const path& p, error_code& ec) _NOEXCEPT;
+
+    bool status_known(file_status s) _NOEXCEPT;
+
+    file_status  symlink_status(const path& p);
+    file_status  symlink_status(const path& p, error_code& ec) _NOEXCEPT;
+
+    path system_complete(const path& p);
+    path system_complete(const path& p, error_code& ec);
+
+    path temp_directory_path();
+    path temp_directory_path(error_code& ec);
+
+} } } }  // namespaces std::experimental::filesystem::v1
+
+*/
+
+#include <experimental/__config>
+#include <cstddef>
+#include <chrono>
+#include <iterator>
+#include <iosfwd>
+#include <locale>
+#include <memory>
+#include <stack>
+#include <string>
+#include <system_error>
+#include <utility>
+#include <iomanip> // for quoted
+#include <experimental/string_view>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+typedef chrono::time_point<std::chrono::system_clock>  file_time_type;
+
+struct _LIBCPP_TYPE_VIS space_info
+{
+  uintmax_t capacity;
+  uintmax_t free;
+  uintmax_t available;
+};
+
+enum class _LIBCPP_TYPE_VIS file_type : signed char
+{
+    none       = 0,
+    not_found  = -1,
+    regular    = 1,
+    directory  = 2,
+    symlink    = 3,
+    block      = 4,
+    character  = 5,
+    fifo       = 6,
+    socket     = 7,
+    unknown    = 8
+};
+
+enum class _LIBCPP_TYPE_VIS perms : unsigned
+{
+    none         = 0,
+
+    owner_read   = 0400,
+    owner_write  = 0200,
+    owner_exec   = 0100,
+    owner_all    = 0700,
+
+    group_read   = 040,
+    group_write  = 020,
+    group_exec   = 010,
+    group_all    = 070,
+
+    others_read  = 04,
+    others_write = 02,
+    others_exec  = 01,
+    others_all   = 07,
+
+    all          = 0777,
+
+    set_uid      = 04000,
+    set_gid      = 02000,
+    sticky_bit   = 01000,
+    mask         = 07777,
+    unknown      = 0xFFFF,
+
+    add_perms        = 0x10000,
+    remove_perms     = 0x20000,
+    resolve_symlinks = 0x40000
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator|(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) | static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS)
+{ return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR perms operator~(perms _LHS)
+{ return static_cast<perms>(~static_cast<unsigned>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator&=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator|=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline perms& operator^=(perms& _LHS, perms _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+enum class _LIBCPP_TYPE_VIS copy_options : unsigned short
+{
+    none               = 0,
+    skip_existing      = 1,
+    overwrite_existing = 2,
+    update_existing    = 4,
+    recursive          = 8,
+    copy_symlinks      = 16,
+    skip_symlinks      = 32,
+    directories_only   = 64,
+    create_symlinks    = 128,
+    create_hard_links  = 256,
+    __in_recursive_copy = 512,
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator&(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator|(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) | static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator^(copy_options _LHS, copy_options _RHS)
+{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ static_cast<unsigned short>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR copy_options operator~(copy_options _LHS)
+{ return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+
+enum class directory_options : unsigned char
+{
+    none                     = 0,
+    follow_directory_symlink = 1,
+    skip_permission_denied   = 2
+};
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator&(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator|(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) | static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator^(directory_options _LHS, directory_options _RHS)
+{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ static_cast<unsigned char>(_RHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_CONSTEXPR directory_options operator~(directory_options _LHS)
+{ return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator&=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS & _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator|=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS | _RHS; }
+
+_LIBCPP_INLINE_VISIBILITY
+inline directory_options& operator^=(directory_options& _LHS, directory_options _RHS)
+{ return _LHS = _LHS ^ _RHS; }
+
+
+class _LIBCPP_TYPE_VIS file_status
+{
+public:
+    // constructors
+    _LIBCPP_INLINE_VISIBILITY
+    explicit file_status(file_type __ft = file_type::none,
+                         perms __prms   = perms::unknown) _NOEXCEPT
+      : __ft_(__ft), __prms_(__prms)
+    {}
+
+    file_status(const file_status&) _NOEXCEPT = default;
+    file_status(file_status&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~file_status() {}
+
+    file_status& operator=(const file_status&) _NOEXCEPT = default;
+    file_status& operator=(file_status&&) _NOEXCEPT = default;
+
+    // observers
+    _LIBCPP_ALWAYS_INLINE
+    file_type type() const _NOEXCEPT {
+        return __ft_;
+    }
+
+    _LIBCPP_ALWAYS_INLINE
+    perms permissions() const _NOEXCEPT {
+        return __prms_;
+    }
+
+    // modifiers
+    _LIBCPP_ALWAYS_INLINE
+    void type(file_type __ft) _NOEXCEPT {
+        __ft_ = __ft;
+    }
+
+    _LIBCPP_ALWAYS_INLINE
+    void permissions(perms __p) _NOEXCEPT {
+        __prms_ = __p;
+    }
+private:
+    file_type __ft_;
+    perms __prms_;
+};
+
+class _LIBCPP_TYPE_VIS directory_entry;
+
+template <class _Tp> struct __can_convert_char {
+  static const bool value = false;
+};
+template <> struct __can_convert_char<char> {
+    static const bool value = true;
+    using __char_type = char;
+};
+template <> struct __can_convert_char<wchar_t>  {
+    static const bool value = true;
+    using __char_type = wchar_t;
+};
+template <> struct __can_convert_char<char16_t> {
+    static const bool value = true;
+    using __char_type = char16_t;
+};
+template <> struct __can_convert_char<char32_t> {
+    static const bool value = true;
+    using __char_type = char32_t;
+};
+
+template <class _ECharT>
+typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
+__is_separator(_ECharT __e) {
+    return __e == _ECharT('/');
+};
+
+struct _NullSentinal {};
+
+template <class _Tp>
+using _Void = void;
+
+template <class _Tp, class = void>
+struct __is_pathable_string : public false_type {};
+
+template <class _ECharT, class _Traits, class _Alloc>
+struct __is_pathable_string<basic_string<_ECharT, _Traits, _Alloc>,
+                            _Void<typename __can_convert_char<_ECharT>::__char_type>>
+: public __can_convert_char<_ECharT>
+{
+    using _Str = basic_string<_ECharT, _Traits, _Alloc>;
+    using _Base = __can_convert_char<_ECharT>;
+    static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
+    static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
+    static _ECharT __first_or_null(_Str const& __s) {
+        return __s.empty() ? _ECharT{} : __s[0];
+    }
+};
+
+template <class _Source,
+          class _DS = typename decay<_Source>::type,
+          class _UnqualPtrType = typename remove_const<
+              typename remove_pointer<_DS>::type>::type,
+          bool _IsCharPtr = is_pointer<_DS>::value &&
+                            __can_convert_char<_UnqualPtrType>::value
+        >
+struct __is_pathable_char_array : false_type {};
+
+template <class _Source, class _ECharT, class _UPtr>
+struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
+        : __can_convert_char<typename remove_const<_ECharT>::type>
+{
+  using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
+
+  static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
+  static _ECharT const* __range_end(const _ECharT* __b)
+  {
+      using _Iter = const _ECharT*;
+      const _ECharT __sentinal = _ECharT{};
+      _Iter __e = __b;
+      for (; *__e != __sentinal; ++__e)
+          ;
+      return __e;
+  }
+
+  static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
+};
+
+template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, class = void>
+struct __is_pathable_iter : false_type {};
+
+template <class _Iter>
+struct __is_pathable_iter<_Iter, true,
+        _Void<typename __can_convert_char<typename iterator_traits<_Iter>::value_type>::__char_type>>
+        : __can_convert_char<typename iterator_traits<_Iter>::value_type>
+{
+  using _ECharT = typename iterator_traits<_Iter>::value_type;
+  using _Base = __can_convert_char<_ECharT>;
+
+  static _Iter         __range_begin(_Iter __b) { return __b; }
+  static _NullSentinal __range_end(_Iter)       { return _NullSentinal{}; }
+
+  static _ECharT __first_or_null(_Iter __b) { return *__b; }
+};
+
+template <class _Tp, bool _IsStringT =  __is_pathable_string<_Tp>::value,
+                     bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
+                     bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value
+         >
+struct __is_pathable : false_type {
+  static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
+};
+
+template <class _Tp>
+struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
+
+
+template <class _Tp>
+struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {};
+
+
+template <class _Tp>
+struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
+
+
+template <class _ECharT>
+struct _PathCVT {
+    static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible");
+
+    typedef __narrow_to_utf8<sizeof(_ECharT)*__CHAR_BIT__> _Narrower;
+
+    static void __append_range(string& __dest, _ECharT const* __b, _ECharT const* __e)  {
+        _Narrower()(back_inserter(__dest), __b, __e);
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _Iter __e) {
+        static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
+        if (__b == __e) return;
+        basic_string<_ECharT> __tmp(__b, __e);
+        _Narrower()(back_inserter(__dest), __tmp.data(),
+                    __tmp.data() + __tmp.length());
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
+        static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
+        const _ECharT __sentinal = _ECharT{};
+        if (*__b == __sentinal) return;
+        basic_string<_ECharT> __tmp;
+        for (; *__b != __sentinal; ++__b)
+            __tmp.push_back(*__b);
+        _Narrower()(back_inserter(__dest), __tmp.data(),
+                    __tmp.data() + __tmp.length());
+    }
+
+    template <class _Source>
+    static void __append_source(string& __dest, _Source const& __s)
+    {
+        using _Traits = __is_pathable<_Source>;
+        __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
+    }
+};
+
+template <>
+struct _PathCVT<char> {
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _Iter __e) {
+        // TODO(EricWF) We get better allocation behavior here if we don't
+        // provide the same exception safety guarantees as string.append.
+        // __dest.append(__b, __e);
+        for (; __b != __e; ++__b)
+            __dest.push_back(*__b);
+    }
+
+    template <class _Iter>
+    static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
+        const char __sentinal = char{};
+        for (; *__b != __sentinal; ++__b)
+            __dest.push_back(*__b);
+    }
+
+    template <class _Source>
+    static void __append_source(string& __dest, _Source const& __s)
+    {
+        using _Traits = __is_pathable<_Source>;
+        __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
+    }
+};
+
+
+class _LIBCPP_TYPE_VIS path
+{
+    template <class _SourceOrIter, class _Tp = path&>
+    using _EnableIfPathable = typename
+        enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
+
+    template <class _Tp>
+    using _SourceChar = typename __is_pathable<_Tp>::__char_type;
+
+    template <class _Tp>
+    using _SourceCVT = _PathCVT<_SourceChar<_Tp>>;
+
+public:
+    typedef char value_type;
+    typedef basic_string<value_type> string_type;
+    static _LIBCPP_CONSTEXPR value_type preferred_separator = '/';
+
+    // constructors and destructor
+    _LIBCPP_INLINE_VISIBILITY path() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY path(const path& __p)      : __pn_(__p.__pn_) {}
+    _LIBCPP_INLINE_VISIBILITY path(path&& __p) _NOEXCEPT : __pn_(_VSTD::move(__p.__pn_)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    path(string_type&& __s) _NOEXCEPT : __pn_(_VSTD::move(__s)) {}
+
+    template <
+        class _Source,
+        class = _EnableIfPathable<_Source, void>
+        >
+    path(const _Source& __src) {
+        _SourceCVT<_Source>::__append_source(__pn_, __src);
+    }
+
+    template <class _InputIt>
+    path(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+    }
+
+    // TODO
+    template <class _Source,
+              class = _EnableIfPathable<_Source, void>
+             >
+        path(const _Source& __src, const locale& __loc);
+    template <class _InputIt>
+        path(_InputIt __first, _InputIt _last, const locale& __loc);
+
+    _LIBCPP_INLINE_VISIBILITY
+    ~path() = default;
+
+    // assignments
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(const path& __p) {
+        __pn_ = __p.__pn_;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(path&& __p) _NOEXCEPT {
+        __pn_ = _VSTD::move(__p.__pn_);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator=(string_type&& __s) _NOEXCEPT {
+        __pn_ = _VSTD::move(__s);
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& assign(string_type&& __s) _NOEXCEPT {
+        __pn_ = _VSTD::move(__s);
+        return *this;
+    }
+
+    template <class _Source>
+    _LIBCPP_INLINE_VISIBILITY
+    _EnableIfPathable<_Source>
+    operator=(const _Source& __src)
+    { return this->assign(__src); }
+
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    assign(const _Source& __src) {
+        __pn_.clear();
+        _SourceCVT<_Source>::__append_source(__pn_, __src);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& assign(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        __pn_.clear();
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+        return *this;
+    }
+
+private:
+    template <class _ECharT>
+    void __append_sep_if_needed(_ECharT __first_or_null) {
+        const _ECharT __null_val = {};
+        bool __append_sep = !empty()                       &&
+                            !__is_separator(__pn_.back())  &&
+                            __first_or_null != __null_val  && // non-empty
+                            !__is_separator(__first_or_null);
+        if (__append_sep)
+            __pn_ += preferred_separator;
+    }
+
+public:
+    // appends
+    path& operator/=(const path& __p) {
+        __append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]);
+        __pn_ += __p.native();
+        return *this;
+    }
+
+    template <class _Source>
+    _LIBCPP_INLINE_VISIBILITY
+    _EnableIfPathable<_Source>
+    operator/=(const _Source& __src) {
+        return this->append(__src);
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    append(const _Source& __src) {
+        using _Traits = __is_pathable<_Source>;
+        using _CVT = _PathCVT<_SourceChar<_Source>>;
+        __append_sep_if_needed(_Traits::__first_or_null(__src));
+        _CVT::__append_source(__pn_, __src);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& append(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
+        using _CVT = _PathCVT<_ItVal>;
+        if (__first != __last) {
+            __append_sep_if_needed(*__first);
+            _CVT::__append_range(__pn_, __first, __last);
+        }
+        return *this;
+    }
+
+    // concatenation
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const path& __x) {
+        __pn_ += __x.__pn_;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const string_type& __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(const value_type* __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    path& operator+=(value_type __x) {
+        __pn_ += __x;
+        return *this;
+    }
+
+
+    template <class _ECharT>
+    typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
+    operator+=(_ECharT __x)
+    {
+        basic_string<_ECharT> __tmp;
+        __tmp += __x;
+        _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
+        return *this;
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    operator+=(const _Source& __x) {
+       return this->concat(__x);
+    }
+
+    template <class _Source>
+    _EnableIfPathable<_Source>
+    concat(const _Source& __x) {
+         _SourceCVT<_Source>::__append_source(__pn_, __x);
+        return *this;
+    }
+
+    template <class _InputIt>
+    path& concat(_InputIt __first, _InputIt __last) {
+        typedef typename iterator_traits<_InputIt>::value_type _ItVal;
+        _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
+        return *this;
+    }
+
+    // modifiers
+    _LIBCPP_INLINE_VISIBILITY
+    void clear() _NOEXCEPT {
+        __pn_.clear();
+    }
+
+    path& make_preferred() { return *this; }
+    path& remove_filename() { return *this = parent_path(); }
+
+    path& replace_filename(const path& __replacement) {
+        remove_filename();
+        return (*this /= __replacement);
+    }
+
+    path& replace_extension(const path& __replacement = path());
+
+    _LIBCPP_INLINE_VISIBILITY
+    void  swap(path& __rhs) _NOEXCEPT {
+        __pn_.swap(__rhs.__pn_);
+    }
+
+    // native format observers
+    _LIBCPP_INLINE_VISIBILITY
+    const string_type& native() const _NOEXCEPT {
+        return __pn_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const value_type* c_str() const _NOEXCEPT { return __pn_.c_str(); }
+
+    _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_;  }
+
+    template <class _ECharT, class _Traits = char_traits<_ECharT>,
+              class _Allocator = allocator<_ECharT> >
+    basic_string<_ECharT, _Traits, _Allocator>
+    string(const _Allocator& __a = _Allocator()) const {
+        using _CVT = __widen_from_utf8<sizeof(_ECharT)*__CHAR_BIT__>;
+        using _Str = basic_string<_ECharT, _Traits, _Allocator>;
+        _Str __s(__a);
+        __s.reserve(__pn_.size());
+        _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
+        return __s;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY std::string    string()    const { return __pn_; }
+    _LIBCPP_INLINE_VISIBILITY std::wstring   wstring()   const { return string<wchar_t>(); }
+    _LIBCPP_INLINE_VISIBILITY std::string    u8string()  const { return __pn_; }
+    _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { return string<char16_t>(); }
+    _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { return string<char32_t>(); }
+
+    // generic format observers
+    template <class _ECharT, class _Traits = char_traits<_ECharT>,
+              class _Allocator = allocator<_ECharT>
+    >
+    basic_string<_ECharT, _Traits, _Allocator>
+    generic_string(const _Allocator& __a = _Allocator()) const {
+        return string<_ECharT, _Traits, _Allocator>(__a);
+    }
+
+    std::string    generic_string()    const { return __pn_; }
+    std::wstring   generic_wstring()   const { return string<wchar_t>(); }
+    std::string    generic_u8string()  const { return __pn_; }
+    std::u16string generic_u16string() const { return string<char16_t>(); }
+    std::u32string generic_u32string() const { return string<char32_t>(); }
+
+private:
+    _LIBCPP_FUNC_VIS int __compare(const value_type*) const;
+    _LIBCPP_FUNC_VIS string_view __root_name() const;
+    _LIBCPP_FUNC_VIS string_view __root_directory() const;
+    _LIBCPP_FUNC_VIS string_view __relative_path() const;
+    _LIBCPP_FUNC_VIS string_view __parent_path() const;
+    _LIBCPP_FUNC_VIS string_view __filename() const;
+    _LIBCPP_FUNC_VIS string_view __stem() const;
+    _LIBCPP_FUNC_VIS string_view __extension() const;
+
+public:
+    // compare
+    _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const _NOEXCEPT { return __compare(__p.c_str());}
+    _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { return __compare(__s.c_str()); }
+    _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const  { return __compare(__s); }
+
+    // decomposition
+    _LIBCPP_INLINE_VISIBILITY path root_name()      const { return  __root_name().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path root_directory() const { return  __root_directory().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path root_path()      const { return root_name().append(__root_directory().to_string()); }
+    _LIBCPP_INLINE_VISIBILITY path relative_path()  const { return __relative_path().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path parent_path()    const { return __parent_path().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path filename()       const { return __filename().to_string(); }
+    _LIBCPP_INLINE_VISIBILITY path stem()           const { return __stem().to_string();}
+    _LIBCPP_INLINE_VISIBILITY path extension()      const { return __extension().to_string(); }
+
+    // query
+    _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); }
+
+    _LIBCPP_INLINE_VISIBILITY bool has_root_name()      const { return !__root_name().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_root_path()      const { return !(__root_name().empty() && __root_directory().empty()); }
+    _LIBCPP_INLINE_VISIBILITY bool has_relative_path()  const { return !__relative_path().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_parent_path()    const { return !__parent_path().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_filename()       const { return !__filename().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_stem()           const { return !__stem().empty(); }
+    _LIBCPP_INLINE_VISIBILITY bool has_extension()      const { return !__extension().empty(); }
+
+    _LIBCPP_INLINE_VISIBILITY bool is_absolute()        const { return has_root_directory(); }
+    _LIBCPP_INLINE_VISIBILITY bool is_relative()        const { return !is_absolute(); }
+
+    // iterators
+    class _LIBCPP_TYPE_VIS iterator;
+    typedef iterator const_iterator;
+
+    _LIBCPP_FUNC_VIS iterator begin() const;
+    _LIBCPP_FUNC_VIS iterator end() const;
+
+private:
+    inline _LIBCPP_INLINE_VISIBILITY
+    path& __assign_view(string_view const& __s) noexcept { __pn_ = __s.to_string(); return *this; }
+    string_type __pn_;
+};
+
+inline _LIBCPP_ALWAYS_INLINE
+void swap(path& __lhs, path& __rhs) _NOEXCEPT {
+    __lhs.swap(__rhs);
+}
+
+_LIBCPP_FUNC_VIS
+size_t hash_value(const path& __p) _NOEXCEPT;
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) == 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) != 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) < 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) <= 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) > 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT
+{ return __lhs.compare(__rhs) >= 0; }
+
+inline _LIBCPP_INLINE_VISIBILITY
+path operator/(const path& __lhs, const path& __rhs) {
+    return path(__lhs) /= __rhs;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<is_same<_CharT, char>::value &&
+                   is_same<_Traits, char_traits<char>>::value,
+                   basic_ostream<_CharT, _Traits>&
+>::type
+operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.native());
+    return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<!is_same<_CharT, char>::value ||
+                   !is_same<_Traits, char_traits<char>>::value,
+                   basic_ostream<_CharT, _Traits>&
+>::type
+operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.string<_CharT, _Traits>());
+    return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_INLINE_VISIBILITY
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
+{
+    basic_string<_CharT, _Traits> __tmp;
+    __is >> __quoted(__tmp);
+    __p = __tmp;
+    return __is;
+}
+
+template <class _Source>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<__is_pathable<_Source>::value, path>::type
+u8path(const _Source& __s){
+    static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value,
+        "u8path(Source const&) requires Source have a character type of type 'char'");
+    return path(__s);
+}
+
+template <class _InputIt>
+_LIBCPP_INLINE_VISIBILITY
+typename enable_if<__is_pathable<_InputIt>::value, path>::type
+u8path(_InputIt __f, _InputIt __l) {
+    static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
+        "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
+    return path(__f, __l);
+}
+
+class _LIBCPP_TYPE_VIS path::iterator
+{
+public:
+    typedef bidirectional_iterator_tag iterator_category;
+    typedef path                       value_type;
+    typedef std::ptrdiff_t             difference_type;
+    typedef const path*                pointer;
+    typedef const path&                reference;
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    iterator() : __elem_(), __path_ptr_(nullptr), __pos_(0) {}
+
+    iterator(const iterator&) = default;
+    ~iterator() = default;
+
+    iterator& operator=(const iterator&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    reference operator*() const {
+        return __elem_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    pointer operator->() const {
+        return &__elem_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator& operator++() {
+        return __increment();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator operator++(int) {
+        iterator __it(*this);
+        this->operator++();
+        return __it;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator& operator--() {
+        return __decrement();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    iterator operator--(int) {
+        iterator __it(*this);
+        this->operator--();
+        return __it;
+    }
+
+private:
+    friend class path;
+    friend bool operator==(const iterator&, const iterator&);
+
+    _LIBCPP_FUNC_VIS iterator& __increment();
+    _LIBCPP_FUNC_VIS iterator& __decrement();
+
+    path __elem_;
+    const path* __path_ptr_;
+    size_t __pos_;
+};
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
+    return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
+           __lhs.__pos_      == __rhs.__pos_;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
+    return !(__lhs == __rhs);
+}
+
+class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error
+{
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, error_code __ec)
+        : system_error(__ec, __what),
+          __paths_(make_shared<_Storage>(path(), path()))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, const path& __p1, error_code __ec)
+        : system_error(__ec, __what),
+        __paths_(make_shared<_Storage>(__p1, path()))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    filesystem_error(const string& __what, const path& __p1, const path& __p2,
+                     error_code __ec)
+        : system_error(__ec, __what),
+          __paths_(make_shared<_Storage>(__p1, __p2))
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    const path& path1() const _NOEXCEPT {
+        return __paths_->first;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const path& path2() const _NOEXCEPT {
+        return __paths_->second;
+    }
+
+    _LIBCPP_FUNC_VIS
+    ~filesystem_error() override; // key function
+
+    // TODO(ericwf): Create a custom error message.
+    //const char* what() const _NOEXCEPT;
+
+private:
+    typedef pair<path, path> _Storage;
+    shared_ptr<_Storage> __paths_;
+};
+
+// operational functions
+
+_LIBCPP_FUNC_VIS
+path __canonical(const path&, const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __copy(const path& __from, const path& __to, copy_options __opt,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __copy_file(const path& __from, const path& __to, copy_options __opt,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directories(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directory(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __create_directory(const path& p, const path & attributes,
+        error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_directory_symlink(const path& __to, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_hard_link(const path& __to, const path& __new_hard_link,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __create_symlink(const path& __to, const path& __new_symlink,
+        error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __current_path(error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __current_path(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __equivalent(const path&, const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __file_size(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __fs_is_empty(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_time_type __last_write_time(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __last_write_time(const path& p, file_time_type new_time,
+        error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __permissions(const path& p, perms prms, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __read_symlink(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+bool __remove(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+uintmax_t __remove_all(const path& p, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __rename(const path& from, const path& to, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr);
+_LIBCPP_FUNC_VIS
+space_info __space(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_status __status(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+file_status __symlink_status(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __system_complete(const path&, error_code *__ec=nullptr);
+_LIBCPP_FUNC_VIS
+path __temp_directory_path(error_code *__ec=nullptr);
+
+inline _LIBCPP_INLINE_VISIBILITY
+path current_path() {
+    return __current_path();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path current_path(error_code& __ec) {
+    return __current_path(&__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void current_path(const path& __p) {
+    __current_path(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void current_path(const path& __p, error_code& __ec) _NOEXCEPT {
+    __current_path(__p, &__ec);
+}
+
+_LIBCPP_FUNC_VIS
+path absolute(const path&, const path& __p2 = current_path());
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, const path& __base = current_path()) {
+    return __canonical(__p, __base);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, error_code& __ec) {
+    path __base = __current_path(&__ec);
+    if (__ec) return {};
+    return __canonical(__p, __base, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path canonical(const path& __p, const path& __base, error_code& __ec) {
+    return __canonical(__p, __base, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to) {
+    __copy(__from, __to, copy_options::none);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    __copy(__from, __to, copy_options::none, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to, copy_options __opt) {
+    __copy(__from, __to, __opt);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy(const path& __from, const path& __to,
+          copy_options __opt, error_code& __ec) _NOEXCEPT {
+    __copy(__from, __to, __opt, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to) {
+    return __copy_file(__from, __to, copy_options::none);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    return __copy_file(__from, __to, copy_options::none, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to, copy_options __opt) {
+    return __copy_file(__from, __to, __opt);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool copy_file(const path& __from, const path& __to,
+               copy_options __opt, error_code& __ec) _NOEXCEPT {
+    return __copy_file(__from, __to, __opt, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy_symlink(const path& __existing, const path& __new) {
+    __copy_symlink(__existing, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT {
+    __copy_symlink(__ext, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directories(const path& __p) {
+    return __create_directories(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __create_directories(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p) {
+    return __create_directory(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __create_directory(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, const path& __attrs) {
+    return __create_directory(__p, __attrs);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT {
+    return __create_directory(__p, __attrs, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_directory_symlink(const path& __to, const path& __new) {
+    __create_directory_symlink(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_directory_symlink(const path& __to, const path& __new,
+                              error_code& __ec) _NOEXCEPT {
+    __create_directory_symlink(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_hard_link(const path& __to, const path& __new) {
+    __create_hard_link(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
+    __create_hard_link(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_symlink(const path& __to, const path& __new) {
+    __create_symlink(__to, __new);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
+    return __create_symlink(__to, __new, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool status_known(file_status __s) _NOEXCEPT {
+    return __s.type() != file_type::none;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(file_status __s) _NOEXCEPT {
+    return status_known(__s) && __s.type() != file_type::not_found;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(const path& __p) {
+    return exists(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool exists(const path& __p, error_code& __ec) _NOEXCEPT {
+    return exists(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool equivalent(const path& __p1, const path& __p2) {
+    return __equivalent(__p1, __p2);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT {
+    return __equivalent(__p1, __p2, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t file_size(const path& __p) {
+    return __file_size(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __file_size(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t hard_link_count(const path& __p) {
+    return __hard_link_count(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __hard_link_count(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::block;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(const path& __p) {
+    return is_block_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_block_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::character;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(const path& __p) {
+    return is_character_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_character_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::directory;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(const path& __p) {
+    return is_directory(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_directory(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_empty(const path& __p) {
+    return __fs_is_empty(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __fs_is_empty(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::fifo;
+}
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(const path& __p) {
+    return is_fifo(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_fifo(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::regular;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(const path& __p) {
+    return is_regular_file(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_regular_file(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::socket;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(const path& __p) {
+    return is_socket(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_socket(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(file_status __s) _NOEXCEPT {
+    return __s.type() == file_type::symlink;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(const path& __p) {
+    return is_symlink(__symlink_status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_symlink(__symlink_status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(file_status __s) _NOEXCEPT {
+    return exists(__s)
+        && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(const path& __p) {
+    return is_other(__status(__p));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool is_other(const path& __p, error_code& __ec) _NOEXCEPT {
+    return is_other(__status(__p, &__ec));
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_time_type last_write_time(const path& __p) {
+    return __last_write_time(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __last_write_time(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void last_write_time(const path& __p, file_time_type __t) {
+    __last_write_time(__p, __t);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT {
+    __last_write_time(__p, __t, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void permissions(const path& __p, perms __prms) {
+    __permissions(__p, __prms);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void permissions(const path& __p, perms __prms, error_code& __ec) _NOEXCEPT {
+    __permissions(__p, __prms, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path read_symlink(const path& __p) {
+    return __read_symlink(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path read_symlink(const path& __p, error_code& __ec) {
+    return __read_symlink(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool remove(const path& __p) {
+    return __remove(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool remove(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __remove(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t remove_all(const path& __p) {
+    return __remove_all(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __remove_all(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void rename(const path& __from, const path& __to) {
+    return __rename(__from, __to);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+    return __rename(__from, __to, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void resize_file(const path& __p, uintmax_t __ns) {
+    return __resize_file(__p, __ns);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT {
+    return __resize_file(__p, __ns, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+space_info space(const path& __p) {
+    return __space(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+space_info space(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __space(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status status(const path& __p) {
+    return __status(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status status(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __status(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status symlink_status(const path& __p) {
+    return __symlink_status(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT {
+    return __symlink_status(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path system_complete(const path& __p) {
+    return __system_complete(__p);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path system_complete(const path& __p, error_code& __ec) {
+    return __system_complete(__p, &__ec);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path temp_directory_path() {
+    return __temp_directory_path();
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+path temp_directory_path(error_code& __ec) {
+    return __temp_directory_path(&__ec);
+}
+
+
+class directory_entry
+{
+    typedef _VSTD_FS::path _Path;
+
+public:
+    // constructors and destructors
+    directory_entry() _NOEXCEPT = default;
+    directory_entry(directory_entry const&) = default;
+    directory_entry(directory_entry&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit directory_entry(_Path const& __p) : __p_(__p) {}
+
+    ~directory_entry() {}
+
+    directory_entry& operator=(directory_entry const&) = default;
+    directory_entry& operator=(directory_entry&&) _NOEXCEPT = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    void assign(_Path const& __p) {
+        __p_ = __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void replace_filename(_Path const& __p) {
+        __p_ = __p_.parent_path() / __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    _Path const& path() const _NOEXCEPT {
+        return __p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    operator const _Path&() const _NOEXCEPT {
+        return __p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status status() const {
+        return _VSTD_FS::status(__p_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status status(error_code& __ec) const _NOEXCEPT {
+        return _VSTD_FS::status(__p_, __ec);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status symlink_status() const {
+        return _VSTD_FS::symlink_status(__p_);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    file_status symlink_status(error_code& __ec) const _NOEXCEPT {
+        return _VSTD_FS::symlink_status(__p_, __ec);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator< (directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ < __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator==(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ == __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator!=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ != __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator<=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ <= __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator> (directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ > __rhs.__p_;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator>=(directory_entry const& __rhs) const _NOEXCEPT {
+        return __p_ >= __rhs.__p_;
+    }
+private:
+    _Path __p_;
+};
+
+
+class directory_iterator;
+class recursive_directory_iterator;
+class __dir_stream;
+
+class __dir_element_proxy {
+public:
+
+    inline _LIBCPP_INLINE_VISIBILITY
+    directory_entry operator*() { return _VSTD::move(__elem_); }
+
+private:
+    friend class directory_iterator;
+    friend class recursive_directory_iterator;
+    explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
+    __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {}
+    directory_entry __elem_;
+};
+
+class directory_iterator
+{
+public:
+    typedef directory_entry value_type;
+    typedef ptrdiff_t difference_type;
+    typedef value_type const* pointer;
+    typedef value_type const& reference;
+    typedef input_iterator_tag iterator_category;
+
+public:
+    //ctor & dtor
+    directory_iterator() _NOEXCEPT
+    { }
+
+    explicit directory_iterator(const path& __p)
+        : directory_iterator(__p, nullptr)
+    { }
+
+    directory_iterator(const path& __p, directory_options __opts)
+        : directory_iterator(__p, nullptr, __opts)
+    { }
+
+    directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+        : directory_iterator(__p, &__ec)
+    { }
+
+    directory_iterator(const path& __p, directory_options __opts,
+                       error_code& __ec) _NOEXCEPT
+        : directory_iterator(__p, &__ec, __opts)
+    { }
+
+    directory_iterator(const directory_iterator&) = default;
+    directory_iterator(directory_iterator&&) = default;
+    directory_iterator& operator=(const directory_iterator&) = default;
+
+    directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT {
+        // non-default implementation provided to support self-move assign.
+        if (this != &__o) {
+            __imp_ = _VSTD::move(__o.__imp_);
+        }
+        return *this;
+    }
+
+    ~directory_iterator() = default;
+
+    const directory_entry& operator*() const {
+        _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
+        return __deref();
+    }
+
+    const directory_entry* operator->() const
+    { return &**this; }
+
+    directory_iterator& operator++()
+    { return __increment(); }
+
+    __dir_element_proxy operator++(int) {
+        __dir_element_proxy __p(**this);
+        __increment();
+        return __p;
+    }
+
+    directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    { return __increment(&__ec); }
+
+private:
+    friend bool operator==(const directory_iterator& __lhs,
+                           const directory_iterator& __rhs) _NOEXCEPT;
+
+    // construct the dir_stream
+    _LIBCPP_FUNC_VIS
+    directory_iterator(const path&, error_code *, directory_options = directory_options::none);
+    _LIBCPP_FUNC_VIS
+    directory_iterator& __increment(error_code * __ec = nullptr);
+    _LIBCPP_FUNC_VIS
+    const directory_entry& __deref() const;
+
+private:
+    shared_ptr<__dir_stream> __imp_;
+};
+
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator==(const directory_iterator& __lhs,
+                const directory_iterator& __rhs) _NOEXCEPT {
+    return __lhs.__imp_ == __rhs.__imp_;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+bool operator!=(const directory_iterator& __lhs,
+                const directory_iterator& __rhs) _NOEXCEPT {
+    return !(__lhs == __rhs);
+}
+
+// enable directory_iterator range-based for statements
+inline _LIBCPP_INLINE_VISIBILITY
+directory_iterator begin(directory_iterator __iter) _NOEXCEPT {
+    return __iter;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+directory_iterator end(const directory_iterator&) _NOEXCEPT {
+    return directory_iterator();
+}
+
+class recursive_directory_iterator {
+public:
+    using value_type = directory_entry;
+    using difference_type = std::ptrdiff_t;
+    using pointer = directory_entry const *;
+    using reference = directory_entry const &;
+    using iterator_category = std::input_iterator_tag;
+
+public:
+    // constructors and destructor
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator() _NOEXCEPT
+    {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit recursive_directory_iterator(const path& __p,
+                directory_options __xoptions = directory_options::none)
+        : recursive_directory_iterator(__p, __xoptions,  nullptr)
+    { }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator(const path& __p,
+        directory_options __xoptions, error_code& __ec) _NOEXCEPT
+        : recursive_directory_iterator(__p, __xoptions, &__ec)
+    { }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+        : recursive_directory_iterator(__p, directory_options::none,  &__ec)
+    { }
+
+    recursive_directory_iterator(const recursive_directory_iterator&) = default;
+    recursive_directory_iterator(recursive_directory_iterator&&) = default;
+
+    recursive_directory_iterator & 
+    operator=(const recursive_directory_iterator&) = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator & 
+    operator=(recursive_directory_iterator&& __o) noexcept {
+        // non-default implementation provided to support self-move assign.
+        if (this != &__o) {
+            __imp_ = _VSTD::move(__o.__imp_);
+            __rec_ = __o.__rec_;
+        }
+        return *this;
+    }
+
+    ~recursive_directory_iterator() = default;
+
+    _LIBCPP_INLINE_VISIBILITY
+    const directory_entry& operator*() const
+    { return __deref(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    const directory_entry* operator->() const
+    { return &__deref(); }
+
+    recursive_directory_iterator& operator++()
+    { return __increment(); }
+
+    _LIBCPP_INLINE_VISIBILITY
+    __dir_element_proxy operator++(int) {
+        __dir_element_proxy __p(**this);
+        __increment();
+        return __p;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    { return __increment(&__ec); }
+
+    _LIBCPP_FUNC_VIS directory_options options() const;
+    _LIBCPP_FUNC_VIS int  depth() const;
+    _LIBCPP_FUNC_VIS void pop();
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool recursion_pending() const
+    { return __rec_; }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void disable_recursion_pending()
+    { __rec_ = false; }
+
+private:
+    recursive_directory_iterator(const path& __p, directory_options __opt,
+                                 error_code *__ec);
+
+    _LIBCPP_FUNC_VIS const directory_entry& __deref() const;
+    bool __try_recursion(error_code* __ec);
+    _LIBCPP_FUNC_VIS void __advance(error_code* __ec=nullptr);
+    _LIBCPP_FUNC_VIS recursive_directory_iterator& __increment(error_code *__ec=nullptr);
+
+    friend bool operator==(const recursive_directory_iterator&,
+                           const recursive_directory_iterator&) _NOEXCEPT;
+
+    struct __shared_imp;
+    shared_ptr<__shared_imp> __imp_;
+    bool __rec_;
+};                                     // class recursive_directory_iterator
+
+
+_LIBCPP_INLINE_VISIBILITY
+inline bool operator==(const recursive_directory_iterator& __lhs,
+                        const recursive_directory_iterator& __rhs) _NOEXCEPT
+{
+    return __lhs.__imp_ == __rhs.__imp_;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+inline bool operator!=(const recursive_directory_iterator& __lhs,
+                        const recursive_directory_iterator& __rhs) _NOEXCEPT
+{
+    return !(__lhs == __rhs);
+}
+// enable recursive_directory_iterator range-based for statements
+inline _LIBCPP_INLINE_VISIBILITY
+recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT {
+    return __iter;
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT {
+    return recursive_directory_iterator();
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM

src/experimental/directory_iterator.cpp

+#include "experimental/filesystem"
+#include <dirent.h>
+#include <errno.h>
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+namespace { namespace detail {
+
+inline error_code capture_errno() {
+    _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
+    return error_code{errno, std::generic_category()};
+}
+
+template <class ...Args>
+inline bool capture_error_or_throw(std::error_code* user_ec,
+                                   const char* msg, Args&&... args)
+{
+    std::error_code my_ec = capture_errno();
+    if (user_ec) {
+        *user_ec = my_ec;
+        return true;
+    }
+    __libcpp_throw(filesystem_error(msg, std::forward<Args>(args)..., my_ec));
+    return false;
+}
+
+template <class ...Args>
+inline bool set_or_throw(std::error_code& my_ec,
+                               std::error_code* user_ec,
+                               const char* msg, Args&&... args)
+{
+    if (user_ec) {
+        *user_ec = my_ec;
+        return true;
+    }
+    __libcpp_throw(filesystem_error(msg, std::forward<Args>(args)..., my_ec));
+    return false;
+}
+
+typedef path::string_type string_type;
+
+
+inline string_type posix_readdir_r(DIR *dir_stream, error_code& ec) {
+    struct dirent dir_entry;
+    struct dirent *dir_entry_ptr{nullptr};
+    int ret;
+    if ((ret = ::readdir_r(dir_stream,  &dir_entry,  &dir_entry_ptr)) != 0)
+    {
+        ec = capture_errno();
+        return {};
+    }
+    ec.clear();
+    return dir_entry_ptr ? dir_entry.d_name : string_type{};
+}
+
+}}                                                       // namespace detail
+
+using detail::set_or_throw;
+
+class __dir_stream {
+public:
+    __dir_stream() = delete;
+    __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_))
+    {
+        other.__stream_ = nullptr;
+    }
+
+
+    __dir_stream(const path& root, directory_options opts, error_code& ec)
+        : __stream_(nullptr),
+          __root_(root)
+    {
+        if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
+            ec = detail::capture_errno();
+            const bool allow_eacess =
+                bool(opts & directory_options::skip_permission_denied);
+            if (allow_eacess && ec.value() == EACCES)
+                ec.clear();
+            return;
+        }
+        advance(ec);
+    }
+
+    ~__dir_stream() noexcept
+      { if (__stream_) close(); }
+
+    bool good() const noexcept { return __stream_ != nullptr; }
+
+    bool advance(error_code &ec) {
+        while (true) {
+            auto str = detail::posix_readdir_r(__stream_,  ec);
+            if (str == "." || str == "..") {
+                continue;
+            } else if (ec || str.empty()) {
+                close();
+                //__entry_ = {};
+                return false;
+            } else {
+                __entry_.assign(__root_ / str);
+                return true;
+            }
+        }
+    }
+private:
+    std::error_code close() noexcept {
+        std::error_code m_ec;
+        if (::closedir(__stream_) == -1)
+           m_ec = detail::capture_errno();
+        __stream_ = nullptr;
+        return m_ec;
+    }
+
+    DIR * __stream_{nullptr};
+public:
+    path __root_;
+    directory_entry __entry_;
+};
+
+// directory_iterator
+
+directory_iterator::directory_iterator(const path& p, error_code *ec,
+                                       directory_options opts)
+{
+    std::error_code m_ec;
+    __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
+    if (ec) *ec = m_ec;
+    if (!__imp_->good()) {
+        __imp_.reset();
+        if (m_ec)
+            set_or_throw(m_ec, ec,
+                         "directory_iterator::directory_iterator(...)", p);
+    }
+}
+
+directory_iterator& directory_iterator::__increment(error_code *ec)
+{
+    _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
+    std::error_code m_ec;
+    if (!__imp_->advance(m_ec)) {
+        __imp_.reset();
+        if (m_ec)
+            set_or_throw(m_ec, ec, "directory_iterator::operator++()");
+    } else {
+        if (ec) ec->clear();
+    }
+    return *this;
+
+}
+
+directory_entry const& directory_iterator::__deref() const {
+    _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
+    return __imp_->__entry_;
+}
+
+// recursive_directory_iterator
+
+struct recursive_directory_iterator::__shared_imp {
+  stack<__dir_stream> __stack_;
+  directory_options   __options_;
+};
+
+recursive_directory_iterator::recursive_directory_iterator(const path& p, 
+    directory_options opt, error_code *ec)
+    : __imp_(nullptr), __rec_(true)
+{
+    std::error_code m_ec;
+    __dir_stream new_s(p, opt, m_ec);
+    if (m_ec) set_or_throw(m_ec, ec, "recursive_directory_iterator", p);
+    if (m_ec || !new_s.good()) return;
+
+    __imp_ = _VSTD::make_shared<__shared_imp>();
+    __imp_->__options_ = opt;
+    __imp_->__stack_.push(_VSTD::move(new_s));
+}
+
+void recursive_directory_iterator::pop()
+{
+    _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
+    __imp_->__stack_.pop();
+    if (__imp_->__stack_.size() == 0)
+        __imp_.reset();
+    else
+        __advance();
+}
+
+directory_options recursive_directory_iterator::options() const {
+    return __imp_->__options_;
+}
+
+int recursive_directory_iterator::depth() const {
+    return __imp_->__stack_.size() - 1;
+}
+
+const directory_entry& recursive_directory_iterator::__deref() const {
+    return __imp_->__stack_.top().__entry_;
+}
+
+recursive_directory_iterator& 
+recursive_directory_iterator::__increment(error_code *ec)
+{
+    if (recursion_pending()) {
+        if (__try_recursion(ec) || (ec && *ec))
+            return *this;
+    }
+    __rec_ = true;
+    __advance(ec);
+    return *this;
+}
+
+void recursive_directory_iterator::__advance(error_code* ec) {
+    const directory_iterator end_it;
+    auto& stack = __imp_->__stack_;
+    std::error_code m_ec;
+    while (stack.size() > 0) {
+        if (stack.top().advance(m_ec)) {
+            if (ec) ec->clear();
+            return;
+        }
+        if (m_ec) break;
+        stack.pop();
+    }
+    __imp_.reset();
+    if (m_ec)
+        set_or_throw(m_ec, ec, "recursive_directory_iterator::operator++()");
+}
+
+bool recursive_directory_iterator::__try_recursion(error_code *ec) {
+
+    bool rec_sym =
+        bool(options() & directory_options::follow_directory_symlink);
+    auto& curr_it = __imp_->__stack_.top();
+
+    if (is_directory(curr_it.__entry_.status()) &&
+        (!is_symlink(curr_it.__entry_.symlink_status()) || rec_sym))
+    {
+        std::error_code m_ec;
+        __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
+        if (new_it.good()) {
+            __imp_->__stack_.push(_VSTD::move(new_it));
+            return true;
+        }
+        if (m_ec) {
+            __imp_.reset();
+            set_or_throw(m_ec, ec,
+                               "recursive_directory_iterator::operator++()");
+        }
+    }
+    return false;
+}
+
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

src/experimental/operations.cpp

+//===--------------------- filesystem/ops.cpp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "experimental/filesystem"
+#include "iterator"
+#include "fstream"
+#include "type_traits"
+#include "random"  /* for unique_path */
+#include "cstdlib"
+#include "climits"
+
+#include <unistd.h>
+#include <utime.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <fcntl.h>  /* values for fchmodat */
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
+
+filesystem_error::~filesystem_error() {}
+
+
+//                       POSIX HELPERS
+
+namespace detail { namespace  {
+
+using value_type = path::value_type;
+using string_type = path::string_type;
+
+
+
+inline std::error_code capture_errno() {
+    _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
+    std::error_code m_ec(errno, std::generic_category());
+    return m_ec;
+}
+
+void set_or_throw(std::error_code const& m_ec, std::error_code* ec,
+                  const char* msg, path const& p = {}, path const& p2 = {})
+{
+    if (ec) {
+        *ec = m_ec;
+    } else {
+        string msg_s("std::experimental::filesystem::");
+        msg_s += msg;
+        __libcpp_throw(filesystem_error(msg_s, p, p2, m_ec));
+    }
+}
+
+void set_or_throw(std::error_code* ec, const char* msg,
+                  path const& p = {}, path const& p2 = {})
+{
+    return set_or_throw(capture_errno(), ec, msg, p, p2);
+}
+
+perms posix_get_perms(const struct ::stat & st) noexcept {
+    return static_cast<perms>(st.st_mode) & perms::mask;
+}
+
+::mode_t posix_convert_perms(perms prms) {
+    return static_cast< ::mode_t>(prms & perms::mask);
+}
+
+file_status create_file_status(std::error_code& m_ec, path const& p,
+                               struct ::stat& path_stat,
+                               std::error_code* ec)
+{
+    if (ec) *ec = m_ec;
+    if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
+        return file_status(file_type::not_found);
+    }
+    else if (m_ec) {
+        set_or_throw(m_ec, ec, "posix_stat", p);
+        return file_status(file_type::none);
+    }
+    // else
+
+    file_status fs_tmp;
+    auto const mode = path_stat.st_mode;
+    if      (S_ISLNK(mode))  fs_tmp.type(file_type::symlink);
+    else if (S_ISREG(mode))  fs_tmp.type(file_type::regular);
+    else if (S_ISDIR(mode))  fs_tmp.type(file_type::directory);
+    else if (S_ISBLK(mode))  fs_tmp.type(file_type::block);
+    else if (S_ISCHR(mode))  fs_tmp.type(file_type::character);
+    else if (S_ISFIFO(mode)) fs_tmp.type(file_type::fifo);
+    else if (S_ISSOCK(mode)) fs_tmp.type(file_type::socket);
+    else                     fs_tmp.type(file_type::unknown);
+
+    fs_tmp.permissions(detail::posix_get_perms(path_stat));
+    return fs_tmp;
+}
+
+file_status posix_stat(path const & p, struct ::stat& path_stat, std::error_code* ec)
+{
+    std::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) {
+    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;
+    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) {
+    struct ::stat path_stat;
+    return posix_lstat(p, path_stat, ec);
+}
+
+bool stat_equivalent(struct ::stat& st1, struct ::stat& st2) {
+    return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
+}
+
+//                           DETAIL::MISC
+
+
+bool copy_file_impl(const path& from, const path& to, perms from_perms,
+                    std::error_code *ec)
+{
+    std::ifstream in(from.c_str(), std::ios::binary);
+    std::ofstream out(to.c_str(),  std::ios::binary);
+
+    if (in.good() && out.good()) {
+        using InIt = std::istreambuf_iterator<char>;
+        using OutIt = std::ostreambuf_iterator<char>;
+        InIt bin(in);
+        InIt ein;
+        OutIt bout(out);
+        std::copy(bin, ein, bout);
+    }
+    if (out.fail() || in.fail()) {
+        set_or_throw(make_error_code(errc::operation_not_permitted),
+                     ec, "copy_file", from, to);
+        return false;
+    }
+    __permissions(to, from_perms, ec);
+    // TODO what if permissions fails?
+    return true;
+}
+
+}} // end namespace detail
+
+using detail::set_or_throw;
+
+path __canonical(path const & orig_p, const path& base, std::error_code *ec)
+{
+    path p = absolute(orig_p, base);
+    char buff[PATH_MAX + 1];
+    char *ret;
+    if ((ret = ::realpath(p.c_str(), buff)) == nullptr) {
+        set_or_throw(ec, "canonical", orig_p, base);
+        return {};
+    }
+    if (ec) ec->clear();
+    return {ret};
+}
+
+void __copy(const path& from, const path& to, copy_options options,
+            std::error_code *ec)
+{
+    const bool sym_status = bool(options &
+        (copy_options::create_symlinks | copy_options::skip_symlinks));
+
+    const bool sym_status2 = bool(options &
+        copy_options::copy_symlinks);
+
+    std::error_code m_ec;
+    struct ::stat f_st = {};
+    const file_status f = sym_status || sym_status2
+                                     ? detail::posix_lstat(from, f_st, &m_ec)
+                                     : detail::posix_stat(from,  f_st, &m_ec);
+    if (m_ec)
+        return set_or_throw(m_ec, ec, "copy", from, to);
+
+    struct ::stat t_st = {};
+    const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec)
+                                     : detail::posix_stat(to, t_st, &m_ec);
+
+    if (not status_known(t))
+        return set_or_throw(m_ec, ec, "copy", from, to);
+
+    if (!exists(f) || is_other(f) || is_other(t)
+        || (is_directory(f) && is_regular_file(t))
+        || detail::stat_equivalent(f_st, t_st))
+    {
+        return set_or_throw(make_error_code(errc::function_not_supported),
+                            ec, "copy", from, to);
+    }
+
+    if (ec) ec->clear();
+
+    if (is_symlink(f)) {
+        if (bool(copy_options::skip_symlinks & options)) {
+            // do nothing
+        } else if (not exists(t)) {
+            __copy_symlink(from, to, ec);
+        } else {
+            set_or_throw(make_error_code(errc::file_exists),
+                         ec, "copy", from, to);
+        }
+        return;
+    }
+    else if (is_regular_file(f)) {
+        if (bool(copy_options::directories_only & options)) {
+            // do nothing
+        }
+        else if (bool(copy_options::create_symlinks & options)) {
+            __create_symlink(from, to, ec);
+        }
+        else if (bool(copy_options::create_hard_links & options)) {
+            __create_hard_link(from, to, ec);
+        }
+        else if (is_directory(t)) {
+            __copy_file(from, to / from.filename(), options, ec);
+        } else {
+            __copy_file(from, to, options, ec);
+        }
+        return;
+    }
+    else if (is_directory(f)) {
+        if (not bool(copy_options::recursive & options) &&
+            bool(copy_options::__in_recursive_copy & options))
+        {
+            return;
+        }
+
+        if (!exists(t)) {
+            // create directory to with attributes from 'from'.
+            __create_directory(to, from, ec);
+            if (ec && *ec) { return; }
+        }
+        directory_iterator it = ec ? directory_iterator(from, *ec)
+                                   : directory_iterator(from);
+        if (ec && *ec) { return; }
+        std::error_code m_ec;
+        for (; it != directory_iterator(); it.increment(m_ec)) {
+            if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to);
+            __copy(it->path(), to / it->path().filename(),
+                   options | copy_options::__in_recursive_copy, ec);
+            if (ec && *ec) { return; }
+        }
+    }
+}
+
+
+bool __copy_file(const path& from, const path& to, copy_options options,
+                 std::error_code *ec)
+{
+    if (ec) ec->clear();
+
+    std::error_code m_ec;
+    auto from_st = detail::posix_stat(from, &m_ec);
+    if (not is_regular_file(from_st)) {
+        if (not m_ec)
+            m_ec = make_error_code(errc::not_supported);
+        set_or_throw(m_ec, ec, "copy_file", from, to);
+        return false;
+    }
+
+    auto to_st = detail::posix_stat(to, &m_ec);
+    if (!status_known(to_st)) {
+        set_or_throw(m_ec, ec, "copy_file", from, to);
+        return false;
+    }
+
+    const bool to_exists = exists(to_st);
+    if (to_exists && bool(copy_options::skip_existing & options)) {
+        return false;
+    }
+    else if (to_exists && bool(copy_options::update_existing & options)) {
+        auto from_time = __last_write_time(from, ec);
+        if (ec && *ec) { return false; }
+        auto to_time = __last_write_time(to, ec);
+        if (ec && *ec) { return false; }
+        if (from_time <= to_time) {
+            return false;
+        }
+        return detail::copy_file_impl(from, to, from_st.permissions(), ec);
+    }
+    else if (!to_exists || bool(copy_options::overwrite_existing & options)) {
+        return detail::copy_file_impl(from, to, from_st.permissions(), ec);
+    }
+    else {
+        set_or_throw(make_error_code(errc::file_exists), ec, "copy", from, to);
+        return false;
+    }
+}
+
+void __copy_symlink(const path& existing_symlink, const path& new_symlink,
+                    std::error_code *ec)
+{
+    const path real_path(__read_symlink(existing_symlink, ec));
+    if (ec && *ec) { return; }
+    // NOTE: proposal says you should detect if you should call
+    // create_symlink or create_directory_symlink. I don't think this
+    // is needed with POSIX
+    __create_symlink(real_path, new_symlink, ec);
+}
+
+
+bool __create_directories(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    auto const st = detail::posix_stat(p, &m_ec);
+    if (!status_known(st)) {
+        set_or_throw(m_ec, ec, "create_directories", p);
+        return false;
+    }
+    else if (is_directory(st)) {
+        if (ec) ec->clear();
+        return false;
+    }
+    else if (exists(st)) {
+        set_or_throw(make_error_code(errc::file_exists),
+                     ec, "create_directories", p);
+        return false;
+    }
+
+    const path parent = p.parent_path();
+    if (!parent.empty()) {
+        const file_status parent_st = status(parent, m_ec);
+        if (not status_known(parent_st)) {
+            set_or_throw(m_ec, ec, "create_directories", p);
+            return false;
+        }
+        if (not exists(parent_st)) {
+            __create_directories(parent, ec);
+            if (ec && *ec) { return false; }
+        }
+    }
+    return __create_directory(p, ec);
+}
+
+bool __create_directory(const path& p, std::error_code *ec)
+{
+    if (ec) ec->clear();
+    if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
+        return true;
+    if (errno != EEXIST || !is_directory(p))
+        set_or_throw(ec, "create_directory", p);
+    return false;
+}
+
+bool __create_directory(path const & p, path const & attributes,
+                        std::error_code *ec)
+{
+    struct ::stat attr_stat;
+    std::error_code mec;
+    auto st = detail::posix_stat(attributes, attr_stat, &mec);
+    if (!status_known(st)) {
+        set_or_throw(mec, ec, "create_directory", p, attributes);
+        return false;
+    }
+    if (ec) ec->clear();
+    if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
+        return true;
+    if (errno != EEXIST || !is_directory(p))
+        set_or_throw(ec, "create_directory", p, attributes);
+    return false;
+}
+
+void __create_directory_symlink(path const & from, path const & to,
+                                std::error_code *ec){
+    if (::symlink(from.c_str(), to.c_str()) != 0)
+        set_or_throw(ec, "create_directory_symlink", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __create_hard_link(const path& from, const path& to, std::error_code *ec){
+    if (::link(from.c_str(), to.c_str()) == -1)
+        set_or_throw(ec, "create_hard_link", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __create_symlink(path const & from, path const & to, std::error_code *ec){
+    if (::symlink(from.c_str(), to.c_str()) != 0)
+        set_or_throw(ec, "create_symlink", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+path __current_path(std::error_code *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]);
+    char* ret;
+    if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr) {
+        set_or_throw(ec, "current_path");
+        return {};
+    }
+    if (ec) ec->clear();
+    return {buff.get()};
+}
+
+void __current_path(const path& p, std::error_code *ec) {
+    if (::chdir(p.c_str()) == -1)
+        set_or_throw(ec, "current_path", p);
+    else if (ec)
+        ec->clear();
+}
+
+bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
+{
+    std::error_code ec1, ec2;
+    struct ::stat st1 = {};
+    struct ::stat st2 = {};
+    auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
+    auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
+
+    if ((!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))) {
+        set_or_throw(make_error_code(errc::not_supported), ec,
+                     "equivalent", p1, p2);
+        return false;
+    }
+    if (ec) ec->clear();
+    return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
+}
+
+
+std::uintmax_t __file_size(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    struct ::stat st;
+    file_status fst = detail::posix_stat(p, st, &m_ec);
+    if (!exists(fst) || !is_regular_file(fst)) {
+        if (!m_ec)
+            m_ec = make_error_code(errc::not_supported);
+        set_or_throw(m_ec, ec, "file_size", p);
+        return static_cast<uintmax_t>(-1);
+    }
+    // is_regular_file(p) == true
+    if (ec) ec->clear();
+    return static_cast<std::uintmax_t>(st.st_size);
+}
+
+std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
+{
+    std::error_code m_ec;
+    struct ::stat st;
+    detail::posix_stat(p, st, &m_ec);
+    if (m_ec) {
+        set_or_throw(m_ec, ec, "hard_link_count", p);
+        return static_cast<std::uintmax_t>(-1);
+    }
+    if (ec) ec->clear();
+    return static_cast<std::uintmax_t>(st.st_nlink);
+}
+
+
+bool __fs_is_empty(const path& p, std::error_code *ec)
+{
+    if (ec) ec->clear();
+    std::error_code m_ec;
+    struct ::stat pst;
+    auto st = detail::posix_stat(p, pst, &m_ec);
+    if (is_directory(st))
+        return directory_iterator(p) == directory_iterator{};
+    else if (is_regular_file(st))
+        return static_cast<std::uintmax_t>(pst.st_size) == 0;
+    // else
+    set_or_throw(m_ec, ec, "is_empty", p);
+    return false;
+}
+
+
+file_time_type __last_write_time(const path& p, std::error_code *ec)
+{
+    using Clock = file_time_type::clock;
+    std::error_code m_ec;
+    struct ::stat st;
+    detail::posix_stat(p, st, &m_ec);
+    if (m_ec) {
+        set_or_throw(m_ec, ec, "last_write_time", p);
+        return file_time_type::min();
+    }
+    if (ec) ec->clear();
+    return Clock::from_time_t(static_cast<std::time_t>(st.st_mtime));
+}
+
+
+void __last_write_time(const path& p, file_time_type new_time,
+                       std::error_code *ec)
+{
+    std::error_code m_ec;
+#if !defined(__APPLE__)
+    using namespace std::chrono;
+    auto dur_since_epoch = new_time.time_since_epoch();
+    auto sec_since_epoch = duration_cast<seconds>(dur_since_epoch);
+    auto ns_since_epoch = duration_cast<nanoseconds>(dur_since_epoch - sec_since_epoch);
+    struct ::timespec tbuf[2];
+    tbuf[0].tv_sec = 0;
+    tbuf[0].tv_nsec = UTIME_OMIT;
+    tbuf[1].tv_sec = sec_since_epoch.count();
+    tbuf[1].tv_nsec = ns_since_epoch.count();
+
+    if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
+        m_ec = detail::capture_errno();
+    }
+#else
+    using Clock = file_time_type::clock;
+    struct ::stat st;
+    detail::posix_stat(p, st, &m_ec);
+    if (!m_ec) {
+        ::utimbuf tbuf;
+        tbuf.actime = st.st_atime;
+        tbuf.modtime = Clock::to_time_t(new_time);
+        if (::utime(p.c_str(), &tbuf) == -1) {
+            m_ec = detail::capture_errno();
+        }
+    }
+#endif
+    if (m_ec)
+        set_or_throw(m_ec, ec, "last_write_time", p);
+    else if (ec)
+        ec->clear();
+}
+
+
+void __permissions(const path& p, perms prms, std::error_code *ec)
+{
+    _LIBCPP_ASSERT(not (bool(perms::add_perms & prms)
+                 && bool(perms::remove_perms & prms)), "invalid perms mask");
+
+    std::error_code m_ec;
+    file_status st = detail::posix_stat(p, &m_ec);
+    if (m_ec)
+        return set_or_throw(m_ec, ec, "permissions", p);
+
+    if (bool(perms::add_perms & prms))
+        prms |= st.permissions() & perms::mask;
+    else if (bool(perms::remove_perms & prms))
+        prms = st.permissions() & ~(prms & perms::mask);
+    auto real_perms = detail::posix_convert_perms(prms);
+
+# if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD) \
+  && !defined(__linux__)
+    const int flags = bool(perms::resolve_symlinks & prms)
+                   ? 0 : AT_SYMLINK_NOFOLLOW;
+    if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
+# else
+    if (::chmod(p.c_str(), real_perms) == -1) {
+# endif
+        return set_or_throw(ec, "permissions", p);
+    }
+    if (ec) ec->clear();
+}
+
+
+path __read_symlink(const path& p, std::error_code *ec) {
+    char buff[PATH_MAX + 1];
+    std::error_code m_ec;
+    ::ssize_t ret;
+    if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
+        set_or_throw(ec, "read_symlink", p);
+        return {};
+    }
+    _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
+    _LIBCPP_ASSERT(ret > 0, "TODO");
+    if (ec) ec->clear();
+    buff[ret] = 0;
+    return {buff};
+}
+
+
+bool __remove(const path& p, std::error_code *ec) {
+    if (::remove(p.c_str()) == -1) {
+        set_or_throw(ec, "remove", p);
+        return false;
+    }
+    if (ec) ec->clear();
+    return true;
+}
+
+namespace {
+
+std::uintmax_t remove_all_impl(path const & p, file_status const & st,
+                               std::error_code *ec)
+{
+    static constexpr std::uintmax_t npos = static_cast<std::uintmax_t>(-1);
+    std::uintmax_t count = 1;
+    if (is_directory(st)) {
+        for (directory_iterator it(p); it != directory_iterator(); ++it) {
+            const file_status fst = __symlink_status(it->path(), ec);
+            if (ec && *ec) {
+                return npos;
+            }
+            const std::uintmax_t other_count =
+                remove_all_impl(it->path(), fst, ec);
+            if ((ec && *ec) || other_count == npos) {
+                return npos;
+            }
+            count += other_count;
+        }
+    }
+    const bool ret = __remove(p, ec);
+    _LIBCPP_ASSERT(ret, "Remove should have succeeded"); ((void)ret);
+    if (ec && *ec)
+        return npos;
+    else
+        return count;
+}
+
+} // end namespace
+
+std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
+    std::error_code mec;
+    const file_status st = __symlink_status(p, &mec);
+    if (mec) {
+        set_or_throw(mec, ec, "remove_all", p);
+        return static_cast<std::uintmax_t>(-1);
+    }
+    else if (exists(st)) {
+        return remove_all_impl(p, st, ec);
+    } else {
+        if (ec) ec->clear();
+        return 0;
+    }
+}
+
+void __rename(const path& from, const path& to, std::error_code *ec) {
+    if (::rename(from.c_str(), to.c_str()) == -1)
+        set_or_throw(ec, "rename", from, to);
+    else if (ec)
+        ec->clear();
+}
+
+void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
+    if (::truncate(p.c_str(), static_cast<long>(size)) == -1)
+        set_or_throw(ec, "resize_file", p);
+    else if (ec)
+        ec->clear();
+}
+
+space_info __space(const path& p, std::error_code *ec) {
+    space_info si;
+    struct statvfs m_svfs;
+    //if we fail but don't throw
+    if (::statvfs(p.c_str(), &m_svfs) == -1)  {
+        set_or_throw(ec, "space", p);
+        si.capacity = si.free = si.available =
+            static_cast<decltype(si.free)>(-1);
+        return si;
+    }
+    if (ec) ec->clear();
+    si.capacity =   m_svfs.f_blocks * m_svfs.f_frsize;
+    si.free =       m_svfs.f_bfree  * m_svfs.f_frsize;
+    si.available =  m_svfs.f_bavail * m_svfs.f_frsize;
+    return si;
+}
+
+file_status __status(const path& p, std::error_code *ec) {
+    return detail::posix_stat(p, ec);
+}
+
+file_status __symlink_status(const path& p, std::error_code *ec) {
+    return detail::posix_lstat(p, ec);
+}
+
+path __system_complete(const path& p, std::error_code *ec) {
+    if (ec) ec->clear();
+    return absolute(p, current_path());
+}
+
+path __temp_directory_path(std::error_code *ec) {
+    const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
+    const char* ret = nullptr;
+    for (auto & ep : env_paths)  {
+        if ((ret = std::getenv(ep)))
+            break;
+    }
+    path p(ret ? ret : "/tmp");
+    if (is_directory(p)) {
+        if (ec) ec->clear();
+        return p;
+    }
+    set_or_throw(make_error_code(errc::no_such_file_or_directory), ec,
+                 "temp_directory_path");
+    return {};
+}
+
+//since the specification of absolute in the current specification
+// this implementation is designed after the sample implementation
+// using the sample table as a guide
+path absolute(const path& p, const path& base) {
+    auto root_name = p.root_name();
+    auto root_dir = p.root_directory();
+
+    if (!root_name.empty() && !root_dir.empty())
+      return p;
+
+    auto abs_base = base.is_absolute() ? base : absolute(base);
+
+    /* !has_root_name && !has_root_dir */
+    if (root_name.empty() && root_dir.empty())
+    {
+      return abs_base / p;
+    }
+    else if (!root_name.empty()) /* has_root_name && !has_root_dir */
+    {
+      return  root_name / abs_base.root_directory()
+              /
+              abs_base.relative_path() / p.relative_path();
+    }
+    else /* !has_root_name && has_root_dir */
+    {
+      if (abs_base.has_root_name())
+        return abs_base.root_name() / p;
+      // else p is absolute,  return outside of block
+    }
+    return p;
+}
+
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp

 void test_noexcept_function_pointers()
 {
     struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
-#if !defined(__cpp_noexcept_function_type)
+#if !defined(__cpp_noexcept_function_type) && 0
     {
         // Check that PMF's and function pointers *work*. is_nothrow_callable will always
         // return false because 'noexcept' is not part of the function type.