[libc++] Roll up fstream support into filesystem support

[ldionne]

Summary

LIBCXX_ENABLE_FILESYSTEM should represent whether the platform has
support for a filesystem, not just whether we support <filesystem>.
This patch slightly generalizes the setting to also encompass whether
we provide <fstream>, since that only makes sense when a filesystem is
supported.

[ldionne]

Poke CI after setting parent revision.

[philnik]

LGTM, but #libc_vendors should be aware of this.

[ldionne]

In D152168#4396140, @philnik wrote:

LGTM, but #libc_vendors should be aware of this.

Indeed. In particular, heads up @mstorsjo and @rnk for Windows impact.

[mstorsjo]

In D152168#4396660, @ldionne wrote:

In D152168#4396140, @philnik wrote:

LGTM, but #libc_vendors should be aware of this.

Indeed. In particular, heads up @mstorsjo and @rnk for Windows impact.

With this in place, we really should go ahead with D134912 too, since I'm fairly sure that <fstream> is somewhat widely used on Windows even if <filesystem> is less common.

[phosek]

LGTM

[ldionne]

Rebase onto main.

[glandium]

FWIW, WASI had fstream but not filesystem, so this effectively removes fstream from it. See https://github.com/WebAssembly/wasi-sdk/issues/125

[ldionne]

In D152168#4407135, @glandium wrote:

FWIW, WASI had fstream but not filesystem, so this effectively removes fstream from it. See https://github.com/WebAssembly/wasi-sdk/issues/125

Just curious, how could it have fstream without having a filesystem?

[glandium]

In D152168#4413981, @ldionne wrote:

In D152168#4407135, @glandium wrote:

FWIW, WASI had fstream but not filesystem, so this effectively removes fstream from it. See https://github.com/WebAssembly/wasi-sdk/issues/125

Just curious, how could it have fstream without having a filesystem?

It has some I/O functions available (enough for <fstream>) but not everything required for <filesystem>.

[michaelplatings]

LLVM Embedded Toolchain for Arm also supports <fstream> but not <filesystem>. We have a C library so supporting <fstream> is easy. We don't have POSIX support so supporting <filesystem> is much more challenging.

Please can this change be reverted?

[peter.smith]

In D152168#4427603, @michaelplatings wrote:

LLVM Embedded Toolchain for Arm also supports <fstream> but not <filesystem>. We have a C library so supporting <fstream> is easy. We don't have POSIX support so supporting <filesystem> is much more challenging.

Please can this change be reverted?

To give some background. Simple file IO can be handled by an embedded toolchain using semihosting IO https://github.com/ARM-software/abi-aa/blob/main/semihosting/semihosting.rst (also supported by RISCV https://github.com/riscv-software-src/riscv-semihosting) the POSIX function in posix_compat.h can't easily be supported using that API.

[ldionne]

Thanks for the additional context. So basically, you folks are considering systems where a file system does exist (even in the case of semihosted I/O), but where the platform does not provide the necessary set of library functions to implement all of <filesystem>. In other words, that's a system where LIBCXX_ENABLE_FILESYSTEM is true, but where parts of the filesystem-requiring functionality in libc++ can't be implemented due to incomplete platform support.

If I understand correctly, then I think that's the correct way to think about this, instead of pretending that these platforms don't have support for a filesystem but magically have the <fstream> class and only that one. Can you tell me a bit more about your setups? This didn't come up during our CI testing (which tests all officially supported configurations), so we're not formally aware of your use cases:

1. Do you carry downstream patches?
2. How did you find out about this change?
3. How much of <filesystem> can't be implemented on your platforms?

I'm interested in supporting your use cases, and in particular in making things work well for embedded platforms -- that's part of the reason why we're making all these changes. But I'm also interested in making sure we provide coherent and well-supported ways to subset the library instead of arbitrary ones based on individual platform's needs, so at the moment just re-introducing LIBCXX_ENABLE_FSTREAM doesn't seem like the right approach to me. FWIW, the only reason why I introduced LIBCXX_ENABLE_FSTREAM is that I didn't have time to do this full stack of patches back then. Let's talk.

[miyuki]

