[libc++] Remove more _LIBCPP_CXX03_LANG (iostreams edition)

[• Quuxplusone]

Summary

This follows on from D104172 (which is the same idea, STL container edition). The idea is to remove #ifs that have become unnecessary due to Clang's C++03 mode gaining more C++11 features as extensions. We need to keep libc++ building with clang++ -std=c++03 and with g++ -std=c++11, but we don't claim to build in pedantic C++03 mode — anything Clang supports with a warning, we can use!

[libc++] Remove some _LIBCPP_CXX03_LANG from iostreams headers.

With the STL containers, I didn't enable move operations in C++03 mode
because that would change the overload resolution for things that today
are copy operations. With iostreams, though, the copy operations aren't
present at all, and so I see no problem with enabling move operations
even in (Clang's greatly extended) C++03 mode.

Clang's C++03 mode does not support delegating constructors.

[• Quuxplusone]

Rebase. Hoping to land on Monday alongside D104172, if someone can give me a thumbs-up here.

[• Quuxplusone]

Update affected unit tests, and rebase.
This is now just one commit, not three, because the other two commits (with their affected unit tests) have been split out into D104682 and D104725.

[• Quuxplusone]

Rebase on master.
Enable the rvalue overloads of std::getline in C++03 mode, and update its tests.
Serendipitously, I was reminded of the rvalue overload of std::getline by https://github.com/microsoft/STL/pull/2025/files . I have no idea why this overload exists; if anyone thinks they know, I'd like to hear about it.

@ldionne ping! (I think D104310 is now more baked and less controversial than the STL-containers one in D104172.)

libcxx/include/fstream

public:
     typedef _Traits                          traits_type;
     typedef typename traits_type::int_type   int_type;
     typedef typename traits_type::pos_type   pos_type;
     typedef typename traits_type::off_type   off_type;
     typedef typename traits_type::state_type state_type;
 
     // 27.9.1.2 Constructors/destructor:
     basic_filebuf();
-#ifndef _LIBCPP_CXX03_LANG
     basic_filebuf(basic_filebuf&& __rhs);
-#endif
     virtual ~basic_filebuf();
 
     // 27.9.1.3 Assign/swap:
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_filebuf& operator=(basic_filebuf&& __rhs);
-#endif
     void swap(basic_filebuf& __rhs);
 
     // 27.9.1.4 Members:
     _LIBCPP_INLINE_VISIBILITY
     bool is_open() const;
 #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<_CharT, _Traits>::basic_filebuf()
     if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
     {
         __cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
         __always_noconv_ = __cv_->always_noconv();
     }
     setbuf(nullptr, 4096);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
     : basic_streambuf<_CharT, _Traits>(__rhs)
 {
     if (__rhs.__extbuf_ == __rhs.__extbuf_min_)
     {
         __extbuf_ = __extbuf_min_;
         __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);

 basic_filebuf<_CharT, _Traits>&
 basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
 {
     close();
     swap(__rhs);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_filebuf<_CharT, _Traits>::~basic_filebuf()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCPP_NO_EXCEPTIONS
         close();
#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)
     _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);
-
     _LIBCPP_INLINE_VISIBILITY
     basic_ifstream& operator=(basic_ifstream&& __rhs);
-#endif
     _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;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE

 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);
 }
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
     : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
 inline
 basic_ifstream<_CharT, _Traits>&
 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
 {
     basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 void
 basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
 {
     basic_istream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }
#endif
     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
 
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream(basic_ofstream&& __rhs);
-
     _LIBCPP_INLINE_VISIBILITY
     basic_ofstream& operator=(basic_ofstream&& __rhs);
-#endif
     _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;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE

 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);
 }
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
     : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
 inline
 basic_ofstream<_CharT, _Traits>&
 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
 {
     basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 void
 basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
 {
     basic_ostream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }

 
 #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
 
 #endif
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream(basic_fstream&& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_fstream& operator=(basic_fstream&& __rhs);
-#endif
+
     _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;
 #ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE

 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);
 }
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
     : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
       __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
 inline
 basic_fstream<_CharT, _Traits>&
 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
 {
     basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
     __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 inline
 void
 basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
 {
     basic_iostream<char_type, traits_type>::swap(__rhs);
     __sb_.swap(__rhs.__sb_);
 }

libcxx/include/ios

protected:
     _LIBCPP_INLINE_VISIBILITY
     basic_ios() {// purposefully does no initialization
                 }
     _LIBCPP_INLINE_VISIBILITY
     void init(basic_streambuf<char_type, traits_type>* __sb);
 
     _LIBCPP_INLINE_VISIBILITY
     void move(basic_ios& __rhs);
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void move(basic_ios&& __rhs) {move(__rhs);}
-#endif
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ios& __rhs) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
     basic_ostream<char_type, traits_type>* __tie_;
     mutable int_type __fill_;
 };

