[libc++] Unconditionally provide the open-with-wchar_t extension

[ldionne]

Summary

The extension is enabled and apparently quite useful on Windows. While
I think extensions are generally evil, conditional extensions are even
worse, so I'd rather enable this extension on all platforms.

[ldionne]

Unconditionally enable the extension as discussed in https://reviews.llvm.org/D42225

[ldionne]

Turns out this was a bit naive, _wfopen isn't provided outside of Windows so we can't implement this.

libcxx/include/__config

 // If mingw not explicitly detected, assume using MS C runtime only if
 // a MS compatibility version is specified.
 #  if defined(_MSC_VER) && !defined(__MINGW32__)
 #    define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
 #  endif
 #  if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
 #    define _LIBCPP_HAS_BITSCAN64
 #  endif
-#  define _LIBCPP_HAS_OPEN_WITH_WCHAR
 #  if defined(_LIBCPP_MSVCRT)
 #    define _LIBCPP_HAS_QUICK_EXIT
 #  endif
 
 // Some CRT APIs are unavailable to store apps
 #  if defined(WINAPI_FAMILY)
 #    include <winapifamily.h>
 #    if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) &&                  \

libcxx/include/fstream

public:
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf& operator=(basic_filebuf&& __rhs);
     void swap(basic_filebuf& __rhs);
 
     // 27.9.1.4 Members:
     _LIBCPP_INLINE_VISIBILITY
     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
+    basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode); // EXTENSION
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 
 #if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
     _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
     basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
       return open(__p.c_str(), __mode);
     }
if (const char* __mdstr = __make_mdstring(__mode)) {
         }
       } else
         __rt = nullptr;
     }
   }
   return __rt;
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 // This is basically the same as the char* overload except that it uses _wfopen
 // and long mode strings.
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
 {
     basic_filebuf<_CharT, _Traits>* __rt = nullptr;
     if (__file_ == nullptr)
     {
         __rt = this;
         const wchar_t* __mdstr;
         switch (__mode & ~ios_base::ate)
         {
if (__file_ == nullptr)
                 }
             }
             else
                 __rt = nullptr;
         }
     }
     return __rt;
 }
-#endif
 
 template <class _CharT, class _Traits>
 inline
 basic_filebuf<_CharT, _Traits>*
 basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     return open(__s.c_str(), __mode);
 }
public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream();
     _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
+    explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in); // EXTENSION
     _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)
     _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 wchar_t* __s, ios_base::openmode __mode = ios_base::in); // EXTENSION
     void open(const string& __s, ios_base::openmode __mode = ios_base::in);
 #if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
     _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

 inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
+basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
     : basic_istream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
     : basic_istream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
         this->setstate(ios_base::failbit);

 basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::in))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 void
-basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
 {
     if (__sb_.open(__s, __mode | ios_base::in))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 void
 basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::in))
         this->clear();
     else
public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream();
     _LIBCPP_INLINE_VISIBILITY
     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
+    explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out); // EXTENSION
     _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)
     _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 wchar_t* __s, ios_base::openmode __mode = ios_base::out); // EXTENSION
     void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 
 #if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
     _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
 

 inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
+basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
     : basic_ostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
         this->setstate(ios_base::failbit);

 basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::out))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 void
-basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
 {
     if (__sb_.open(__s, __mode | ios_base::out))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 void
 basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode | ios_base::out))
         this->clear();
     else
public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream();
     _LIBCPP_INLINE_VISIBILITY
     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
+    explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); // EXTENSION
     _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)
     _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;
     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 wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out); // EXTENSION
     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)
     _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
 

 inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode) == nullptr)
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 inline
-basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
+basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode) == nullptr)
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 inline
 basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
     : basic_iostream<char_type, traits_type>(&__sb_)
 {
     if (__sb_.open(__s, __mode) == nullptr)
         this->setstate(ios_base::failbit);

 basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
 void
-basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
+basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) // EXTENSION
 {
     if (__sb_.open(__s, __mode))
         this->clear();
     else
         this->setstate(ios_base::failbit);
 }