In other words, that's a system where LIBCXX_ENABLE_FILESYSTEM is true, but where parts of the filesystem-requiring functionality in libc++ can't be implemented due to incomplete platform support.

Yes, that is correct.

Do you carry downstream patches?

At the moment we basically have two kinds of toolchains: one open source toolchain based on picolibc C library (which is in turn based on newlib), it does not need any downstream patches in the libc++ part (just a custom lit configuration), but the C++ support and testing is incomplete; we are currently actively improving it. We also have two proprietary toolchains based on our own C library which do have some downstream changes (but we want to keep them to a minimum). Both kinds rely on the same semihosting API/ABI to implement file system operations in the C library.

How did you find out about this change?

We have CI set up for the proprietary toolchains in which some fstream tests are xfailed (via a separate mechanism, rather than lit "// XFAIL" to reduce downstream changes) because of some missing functionality in the C library. Those started passing unexpectedly because they are now marked as unsupported. We also monitor the stream of libc++ patches (I am subscribed to the libc++ group in Phabricator).

How much of <filesystem> can't be implemented on your platforms?

In the Arm semihosting API, directory operations (such as checking whether a directory exists, creating a directory, and enumerating files in a directory) are not available. Querying and setting permissions, file creation/modification time, space_info, and working with hardlinks and symlinks is also not supported. Basically, the following operations are supported: opening a file by name, seeking, reading, writing, querying the length of an open file, renaming, and removing a file by name.

[glandium]

This comment was removed by glandium.