libcxx/include/istream

public:
     typedef typename traits_type::off_type off_type;
 
     // 27.7.1.1.1 Constructor/destructor:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
     { this->init(__sb); }
     virtual ~basic_istream();
 protected:
-#ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_istream(basic_istream&& __rhs);
 
     // 27.7.1.1.2 Assign/swap:
     inline _LIBCPP_INLINE_VISIBILITY
     basic_istream& operator=(basic_istream&& __rhs);
-#endif
 
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     void swap(basic_istream& __rhs) {
       _VSTD::swap(__gc_, __rhs.__gc_);
       basic_ios<char_type, traits_type>::swap(__rhs);
     }
 
-#ifndef _LIBCPP_CXX03_LANG
     basic_istream           (const basic_istream& __rhs) = delete;
     basic_istream& operator=(const basic_istream& __rhs) = delete;
-#endif
 public:
 
     // 27.7.1.1.3 Prefix/suffix:
     class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.1.2 Formatted input:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
if (__is.good())
                 __is.setstate(ios_base::failbit | ios_base::eofbit);
         }
         __ok_ = __is.good();
     }
     else
         __is.setstate(ios_base::failbit);
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
     : __gc_(__rhs.__gc_)
 {
     __rhs.__gc_ = 0;
     this->move(__rhs);
 }
 
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>&
 basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::~basic_istream()
 {
 }
 
 template <class _Tp, class _CharT, class _Traits>
 _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
public:
     // constructor/destructor
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
       : basic_istream<_CharT, _Traits>(__sb)
     {}
 
     virtual ~basic_iostream();
 protected:
-#ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream(basic_iostream&& __rhs);
 
     // assign/swap
     inline _LIBCPP_INLINE_VISIBILITY
     basic_iostream& operator=(basic_iostream&& __rhs);
-#endif
+
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     void swap(basic_iostream& __rhs)
     { basic_istream<char_type, traits_type>::swap(__rhs); }
 };
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
     : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
 {
 }
 
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>&
 basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>::~basic_iostream()
 {
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,

 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
 {
     return getline(__is, __str, __dlm);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str)
 {
     return getline(__is, __str, __is.widen('\n'));
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits, size_t _Size>
 basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
 {
     ios_base::iostate __state = ios_base::goodbit;
     typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
     if (__sen)
     {

libcxx/include/ostream

public:
     typedef typename traits_type::off_type off_type;
 
     // 27.7.2.2 Constructor/destructor:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
     { this->init(__sb); }
     virtual ~basic_ostream();
 protected:
-#ifndef _LIBCPP_CXX03_LANG
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream(basic_ostream&& __rhs);
 
     // 27.7.2.3 Assign/swap
     inline _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
-#endif
+
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     void swap(basic_ostream& __rhs)
     { basic_ios<char_type, traits_type>::swap(__rhs); }
 
-#ifndef _LIBCPP_CXX03_LANG
     basic_ostream           (const basic_ostream& __rhs) = delete;
     basic_ostream& operator=(const basic_ostream& __rhs) = delete;
-#else
-    basic_ostream           (const basic_ostream& __rhs); // not defined
-    basic_ostream& operator=(const basic_ostream& __rhs); // not defined
-#endif
-public:
 
+public:
     // 27.7.2.4 Prefix/suffix:
     class _LIBCPP_TEMPLATE_VIS sentry;
 
     // 27.7.2.6 Formatted output:
     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
     basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
     { return __pf(*this); }
 
#ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
         {
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
     }
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
 {
     this->move(__rhs);
 }
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
 {
     swap(__rhs);
     return *this;
 }
 
-#endif // _LIBCPP_CXX03_LANG
-
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>::~basic_ostream()
 {
 }
 
 template <class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)

libcxx/include/sstream

 private:
 
     string_type __str_;
     mutable char_type* __hm_;
     ios_base::openmode __mode_;
 
 public:
     // 30.8.2.1 [stringbuf.cons], constructors
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}
+    basic_stringbuf()
+        : __hm_(nullptr), __mode_(ios_base::in | ios_base::out) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(ios_base::openmode __wch)
         : __hm_(nullptr), __mode_(__wch) {}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringbuf(ios_base::openmode __wch = ios_base::in |
-                                                        ios_base::out)
-        : __hm_(nullptr), __mode_(__wch) {}
-#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringbuf(const string_type& __s,
                              ios_base::openmode __wch = ios_base::in | ios_base::out)
         : __str_(__s.get_allocator()), __hm_(nullptr), __mode_(__wch)
     {
         str(__s);
     }
public:
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 30.8.3.1 [istringstream.cons], constructors
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    basic_istringstream() : basic_istringstream(ios_base::in) {}
+    basic_istringstream()
+        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(ios_base::openmode __wch)
         : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_istringstream(ios_base::openmode __wch = ios_base::in)
-        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
-#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_istringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::in)
         : basic_istream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::in)
     { }
 
