[libc++] Mark <filesystem> as unavailable on Apple platforms

[ldionne]

Summary

Also add the corresponding XFAILs to tests that require filesystem.
Note that I did try to use a less intrusive approach using pragma
clang attribute, but this didn't work due to apparent bugs in Clang
(which should be fixed independently but should not delay this change).

Also note that we mark the functions as being introduced in versions
99.99 of the platforms because of a Clang bug (PR40991), which causes
a hard error when an unavailable function is used to initialize the
default argument of another unavailable function. We run into this
issue with functions like proximate().

[dexonsmith]

libcxx/include/__config

1372–1375

Can we make this 9999?

[mclow.lists]

I don't like how intrusive and pervasive this is.

libcxx/include/chrono

2830

This is a ABI change for people who are using the filesystem.
A public symbol has become non-public.

[ldionne]

In D59093#1421820, @mclow.lists wrote:

I don't like how intrusive and pervasive this is.

Me neither. Per our offline conversation, I'm currently trying to get the #pragma approach to work (again). I'll report here.

libcxx/include/chrono

2830

Sorry, I don't follow you here. How did I change the symbol?

[mclow.lists]

libcxx/include/chrono

2830

Sorry; my bad. Misleading diff markup.

[EricWF]

We've got to find a better way to do this.

Also, a lot of these symbols are inline and don't depend on anything in the dylib. Why are the being marked unavailable?

[ldionne]

In D59093#1423652, @EricWF wrote:

We've got to find a better way to do this.

Yes, I don't like this but it is necessary if we want to ship <filesystem> as part of the dylib. Like I said, it is possible to use #pragma clang attribute to apply this to several declarations at once which makes it less intrusive. But at the end of the day, it is necessary to annotate the declarations that were added to the dylib, and anything that uses those transitively.

Also, a lot of these symbols are inline and don't depend on anything in the dylib. Why are the being marked unavailable?

This patch did annotate too many things -- I'll submit a follow-up that does not annotate as many things. For example the perms enumeration and its associated operations don't need to be annotated. However, one must keep in mind that I need to annotate anything that uses a symbol in the dylib, and do that transitively. So some things that might not seem to be implemented in the dylib still need to be annotated because they are using something that's in the dylib (sometimes indirectly).

[ldionne]

Remove markup on inline enums, and add markup for path.

I had somehow forgotten path in the previous patch.. oops.

[ldionne]

With the new patch (which removes markup from unnecessary methods and classes), I think this is actually the right approach. Using an attribute wouldn't buy us very much as we'd have to close the namespace, push the pragma, open the namespace and then close it again to pop the pragma. And the only set of declarations this would cleanly apply to is the set of operations on path. So I think this is as simple as we can get now.

Now, I understand folks don't like availability markup (and markup in general). I share that distaste because it clutters the source code. So I would encourage us to work on a better general solution if we can find one:

• maybe the markup can somehow be stored externally to the library?
• maybe we can automatically derive the list of declarations in the compiler by knowing what symbols were added and when?
• maybe it's easy to write an external tool to check this instead of having it in the library?

However, we shouldn't stop progress on putting <filesystem> into the dylib while we're waiting for a better general solution to this problem. Once/if we have such a solution, we can come back and apply it throughout the library (<variant>, <optional> & friends would also benefit).

[ldionne]

I'm dropping this in favour of https://reviews.llvm.org/D59224, which is less intrusive.

libcxx/include/__config

#  define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE                                 \
      __attribute__((availability(macosx,strict,introduced=10.9)))              \
      __attribute__((availability(ios,strict,introduced=7.0)))
 #  define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY                                 \
      __attribute__((availability(macosx,strict,introduced=10.9)))              \
      __attribute__((availability(ios,strict,introduced=7.0)))
 #  define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR                               \
      __attribute__((availability(macosx,strict,introduced=10.9)))              \
      __attribute__((availability(ios,strict,introduced=7.0)))
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM                                      \
+     __attribute__((availability(macosx,strict,introduced=99.99)))             \
+     __attribute__((availability(ios,strict,introduced=99.99)))                \
+     __attribute__((availability(tvos,strict,introduced=99.99)))               \
+     __attribute__((availability(watchos,strict,introduced=99.99)))
 #else
 #  define _LIBCPP_AVAILABILITY_SHARED_MUTEX
 #  define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
 #  define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
 #  define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
 #  define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
 #  define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
 #  define _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #  define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
 #  define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
 #  define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