libcxx/CMakeLists.txt

 
 # Basic options ---------------------------------------------------------------
 option(LIBCXX_ENABLE_ASSERTIONS
   "Enable assertions inside the compiled library, and at the same time make it the
    default when compiling user code. Note that assertions can be enabled or disabled
    by users in their own code regardless of this option." OFF)
 option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
 option(LIBCXX_ENABLE_STATIC "Build libc++ as a static library." ON)
-option(LIBCXX_ENABLE_FILESYSTEM "Build filesystem as part of the main libc++ library" ON)
+option(LIBCXX_ENABLE_FILESYSTEM
+  "Whether to include support for parts of the library that rely on a filesystem being
+   available on the platform. This includes things like most parts of <filesystem> and
+   others like <fstream>" ON)
 option(LIBCXX_INCLUDE_TESTS "Build the libc++ tests." ${LLVM_INCLUDE_TESTS})
 option(LIBCXX_ENABLE_DEBUG_MODE
   "Whether to build libc++ with the debug mode enabled.
    By default, this is turned off. Turning it on results in a different ABI (additional
    symbols but also potentially different layouts of types), and one should not mix code
    built against a dylib that has debug mode and code built against a regular dylib." OFF)
 option(LIBCXX_ENABLE_RANDOM_DEVICE
   "Whether to include support for std::random_device in the library. Disabling
    this can be useful when building the library for platforms that don't have
    a source of randomness, such as some embedded platforms. When this is not
    supported, most of <random> will still be available, but std::random_device
    will not." ON)
 option(LIBCXX_ENABLE_LOCALIZATION
   "Whether to include support for localization in the library. Disabling
    localization can be useful when porting to platforms that don't support
    the C locale API (e.g. embedded). When localization is not supported,
    several parts of the library will be disabled: <iostream>, <regex>, <locale>
    will be completely unusable, and other parts may be only partly available." ON)
-option(LIBCXX_ENABLE_FSTREAM
-   "Whether to include support for <fstream>." ON) # TODO: Consider rolling that into LIBCXX_ENABLE_FILESYSTEM
 option(LIBCXX_ENABLE_UNICODE
   "Whether to include support for Unicode in the library. Disabling Unicode can
    be useful when porting to platforms that don't support UTF-8 encoding (e.g.
    embedded)." ON)
 option(LIBCXX_ENABLE_WIDE_CHARACTERS
   "Whether to include support for wide characters in the library. Disabling
    wide character support can be useful when porting to platforms that don't
    support the C functionality for wide characters. When wide characters are
if (NOT LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION STREQUAL "default")
   config_define("${LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION}" _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION)
 endif()
 config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_HAS_WIN32_THREAD_API _LIBCPP_HAS_THREAD_API_WIN32)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
-config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
-config_define_if_not(LIBCXX_ENABLE_FSTREAM _LIBCPP_HAS_NO_FSTREAM)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 config_define_if(LIBCXX_ENABLE_DEBUG_MODE _LIBCPP_ENABLE_DEBUG_MODE)
 if (LIBCXX_ENABLE_ASSERTIONS)
   config_define(1 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)
 else()
   config_define(0 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)

libcxx/cmake/caches/Generic-no-fstream.cmake

-set(LIBCXX_ENABLE_FSTREAM OFF CACHE BOOL "")

libcxx/docs/ReleaseNotes.rst

- Symbols for ``std::allocator_arg``, ``std::defer_lock``, ``std::try_to_lock``, ``std::adopt_lock``, and
   since those objects were defined in the headers as ``constexpr``.
 
 Build System Changes
 --------------------
 
 - Building libc++ and libc++abi for Apple platforms now requires targeting macOS 10.13 and later.
   This is relevant for vendors building the libc++ shared library and for folks statically linking
   libc++ into an application that has back-deployment requirements on Apple platforms.
+
+- ``LIBCXX_ENABLE_FILESYSTEM`` now represents whether a filesystem is supported on the platform instead
+  of representing merely whether ``<filesystem>`` should be provided. This means that vendors building
+  with ``LIBCXX_ENABLE_FILESYSTEM=OFF`` will now also get ``<fstream>`` excluded from their configuration
+  of the library.
+
+- ``LIBCXX_ENABLE_FSTREAM`` is not supported anymore, please use ``LIBCXX_ENABLE_FILESYSTEM=OFF`` if your
+  platform does not have support for a filesystem.

libcxx/include/CMakeLists.txt

set(files
   valarray
   variant
   vector
   version
   wchar.h
   wctype.h
   )
 
-foreach(feature LIBCXX_ENABLE_FILESYSTEM LIBCXX_ENABLE_LOCALIZATION LIBCXX_ENABLE_FSTREAM LIBCXX_ENABLE_THREADS LIBCXX_ENABLE_WIDE_CHARACTERS)
+foreach(feature LIBCXX_ENABLE_FILESYSTEM LIBCXX_ENABLE_LOCALIZATION LIBCXX_ENABLE_THREADS LIBCXX_ENABLE_WIDE_CHARACTERS)
   if (NOT ${${feature}})
     set(requires_${feature} "requires LIBCXX_CONFIGURED_WITHOUT_SUPPORT_FOR_THIS_HEADER")
   endif()
 endforeach()
 
 configure_file("__config_site.in" "${LIBCXX_GENERATED_INCLUDE_TARGET_DIR}/__config_site" @ONLY)
 configure_file("module.modulemap.in" "${LIBCXX_GENERATED_INCLUDE_DIR}/module.modulemap" @ONLY)
 

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_HAS_THREAD_API_PTHREAD
 #cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL
 #cmakedefine _LIBCPP_HAS_THREAD_API_WIN32
 #cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
-#cmakedefine _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#cmakedefine _LIBCPP_HAS_NO_FILESYSTEM
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
-#cmakedefine _LIBCPP_HAS_NO_FSTREAM
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
 #cmakedefine _LIBCPP_ENABLE_DEBUG_MODE
 
 // PSTL backends
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_SERIAL
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_THREAD
 

libcxx/include/filesystem

 #include <__filesystem/u8path.h>
 #include <version>
 
 // standard-mandated includes
 
 // [fs.filesystem.syn]
 #include <compare>
 
-#if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if defined(_LIBCPP_HAS_NO_FILESYSTEM)
 # error "The <filesystem> library is not supported since libc++ has been configured without support for a filesystem."
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <system_error>
 #endif
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/fstream

 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
 #include <istream>
 #include <ostream>
 #include <typeinfo>
 #include <version>
 
-#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 #   include <filesystem>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION)
 #  define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #endif
 
-#if !defined(_LIBCPP_HAS_NO_FSTREAM)
+#if !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_filebuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
public:
     bool is_open() const;
     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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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);
     basic_filebuf* close();
public:
     _LIBCPP_INLINE_VISIBILITY
     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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream(basic_ifstream&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream& operator=(basic_ifstream&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ifstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
     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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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
public:
     explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
 #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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream(basic_ofstream&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream& operator=(basic_ofstream&& __rhs);
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ofstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
     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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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);
     _LIBCPP_INLINE_VISIBILITY
public:
     explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #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 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream(basic_fstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream& operator=(basic_fstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_fstream& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
     _LIBCPP_HIDE_FROM_ABI 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
     _LIBCPP_HIDE_FROM_ABI void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#if _LIBCPP_STD_VER >= 17
     _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
 
     _LIBCPP_INLINE_VISIBILITY
     void close();
 

 #if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1)
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_HAS_NO_FSTREAM
+#endif // _LIBCPP_HAS_NO_FILESYSTEM
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/module.modulemap.in

module std [system] {
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
-    @requires_LIBCXX_ENABLE_FSTREAM@
+    @requires_LIBCXX_ENABLE_FILESYSTEM@
     header "fstream"
     export *
   }
   module functional {
     header "functional"
     // the contents of __type_traits/unwrap_ref.h should be available from functional too.
     export type_traits.unwrap_ref
     export *

libcxx/src/ios.instantiations.cpp

 
 // Additional instantiations added later. Whether programs rely on these being
 // available is protected by _LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1.
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringbuf<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ostringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_istringstream<char>;
 
-#ifndef _LIBCPP_HAS_NO_FSTREAM
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ifstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ofstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_filebuf<char>;
 #endif
 
 // Add more here if needed...
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_bidirectional_iterator.compile.pass.cpp

 // concept __iterator_traits_detail::__cpp17_bidirectional_iterator;
 
 #include "test_macros.h"
 
 #include <iterator>
 
 #include <array>
 #include <deque>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #include <filesystem>
 #endif
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <string_view>

 
 // <deque>
 static_assert(std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::deque<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::deque<int>::const_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::deque<int>::reverse_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::deque<int>::const_reverse_iterator>);
 
 // <filesystem>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(!std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::filesystem::directory_iterator>);
 static_assert(!std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::filesystem::recursive_directory_iterator>);
 #endif
 
 // <forward_list>
 static_assert(!std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::forward_list<int>::iterator>);
 static_assert(!std::__iterator_traits_detail::__cpp17_bidirectional_iterator<std::forward_list<int>::const_iterator>);
 

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_forward_iterator.compile.pass.cpp

 // concept __iterator_traits_detail::__cpp17_forward_iterator;
 
 #include "test_macros.h"
 
 #include <iterator>
 
 #include <array>
 #include <deque>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #include <filesystem>
 #endif
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <string_view>

 
 // <deque>
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::deque<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::deque<int>::const_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::deque<int>::reverse_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::deque<int>::const_reverse_iterator>);
 
 // <filesystem>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(!std::__iterator_traits_detail::__cpp17_forward_iterator<std::filesystem::directory_iterator>);
 static_assert(!std::__iterator_traits_detail::__cpp17_forward_iterator<std::filesystem::recursive_directory_iterator>);
 #endif
 
 // <forward_list>
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::forward_list<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_forward_iterator<std::forward_list<int>::const_iterator>);
 

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_input_iterator.compile.pass.cpp

 // concept __iterator_traits_detail::__cpp17_input_iterator;
 
 #include "test_macros.h"
 
 #include <iterator>
 
 #include <array>
 #include <deque>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #include <filesystem>
 #endif
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <string_view>

 
 // <deque>
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::deque<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::deque<int>::const_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::deque<int>::reverse_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::deque<int>::const_reverse_iterator>);
 
 // <filesystem>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::filesystem::directory_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::filesystem::recursive_directory_iterator>);
 #endif
 
 // <forward_list>
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::forward_list<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_input_iterator<std::forward_list<int>::const_iterator>);
 

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_iterator.compile.pass.cpp

 // concept __iterator_traits_detail::__cpp17_iterator;
 
 #include "test_macros.h"
 
 #include <iterator>
 
 #include <array>
 #include <deque>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #include <filesystem>
 #endif
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <string_view>

 
 // <deque>
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::deque<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::deque<int>::const_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::deque<int>::reverse_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::deque<int>::const_reverse_iterator>);
 
 // <filesystem>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::filesystem::directory_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::filesystem::recursive_directory_iterator>);
 #endif
 
 // <forward_list>
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::forward_list<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_iterator<std::forward_list<int>::const_iterator>);
 