public:
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 30.8.4.1 [ostringstream.cons], constructors
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    basic_ostringstream() : basic_ostringstream(ios_base::out) {}
+    basic_ostringstream()
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::out) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(ios_base::openmode __wch)
-        : basic_ostream<_CharT, _Traits>(&__sb_),
-          __sb_(__wch | ios_base::out) {}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ostringstream(ios_base::openmode __wch = ios_base::out)
-        : basic_ostream<_CharT, _Traits>(&__sb_),
-          __sb_(__wch | ios_base::out) {}
-#endif
+        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::out) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ostringstream(const string_type& __s,
                                  ios_base::openmode __wch = ios_base::out)
         : basic_ostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch | ios_base::out)
     { }
 
public:
 
     typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
     basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
     // 30.8.5.1 [stringstream.cons], constructors
-#ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
-    basic_stringstream() : basic_stringstream(ios_base::in | ios_base::out) {}
+    basic_stringstream()
+        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in | ios_base::out) {}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringstream(ios_base::openmode __wch)
         : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringstream(ios_base::openmode __wch = ios_base::in |
-                                                           ios_base::out)
-        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
-#endif
 
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_stringstream(const string_type& __s,
                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
         : basic_iostream<_CharT, _Traits>(&__sb_)
         , __sb_(__s, __wch)
     { }
 

libcxx/include/string

         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str);
 
-#ifndef _LIBCPP_CXX03_LANG
-
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
 
 template<class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istream<_CharT, _Traits>&
 getline(basic_istream<_CharT, _Traits>&& __is,
         basic_string<_CharT, _Traits, _Allocator>& __str);
 
-#endif // _LIBCPP_CXX03_LANG
-
 #if _LIBCPP_STD_VER > 17
 template <class _CharT, class _Traits, class _Allocator, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
     typename basic_string<_CharT, _Traits, _Allocator>::size_type
     erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
   auto __old_size = __str.size();
   __str.erase(_VSTD::remove(__str.begin(), __str.end(), __v), __str.end());
   return __old_size - __str.size();

libcxx/test/std/input.output/file.streams/fstreams/filebuf.assign/move_assign.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_filebuf
 
 // basic_filebuf& operator=(basic_filebuf&& rhs);
 
 #include <fstream>

libcxx/test/std/input.output/file.streams/fstreams/filebuf.cons/move.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_filebuf
 
 // basic_filebuf(basic_filebuf&& rhs);
 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
         std::filebuf f;
         assert(f.open(temp.c_str(), std::ios_base::out | std::ios_base::in
                                                | std::ios_base::trunc) != 0);
         assert(f.is_open());
         assert(f.sputn("123", 3) == 3);
         f.pubseekoff(1, std::ios_base::beg);
         assert(f.sgetc() == '2');
-        std::filebuf f2(move(f));
+        std::filebuf f2(std::move(f));
         assert(!f.is_open());
         assert(f2.is_open());
         assert(f2.sgetc() == '2');
     }
     std::remove(temp.c_str());
     {
         std::wfilebuf f;
         assert(f.open(temp.c_str(), std::ios_base::out | std::ios_base::in
                                                | std::ios_base::trunc) != 0);
         assert(f.is_open());
         assert(f.sputn(L"123", 3) == 3);
         f.pubseekoff(1, std::ios_base::beg);
         assert(f.sgetc() == L'2');
-        std::wfilebuf f2(move(f));
+        std::wfilebuf f2(std::move(f));
         assert(!f.is_open());
         assert(f2.is_open());
         assert(f2.sgetc() == L'2');
     }
     std::remove(temp.c_str());
 
   return 0;
 }