-#endif
 
 template <class _CharT, class _Traits>
 void
 basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
 {
     if (__sb_.open(__s, __mode))
         this->clear();
     else

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

 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
     {
         std::fstream fs(temp.c_str(), std::ios_base::in | std::ios_base::out
                                                 | std::ios_base::trunc);
         double x = 0;
         fs << 3.25;
         fs.seekg(0);
         fs >> x;
         assert(x == 3.25);
     }
     _wremove(temp.c_str());
     {
         std::wfstream fs(temp.c_str(), std::ios_base::in | std::ios_base::out
                                                  | std::ios_base::trunc);
         double x = 0;
         fs << 3.25;
         fs.seekg(0);
         fs >> x;
         assert(x == 3.25);
     }
     _wremove(temp.c_str());
-#endif
 
     return 0;
 }

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

 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
     {
         std::fstream fs;
         assert(!fs.is_open());
         fs.open(temp.c_str(), std::ios_base::in | std::ios_base::out
                                         | std::ios_base::trunc);
         assert(fs.is_open());
         double x = 0;
_wremove(temp.c_str());
         assert(fs.is_open());
         double x = 0;
         fs << 3.25;
         fs.seekg(0);
         fs >> x;
         assert(x == 3.25);
     }
     _wremove(temp.c_str());
-#endif
 
     return 0;
 }

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

 
 #include <fstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
         std::ifstream fs(L"test.dat");
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     // std::ifstream(const wchar_t*, std::ios_base::openmode) is tested in
     // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
     // which creates writable files.
     {
         std::wifstream fs(L"test.dat");
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     // std::wifstream(const wchar_t*, std::ios_base::openmode) is tested in
     // test/libcxx/input.output/file.streams/fstreams/ofstream.cons/wchar_pointer.pass.cpp
     // which creates writable files.
-#endif
 
     return 0;
 }

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

 
 #include <fstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     {
         std::ifstream fs;
         assert(!fs.is_open());
         char c = 'a';
         fs >> c;
         assert(fs.fail());
         assert(c == 'a');
         fs.open(L"test.dat");
         assert(fs.is_open());
         fs >> c;
         assert(c == 'r');
     }
     {
         std::wifstream fs;
         assert(!fs.is_open());
         wchar_t c = L'a';
         fs >> c;
         assert(fs.fail());
         assert(c == L'a');
         fs.open(L"test.dat");
         assert(fs.is_open());
         fs >> c;
         assert(c == L'r');
     }
-#endif
 
     return 0;
 }

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

 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
     {
         std::ofstream fs(temp.c_str());
         fs << 3.25;
     }
     {
         std::ifstream fs(temp.c_str());
         double x = 0;
int main(int, char**)
     }
     {
         std::wifstream fs(temp.c_str(), std::ios_base::out);
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     _wremove(temp.c_str());
-#endif
 
     return 0;
 }

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

 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
     std::wstring temp = get_wide_temp_file_name();
     {
         std::ofstream fs;
         assert(!fs.is_open());
         char c = 'a';
         fs << c;
         assert(fs.fail());
         fs.open(temp.c_str());
int main(int, char**)
     }
     {
         std::wifstream fs(temp.c_str());
         wchar_t c = 0;
         fs >> c;
         assert(c == L'a');
     }
     _wremove(temp.c_str());
-#endif
 
     return 0;
 }

libcxx/test/support/platform_support.h

do {
             abort();
         }
     } while (FD == -1);
     close(FD);
     return Name;
 #endif
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 inline
 std::wstring get_wide_temp_file_name()
 {
     return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> >().from_bytes(
         get_temp_file_name());
 }
-#endif // _LIBCPP_HAS_OPEN_WITH_WCHAR
 
 #if defined(_CS_GNU_LIBC_VERSION)
 inline bool glibc_version_less_than(char const* version) {
   std::string test_version = std::string("glibc ") + version;
 
   size_t n = confstr(_CS_GNU_LIBC_VERSION, nullptr, (size_t)0);
   char *current_version = new char[n];
   confstr(_CS_GNU_LIBC_VERSION, current_version, n);
 
   bool result = strverscmp(current_version, test_version.c_str()) < 0;
   delete[] current_version;
   return result;
 }
 #endif // _CS_GNU_LIBC_VERSION
 
 #endif // PLATFORM_SUPPORT_H