libcxx/test/libcxx/iterators/iterator.requirements/iterator.assoc.types/iterator.traits/legacy_random_access_iterator.compile.pass.cpp

 // concept __iterator_traits_detail::__cpp17_random_access_iterator;
 
 #include "test_macros.h"
 
 #include <iterator>
 
 #include <array>
 #include <deque>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #include <filesystem>
 #endif
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <string_view>

 
 // <deque>
 static_assert(std::__iterator_traits_detail::__cpp17_random_access_iterator<std::deque<int>::iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_random_access_iterator<std::deque<int>::const_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_random_access_iterator<std::deque<int>::reverse_iterator>);
 static_assert(std::__iterator_traits_detail::__cpp17_random_access_iterator<std::deque<int>::const_reverse_iterator>);
 
 // <filesystem>
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(!std::__iterator_traits_detail::__cpp17_random_access_iterator<std::filesystem::directory_iterator>);
 static_assert(!std::__iterator_traits_detail::__cpp17_random_access_iterator<std::filesystem::recursive_directory_iterator>);
 #endif
 
 // <forward_list>
 static_assert(!std::__iterator_traits_detail::__cpp17_random_access_iterator<std::forward_list<int>::iterator>);
 static_assert(!std::__iterator_traits_detail::__cpp17_random_access_iterator<std::forward_list<int>::const_iterator>);
 