libcxx/test/std/input.output/file.streams/fstreams/fstream.assign/move_assign.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // basic_fstream& operator=(basic_fstream&& rhs);
 
 #include <fstream>

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/move.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // basic_fstream(basic_fstream&& rhs);
 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
         std::fstream fso(temp, std::ios_base::in | std::ios_base::out
                                                  | std::ios_base::trunc);
-        std::fstream fs = move(fso);
+        std::fstream fs = std::move(fso);
         double x = 0;
         fs << 3.25;
         fs.seekg(0);
         fs >> x;
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
     {
         std::wfstream fso(temp, std::ios_base::in | std::ios_base::out
                                                   | std::ios_base::trunc);
-        std::wfstream fs = move(fso);
+        std::wfstream fs = std::move(fso);
         double x = 0;
         fs << 3.25;
         fs.seekg(0);
         fs >> x;
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
 
   return 0;
 }

libcxx/test/std/input.output/file.streams/fstreams/ifstream.assign/move_assign.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++03
 // FILE_DEPENDENCIES: test.dat
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ifstream
 
 // basic_ifstream& operator=(basic_ifstream&& rhs);

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/move.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++03
 // FILE_DEPENDENCIES: test.dat
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ifstream
 
 // basic_ifstream(basic_ifstream&& rhs);
 
 #include <fstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::ifstream fso("test.dat");
-        std::ifstream fs = move(fso);
+        std::ifstream fs = std::move(fso);
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     {
         std::wifstream fso("test.dat");
-        std::wifstream fs = move(fso);
+        std::wifstream fs = std::move(fso);
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
 
   return 0;
 }

libcxx/test/std/input.output/file.streams/fstreams/ofstream.assign/move_assign.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 
 // basic_ofstream& operator=(basic_ofstream&& rhs);
 
 #include <fstream>

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/move.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++03
-
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 
 // basic_ofstream(basic_ofstream&& rhs);
 
 #include <fstream>
 #include <cassert>
 #include "test_macros.h"
 #include "platform_support.h"
 
 int main(int, char**)
 {
     std::string temp = get_temp_file_name();
     {
         std::ofstream fso(temp.c_str());
-        std::ofstream fs = move(fso);
+        std::ofstream fs = std::move(fso);
         fs << 3.25;
     }
     {
         std::ifstream fs(temp.c_str());
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
     {
         std::wofstream fso(temp.c_str());
-        std::wofstream fs = move(fso);
+        std::wofstream fs = std::move(fso);
         fs << 3.25;
     }
     {
         std::wifstream fs(temp.c_str());
         double x = 0;
         fs >> x;
         assert(x == 3.25);
     }
     std::remove(temp.c_str());
 
   return 0;
 }

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.assign/move_assign.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++03
-
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_iostream;
 
 // basic_iostream& operator=(basic_iostream&& rhs);
 
 #include <istream>

libcxx/test/std/input.output/iostream.format/input.streams/iostreamclass/iostream.cons/move.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++03
-
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_iostream;
 
 // basic_iostream(basic_iostream&& rhs);
 
 #include <istream>

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.assign/move_assign.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++03
-
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_istream;
 
 // basic_istream& operator=(basic_istream&& rhs);
 
 #include <istream>

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/copy.fail.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++03
-
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_istream;
 
 // basic_istream(basic_istream const& rhs) = delete;
 // basic_istream& operator=(basic_istream const&) = delete;
 
struct test_istream
 
     test_istream& operator=(test_istream const& s) {
       base::operator=(s); // expected-error {{call to deleted member function 'operator='}}
       return *this;
     }
 
 };
 
-
 int main(int, char**)
 {
-
-
   return 0;
 }

libcxx/test/std/input.output/iostream.format/input.streams/istream/istream.cons/move.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++03
-
 // <istream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_istream;
 
 // basic_istream(basic_istream&& rhs);
 
 #include <istream>