+#  define _LIBCPP_AVAILABILITY_FILESYSTEM
 #endif
 
 // Define availability that depends on _LIBCPP_NO_EXCEPTIONS.
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #  define _LIBCPP_AVAILABILITY_FUTURE
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
 #  define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS

libcxx/include/chrono

 }
 
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-struct _FilesystemClock {
+struct _LIBCPP_AVAILABILITY_FILESYSTEM _FilesystemClock {
 #if !defined(_LIBCPP_HAS_NO_INT128)
   typedef __int128_t rep;
   typedef nano period;
 #else
   typedef long long rep;
   typedef nano period;
 #endif
 

libcxx/include/filesystem

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-typedef chrono::time_point<_FilesystemClock> file_time_type;
+typedef _LIBCPP_AVAILABILITY_FILESYSTEM chrono::time_point<_FilesystemClock> file_time_type;
 
 struct _LIBCPP_TYPE_VIS space_info {
   uintmax_t capacity;
   uintmax_t free;
   uintmax_t available;
 };
 
 enum class _LIBCPP_ENUM_VIS file_type : signed char {
struct _PathCVT<char> {
   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 {
+class _LIBCPP_AVAILABILITY_FILESYSTEM _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>
private:
   inline _LIBCPP_INLINE_VISIBILITY path&
   __assign_view(__string_view const& __s) noexcept {
     __pn_ = string_type(__s);
     return *this;
   }
   string_type __pn_;
 };
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
   __lhs.swap(__rhs);
 }
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 size_t hash_value(const path& __p) noexcept;
 
 template <class _Source>
+_LIBCPP_AVAILABILITY_FILESYSTEM
 _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_AVAILABILITY_FILESYSTEM
 _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);
 }
private:
   iterator& __decrement();
 
   path __stashed_elem_;
   const path* __path_ptr_;
   path::__string_view __entry_;
   _ParserState __state_;
 };
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
          __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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 {
+class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(path(), path())) {
     __create_what(0);
   }
 