libcxx/test/std/input.output/file.streams/lit.local.cfg

 # All non-trivial uses of iostreams require localization support
 if "no-localization" in config.available_features:
     config.unsupported = True
 
-if "no-fstream" in config.available_features:
+if "no-filesystem" in config.available_features:
     config.unsupported = True

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.PR14074.pass.cpp

 // class basic_streambuf;
 
 // streamsize xsputn(const char_type* s, streamsize n);
 
 // Test https://llvm.org/PR14074. The bug is really inside
 // basic_streambuf, but I can't seem to reproduce without going through one
 // of its derived classes.
 
-// UNSUPPORTED: no-fstream
+// UNSUPPORTED: no-filesystem
 
 #include <cassert>
 #include <cstddef>
 #include <cstdio>
 #include <fstream>
 #include <sstream>
 #include <string>
 #include "test_macros.h"

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

 #include "test_macros.h"
 
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <regex>
 #  include <ostream>
 #  include <istream>
 #endif
 
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #  include <filesystem>
 #endif
 
 #include "test_iterators.h"
 #include "iterator_traits_cpp17_iterators.h"
 
 template <class Traits>
 constexpr bool has_iterator_concept_v = requires {

 LIBCPP_STATIC_ASSERT(test<std::istreambuf_iterator<char>, std::input_iterator_tag, char, long long, char, char*>());
 static_assert(test<std::move_iterator<int*>, std::random_access_iterator_tag, int, std::ptrdiff_t, int&&, int*>());
 static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testConst<std::cregex_iterator, std::forward_iterator_tag, std::cmatch>());
 static_assert(testConst<std::cregex_token_iterator, std::forward_iterator_tag, std::csub_match>());
 #endif // !TEST_HAS_NO_LOCALIZATION
 
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(test<std::filesystem::directory_iterator, std::input_iterator_tag, std::filesystem::directory_entry,
                    std::ptrdiff_t, const std::filesystem::directory_entry&, const std::filesystem::directory_entry*>());
 static_assert(test<std::filesystem::recursive_directory_iterator, std::input_iterator_tag,
                    std::filesystem::directory_entry, std::ptrdiff_t, const std::filesystem::directory_entry&,
                    const std::filesystem::directory_entry*>());
 #endif
 
 // Local test iterators.

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp

int main(int, char**)
         }
         {
             std::istringstream in(s);
             test_buf f(in.rdbuf());
             assert(f.sgetc() == L'a');
         }
     }
     // TODO: Move this to std::stringstream once https://llvm.org/PR59083 has been resolved