libcxx/test/std/input.output/iostream.format/output.streams/ostream.assign/move_assign.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++03
-
 // <ostream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ostream;
 
 // basic_ostream& operator=(basic_ostream&& rhs);
 
 #include <ostream>

libcxx/test/std/input.output/iostream.format/output.streams/ostream.cons/move.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++03
-
 // <ostream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_ostream;
 
 // basic_ostream(basic_ostream&& rhs);
 
 #include <ostream>

libcxx/test/std/input.output/iostreams.base/is_error_code_enum_io_errc.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++03
 
 // <ios>
 
 // template <> struct is_error_code_enum<io_errc> : public true_type {};
 
 #include <ios>
 #include "test_macros.h"
 

libcxx/test/std/input.output/string.streams/istringstream/istringstream.assign/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_istringstream
 
 // basic_istringstream& operator=(basic_istringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/input.output/string.streams/istringstream/istringstream.cons/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_istringstream
 
 // basic_istringstream(basic_istringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.assign/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_ostringstream
 
 // basic_ostringstream& operator=(basic_ostringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/input.output/string.streams/ostringstream/ostringstream.cons/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_ostringstream
 
 // basic_ostringstream(basic_ostringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/input.output/string.streams/stringbuf/stringbuf.cons/move.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
         std::stringbuf buf1("testing");
-        std::stringbuf buf(move(buf1));
+        std::stringbuf buf(std::move(buf1));
         assert(buf.str() == "testing");
     }
     {
         std::stringbuf buf1("testing", std::ios_base::in);
-        std::stringbuf buf(move(buf1));
+        std::stringbuf buf(std::move(buf1));
         assert(buf.str() == "testing");
     }
     {
         std::stringbuf buf1("testing", std::ios_base::out);
-        std::stringbuf buf(move(buf1));
+        std::stringbuf buf(std::move(buf1));
         assert(buf.str() == "testing");
     }
     {
         std::wstringbuf buf1(L"testing");
-        std::wstringbuf buf(move(buf1));
+        std::wstringbuf buf(std::move(buf1));
         assert(buf.str() == L"testing");
     }
     {
         std::wstringbuf buf1(L"testing", std::ios_base::in);
-        std::wstringbuf buf(move(buf1));
+        std::wstringbuf buf(std::move(buf1));
         assert(buf.str() == L"testing");
     }
     {
         std::wstringbuf buf1(L"testing", std::ios_base::out);
-        std::wstringbuf buf(move(buf1));
+        std::wstringbuf buf(std::move(buf1));
         assert(buf.str() == L"testing");
     }
 
   return 0;
 }

libcxx/test/std/input.output/string.streams/stringstream.cons/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_stringstream(basic_stringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/input.output/string.streams/stringstream.cons/stringstream.assign/move.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++03
-
 // <sstream>
 
 // template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
 // class basic_stringstream
 
 // basic_stringstream& operator=(basic_stringstream&& rhs);
 
 #include <sstream>

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_delim_rv.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++03
-
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   basic_istream<charT,traits>&
 //   getline(basic_istream<charT,traits>&& is,
 //           basic_string<charT,traits,Allocator>& str, charT delim);
 
 #include <string>
int main(int, char**)
         assert(s == " abc");
     }
     {
         std::wstring s(L"initial text");
         getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
         assert(s == L" abc");
     }
     {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
         S s("initial text");
         getline(std::istringstream(" abc*  def*   ghij"), s, '*');
         assert(s == " abc");
     }
     {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
+        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
         S s(L"initial text");
         getline(std::wistringstream(L" abc*  def*   ghij"), s, L'*');
         assert(s == L" abc");
     }
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/get_line_rv.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++03
-
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   basic_istream<charT,traits>&
 //   getline(basic_istream<charT,traits>&& is,
 //           basic_string<charT,traits,Allocator>& str);
 
 #include <string>
int main(int, char**)
         assert(s == " abc");
     }
     {
         std::wstring s(L"initial text");
         getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
         assert(s == L" abc");
     }
     {
-        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+        typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
         S s("initial text");
         getline(std::istringstream(" abc\n  def\n   ghij"), s);
         assert(s == " abc");
     }
     {
-        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t>> S;
+        typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, min_allocator<wchar_t> > S;
         S s(L"initial text");
         getline(std::wistringstream(L" abc\n  def\n   ghij"), s);
         assert(s == L" abc");
     }
 
   return 0;
 }