struct _Storage {
     path __p1_;
     path __p2_;
     string __what_;
   };
   shared_ptr<_Storage> __storage_;
 };
 
 template <class... _Args>
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_NORETURN inline _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(std::forward<_Args>(__args)...);
 }
 #else
 void __throw_filesystem_error(_Args&&...) {
   _VSTD::abort();
 }
 #endif
 
 // operational functions
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __absolute(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __canonical(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __copy(const path& __from, const path& __to, copy_options __opt,
             error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __copy_file(const path& __from, const path& __to, copy_options __opt,
                  error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
                     error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __create_directories(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __create_directory(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __create_directory(const path& p, const path& attributes,
                         error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __create_directory_symlink(const path& __to, const path& __new_symlink,
                                 error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __create_hard_link(const path& __to, const path& __new_hard_link,
                         error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __create_symlink(const path& __to, const path& __new_symlink,
                       error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __current_path(error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __current_path(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 uintmax_t __file_size(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __fs_is_empty(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __last_write_time(const path& p, file_time_type new_time,
                        error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __permissions(const path&, perms, perm_options, error_code* = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __read_symlink(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 bool __remove(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __rename(const path& from, const path& to, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 space_info __space(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 file_status __status(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 file_status __symlink_status(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __system_complete(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __temp_directory_path(error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS
+_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS
 path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path current_path() {
   return __current_path();
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
   return __current_path(&__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
   __current_path(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
                                                    error_code& __ec) noexcept {
   __current_path(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
   return __absolute(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
                                                error_code& __ec) {
   return __absolute(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
   return __canonical(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
                                                 error_code& __ec) {
   return __canonical(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
                                            const path& __to) {
   __copy(__from, __to, copy_options::none);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            error_code& __ec) {
   __copy(__from, __to, copy_options::none, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            copy_options __opt) {
   __copy(__from, __to, __opt);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            copy_options __opt,
                                            error_code& __ec) {
   __copy(__from, __to, __opt, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
                                                 const path& __to) {
   return __copy_file(__from, __to, copy_options::none);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 copy_file(const path& __from, const path& __to, error_code& __ec) {
   return __copy_file(__from, __to, copy_options::none, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 copy_file(const path& __from, const path& __to, copy_options __opt) {
   return __copy_file(__from, __to, __opt);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
                                                 const path& __to,
                                                 copy_options __opt,
                                                 error_code& __ec) {
   return __copy_file(__from, __to, __opt, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
                                                    const path& __new) {
   __copy_symlink(__existing, __new);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
   __copy_symlink(__ext, __new, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
   return __create_directories(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
                                                          error_code& __ec) {
   return __create_directories(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
   return __create_directory(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 create_directory(const path& __p, error_code& __ec) noexcept {
   return __create_directory(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
                                                        const path& __attrs) {
   return __create_directory(__p, __attrs);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 create_directory(const path& __p, const path& __attrs,
                  error_code& __ec) noexcept {
   return __create_directory(__p, __attrs, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 create_directory_symlink(const path& __to, const path& __new) {
   __create_directory_symlink(__to, __new);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 create_directory_symlink(const path& __to, const path& __new,
                          error_code& __ec) noexcept {
   __create_directory_symlink(__to, __new, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
                                                        const path& __new) {
   __create_hard_link(__to, __new);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 create_hard_link(const path& __to, const path& __new,
                  error_code& __ec) noexcept {
   __create_hard_link(__to, __new, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
                                                      const path& __new) {
   __create_symlink(__to, __new);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
   return exists(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
                                              error_code& __ec) noexcept {
   auto __s = __status(__p, &__ec);
   if (status_known(__s))
     __ec.clear();
   return exists(__s);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
                                                  const path& __p2) {
   return __equivalent(__p1, __p2);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
   return __equivalent(__p1, __p2, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
   return __file_size(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t
 file_size(const path& __p, error_code& __ec) noexcept {
   return __file_size(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
   return __hard_link_count(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
   return is_block_file(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
   return is_character_file(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
   return is_directory(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
                                                    error_code& __ec) noexcept {
   return is_directory(__status(__p, &__ec));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
   return __fs_is_empty(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
                                                error_code& __ec) {
   return __fs_is_empty(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
   return __s.type() == file_type::fifo;
 }
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
   return is_fifo(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
   return is_regular_file(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
   return is_socket(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
   return is_symlink(__symlink_status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
   return is_other(__status(__p));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
                                                error_code& __ec) noexcept {
   return is_other(__status(__p, &__ec));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_time_type
 last_write_time(const path& __p) {
   return __last_write_time(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_time_type
 last_write_time(const path& __p, error_code& __ec) noexcept {
   return __last_write_time(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
                                                       file_time_type __t) {
   __last_write_time(__p, __t);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 permissions(const path& __p, perms __prms,
             perm_options __opts = perm_options::replace) {
   __permissions(__p, __prms, __opts);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
                                                   error_code& __ec) noexcept {
   __permissions(__p, __prms, perm_options::replace, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
                                                   perm_options __opts,
                                                   error_code& __ec) {
   __permissions(__p, __prms, __opts, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
                                                 const path& __base,
                                                 error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return {};
   path __tmp_base = __weakly_canonical(__base, &__ec);
   if (__ec)
     return {};
   return __tmp.lexically_proximate(__tmp_base);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
                                                 error_code& __ec) {
   return proximate(__p, current_path(), __ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path
 proximate(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_proximate(
       __weakly_canonical(__base));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
   return __read_symlink(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
                                                    error_code& __ec) {
   return __read_symlink(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
                                                const path& __base,
                                                error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return path();
   path __tmpbase = __weakly_canonical(__base, &__ec);
   if (__ec)
     return path();
   return __tmp.lexically_relative(__tmpbase);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
                                                error_code& __ec) {
   return relative(__p, current_path(), __ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path
 relative(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
   return __remove(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
                                              error_code& __ec) noexcept {
   return __remove(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
   return __remove_all(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
                                                       error_code& __ec) {
   return __remove_all(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
                                              const path& __to) {
   return __rename(__from, __to);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 rename(const path& __from, const path& __to, error_code& __ec) noexcept {
   return __rename(__from, __to, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
                                                   uintmax_t __ns) {
   return __resize_file(__p, __ns);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY void
 resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
   return __resize_file(__p, __ns, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
   return __space(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
                                                   error_code& __ec) noexcept {
   return __space(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
   return __status(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
                                                     error_code& __ec) noexcept {
   return __status(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
   return __symlink_status(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY file_status
 symlink_status(const path& __p, error_code& __ec) noexcept {
   return __symlink_status(__p, &__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
   return __temp_directory_path();
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
   return __temp_directory_path(&__ec);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
   return __weakly_canonical(__p);
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
                                                        error_code& __ec) {
   return __weakly_canonical(__p, &__ec);
 }
 
 class directory_iterator;
 class recursive_directory_iterator;
 class __dir_stream;
 
-class directory_entry {
+class _LIBCPP_AVAILABILITY_FILESYSTEM 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;
 
file_time_type __get_write_time(error_code* __ec = nullptr) const {
     _LIBCPP_UNREACHABLE();
   }
 
 private:
   _Path __p_;
   __cached_data __data_;
 };
 
-class __dir_element_proxy {
+class _LIBCPP_AVAILABILITY_FILESYSTEM __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 {
+class _LIBCPP_AVAILABILITY_FILESYSTEM 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:
private:
 
   _LIBCPP_FUNC_VIS
   const directory_entry& __dereference() const;
 
 private:
   shared_ptr<__dir_stream> __imp_;
 };
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY bool
 operator==(const directory_iterator& __lhs,
            const directory_iterator& __rhs) noexcept {
   return __lhs.__imp_ == __rhs.__imp_;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 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
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
 begin(directory_iterator __iter) noexcept {
   return __iter;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
 end(const directory_iterator&) noexcept {
   return directory_iterator();
 }
 
-class recursive_directory_iterator {
+class _LIBCPP_AVAILABILITY_FILESYSTEM 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:
private:
   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_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY 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 {
+_LIBCPP_AVAILABILITY_FILESYSTEM
+inline _LIBCPP_INLINE_VISIBILITY bool
+operator!=(const recursive_directory_iterator& __lhs,
   return !(__lhs == __rhs);
 }
 // enable recursive_directory_iterator range-based for statements
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 end(const recursive_directory_iterator&) noexcept {
   return recursive_directory_iterator();
 }
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // !_LIBCPP_CXX03_LANG
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/fstream

#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     basic_filebuf* open(const char* __s, ios_base::openmode __mode);
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
       return open(__p.c_str(), __mode);
     }
 #endif
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* __open(int __fd, ios_base::openmode __mode);
 #endif
     basic_filebuf* close();
if (this->gptr() == this->egptr())
 
                 __extbufend_ = __extbufnext_ + __nr;
                 char_type*  __inext;
                 __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
                                        this->eback() + __unget_sz,
                                        this->eback() + __ibs_, __inext);
                 if (__r == codecvt_base::noconv)
                 {
-                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, 
+                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
                                           (char_type*)const_cast<char *>(__extbufend_));
                     __c = traits_type::to_int_type(*this->gptr());
                 }
                 else if (__inext != this->eback() + __unget_sz)
                 {
                     this->setg(this->eback(), this->eback() + __unget_sz, __inext);
                     __c = traits_type::to_int_type(*this->gptr());
                 }
#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in)
       : basic_ifstream(__p.c_str(), __mode) {}
 #endif // _LIBCPP_STD_VER >= 17
 #endif
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream(basic_ifstream&& __rhs);
 
#endif
     bool is_open() const;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in);
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
 #endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::in);
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     void open(const filesystem::path& __p,
               ios_base::openmode __mode = ios_base::in) {
       return open(__p.c_str(), __mode);
     }
 #endif // _LIBCPP_STD_VER >= 17
 
     _LIBCPP_INLINE_VISIBILITY
     void __open(int __fd, ios_base::openmode __mode);

 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
       : basic_ofstream(__p.c_str(), __mode) {}
 #endif // _LIBCPP_STD_VER >= 17
 
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream(basic_ofstream&& __rhs);
 

 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::out);
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
 #endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
     { return open(__p.c_str(), __mode); }
 #endif // _LIBCPP_STD_VER >= 17
 
     _LIBCPP_INLINE_VISIBILITY
     void __open(int __fd, ios_base::openmode __mode);
 #endif
     _LIBCPP_INLINE_VISIBILITY

 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
       : basic_fstream(__p.c_str(), __mode) {}
 #endif // _LIBCPP_STD_VER >= 17
 
 #endif
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream(basic_fstream&& __rhs);

 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
     void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #endif
     void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out)
     { return open(__p.c_str(), __mode); }
 #endif // _LIBCPP_STD_VER >= 17
 
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void close();
 

libcxx/test/libcxx/input.output/filesystems/lit.local.cfg

 # Disable all of the filesystem tests if the correct feature is not available.
 if 'c++filesystem' not in config.available_features:
   config.unsupported = True
+
+# Disable all of the filesystem tests if the dylib under test doesn't support them.
+if 'dylib-has-no-filesystem' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // basic_filebuf<charT,traits>* open(const filesystem::path& p, ios_base::openmode mode);
 
 #include <fstream>
 #include <filesystem>
 #include <cassert>

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // explicit basic_fstream(const filesystem::path& s,
 //     ios_base::openmode mode = ios_base::in|ios_base::out);

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in|ios_base::out);
 

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ifstream
 
 // explicit basic_ifstream(const filesystem::path& s,
 //     ios_base::openmode mode = ios_base::in);

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ifstream
 
 // void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in);
 

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 
 // explicit basic_ofstream(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
 

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
+// XFAIL: dylib-has-no-filesystem
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 
 // void open(const filesystem::path& s, ios_base::openmode mode = ios_base::out);
 

libcxx/test/std/input.output/filesystems/lit.local.cfg

 # Disable all of the filesystem tests if the correct feature is not available.
 if 'c++filesystem' not in config.available_features:
   config.unsupported = True
+
+# Disable all of the filesystem tests if the dylib under test doesn't support them.
+if 'dylib-has-no-filesystem' in config.available_features:
+  config.unsupported = True

libcxx/test/std/utilities/time/time.clock/time.clock.file/consistency.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 //
 // TODO: Remove this when filesystem gets integrated into the dylib
 // REQUIRES: c++filesystem
 
 // <chrono>
 
 // file_clock
 

libcxx/test/std/utilities/time/time.clock/time.clock.file/file_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 
 // <chrono>
 
 // file_time
 
 #include <chrono>
 
 #include "test_macros.h"
 
 template <class Dur>
 void test() {
   ASSERT_SAME_TYPE(std::chrono::file_time<Dur>, std::chrono::time_point<std::chrono::file_clock, Dur>);
 }
 
 int main(int, char**) {
   test<std::chrono::nanoseconds>();
   test<std::chrono::minutes>();
   test<std::chrono::hours>();
 
   return 0;
 }
 No newline at end of file

libcxx/test/std/utilities/time/time.clock/time.clock.file/now.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 
 // TODO: Remove this when filesystem gets integrated into the dylib
 // REQUIRES: c++filesystem
 
 // <chrono>
 
 // file_clock
 

libcxx/test/std/utilities/time/time.clock/time.clock.file/rep_signed.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// XFAIL: dylib-has-no-filesystem
 
 // TODO: Remove this when filesystem gets integrated into the dylib
 // REQUIRES: c++filesystem
 
 // <chrono>
 
 // file_clock
 

libcxx/utils/libcxx/test/config.py

def configure_deployment(self):
                 self.config.available_features.add('dylib-has-no-bad_optional_access')
                 self.lit_config.note("throwing bad_optional_access is not supported by the deployment target")
 
                 self.config.available_features.add('dylib-has-no-bad_variant_access')
                 self.lit_config.note("throwing bad_variant_access is not supported by the deployment target")
 
                 self.config.available_features.add('dylib-has-no-bad_any_cast')
                 self.lit_config.note("throwing bad_any_cast is not supported by the deployment target")
+            # Filesystem is not supported on Apple platforms yet
+            if name == 'macosx':
+                self.config.available_features.add('dylib-has-no-filesystem')
+                self.lit_config.note("the deployment target does not support the dylib parts of <filesystem>")
         else:
             self.cxx.flags += ['-D_LIBCPP_DISABLE_AVAILABILITY']
 
     def configure_env(self):
         self.target_info.configure_env(self.exec_env)
 
     def add_path(self, dest_env, new_path):
         if 'PATH' not in dest_env:
             dest_env['PATH'] = new_path
         else:
             split_char = ';' if self.is_windows else ':'
             dest_env['PATH'] = '%s%s%s' % (new_path, split_char,
                                            dest_env['PATH'])