-#ifndef TEST_HAS_NO_FSTREAM
+#ifndef TEST_HAS_NO_FILESYSTEM
     {
         {
             std::ofstream bs("overflow.dat");
             test_buf f(bs.rdbuf());
             assert(f.sputc(0x4E51) == 0x4E51);
             assert(f.sputc(0x4E52) == 0x4E52);
             assert(f.sputc(0x4E53) == 0x4E53);
         }
         {
             std::ifstream f("overflow.dat");
             assert(f.is_open());
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x91);
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x92);
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x93);
             assert(f.get() == -1);
         }
         std::remove("overflow.dat");
     }
-#endif // TEST_HAS_NO_FSTREAM
+#endif // TEST_HAS_NO_FILESYSTEM
 
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp

 // pos_type seekpos(pos_type sp,
 //                  ios_base::openmode which = ios_base::in | ios_base::out);
 
 // This test is not entirely portable
 
 // XFAIL: no-wide-characters
 
 // TODO: Avoid using <fstream> in this test.
-// XFAIL: no-fstream
+// XFAIL: no-filesystem
 
 #include <locale>
 #include <codecvt>
 #include <fstream>
 #include <cassert>
 
 class test_codecvt
     : public std::codecvt<wchar_t, char, std::mbstate_t>

libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp

 #include <unordered_map>
 #include <unordered_set>
 #include <valarray>
 #include <variant>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #  include <filesystem>
 #endif
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <regex>
 #endif
 #ifndef TEST_HAS_NO_THREADS
 #  include <thread>
 #endif

 // Note the paper has been abandoned, the types are kept since other papers may
 // introduce these formatters.
 template <class CharT>
 void test_P1636() {
   assert_is_not_formattable<std::basic_streambuf<CharT>, CharT>();
   assert_is_not_formattable<std::bitset<42>, CharT>();
   assert_is_not_formattable<std::complex<double>, CharT>();
   assert_is_not_formattable<std::error_code, CharT>();
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
   assert_is_not_formattable<std::filesystem::path, CharT>();
 #endif
   assert_is_not_formattable<std::shared_ptr<int>, CharT>();
 #ifndef TEST_HAS_NO_LOCALIZATION
   if constexpr (!std::same_as<CharT, int>) // sub_match only works with proper character types
     assert_is_not_formattable<std::sub_match<CharT*>, CharT>();
 #endif
 #ifndef TEST_HAS_NO_THREADS

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

 #include <span>
 #include <vector>
 #include <unordered_map>
 #include <unordered_set>
 #include <valarray>
 
 #include "test_macros.h"
 
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 #  include <filesystem>
 #endif
 
 // [format.range.fmtkind]
 // If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
 // format_kind<R> is range_format::disabled.
 // [Note 1: This prevents constraint recursion for ranges whose reference type
 // is the same range type. For example, std::filesystem::path is a range of
struct recursive_range {
 
   iterator begin();
   iterator end();
 };
 
 static_assert(std::ranges::input_range<recursive_range>, "format_kind requires an input range");
 static_assert(std::format_kind<recursive_range> == std::range_format::disabled);
 
-#ifndef TEST_HAS_NO_FILESYSTEM_LIBRARY
+#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(std::format_kind<std::filesystem::path> == std::range_format::disabled);
 #endif
 
 static_assert(std::format_kind<std::map<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::multimap<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::unordered_map<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::unordered_multimap<int, int>> == std::range_format::map);
 

libcxx/test/support/test_macros.h

 #if TEST_STD_VER <= 17 || !defined(__cpp_char8_t)
 #  define TEST_HAS_NO_CHAR8_T
 #endif
 
 #if defined(_LIBCPP_HAS_NO_THREADS)
 #  define TEST_HAS_NO_THREADS
 #endif
 
-#if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-#  define TEST_HAS_NO_FILESYSTEM_LIBRARY
-#endif
-
-#if defined(_LIBCPP_HAS_NO_FSTREAM)
-#  define TEST_HAS_NO_FSTREAM
+#if defined(_LIBCPP_HAS_NO_FILESYSTEM)
+#  define TEST_HAS_NO_FILESYSTEM
 #endif
 
 #if defined(_LIBCPP_HAS_NO_FGETPOS_FSETPOS)
 #  define TEST_HAS_NO_FGETPOS_FSETPOS
 #endif
 
 #if defined(_LIBCPP_HAS_NO_C8RTOMB_MBRTOC8)
 #  define TEST_HAS_NO_C8RTOMB_MBRTOC8

libcxx/utils/ci/buildkite-pipeline.yml

- label: "No random device"
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
-    - label: "No fstream"
-      command: "libcxx/utils/ci/run-buildbot generic-no-fstream"
-      artifact_paths:
-        - "**/test-results.xml"
-        - "**/*.abilist"
-      env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
-          ENABLE_CLANG_TIDY: "On"
-      agents:
-        queue: "libcxx-builders"
-        os: "linux"
-      retry:
-        automatic:
-          - exit_status: -1  # Agent was lost
-            limit: 2
-      timeout_in_minutes: 120
-
     - label: "No locale"
       command: "libcxx/utils/ci/run-buildbot generic-no-localization"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"

libcxx/utils/ci/run-buildbot

generic-no-filesystem)
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-filesystem.cmake"
     check-runtimes
 ;;
 generic-no-random_device)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-random_device.cmake"
     check-runtimes
 ;;
-generic-no-fstream)
-    clean
-    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-fstream.cmake"
-    check-runtimes
-;;
 generic-no-localization)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-localization.cmake"
     check-runtimes
 ;;
 generic-no-unicode)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-unicode.cmake"

libcxx/utils/libcxx/test/features.py

 # while features that are more general in nature are not prefixed with 'libcpp-'.
 macros = {
     "_LIBCPP_HAS_NO_MONOTONIC_CLOCK": "no-monotonic-clock",
     "_LIBCPP_HAS_NO_THREADS": "no-threads",
     "_LIBCPP_HAS_THREAD_API_EXTERNAL": "libcpp-has-thread-api-external",
     "_LIBCPP_HAS_THREAD_API_PTHREAD": "libcpp-has-thread-api-pthread",
     "_LIBCPP_NO_VCRUNTIME": "libcpp-no-vcruntime",
     "_LIBCPP_ABI_VERSION": "libcpp-abi-version",
-    "_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY": "no-filesystem",
+    "_LIBCPP_HAS_NO_FILESYSTEM": "no-filesystem",
     "_LIBCPP_HAS_NO_RANDOM_DEVICE": "no-random-device",
     "_LIBCPP_HAS_NO_LOCALIZATION": "no-localization",
-    "_LIBCPP_HAS_NO_FSTREAM": "no-fstream",
     "_LIBCPP_HAS_NO_WIDE_CHARACTERS": "no-wide-characters",
     "_LIBCPP_HAS_NO_UNICODE": "libcpp-has-no-unicode",
     "_LIBCPP_ENABLE_DEBUG_MODE": "libcpp-has-debug-mode",
 }
 for macro, feature in macros.items():
     DEFAULT_FEATURES.append(
         Feature(
             name=lambda cfg, m=macro, f=feature: f

libcxx/utils/libcxx/test/header_information.py

lit_header_restrictions = {
     "experimental/span": "// UNSUPPORTED: c++03",
     "experimental/string": "// UNSUPPORTED: c++03",
     "experimental/type_traits": "// UNSUPPORTED: c++03",
     "experimental/unordered_map": "// UNSUPPORTED: c++03",
     "experimental/unordered_set": "// UNSUPPORTED: c++03",
     "experimental/utility": "// UNSUPPORTED: c++03",
     "experimental/vector": "// UNSUPPORTED: c++03",
     "filesystem": "// UNSUPPORTED: no-filesystem, c++03, c++11, c++14",
-    "fstream": "// UNSUPPORTED: no-localization, no-fstream",
+    "fstream": "// UNSUPPORTED: no-localization, no-filesystem",
     "future": "// UNSUPPORTED: no-threads, c++03",
     "iomanip": "// UNSUPPORTED: no-localization",
     "ios": "// UNSUPPORTED: no-localization",
     "iostream": "// UNSUPPORTED: no-localization",
     "istream": "// UNSUPPORTED: no-localization",
     "latch": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
     "locale.h": "// UNSUPPORTED: no-localization",
     "locale": "// UNSUPPORTED: no-localization",